Docker

docker 基础

一.docker

什么是 docker？

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux 或 Windows 操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

docker 基本组成

docker 的基本组成：客户端，服务器，镜像仓库。
镜像（ image ）：
docker 镜像就好比是一个模板，可以通过这个模板来创建容器服务， 通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的），镜像没有启动，停止 这些操作
容器（ container ):
Docker 利用容器技术，独立运行一个或者一个组应用，通过镜像来创建的。 启动，停止，刪除，基本命令！ 目前就可以把这个容器理解为就是一个简易的 inux 系统
仓库（ repository ）：
仓库就是存放镜像的地方！ 仓库分为公有仓库和私有仓库！ Docker Hub(默认是国外的) 阿里云 腾讯云 …都有容器服务器(配置镜像加速！）

二.docker 安装

环境：CentOS Linux release 7.7.1908 (Core)/版本：3.10.0-1062.el7.x86_64

  1. 卸载旧的版本
1
2
3
4
5
6
7
8
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
  1. 安装需要的包
1
yum install -y yum-utils
  1. 设置镜像仓库
1
2
3
4
5
yum -y install docker-ce docker-ce-cli containerd.io
yum -y install docker-ce-20.10.* docker-ce-cli-20.10.* containerd.io
docker-ce #社区版
#安装完成后验证
docker version
  1. 更新 yum 软件包索引
1

  1. 安装 docker
1
systemctl start docker
  1. 启动 docker
1
docker run hello-world
  1. 运行 hello-world 进行验证
1
docker images

  1. 查看运行的 hello-world

  2. 卸载 docker

1
2
3
4
1.删除安装包
yum remove docker-ce docker-ce-cli containerd.io
2.删除镜像、容器、配置文件等内容
rm -rf /var/lib/docker
  1. 阿里云镜像加速
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
	{
		"exec-opts": ["native.cgroupdriver=systemd"],
		"registry-mirrors": [
		"http://hub-mirror.c.163.com",
		"https://docker.m.daocloud.io",
		"https://dockerproxy.com",
		"https://docker.mirrors.ustc.edu.cn",
		"https://docker.nju.edu.cn",
		"https://docker.m.daocloud.io",
		yum-config-manager \
		--add-repo \
		http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
		yum makecache fast
		yum -y install docker-ce docker-ce-cli containerd.io
		yum -y install docker-ce-20.10.* docker-ce-cli-20.10.* containerd.io
		docker-ce #社区版
		#安装完成后验证
		docker version
		systemctl start docker
		docker run hello-world
		docker images
		"https://dockerproxy.com",
		"https://docker.mirrors.ustc.edu.cn",
		"https://docker.nju.edu.cn"
		]
	}
	EOF
	systemctl daemon-reload
	systemctl restart docke

三.底层原理

  1. Docker 是怎么工作的？
    Docker 是一个 Client-Server 结构的系统，Docker 的守护进程运行在主机上。通过 Socket 从客户端访问！
    DockerServer 接收到 Docker-Client 的指令，就会执行这个命令！
  2. Docker 为什么比 VM 快？
  • 1、Docker 有着比虚拟机更少的抽象层。
  • 2、docker 利用的是宿主机的内核，vm 需要是 Guest OS。
    所以说，新建一个容器的时候，docker 不需要像虚拟机一样重新加载一个操作系统内核，避免引导。 虚拟机是加载 GuestOS，分钟级别的，而 docker 是利用宿主机的操作系统，省略了这个复杂的过程，秒级！

四.Docker 常用命令

  1. 帮助命令
1
2
3
docker version # 显示 docker 的版本信息
docker info # 显示 docker 的系统信息，包括镜像和容器的数量
docker 命令 --help # 帮助命令
  1. 列出 docker 下的镜像
1
2
3
4
5
6
7
8
9
10
11
12
testroot@heber ~# docker images
REPOSITORY  TAG     IMAGE       ID  CREATED     SIZE
hello-world latest feb5d9fea6a5 7   months ago  13.3kB
# 解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的id
CREATED 镜像的创建时间
SIZE 镜像的大小
# 命令参数可选项
-a, --all # 显示所有镜像 (docker images -a)
-q, --quiet # 仅显示镜像id (docker images -q）
  1. 在镜像仓库搜索某一个镜像
1
2
3
4
5
6
[root@heber ~]# docker search --limit 5 redis
NAME    DESCRIPTION STARS     OFFICIAL    AUTOMATED
镜像名称 镜像说明     点赞数量  是否为官方的 是否是自动构建的
# 命令参数可选项 (通过搜索来过滤)
--filter=STARS=3000 # 搜索出来的镜像就是 stars 大于 3000 的
bash
  1. docker 下载镜像
1
docker pull 镜像名:6.0.8
  1. 查看镜像所占空间
1
docker system df
  1. docker 删除镜像
1
2
3
4
docker rmi -f IMAGEID
docker rmi -f 镜像 id # 删除指定的镜像
docker rmi -f 镜像 id 镜像 id 镜像 id # 删除多个镜像（空格分隔）
docker rmi -f $(docker images -aq) # 删除全部的镜像
  1. 导出导入镜像
1
2
3
4
5
6
#导出
docker save -o 要保存的文件名 要保存的镜像
docker save -o /opt/mysql.tar mysql:5.7
#导入
docker load --input 文件
docker load --input mysql.tar

五.docker 容器命令 1.新建+启动容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
docker run [可选参数] image
# 参数说明
--name="name" 容器名字：用来区分容器
-d 后台方式运行：相当于 nohup
-it 使用交互式运行：进入容器查看内容
-p 指定容器的端口（四种方式）
-P 随机指定端口（大写字母 P）
# 端口映射方式（-p）
  -p ip:主机端口：容器端口
  -p 主机端口：容器端口（常用）
  -p 容器端口 # 仅指定容器端口（宿主机会随机分配）
# 测试：启动并进入容器
docker run -it ubuntu /bin/bash
#for 循环启动容器
for i in {1..4} ;do
  docker run -d --name=nginxtest$i nginx:1.18.0 ;
done #启动 nginx
docker run -id --name=nginx1.18.0 -p 80:80 \
-v /docker_nginx/conf:/etc/nginx \
-v /docker_nginx/html:/usr/share/nginx/html \
-v /docker_nginx/logs:/var/log/nginx \
nginx:1.18.0
  1. 退出容器
1
2
3
#退出容器的两种方式
exit #run 进去 直接退出，容器停止
ctrl+p+q #run 进去 容器退出 容器不停止
  1. 列出正在运行的容器
1
2
3
4
5
6
7
8
9
10
docker ps # 列出当前正在运行的容器

# 命令参数可选项

-a # 列出当前正在运行的容器+历史运行过的容器
-n=? # 显示最近创建的容器（可以指定显示几条，比如-n=1）
-q # 只显示容器的编号
[root@heber ~]# docker ps -alnq
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAME
容器 ID 镜像 命令 创建时间 状态 端口 容器新名字
  1. 删除容器
1
2
3
4
docker rm 容器 id # 删除容器（不能删除正在运行的容器）如果要强制删除：docker rm -f 容器 id
docker rm -f $(docker ps -aq) # 删除全部容器
docker ps -a -q|xargs docker rm # 删除所有容器 #批量删除
for i in `docker ps -a|grep nginxtest|awk '{print $1}'`;do docker rm $i;done
  1. 启动已停止运行的容器
1
2
3
4
docker start 容器 id # 启动容器
docker restart 容器 id # 重启容器
docker stop 容器 id # 停止当前正在运行的容器
docker kill 容器 id # 强制停止当前容器
  1. 后台启动容器
1
2
3
docker run -d 容器名
# 常见的坑：docker 容器使用后台运行，就必须要有要一个前台进程，docker 发现没有应用，就会自动停止。
# 比如：nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

7.查看容器日志

1
2
3
4
5
docker logs -tf --tail 容器 id

# 参数选项
-tf # 显示日志
--tail number # 要显示的日志条数
  1. 查看容器内的进程
1
docker top 容器 ID
  1. 查看容器内部细节
1
docker inspect 容器 ID
  1. 进入正在运行的容器
1
2
3
4
5
docker exec -it 容器 id /bin/bash #一般选择这个
docker attach 容器 id

# docker exec # 进入容器后开启一个新的终端，可以再里面操作（常用）
# docker attach # 进入容器正在执行的终端，不会启动新的进程。
  1. 从容器拷贝数据到主机
1
2
docker cp 容器 id:容器内路径 目标主机路径
docker cp 667fa4fec647:/tmp/1.txt /tmp
  1. 导入和导出容器 #导出
1
2
3
docker export 容器 id >文件名.tar #导入
cat 文件名.tar | docker import-镜像用户/镜像名:镜像版本号
cat ubuntu.tar |docker import - ubuntu:18.0.0

六.小结练习

1.docker 安装 nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
1.搜索镜像： (建议去 dockerHub 上去搜索)
[root@localhost ~]# docker search nginx
2.下载镜像：docker pull nginx
[root@localhost ~]# docker pull nginx:1.8
3.启动 nginx：
[root@localhost ~]# docker run -d --name nginxtest -p 80:80 nginx
# -d 后台运行
# --name="nginxtest" 给容器命名
# -p 宿主机端口:容器内部端口
4.查看进程
[root@localhost ~]# docker ps
5.测试
http://ip:80

2.docker 安装 tomcat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1.搜索 Tomcat
[root@localhost ~]# docker search tomcat
2.下载镜像
docker pull tomcat:8
3.启动
docker run -d --name tomcattest -p 8080:8080 tomcat:8
4.查看进程
[root@localhost ~]# docker ps
5.进入容器
[root@localhost ~]# docker exec -it tomcattest /bin/bash
6.把 webapps.dist 文件夹下的文件复制到 webapps 文件夹下
root@6b278de8bce0:/usr/local/tomcat# cp -r webapps.dist/\* webapps/
7.退出保持后台运行
ctrl+q+p
8.测试
http://ip:8080

七.可视化 portainer

  1. portainer 是什么
    是一款轻量级的应用,它提供了图形化界面，用于方便管理 docker 环境，包括单机环境和集群环境
  2. 安装
1
2
3
4
5
#官网
https://www.portainer.io/
#安装并启动
docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart=always -v
/var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
  1. 访问
1
2
http://192.168.0.119:9000/
admin/admin123.

八.docker 镜像详解

  1. docker 镜像是什么
    镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件
    所需的所有内容，包括代码、运行时、库、环境变量和配置文件。 所有的应用，直接打包 docker 镜像，就可以直接跑起来！
    如何得到镜像：
  • 从远程仓库下载
  • 朋友拷贝给你
  • 自己制作一个镜像 DockerFile
  1. commit 镜像
    commit 提交容器副本使之成为一个新的镜像
    docker commit -m=”提交的描述信息” -a=”作者” 容器 id 目标镜像名:[TAG] #案列演示 Ubuntu 安装 vim
    apt-get update #更新包
    apt-get -y install vim #安装 vim
    docker commit -m=”Ubuntu_vim”-a”heber” a23fe6a14871 myubuntu:18.0.24
  2. 发布自己的镜像
    1.发布到 dockerhub 上
    https://hub.docker.com/注册自己的账号，确定这个账号可以登录在我们服务器上提交自己的镜像
1
2
3
#登录完毕后就可以提交镜像了
docker login -u username #登录
docker push 镜像名:[tag]

2.发布到阿里云上
登录阿里云账号，找到镜像容器服务，创建命名空间（一个账号只能创建 3 个命名空间），创建镜像仓库，浏览相关
操作命令。

1
2
3
docker login --username=username xxxxx
docker tag imageid xxxxxx #给镜像生成版本号
docker push 镜像名:[tag]

九.docker 容器数据卷

容器卷是什么?
将 docker 容器内的数据保存进宿主机的磁盘中
容器卷记得加入参数–privileged=true 表示开启权限

  1. 使用数据卷
    直接使用命令来挂载：-v
1
2
3
docker run -it --privileged=true -v /宿主机绝对路径:/容器内目录 镜像名
# 测试，查看容器信息
docker inspect 容器 id
  1. 测试安装 MySQL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#搜索 mysql
docker search mysql
#拉取 Tomcat 镜像
docker pull mysql
#查看下载好的镜像
docker images
#创建 mysql 配置文件等
mkdir /app/mysql
#运行 Tomcat
docker run -d -p 3306:3306 --privileged=true \
-v /app/mysql/log:/var/log/mysql \
-v /app/mysql/data:/var/lib/mysql \
-v /app/mysql/conf/:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=123456 \
--name mysql5.7 \
mysql:5.7
#进入配置
docker exec -it mysql /bin/bash
#登录 MySQL
mysql -uroot -p123456
  1. 匿名和具名挂载
    如何确定是具名挂载，还是匿名挂载，还是指定路径挂载
1
2
3
-v 容器内的路径 # 匿名挂载
-v 卷名:容器内的路径 # 具名挂载
-v /宿主机路径:容器内路径 # 指定路径挂载
  1. 拓展
    通过 -v 容器内的路径:ro rw 改变读写权限
1
2
3
4
5
6
ro read only # 只读
rw read write # 可读可写
# 一旦设置了容器权限，容器对我们挂载出来的内容就有了限定。
docker run -d -p 80:80 --name nginx -v my-nginx:/etc/nginx:ro nginx
docker run -d -p 80:80 --name nginx -v my-nginx:/etc/nginx:rw nginx
# 只要看到 ro 就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

十.dockerfile

  1. dockerfile 是什么？
    dockerfile 是用来构建 docker 镜像的文本文件命令脚本！。
    通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个一个的命令，每个命令都是一层！
    基础知识
  • 1、每个保留关键字（指令）都是必须是大写字母
  • 2、执行从上到下顺序执行
  • 3、# 表示注释
  • 4、每一个指令都会创建
    提交一个新的镜像层，并提交！
    容器之间可以相互同步，几个容器共享时只要删除其他容器之后还有一个存在里面的数据都不会丢失
1
2
docker run -it --name nginx02 --volumes-from nginx01 nginx:1.8 #解释
nginx02 --volumes-from nginx01 两个容器之间相互同步
  1. dockerfile 常用保留字指令
1
2
3
4
5
6
7
8
9
10
11
12
13
14
FROM #基础镜像，当前镜像是基于哪个镜像的，指定一个已经存在的镜像模板，第一条必须是 from
MAINTAINER #镜像维护者的姓名和邮箱地址
RUN #容器构建是需要运行的命令
EXPOSE #当前容器对外暴露的端口号
WORKDIR #指定在创建容器后终端默认登录进来的目录
USER #指定镜像以什么样的的用户去执行
ENV #用来在构建镜像过程中设置环境变量
ADD #将宿主机的文件拷贝进镜像且会自动处理 URL 和解压 tar 压缩包
COPY #拷贝文件和目录到镜像中
VOLUME #容器数据卷，用于数据保存和持久化工作
CMD #指定容器启动后要干的事，只有最后一个会生效
ENTRYPONIT #指定一个容器启动是要运行的命令
ONBUILD #当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 的指令。触发指令。
COPY # 类似 ADD，将我们文件拷贝到镜像中
  1. 实例 #创建 dockerfile 文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
vim Dockerfile
FROM centos
MAINTAINER heber<heber@123.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
#安装vim
RUN yum -y install vim
#安装ifconfig
RUN yum -y install net-tools
#安装Java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#添加Java包
ADD Jdk-8u171-linux-x64.tar.gz /usr/local/java
#配置Java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:PATH
EXPOSE 8080
CMD echo $MYPATH
CMD echo 'success......ok'
CMD /bin/bash
  1. 构建
1
docker build dockerfilename -t 镜像名字:tag .
  1. 查看已经构造的镜像
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[root@localhost ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat 8 2d2bccf89f53 13 months ago 678MB
mysql 5.7 c20987f18b13 13 months ago 448MB
portainer/portainer latest 580c0e4e98b0 22 months ago 79.1MB
nginx 1.8 0d493297b409 6 years ago 133MB
[root@localhost ~]# docker history 0d493297b409
IMAGE CREATED CREATED BY SIZE
COMMENT
0d493297b409 6 years ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon … 0B
<missing> 6 years ago /bin/sh -c #(nop) EXPOSE 443/tcp 80/tcp 0B
<missing> 6 years ago /bin/sh -c ln -sf /dev/stdout /var/log/nginx… 22B
<missing> 6 years ago /bin/sh -c apt-key adv --keyserver hkp://pgp… 8.19MB
<missing> 6 years ago /bin/sh -c #(nop) ENV NGINX_VERSION=1.8.1-1~… 0B
<missing> 6 years ago /bin/sh -c #(nop) MAINTAINER NGINX Docker Ma… 0B
<missing> 6 years ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0B
<missing> 6 years ago /bin/sh -c #(nop) ADD file:2ed80fd333c2052ad… 125MB
  1. 实战 tomcat 镜像
    准备镜像文件：tomcat 压缩包，jdk 的压缩包！
    编写 dockerfile 文件，官方命名 Dockerfile ，build 会自动寻找这个文件，就不需要-f 指定文件名了！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FROM centos:7
MAINTAINER heber<heber@163.com>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u271-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.5.tar.gz /usr/local/
RUN yum -y install vim
RUN yum -y install net-tools
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_271
ENV CLASS_PATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.5
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.5
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.5/bin/startup.sh && tail -F /usr/local/apache-tomcat-
9.0.5/bin/logs/catalina.out

十一. docker 网络

linux 是可以 ping 通容器的网络的。容器和容器之间也是可以相互 ping 通的。只要容器一删除，对应的一对网桥就一起被删除。
我们每启动一个 docker 容器，docker 就会给 docker 容器分配一个 ip，我们只要安装了 ddcker，就会有一个网卡 docker0（桥接模式，使用的技术是 veth-pair 技术）

  1. 查看容器的内部网络地址
1
docker exec -it 容器 id ip addr
  1. 容器互联 link
    编写了一个微服务，database url=ip:，项目不重启，数据库 ip 换掉了，我们希望可以处理这个问题，可以用名字来进行访问容器
1
2
docker run -d -P --name tomcat03 --link tomcat02 tomcat:8.0
#这个操作就是在/etc/hosts 配置了解析
  1. 查看 docker 网络模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[root@localhost ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
dc2cbff90c52 bridge bridge local
f3a59ab02850 host host local
c130e4e8fe19 none null local
bridge #为每一个容器分配，设置 ip，并将容器连接到 docker0
host #容器不会虚拟出自己的网卡，配置自己的 ip，而是用宿主机的 ip 和端口
none #容器有独立的 network namespace ，但是并没有对其进行网络分配
container #共享一个 ip #查看详细信息
[root@localhost ~]# docker network inspect dc2cbff90c52 |grep bridge
        "Name": "bridge",
        "Driver": "bridge",
          "com.docker.network.bridge.default_bridge": "true",
          "com.docker.network.bridge.enable_icc": "true",
          "com.docker.network.bridge.enable_ip_masquerade": "true",
          "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
          "com.docker.network.bridge.name": "docker0",
#docker 网络能干嘛？
容器间的互联和通信以及端口映射
  1. 自定义网络
1
2
3
4
5
6
7
# 我们直接启动的命令--net bridge（这个就是我们的 docker0）；默认带上这个参数的，以下两种启动方式效果一致。
docker run -d -P --name tomcato1 --het bridge tomcat
# docker0 特点：默认，域名不能访问，--1ink 可以打通连接！
# 我们可以自定义一个网络！
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet #启动两个容器测试：
docker run -d -P --name tomcat-net-01 --net mynet tomcat:7.0
docker run -d -P --name tomcat-net-02 --net mynet tomcat:7.0 #自定义的网络不适用--link 也可以使用名字通信
  1. 网络连通
    tomcat01 在 docker0 网络下，tomcat-net-01 在 mynet 网络下；
    tomcat01 ping tomcat-net-01 是 ping 不通的
1
2
3
4
5
6

# 测试：打通 tomcat01 连接 mynet
docker network connect mynet tomcat01
# 连通之后就是将 tomcat01 放到了 mynet 网络下
# 一个容器两个 ip 地址！I
# 阿里云服务：公网 ip 和私网 ip

十二.docker_compose 容器编排

  1. 是什么
    docker_compose 是 docker 官方开源项目，负责实现对 docker 容器集群的快速编排，多服务管理工具
  2. 能干嘛
    用来管理容器实例
    compose 允许用户通过一个单独的 docker_compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目
  3. 去哪里下
1
2
3
4
5
6
7
8
9
10
#官网下载
https://docs.docker.com/compose/install
#安装
curl -L https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-linux￾x86_64 -o usr/local/bin/docker-compose
#授权
chmod +x /usr/local/bin/docker-compose
#测试安装
docker-compose version
#卸载
rm -f /usr/local/bin/docker-compose
  1. conpose 核心概念 #一个文件
    docker-compose.yml #
    两大要素
    服务 #一个个应用容器实例
    工程 #由一组关联的应用容器组成的完整业务单元，在 docker-compose.yml 文件中定义
  2. compose 常用命令
1
2
3
4
5
6
7
8
9
10
11
12
13
docker-compose -h #查看帮助
docker-compose up #启动所有 docker-compose 服务
docker-compose up -d #启动所有 docker-compose 服务并后台启动
docker-compose down #停止并删除容器，网络，卷，镜像
docker-compose exec yml 里面的服务 id #进入容器内部实例
docker-compose ps #展示当前编排过的运行的所有容器
docker-compose top #展示当前编排过的容器进程
docker-compose logs yml 容器 id #查看容器输出日志
docker-compose config #检查配置
docker-compose config -q #检查配置，有问题的才输出
docker-compose start #启动服务
docker-compose restart #重启服务
docker-compose stop #停止服务
  1. conpose 编排微服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#编写docker-compose.yml
vim docker-conpose.yml
version:"3" #版本
servers:
  microSerice:
  image:heber_docker:1.8 #选择镜像
  container_name:ms01 #名字
  ports: #端口
    -"6001:6001"
  volumes: #容器数据卷
    - /app/microSerice:/data
  networks: #网卡
    - heber_net
  depends_no: #备注需要的依赖
    - redis
    - mysql
redis:
  image:redis:6.0.8 #选择镜像
  ports: #端口
    -"6379:6379"
  volumes: #容器数据卷
    - /app/redis/redis.conf:/etc/redis/redis.conf
    - /app/redis/data:/data
  networks: #网卡
    - heber_net
  command:redis-server /etc/redis/redis.conf
nginx:
  image: nginx:1.8
  container_name: nginx
  restart: always
  ports:
    - "80:80"
    - "443:443"
  volumes:
    - /nginx/conf/nginx.conf:/etc/nginx/nginx.conf
    - /nginx/conf.d:/etc/nginx/conf.d
    - /nginx/html:/usr/share/nginx/html
    - /nginx/logs:/var/log/nginx
  networks:
    - heber_net

networks:
  heber_net:

mysql:
  image:mysql:5.7 #选择镜像
  environment:
    MYSQL_ROOT_PASSWORD:"123456"
    MYSQL_ALLOW_EMPTY_PASSWORD:"no"
    MYSQL_DATABASE:"db2022"
    MYSQL_USER:"heber"
    MYSQL_PASSWORD:"heber123"
  ports: #端口
    -"3306:3306"
  volumes: #容器数据卷
    - /app/mysql/db:/var/lib/mysql
    - /app/mysql/conf/my.cnf:/etc/my.cnf
    - /app/mysql/init:/docker-entrypoint-initdb.d
  networks: #网卡
    - heber_net
  command:--default-authentication-plugin=mysql_native_password #解决外部无法访问
networks: #创建网卡
  heber_net
  1. nginx+tomcat+mysql
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
version: "3"
services:
  nginx:
  image: nginx:1.8
  container_name: nginx
  expose:
    - 80
    - 443
  ports:
    - 80:80
    - 443:443
  volumes:
    - /data/nginx/nginx.conf:/etc/nginx/nginx.conf
    - /data/nginx/html:/usr/share/nginx/html
    - /data/nginx/nginx/conf.d:/etc/nginx/conf.d
    - /data/nginx/logs:/var/log/nginx
  restart: always
  networks:
    - wd_net
  depends_on:
    - tomcat

  tomcat:
    image: tomcat:9.0.71
    container_name: tomcat9
    ports:
      - 8080:8080
    volumes:
      - /data/tomcat/:/usr/local/tomcat/webapps
    networks:
      - wd_net
    links:
      - mysql

# mysql:
  mysql:
    image: mysql:5.7
    container_name: mysql
    expose:
      - 3306
    ports:
      - 3306:3306
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
      TZ: Asia/Shanghai"
    restart: always
    volumes:
      - /data/mysql/db:/var/lib/mysql
      - /data/mysql/init:/docker-entrypoint-initdb.d
    networks:
      - wd_net
    command: --character-set-server=utf8 --collation-server=utf8_general_ci
networks:
  wd_net:

十三.docker swarm

docker swarm 用来做集群使用，地址：https://docs.docker.com/engine/swarm/
准备 2 台服务器，并且都安装上 docker
有两种类型的节点：管理节点，工作节点

  1. swarm 集群搭建
    docker swarm --help 可以查看命令
1
2
3
4
5
6
7
8
9
10
11
12
#初始化，ip 就是主节点的 ip
docker swarm init --advertise-addr ip
#加入一个节点，获取令牌，manager 是创建集群节点，worker 为工作节点
docker swarm join-token manager
docker swarm join-token worker
#从节点执行
docker swarm leave
#docker swarm join --token SWMTKN-1-431qyos84ddcg096l7qvvrrc1b3n45wuai36sxv44vhu0hnwei￾c3elgflbtmf5cdm2ql32xt0kt 36.111.190.72:2377
#查看加入的节点
docker node ls
#解散集群
docker swarm leave --force
  1. 删除工作节点
1
2
3
#想要删除工作节点需要现在工作节点执行
docker swarm leave #然后在 master 节点执行
docker node rm docker-node1
  1. 查看集群中节点信息
1
docker node inspect docker-node1 --pretty
  1. 调度
1
2
3
4
5
6
#调度程序可以将任务分配给节点
docker node update --availability active docker-node1
#调度程序不向节点分配新任务，但是现有任务仍然保持运行
docker node update --availability pause docker-node1
#调度程序不会将新任务分配给节点。调度程序关闭任何现有任务并在可用节点上安排它们. 也就是线下节点,不参与任务分配.
docker node update --availability drain docker-node1
  1. 标签
1
2
3
#添加节点标签
docker node update --label-add label1 docker-node1 #删除节点标签
docker node update --label-rm label1 docker-node1
  1. manager 与 worker 互换
1
2
3
#将 worker 节点升级为 manager 节点
docker node promote docker-node1 #将 manager 节点降级为 worker 节点
docker node demote docker-node1
  1. 服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#查看服务列表
docker service ls
#查看服务的具体信息
docker service ps my-test
#创建一个指定 name 的服务
docker service create --name my-nginx nginx:1.18.0
#删除一个服务
docker service rm my-nginx
#创建一个指定 name、port、replicas 的服务
docker service create --name my-nginx --replicas 2 -p 80:80 nginx:1.18.0
#为指定的服务更新一个端口
docker service update --publish-add 80:80 my-nginx
#为指定的服务删除一个端口
docker service update --publish-rm 80:80 my-nginx
#将 redis:3.0.6 更新至 redis:3.0.7
docker service update --image redis:3.0.7 redis
#配置运行环境，指定工作目录及环境变量
docker service create --name my-nginx --env MYVAR=myvalue --workdir /data/www --user my_user
nginx
#创建群组并配置 cpu 和内存
docker service create --name my_nginx --reserve-cpu 2 --reserve-memory 512m --replicas 3
nginx
#更改所分配的 cpu 和内存
docker service update --reserve-cpu 1 --reserve-memory 256m my_nginx