docker学习笔记

Docker

• 官方文档地址：https://www.docker.com/get-started
• 中文参考文档：https://docker_practice.gitee.io/zh-cn/

Docker优势

• 环境一致，高效迁移，docker可以将程序与依赖环境统一打包成为镜像
• 进程级隔离、容器之间相互独立
• 镜像机制、便于部署

Docker与虚拟机

1. 启动速度不同，docker启动速度快速
2. 性能损耗不同，docker需要的资源更少
3. 系统利用率不同，docker对系统的利用率远超与虚拟机
4. 隔离性不同，docker为进程级隔离，虚拟机为系统级隔离
5. 部署速度不同，docker可以快速部署

安装

docker安装

# 卸载老版本
 sudo yum remove docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
# 设置仓库
 sudo yum install -y yum-utils
 sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# 安装docker引擎
 sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 开启docker
sudo systemctl start docker

# 运行helloworld
sudo docker run hello-world

bash安装(通用安装)

#下载docker
curl -fsSL get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun
#启动docker
sudo systemctl enable docker
sudo systemctl start docker
#创建docker用户组
sudo groupadd docker
#将当前用户加入docker组
sudo usermod -aG docker $USER

概念

镜像

镜像是原子化的逻辑镜像=物理镜像+环境镜像+OS镜像；逻辑镜像是应用模板

容器

容器本质上是多个镜像加载到内存中的副本的组合，因此容器是OS级别的隔离，最终表现为精简的OS+运行需要的环境+对应的应用，比如tomcat容器就是精简的OS+jdk+tomcat。 镜像每次运行之后就产生一个容器，容器就是镜像实例，也就是应用。

仓库

用来存放镜像的位置，类似于maven仓库，也是镜像下载和上传的位置，有远程和本地仓库之分。

• 本地仓库：主要用于存储docker pull命令拉取的镜像信息，一般存放与：/var/lib/docker

docker核心架构图

镜像加速配置

