docker学习笔记

 curl -fsSL get.docker.com -o get-docker.sh
 sudo sh get-docker.sh --mirror Aliyun
 # 开机启动 docker
 sudo systemctl enable docker
 # 启动 docker
 sudo systemctl start docker

2. 阿里云镜像加速

注意！registry-mirrors 需要替换成自己的阿里云镜像加速器地址，通过点击地址获取

 sudo mkdir -p /etc/docker
 sudo tee /etc/docker/daemon.json <<-'EOF'
 {
   "registry-mirrors": ["这里替换成自己的阿里云镜像加速器地址"]
 }
 EOF
 sudo systemctl daemon-reload
 sudo systemctl restart docker

Docker CLI

CLI 是 Command-Line Interface （命令行界面）的缩写命令详情可以参考官方文档：Docker Reference Documentation

这里通过几个场景，把 Docker 先用起来

# 镜像操作
     # 拉取 tomcat 镜像
     docker pull tomcat:8.0-jre8
     # 查看镜像列表，可以看到 tomcat 镜像，该命令等特于：docker image ls
     docker images
     # 删除镜像
     docker image rm tomcat:8.0-jre8
     # 运行tomcat 镜像 前台运行，会输出 tomcat 日志 按 Ctrl + C 停止
     docker run tomcat:8.0-jre8
     # 添加 -d 后台运行参数
     docker run -d tomcat:8.0-jre8
 # 容器操作
     # 查看运行的容器 查看到容器的id、镜像(IMAGE)、状态(STATUS)、网络端口(PROT)、容器名称(NAME)等信息
     docker ps
     # -a 参数查看全部所有容器的列表
     docker ps -a
     # 运行容器 -p 将容器内的网络端口映射到宿主机 ，8080:8080 前面为宿主机，后面为容器 --name 指定容器名称 -d 后台运行 
     docker run -p 8080:8080 -d --name mytomcat tomcat:8.0-jre8
     # 停止容器
     docker stop 容器id或名称
     # 启动已经停止的容器
     docker start 容器id或名称
     # 进入容器 i 和 t 参数可以让我们以伪终端的方式进入容器 bash 是所使用 shell
     docker exec -it 容器id或名称 bash
     # 退出容器，回到宿主机（宿主机就是安装 Docker 的这台机器）
     exit
     # 删除容器，如果容器还在运行需要加 -f 参数
     docker rm 容器id或名称
     docker rm -f 容器id或名称
     # 结合 rm -f 就可以移除所有的容器了
     docker rm -f $(docker ps -aq)
     # 查看 容器 日志，
     docker logs 容器id或名称
     # 查看容器内部进程信息
     docker top 容器id或名称
         
 # 数据卷 作用：将宿主机文件与容器文件绑定
     #使用数据卷 
         #自定义数据卷目录 启动时加 -v
         docker run -p 8080:8080 -d -v 宿主机文件路径：容器文件路径 --name mytomcat tomcat:8.0-jre8
         # 自动数据卷目录 aa代表数据卷名字，可以随便写，docker再不存在时自动创建这个数据卷
         docker run -p 8080:8080 -d -v aa:容器文件路径 --name mytomcat tomcat:8.0-jre8
     #查看数据卷
     docker volume ls
     # 查看某个数据卷的信息
     docker volume inspect 卷名
     # 创建数据卷
     docker volume create 卷名
     # 删除没有使用的数据卷
     docker volume prune
     # 删除指定的数据卷
     docker volume rm 卷m

场景0：Tomcat

# 输入 docker 回车，docker 的命令会被罗列出来，便于查询
 docker
 
 # 查询有那些 tomcat 镜像
 docker search tomcat

相对于直接search，使用搜索 Docker Hub 更方便

搜索 Tomcat

可以看到相关的镜像介绍、使用帮助、历史版本：Tomcat

可以按照文档中的 "How to use this image" 的提示来运行镜像

