docker安装

原理

r

起步

安装

1. 安装Centos7操作系统，并查看系统配置

cat /etc/os-release

2. 卸载旧版本

如果你的系统中安装过 docker，需要先将旧版本的 docker 卸载

如果你没有安装过 docker，此步骤可以跳过

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

3. 安装依赖环境

sudo yum install -y yum-utils

4. 设置镜像仓库

sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

5. 更新YUM源

sudo yum makecache fast

6. 安装DOCKER引擎

sudo yum install docker-ce docker-ce-cli containerd.io -y

7. 启动DOCKER

sudo systemctl enable docker && systemctl start docker

8. 查看DOCKER版本

docker version

9. 验证DOCKER是否安装成功

sudo docker run hello-world

出现如下界面，则说明 docker 安装成功

卸载

如果你不想使用 docker 了，可以选择卸载

sudo yum remove docker-ce docker-ce-cli containerd.io
sudo rm -rf /var/lib/docker

镜像加速器

1. 登陆阿里云，开通容器服务

2. 查看配置镜像加速配置

3. 加速配置

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://kcugg9vg.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

系统命令

查看版本

docker version

查看系统信息

docker info

帮助命令

查看所有帮助

docker --help

查看指定指令的帮助

# 查看 images 命令帮助
docker images --help

镜像命令

查看本地镜像

docker images [可选参数]

# 查看所有镜像
docker images

# 查看所有镜像，包括中间环节
docker images -a

# 查看所有镜像的ID
docker images -q

查询结果列表

REPOSITORY	TAG	IMAGE ID	CREATED	SIZE
镜像的仓库源	镜像的标签	镜像的ID	镜像的创建时间	镜像的大小

查找远程镜像

查找 centos 镜像

docker search [可选参数] <镜像名称>

# 查找星数大于3000的镜像
docker search --filter=STARS=3000 centos

查询结果列表

NAME	DESCRIPTION	STARS	OFFICIAL	AUTOMATED
镜像名称	镜像描述	星数	是否为 docker 官方发布	是否为自动构建

下载远程镜像

docker pull <镜像名称:标签>

# 下载最新版本的镜像
docker pull centos

# 下载指定版本的镜像
docker pull centos:7

删除本地镜像

docker rim [可选参数] <镜像名称>

# 删除未被引用的镜像
docker rmi centos

# 强制删除镜像
docker rmi -f centos

# 删除所有镜像
docker rmi -f $(docker images -aq)

查看历史信息

docker history <镜像名称>

docker history centos

添加镜像标签

docker tag <镜像名称:[标签]> <镜像名称:[标签]>

docker tag my_tomcat yacon/tomcat:1.0

容器命令

创建与删除容器

创建容器

docker run [可选参数] <镜像名称> [命令行] [参数]

创建并启动容器

# 启动容器后，进入交互模式
docker run -it centos

# 启动容器后，进入后台运行模式
docker run -d centos

命名容器

# 给容器命名
docker run --name myCentos -it centos

设置工作目录

# 设置工作目录
# 进入容器后，会自动进入工作目录
# 如果当前工作目录不存在，则会创建
# 可使用 pwd 查看当前所在的目录
docker run -w /path/to/dir -it centos

端口映射

# 将容器的 80 端口映射到本地的 8080 端口
docker run -d -p 8080:80 nginx

# 将容器的 80 端口映射到本地的随机端口上
docker run -d -P nginx

环境变量配置

# 给容器进行环境变量的配置
docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=ok mysql:5.7

删除容器

docker rm [可选参数] <容器ID>

# 删除以停止的容器
docker rm b4322f768dc5

# 强制删除容器
docker rm -f b4322f768dc5

# 强制删除所有容器
docker rm -f $(docker ps -aq)

# 强制删除所有容器
docker ps -aq | xargs docker rm

查看容器

查看容器列表

docker ps [可选参数]

# 查看正在运行的容器
docker ps

# 查看所有的容器
docker ps -a

# 显示最近创建的3个容器
docker ps -a -n=3

# 仅显示容器的数字ID
docker ps -aq

# 显示最新创建的容器
docker ps -al

