橘子学docker01之基本玩法

docker

docker镜像集成了最核心需要得环境,所以占空间小,运行快,启动秒级。

docker的几个概念:

注册中心:相当于超级码头,上面放的就是集装箱。

镜像(image):集装箱,好比一个模板,可以通过这个模板来创建容器服务,tomcat镜像–》run–》tomcat01容器(提供·服务器),通过这个镜像可以创建多个容器,最终服务运行或者项目运行就是在容器中的。

**容器(container):**运行起来的镜像,利用容器技术,独立运行一个或者一组应用,通过镜像来创建,启动,停止,删除等基本命令。

可以理解donker容器就是一个单独的Linux系统。

**仓库(repository)*仓库就是存放镜像的地方,仓库分为共有和私有,Docker Hub(默认是国外的),阿里云都有容器服务器,自己的。我们配置镜像加速就能用了,国外的太卡。

docker官网:https://www.docker.com/

docker的官方文档:https://docs.docker.com/,文档超级详细。

docker的仓库地址:https://hub.docker.com/


## docker和传统虚拟机技术的区别:
1、传统虚拟机是虚拟出一套硬件,运行一个完整的操作系统,然后在这个系统上安装和运行软件。
2、容器内的应用直接运行在宿主机的内核,容器自己没有内核,也不需要虚拟硬件,容器只包含自己那个运行的应用还有一些必须要有的函数库,至于内核就用宿主机的,提高了利用率,减少其他开销,变得更轻量级。
3、每个容器之间是互相隔离,每个容器都有属于自己的文件系统,互不影响。

橘子学docker01之基本玩法_第1张图片

Docker 的基本操作

安装Docker

环境准备:

1、linux基础   

2、Centos 7 

3、xshell连接

环境查看

# 系统内核时3.10以上的
[root@iZ2zec103hcivif4pv3ai2Z docker]# uname -r
3.10.0-1062.9.1.el7.x86_64

#系统版本是centos7
[root@iZ2zec103hcivif4pv3ai2Z docker]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装docker

安装一切以官网文档为标准:https://docs.docker.com/engine/install/centos/

#1、卸载旧的版本:
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                  
#2、安装Docker的依赖环境:
yum install -y yum-utils

#3、设置阿里的镜像仓库:
yum-config-manager  --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#更新yum软件包的索引
yum makecache fast

#4、安装docker:ce 表示社区版,ee表示企业版
yum install docker-ce docker-ce-cli containerd.io

#5、启动Docker服务:
systemctl start docker 

#6、使用docker version 测试是否安装

#7、设置为开机自动启动:
systemctl enable docker

#8、测试:
docker run hello-world
此时会拉取镜像,然后出现hello-world from docker就成功了。

#9、查看镜像是否下载下来
docker images

#10、卸载docker
卸载Docker Engine,CLI和Containerd软件包等docker依赖:
yum remove docker-ce docker-ce-cli containerd.io

删除环境,资源,包括主机上的映像,容器,卷或自定义配置文件不会自动删除。要删除所有图像,容器和卷:
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
您必须手动删除所有之前已编辑的配置的相关文件。

橘子学docker01之基本玩法_第2张图片

还得配置阿里云加速器,我没有就不配了。可以去百度教程。

docker的底层原理

工作原理:守护进程…

为什么docker比vm快…

Docker的中央仓库

1、Docker官方的中央仓库:这个仓库是镜像最全的,但是下载速度慢

​ https://hub.docker.com/

2、国内的镜像网站:网易蜂巢,daoCloud…

​ https://c.163yun.com/hub#/home(需要登录)

​ http://hub.daocloud.io/(推荐使用)

3、在公司内部会采用私服的方式拉取镜像。需要添加以下配置。

** 需要在 /etc/docker/daemon.json(没有自己建) **

