docker使用

文章目录

1 安装docker
2 docker使用
3 docker容器编排compose
4 swarm跨主机容器编排
5 容器可视化工具 portainer

1 安装docker

准备一台虚拟机centos7.9的系统
虚拟化 virtualization ：模拟出来的，不是物理的，算真的
容器技术：container 存放东西的地方
容纳别的东西的器皿
docker，containerd，k8s等
虚拟化技术：
vmware： workstation 入门级的产品
docker：容器技术的经典代表
CNCF 云原生基金会 : google redhat ibm等: k8s（kubernetes）： containerd（容器运行时软件）
docker是容器运行时软件–》容器软件
k8s是管理容器运行时软件（docker，containerd，rkt等）集群的软件 --》k8s理解为管理docker集群的软件
k8s建立在docker之上的软件
docker和k8s都是使用go语言开发的
只要是与k8s相关的技术都叫云原生相关的技术
docker的安装
https://docs.docker.com/engine/install/centos/

1.卸载原来安装过的docker，如果没有安装可以不需要卸载
yum remove docker
docker-client
docker-client-latest
docker-common
docker-latest
docker-latest-logrotate
docker-logrotate
docker-engine
2.安装yum相关的工具，下载docker-ce.repo文件
[root@cali ~]#
[root@cali ~]# yum install -y yum-utils -y
[root@cali ~]#yum-config-manager
–add-repo
https://download.docker.com/linux/centos/docker-ce.repo
下载docker-ce.repo文件存放在/etc/yum.repos.d
[root@cali yum.repos.d]# pwd
/etc/yum.repos.d
[root@cali yum.repos.d]# ls
CentOS-Base.repo CentOS-Debuginfo.repo CentOS-Media.repo CentOS-Vault.repo docker-ce.repo
CentOS-CR.repo CentOS-fasttrack.repo CentOS-Sources.repo CentOS-x86_64-kernel.repo nginx.repo
[root@cali yum.repos.d]#
3.安装docker-ce软件
container engine 容器引擎
docker是一个容器管理的软件
docker-ce 是服务器端软件 server
docker-ce-cli 是客户端软件 client
docker-compose-plugin 是compose插件，用来批量启动很多容器，在单台机器上
containerd.io 底层用来启动容器的
[root@cali yum.repos.d]# yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y
[root@cali yum.repos.d]# docker --version
Docker version 20.10.17, build 100c701
[root@cali yum.repos.d]#
4.启动docker服务
[root@cali yum.repos.d]# systemctl start docker
[root@cali yum.repos.d]# ps aux|grep docker
root 1892 1.4 1.5 1095108 58972 ? Ssl 11:39 0:00 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
root 2029 0.0 0.0 112824 976 pts/0 S+ 11:40 0:00 grep --color=auto docker
5.设置docker服务开机启动
[root@cali yum.repos.d]# systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
[root@cali yum.repos.d]#

Docker Desktop release notes | Docker Docs docker对应的版本问题

6.如果无法下载可以添加代理，修改/etc/yum.conf 添加这一行 proxy=http://192.168.60.157:7890

# 由于docker被墙，所以必须使用代理的形式来下载
vim  /etc/systemd/system/multi-user.target.wants/docker.service
[Service] #在这个层次结构中添加
Environment=HTTP_PROXY=http://192.168.60.157:7890
Environment=HTTPS_PROXY=http://192.168.60.157:7890
Environment=NO_PROXY=localhost,127.0.0.1

2 docker使用

[root@cali yum.repos.d]# docker ps 查看有哪些docker容器在运行
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

[root@cali yum.repos.d]# docker images 查看有哪些容器
REPOSITORY TAG IMAGE ID CREATED SIZE

镜像里面包含了我们需要的软件的代码和基础环境，以及依赖软件
[root@cali yum.repos.d]# docker pull nginx 下载nginx的镜像

[root@cali yum.repos.d]#启动docker容器启动一个容器，可以理解为开启一台虚拟机
[root@cali yum.repos.d]# docker run -d -p 8090:80 --name test-nginx nginx
bda1e5c73838b5e48e711f27f3473f1749006786c28e061a9469f49e93439e32

docker run 是启动容器的命令
 -d 在后台运行 daemon 守护进程
-p 8090:80  指定端口映射    DNAT 访问本机的8090端口，转发到docker容器的80端口
--name  test-nginx  指定容器的名字
 nginx 是镜像的名字

[root@rabbit4-64 yum.repos.d]# docker ps -a 查看所有的容器，包括停止的
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f3fbd6026ce6 nginx “/docker-entrypoint.…” About a minute ago Up About a minute 0.0.0.0:8090->80/tcp, :::8090->80/tcp test-nginx

[root@cali yum.repos.d]# service firewalld stop (建议关闭防火墙)
Redirecting to /bin/systemctl stop firewalld.service
[root@cali yum.repos.d]# service docker restart（防火墙关闭后，docker需要重启）
Redirecting to /bin/systemctl restart docker.service

[root@rabbit4-64 yum.repos.d]# docker restart test-nginx
test-nginx

2.1使用docker容器

[root@cali yum.repos.d]# docker exec -it test-nginx /bin/bash 进入容器
17 apt update
18 apt install vim 下载使用vim

root@f3fbd6026ce6:/etc/nginx/conf.d# pwd
/etc/nginx/conf.d
root@f3fbd6026ce6:/etc/nginx/conf.d# ls
default.conf web_text.conf
root@f3fbd6026ce6:/etc/nginx/conf.d#
注意点：当使用vim，复制粘贴时，需要在输入 :set mouse= 然后点击右键，就可以复制粘贴了

2.2访问启动容器的端口

[root@rabbit4-64 yum.repos.d]# curl 192.168.70.64:8090
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>
[root@rabbit4-64 yum.repos.d]# netstat -nltp|grep 8090
tcp        0      0 0.0.0.0:8090            0.0.0.0:*               LISTEN      29459/docker-proxy  
tcp6       0      0 :::8090                 :::*                    LISTEN      29465/docker-proxy

2.3 docker中的命令

service docker restart   #会导致所有的正在运行的容器停止
iptables -F -t nat   #清空nat表的规则会导致容器网路故障，外面的机器无法访问进来，因为本质上清空了snat和dnat规则

docker ps    #查看正在运行的容器
docker ps -a   #查看所有的容器（包括没有运行的）
docker start nginx-1   #启动nginx-1镜像
docker stop nginx-1    #关闭nginx-1镜像
docker version   #查看docker版本信息 
docker images    #查看docker里有哪些镜像 
docker search nginx    #从docker官网搜索nginx
docker rmi nginx-1  #删除名为nginx-1的镜像
docker rm nginx-1   #删除名为nginx-1的容器
docker rm -f nginx_env  #删除正在启动的nginx_env容器
docker pull nginx   #从docker官网拉下nginx 
docker logs nginx-1 #查看容器的日志

docker exec -it nginx-1  /bin/bash    #进入名为nginx-1的容器的内部
docker cp hh.txt nginx-1:/    #将宿主机的当前目录下的 hh.txt文件 复制到 容器nginx-1的 / 目录 下
docker cp nginx-1:/docker-entrypoint.sh .   #将容器nginx-1的 / 目录下的 .sh 复制到宿主机的当前目录

docker run = docker create + docker start + docker pull
docker run -d -p 80:80 --name nginx-1 nginx
docker kill nginx-2  #杀死容器nginx-2

docker built -t：生成镜像， -t：指定镜像的名字。