1. 登录阿里云
2. 进入控制台
3. 搜索镜像加速服务
4. 配置

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["阿里云镜像地址"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

docker命令

辅助命令

# 查看docker版本信息
docker version
# 查看docker详细信息
docker info
# 查看帮助信息
docker --help

镜像命令

• 查看已有镜像

# 显示全部信息
docker images
# 显示镜像ID
docker images -q
# 显示所有镜像信息
docker images -a
# 格式化输出
docker images --format "{{.ID}}:{{.Repository}}"

格式化占位符

占位符	描述
.ID	镜像id
.Repository	镜像名称
.Tag	镜像标签
.Digest	镜像简介
.CreatedSince	自创以来经过的时间
.CreatedAt	创建镜像的时间
.Size	镜像大小

• 下载镜像

# 拉取镜像时不携带版本号时，则下载最新
docker pull 镜像名称[:version]

• 搜索镜像

docker search 镜像名称

• 删除镜像

#强制删除指定镜像
docker image rm -f 镜像名称
#强制删除全部镜像
docker image rm -f $(docker images -q) 

• 打包镜像

docker save [容器ID]|[容器名称]:[tag] -o [名称].tar

• 载入镜像

docker load -i [名称].tar

容器命令

• 查看正在运行的容器

# 查看正在运行的容器信息
docker ps 
# 查看所有容器信息
docker ps -a
# 查看所有容器ID
docker ps -q

docker run 启动参数

参数名	作用	edge
-p	端口映射,可以通过-p参数同时绑定多个端口	-p [宿主机端口]:[容器端口] (8080:8080)
-d	后台运行	-d
-v	数据卷映射， 即宿主机目录和容器内目录进行绑定以同步,数据卷只有在首次启动时设置	-v [宿主机目录]:[容器内目录路径]
–name	容器名称	–name mongodb
-e	设置系统变量	-e [变量名]=[变量值]
–restart	docker重启时，添加–restart=always参数的容器也会随之重启配置	–restart=always

• 创建启动容器

docker run 镜像名|镜像ID

• 绑定端口

# 绑定单个端口
docker run -p 8080:8080 tomcat:8.0
# 绑定多个端口
docker run -p 9200:9200 -p 9300:9300  elasticsearch:7.14.0

• 后台运行

docker run -d  -p 8080:8080 tomcat:8.0

• 设置容器名称

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

• 数据卷使用

# 绝对路径，该方式会将容器路径的原始内容全部清空，始终以宿主机路径为主
docker run -d  -p 8080:8080 -v /opt/apps:/usr/local/tomcat/webapps --name tomcat tomcat:8.0
# 使用别名设置数据卷,若别名路径不存在时会自动创建，该方式可以保留容器路径原有内容(条件：别名目录为空)
# 别名目录默认创建在/var/lib/docker/volumes目录中
docker run -d  -p 8080:8080 -v aa:/usr/local/tomcat/webapps --name tomcat tomcat:8.0

• 停止、重启、容器、暂停、恢复、kill

# 停止容器
docker stop [容器ID]|[容器名称]
# 启动容器
docker start [容器ID]|[容器名称]
# 重启容器
docker restart [容器ID]|[容器名称]
# 暂停容器
docker pause [容器ID]|[容器名称]
# 重启容器
docker unpause [容器ID]|[容器名称]
# kill
docker kill [容器ID]|[容器名称]

• 删除容器

# 删除停止容器
docker rm [容器ID]|[容器名称]
# 强制删除
docker rm -f [容器ID]|[容器名称]
# 删除所有容器
docker rm -f $(docker ps -qa)

• 查看日志

# 打印日志
docker logs [容器ID]|[容器名称]
# 打印末尾10行日志
docker logs --tail 10 [容器ID]|[容器名称]
# 实时打印日志
docker logs -f [容器ID]|[容器名称]
# 打印时间
docker logs -f -t [容器ID]|[容器名称]

• 进入容器

# 交互模式进入容器
docker exec -it [容器ID]|[容器名称] bash

• 退出容器

exit

• 文件拷贝

#从容器复制文件到宿主主机
docker cp [容器ID]|[容器名称]:文件路径 文件路径
#从宿主主机复制文件到容器
docker cp 文件路径 [容器ID]|[容器名称]:文件路径  

• 查看容器进程

docker top [容器ID]|[容器名称]

• 查看容器内应用的信息

docker inspect [容器ID]|[容器名称]

• 容器打包成新的镜像

# 命令
docker commit -m "描述信息" -a "作者信息"  [容器ID]|[容器名称] [新的镜像名称]:[版本]
# 简化
docker commit [容器ID]|[容器名称] 镜像名:版本

docker commit -m "deploy docker-test-war in tomcat 8.0" -a "test" 5840e7299983 test-tomcat:8.0

镜像原理

UnionFS（联合文件系统）

• UnionFS (联合文件系统） :Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtualfilesystem)。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
• 特性:一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

docker镜像加载

docker镜像实际是由一层层的文件系统组成；
docker镜像构建：基于基础镜像，不断叠加新服务，从而构建形成新的镜像；
   每次加载时通过UnionFS一次同时加载多个文件系统，从外观看起来，只是一个文件系统，每次加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层文件和目录
   当用docker run启动这个容器时，实际上在镜像的顶部添加了一个新的可写层。这个可写层也叫容器层

使用：docker image inspect [镜像名称]命令查看镜像分层

docker采用分层结构的优势

• 可以进行资源共享，可以基于base镜像来构建新的镜像
• 镜像层只允许进行读操作

基础服务搭建

mysql服务搭建

# 拉取镜像
docker pull mysql:5.6

# 运行镜像
docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d -p 3306:3306 --restart=always -v /opt/data/mysql:/var/lib/mysql mysql:5.6

# 数据备份(官方)
-- 导出所有库
docker exec [容器ID]|[容器名称] sh -c 'exec mysqldump --all-databases -uroot -p"$MYSQL_ROOT_PASSWORD"' > /opt/all-databases.sql
-- 导出指定库
docker exec [容器ID]|[容器名称] sh -c 'exec mysqldump ----databases [库名] -uroot -p"$MYSQL_ROOT_PASSWORD"' > /opt/all-databases.sql
-- 导出指定库，并不要数据
docker exec [容器ID]|[容器名称] sh -c 'exec mysqldump --no-data --databases [库名] -uroot -p"$MYSQL_ROOT_PASSWORD"' > /opt/all-databases.sql

# 数据导入
docker exec -i [容器ID]|[容器名称] sh -c 'exec mysql -uroot -p"$MYSQL_ROOT_PASSWORD"' < /opt/all-databases.sql

redis服务搭建

# 拉取镜像
docker pull redis:5.0.12

# 运行、数据持久化
docker run --name redis -d -p 6379:6379 --restart=always -v /opt/data/redis:/data redis:5.0.12 redis-server --appendonly yes

# 配置文件启动
docker run --name redis -d -p 6379:6379 --restart=always -v /opt/data/redis/conf:/data redis:5.0.12 redis-server /data/redis.conf

高级网络

学习网址|博客链接

概念

当 Docker 启动时，会自动在主机上创建一个 docker0 虚拟网桥，实际上是 Linux 的一个 bridge，可以理解为一个软件交换机。它会在挂载到它的网口之间进行转发。

同时，Docker 随机分配一个本地未占用的私有网段（在 RFC1918 (opens new window)中定义）中的一个地址给 docker0 接口。比如典型的 172.17.42.1，掩码为 255.255.0.0。此后启动的容器内的网口也会自动分配一个同一网段（172.17.0.0/16）的地址。

当创建一个 Docker 容器的时候，同时会创建了一对 veth pair 接口（当数据包发送到一个接口时，另外一个接口也可以收到相同的数据包）。这对接口一端在容器内，即 eth0；另一端在本地并被挂载到 docker0 网桥，名称以 veth 开头（例如 vethAQI2QT）。通过这种方式，主机可以跟容器通信，容器之间也可以相互通信。Docker 就创建了在主机和所有容器之间一个虚拟共享网络。


网络总结

• 默认docker在创建容器时将所有容器都连接到docker0网桥上，默认在docker0网桥的容器都可以使用容器内ip地址进行通信
• 默认docker在创建容器时将所有容器都连接到docker0网桥上，默认在docker0网桥的容器都可以使用容器名称作为容器ip地址进行通信，注意：使用容器名称作为容器ip时必须自定义网桥不能使用默认docker0网桥

自定义网桥

docker网桥类型

# 命令
docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
cde06038a6d3   bridge    bridge    local
82ebf5a2b4c9   host      host      local
b95f6c095f36   none      null      local

• bridge：网桥模式
• host：仅主机自身可以内部通信
• null： 没有网络服务

创建自定义网桥

# 创建
docker network create -d [网桥类型] [网络名称]
docker network create -d bridge test
# 查看
docker network ls
# 详情
docker network inspect [网络名称]
# 删除指定网络
docker network rm [网络名称]
# 删除无用的网络
docker network prune
# 运行容器在指定网络中（启动前）
docker run -d --network [网络名称] -p 8080:8080 --name tomcat01 tomcat:8.0
# 运行容器在指定网络中（启动后）
docker network connect [网络名称] [容器名称]|[容器ID]

高级数据卷

docker文件同步主要通过-v 来挂在文件(绝对路径方式、别名方式)

别名方式主要是一个docker自身维护的数据卷

# 查看docker维护的数据卷信息
docker volume ls
# 查看数据卷详情
docker volume inspect [数据卷别名]
# 删除数据卷名
docker volume rm [数据卷别名]
# 创建数据卷别名
docker volume create [数据卷]

DockerFile

什么是DockerFile

DockerFile可以认为是Docker镜像的描述文件，由一系列命令和参数构成的脚本。主要用来构建docker镜像的构建文件

DockerFile在构建镜像时，每条命令都会创建一个临时镜像

DockerFile基础语法

Dockerfile是一个文件，内容是镜像产生需要执行的语句。 Dockerfile中一个命令或注释独占一行

保留字	作用
FROM	基于这个镜像进行构建，必须作为Dockerfile的第一个指令出现。
MAINTAINER(已废弃)	镜像维护这的姓名和邮箱地址
RUN	构建镜像时需要运行的指令
EXPOSE	当前容器对外暴露出的端口
WORKDIR	指定在创建容器后，终端默认登录进来的工作目录
ENV	用来在构建过程中设置环境变量
ADD	将宿主机目录下的文件拷贝至镜像内部，ADD命令会自动处理URL(构建时下载文件，并放在指定位置)和解压tar包
COPY	类似于ADD,拷贝文件和目录到镜像中 将从构建上下文目录中<原路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
VOLUME	容器数据卷，用于数据保存和持久化工作
CMD	指定一个容器启动时要运行的命令 Dockerfile中可以有多个CMD命令，但是只有最后一个生效，CMD会被docker run之后的参数替换
ENTRYPOINT	指定一个容器启动时要运行的命令 ENTRYPOINT的母的和CMD一样，都是在指定容器启动程序和参数

FROM命令

# 语法
FROM 镜像名:版本
FROM centos:latest

RUN命令

# 语法
RUN <命令>
RUN ["命令"，"参数一"，"参数二"]
[edge1]
RUN yum -y install vim
[edge2]
RUN ["yum"，"-y","install","vim"]
[edge3]
RUN ["/bin/bash"，"-c","echp hello"]

EXPOSE命令

• 声明容器中服务的端口是多少，主要便于人们理解，起到提示作用

# 命令,若没有显示指定通信协议，默认为tcp
EXPOSE [端口号]
EXPOSE 8081/tcp
EXPOSE 9092/udp

WORKDIR命令

• 用来为Dockerfile中的任何RUN、CMD、ENTRYPOINT、COPY、ADD指令设置工作目录，如何配置的路径不存在，即使它没有在任何后续Dockerfile指令中使用，也会被创建
• WORKDIR指令可以在Dockerfile中多次使用，如果提供了相对路径，则该路径将与先前WORKDIR指定的路径相对

# 命令
WORKDIR <路径>
[edge]
WORKDIR /a
WORKDIR b
WORKDIR c

ENV命令

• 用来为构建镜像设置环境变量。这个值将出现在构建阶段中所有后续指令的环境中

# 语法
ENV <k> <v>
ENV <k>=<v>
[edge]
ENV BASE_path=/data/apps
WORKDIR $BASE_path

ADD命令

# 命令
ADD <文件路径>|<URL> <目标路径>
[edge]
ADD https://example.com/big.tar.xz /usr/src/things/
RUN tar -zxvf /usr/src/things/big.tar.xz -C /usr/src/things
RUN make -C /usr/src/things all

COPY命令

# 命令
COPY <文件路径> <目标路径>
[edge]
COPY requirements.txt /tmp/
RUN pip install --requirement /tmp/requirements.txt
COPY . /tmp/

VOLUME命令

• 声明容器中服务的文件映射地址是多少，主要便于人们理解，起到提示作用

# 命令
VOLUME <文件路径> 
[edge]
VOLUME /tmp/

CMD命令

# 语法
CMD <shell 命令> 
CMD ["<可执行文件或命令>","","",...] 
# 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数
CMD ["","",...]
# 示例
FROM centos:7.6.1810
ENV BASE_PATH=/etc
RUN yum install -y vim
EXPOSE 8081
CMD ["ls","/root"]
# CMDT使用环境变量，使用方式一
CMD ["sh", "-c", "[命令] ${环境变量}"]
# CMDT使用环境变量，使用方式二
CMD [命令] ${环境变量}
# 示例
FROM centos:7.6.1810
ENV BASE_PATH=/etc
RUN yum install -y vim
EXPOSE 8081
# 使用方式一
CMD ["sh", "-c"，"ls","${BASE_PATH}"] 
# 使用方式二
CMD ls ${BASE_PATH}

• 用来指定容器启动时默认执行的指令
• 可以存在多个，但是只有最后一个生效
• 可以和ENTRYPOINT指令可以同时存在
• CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖

# cmd命令覆盖
docker run [镜像名]:[版本号] [命令]
[edge]
docker run mycentos:03 ls /apps

ENTRYPOINT指令

# 语法
ENTRYPOINT  
ENTRYPOINT ["executable", "param1", "param2"]
# 示例
FROM centos:7.6.1810
ENV BASE_PATH=/etc
RUN yum install -y vim
EXPOSE 8081
ENTRYPOINT ["ls","/root"]
# ENTRYPOINT使用环境变量,方式一
ENTRYPOINT ["sh", "-c", "[命令] ${环境变量}"]
# ENTRYPOINT使用环境变量,方式二
ENTRYPOINT [命令] ${环境变量}
# 示例
FROM centos:7.6.1810
ENV BASE_PATH=/etc
RUN yum install -y vim
EXPOSE 8081
# 使用方式一
ENTRYPOINT ["sh", "-c"，"ls","${BASE_PATH}"] 
# 使用方式二
ENTRYPOINT ls ${BASE_PATH}

• 用来指定容器启动时默认执行的指令
• 可以存在多个，但是只有最后一个生效
• 可以和CMD指令可以同时存在
• ENTRYPOINT指令指定的程序可被–entrypoint参数中指定要运行的程序所覆盖

# ENTRYPOINT命令覆盖
docker run --entrypoint=[指令名称] [镜像名]:[版本号] [参数]
[edge]
docker run --entrypoint=ls mycentos:03 ls /etc

ENTRYPOINT与CMD结合使用

# ENTRYPOINT来固定执行指令  CMD来动态为ENTRYPOINT管理参数，两者配合使用时必须要数组方式，shell方式不支持
FROM centos:7.6.1810
ENV BASE_PATH=/etc
RUN yum install -y vim
EXPOSE 8081
ENTRYPOINT ["ls"] 
CMD ["/etc"]

构建镜像

# 命令
docker build -t [镜像名]:[版本] .
# 运行测试
docker run -it [镜像名]:[版本]

Dockerfile实战

1. 准备jar包
2. 编写dockerfile生成项目镜像
3. 运行镜像

FROM openjdk:8-jre
ENV APP_PATH=/apps
ENV APP_NAME=test
WORKDIR ${APP_PATH}
EXPOSE 9002
ADD docker-dockerfile-test-0.0.1-SNAPSHOT.jar ./${APP_NAME}.jar
ENTRYPOINT ["java","-jar"]
CMD ["test.jar"]

Docker-Compose

简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

• 使用 Dockerfile 定义应用程序的环境。
• 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
• 最后，执行 docker-compose up 命令来启动并运行整个应用程序。

安装

# 下载github
sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# 国内下载地址
curl -L https://get.daocloud.io/docker/compose/releases/download/v2.12.2/docker-compose-`uname -s`-`uname -m` > /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

模板命令

注意：version主要是docker-compose与docker server之间的对应关系，可以使用 docker version命令查看docker引擎版本后，选择对应的docker compose的版本

Compose file format	Docker Engine release
Compose specification	19.03.0+
3.8	19.03.0+
3.7	18.06.0+
3.6	18.02.0+
3.5	17.12.0+
3.4	17.09.0+
3.3	17.06.0+
3.2	17.04.0+
3.1	1.13.1+
3.0	1.13.0+
2.4	17.12.0+
2.3	17.06.0+
2.2	1.13.0+
2.1	1.12.0+
2.0	1.10.0+

使用案例

# yaml 配置
version: "3.8"
services:
  tomcat:
    image: tomcat:8.0
    ports:
      - 8081:8080
  redis:
    image: "redis:5.0.12"
    ports:
      - 6379:6379
  mysql:
    image: "mysql:5.6"
    # 进行端口映射，类似于 -p参数
    ports:
      - 3306:3306
    environment:
      # 设置当前容器启动时指定的环境变量参数，类似于 -e
      - "MYSQL_ROOT_PASSWORD=root"
    volumes:
      # 进行数据卷映射，注意docker-compose使用绝对路径要求必须先创建才能使用，类似于 -v
      # - /root/mysqldata:/var/lib/mysql
      - mysqlData:/var/lib/mysql
volumes:
  #声明数据卷别名
  mysqlData:

build指令

• 通过docker-compose在启动容器之前先根据指定的Dockerfile构建镜像，然后根据构建的镜像启动容器；
• 可以指定 Dockerfile 所在文件夹的路径（可以是绝对路径，或者相对 docker-compose.yml 文件的路径）。 Compose 将会利用它自动构建这个镜像，然后使用这个镜像。

参数名称	参数说明
context	指定 Dockerfile所在文件夹的路径。
dockerfile	指定 Dockerfile文件名
args	指定构建镜像时的变量,配置 --build-arg的传参

# Dockerfile与docker-compose在同级目录
version: '3.8'
services:
  webapp:
    # 指定上下文路径
    build: ./dir
# Dockerfile与docker-compose不在同级目录，并且指定Dockerfile文件名称
version: '3'
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1

command指令

• 覆盖容器启动后默认执行的命令

version: "3.8"
services:
  webapp:
    build:
      # 指定上下文
      context: /opt/dockerfile/item
      # Dockerfile文件名称，默认寻找Dockerfile
      dockerfile: Dockerfile
    command: ["app.jar"]
   

container_name指令

• 指定容器名称。默认将会使用 项目名称_服务名称_序号 这样的格式。

version: "3.8"
services:
  webapp:
    build:
      # 指定上下文
      context: /opt/dockerfile/item
      # Dockerfile文件名称，默认寻找Dockerfile
      dockerfile: Dockerfile
      args:
        buildno: 1
    command: ["app.jar"]
    container_name: "weapps"
   

depends_on指令

• 解决容器的依赖、启动先后的问题
• 服务不会等待所有依赖服务「完全启动」之后才启动。

version: "3.8"
services:
  tomcat:
    image: tomcat:8.0
    ports:
      - 8081:8080
  redis:
    image: "redis:5.0.12"
    ports:
      - 6379:6379
  mysql:
    image: "mysql:5.6"
    # 进行端口映射，类似于 -p参数
    ports:
      - 3306:3306
    environment:
      # 设置当前容器启动时指定的环境变量参数，类似于 -e
      - "MYSQL_ROOT_PASSWORD=root"
    volumes:
      # 进行数据卷映射，注意docker-compose使用绝对路径要求必须先创建才能使用，类似于 -v
      # - /root/mysqldata:/var/lib/mysql
      - mysqlData:/var/lib/mysql
  webapp:
    build:
      # 指定上下文
      context: /opt/dockerfile/item
      # Dockerfile文件名称，默认寻找Dockerfile
      dockerfile: Dockerfile
      # 指定参数
      args:
        a: 1
    command: [ "test.jar" ]
    depends_on:
      - mysql
      - tomcat
      - redis
volumes:
  #声明数据卷别名
  mysqlData:

env_file指令

• 从文件中获取环境变量，可以为单独的文件路径或列表
• 如果有变量名称与 environment 指令冲突，则按照惯例，以后者为准
• 如果通过 docker compose -f FILE 方式来指定 Compose 模板文件，则 env_file 中变量的路径会基于模板文件路径。

# 单文件
env_file: .env
# 多文件
env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env
  
# common.env文件
PROG_ENV=development

environment指令

• 设置环境变量。你可以使用数组或字典两种格式

# 字典
environment:
  RACK_ENV: development
  SESSION_SECRET:
# 数组
environment:
  - "RACK_ENV=development"
  - "SESSION_SECRET=1234" 

expose指令

• 暴露端口，但不映射到宿主机，只被连接的服务访问(容器间)

expose:
 - "3000"
 - "8000"

image指令

• 指定为镜像名称或镜像 ID。如果镜像在本地不存在，Compose 将会尝试拉取这个镜像。

image: ubuntu
image: orchardup/postgresql
image: a4bc65fd

networks指令

• 配置容器连接的网络
• 统一网桥内的服务，可以使用服务ip进行通信，也可以使用服务名称作为服务ip进行通信

version: "3.8"
services:
 webapp:
    build:
      # 指定上下文
      context: /opt/dockerfile/item
      # Dockerfile文件名称，默认寻找Dockerfile
      dockerfile: Dockerfile
      # 指定参数
      args:
        a: 1
    command: [ "test.jar" ]
    networks:
     - some-network
     - other-network
# 声明网路
networks:
  some-network:
  other-network:

ports指令

• 指定宿主机和容器之间端口映射关系

ports:
 - "8000:8000"

volumes指令

• 数据卷所挂载路径设置。可以设置为宿主机路径(绝对路径)或者数据卷名称(别名)，并且可以设置访问模式 （HOST:CONTAINER:ro）

volumes:
 # 绝对路径
 - /root/data/:/var/lib/mysql
 # 别名
 - cache/:/tmp/cache
 # 设置只读访问模式
 - ~/configs:/etc/configs/:ro

• 使用别名方式挂载时，需要声明

version: "3.8"
services:
  my_src:
    image: mysql:8.0
    volumes:
      - mysql_data:/var/lib/mysql
# 声明别名数据卷
volumes:
  mysql_data:   

restart指令

• 指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，在生产环境中推荐配置为 always 或者 unless-stopped

restart: always

version: "3.8"
services:
  mysql:
    image: "mysql:5.6"
    # 进行端口映射，类似于 -p参数
    ports:
      - 3306:3306
    environment:
      # 设置当前容器启动时指定的环境变量参数，类似于 -e
      - "MYSQL_ROOT_PASSWORD=root"
    volumes:
      # 进行数据卷映射，注意docker-compose使用绝对路径要求必须先创建才能使用，类似于 -v
      # - /root/mysqldata:/var/lib/mysql
      - mysqlData:/var/lib/mysql
    restart: always

docker-compose命令

命令格式

对于 Compose 来说，大部分命令的对象既可以是项目本身，也可以指定为项目中的服务或者容器。如果没有特别的说明，命令对象将是项目，这意味着项目中所有的服务都会受到命令影响。

执行 docker compose [COMMAND] --help 可以查看具体某个命令的使用格式。

docker compose 命令的基本的使用格式是

docker compose [-f=<arg>...] [options] [COMMAND] [ARGS...]

命令选项

• -f, --file FILE 指定使用的 Compose 模板文件，默认为 docker-compose.yml，可以多次指定。
• -p, --project-name NAME 指定项目名称，默认将使用所在目录名称作为项目名。
• --verbose 输出更多调试信息。
• -v, --version 打印版本并退出。

命令使用说明

up

格式为 docker compose up [options] [SERVICE...]。

• 该命令十分强大，它将尝试自动完成包括构建镜像，（重新）创建服务，启动服务，并关联服务相关容器的一系列操作。
• 链接的服务都将会被自动启动，除非已经处于运行状态。
• 可以说，大部分时候都可以直接通过该命令来启动一个项目。
• 默认情况，docker compose up 启动的容器都在前台，控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
• 当通过 Ctrl-C 停止命令时，所有容器将会停止。
• 如果使用 docker compose up -d，将会在后台启动并运行所有的容器。一般推荐生产环境下使用该选项。
• 默认情况，如果服务容器已经存在，docker compose up 将会尝试停止容器，然后重新创建（保持使用 volumes-from 挂载的卷），以保证新启动的服务匹配 docker-compose.yml 文件的最新内容。如果用户不希望容器被停止并重新创建，可以使用 docker compose up --no-recreate。这样将只会启动处于停止状态的容器，而忽略已经运行的服务。如果用户只想重新部署某个服务，可以使用 docker compose up --no-deps -d 来重新创建服务并后台停止旧服务，启动新服务，并不会影响到其所依赖的服务。

选项：

• -d 在后台运行服务容器。
• --no-color 不使用颜色来区分不同的服务的控制台输出。
• --no-deps 不启动服务所链接的容器。
• --force-recreate 强制重新创建容器，不能与 --no-recreate 同时使用。
• --no-recreate 如果容器已经存在了，则不重新创建，不能与 --force-recreate 同时使用。
• --no-build 不自动构建缺失的服务镜像。
• -t, --timeout TIMEOUT 停止容器时候的超时（默认为 10 秒）。

down

格式为：docker-compose down

此命令将会停止 up 命令所启动的容器，并移除网络

exec

格式为：docker-compose exec [服务id] bash(命令)

• 进入指定容器

ps

格式为 docker compose ps [options] [SERVICE...]。

列出项目中目前的所有容器。

选项：

• -q 只打印容器的 ID 信息。

restart

格式为 docker compose restart [options] [SERVICE...]。

重启项目中的服务。

选项：

• -t, --timeout TIMEOUT 指定重启前停止容器的超时（默认为 10 秒）。

docker-compose restart -t 10 

rm

格式为 docker compose rm [options] [SERVICE...]。

删除所有（停止状态的）服务容器。推荐先执行 docker compose stop 命令来停止容器。

选项：

• -f, --force 强制直接删除，包括非停止状态的容器。一般尽量不要使用该选项。
• -v 删除容器所挂载的数据卷。

start

格式为 docker compose start [SERVICE...]。

启动已经存在的服务容器。

stop

格式为 docker compose stop [options] [SERVICE...]。

停止已经处于运行状态的容器，但不删除它。通过 docker compose start 可以再次启动这些容器。

选项：

• -t, --timeout TIMEOUT 停止容器时候的超时（默认为 10 秒）。

top

查看各个服务容器内运行的进程。

格式为：docker-compose top [服务id]

pause

格式为 docker compose pause [SERVICE...]。

暂停一个服务容器

unpause

格式为 docker compose unpause [SERVICE...]

恢复处于暂停状态中的服务

logs

格式为 docker compose logs [options] [SERVICE...]。

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

学习链接

博客|视频