# 拉取 tomcat 镜像
 docker pull tomcat:8.0-jre8
 
 # 查看镜像列表，可以看到 tomcat 镜像，该命令等特于：docker image ls
 docker images
 # 删除镜像
 docker image rm tomcat:8.0-jre8
 
 # 运行tomcat 镜像
 docker run tomcat:8.0-jre8
 
 # 前台运行，会输出 tomcat 日志
 # 按 Ctrl + C 停止
 
 
 # 添加 -d 后台运行参数
 docker run -d tomcat:8.0-jre8
 # 查看容器列表，可以查看到容器的id、镜像(IMAGE)、状态(STATUS)、网络端口(PROT)、容器名称(NAME)等信息
 docker ps
 # 查看 tomcat 日志，
 docker logs 容器id或名称
 
 
 # 查看容器内部进程信息
 docker top 容器id或名称
 
 # 进入容器
 # i 和 t 参数可以让我们以伪终端的方式进入容器
 # bash 是所使用 shell
 docker exec -it 容器id或名称 bash
 # 在容器内可以使用 Linux 命令
 
 # 退出容器，回到宿主机（宿主机就是安装 Docker 的这台机器）
 exit
 
 # 不需要容器了，可以停止容器
 docker stop 容器id或名称
 
 
 # 启动已经停止的容器
 docker start 容器id或名称
 
 # 删除容器，如果容器还在运行需要加 -f 参数
 docker rm 容器id或名称
 docker rm -f 容器id或名称
 
 # 删除了容器，就可以把镜像也删除了，如果有容器还是该镜像需要加 -f 参数
 docker rmi tomcat:8.0-jre8
 docker rmi -f tomcat:8.0-jre8

场景1：Tomcat

只是将 Tomcat 容器 run 起来，还是无法满足使用还需要将容器网络端口映射到宿主机才可以使得外部可以访问容器内部服务为了方便还需要把 Tomcat 的数据目录和配置目录挂载到宿主机，方便直接进行编辑

可参考官方文档：Tomcat


# 部署 Tomcat
 # run 容器时，本地不存在对应镜像，会自动 pull
 # -p 将容器内的网络端口映射到宿主机 ，8080:8080 前面为宿主机，后面为容器
 # --name 指定容器名称
 # -d 后台运行
 docker run -p 8080:8080 -d --name mytomcat tomcat:8.0-jre8
 
 # 可以通过 docker 的子命令对 容器进行操作，比如：ps,exec,top,stop
 
 # 这个容器已经占用了宿主机的 8080 端口，为了后续的 Tomcat 可以绑定到宿主机的 8080 端口，所以将 这个容器 stop
 docker stop mytomcat
 
 # 通过数据卷的方式 将容器内的数据映射到宿主机
 # 语法：- v 数据卷名称:容器内目录
 # Tomcat 部署的 web应用目录：/usr/local/tomcat/webapps
 # 配置文件：/usr/local/tomcat/conf
 docker run -p 8080:8080 -v apps:/usr/local/tomcat/webapps -v confs:/usr/local/tomcat/conf -d --name mytomcat2 tomcat:8.0-jre8
这个时候 Tomcat 已经启动了，可以通过 http://ip宿主机:8080 来访问 Tomcat 的默认主页，例如我的访问地址 http://192.168.43.166:8080 ，看到汤姆猫的图标就成功了。如果访问失败，可能是对应的 8080 端口没有开放，CentOS7 可以参考：CentOS7开启端口

场景2：MySQL
可参考官方文档：MySQL

 # 通过 -e 指定参数，指定 MySQL 的 root 账户的密码为：1234
 docker run --name mysql -e MYSQL_ROOT_PASSWORD=1234 -p 3306:3306 -d mysql:5.7.32
 
 # 停止容器，防止端口占用
 docker stop mysql
 
 # 数据库的数据将会随着容器消失而消失，所以需要将数据库文件持久化到宿主机，
 # 配置映射到本地
 docker run --name mysql2 -e MYSQL_ROOT_PASSWORD=1234 -p 3306:3306 -d -v mysqldata:/var/lib/mysql -v mysqlconfig:/etc/mysql  mysql:5.7.32

MySQL 就成功运行了，可以通过 Navicat 或者其他工具测试数据库，地址为宿主机 ip地址，用户名为 root，密码为：1234，可以尝试存储数据，数据会被存储在数据卷，这里指定的数据卷名称为：mysqldata

# 查看所有数据卷
 docker volume ls
 # 查看 MySQL 的数据卷
 docker inspect mysqldata
 # 返回的 json 对象，其中 Mountpoint 的值就是，文件对应挂载的位置
 
 # 我这里挂载的地址为：/var/lib/docker/volumes/mysqldata/_data
 # 进入这个目录，就可以看到存储的文件