docker run = docker create + docker start + docker pull
docker create：生成容器，没有运行
#例：docker create -p 7700:80 --name nginx-2 nginx:1.22.0  基于nginx:1.22.0镜像创建容器nginx-2， 7700是宿主机端口，80是容器内部端口
如果需要启动这个这个容器   docker start nginx-2
进入这个容器：docker exec -it nginx-2  /bin/bash    #进入名为nginx-2的容器的内部
使用docker run  一步完成
docker run -p 7700:80 --name nginx-2 -d nginx:1.22.0

docker run -p 7700:80 --rm --name nginx-2 -d nginx:1.22.0 #会启动这个ngnx-2这个容器，但是当docker stop nginx-2后，表示退出容器时，同时删除容器，使用docker ps -a无法查看到这个容器
docker inspetct nginx-1   #查看容器nginx-1的详细信息
docker logs nginx-1   #查看容器nginx-1容器启动的过程中的日志，用于排错
docker top nginx-1    #查看容器nginx-1内部的进程
docker info     #显示docker软件更加详细的信息
docker stats    #查看容器的资源消耗
docker plugin xx  #安装插件
#例：docker plugin install --grant-all-permissions vieux/sshfs

docker history nginx     #查看镜像的历史

2.4 docker数据存储volume

当你在运行 nginx 容器时没有显式指定数据卷挂载，nginx 的数据会存储在容器的内部。这些数据通常位于容器的文件系统中，而不是宿主机上。如果容器被删除，这些数据也会被删除。如果想要持久化存储在本地，可以使用-v这个选项。

1 第一种方式
docker run -p 7700:80 --name nginx-2 -v /srv/nginx-data:/usr/share/nginx/html -d nginx:1.22.0
nginx 容器中的 /usr/share/nginx/html 目录中的数据就会持久化存储在宿主机的 /srv/nginx-data 目录中。
可以使用docker inspect nginx-2  查看挂载情况
2 第二种方式 创建卷
docker volume create my-vol   #创建卷my-vol
docker volume rm myvolume    # 删除卷
docker volume inspect my-vol  #查看卷的详细信息
docker run -d --name nginx-3 --mount source=my-vol,target=/app -p8805:80  nginx
存储在/var/lib/docker/volumes/my-vol/_data/目录下

注意点；当两个容器共用一个volume，那么就会实现文件共享
测试：
docker volume create my-vol-1
docker run -d --name container1 -v my-vol-1:/test nginx
docker run -d --name container2 -v my-vol-1:/test nginx
[root@rabbit4-64 test]# docker exec -it container1 /bin/bash
root@16b3805b80b1:/# echo "Hello from container1" > /test/hello.txt
root@16b3805b80b1:/# exit
exit
[root@rabbit4-64 test]# docker exec -it container2 /bin/bash
root@1f5e6d1cb31a:/# cat /test/hello.txt 
Hello from container1
root@1f5e6d1cb31a:/# 

[root@rabbit4-64 my-vol-1]# cd _data/
[root@rabbit4-64 _data]# ls
hello.txt
[root@rabbit4-64 _data]# cat hello.txt 
Hello from container1
[root@rabbit4-64 _data]# pwd
/var/lib/docker/volumes/my-vol-1/_data  #本地的数据存储文件
[root@rabbit4-64 _data]# 

