Docker——Docker命令集合_docker pull 指定镜像源

摘要

本博文介绍docker命令集合,帮助大家更好的使用docker容器。

一、Docker的安装

1.1 一键安装:

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

 也可以使用国内 daocloud 一键安装命令：

curl -sSL https://get.daocloud.io/docker | sh

1.2 普通安装

#更新 apt 包索引
sudo apt-get update
 
#添加 Docker 的官方 GPG 密钥：
curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
 
#更新 apt 包索引
sudo apt-get update
 
#安装最新版本的 Docker Engine-Community 和 containerd ，或者转到下一步安装特定版本：
sudo apt-get install docker-ce docker-ce-cli containerd.io
 
#测试 Docker 是否安装成功，输入以下指令，打印出以下信息则安装成功:
sudo docker run hello-world
 
#删除安装包
sudo apt-get purge docker-ce

二、Docker镜像源修改

由于docker默认的源为国外官方源，下载速度较慢，所以在学习和使用中可改为国内的镜像源，这样速度会提高狠多。 

3.1 vim /etc/docker/daemon.json

vi /etc/docker/daemon.json
 
#添加如下网易镜像源
{
    "registry-mirrors": ["http://hub-mirror.c.163.com"]
}

3.2 vim /etc/sysconfig/docker

在OPTIONS变量后追加参数  --registry-mirror=镜像源地址

vi /etc/sysconfig/docker
 
#编辑OPTIONS，添加中国科技大学的镜像源
OPTIONS='--selinux-enabled --log-driver=journald --registry mirror=https://docker.mirrors.ustc.edu.cn'

3.3 vim /etc/default/docker

添加DOCKER_OPTS="--registry-mirror=镜像源"

vi /etc/default/docker
 
#指定镜像源为阿里的镜像源
DOCKER_OPTS="--registry-mirror=https://pee6w651.mirror.aliyuncs.com"
其他：docker pull拉取镜像时也可以指定仓库下载地址

3.4 vim /etc/docker/daemon.json

如果没有先建一个即可

sudo vim /etc/docker/daemon.json

修改配置文件