查看容器日志

docker logs [可选参数] <容器ID>

# 显示全部日志
docker logs 07b40ddf4bb0

# 显示日志时间戳
docker logs -t 07b40ddf4bb0

# 跟踪日志
docker logs -tf 07b40ddf4bb0

# 显示指定行数的日志
docker logs -tf --tail 10 07b40ddf4bb0

查看容器内的进程

docker top <容器ID>

docker top 07b40ddf4bb0

查看容器的元数据

docker inspect <容器ID>

docker inspect 07b40ddf4bb0

监控容器状态

docker stats [可选参数] <容器ID>

docker stats 07b40ddf4bb0

进入与退出容器

进入容器

使用 exit 退出容器，容器不会停止，会进入后台运行模式

docker exec [可选参数] <容器ID> <命令行> [参数...]

# 进入容器后打开新的终端
docker exec -it 1ecedf1b6af0 /bin/bash

# 在容器内执行指令，将结果返回
docker exec -t 1ecedf1b6af0 ls -l /tmp

使用 exit 退出容器，容器会停止运行

docker attach [可选参数] <容器ID>

# 进入容器后打开上次退出的终端
docker attach 1ecedf1b6af0

退出容器

# 从容器中退出,并停止容器
exit

# 从容器中退出，容器继续后台运行
Ctrl+P+Q

启动与停止容器

启动容器

docker start [可选参数] <容器ID>

docker start 07b40ddf4bb0

重启容器

docker restart [可选参数] <容器ID>

docker restart 07b40ddf4bb0

停止容器

正常停止

docker stop [可选参数] <容器ID>

docker stop 07b40ddf4bb0

强制停止

docker kill [可选参数] <容器ID>

docker kill 07b40ddf4bb0

重命名容器

docker rename <容器ID> <新名称>

docker rename 07b40ddf4bb0 web_server

导出容器内的文件

docker cp [可选参数] <容器ID>:<容器内路径> <容器外路径>

# 导出文件
docker cp 1ecedf1b6af0:/home/test.txt d:/test.txt

# 导入目录
docker cp 1ecedf1b6af0:/tmp d:/tmp

镜像与容器转换

提交容器为镜像

该操作有点类似于容器的快照

docker commit [可选参数] <容器ID> <镜像名称[:标签]>

docker commit -m="提交说明" -a="作者" 1cc86525a347 tomcat-apps:1.0

导出容器为镜像

将容器进行备份，导出为镜像文件，镜像文件的后缀为 *.tar 文件

docker export [可选参数] <容器ID>

# 导出容器到 d:/centos.tar
docker export -o d:/centos.tar c2b3cb1d7674

导入外部镜像

docker import <镜像路径> <容器名称:[标签]>

docker import d:/centos.tar centos1

数据卷管理

挂载数据卷

指定目录挂载

# 指定宿主机目录挂载到容器指定的目录中
# 宿主机目录中的内容会覆盖掉容器内的目录
docker run -it -v D:/docker/html:/usr/share/nginx/html nginx

自动挂载

# 此方法只能在 Linux 系统下运行
# 这里指定的路径为容器内路径
# 请访问容器元数据，来确定宿主机的挂载目录
# 如果容器内有数据，会拷贝到宿主机中
docker run -it -v /usr/share/nginx/html nginx

只读数据卷挂载

# 容器内无法进项修改数据，只能在容器外进行修改
docker run -it -v D:/docker/szj:/usr/rqj:ro centos

具名数据卷

docker run -it -v nginxHtml:/usr/share/nginx/html nginx

查看数据卷列表

docker volume ls

删除数据卷

docker volume rm [可选参数] <数据卷ID>

# 删除匿名数据卷
docker volume rm 2a65c16e8bf0ee0d2f79561c8581437cd769de4de9e79585f5ffbcb88498aa42

# 删除具名数据卷
docker volume rm nginxHtml

# 删除所有没有被容器使用的卷
docker volume prune

查看数据卷元数据

docker volume inspect <数据卷ID>

docker volume inspect 2a65c16e8bf0ee0d2f79561c8581437cd769de4de9e79585f5ffbcb88498aa42