使用数据卷的好处在于：容器被移除了，重新运行一个新容器，直接挂载原来的数据卷就可了，数据不会丢失

# 移除容器
docker rm -f mysql2
# 重新运行新的容器，并挂载原来的数据卷
docker run --name mysql2 -e MYSQL_ROOT_PASSWORD=1234 -p 3306:3306 -d -v mysqldata:/var/lib/mysql -v mysqlconfig:/etc/mysql  mysql:5.7.32

场景2：Redis

可参考官方文档：Redis

需要注意的是：Redis 需要在镜像名称即 redis:5.0.10 的后面添加 redis-server --appendonly yes ，以此覆盖镜像默认的命令

docker run --name redis -p 6379:6379 -d redis:5.0.10

# 停止容器，防止端口占用
docker stop redis

# 开启持久化 redis-server --appendonly yes
# 开启后，持久化生成的 aop 文件会被放入容器中的 /data 目录中
docker run --name redis2 -p 6379:6379 -d -v redisdata:/data redis:5.0.10 redis-server --appendonly yes
# 可以使用 Redis Desktop Manager 等工具，通过宿主机 ip 连接，进行测试

清理容器

# 查看容器列表可以看到很多容器
docker ps
# -a 可以看到所有的容器，包括已经停止的
docker ps -a
# 如果忘记了参数或者命令可以在命令后面加上 --help，会有提示
docker ps --help
# 可以看到：-q, --quiet   Only display container IDs，即：-q参数仅输出容器id，结合 -a，可以输出所有容器的 id
docker ps -aq
# 结合 rm -f 就可以移除所有的容器了
docker rm -f $(docker ps -aq)

# 清除没有用到的数据卷，有重要数据要谨慎
docker volume prune

docker

我们可以通过下面的命令，来找到 docker 的位置

whereis docker
# 我这里执行返回的结果是：docker: /usr/bin/docker /etc/docker /usr/libexec/docker /usr/share/man/man1/docker.1.gz

可以看到 docker 的可执行文件位于 /usr/bin，这个路径存在环境变量 PATH 中，所以我们可以在任意路径使用 docker 命令

Docker 是 C/S 架构模式（客户端-服务器），所以上面的 docker 实际上是 Docker 的客户端，Docker 的服务器是 Docker Deamon 对应的就是 dockerd，也在这个目录下，Deamon 就是 Docker 引擎，Docker 客户端通过 Docker API 与 Deamon 进行通信

docker 是一个可执行程序，包含了许多命令，输入

docker --help

会将 Usage（用法）、Option（选项）、Commands（命令）都展示出来，Management Commands 也s是 Commands。每个命令可能会有它自己的子命令、选项

# run 命令有许多的选项
docker run --help
# volume 命令有许多子命令，例如：ls, rm, inspect
docker volume --help

命令梳理

使用 --help 参数，就可以查询到到对应命令的使用方法，所以我们只要理解 Docker 命令的框架即可，不用记忆命令细节对镜像进行操作：images, rmi, search 对容器进行操作：run, stop, start, restart, exec, logs, top 其他：ps, cp, info, pull, version

还有一些 Management Commands，例如：image, network, volume 这些命令都是名词，即要操作的对象，而具体的操作通过其子命令指定，语义更加清晰 image 常用子命令：ls, rm, prune network 常用子命令：create, ls, inspect, rm, prune volume 常用子命令：同上面 network 的四个

Dockerfile 实践及梳理

Dockerfile 是一个文本文件，我们可以通过组合一条条的指令 (Instruction)，来构建满足我们需求的 Docker 镜像

文档

Best practices for writing Dockerfiles

Reference

Dockerfile 指令详解

简单上手

使用 Dockerfile 构建SpringBoot 工程的镜像

新建 SpringBoot 项目，默认的端口是 8080 ，新建 Controller 和 Mapping

@RestController
public class HelloController {
    @GetMapping("hello")
    public String hello() {
        return "hello world!";
    }
}

启动项目，访问 http://localhost:8080/hello 测试

打 jar 包注意，需要在 pom 中添加 spring-boot-maven-plugin 插件，否则运行 jar 包时会提示：没有主清单属性

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
#打包
mvn package

target 目录下就可以找到 .jar 文件，我这里的文件名为：demo-0.0.1-SNAPSHOT.jar 在 Linux 新建 ~/springboot 文件夹，并将 jar 包上传到这个文件夹下