{
  "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

使配置文件生效

sudo systemctl daemon-reload

重启Docker

sudo service docker restart

测试配置是否成功

docker search nginx

三、Docker常用命令

3.1 Docker启动与停止

#启动：
systemctl start docker
 
#重启docker服务
systemctl restart docker或者是sudo service docker restart
 
#关闭docker
docker service docker stop或者是docker systemctl stop docker
 
#启动docker镜像
docker start 应用名称
 
 
#设置开机启动
sudo systemctl enable docker
 
#查看docker状态
sudo systemctl status docker
 
#查看docker内容器的运行状态
sudo docker stats
 
#查看docker概要信息
sudo docker info
 
#查看docker 帮助文档
sudo docker --help

3.2 镜像的管理命令

# 查看镜像
 
docker images
 
# 搜索镜像
 
docker search 镜像名称
 
# 拉取镜像
 
docker pull 镜像名称
 
# 删除单个镜像
 
docker rmi 镜像ID
 
# 删除多个镜像
 
docker rmi 镜像ID 镜像ID 镜像ID

3.3 容器的管理命令

# 查看正在运行的容器
 
docker ps
 
# 查看停止的容器
 
docker ps -f status=exited
 
# 查看所有容器（包括运行和停止）。
 
docker ps -a
 
# 创建与启动容器
 
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
 
    -i：表示运行容器；
    -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端；
    --name：为创建的容器命名；
    -v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个 -v 做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上；
    -d：在 run 后面加上 -d 参数，则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加 -i -t 两个参数，创建容器后就会自动进容器里）；
    -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个 -p 做多个端口映射。
    -P：随机使用宿主机的可用端口与容器内暴露的端口映射。
 
# 创建并进入容器
 
docker run -it --name 容器名称 镜像名称:标签 /bin/bash
 
# 退出当前容器
 
exit
 
# 守护式方式创建容器
 
docker run -di --name 容器名称 镜像名称:标签
 
# 登录守护式容器方式
 
docker exec -it 容器名称|容器ID /bin/bash
 
# 停止容器
 
docker stop 容器名称|容器ID
 
# 启动容器
 
docker start 容器名称|容器ID
 
# 文件拷贝
 
docker cp 需要拷贝的文件或目录 容器名称:容器目录
 
# 也可以将文件从容器内拷贝出来。
 
docker cp 容器名称:容器目录 需要拷贝的文件或目录
 
# 目录挂载（容器数据卷操作）
 
docker run -di -v /mydata/docker_centos/data:/usr/local/data --name centos7-01 centos:7
 
# 多目录挂载
 
docker run -di -v /宿主机目录:/容器目录 -v /宿主机目录2:/容器目录2 镜像名
 
# 匿名挂载
 
docker run -di -v /usr/local/data --name centos7-02 centos:7
 
# 查看 volume 数据卷信息
 
docker volume ls
 
# 匿名挂载
docker run -di -v docker_centos_data:/usr/local/data --name centos7-03 centos:7
 
# 查看 volume 数据卷信息
docker volume ls
 
# 指定目录挂载
 
docker run -di -v /mydata/docker_centos/data:/usr/local/data --name centos7-01 centos:7
 
# 多目录挂载
 
docker run -di -v /宿主机目录:/容器目录 -v /宿主机目录2:/容器目录2 镜像名
 
# 只读。只能通过修改宿主机内容实现对容器的数据管理。
 
docker run -it -v /宿主机目录:/容器目录:ro 镜像名
 
# 读写，默认。宿主机和容器可以双向操作数据。
 
docker run -it -v /宿主机目录:/容器目录:rw 镜像名
 
# 查看容器 IP 地址
 
docker inspect 容器名称|容器ID
 
#删除容器
 
# 删除指定容器
 
docker rm 容器名称|容器ID
 
# 删除多个容器
 
docker rm 容器名称|容器ID 容器名称|容器ID

四、Docker备份与恢复迁移命令

# docker save 将指定镜像保存成 tar 归档文件。
 
docker save [OPTIONS] IMAGE [IMAGE...]
docker save -o /root/mycentos7.tar mycentos:7
 
# 使用 docker load 导入 docker save 命令导出的镜像归档文件。
 
docker load [OPTIONS]
docker load -i mycentos7.tar
 
# 镜像迁移
 
镜像迁移同时涉及到了上面两个操作，备份和恢复。 我们可以将任何一个 Docker 镜像从一台机器迁移到另一台机器。在迁移过程中，首先我们要把容器构建为 Docker 镜像。然后， 该 Docker 镜像被作为 tar 包文件保存到本地。此时只需要拷贝或移动该镜像到我们想要的机器上，恢复该镜像并运行容器即可。 

五、Docker网络管理命令

# docker 默认网络
 
docker network ls
 
# 通过 docker network create 命令可以创建自定义网络模式，创建一个基于 bridge 网络模式的自定义网络模式 custom_network
 
docker network create custom_network
 
# 通过自定义网络模式 custom_network 创建容器：
 
docker run -di --name bbox05 --net custom_network busybox
 
# 通过 docker network connect 网络名称 容器名称 为容器连接新的网络模式
 
docker network connect bridge bbox05
 
# 通过 docker network disconnect 网络名称 容器名称 命令断开网络
 
docker network disconnect custom_network bbox05
 
# 移除网络
 
docker network rm custom_network
 
# 容器间网络通信
 
docker run -di --name default_bbox01 busybox
 
docker run -di --name default_bbox02 busybox

前面我们使用 Docker 的时候，定义 Dockerfile 文件，然后使用 docker build、docker run 等命令操作容器。然而微服务架构的应用系统一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，那么效率之低，维护量之大可想而知，使用 Docker Compose 可以轻松、高效的管理容器，它是一个用于定义和运行多容器 Docker 的应用程序工具。

Docker Compose 将所管理的容器分为三层，分别是工程（project）、服务（service）、容器（container）。Docker Compose 运行目录下的所有文件（docker-compose.yml）组成一个工程,一个工程包含多个服务，每个服务中定义了容器运行的镜像、参数、依赖，一个服务可包括多个容器实例。

六、Doceker-compose安装

#安装 Docker Compose 可以通过下面命令自动下载适应版本的 Compose，并为安装脚本添加执行权限
 
sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
 
#赋予权限
 
sudo chmod +x /usr/local/bin/docker-compose
 
#查看安装是否成功
 
docker-compose -v

七、Doceker-compose常用命令

# 下载服务镜像
 
docker-compose pull：
 
# ps：列出所有运行容器
 
docker-compose ps
 
# logs：查看服务日志输出
 
docker-compose logs
 
# up：构建、启动容器
 
docker-compose up
 
# kill：通过发送 SIGKILL 信号来停止指定服务的容器
 
docker-compose kill eureka
 
# port：打印绑定的公共端口，下面命令可以输出 eureka 服务 8761 端口所绑定的公共端口
 
docker-compose port eureka 8761
 
# build：构建或者重新构建服务
 
docker-compose build
 
# start：启动指定服务已存在的容器
 
docker-compose start eureka
 
# stop：停止已运行的服务的容器
 
docker-compose stop eureka
 
# rm：删除指定服务的容器
 
docker-compose rm eureka
 
# 设置指定服务运气容器的个数，以 service=num 形式指定
 
docker-compose scale user=3 movie=3
 
# run：在一个服务上执行一个命令
 
docker-compose run web bash

当服务的配置发生更改时，可使用 docker-compose up 命令更新配置，此时，Compose 会删除旧容器并创建新容器，新容器会以不同的 IP 地址加入网络，名称保持不变，任何指向旧容起的连接都会被关闭，重新找到新容器并连接上去。

links：服务之间可以使用服务名称相互访问，links 允许定义一个别名，从而使用该别名访问其它服务
，这样 Web 服务就可以使用 db 或 database 作为 hostname 访问 db 服务了。
 
version: '2'
services:
    web:
        build: .
        links:
            - "db:database"
    db:
        image: postgres
 

八、Doceker-compose详细命令

config
 
docker-compose config -q
 
验证 `docker-compose.yml` 文件。当配置正确时，不输出任何内容，当配置错误时，输出错误信息。

pull
 
docker-compose pull` 拉取服务依赖的镜像。
 
 
# 拉取工程中所有服务依赖的镜像
 
docker-compose pull
 
# 拉取工程中 nginx 服务依赖的镜像
 
docker-compose pull nginx
 
# 拉取镜像过程中不打印拉取进度信息
 
docker-compose pull -q

up
 
`docker-compose up` 创建并启动所有服务的容器。指定多个 yml 加 `-f` 选项。以守护进程模式运行加 `-d` 选项。
 
 
# 前台启动
 
docker-compose up
 
# 后台启动
 
docker-compose up -d
 
# -f 指定使用的 Compose 模板文件，默认为 docker-compose.yml，可以多次指定，指定多个 yml
docker-compose -f docker-compose.yml up -d 
 

logs
 
`docker-compose logs` 查看服务容器的输出日志。默认情况下，docker-compose 将对不同的服务输出使用不同的颜色来区分。可以通过 `--no-color` 来关闭颜色。
 
 
# 输出日志，不同的服务输出使用不同的颜色来区分
 
docker-compose logs
 
# 跟踪日志输出
 
docker-compose logs -f
 
# 关闭颜色
 
docker-compose logs --no-color

ps
　　
`docker-compose ps` 列出工程中所有服务的容器。
 
# 列出工程中所有服务的容器
 
docker-compose ps
 
# 列出工程中指定服务的容器
 
docker-compose ps nginx

run
 
`docker-compose run` 在指定服务容器上执行一个命令。
 
# 在工程中指定服务的容器上执行 echo "helloworld"
 
docker-compose run nginx echo "helloworld"

exec
 
`docker-compose exec` 进入服务容器。
 
 
# 进入工程中指定服务的容器
 
docker-compose exec nginx bash
 
# 当一个服务拥有多个容器时，可通过 --index 参数进入到该服务下的任何容器
 
docker-compose exec --index=1 nginx bash

pause
 
`docker-compose pause` 暂停服务容器。
 
# 暂停工程中所有服务的容器
 
docker-compose pause
 
# 暂停工程中指定服务的容器
 
docker-compose pause nginx

unpause
 
`docker-compose unpause` 恢复服务容器。
 
# 恢复工程中所有服务的容器
 
docker-compose unpause
 
# 恢复工程中指定服务的容器
 
docker-compose unpause nginx

restart
 
`docker-compose restart` 重启服务容器。
 
# 重启工程中所有服务的容器
 
docker-compose restart
 
# 重启工程中指定服务的容器
 
docker-compose restart nginx

start
 
`docker-compose start` 启动服务容器。
 
 
# 启动工程中所有服务的容器
 
docker-compose start
 
# 启动工程中指定服务的容器
 
docker-compose start nginx

stop
 
`docker-compose stop` 停止服务容器。
 
# 停止工程中所有服务的容器
 
docker-compose stop
 
# 停止工程中指定服务的容器
 
docker-compose stop nginx

kill
 
`docker-compose kill` 通过发送 `SIGKILL` 信号停止指定服务的容器。
 
# 通过发送 SIGKILL 信号停止工程中指定服务的容器
 
docker-compose kill nginx

rm
 
`docker-compose rm` 删除服务（停止状态）容器。
 
# 删除所有（停止状态）服务的容器
 
docker-compose rm
 
# 先停止所有服务的容器，再删除所有服务的容器
 
docker-compose rm -s
 
# 不询问是否删除，直接删除
 
docker-compose rm -f
 
# 删除服务容器挂载的数据卷
 
docker-compose rm -v
 
# 删除工程中指定服务的容器
 
docker-compose rm -sv nginx

down
 
停止并删除所有服务的容器、网络、镜像、数据卷。
 
 
# 停止并删除工程中所有服务的容器、网络
 
docker-compose stop
 
# 停止并删除工程中所有服务的容器、网络、镜像
 
docker-compose down --rmi all
 
# 停止并删除工程中所有服务的容器、网络、数据卷
 
docker-compose down -v

images
 
`docker-compose images` 打印服务容器所对应的镜像。
 
# 打印所有服务的容器所对应的镜像
 
docker-compose images
 
# 打印指定服务的容器所对应的镜像
 
docker-compose images nginx

port
 
`docker-compose port` 打印指定服务容器的某个端口所映射的宿主机端口。
 
[root@localhost docker-nginx]# docker-compose port nginx 80
0.0.0.0:80

top
 
`docker-compose top` 显示正在运行的进程。
 
 
# 显示工程中所有服务的容器正在运行的进程
 
docker-compose top
 
# 显示工程中指定服务的容器正在运行的进程
 
docker-compose top nginx

九、Doceker-compose.yaml文件

详细启动一个docek的实例的配置请参考官方文档中的配置和网站上自己搜索对应的docker的配置文件。详细的网站在博文参考中，提供给大家参考。

---------------------Redis 配置指令参考---------------------
version: "2"
 
services:
### console
    console:
        build:
            context: ./images/console
            args:
                # console 容器 www-data用户密码
                - USERPASS=root
                - GIT_NAME=yangnan
                - GIT_EMAIL=20706149@qq.com
                - INSTALL_YARN=false
        volumes_from:
            - php-fpm
            - nginx
            - mysql
            - redis
        volumes:
            - ./ssh:/home/www-data/.ssh
        links:
            - redis
            - mysql
        tty: true
 
### php-fpm
    php-fpm:
        build: ./images/php-fpm
        volumes:
            - ./app/:/var/www/
 
### nginx
    nginx:
        image: nginx
        ports:
            - "8081:80"
        volumes_from:
            - php-fpm
        volumes:
            - ./logs/nginx/:/var/log/nginx/
            - ./images/nginx/sites:/etc/nginx/conf.d/
        links:
            - php-fpm
 
### mysql
    mysql:
        image: mysql
        ports:
            - "7706:3306"
        environment:
            MYSQL_ROOT_PASSWORD: "123"
            MYSQL_DATABASE: "test"
            MYSQL_USER: "root"
            MYSQL_PASSWORD: "123"
        volumes:
            - ./data/mysql:/var/lib/mysql
 
### redis
    redis:
        image: redis
        ports:
            - "6379:6379"
        volumes:
            - ./data/redis:/data

十、Docker compose build

10.1 DockerFile

# 打包项目，获得 jar 包 docker-demo-1.0.jar
 
mvn clean package
 
# 在 jar 包所在路径创建 Dockerfile 文件，添加以下内容
 
FROM java:8
VOLUME /tmp
ADD docker-demo-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
EXPOSE 9000
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

10.2 Docker-compose.yml文件

# 在 jar 包所在路径创建文件 docker-compose.yml，添加以下内容
 
version: '2' # 表示该 Docker-Compose 文件使用的是 Version 2 file
services:
  docker-demo:  # 指定服务名称
    build: .  # 指定 Dockerfile 所在路径
    ports:    # 指定端口映射
      - "9000:8761"

10.3 Docker-compose up 编译

# 在 docker-compose.yml 所在路径下执行该命令 Compose 就会自动构建镜像并使用镜像启动容器
 
访问 http://localhost:9000/hello 即可访问微服务接口
 
 
docker-compose up
 
docker-compose up -d  // 后台启动并运行容器

 十一、Docker swarm命令

# 初始化集群
 
docker swarm init 	
 
# 查看工作节点的 token
 
docker swarm join-token worker 	
 
# 查看管理节点的 token
 
docker swarm join-token manager
 
# 加入集群
 
docker swarm join 	

# 查看集群所有节点
 
docker node ls 
	
# 查看当前节点所有任务
 
docker node ps
 
# 删除节点（-f强制删除）
 	
docker node rm 节点名称| 节点ID
 
# 查看节点详情
 	
docker node inspect 节点名称| 节点ID 
	
# 节点降级，由管理节点降级为工作节点
 
docker node demote 节点名称| 节点ID 	
 
# 节点升级，由工作节点升级为管理节点
 
docker node promote 节点名称| 节点ID 	
 
# 更新节点
 
docker node update 节点名称| 节点ID 	

创建服务
 
docker service create
 
# 查看所有服务
 
docker service ls 	
 
# 查看服务详情
 
docker service inspect 服务名称|服务ID
 	
# 查看服务日志
 
docker service logs 服务名称|服务ID
 	
# 删除服务（-f强制删除）
 
docker service rm 服务名称|服务ID
 	
# 设置服务数量
 
docker service scale 服务名称|服务ID=n 	
 
# 更新服务
 
docker service update 服务名称|服务ID 	

11.1 创建服务

docker service create --replicas 1 --name mynginx -p 80:80 nginx

• docker service create：创建服务；
• --replicas：指定一个服务有几个实例运行；
• --name：服务名称。

可以通过 docker service ls 查看运行的服务。

[root@manager1 ~]# docker service ls
 
ID                NAME           MODE              REPLICAS        IMAGE              PORTS
hepx06k5ik5n      mynginx        replicated        1/1             nginx:latest       *:80->80/tcp

可以通过 docker service inspect 服务名称|服务ID 查看服务的详细信息。

[root@manager1 ~]# docker service inspect mynginx
[
    {
        "ID": "k0dbjg1zzy3l3g71kdwa56ect",
        "Version": {
            "Index": 127
        },
        "CreatedAt": "2020-09-16T10:05:55.627974095Z",
        "UpdatedAt": "2020-09-16T10:05:55.629507771Z",
        "Spec": {
            "Name": "mynginx",
            "Labels": {},
            "TaskTemplate": {
                "ContainerSpec": {
                    "Image": "nginx:latest@sha256:c628b67d21744fce822d22fdcc0389f6bd763daac23a6b77147d0712ea7102d0",
                    "Init": false,
                    "StopGracePeriod": 10000000000,
                    "DNSConfig": {},
                    "Isolation": "default"
                },
                "Resources": {
                    "Limits": {},
                    "Reservations": {}
                },
                "RestartPolicy": {
                    "Condition": "any",
                    "Delay": 5000000000,
                    "MaxAttempts": 0
                },
                "Placement": {
                    "Platforms": [
                        {
                            "Architecture": "amd64",
                            "OS": "linux"
                        },
                        {
                            "OS": "linux"
                        },
                        {
                            "OS": "linux"
                        },
                        {
                            "Architecture": "arm64",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "386",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "mips64le",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "ppc64le",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "s390x",
                            "OS": "linux"
                        }
                    ]
                },
                "ForceUpdate": 0,
                "Runtime": "container"
            },
            "Mode": {
                "Replicated": {
                    "Replicas": 1
                }
            },
            "UpdateConfig": {
                "Parallelism": 1,
                "FailureAction": "pause",
                "Monitor": 5000000000,
                "MaxFailureRatio": 0,
                "Order": "stop-first"
            },
            "RollbackConfig": {
                "Parallelism": 1,
                "FailureAction": "pause",
                "Monitor": 5000000000,
                "MaxFailureRatio": 0,
                "Order": "stop-first"
            },
            "EndpointSpec": {
                "Mode": "vip",
                "Ports": [
                    {
                        "Protocol": "tcp",
                        "TargetPort": 80,
                        "PublishedPort": 80,
                        "PublishMode": "ingress"
                    }
                ]
            }
        },
        "Endpoint": {
            "Spec": {
                "Mode": "vip",
                "Ports": [
                    {
                        "Protocol": "tcp",
                        "TargetPort": 80,
                        "PublishedPort": 80,
                        "PublishMode": "ingress"
                    }
                ]
            },
            "Ports": [
                {
                    "Protocol": "tcp",
                    "TargetPort": 80,
                    "PublishedPort": 80,
                    "PublishMode": "ingress"
                }
            ],
            "VirtualIPs": [
                {
                    "NetworkID": "st2xiy7pjzap093wz4w4u6nbs",
                    "Addr": "10.0.0.15/24"
                }
            ]
        }
    }
]

可以通过 docker service ps 服务名称|服务ID 查看服务运行在哪些节点上。

 在对应的任务节点上运行 docker ps 可以查看该服务对应容器的相关信息。

11.2 创建服务

接下来我们测试一下服务是否能被正常访问，并且该集群下任意节点的 IP 地址都要能访问到该服务才行。测试结果：5 台机器均可正常访问到该服务。

11.3 弹性服务

将 service 部署到集群以后，可以通过命令弹性扩缩容 service 中的容器数量。在 service 中运行的容器被称为 task（任务）。 通过docker service scale服务名称|服务ID=n 可以将 service 运行的任务扩缩容为 n 个。 通过 docker service update --replicas n 服务名称|服务ID 也可以达到扩缩容的效果。 将 mynginx service 运行的任务扩展为 5 个：

[root@manager1 ~]# docker service scale mynginx=5
mynginx scaled to 5
overall progress: 5 out of 5 tasks 
1/5: running   [==================================================>] 
2/5: running   [==================================================>] 
3/5: running   [==================================================>] 
4/5: running   [==================================================>] 
5/5: running   [==================================================>] 
verify: Service converged

通过 docker service ps 服务名称|服务ID 查看服务运行在哪些节点上。

我们再来一波缩容的操作，命令如下：

[root@manager1 ~]# docker service update --replicas 3 mynginx
mynginx
overall progress: 3 out of 3 tasks 
1/3: running   [==================================================>] 
2/3: running   [==================================================>] 
3/3: running   [==================================================>] 
verify: Service converged

通过 docker service ps 服务名称|服务ID 查看服务运行在哪些节点上。

 在 Swarm 集群模式下真正意义实现了所谓的弹性服务，动态扩缩容一行命令搞定，简单、便捷、强大。

11.4 删除服务

通过 docker service rm 服务名称|服务ID 即可删除服务。

[root@manager1 ~]# docker service rm mynginx
 
mynginx
 
[root@manager1 ~]# docker service ls
ID                NAME              MODE              REPLICAS          IMAGE             PORTS

11.5 容器的滚动更新及回滚

Redis 版本如何滚动升级至更高版本再回滚至上一次的操作。 首先，创建 5 个 Redis 服务副本，版本为 5，详细命令如下：

# 创建 5 个副本，每次更新 2 个，更新间隔 10s，20% 任务失败继续执行，超出 20% 执行回滚，每次回滚 2 个
 
docker service create --replicas 5 --name redis \
--update-delay 10s \
--update-parallelism 2 \
--update-failure-action continue \
--rollback-monitor 20s \
--rollback-parallelism 2 \
--rollback-max-failure-ratio 0.2 \
redis:5

--update-delay：定义滚动更新的时间间隔；
 
--update-parallelism：定义并行更新的副本数量，默认为 1；
 
--update-failure-action：定义容器启动失败之后所执行的动作；
 
--rollback-monitor：定义回滚的监控时间；
 
--rollback-parallelism：定义并行回滚的副本数量；
 
--rollback-max-failure-ratio：任务失败回滚比率，超过该比率执行回滚操作，0.2 表示 20%。

然后通过以下命令实现服务的滚动更新。

docker service update --image redis:6 redis

 回滚服务，只能回滚到上一次操作的状态，并不能连续回滚到指定操作。

docker service update --rollback redis

博文参考

命令说明 - Docker —— 从入门到实践

Docker Compose | 菜鸟教程

Docker：Docker Compose 详解 - 简书

docker -compose 容器常用命令 - 时光一寸灰 - 博客园

https://www.exception.site/docker

Docker Dockerfile | 菜鸟教程