容器间数据共享

# 创建 centos01 容器，centos01与宿主机实现数据共享
docker run -it --name centos01 -v D:/docker/centos:/volume_data centos /bin/bash
# 创建 centos02 容器，centos02与centos01实现数据共享
docker run -it --name centos02 --volumes-from centos01 centos /bin/bash
# 创建 centos03 容器，centos03与centos01实现数据共享
docker run -it --name centos03 --volumes-from centos01 centos /bin/bash

镜像发布

发布到DockerHub

1. 在DockerHub上注册账户

2. 登陆DockerHub

   docker login -u <用户名>

   docker login -u yaconit

3. 提交镜像

   docker push 作者名/镜像名:TAG

   docker push yaconit/mytomcat:1.0

发布到阿里云镜像

1. 登陆阿里云
2. 进入容器镜像服务
3. 创建命名空间
4. 创建镜像仓库
5. 浏览镜像仓库
6. 根据提示进行镜像发布

基础案例

搭建 Nginx 服务器

下载 Nginx 服务器

docker pull nginx

创建并运行 Nginx 服务器

docker run -it \
    --name nginx \
    -p 80:80 \
    -v /home/nginx/html:/usr/share/nginx/html \
    nginx /bin/bash

访问 Nginx 服务器

http://localhsot:8080/

进入 Nginx 服务器

docker exec -it a18dd27aa70d /bin/bash

查找 Nginx 位置

whereis nginx

查看 Nginx 配置文件

cat /etc/nginx/nginx.conf

退出 Nginx 服务器

exit

停止 Nginx 服务器

docker stop a18dd27aa70d

搭建 Tomcat 服务器

下载 Tomcat 服务器

docker pull tomcat:9.0

创建并启动 Tomcat 容器

docker run -d --name tomcat -p 8080:8080 tomcat:9.0 

进入 Tomcat 服务器

docker exec -it 1cc86525a347 /bin/bash

查找 Tomcat 位置

whereis tomcat

查看 Tomcat 配置文件

cat /usr/local/tomcat/conf/server.xml

部署测试应用