新建 Dockerfile 在这个文件下新建 Dockerfile 文件

# 基于 openjdk:8-jre 这个基础镜像进行构建
FROM openjdk:8-jre

# 这里的 demo-0.0.1- SNAPSHOT.jar 要对应上传的 jar 包名称
# 将 本地 jar包 复制到容器内
COPY demo-0.0.1-SNAPSHOT.jar  app.jar

# 开放 8080 端口
EXPOSE 8080

# 运行命令、参数
ENTRYPOINT ["java","-jar"]
CMD ["app.jar"]

保存文件，退出编辑器

编译 Docker 镜像

# build 是构建 Docker 镜像的命令
# -t 指定镜像的 tag
# 名称：demo 版本：v1.0
# 最后的 . 表示 build context 目录为当前目录，目的是为了找到 所需的 jar 包
docker build -t demo:v1.0 .

启动容器

# 前台启动刚构建的 SpringBoot 容器
# -p 映射容器8080端口 到宿主机的 8080 上
docker run -p 8080:8080 demo:v1.0

测试访问 Linux 的8080 端口，注意替换为自己的 Linux 的地址，并开放 8080 端口

http://192.168.43.161:8080/hello

build context

Dockerfile 默认会使用它自己所在的目录作为 context，通过 docker 执行构建命令后，Docker daemon 会拷贝 context 目录下的所有文件，所以 context 目录不要放置项目无关的文件，或者可以使用 .dockerignore 定义忽略文件，也可以指定 context 路径

# build 命令通过 Dockerfile 构建镜像
# 指定 ~/dockerfile 为 build context
docker build ~/dockerfile
# 不需要添加文件到 context 可以使用 -
docker build -

可以通过 stdin 的方式，避免生产 Dockerfile 文件，直接 build 镜像

docker build -t myimage:latest -<<EOF
FROM busybox
RUN echo "hello world"
EOF

除了可以指定 context外，还可以通过-f 指定 Dockerfile 所在的路径

docker build  -f dockerfiles/Dockerfile .

最佳实践

非常推荐官方的 Dockerfile最佳实践：Best practices for writing Dockerfiles

每个容器单一职责，有利于横向拓展和复用
旧版强调减少层数以提高性能，现在只有 RUN, COPY, ADD 这几个命令会创建层，其他命令只会创建中间层。并且只有使用到资源最终会被拷贝到最终镜像
多个参数按字母顺序排列，并使用空格和 \ 进行分割，提高可读性
--no-cache 不使用缓存，默认 build 过程中如果检查到有可重用的镜像层则使用。从基础镜像开始，每一条命令逐一检查，如果命令不一样则缓存失效。使用 ADD 和 COPY 则会校验使用到的文件校验和是否相同，除了这两个命令，其他则不会通过文件变化来决定是否匹配缓存，而是仅通过命令本身是否一致来判断是否匹配缓存，比如：RUN apt-get -y update会改变容器内的文件，但是也只使用这个命令匹配缓存，而不会通过文件的变动。一旦缓存失效，后续都会产生新的镜像层

Dockerfile 指令 (instructions)

FROM

Dockerfile 的第一个命令一般都是 FROM，通过这个指定该镜像的 Base Image，推荐基础镜像：alpine，因为它完整且轻量，如果不需要 Base Image 可以用 FROM scratch，代表该镜像基于一个空镜像进行构建

RUN

由于上面提到的缓存匹配原则，RUN apt-get update 命令可能会导致直接使用了原来缓存的镜像层，而没有执行该命令获取最新的软件列表，可以使用 RUN apt-get update && apt-get install -y 来使缓存失效可以使用 \ 分割，提高可读性：

RUN apt-get update && apt-get install -y \
    curl

CMD

指定容器启动时运行的命令，通常默认采用的格式：CMD ["executable", "param1", "param2"…]，如：

CMD ["perl", "-de0"]

这样使用 docker run -it 命令进入容器时，就会默认进入 shell 界面

EXPOSE

指定容器需要监听的端口

ENV

可以使用 ENV 更新 PATH 环境变量，例如

ENV PATH=/usr/local/nginx/bin:$PATH