{

​ “registry-mirrors” : [“https://registry.docker.cn.com”],

​ “insecure-registries” : [“公司私服的ip:公司私服的端口号”]

}

重启两个服务

systemctl daemon-reload

systemctl restart docker

Docker的常用命令

帮助命令

docker version  	#显示docker的版本信息

docker info     	#显示docker的系统信息,包括镜像和容器的数量

docker [命令] --help  #帮助命令

帮助文档的地址:https://docs.docker.com/reference/

橘子学docker01之基本玩法_第3张图片

镜像命令

docker images:查看所有本地的主机上的镜像

# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   14 months ago   13.3kB

# 解释一下
# REPOSITORY:镜像的仓库源,就是镜像的名字
# TAG:镜像的标签,版本号
# IMAGE ID:镜像的ID
# CREATED:镜像创建的时间
# SIZE:镜像的大小

# 可选项,参数
 -a, --all             # 列出所有的镜像
 -q, --quiet           # 只显示镜像的id
 -aq                   # 组合使用,查询所有的id,docker支持这种组合的参数,和linux一样

**docker search **:搜索指定的镜像

[root@iZ2zec103hcivif4pv3ai2Z docker]# docker search mysql   #列出所有的关于mysql的信息
NAME     DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql    MySQL is a widely used, open-source relation…   10585     [OK]       
mariadb  MariaDB Server is a high performing open sou…   3960      [OK]    

# 可选项,参数,通过docker search --help查看
例子:查出所有start是3000星级以上的
docker search mysql -f STARS=3000
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker search mysql -f STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   10585     [OK]       
mariadb   MariaDB Server is a high performing open sou…   3960      [OK]       

docker pull:下载镜像

#下载镜像 docker pull 镜像名[:tag]
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker pull mysql
Using default tag: latest  #如果不写tag,默认就是latest最新版本
latest: Pulling from library/mysql
a076a628af6f: Pull complete  #分层下载,docker镜像的核心机制,联合文件系统
f6c208f3f991: Pull complete  #把镜像文件分层,不同版本之间如果一样可以共享,共享的层就不用再次下载
88a9455a9165: Pull complete 
406c9b8427c6: Pull complete 
7c88599c0b25: Pull complete 
25b5c6debdaf: Pull complete 
43a5816f1617: Pull complete 
1a8c919e89bf: Pull complete 
9f3cf4bd1a07: Pull complete 
80539cea118d: Pull complete 
201b3cad54ce: Pull complete 
944ba37e1c06: Pull complete 
Digest: sha256:feada149cb8ff54eade1336da7c1d080c4a1c7ed82b5e320efb5beebed85ae8c #镜像签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest  #下载的真实地址

#因为真实地址的存在,所以上述下载就等价于
docker pull mysql
docker pull docker.io/library/mysql:latest

#指定版本下载,这个版本必须是dockerhub上存在的,不然下载不下来,因为就是去dockerhub下载的
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker pull mysql:5.7
5.7: Pulling from library/mysql
a076a628af6f: Already exists 
f6c208f3f991: Already exists 
88a9455a9165: Already exists 
406c9b8427c6: Already exists 
7c88599c0b25: Already exists 
25b5c6debdaf: Already exists 
43a5816f1617: Already exists 
1831ac1245f4: Pull complete 
37677b8c1f79: Pull complete 
27e4ac3b0f6e: Pull complete 
7227baa8c445: Pull complete 
Digest: sha256:b3d1eff023f698cd433695c9506171f0d08a8f92a0c8063c1a4d9db9a55808df
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

#检查一下
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         5.7       a70d36bc331a   6 weeks ago     449MB
mysql         latest    c8562eaf9d81   6 weeks ago     546MB
hello-world   latest    bf756fb1ae65   14 months ago   13.3kB

docker rmi -f 镜像Id :镜像的删除

docker rmi -f 容器id  #删除指定镜像Id
docker rmi -f 容器id1  容器id2  容器id3 ... #删除多个容器
docker rmi -f $(docker images -aq) #通过id删除全部镜像

那些指定id不用写全,能区分就行。

容器命令

说明:我们pull下载下来了镜像,就能运行起来成为容器,容器里面运行着服务,此处我们下载一个centos镜像来学习测试。

docker pull centos   #此时容器里运行的就相当于一个centos系统,这比虚拟机要快多了。

新建容器并启动

docker run [可选参数] 镜像id
#参数说明
--name="name    #容器名字,比如tomcat1 tomcat2用来给启动的容器取名字做区分
-d              #容器以后台方式运行
-it             #使用交互方式运行,进入容器内部查看内容
-P(大写p)       #指定容器的端口,        -P 8080:8080
	-P	ip:主机端口:容器端口
	-P  主机端口:容器端口(常用)
	-P 容器端口
	容器端口
-p(小写p)        #不显式端口,启动随机指定

#测试运行,启动并进入容器
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
centos       latest    300e315adb2f   3 months ago   209MB
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -it 300e315adb2f(也可以用容器名,启动进入) /bin/bash
[root@4b3cacb0c99e /]# ls  #我们已经看到进入了容器内部,是一个独立的centos的系统,小服务器,而且用户也变了,这个小系统是最基础版本的那些命令,有些命令还不全。
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 

#从容器中退出主机
[root@4b3cacb0c99e /]# exit  #退出了容器内部,而且容器也结束运行了
exit

列出所有的运行中的容器

# docker ps [可选参数]:不加参数就是显示正在运行的容器
-a #列出当前正在运行的容器和以前历史运行过的容器
-n=?  #显示最近创建的?个容器记录
-q  #只显示容器的编号,当然可以组合使用
-aq   #显示所有的容器编号
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -a
CONTAINER ID   IMAGE     COMMAND    CREATED         STATUS           PORTS     NAMES
4b3cacb0c99e   300e315adb2f   "/bin/bash"   6 minutes ago   Exited (0) 3 minutes ago             interesting_almeida
efcadb58f789   bf756fb1ae65   "/hello"      5 hours ago     Exited (0) 5 hours ago               amazing_margulis
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -n=1
CONTAINER ID   IMAGE    COMMAND       CREATED         STATUS        PORTS     NAMES
4b3cacb0c99e   300e315adb2f   "/bin/bash"   8 minutes ago   Exited (0) 5 minutes ago             interesting_almeida
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -q
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -aq
4b3cacb0c99e
efcadb58f789

退出容器

exit    #直接容器停止并且退出
ctrl  + p + q   #容器退出但是不停止运行

删除容器

docker rm 容器id  #删除指定的容器,不能删除正在运行的容器,如果要强制删除要用docker rm -f 容器id
docker rm -f $(docker ps -aq)   #删除所有的容器
docker ps -a -q|xargs  docker rm #删除所有的容器

启动和停止容器

#第一次运行之后,查询历史运行就有容器id了,就可以直接跑了,不用再run镜像了
docker start 容器id   #启动容器
docker restart 容器id #重启容器
docker stop 容器id    #停止容器
docker kill 容器id    #强制停止当前容器

其他命令

后台启动容器:-d

# docker run -d 镜像名  
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -d centos
7f4d2563b9d6a3995a0ec97889b2aec8c79057ffa740b953f740062395b97024
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

#常见问题,启动后docker ps发现容器centos停止了

#坑:docker容器使用后台运行,就必须要有一个前台进程,docker要是发现没有前台应用就会自动停止,所以你以前-it -/bin/bash就相当于一个前台的连接进去容器,所以它不停。
#nginx,容器启动后,发现自己没提供服务,就会立即停止,其实就是没有程序了。

查看容器日志

docker logs -tf --tail 显示条数 :发现没有日志

#自己往容器里写一段脚本
#docker run -d centos /bin/sh -c "while true:do echo lwqniubi;sleep 1;done"

[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -d centos /bin/sh -c "while true;do echo lwqniubi;sleep 1;done"
6f0bd66bbe90d7541c7a2beda5ef17970505bb70e6b1a430e46a52f30439b45f
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS        PORTS     NAMES
6f0bd66bbe90   centos    "/bin/sh -c 'while t…"   2 seconds ago   Up 1 second             gallant_brown
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker logs -f -t 6f0bd66bbe90

#显示日志
-tf   #显示日志,-t -f可以组合用
--tail  number #显示number条日志
 docker logs -f -t  --tail 10 6f0bd66bbe90 #显示最近10条日志

查看容器中的进程信息,类似于linux的ps

# docker top 容器id
docker top 6f0bd66bbe90
以后可以进去容器杀个进程什么的,比如杀个容器里的tomcat之类的,因为以后自己打包一个容器里可能多个服务。

在这里插入图片描述

查看镜像的元数据

#命令:
docker inspect 容器id
查看容器的一些基本系统级别数据。

进入当前正在运行的容器

#我们通常容器都是使用后台方式运行的,需要进入容器查看修改一些配置

#方式一
docker exec -it 容器id  bashshell
exit退出容器。
#测试
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND      CREATED          STATUS          PORTS     NAMES
6f0bd66bbe90  centos  "/bin/sh -c 'while t…"   11 minutes ago   Up 11 minutes             
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker exec -it 6f0bd66bbe90 /bin/bash
[root@6f0bd66bbe90 /]# ls  #进入了
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 
[root@6f0bd66bbe90 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 14:33 ?     00:00:00 /bin/sh -c while true;do echo lwqniubi;sleep 1;done
root       748     0  0 14:45 pts/0    00:00:00 /bin/bash
root       821     1  0 14:46 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-
root       822   748  0 14:46 pts/0    00:00:00 ps -ef

#方式二
docker attach 容器id
#测试
docker attach  6f0bd66bbe90
看到正在运行的程序


$ docker exec  #进入容器后开启一个新得区域,我们可以在里面操作(常用)
$ docker attach  #进入容器正在执行得终端区域,不会启动新得进程区域

从容器内部拷贝文件到外部主机上

#命令,不管你容器是不是启动着,只要里面有对应文件就能复制,你创建了又停了只要没删就是有。
docker  cp 容器id:容器内路径  主机目的路径

#测试
#查看当前主机,没有文件
[root@iZ2zec103hcivif4pv3ai2Z docker]# ls  
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND        CREATED     STATUS          PORTS     NAMES
6f0bd66bbe90   centos    "/bin/sh -c 'while t…"   26 minutes ago   Up 26 minutes

#进入容器内部在opt下创建一个文件test.java
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker exec -it 6f0bd66bbe90 /bin/bash
[root@6f0bd66bbe90 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 
[root@6f0bd66bbe90 /]# cd opt
[root@6f0bd66bbe90 opt]# touch test.java
[root@6f0bd66bbe90 opt]# ls
test.java

#把容器内得test.java文件复制到外部主机得opt里
[root@iZ2zec103hcivif4pv3ai2Z docker]# ls /opt
test.java

#拷贝是一个手动过程,未来使用数据卷-v实现容器内外得同步。

练习

Docker部署Nginx

# 1、搜索nginx的镜像信息
docker search nginx
# 2、根据信息下载对应版本nginx(我这里就用默认最新)
docker pull nginx
# 3、查看下载镜像
docker images
# 4、启动nginx容器
docker run -d --name nginx01 -p 8180:80 f6d0b4767a6c
	#解释一下:
	-d:表示后台启动
	--name nginx01:启动了一个容器,名字为nginx01,你可以随意命名,就能启动多个。
	-p:表示端口
	8180:80  :nginx的默认端口是80,我们这个nginx是部署在docker容器里的,容器是和外面隔离的,而你访问只是去访问你得linux宿主机,隔离的你访问不到,所以就需要映射端口,我把容器里nginx默认的80端口和宿主机linux的8180做映射,以后我就访问Linux的8180就能映射到容器里的80了。
	f6d0b4767a6c:镜像id,表示使用该镜像创建容器


# 5、测试访问
curl localhost:8180

# 6、进入nginx容器内部
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                    NAMES
d54b129e940b   f6d0b4767a6c   "/docker-entrypoint.…"   17 minutes ago   Up 17 minutes   0.0.0.0:8180->80/tcp     nginx01

[root@iZ2zec103hcivif4pv3ai2Z docker]#  docker exec -it d54b129e940b bin/bash #进入容器

root@d54b129e940b:/usr/local/src# whereis nginx   #查看安装位置
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@d54b129e940b:/usr/local/src# cd /etc/nginx
root@d54b129e940b:/etc/nginx# ls
conf.d	fastcgi_params	koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params	uwsgi_params  win-utf
root@d54b129e940b:/etc/nginx# cat nginx.conf
# 6、页面访问

橘子学docker01之基本玩法_第4张图片

橘子学docker01之基本玩法_第5张图片

思考:我们每次改动nginx配置文件,都需要进入容器内部,十分的麻烦,要是能在容器外部提供一个映射路径,达到每次在外部修改使得容器内部iu能自动修改多好。这就是-v 数据卷技术。

Docker部署Tomcat

#官方的使用:
docker run -it --rm tomcat:9.0   #一般用来测试,--rm是用完就删了,所以我们一般不用,它运行一次就没了。

#我们之前的启动都是后台启动,停止了容器后容器还能查到,--rm是用完就删,一般用来测试。

#常用的是下载启动
docker pull tomcat  #不指定版本号默认就是最新的

#启动运行
docker run -d -p 8080:8080 --name tomcat01  tomcat

#启动成功但是页面访问404,因为最新的镜像容器内部webapp是空的,而tomcat得默认网站就在webapp下
#进入容器
docker exec -it  tomcat01 /bin/bash

#进入发现,1、linux命令有的不能用,因为它极尽简化 2、没有webapps,是因为阿里云镜像得原因,默认是最小镜像,所有不必要得全部删除了,方便下载。只保证了最小得客运行环境。
#把webapps.dist(这里面是个基本得备份)里得复制到webapp下,就可以了。
cp webapps.dist/*  webapps

思考:我们以后部署项目,如果每次都要进入容器就十分得麻烦,要是能在容器外面提供一个路径,webapps我们就直接在外部布置项目,自动同步到容器内部就好了。

Docker部署ES+kIbana

#es比起其他暴露得端口比较多,9200,9300
#es十分得耗费内存
#es得数据一般需要放置到安全目录,需要数据卷挂载
# --net somenetwork?需要涉及网络配置

#启动elasticsearch,直接启动,它发现没镜像就会自己先拉取镜像。
docker run -d --name elasticsearch01  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

#启动之后发现linux卡死了,使用docker stats查看docker占用cpu状态,占比十分大。

#es是十分耗费内存得

#查看docker stats,发现占比巨大
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker stats

CONTAINER ID   NAME              CPU %     MEM USAGE / LIMIT     MEM %     NET I/O           BLOCK I/O        PIDS
f5801a042824   elasticsearch01   0.00%     360.2MiB / 1.795GiB   19.60%    0B / 0B           6.44MB / 729kB   42
d54b129e940b   nginx01           0.00%     1.953MiB / 1.795GiB   0.11%     5.18kB / 5.81kB   0B / 4.1kB       3
3be601876cef   tomcat01          0.08%     127.6MiB / 1.795GiB   6.94%     52.2kB / 392kB    10.1MB / 0B      31
6f0bd66bbe90   gallant_brown     0.01%     3.652MiB / 1.795GiB   0.20%     2.4kB / 0B        6.77MB / 0B      4

#测试一下启动成功了
[root@iZ2zec103hcivif4pv3ai2Z ~]# curl localhost:9200
{
  "name" : "f5801a042824",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "NuEcsBc9SbuUgEnGKXqsvQ",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

#赶紧关闭,在启动时增加内存限制,修改配置文件,-e增加环境配置参数,设置常规使用64m,最大分配512m
docker run -d --name elasticsearch01  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node"  -e ES_JAVA_OPTS="-Xms64m  -Xmx512m"  elasticsearch:7.6.2
这次就不卡了。

使用kibana连接es直接连不上,因为容器互相隔离,但是es得端口已经和宿主机Linux做了对应,所以可以把宿主机当成中间传递。

橘子学docker01之基本玩法_第6张图片

可视化

1、portainer(先用这个,不是最终的)

docker run -d -p 8088:9000\
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

2、Rancher(CI/CD再用)

什么是portainer?

Docker图形化界面管理工具,提供一个后台面板供我们使用操作。

docker run -d -p 9001:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试:http:ip:8088/

…这个不重要,后面补上,我没测试过。

Docker镜像讲解

镜像是什么

镜像是一种轻量级,可执行的独立软件包,用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码,运行时,库,环境变量和配置文件。

所有的应用,直接打包docker镜像就可以直接运行跑起来。

如何得到镜像

1、从远程库下载。

2、朋友拷贝给你。

3、自己制作一个镜像,DockerFile.

Docker镜像加载原理

UnionFS(联合文件系统)

我们下载的时候看到的一层一层就是这个。具体可以百度。

特性:一次同时加载多个文件系统,但从外面看起来只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录。

橘子学docker01之基本玩法_第7张图片

就是不同的容器或者相同的容器,相同的层可以共用,mysql用了那个,下次tomcat下载要是还用就能复用,不需要再下载了,节省。

橘子学docker01之基本玩法_第8张图片

分层理解

橘子学docker01之基本玩法_第9张图片
橘子学docker01之基本玩法_第10张图片

commit镜像

docker commit  # 提交现容器成为一个新得镜像

# 命令和git很像
docker commit  -m="提交的描述信息"  -a="作者" 容器id 目标镜像名:[tag版本号]

实战测试:

# 1、启动一个默认的tomcat

# 2、发现这个默认的tomcat是没有webapps应用,镜像的原因,阿里云官方默认webapps下没有这些文件,它只保留了必须启动的一些东西。

# 3、我自己拷贝进去那些文件进入webapps中

# 4、此时我们这个容器就比默认的多了,将我们操作过的容器通过commit提交为一个镜像,我们以后就用我们修改过的镜像即可,这就是我们自己修改创建的一个新镜像。
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker commit  -m="lwq add wabapps" -a="lwq" 3be601876cef tomcat02:1.0
sha256:04a183e0cb0f926d167454c00bf283049e28a1006fd74bc8ce80a91f7fa8dc04
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
tomcat02              1.0       04a183e0cb0f   5 seconds ago   654MB
tomcat                latest    040bdb29ab37   7 weeks ago     649MB
nginx                 latest    f6d0b4767a6c   8 weeks ago     133MB
centos                latest    300e315adb2f   3 months ago    209MB
portainer/portainer   latest    62771b0b9b09   7 months ago    79.1MB
elasticsearch         7.6.2     f29a1ee41030   11 months ago   791MB

到此处docker算是入门了,此时我们对分层有理解了,我创建的tomcat02和01大部分都是共用层的,多的就是自己添加的那些。

镜像的操作(补充)

# 1、从仓库拉取镜像到本地
docker pull 镜像名称[:tag]   # []表示可以不写,如果不写版本号就是默认最新版本

# 举个栗子:
docker  pull  daocloud.io/library/tomcat:8.5.14-jre8
#daocloud.io/library/tomcat:8.5.14-jre8是从daocloud上找下来的

# 2、查看本地全部docker镜像
docker images
[root@iZ2zeanc2b2vggedkulxdnZ ~]# docker images
REPOSITORY                   TAG           IMAGE ID       CREATED         SIZE
hello-world                  latest        bf756fb1ae65   13 months ago   13.3kB
daocloud.io/library/tomcat   8.5.14-jre8   a0fd548664d9   3 years ago     367MB

# 3、删除本地镜像
docker rmi 镜像的标识号(不用写全,只要能保证是它就行)

# 4、镜像的导入导出(不规范)
#就是将本地的镜像文件打包,然后可以拷走,直接在其他地方再导出就是你打包的那个东西了

# 将本地的镜像导出
docker save -o 导出的路径/导出的名字(image为后缀)  要导出镜像的id
#docker save -o /opt/docker/tomcat.image  a0fd548664d9

#加载本地的镜像文件(相当于解压你导出的文件,就能用了,和上面的相对的)
docker load -i 加载的镜像名称
#docker load -i tomcat.image
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
<none>        <none>    a0fd548664d9   3 years ago     367MB

#上面加载完的镜像是没有名字版本号的,是none,所以要修改以下镜像文件
docker tag  镜像id(不必全) 镜像名字:版本号(名字自己取,版本号实事求是就行)
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker tag   a0fd548664d9 tomcat:8.5
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
tomcat        8.5       a0fd548664d9   3 years ago     367MB

容器的操作(补充)

# 1、运行容器
#简单的操作就是:
docker  run  镜像的标识|镜像的名称[:tag]

#规范的操作,常用的参数
docker  run -d -p 宿主机端口:容器端口  --name 容器名称 镜像的标识|镜像名称[:tag]

# -d:代表后台运行该容器,不至于关了窗口容器也没了
# -p 宿主机端口:容器端口:为了映射当前linux端口和容器的端口,你客户端访问的是Linux的,所以要映射进去docker内部才能真正访问docker提供的服务。
# --name容器名称:你运行容器的名字,自己取就好,真正确定运行哪个容器是后面的标识。

#docker run -d -p 8080:8080  --name tomcat  b4b762737ed4

# 2、查看正在运行的容器
docker ps [-qa]
# -a:查看全部的容器,包括没有运行的
# -q:只查看容器的标识
# -qa:只查看正在运行的容器标识

# 3、查看容器的日志(启动,运行)
docker logs -f 容器id
# -f:可以滚动的查看日志的最后几行,退出用ctrl + c

# 4、进入容器内部做操作
docker exec -it 容器id bash
#一般不建议进入容器内部操作,有时候需要确认文件在哪可以进去
exit退出

#5、删除容器(删除容器前,需要先停止容器)
docker stop 容器id #停止某一个容器
docker stop $(docker ps -qa) #停止所有运行的容器

docker rm 容器id #删除某一个容器
docker rm $(docker ps -qa) #删除所有运行的容器


# 6、启动容器
docker start 容器id(第一次运行完,本地就有容器环境了,下次就能启动了)

Docker的容器数据卷

什么是容器数据卷

docker的理念回顾

docker是将应用和环境打包成一个镜像,就能很方便的带着环境直接运行整个应用。

数据都放在容器中有两个问题:

1、如果将容器删除,数据就会丢失,所以需要将数据持久化。

2、每次修改什么文件都要进入容器中修改,极其不便。

所以需要一个技术,将容器数据和本地同步,再本地修改可以直接反应到容器中,在容器内部产生的数据也能同步到本地。这就是数据卷技术,目录的挂载,将我们容器内的目录,挂载到linux上面。
橘子学docker01之基本玩法_第11张图片


总结起来一句话,容器的持久化和同步操作,容器间也可以共享数据,挂载一个数据卷地址就可以了。

使用数据卷

方式一:直接使用命令挂载 -v

docker run -it -v 主机目录:容器内目录  

# 测试
docker run -it -v /home/ceshi:/home  centos /bin/bash

#启动之后,我们可以使用docker inspect 容器id来查看挂载情况
docker inspect 8a5737fcf86a

橘子学docker01之基本玩法_第12张图片

测试文件同步:

橘子学docker01之基本玩法_第13张图片

在这里插入图片描述

再来测试:

1、停止容器

2、宿主机修改文件内容

3、启动容器

4、容器内的数据也被同步,可见是宿主机和容器的双向同步。

所以以后修改容器内部就直接在宿主机上修改,容器内部就能自动同步了。

实战:安装Mysql

思考:mysql数据的持久化。

# 拉取mysql镜像
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker pull mysql:5.7

# 运行容器,需要做数据卷的挂载,安装启动mysql,需要配置密码,需要注意
# mysql官方命令:docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 启动我们的容器
docker run -d -p 8088:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 a70d36bc331a

#解释:
-d:后台运行
-p:端口映射
-v:数据卷挂载,本地路径映射到容器路径
-e:环境配置
--name:定义容器名字

#启动之后,用navicat连接一下ip和8080端口

#navicat连接对应linux的服务器地址,端口为宿主机的8088端口,8088映射容器3306就连接上了。

#在navicat创建了一个数据库test,进去容器的/var/lib/mysql发现有这个表,在宿主机上的/home/mysql/data也有,可见映射同步成功,之后你只要映射了,对应的文件外面修改了容器内部也就修改了。

#你把容器删除了,外面宿主机的数据也不会丢失这就是持久化成功了。


docker create --name mysql-master01 -v /data/mysql/master01/data:/var/lib/mysql -v /data/mysql/master01/conf:/etc/mysql/conf.d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7.33

docker create --name mysql-slave1 -v /data/mysql/slave01/data:/var/lib/mysql -v /data/mysql/slave01/conf:/etc/mysql/conf.d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7.33

具名和匿名挂载

# 匿名挂载
# 命令
-v 容器内部路径
# 测试,挂载一个nginx,直接就-v 后面是容器内部的路径
docker run -d -P(大写的随机指定端口,我这里测试就随机了) --name nginx01 -v /etc/nginx  nginx

# 查看所有的volume的情况
[root@iZ2zec103hcivif4pv3ai2Z /]# docker volume ls
DRIVER    VOLUME NAME
local     0bd9502f2a7328e3ef0db380f31981d37ab7ab712dab257b4f0d57a878a0e0b8
# 这里发现,这种就是匿名挂载,我们在-v后面只写了容器内部的路径,没写容器外部的路径。查出来的volume就是一长串字符串这个名字,没具体名字。

#具名挂载
[root@iZ2zec103hcivif4pv3ai2Z /]# docker run -d -P --name nginx02  -v juming-nginx:/etc/nginx nginx
b5ec3d3915d8201c9fe62c3021be808a57c4c4d6bf0adb28c2781c7341fa25ee
# 说明:
-v 后面直接就是一个数据卷名字:容器内路径 这里和上面挂载mysql不一样,这个:前面不是外部路径,是名字,因为路径前面都有/现在没有就是名字。
# 查看数据卷
[root@iZ2zec103hcivif4pv3ai2Z /]# docker volume ls
DRIVER    VOLUME NAME
local     juming-nginx

# 通过 -v 卷名:容器内部路径,查看一下这个卷
# inspect查看数据卷

橘子学docker01之基本玩法_第14张图片

所有的docker容器的卷,没有指定目录的情况下都是在/var/lib/docker/volumes/***/_data
我们通过具名挂载可以方便的找到我们的一个卷,大多数都是具名挂载。

# 如何区分是具名挂载还是匿名挂载还是指定路径挂载
-v 容器内路径      # 匿名挂载
-v 卷名:容器内路径  # 具名挂载
-v /宿主机路径:容器内路径 # 指定路径挂载

拓展:

# 通过 -v 容器内路径:ro 或者rw 设置读写权限
ro readonly # 只读
rw readdwrite  # 可读可写

# 一旦这个设置了容器权限,容器对我们挂载出来的内容就有限定了。
docker run -d -P --name nginx02  -v juming-nginx:/etc/nginx:ro  nginx
docker run -d -P --name nginx02  -v juming-nginx:/etc/nginx:rw  nginx

# ro是只读,针对的是说容器只读,只要看到这个就说明这个路径是只能对宿主机操作的,容器内部是无法修改的。

初识Dockerfile

Dockerfile就是用来构建docker镜像的文件,其实就是一个脚本,用来创建docker镜像的。

通过这个脚本可以生成镜像,镜像是一层一层的,脚本一个个的命令,每一个命令就是一层。

# 创建一个dockerfile文件(脚本文件,命令全部大写),文件名字可以随意,但是建议就叫Dockerfile
# 文件中的内容格式为:指令(大写) 参数
FROM centos     #表示镜像是以现有的一个叫centos镜像为基础层的
VOLUME ["volume01","volume02"]   #在基础层上添加两个数据卷,vo1和vo2,都是以匿名挂载的形式,在生成镜像的时候就直接指定容器内路径。
CMD echo "---------end--------"   #在容器输出一句话
CMD /bin/bash   # 使用bin bash进入容器,就是生成镜像的时候,我们是进去的

#以上没一句命令都是在基础centos的基础上加了一层,docker镜像就是一层一层的

使用镜像文件生成一个镜像:docker build -f /opt/docker-test-volume/Dockerfile -t lwq-centos:1.0 .

[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# pwd
/opt/docker-test-volume
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# vim Dockerfile
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# ls
Dockerfile
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# cat Dockerfile 
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "---------------------------end-----------------"
CMD /bin/bash
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# docker build -f /opt/docker-test-volume/Dockerfile  -t lwq-centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos   #第一句执行,第一层构建
 ---> 300e315adb2f
Step 2/4 : VOLUME ["volume01","volume02"] #第二句执行,第二层构建
 ---> Running in 42ece5a6a1da 
Removing intermediate container 42ece5a6a1da
 ---> 1c4d223008df
Step 3/4 : CMD echo "---------------------------end-----------------"  #第三句执行,第三层构建
 ---> Running in dd956b2fe0e7
Removing intermediate container dd956b2fe0e7
 ---> c64818729098
Step 4/4 : CMD /bin/bash    #第四句执行,第四层构建
 ---> Running in f878d7c6cc0f
Removing intermediate container f878d7c6cc0f
 ---> 5a6fba29f440
Successfully built 5a6fba29f440
Successfully tagged lwq-centos:1.0


#解释一下
docker build -f /opt/docker-test-volume/Dockerfile  -t lwq-centos:1.0 .
build:构建参数
-f:表示使用文件构建
/opt/docker-test-volume/Dockerfile  :指定是哪个文件
-t:target表示目标镜像
lwq-centos:1.0  :目标镜像名
.  :表示在当前路径下执行,所以那个指定文件可以直接写,不用写绝对路径,因为是当前路径。

橘子学docker01之基本玩法_第15张图片

启动我们创建的镜像

[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# docker run -it lwq-centos:1.0  /bin/bash
[root@e94dc4ed1d75 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  volume01	volume02

#启动成功,我们发现内部也有volume01	volume02这两个路径。
#注意,你直接启动不加版本号,它默认去找lasted,没有这个版本,所以记得加上1.0 ,我们创建的时候指定的1.0

查看容器挂载情况 e94dc4ed1d75是容器id

[root@iZ2zec103hcivif4pv3ai2Z ~]# docker inspect e94dc4ed1d75

橘子学docker01之基本玩法_第16张图片

测试一下是不是内部外部同步了

# 在容器内部路径创建一个文件

在这里插入图片描述

在这里插入图片描述

这种方式使用的特别多,因为我们通常会自己构建镜像。假设构建镜像的时候没有挂载卷,就要手动挂载-v 卷名:容器内路径。

数据卷容器(–volumes-from)

多个容器之间做数据的同步,多个Mysql同步数据。
橘子学docker01之基本玩法_第17张图片

就是centos2这个容器同步了centos1这个容器,那么以后1,2之间数据就是双向同步的,删除了一个另一个不会受影响,可以当成一个数据备份。

启动两个容器,设置同步。

橘子学docker01之基本玩法_第18张图片

在这里插入图片描述

在docker01的volume01数据卷中创建一个文件,看看docker02容器里有没有。

在这里插入图片描述

在这里插入图片描述

# 你创建了docker03继承于docker01三个之间就是全部同步了,你删除docker01,查看docker02,docker03里还能看到文件,就是说删除一个不会影响其他的运行,直到全部删除完了才行。是一个互相拷贝的概念,带点复制备份。

多个mysql之间是可以实现数据共享。

docker run -d -p 8088:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

docker run -d -p 8088:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02
--volumes-from mysql01 mysql:5.7

#这个时候可以实现两个容器的数据同步。

结论:

容器之间配置信息的传递,数据卷容器的生命周期一直持续到没有容器使用为止。全停了。

但是一旦持久化到本地,这个时候,本地的数据不会因为删除哪个容器而被删除。

DockerFile

DockerFile介绍

dockerfile是用来构建docker镜像的文件,是一个命令参数脚本。

构建步骤:

1、编写一个dockerfile文件

2、docker build构建成为一个镜像

3、docker run运行镜像

4、docker push 发布镜像(可以发布到DockerHub、阿里云镜像仓库上)

你去官方查看镜像点进去都是在github上的一个个的dockerfile文件,但是很多官方镜像都是基础包,只保留了运行必须的一些数据信息,很多功能都没有,所以我们一般会创建自己的镜像文件。

官方可以制作镜像,我们也可以。

DockerFile构建过程

基础知识

1、每个保留关键字(指令)都必须是大写字母。

2、执行指令从上到下。

3、# 表示注释。

4、每个执行都会创建提交一个新的镜像层,并提交。

橘子学docker01之基本玩法_第19张图片

dockerfile是面向开发的,我们以后要发布项目做镜像,就需要编写dockerfile文件,这个文件十分简单。

Docker镜像逐渐成为企业交付的标准,需要掌握拿下。

步骤:开发,部署,运维。

DockerFile:构建一个镜像生成的一切步骤。

DockerImages:通过DockerFile构建生成的镜像,最终发布和运行的产品。

Docker容器:容器就是镜像运行起来提供服务的。以前我们项目打包为jar或者war,现在只需要把项目弄成镜像,包含一切组件,直接运行发布就行。

DcokerFile的指令

以前我们就是使用别人的镜像,现在有了这些指令,我们就能自己创建自己的镜像文件。

FROM      			# 基础镜像,一切都是从这一层开始加,一切从此开始构建
MAINTAINER			# 镜像是谁写的,姓名+邮箱(国际惯例)
RUN					# 镜像构建的时候需要运行的命令,run后面跟你要执行的命令
ADD					# 添加文件进入镜像,比如,把tomcat镜像添加集成到你制作的镜像中,添加tomcat一层,搭建一个里面有tomcat的容器,不然它里面的项目要起tomcat起谁去呢?
WORKDIR				# 镜像当前的工作目录,exec进入的目录
VOLUME				# 数据卷的挂载目录
EXPOSE				# 保留端口配置,对外指定端口,这里直接在镜像暴露端口,这里不暴露,启动的时候-p暴露才行
CMD					# 指定这个容器启动的时候要运行的命令,只有最后一个会生效,后面的替代前面的
ENTRYPOINT          # 指定这个容器启动的时候要运行的命令,比起CMD不会替代,会追加指令
ONBUILD				# 当构建一个被继承的DockerFile这个时候就会运行ONBUILD的指令,触发指令
COPY 				# 类似ADD,将我们的文件拷贝到你要制作的镜像中
ENV					# 构建的时候设置环境变量,和run的时候那个-e差不多

橘子学docker01之基本玩法_第20张图片

实战测试1

Docker Hub中99%的镜像是从这个基础镜像过来的 FROM scratch,然后配置需要的软件和配置来进行添加构建。

橘子学docker01之基本玩法_第21张图片

我们从dockerhub上下下来的ccentos容器里有很多命令是没有的,他是个阉割版的。

在这里插入图片描述

所以我们现在以centos为例,我们制作一个有这两个命令的加强版的镜像。

创建一个自己的centos,加强版的

# 1、编写dockerfile文件
FROM centos     # 从我本地下载的镜像centos作为基本的版本层开始制作
MAINTAINER   lwq<2018305346@qq.com>   # 作者信息

ENV  MYPATH  /usr/local   # 声明一个环境变量,路径作为一个变量,可以多个
WORKDIR  $MYPATH   # 把这个路径变量设置给工作目录

RUN yum -y install  vim    # 制作过程需要执行的命令,下载vim指令
RUN yum -y install net-tools  # 下载一些网络的指令,ifconfig就在这里面

EXPOSE  80   #暴露端口

CMD echo $MYPATH   # 制作过程输出这个路径变量
CMD echo "----------------------------end-----------------"   # 输出一句话
CMD /bin/bash   # 执行进入/bin/bash

# 2、通过编写的dockerfile创建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag版本号] .
docker build -f myCentosDockerFile -t lwqcentos:1.0 .

成功:
我们看到日志,生成的过程就是一层一层的创建,各种过程,这里就不列出来了。
Successfully built 6aea258a4627
Successfully tagged lwqcentos:1.0

# 3、测试运行
docker run -d -it lwqcentos /bin/bash

橘子学docker01之基本玩法_第22张图片

橘子学docker01之基本玩法_第23张图片

# 4、可以通过docker history查看镜像的制作过程,历史记录,变更历史
docker history 镜像id

# 我们平时拿到一个镜像就能看看它的制作过程记录

橘子学docker01之基本玩法_第24张图片

CMD和ENTRYPOINT的区别

CMD					# 指定这个容器启动的时候要运行的命令,只有最后一个会生效,后面的替代前面的
ENTRYPOINT          # 指定这个容器启动的时候要运行的命令,比起CMD不会替代,会追加指令

测试CMD命令:

# 1、编写dockerfile文件
[root@iZ2zec103hcivif4pv3ai2Z docker]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]   # ls 和-a是命令和参数,放到两个“”里,各是各的

# 2、通过镜像文件,构建镜像
[root docker]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 9f561f311c7c
Removing intermediate container 9f561f311c7c
 ---> 086ef3732fde
Successfully built 086ef3732fde
Successfully tagged cmdtest:latest

# 3、run运行镜像,记住CMD命令是在运行的时候生效的,发现我们的ls -a命令生效了,
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run 086ef3732fde
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt

# 4、命令每次启动都能在启动时候加进去,这种只能生效一次,不像那种CMD写进文件里制作的,我们来加一个
# 追加一个命令-l 我们文件里写的ls -a这里加一个-l最终应该是ls -al
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run 086ef3732fde -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:370: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
# 我们看到报错了,因为CMD这种命令它是覆盖,最后的-l会覆盖前面的ls -a(CMD ["ls","-a"]),但是我们知道-l不是个命令,要是我们追加一个ls -al,那ls -al就会覆盖前面,ls -al是一个命令就能生效。

橘子学docker01之基本玩法_第25张图片

测试ENTRYPOINT

这个就会追加了,ls -al都能执行,具体可以自己敲一下,我就不上了。放个狂神的截图。

橘子学docker01之基本玩法_第26张图片

实战测试2

制作一个tomcat镜像。

1、准备镜像文件需要的文件,tomcat压缩包,还需要jdk环境,一个jdk的压缩包。

在这里插入图片描述

2、编写dockerfile文件,官方的命名一般是Dockerfile,最好有一个readme.txt的帮助说明使用。

取名为Dockerfile,build的时候就会自动寻找这个文件,这就不需要-f指定了,它会默认扫描叫这个名字的文件。很多idea都已经默认了。

[root@iZ2zec103hcivif4pv3ai2Z tomcat-docker]# vim Dockerfile   #创建dockerfile文件

FROM  centos  #基础层,起于centos
MAINTAINER lwq<2018305346@qq.com>  #作者信息

COPY readme.txt  /usr/local/readme.txt  # 把readme.txt帮助文件拷贝到容器的 /usr/local下,因为是.当前文件夹运行,所以readme.txt直接写了,就在当前路径下

ADD jdk-8u171-linux-x64.tar.gz  /usr/local/  #把jdk压缩包放进容器,add命令会自动为我们解压,所以直接添加压缩包,无需你解压
ADD apache-tomcat-8.5.35.tar.gz /usr/local/  #把tomcat压缩包放进容器,add命令会自动为我们解压,所以直接添加压缩包,无需你解压

RUN yum -y install vim  # 下载vim命令

ENV MYPATH  /usr/local   # 环境变量
WORKDIR $MYPATH   # 设置工作路径,进入容器默认就是这个路径

ENV  JAVA_HOME /usr/local/jdk1.8.0_171  #以下是配置jdk和tomcat的环境变量,你在windos安装的时候也是这个,一个原理,只不过这个是写在脚本里的,多百度
ENV  CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV  CATALINA_HOME  /usr/local/apache-tomcat-8.5.35
ENV  CATALINA_BASH  /usr/local/apache-tomcat-8.5.35
ENV  PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE  8080   # 暴露下容器的端口

#运行镜像时执行这个命令,就是启动容器内的tomcat,并且打印日志,两个命令可以一起执行,用&&隔开
CMD  /usr/local/apache-tomcat-8.5.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.35/bin/logs/catalina.out

3、构建docker镜像

# docker build -t lwqdivtomcat .      #Dockerfile这个名字默认扫描,不用写-f了,构建一个目标名叫lwqdivtomcat的镜像,-t是目标的意思,target

Successfully built 9a44d38a8da4
Successfully tagged lwqdivtomcat:latest

4、启动构建成功的docker镜像

# 启动,并设置数据卷挂载,挂载tomcat一些需要的路径
docker run -d -p 8080:8080   --name lwqdivtomcat  -v /home/lwq/build/tomcat/test:/usr/local/apache-tomcat-8.5.35/webapps/test -v /home/lwq/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-8.5.35/logs  lwqdivtomcat

5、访问测试

# 浏览器访问tomcat页面发现成功
http://182.92.152.71:8080/

6、发布项目(由于做了卷挂载,我们直接在本地的挂载目录编写项目就可以发布了),创建发布项目需要的文件,模拟建立一个简单的项目:

# 1、cd  /home/lwq/build/tomcat/test(对应容器内的apache-tomcat-8.5.35/webapps/test),test就相当于我们项目那个文件夹了
# 创建WEB-INF文件夹:mkdir WEB-INF
# 在WEB-INF中创建web.xml文件(模拟一个项目)

web.xml


  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

  web-app>

然后在test文件夹下,创建一个页面,用于访问,index.jsp

# cd ..   #进入test文件夹
# vim index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>




hello lwq 这是你自己制作的tomcat


恭喜你docker入门了,运行了自己制作的tomcat-------------------lwq自己div的tomcat镜像--------------------
<% System.out.println("-------------------lwq自己div的tomcat镜像--------------------"); %>

此时容器内部挂载的也就有了这些文件。

访问项目:http://182.92.152.71:8080/test/

在这里插入图片描述

…上传镜像后面写。

你可能感兴趣的:(408,docker,linux,运维)