cd /usr/local/tomcat
cp -r webapps.dist/* webapps

访问 Tomcat 服务器

http://localhost:8080

搭建 ES 服务器

下载 ES 镜像

docker pull elasticsearch:7.6.2

创建并启动容器

docker run -itd -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

访问测试

http://localhost:9200/

内存限制

由于 ES 特别耗内存，所以，启动时，需要对他进行内存限制

# 停止服务
docker stop bbf9d4ab7a6b
# 添加内存限制配置
docker run -itd -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

搭建 Mysql 服务器

下载镜像

docker pull mysql:5.7

创建并启动容器

docker run -d -p 3306:3306 -v D:/mysql/conf:/etc/mysql/conf.d -v D:/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=ok --name mysql5.7 mysql:5.7

Docker 网络

容器单向链接

docker run --link <要联通的容器名> <镜像名>

# 创建容器 tomcat03 并联通 tomcat02
docker run -d -P --name tomcat03 --link tomcat02 tomcat

# ping 容器名
# 通过tomcat03 ping tomcat02
# 单向链接，只能由 tomcat03 ping tomcata02，反向则无法联通
docker exec -it tomcat03 ping tomcat02

查看网络列表

docker network ls

查看网络详情

docker network inspect <网卡ID>

docker network inspect 211f1ca80b00

创建网络

docker network create --driver <网络模式> --subnet <子网掩码>/16 --gateway <网关> <网络名称>

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

网络模式	说明
bridge	桥接模式，默认
none	不配置网络
host	共享宿主机网路

给容器配置网络

docker run <容器名> --net <网络名称> <镜像名>

docker run -d -P --name tomcat01 --net mynet tomcat

给容器配置两个IP

1. 创建 net01

   docker network create --driver bridge --subnet 192.160.0.0/16 --gateway 192.160.0.1 net01

2. 创建 net02

   docker network create --driver bridge --subnet 192.161.0.0/16 --gateway 192.161.0.1 net02

3. 将容器 tomcat-net 分配到 net01 网络

   docker run -d -P --name tomcat-net --net net01 tomcat

4. 将容器 tomcat-net 联通到 net02 网络

   docker network connect net02 tomcat-net

5. 查看 tomcat-net 的网络信息

   docker inspect tomcat-net

   

Dockerfile

Dockerfile 是用来构建 docker 镜像的构建文件。每一个指令执行都将生成一个新的镜像层。

原理图

常用指令

基础镜像

FROM <镜像名称:标签>

FROM centos

镜像作者

MAINTAINER 姓名<邮箱>

MAINTAINER yacon<517837215@qq.com>

运行命令

RUN <运行脚本>

RUN yum install -y vim

添加文件

如果添加的文件是压缩包，则可以自动解压

ADD <宿主机路径> <容器内路径>

ADD centos-8-x86_64.tar.xz /usr/local

工作目录

WORKDIR <工作目录>

WORKDIR /usr/local 

挂载数据卷

VOLUME [容器内路径,...]

VOLUME [/usr/local/ngin/html]

对外开放的端口

EXPOSE <端口号>

执行指令

运行容器时执行的命令，无法进行追加

CMD <指令>

CMD ["ls","-l"]

运行容器时执行的命令，可以追加命令

ENTRYPOINT <指令>

ENTRYPOINT ["ls","-l"]

触发指令

ONBUILD

拷贝文件

如果文件时压缩包，则不会自动解压

COPY <宿主机路径> <容器内路径>

COPY readme.txt /usr/local/readme.txt

设置环境变量

ENV <变量名> <变量值>

ENV MYPATH /usr/local 

案例

创建centos镜像

1. 创建dockerfile

   # 基于centos
   FROM centos
   # 作者
   MAINTAINER yacon<517837215@qq.com> 
   
   # 环境变量
   ENV MYPATH /usr/local 
   # 工作目录
   WORKDIR $MYPATH 
   
   # 运行yum指令
   RUN yum -y install vim 
   RUN yum -y install net-tools 
   
   # 对外开放80端口
   EXPOSE 80 
   
   # 执行指令
   CMD echo $MYPATH 
   CMD echo "----end----"
   CMD /bin/bash

2. 执行dockerfile

   docker build -f D:\docker\dockerfile -t mycentos:1.0 .

创建Tomcat镜像

1. 下载 tomcat 和 jdk 压缩包

   链接：https://pan.baidu.com/s/1Badic7FiQwFMy46_rzKbJA 
   提取码：0fv9

2. 在 D:/docker/tomcat 中创建 readme.txt 说明文件

3. 将 tomcat 和 jdk 的压缩包拷贝到 D:/docker/tomcat 中

    

   

4. 创建dockerfile文件

   # D:/docker/tomcat/Dockerfile
   
   FROM centos
   MAINTAINER yacon<517837215@qq.com>
   
   COPY readme.txt /usr/local/readme.txt
   
   ADD apache-tomcat-7.0.75.tar.gz /usr/local/
   ADD jdk-8u121-linux-x64.tar.gz /usr/local/
   
   RUN yum -y install vim
   
   ENV MYPATH /usr/local
   WORKDIR $MYPATH
   
   ENV JAVA_HOME /usr/local/jdk1.8.0_121
   ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$jAVA_HOME/lib/tools.jar
   ENV CATALINA_HOME /usr/local/apache-tomcat-7.0.75
   ENV CATALINA_BASH /usr/local/apache-tomcat-7.0.75
   ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
   
   EXPOSE 8080
   CMD /usr/local/apache-tomcat-7.0.75/bin/startup.sh && tail -F /usr/local/apache-tomcat-7.0.75/bin/logs/catalina.out

5. 执行dockerfile

   # 进入 D:/docker/tomcat
   cd D:/docker/tomcat
   # 执行 Dockerfile 构建镜像
   docker build -t mytomcat .

6. 构建并运行容器

   docker run -d  -p 8080:8080 --name mytomcat -v D:/docker/tomcat/webapps:/usr/local/apache-tomcat-7.0.75/webapps -v D:/docker/tomcat/logs:/usr/local/apache-tomcat-7.0.75/logs mytomcat

7. 创建 app 应用

    

   

8. 访问 app 应用

   http://localhost:8080/app/

SpringBoot 打包 Docker 镜像

1. 创建 SpringBoot Web 项目，并打包为 jar 文件

2. 创建 Dockerfile 文件

   FROM java:8
   COPY *.jar /app.jar
   CMD ["--server.port=8080"]
   EXPOSE 8080
   ENTRYPOINT ["java","-jar","app.jar"]

3. 将 dockerfile 与 jar 文件拷贝到 D:/docker/sbdocker 目录下

4. 构建镜像

   cd D:/docker/sbdocker
   docker build -t springboot-docker .

5. 启动镜像

   docker run -d -p 80:8080 springboot-docker

6. 访问测试

   http://localhost/

Docker Compose

Docker Compose 是用来定义和运行多个容器的工具。

起步

1. 下载 Docker-Compose

sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

2. 设置执行权限

sudo chmod +x /usr/local/bin/docker-compose

3. 测试安装

docker-compose --version

使用步骤

1. 创建 Dockerfile 文件

2. 创建 docker-compose.yml 文件

3. 启动 docker-compose

    

   前台启动

   docker-compose up

   后台启动

   docker-compose up -d

4. 停止 docker-compose

   docker-compose down

5. 重新构建

   docker-compose up --build

案例：搭建WP博客

1. 创建构建目录 D:/docker/my_wordpress

2. 进入 D:/docker/my_wordpress

3. 创建 docker-compose.yml 文件

   version: '3.3'
   
   services:
      db:
        image: mysql:5.7
        volumes:
          - db_data:/var/lib/mysql
        restart: always
        environment:
          MYSQL_ROOT_PASSWORD: somewordpress
          MYSQL_DATABASE: wordpress
          MYSQL_USER: wordpress
          MYSQL_PASSWORD: wordpress
   
      wordpress:
        depends_on:
          - db
        image: wordpress:latest
        ports:
          - "8000:80"
        restart: always
        environment:
          WORDPRESS_DB_HOST: db:3306
          WORDPRESS_DB_USER: wordpress
          WORDPRESS_DB_PASSWORD: wordpress
          WORDPRESS_DB_NAME: wordpress
   volumes:
       db_data: {}

4. 执行 docker-compose.yml

    

   前台执行

   docker-compose up

   后台执行

   docker-compose up -d

5. 测试访问

   http://localhost:8000

案例：一键搭建部署SpringBoot项目

1. 创建SpringBoot项目

   链接：https://pan.baidu.com/s/1H750bO9NDwTeKbawFR2TAQ 
   提取码：032n

2. 将SpringBoot项目打包为 jar 文件

3. 创建 Dockerfile 文件

   FROM java:8
   
   COPY *.jar /app.jar
   
   CMD ["--server.port=8080"]
   
   EXPOSE 8080
   
   ENTRYPOINT ["java","-jar","app.jar"]

4. 创建 docker-compose.yml 文件

   version: '3.8'
   services:
     docker-app:
       build: .
       image: docker-app
       depends_on:
         - redis
       ports:
       - "80:8080"
     redis:
       image: "library/redis:alpine"

5. 将 jar、Dockerfile 和 docker-compose.yml 拷贝到 D:/docker/docker-app

6. 进入 D:/docker/docker-app

7. 启动 docker-compose

   docker-compose up

8. 测试访问

   http://localhost/

Docker Swarm

工作模式

至少保证两台或两台以上管理节点可用，如果只有一台管理节点，则不可用

节点管理

环境准备

1. 搭建4台Linux服务器

每台服务器都需要安装docker

主机名称	IP	节点
docker01	192.168.26.143	管理节点
docker02	192.168.26.144	管理节点
docker03	192.168.26.145	工作节点
docker04	192.168.26.146	工作节点

2. 关闭所有服务器的防火墙

systemctl stop firewalld.service

3. 修改主机名称

将4台主机分别命名为 docker01 ~ dockers04

vi /etc/hostname

localhost.localdomain
docker01

4. 重启计算机

reboot

初始化集群

docker swarm init --advertise-addr <主服务器地址>

# 在 docker01 执行
# 将 docker01 作为管理节点
docker swarm init --advertise-addr 192.168.26.143

添加管理节点

1. 获取管理节点令牌

# 在 docker01 执行
docker swarm join-token manager

2. 将 docker02 添加到管理节点

# 在 docker02 上执行
docker swarm join --token SWMTKN-1-65l8fu28qnfa0ktsk9txsupau6jdbv81ron40n3vu2je3ug1oi-cs31c9x5l117q2zmcz7ylbh33 192.168.26.143:2377

3. 查看节点列表

# 在管理节点上执行
docker node ls

列明	说明
ID	节点ID
HOSTNAME	主机名称
STATUS	主机状态
AVAILABILITY	主机是否可用
MANAGER STATUS	管理状态，Leader和Reachable都标识管理主机，没写标识工作主机
ENGINE VERSION	引擎版本

添加工作节点

1. 获取工作节点令牌

# 在管理节点上执行
docker swarm join-token worker

2. 将 docker03 添加到集群

# 在 docker03 上执行
docker swarm join --token SWMTKN-1-65l8fu28qnfa0ktsk9txsupau6jdbv81ron40n3vu2je3ug1oi-b4k0s2qvjv3bryxmcq4tz9s9n 192.168.26.143:2377

3. 查看节点列表

# 在管理节点上执行
docker node ls

4. 将 docker04 添加到集群

# 在 docker04 上执行
docker swarm join --token SWMTKN-1-65l8fu28qnfa0ktsk9txsupau6jdbv81ron40n3vu2je3ug1oi-b4k0s2qvjv3bryxmcq4tz9s9n 192.168.26.143:2377

移除工作节点

1. 移除 docker03 节点

# 在 docker03 执行
docker swarm leave

2. 查看节点列表

# 在管理节点上执行
docker node ls

移除管理节点

1. 移除 docker01 节点

# 在 docker01 执行
docker swarm leave --force

2. 查看节点列表

由于将 docker01 移除，所以，我们没有了 Leader 节点，所以会报以下错误

# 在管理节点上执行
docker node ls

3. 将 docker02 设置为 Leader

# 在 docker02 上执行
docker swarm init --force-new-cluster

4. 查看节点列表

# 在管理节点上执行
docker node ls

5. 将其它节点添加至集群

# docker01 执行
docker swarm join --token SWMTKN-1-65l8fu28qnfa0ktsk9txsupau6jdbv81ron40n3vu2je3ug1oi-cs31c9x5l117q2zmcz7ylbh33 192.168.26.144:2377

# docker03、docker04 执行
docker swarm join --token SWMTKN-1-65l8fu28qnfa0ktsk9txsupau6jdbv81ron40n3vu2je3ug1oi-b4k0s2qvjv3bryxmcq4tz9s9n 192.168.26.144:2377

6. 查看节点列表

# 在管理节点上执行
docker node ls

服务管理

创建服务

docker service create [可选参数] <镜像名>

# 在 Leader 节点执行
docker service create -p 80:80 --name nginx nginx

查看服务列表

# 在管理节点上执行
docker service ls

列名	说明
ID	服务ID
NAME	服务名
MODE
REPLICAS	副本数量
IMAGE	镜像名
PORTS	端口映射

查看任务列表

docker server [可选参数] ps <服务名>

# 在管理节点上执行
docker server ps nginx

列名	说明
ID	任务ID
NAME	任务名
IMAGE	镜像名
NODE	节点名
DESIRED STATE	预期状态
CURRENT STATE	当前状态
ERROR	错误
PORTS	端口映射

查看服务详情

docker service inspect <服务名>

# 在管理节点上执行
docker service inspect nginx

更新服务

docker service update [可选参数] <服务名>

# 在管理节点上执行
docker service update --replicas 3 nginx

扩缩容

docker service scale <服务名>=<份数>

docker service scale nginx=3

Docker 图形化管理工具

portainer

下载并运行镜像

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

访问 portainer

http://localhost:8088/

创建密码

进入本地管理