# 绑定方式 匿名绑定  具名绑定  Bind Mount
匿名绑定 ：容器删除，数据卷也会被删除（也就是绑定在宿主机上面的数据）。
命令：docker run --rm -d -p 8090:80 --name nginx_volume -v /usr/share/nginx/html nginx  #其中/usr/share/nginx/html下的是容器内的文件路径，但是并没有绑定在宿主机中
docker inspect nginx_volume
        "Mounts": [
            {
                "Type": "volume",
                "Name": "f594badeea0132176816de9b984d7f697fb9992e888eb668ff94046a6dcc067c",
                "Source": "/var/lib/docker/volumes/f594badeea0132176816de9b984d7f697fb9992e888eb668ff94046a6dcc067c/_data",
                "Destination": "/usr/share/nginx/html",
                "Driver": "local",

[root@rabbit4-64 wolfcode.cn]# cd /var/lib/docker/volumes/f594badeea0132176816de9b984d7f697fb9992e888eb668ff94046a6dcc067c/_data
[root@rabbit4-64 _data]# ls #可以通过修改index.html文件，达到修改容器内部的文件内容。也就是/usr/share/nginx/html下的index.html
50x.html  index.html

[root@rabbit4-64 _data]# docker ps 
CONTAINER ID   IMAGE     COMMAND                   CREATED         STATUS         PORTS                                   NAMES
5a9c730017cc   nginx     "/docker-entrypoint.…"   7 minutes ago   Up 7 minutes   0.0.0.0:8090->80/tcp, :::8090->80/tcp   nginx_volume
[root@rabbit4-64 _data]# docker volume ls
DRIVER    VOLUME NAME
local     f594badeea0132176816de9b984d7f697fb9992e888eb668ff94046a6dcc067c
[root@rabbit4-64 _data]# docker stop nginx_volume
nginx_volume
[root@rabbit4-64 _data]# docker volume ls
DRIVER    VOLUME NAME


具名绑定：容器删除，并不会删除宿主机中/var/lib/docker/volumes/nginx-html/_data的内容
 docker run --rm -d -p 8090:80 --name nginx_volume -v nginx-html:/usr/share/nginx/html nginx
 [root@rabbit4-64 _data]# docker volume ls
 local     nginx-html
 docker inspect nginx_volume
 
         "Mounts": [
            {
                "Type": "volume",
                "Name": "nginx-html",
                "Source": "/var/lib/docker/volumes/nginx-html/_data",
                "Destination": "/usr/share/nginx/html",
可以使用docker volume rm 删除volume


Bind Mount :实现将宿主机中的某个目录绑定在容器中
docker run --rm -d -p 8090:80 --name nginx_volume -v /www/wolfcode.cn:/usr/share/nginx/html nginx 将容器内的文件和宿主机中的文件共享

[root@rabbit4-64 ~]# docker volume ls # 此时并没有创建volume。如果删除容器，并不会对本地的宿主机的目录又影响
DRIVER    VOLUME NAME


相关命令：
docker volume create 
docker volume inspect 
docker volume ls
docker volume rm

2.5 docker中的四种网络模式

host container none bridge 默认事bridge

Docker四种网络模式（Bridge，Host，Container，None） - 大数据老司机 - 博客园 (cnblogs.com)

https://blog.csdn.net/succing/article/details/122433770

Docker0网络及原理探究 - 知乎 (zhihu.com)

bridge模式     在桥接模式下，Docker会为每个容器创建一个虚拟以太网桥（docker0）。当你创建一个使用桥接模式的容器时，Docker会为该容器分配一个虚拟网卡，并将该网卡连接到docker0桥上。每个容器都有自己的IP地址和MAC地址，并且它们可以通过docker0桥相互通信。Docker守护进程会提供网络地址转换（NAT）功能，使得容器可以与外部网络通信。默认为docker0 相当于中间加了一张docker0的虚拟网卡
host模式       容器和宿主机共享ip地址，这意味着容器将使用宿主机的网络栈，与宿主机拥有相同的 IP 地址。在这种情况下，容器之间通过端口来区分，不同的容器可以通过不同的端口与外部通信。假设是在宿主机中使用了host模式开启了一个nginx的80端口，那么可以通过浏览器宿主机ip+端口，访问到容器内的资源
none模式       使用none模式，Docker容器拥有自己的Network Namespace，但是，并不为Docker容器进行任何网络配置。也就是说，这个Docker容器没有网卡、IP、路由等信息。
container模式  使用 container 网络模式会为每个容器分配一个独立的 IP 地址，并且所有容器共用同一个网卡，因此它们之间可以通过 IP 地址进行通信，而不需要通过端口。这种模式下，Docker 使用网桥来连接容器和宿主机之间的网络，每个容器都被分配一个唯一的 IP 地址，这些地址可以在容器之间直接使用。

#第五种网络类型：
#overlay    目前最主流的容器跨节点数据传输和路由方案
用于连接不同机器上的docker容器，允许不同机器上的容器相互通信，同时支持对消息进行加密。--》实现跨主机的docker容器进行通信
#底层原理：VXLAN

container模式测试：
container模式：
docker run -d --name nginx_Numl nginx:alpine
docker run -d --name tomcat_Second  --net=container:nginx_Num1 tomcat:8.5.46-jdk8-openjdk
这两个命令是用来在 Docker 中创建并运行容器的。
docker run -d --name nginx_Num1 nginx:alpine: 这个命令的含义是在后台以守护进程模式（-d选项）运行一个名为nginx_Num1的容器，使用nginx:alpine镜像来创建该容器。--name选项用于指定容器的名称为nginx_Num1，而nginx:alpine是一个轻量级的Nginx服务器镜像，基于Alpine Linux操作系统。这个容器将运行Nginx服务器。
docker run -d --name tomcat_Second --net=container:nginx_Num1 tomcat:8.5.46-jdk8-openjdk: 这个命令的含义是在后台以守护进程模式（-d选项）运行一个名为tomcat_Second的容器，并且将其连接到nginx_Num1容器的网络命名空间（--net=container:nginx_Num1选项）。这样，tomcat_Second容器将共享nginx_Num1容器的网络栈，可以直接访问nginx_Num1容器内部的网络资源。这个容器使用tomcat:8.5.46-jdk8-openjdk镜像创建，这是一个包含了Tomcat 8.5.46和OpenJDK 8的镜像，用于运行Java Web应用。
综上所述，第二个命令创建了一个名为tomcat_Second的Tomcat容器，并将其连接到了nginx_Num1容器的网络中，使得Tomcat容器能够直接访问Nginx容器提供的服务。

该模式≈bridge+host的混合模式，指定一个容器以bridge方式启动，后面容器启动时指定网络模式为container，它们自动共享第一个容器的网络资源.
这个模式指定新创建的容器和已经存在的一个容器共享一个 Network Namespace，而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的 IP，而是和一个指定的容器共享 IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。两个容器的进程可以通过 lo 网卡设备通信。

2.6 docker的三种状态

up
created
exited    说明容器没有启动  exited(1)：故障导致退出  exited(0)：正常退出

2.7 镜像的制作以及导入和导出

#save 与 load
#导出机器上： 导出镜像  
docker save mysql:5.7.41 >mysql-5.7.41.tar  或者   docker save mysql:5.7.41 -o mysql-5.7.41.tar
scp mysql-5.7.41.tar  heyuxin@192.168.237.140:~
#导入机器上： 导入镜像
sudo docker load  > mysql-5.7.41.tar   或者   sudo docker load  -i mysql-5.7.41.tar 

#export 与 import
docker export mysql_container mysql.tar 
docker import nginx.tar nginx:1.23.1
#export：导出正在运行的容器里的文件系统，变成一个归档文件。里面可能新增某些文件等。

docker save&load：导出静态的镜像。
docker export&import：导出动态的运行在容器里的镜像。

docker export和import使用
[root@rabbit4-64 nginx-demo]# docker export  8c8b571b793b  > my_nginx.tar
[root@rabbit4-64 nginx-demo]# ls
my_nginx.tar

新机器导入：
[root@rabbit3-63 app]# docker import my_nginx.tar my_nginx:latest
sha256:281aeeb1fb5782d1431e786f5724e33a44c8dbe51b7239bee032d6afe63b80af
[root@rabbit3-63 app]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
my_nginx     latest    281aeeb1fb57   About a minute ago   547MB
但是导入后，并没有办法实现启动
[root@rabbit3-63 app]# docker run -d -P my_nginx:latest
docker: Error response from daemon: no command specified.
See 'docker run --help'.
# 原因：使用 docker export 和 docker import 会丢失一些元数据。如CMD 等
[root@rabbit3-63 app]# docker run -d --rm -P my_nginx:latest nginx
e46368d61387e92ab7756b8aa6fe545352ffdebabe93140faea53c5b778ea365
docker: Error response from daemon: failed to create task for container: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "nginx": executable file not found in $PATH: unknown.
[root@rabbit3-63 app]# docker run -it --rm my_nginx:latest /bin/bash
[root@ac58a0424449 /]# which nginx
bash: which: command not found
[root@ac58a0424449 /]# nginx -V
bash: nginx: command not found

2.8 容器的重启策略

no，默认策略，在容器退出时不重启容器---------任何时候都不重启容器（可以理解为躺平策略）。
on-failure，在容器非正常退出时（退出状态非0），才会重启容器，------退出状态码非0的时候重启，直到状态码为0为止，不限次数的重启。
on-failure:3，在容器非正常退出时重启容器，最多重启3次，三次之后是什么样就什么样了。-----退出状态码非0的时候重启，直到状态码为0为止。
always，在容器退出时总是重启容器，直到正常。------下面的全部状态码的时候重启。
unless-stopped，在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器，也就是说，如果docker的守护进程启动后，然后因为一些其它原因导致容器退出，将不会重启容器。----------退出状态码不是0,125，126,127的时候。

docker run -d --name nginx-3 -P --restart on-failure:3 nginx  # -P 表示的含义，将容器内部的端口总是暴露出来，此时宿主机的端口是随机的
[root@rabbit4-64 _data]# docker ps
CONTAINER ID   IMAGE          COMMAND                   CREATED         STATUS          PORTS                                     NAMES
ec5fbddc40a4   nginx          "/docker-entrypoint.…"   4 seconds ago   Up 1 second     0.0.0.0:32768->80/tcp, :::32768->80/tcp   nginx-3
docker run -d --name nginx-3 -P --restart always nginx

2.9 docker容器环境变量

[root@rabbit4-64 _data]# docker run -d -P --name nginx_env -e JAVA_ENV=dev -e JAVA_VM=G1 nginx
ac18646afcbc69040045f07398bfef8723a657cb716df2e6906be0ea63642630
[root@rabbit4-64 _data]# docker ps -a
CONTAINER ID   IMAGE          COMMAND                   CREATED         STATUS                     PORTS                                     NAMES
ac18646afcbc   nginx          "/docker-entrypoint.…"   4 seconds ago   Up 2 seconds               0.0.0.0:32770->80/tcp, :::32770->80/tcp   nginx_env

使用docker inspect nginx_env查看环境变量
            "Env": [
                "JAVA_ENV=dev",
                "JAVA_VM=G1",
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "NGINX_VERSION=1.25.4",
                "NJS_VERSION=0.8.3",
                "PKG_RELEASE=1~bookworm"
                
docker exec -it nginx_env env  # 查看容器内的环境变量
[root@rabbit4-64 _data]# docker exec -it nginx_env env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=ac18646afcbc
TERM=xterm
JAVA_ENV=dev
JAVA_VM=G1
NGINX_VERSION=1.25.4
NJS_VERSION=0.8.3
PKG_RELEASE=1~bookworm
HOME=/root

2.10 docker中限制资源 cpu 内存

 docker run -d --rm -m 8m nginx  # -m指定内存 8M  
docker stats confident_chatelet # 表示查看这个容器的资源使用如何
输出为：
CONTAINER ID   NAME                 CPU %     MEM USAGE / LIMIT   MEM %     NET I/O     BLOCK I/O     PIDS
4a8cd2829b97   confident_chatelet   0.00%     3.496MiB / 8MiB     43.70%    656B / 0B   0B / 3.07kB   5

docker run -d --rm -m 8m --cpus 1 nginx # 限制cpu

2.11 Dockerfile使用

https://blog.csdn.net/weixin_67287151/article/details/130264947

FROM    指定基础镜像使用哪个操作系统，安装必备的软件
WOKDIR    工作目录          指定进入容器时，在哪个目录下
RUN      制作镜像的时候，在容器内运行的命令，用一次镜像就加一层，所以要尽量减少RUN的次数
ENTRYPOINT    进入容器就执行的命令
CMD    只有CMD没有ENTRYPOINT，以CMD为准
    #当ENTRYPOINT和CMD都存在的时候，CMD里的内容会成为ENTRYPOINT里的参数(位置参数)。
EXPOSE   开放某个端口，非必需。 
STOPSIGNAL  停止信号，当发xx信号时，停止运行
ENV     环境变量   后面接：变量名   变量值
VOLUME   将容器里的某个路径挂载到宿主机的卷上
LABEL   标签，标记
ARG     在制作镜像时使用，用于传递参数。 argument

COPY     复制宿主机里的文件或者目录到容器里的某个目录下。
ADD      同COPY，而且当复制的是.tar.gz压缩文件时，拷贝到容器里会自动解压。



# ARG赋值
ARG jdk=8
# 指定基础的镜像
FROM openjdk:$jdk
# 指定镜像作者等
MAINTAINER  wolfcode<2985610575@qq.com>
# 设置标签
LABLE version="1.0"
LABLE description="这个是我的第一个镜像"
# 设置环境变量

# 整个dockfile都要考mysql这个用户来操作  所以需要注意用户的权限问题
USER mysql

ENV JAVA_ENV dev
ENV APP_NAME test-dockerfile

# run 在构建镜像时，需要执行的shell命令
RUN ls -al
RUN mkdir /www/dockerfile/test

# 将宿主机的文件复制到容器中的位置
ADD /www/wolfcode.cn/index.html  /www/server

# 设置容器中的工作目录，类似于cd命令。如果该目录不存在，就会自动创建
WORKDIR  /app
RUN pwd

# 数据卷绑定，将容器中的/www/wolfcode.cn匿名绑定在宿主机
VOLLUME ["/www/wolfcode.cn"]

# 设置容器启动后要暴露的端口8080,但是并没有跟宿主机内的端口进行关联
EXPOSE 8080

# CMD 和 ENTRYPOINT选择其中一个即可，作用是描述镜像构建完成后，启动容器时默认执行的脚本。只能设置一次，如果有多个，会执行最后一个CMD或者endpoint
# CMD ping 127.0.0.1
# CMD  ["sh",,"-c","ping 127.0.0.1"]
# ENDPOINT  ping 127.0.0.1
# ENDPOINT  ["sh",,"-c","ping 127.0.0.1"]

# ONBUILD 假设A镜像用了这个命令，B镜像FROM A中继承了，那么B镜像就会执行A中ONBUILD后面所接的命令

# STOPSIGNAL指令
# HEALHCHECK 健康检查 每隔10s钟检查容器是否正常，每次不超过3s，如果失败了，最多不超过3次。sucess0表示成功，unhelathy1表示失败，reserved 保留值
HEALCHECK --interval=10 --timeout=3s --retries=5 CMD ps -ef |grep java || exit = 1

使用dockerfile文件来创建镜像。

docker commit 基于一个现有的容器来构建镜像
docker build 

使用commit制作自己的镜像；
# docker run --rm -d -p 8080:80 --name nginx_commit nginx
[root@rabbit4-64 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                   CREATED         STATUS         PORTS                                   NAMES
677de5f57f42   nginx     "/docker-entrypoint.…"   4 seconds ago   Up 3 seconds   0.0.0.0:8080->80/tcp, :::8080->80/tcp   nginx_commit
[root@rabbit4-64 ~]# docker exec -it nginx_commit /bin/bash
root@677de5f57f42:/# cd /usr/share/nginx/html/
root@677de5f57f42:/usr/share/nginx/html# ls
50x.html  index.html
root@677de5f57f42:/usr/share/nginx/html# echo '<h1>welcome to china,,,,,,</h1>'> index.html
[root@rabbit4-64 ~]# docker commit -a "jiaxing" -m "my container" nginx_commit mynginx:latest #制作自己的镜像
sha256:8910ab9030e19adf60d1db2421336979c5de337d7acf58275f4f2606a43e027b
[root@rabbit4-64 ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
mynginx      latest    8910ab9030e1   7 seconds ago   187MB  #多了的镜像
[root@rabbit4-64 ~]# docker stop nginx_commit
[root@rabbit4-64 ~]# docker run --rm -d -p 8080:80  --name mynginx mynginx:latest #运行自己的镜像
d5a94c1febf31bd891cb2cc2db1ac8eda1f89dcee83e12f8ad5bebae02c08255


docker build构建自己的镜像
第一个例子：
cat Dockerfile
FROM openjdk:8
 #将项目jar包拷贝的容器中
ADD *.jar /app.jar
# 配置项目环境变量
ENV  APP_OPTS=""
ENV  JVM_OPTS="-Duser.timezones=Asia/Shanghai -Xms128m -Xmx128m"
#暴露端口
EXPOSE 8080
#设置启动时的命令
ENTRYPOINT ["sh","-c","java $JVM_OPTS -jar /app.jar $APP_OPTS"]


docker build -t springboot-docker:1.0.0 . #基于Dockerfile来构建自己的镜像
[root@rabbit4-64 spring-boot-docker-demo]# docker images
REPOSITORY          TAG       IMAGE ID       CREATED          SIZE
springboot-docker   1.0.0     c988bda93f74   22 minutes ago   546MB
docker run --rm -d -P springboot-docker:1.0.0 #使用镜像启动一个项目

[root@rabbit4-64 spring-boot-docker-demo]# ls
Dockerfile  springboot-docker-demo-1.0.0.jar

第二个例子：
[root@rabbit4-64 javaweb-docker-demo]# cat Dockerfile 
FROM tomcat:9.0
WORKDIR /usr/local/tomcat/webapps
ADD *.war ROOT.war
ENTRYPOINT ["sh","-c","../bin/catalina.sh run"]
[root@rabbit4-64 javaweb-docker-demo]# ls
Dockerfile  javaweb-docker-demo-1.0-SNAPSHOT.war
[root@rabbit4-64 javaweb-docker-demo]# cat Dockerfile 
FROM tomcat:9.0
WORKDIR /usr/local/tomcat/webapps
ADD *.war ROOT.war
ENTRYPOINT ["sh","-c","../bin/catalina.sh run"]

docker build -t javaweb .#构建镜像
[root@rabbit4-64 javaweb-docker-demo]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED          SIZE
javaweb                                           latest         dfb736310ee3   5 minutes ago    680MB
docker run --rm -d -P javaweb 启动镜像
[root@rabbit4-64 javaweb-docker-demo]# docker ps
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                         NAMES
e13a61753b99   javaweb                   "sh -c '../bin/catal…"   5 minutes ago    Up 4 minutes    0.0.0.0:32780->8080/tcp, :::32780->8080/tcp   silly_rubin
[root@rabbit4-64 javaweb-docker-demo]# curl 192.168.70.64:32780 #实现效果
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Java Web 项目 Docker 容器化部署</title>
</head>
<body>
<h1>Java Web: Hello Docker!!!</h1>
</body>
</html>


# 第三个例子：编译安装nginx,以centos7为镜像
[root@rabbit4-64 nginx-demo]# ls
Dockerfile  index.html  nginx-1.14.2.tar.gz  pcre-8.38.tar.gz
[root@rabbit4-64 nginx-demo]# cat Dockerfile 
FROM centos:7
MAINTAINER jiaxing<tt.@qq.com>
ADD pcre-8.38.tar.gz /usr/local/src
ADD nginx-1.14.2.tar.gz /usr/local/src
# 如果是压缩包，ADD命令会自动解压
# 安装基本工具 
RUN yum install wget gcc gcc-c++ make openssl-devel -y
# 创建www用户作为nginx的启动用户
RUN useradd -s /sbin/nologin -M www
# 进入nginx解压后的目录
WORKDIR /usr/local/src/nginx-1.14.2
RUN ./configure --prefix=/usr/local/nginx --user=www --group=www --with-http_ssl_module --with-http_stub_status_module --with-pcre=/usr/local/src/pcre-8.38
RUN make && make install 
# 关闭nginx后台运行，
RUN echo 'daemon off;' >> /usr/local/nginx/conf/nginx.conf
#容器内的端口是80，所以需要暴露出去
EXPOSE 80 
# 创建nginx变量环境变量 
# ln -s /usr/local/nginx/sbin/nginx /usr/local/bin/nginx
ENV PATH /usr/local/nginx/sbin:$PATH
# 用自定义的nginx首页
ADD index.html /usr/local/nginx/html
# 启动nginx
CMD ["nginx"]

[root@rabbit4-64 nginx-demo]# cat index.html 
<h1>customer nginx in docker ;;</h1>

docker build -t wolfcode_nginx . #构建wolf_code的镜像
docker run -d -P --rm wolfcode_nginx 

[root@rabbit4-64 nginx-demo]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED          SIZE
wolfcode_nginx                                    latest         596b7595937c   17 minutes ago   604MB

[root@rabbit4-64 nginx-demo]# docker ps
CONTAINER ID   IMAGE                     COMMAND                   CREATED         STATUS         PORTS                                         NAMES
8c8b571b793b   wolfcode_nginx            "nginx"                   4 minutes ago   Up 4 minutes   0.0.0.0:32781->80/tcp, :::32781->80/tcp       vibrant_satoshi

[root@rabbit4-64 nginx-demo]# cat index.html 
<h1>customer nginx in docker ;;</h1>
[root@rabbit4-64 nginx-demo]# curl 192.168.70.64:32781
<h1>customer nginx in docker ;;</h1>

2.12 镜像仓库 nexus harbor

类似于git仓库 docker hub是官方的仓库（类似于github，有个人用户名和git地址）

docker nexus安装
# 创建持久化目录
mkdir -p /opt/docker/nexus
# 开放权限
chmod 777 -R /opt/docker

# 启动 nexus 容器
docker run -d --restart=always -p 8868:8081 -p 5000:5000 -p 5001:5001 --name nexus -v /opt/docker/nexus:/nexus-data sonatype/nexus3

查看默认密码
docker exec -it nexus /nexus-data/admin.password

5000是推送镜像 5001是拉取镜像
同时也可以从5000端口下载镜像，但是只能下载个人提交到仓库的镜像，无法下载个人仓库不存在的镜像
snapshots存放的是测试镜像

[root@rabbit4-64 nexus]# cat /etc/docker/daemon.json 
{
        "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn", "https://9cpn8tt6.mirror.aliyuncs.com"],
        "insecure-registries": ["192.168.70.64:5000","192.168.70.64:5001"]

}

在这里插入图片描述

对于图中的remote storage，当用户拉取镜像时，如果私人的仓库（nexus harbor）中没有的话，就会向这个阿里云的地址拉取镜像。也就是一个加速器

推送镜像
[root@rabbit4-64 nexus]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
wolfcode_nginx                                    latest         596b7595937c   3 days ago     604MB
[root@rabbit4-64 nexus]# docker tag 596b7595937c 192.168.70.64:5000/wolfcode_nginx  为镜像打上标签
[root@rabbit4-64 nexus]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
192.168.70.64:5000/wolfcode_nginx                 latest         596b7595937c   3 days ago     604MB
wolfcode_nginx                                    latest         596b7595937c   3 days ago     604MB
[root@rabbit4-64 nexus]# docker push 192.168.70.64:5000/wolfcode_nginx 推送镜像
Using default tag: latest
The push refers to repository [192.168.70.64:5000/wolfcode_nginx]

在这里插入图片描述

拉取镜像
[root@rabbit4-64 ~]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
192.168.70.64:5000/wolfcode_nginx                 latest         596b7595937c   3 days ago     604MB
[root@rabbit4-64 ~]# docker  rmi 192.168.70.64:5000/wolfcode_nginx
Untagged: 192.168.70.64:5000/wolfcode_nginx:latest
Untagged: 192.168.70.64:5000/wolfcode_nginx@sha256:5391ec8db82624ae5fc94371a9fd57182d52b6b0245de45413f00b57acee3fb3
[root@rabbit4-64 ~]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
[root@rabbit4-64 ~]# docker pull wolfcode_nginx # 不能直接拉取，虽然已经登陆了
Using default tag: latest
Error response from daemon: pull access denied for wolfcode_nginx, repository does not exist or may require 'docker login': denied: requested access to the resource is denied
[root@rabbit4-64 ~]# 

[root@rabbit4-64 ~]# docker login -uadmin 192.168.70.64:5000
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
[root@rabbit4-64 ~]# docker pull 192.168.70.64:5000/wolfcode_nginx:latest
latest: Pulling from wolfcode_nginx
Digest: sha256:5391ec8db82624ae5fc94371a9fd57182d52b6b0245de45413f00b57acee3fb3
Status: Downloaded newer image for 192.168.70.64:5000/wolfcode_nginx:latest
192.168.70.64:5000/wolfcode_nginx:latest
[root@rabbit4-64 ~]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
192.168.70.64:5000/wolfcode_nginx                 latest         596b7595937c   3 days ago     604MB


 docker login -uadmin 192.168.70.64:5001 # 如果镜像不存在仓库，会从官网下载
 docker pull 192.168.70.64:5001/wolfcode_nginx:latest

harbor安装使用

Release v2.5.0 · goharbor/harbor (github.com)

需要提前安装好docker compose。有一定的对应关系（安装harbor时，必须要求是docker-compose）

安装docker-compose
https://mirrors.aliyun.com/docker-toolbox/

sudo curl -L "http://mirrors.aliyun.com/docker-toolbox/linux/compose/1.21.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
 docker-compose --version
注意： 对于 alpine，需要以下依赖包： py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

[root@rabbit4-64 opt]# docker compose version
Docker Compose version v2.24.5
[root@rabbit4-64 harbor]# cp harbor.yml.tmpl harbor.yml
[root@rabbit4-64 harbor]# vim harbor.yml
hostname: 192.168.70.64
http:
  # port for http, default is 80. If https enabled, this port will redirect to https port
  port: 8058
harbor_admin_password: 123456
#https: #注释掉443端口
  # https port for harbor, default is 443
#  port: 443
  # The path of cert and key files for nginx
#  certificate: /your/certificate/path
#  private_key: /your/private/key/path
[root@rabbit4-64 bin]# cd /opt/harbor/
[root@rabbit4-64 harbor]# ls
[root@rabbit4-64 harbor]# ./prepare 
prepare base dir is set to /opt/harbor
common.sh  harbor.v2.5.0.tar.gz  harbor.yml  harbor.yml.tmpl  input  install.sh  LICENSE  prepare
[root@rabbit4-64 harbor]# bash install.sh

harbor提交镜像
docker login -uadmin 192.168.70.64:8058
docker images
docker tag 596b7595937c 192.168.70.64:8058/wolfcode_nginx/nginx
docker images
docker push 192.168.70.64:8058/wolfcode_nginx/nginx

[root@rabbit4-64 harbor]# docker images
REPOSITORY                                        TAG            IMAGE ID       CREATED        SIZE
192.168.70.64:8058/wolfcode_nginx/nginx           latest         596b7595937c   3 days ago     604MB

#如果是在其他的机器中使用docker pull
#那么这个时候需要配置/etc/docker/daemon.json
#将仓库地址加入到这个配置文件中
{
        "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn", "https://n5jclonh.mirror.aliyuncs.com", "https://9cpn8tt6.mirror.aliyuncs.com"],
        "insecure-registries": ["192.168.70.64:8058"]

}
# 同时也要注意当重启docker后，会导致使用docker compose启动的harbor无法使用，那么需要做：
docker-compose down
docker-compose up -d
或者直接使用docker-compose -d这一条命令


 docker info #查看受信任的仓库
 docker login -uadmin 192.168.70.64:8058 #登录harbor
 docker pull   192.168.70.64:8058/wolfcode_nginx/nginx@sha256:5391ec8db82624ae5fc94371a9fd57182d52b6b0245de45413f00b57acee3fb3 #拉取，从harbor页面复制导入命令

在这里插入图片描述

3 docker容器编排compose

针对生命周期来创建，对容器的生命周期进行更快速更方便进行管理
当一个容器需要当另外一个容器运行后，才能运行。副本数控制：容器有时候也需要集群.
很多容器按照某个顺序先后启动，同时启动容器需要指定很多参数。

只能在一台机器上
#容器编排工具：compose、swarm、k8s
compose 只能在一台宿主机上编排容器，启动多个容器。而且必须要有.yaml文件。
swarm docker官方推出的产品，可以在多台宿主机上编排容器，启动多个容器。
k8s 云原生基金会推出的产品，可以在多台宿主机上编排容器，启动多个容器。
注意点：docker--compose命令只能在有yml目录下执行，否则会报错

使用一个docker_compose.yml文件来创建多个容器
主要关注的点：服务：services 网络：network 数据卷：volumes

service:需要运行的容器配置，可以理解为原先使用docker run命令后面跟着的一系列配置信息，都配置在这个下面 
networks:公共自定义网络管理，配置好后，可以直接在services引用该网络配置，可以被多个services使用
volumes：在dockercompose统一的数据卷使用，提供给多个service使用

Define and run multi-container applications with Docker.
Usage:
  docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
  docker-compose -h|--help

Options:
  -f, --file FILE             Specify an alternate compose file (default: docker-compose.yml)
  -p, --project-name NAME     Specify an alternate project name (default: directory name)
  --verbose                   Show more output
  -v, --version               Print version and exit
  -H, --host HOST             Daemon socket to connect to

  --tls                       Use TLS; implied by --tlsverify
  --tlscacert CA_PATH         Trust certs signed only by this CA
  --tlscert CLIENT_CERT_PATH  Path to TLS certificate file
  --tlskey TLS_KEY_PATH       Path to TLS key file
  --tlsverify                 Use TLS and verify the remote
  --skip-hostname-check       Don't check the daemon's hostname against the name specified
                              in the client certificate (for example if your docker host
                              is an IP address)

Commands:
  build              构建或重新构建一个服务
  bundle             Generate a Docker bundle from the Compose file
  config             验证并查看 compose 文件
  create             创建一个服务
  down               停止并删除容器、网络、镜像和数据卷
  events             Receive real time events from containers
  exec               在一个运行中的容器执行命令
  help               获取帮助信息
  kill               关闭一个容器
  logs               显示服务的日志信息
  pause              暂停一个服务
  port               打印一个端口绑定的公开端口
  ps                 查看容器列表
  pull               拉取镜像
  push               推送镜像
  restart            重启容器
  rm                 删除已经停止的容器
  run                运行一个一次性执行的命令
  scale              设置服务的容器数量
  start              启动一个停止的服务
  stop               停止服务
  unpause            恢复一个暂停的服务
  up                 可能会创建并启动一个新的容器
  version            显示 compose 的版本信息

docker-compose stop/start/

[root@rabbit4-64 nginx]# cat docker-compose.yml 
version: "2.1"
services: 
  # 这是其中一个service
  nginx-demo: 
    image: "nginx:latest"
    container_name: "nginx_compose" 
    restart: "always"
    networks: 
      - wolfcode_net
    volumes: 
      - /www/wolfcode.cn:/usr/share/nginx/html
    environment:
      APP_ENV: dev
    dns: 
      - 114.114.114.114


networks: 
  wolfcode_net:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 188.18.0.0/16
          gateway: 188.18.0.1

# volumes:
#  wolfcode_volume:
#    - nginx_volume:/usr/share/nginx/html
[root@rabbit4-64 nginx]# docker-compose config # 测试这个文件是否能用
networks: 
  wolfcode_net:
    driver: bridge
    ipam:
      config:
      - gateway: 188.18.0.1
        subnet: 188.18.0.0/16
      driver: default
services:  
  nginx-demo: #服务名 可以使用dokcer-compose stop nginx-demo等方式停止
    container_name: nginx_compose #指定容器的name
    dns:
    - 114.114.114.114
    environment:
      APP_ENV: dev
    image: nginx:latest
    networks:
      wolfcode_net: null
    restart: always
    volumes:
    - /www/wolfcode.cn:/usr/share/nginx/html:rw
version: '2.1'

[root@rabbit4-64 nginx]# docker-compose create nginx-demo  这个命令是启动yaml文件中为 nginx-demo的容器
WARNING: The create command is deprecated. Use the up command with the --no-start flag instead.
Creating nginx_compose ... done
docker-compose  create  #会将当前目录下yaml文件中的所有的service全部启动
docker-compose ps # 查看容器
docker-compose up -d #表示启动yaml文件中所有的服务
docker-compose up -d nginx-demo # 表示启动单独的服务

[root@rabbit4-64 nginx]# docker-compose ps
    Name                   Command               State   Ports 
---------------------------------------------------------------
nginx_compose   /docker-entrypoint.sh ngin ...   Up      80/tcp #这个80表示的是容器内部有一个80端口被占用

[root@rabbit4-64 nginx]# docker ps|grep compose 
6d54951e81be   nginx:latest                         "/docker-entrypoint.…"   7 minutes ago   Up 3 minutes            80/tcp                                                                                                     nginx_compose
# 一个yaml文件中可以包含多个service，一个service中可以包含多个容器，当使用docker-compose ps -a查看容器时，可以使用docker inspect 《容器名》 来查看。比如：docker inspect得到的内容
            "Labels": {
                "com.docker.compose.config-hash": "627d5fd5c4454c2133b21317964c903ba159b609601ce55ea8c9705de2578b03",
                "com.docker.compose.container-number": "1",
                "com.docker.compose.oneoff": "False",
                "com.docker.compose.project": "nginx",  项目名称（默认为当前目录名，可以通过 -p 参数自定义）
                "com.docker.compose.service": "nginx-demo",  是哪个服务启动的
                "com.docker.compose.version": "1.21.2",
                "maintainer": "NGINX Docker Maintainers <docker-maint@nginx.com>"

# 如果修改了yaml文件的内容，比如添加了一个端口，那么只需要执行 docker-compose up -d  很方便

主要功能：

docker-compose build：构建服务的 Docker 镜像，不创建或启动容器。基于dockerfile来创建
docker-compose create：创建服务的容器，但不启动它们。也可以使用docker-compose up -d启动
操作顺序：
docker-compose build 通常在 docker-compose create 之前执行，因为创建容器需要相应的镜像。
docker-compose create 创建的容器，可以使用 docker-compose start 启动。
启动状态：
docker-compose build 不涉及容器的创建和启动。
docker-compose create 创建的容器处于停止状态，直到被显式启动。

docker scale命令使用
[root@rabbit4-64 nginx]# docker-compose scale nginx-demo=3 创建多个容器
WARNING: The scale command is deprecated. Use the up command with the --scale flag instead.
Starting nginx_compose ... done
Creating nginx_nginx-demo_2 ... done
Creating nginx_nginx-demo_3 ... done
[root@rabbit4-64 nginx]# docker^C
[root@rabbit4-64 nginx]# docker-compose ps
       Name                     Command               State                   Ports                 
----------------------------------------------------------------------------------------------------
nginx_compose        /docker-entrypoint.sh ngin ...   Up      0.0.0.0:80->80/tcp,:::80->80/tcp      
nginx_nginx-demo_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32768->80/tcp,:::32768->80/tcp
nginx_nginx-demo_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32769->80/tcp,:::32769->80/tcp
[root@rabbit4-64 nginx]# cat docker-compose.yml 
version: "2.1"
services: 
  # 这是其中一个service
  nginx-demo: 
    image: "nginx:latest"
#    container_name: "nginx_compose" #不固定容器的名字
    restart: "always"
    networks: 
      - wolfcode_net
    volumes: 
      - /www/wolfcode.cn:/usr/share/nginx/html
    environment:
      APP_ENV: dev
    dns: 
      - 114.114.114.114
    ports: 
      - 80 #容器内部的端口

networks: 
  wolfcode_net:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 188.18.0.0/16
          gateway: 188.18.0.1

# volumes:
#  wolfcode_volume:
#    - nginx_volume:/usr/share/nginx/html


#如果设置scale=5，那么将会出现一下内容。也就是自动扩缩
[root@rabbit4-64 nginx]# docker-compose scale nginx-demo=5
WARNING: The scale command is deprecated. Use the up command with the --scale flag instead.
Starting nginx_compose      ... done
Starting nginx_nginx-demo_2 ... done
Starting nginx_nginx-demo_3 ... done
Creating nginx_nginx-demo_4 ... done
Creating nginx_nginx-demo_5 ... done
[root@rabbit4-64 nginx]# docker-compose ps
       Name                     Command               State                   Ports                 
----------------------------------------------------------------------------------------------------
nginx_compose        /docker-entrypoint.sh ngin ...   Up      0.0.0.0:80->80/tcp,:::80->80/tcp      
nginx_nginx-demo_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32768->80/tcp,:::32768->80/tcp
nginx_nginx-demo_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32769->80/tcp,:::32769->80/tcp
nginx_nginx-demo_4   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32770->80/tcp,:::32770->80/tcp
nginx_nginx-demo_5   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32771->80/tcp,:::32771->80/tcp


# 如果设置scale=2，那么他会自动的删除多个容器
[root@rabbit4-64 nginx]# docker-compose scale nginx-demo=2
WARNING: The scale command is deprecated. Use the up command with the --scale flag instead.
Stopping and removing nginx_nginx-demo_3 ... done
Stopping and removing nginx_nginx-demo_4 ... done
Stopping and removing nginx_nginx-demo_5 ... done
[root@rabbit4-64 nginx]# docker-compose ps
       Name                     Command               State                   Ports                 
----------------------------------------------------------------------------------------------------
nginx_compose        /docker-entrypoint.sh ngin ...   Up      0.0.0.0:80->80/tcp,:::80->80/tcp      
nginx_nginx-demo_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32768->80/tcp,:::32768->80/tcp

# docker-compose logs 服务名：查看指定服务的日志信息

4 swarm跨主机容器编排

Swarm 是 Docker 公司推出的用来管理 docker 集群的平台，几乎全部用GO语言来完成的开发的，它是将一群 Docker 宿主机变成一个单一的虚拟主机，Swarm 使用标准的 Docker API 接口作为其前端的访问入口，换言之，各种形式的DockerClient(compose, docker-py 等) 均可以直接与 Swarm 通信，甚至 Docker 本身都可以很容易的与 Swarm 集成，这大大方便了用户将原本基于单节点的系统移植到 Swarm 上，同时Swarm 内置了对 Docker 网络插件的支持，用户也很容易的部署跨主机的容器集群服务。
　　Docker Swarm 和 Docker Compose 一样，都是 Docker 官方容器编排项目，但不同的是，Docker Compose 是一个在单个服务器或主机上创建多个容器的工具，而 Docker Swarm 则可以在多个服务器或主机上创建容器集群服务，对于微服务的部署，显然 Docker Swarm 会更加适合。
从 Docker 1.12.0 版本开始，Docker Swarm 已经包含在 Docker 引擎中（docker swarm），并且已经内置了服务发现工具，我们就不需要像之前一样，再配置 Etcd 或者 Consul 来进行服务发现配置了。
　　Swarm deamon只是一个调度器(Scheduler)加路由器(router),Swarm自己不运行容器，它只是接受Docker客户端发来的请求，调度适合的节点来运行容器，这就意味着，即使Swarm由于某些原因挂掉了，集群中的节点也会照常运行，放Swarm重新恢复运行之后，他会收集重建集群信息。https://github.com/docker/swarm
集群的管理和编排是使用嵌入 docker 引擎的 SwarmKit，可以在docker 初始化时启动 swarm 模式或者加入已存在的 swarm
swarm 集群节点的管理命令：docker swarm --help

初始化集群节点
加入节点
退出节点

运行 Docker 的主机可以主动初始化一个 Swarm 集群或者加入一个已存在的 Swarm 集群，这样这个运行 Docker 的主机就成为一个 Swarm 集群的节点 (node) 。

节点分为管理 (manager) 节点和工作 (worker) 节点。

管理节点用于 Swarm 集群的管理，docker swarm 命令基本只能在管理节点执行（节点退出集群命令 docker swarm leave 可以在工作节点执行）。一个 Swarm 集群可以有多个管理节点，但只有一个管理节点可以成为 leader，leader 通过 raft 协议实现。通常，第一个启用docker swarm的节点将成为leader，后来加入的都是follower。当前的leader如果挂掉，剩余的节点将重新选举出一个新的leader。每一个manager都有一个完整的当前集群状态的副本，可以保证manager的高可用。
工作节点是任务执行节点，管理节点将服务 (service) 下发至工作节点执行。管理节点默认也作为工作节点。你也可以通过配置让服务只运行在管理节点。worker节点之间，通过control plane进行通信，这种通信使用gossip协议，并且是异步的。
来自 Docker 官网的这张图片形象的展示了集群中管理节点与工作节点的关系。
任务（Task）是 Swarm 中的最小的调度单位，目前来说就是一个单一的容器。
服务（Services）是指一组任务的集合(一个服务包含多个任务)，服务定义了任务的属性。服务有两种模式：
replicated services 按照一定规则在各个工作节点上运行指定个数的任务。
global services 每个工作节点上运行一个任务
两种模式通过 docker service create 的 --mode 参数指定。

# 创建容器集群
# 192.168.70.62 manager 192.168.70.63 192.168.70.64 work
[root@rabbit2-62 ~]# docker swarm init --advertise-addr 192.168.70.62  #添加manager
Swarm initialized: current node (p5gtxgdppesojoetcd3yw4wtj) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5p5yv8fdxmwfp9dk64hnjfz8qynole5z423ie2ddzdp8n8q71y-0clyq3nefbe4191jj3ono2t2y 192.168.70.62:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

#将其他的机器加入到节点
[root@rabbit3-63 ~]# docker swarm join --token SWMTKN-1-5p5yv8fdxmwfp9dk64hnjfz8qynole5z423ie2ddzdp8n8q71y-0clyq3nefbe4191jj3ono2t2y 192.168.70.62:2377  # 复制上面的命令
This node joined a swarm as a worker.
[root@rabbit4-64 ~]# docker swarm join --token SWMTKN-1-5p5yv8fdxmwfp9dk64hnjfz8qynole5z423ie2ddzdp8n8q71y-0clyq3nefbe4191jj3ono2t2y 192.168.70.62:2377
This node joined a swarm as a worker.

#manager节点中查看节点
[root@rabbit2-62 ~]# docker node ls
ID                            HOSTNAME     STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
p5gtxgdppesojoetcd3yw4wtj *   rabbit2-62   Ready     Active         Leader           26.1.4
zer7v7zhu9yhy2ec8g1gnf9zn     rabbit3-63   Ready     Active                          25.0.3
z09y9dwmtz2hp543izzu3rm85     rabbit4-64   Ready     Active                          25.0.3

#退出集群
docker swarm leave
#当其中一台机器退出后，那么对应在上面使用swarm启动的容器，将会转移到另外的机器上

[root@rabbit2-62 ~]# docker node --help
Usage:  docker node COMMAND
Manage Swarm nodes
Commands:
  demote      Demote one or more nodes from manager in the swarm
  inspect     Display detailed information on one or more nodes
  ls          List nodes in the swarm
  promote     Promote one or more nodes to manager in the swarm
  ps          List tasks running on one or more nodes, defaults to current node
  rm          Remove one or more nodes from the swarm  # 删除节点
  update      Update a node
Run 'docker node COMMAND --help' for more information on a command.

service使用

[root@rabbit2-62 ~]# docker service --help
Usage:  docker service COMMAND
Manage Swarm services
Commands:
  create      Create a new service
  inspect     Display detailed information on one or more services
  logs        Fetch the logs of a service or task
  ls          List services
  ps          List the tasks of one or more services
  rm          Remove one or more services
  rollback    Revert changes to a service's configuration
  scale       Scale one or multiple replicated services
  update      Update a service

[root@rabbit2-62 ~]# docker service create --replicas 2 -p 80:80 --name nginx_swarm nginx  # 创建容器
c2tvmy0mxamnfeqw4pd3ip08n
overall progress: 2 out of 2 tasks 
1/2: running   [==================================================>] 
2/2: running   [==================================================>] 
verify: Service c2tvmy0mxamnfeqw4pd3ip08n converged 
[root@rabbit2-62 ~]# docker service ls
ID             NAME          MODE         REPLICAS   IMAGE          PORTS
c2tvmy0mxamn   nginx_swarm   replicated   2/2        nginx:latest   *:80->80/tcp
[root@rabbit2-62 ~]# docker ps
CONTAINER ID   IMAGE          COMMAND                   CREATED          STATUS          PORTS     NAMES
5ec665980017   nginx:latest   "/docker-entrypoint.…"   55 seconds ago   Up 53 seconds   80/tcp    nginx_swarm.2.y2if3o4ta0ih7nkqdbe0lfpgg
可以在manager和另外两台之一的work中查看到nginx_swarm，其中的一台work中并没有这个nginx_swarm容器。
#查看容器信息
[root@rabbit2-62 ~]# docker service inspect --pretty nginx_swarm
ID:		c2tvmy0mxamnfeqw4pd3ip08n
Name:		nginx_swarm
Service Mode:	Replicated
 Replicas:	2
Placement:
UpdateConfig:
 Parallelism:	1
 On failure:	pause
 Monitoring Period: 5s
 Max failure ratio: 0
 Update order:      stop-first
RollbackConfig:
 Parallelism:	1
 On failure:	pause
 Monitoring Period: 5s
 Max failure ratio: 0
 Rollback order:    stop-first
ContainerSpec:
 Image:		nginx:latest@sha256:0f04e4f646a3f14bf31d8bc8d885b6c951fdcf42589d06845f64d18aec6a3c4d
 Init:		false
Resources:
Endpoint Mode:	vip
Ports:
 PublishedPort = 80 #发布的端口
  Protocol = tcp
  TargetPort = 80
  PublishMode = ingress
  
#修改副本数
[root@rabbit2-62 ~]# docker service ls
ID             NAME          MODE         REPLICAS   IMAGE          PORTS
c2tvmy0mxamn   nginx_swarm   replicated   2/2        nginx:latest   *:80->80/tcp
[root@rabbit2-62 ~]# docker service update --replicas 1 nginx_swarm
nginx_swarm
overall progress: 1 out of 1 tasks 
1/1: running   [==================================================>] 
verify: Service nginx_swarm converged 
[root@rabbit2-62 ~]# docker service ls
# 如果调整为3个，那么就会出现每一个机器上都有nginx_swarm
[root@rabbit3-63 ~]# docker ps
CONTAINER ID   IMAGE          COMMAND                   CREATED          STATUS          PORTS     NAMES
3bf8b409d127   nginx:latest   "/docker-entrypoint.…"   12 minutes ago   Up 12 minutes   80/tcp    nginx_swarm.1.5z08551x6ly8cbempp3vxjhdk

# 查看使用service启动的容器分别在哪些机器上
[root@rabbit2-62 ~]# docker service ps  c2tvmy0mxamn
ID             NAME            IMAGE          NODE         DESIRED STATE   CURRENT STATE            ERROR     PORTS
5z08551x6ly8   nginx_swarm.1   nginx:latest   rabbit3-63   Running         Running 20 minutes ago           
0h1e77r9bsn9   nginx_swarm.2   nginx:latest   rabbit2-62   Running         Running 9 minutes ago             
76fnrdi69iw3   nginx_swarm.3   nginx:latest   rabbit4-64   Running         Running 8 minutes ago

5 容器可视化工具 portainer

下载：
# 基于 docker 运行
docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
# 基于 swarm 运行 对于这种方式，可以使用集群中任意的ip进行访问。相当于docker swarm自己做了负载均衡
docker service create -p 9000:9000 --replicas 1 --mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock --mount type=volume,src=portainer_data,dst=/data portainer/portainer