注意！每一个 ENV 指令都会创建一个新的中间层 (intermediate layer)，如果使用 ENV 设置了变量，在未来的层 unset 了变量，那么它在 unset 之前依然是可用的。为了防止这种情况，我们应该用 RUN 进行环境变量的设置和取消

ENV ADMIN_USER="mark"
RUN echo $ADMIN_USER > ./mark
RUN unset ADMIN_USER

ADD or COPY

两个命令功能相似，优先使用COPY，它的作用只是将本地文件拷贝到容器内，而 ADD 则有其他特性，比如：自动将本地 tar 文件提取到镜像中、远程URL 如果多个步骤需要使用不同的文件，应该单独 COPY，而不是一次性 COPY，这样部分文件变化不会导致所有的缓存都失效避免使用 ADD 通过 URL 获取包，可以使用 curl 或者 wget，这样可以在提取后删除文件，避免镜像多一层，还可以通过管道，就不需要再手动删除中间文件

RUN mkdir -p /usr/src/things \
    && curl -SL https://example.com/big.tar.xz \
    | tar -xJC /usr/src/things \
    && make -C /usr/src/things all

ENTRYPOINT

使用 ENTRYPOINT 设置主命令，还可以用 CMD 设置默认的可选参数

ENTRYPOINT ["s3cmd"]
CMD ["--help"]

运行编译镜像，指定名称为：s3cmd，运行容器

docker run s3cmd

默认会运行 s3cmd 并带上 --help 参数，即：显示该命令的帮助

运行下面命令：

docker run s3cmd ls s3://mybucket
ls s3://mybucket` 会覆盖默认可选参数 `--help

如果需要覆盖 ENTRYPOINT，需要使用 --entrypoint 参数

VOLUME

暴露镜像中可变和用户可修改的数据，比如：存储文件、配置文件，比如：

VOLUME /data

设置的目录会在容器运行时自动挂载为匿名卷，如果没有设置，就会写入容器存储层

USER

如果不需要使用 sudo ，可以通过 USER 切换到非 root 用户，例如：

RUN groupadd -r postgres && useradd --no-log-init -r -g postgres postgres

WORKDIR

WORKDIR 指令可以来指定工作目录，不存在会自动创建 Dockerfile 不同于 Shell，下面的命令其实是不同的层，第一条的 cd 不会影响第二条命令，最终运行结束会导致在 /app 下找不到 world.txt 文件

RUN cd /app
RUN echo "hello" > world.txt

应该使用：

WORKDIR /app
RUN echo "hello" > world.txt

Docker Compose 实践及梳理

Docker Compose 可以实现 Docker 容器集群的编排，可以通过 docker-compose.yml 文件，定义我们的服务及其需要的依赖，轻松地运行在测试、生产等环境

文档

Product manuals

Compose file version 3 reference

Docker 从入门到实践【中文】

安装 Compose

Compose 依赖 Docker Engine，所有要保证环境安装了 Docker，可参考官方教程，主要分为两步：

# 1. 下载 Compose 只执行文件到 usr/local/bin/ 目录
# 下载失败可以参考下一小结提供地址安装
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 2. 对 Compose 可执行文件添加运行权限
sudo chmod +x /usr/local/bin/docker-compose

# 输入下面命令查看帮助，测试安装是否成功
docker-compose -h

Compose 开源在 Docker 官方的 GitHub 仓库：docker/compose，所有的 Compose 都会发布在仓库的 Releases 里，步骤1就是使用 curl 命令从 Releases 里下载可执行文件，uname -s和uname -m 可以读取系统的内核名称和硬件架构，用来匹配需要的 Compose 版本， curl 的 -L 参数会让 HTTP 请求跟随重定向（默认不跟随），-o (小写o) 会将服务器响应保存成文件，直接下载到：usr/local/bin/ 下，文件名为：docker-compose，因为这个路径已经在环境变量中了，所以完成步骤2，添加可执行权限后，就可以在任意位置使用了

直接从 GitHub 下载比较慢可以通过以下地址下载：

# https://vuepress.mirror.docker-practice.com/compose/install/
sudo curl -L https://download.fastgit.org/docker/compose/releases/download/1.27.4/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

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

入门

Compose 的模版指令与 Docker 的 run 命令相关参数很相似，忘记了 docker 命令可以参考之前的一篇博客：Docker 实践及命令梳理

Compose 中有两个重要的概念：

服务 (service)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例
项目 (project)：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义

docker-compose.yml 格式如下，注意：YAML 文件必须要键值之间的 : 后面必须有一个空格，缩进表示层级，要注意缩进有使用到的 volumes 和 networks 必须声明

# 指定版本
version: "3"
# 服务的集合
services:
  # 其中一个服务，服务名为：webapp
  webapp:
    # 指定该服务使用的镜像
    image: examples/web
    # 端口映射
    ports:
      - "80:80"
    # 数据卷
    volumes:
      - "/data"

简单上手

在一个 Compose 中启动 Tomcat, MySQL, redis，创建 docker-compose.yml

version: "3.0"

services:
  tomcat:
    container_name: mytomcat # --name
    image: tomcat:8.0-jre8
    ports:
      - "8080:8080"
    volumes:
      - "tomcatwebapps:/usr/local/tomcat/webapps"
    networks:
      - some_network
    # tomcat 服务依赖于 mysql 和 redis
    depends_on:
      - mysql
      - redis
  mysql:
    container_name: mysql
    image: mysql:5.7.32
    ports:
      - "3306:3306"
    volumes:
      - "mysqldata:/var/lib/mysql"
      - "mysqlconf:/etc/mysql"
    environment:
      - MYSQL_ROOT_PASSWORD=1234
    networks:
      some_network:
  redis:
    container_name: redis
    image: redis:5.0.10
    ports:
      - "6379:6379"
    volumes:
      - "redisdata:/data"
    command: "redis-server --appendonly yes"
    networks:
      some_network:

# 使用到的 volumes 和 networks 必须声明
volumes:
  tomcatwebapps: 
  mysqldata:
  mysqlconf:
  redisdata: 

networks:
  # 声明名称为 “some_network” 的网络
  some_network:

在 docker-compose.yml 所在路径执行 docker-compose up 启动 Compose 项目，它会下载使用到的镜像并在前台运行打印日志，可以使用 Ctrl + C 终止

如果需要后台运行执行 docker-compose up -d，这时候使用 docker ps 可以看到 Compose 已经根据 yaml 创建了相关的容器，使用 docker-compose down 停止 Compse 并移除自动创建的网桥

使用 docker network ls 查看网络或者 docker volume ls 查看数据卷，Compose 定义的网络或数据卷名称格式为：docker-compose.yml所在文件夹的名称加上下划线再加上 yaml 中定义名称，如果在 "dockerfile" 文件夹下创建 yaml 文件并启动，那么网络名称为：dockerfile_some_network

tomcat 服务使用了 depends_on，表示它依赖于 redis 和 mysql 服务，Compose 将优先启动它的依赖再启动它

命令梳理

Docker Compose 的命令与 Dokcer 类似，可以使用 --help 参数，就可以查询到到对应命令的使用方法

docker-compose --help

默认启动的模版文件名为 docker-compose.yml，可以使用 -f 指定自定义的模版文件可以通过 config 命令，检查模版文件语法是否正确

docker-compse 也包含很多子命令：启动停止相关：up, down, restart, stop, pasue, unpause

资源相关：ps, top, kill, run

进入容器：exec

查看日志：logs

很多子命令都可以在后面跟上某个具体的 service 名称，定向地操作，下面不一一举例，可以使用docker-compose help 再跟上子命令名称，查询其用法

# 后台启动 yaml 定义的所有容器
docker-compose up -d
# 仅启动 mysql 这个service，会启动其依赖的 service
docker-compose up mysql 指定启动的server名称，
# 停止容器并移除自动创建的网桥
docker-compose down 
# 重启所有 service 后面可以指定上某个具体的 service
docker-compose restart

# 暂停 和 恢复
docker-compose pause
docker-compose unpause

# 进入 redis 这个 service 使用 exit 退出
docker-compose exec redis bash

# 列出当前 yaml 中定义的容器的信息
docker-compose ps

# 删除当前 yaml 中定义的容器，需要先 stop，后面可以指定上某个具体的 service
docker-compose rm

# 查看各个 service 容器内运行的进程情况
docker-compose top

# 查看日志默认查看 yaml 所有的，可以跟上具体 service
# -f 可以保持跟踪，新的日志会马上显示在屏幕上
docker-compose logs
# 运行docker可视化工具portainer
sudo docker run -d -p 9000:9000 --name portainer --restart=always  -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer