Docker 学习笔记

• Docker 学习笔记
  • Docker 简介
  • Docker常用网站
  • Docker三要素
  • 安装Docker--centos7示例
  • Docker底层原理
    • 到底什么是Docker？Docker 是怎么工作的？
    • Docker为什么比VM虚拟机快
  • Docker常用命令
    • 容器管理
    • 镜像管理
    • 网络管理
    • 数据卷管理
    • 其他常用命令
  • Docker镜像原理
    • 1. 镜像结构
    • 2. 分层结构
    • 3. 镜像加载过程
    • 4. 优势和效率
    • Docker镜像加载原理：
    • Docker分层结构的优势
    • 从容器生成镜像
  • 数据共享–容器数据卷
    • 命令创建容器数据卷
    • 使用dockerfile创建容器数据卷
  • 数据卷容器
  • Dockerfile解析
    • Dockerfile语法规则
    • Docker执行Dockerfile的大致流程
    • 一张图展示dockerfile,image,container等之间关系
  • Docker容器编排
    • docker-compose案例

Docker 简介

虚拟机（Virtual Machine，简称VM）的发展，减轻了企业对硬件资源的依赖，它将一台物理设备虚拟为多个逻辑设备，每个逻辑设备可运行不同的操作系统，并且应用程序都可以在相互独立的空间内运行而互不影响，从而显著提高设备的工作效率。然而，传统VM需要安装操作系统才能执行应用程序，占用系统资源过多。多数情况下，用户只需要运行简单的应用程序，采用VM技术操作繁琐且造成资源浪费。倘若需要迁移应用服务程序，则需迁移整个VM，因此企业迫切需要轻量级的虚拟化技术。

容器，就是一种轻量级的虚拟化技术，目的和虚拟机一样，都是为了创造 “隔离环境” 。但是它不像VM采用操作系统级的资源隔离，容器采用的是进程级的系统隔离。

容器虚拟化技术化常见的有：Kubernetes（K8s）、Podman、LXC、Rkt、Docker等。基于这个容器的优缺点，我经常使用的是docker。它的优点如下：

• 轻量级和高效： Docker 利用容器技术，与传统的虚拟机相比，它们共享主机操作系统的内核，因此更为轻量级和高效。Docker 容器启动快速，占用资源较少，能够在短时间内快速部署和销毁。
• 一致的开发和运行环境： Docker 提供了一种标准化的打包和交付机制，开发者可以将应用程序及其所有依赖项打包到一个 Docker 镜像中。这种镜像可以在开发、测试和生产环境中一致地运行，消除了由环境差异引起的问题，确保了应用程序的一致性和可移植性。
• 快速部署和扩展： Docker 容器可以快速部署到任何支持 Docker 的主机上，并且可以轻松地进行水平扩展。Docker 提供了简单而强大的容器编排工具（如 Docker Swarm 和 Kubernetes），使得多个容器的管理和扩展变得更加简单和高效。
• 环境隔离和安全性： 每个 Docker 容器都是相互隔离的，有自己的文件系统、进程空间和网络接口，可以避免应用程序之间的冲突和影响。这种隔离性有助于提高应用程序的安全性，并减少了安全漏洞的风险。
• 持续集成和持续部署的支持： Docker 可以与现代的 CI/CD 工具集成，自动化构建、测试和部署流程。这使得开发团队能够更快速、可靠地交付新版本的应用程序，提高了软件开发和部署的效率和质量。
• 开放和生态系统： Docker 是一个开源项目，并且有一个活跃的社区支持和贡献。它的开放性使得用户可以自由地扩展和定制 Docker 平台，同时有许多第三方工具和服务与 Docker 集成，进一步丰富了其功能和应用场景。

Docker常用网站

常用网站:

1. docker官网
2. docker中文网
3. docker hub
4. docker文档

安装 Docker 引擎版请参考 Docker 引擎版安装指南

Docker三要素

• 镜像（Image） ：镜像是 Docker 容器的模板，包含应用程序和运行环境。通过镜像，可以在不同环境中创建一致的容器。
• 容器（Container） ：容器是镜像的运行实例，包含应用程序及其依赖。容器彼此隔离，但共享主机的操作系统内核。
• 仓库（Repository） ：仓库用于存储和分发镜像。Docker Hub 是一个公共的镜像仓库，用户可以从中下载和上传镜像。

​

​

废话不多说我们马上来上手来安装Docker吧！

安装Docker--centos7示例

前置条件 ：安装之前首先需要准备一个centos7的虚拟机并且可以连接到网络。

1. 更新系统软件包首确保所有软件包都是最新的（可选） sudo yum update -y

2. 安装必要的依赖包

   sudo yum install -y yum-utils device-mapper-persistent-data lvm2

3. 添加 Docker 仓库

   sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

4. 安装 Docker

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

5. 启动 Docker 服务并设置开机自启动

   sudo systemctl start docker sudo systemctl enable docker

6. 验证 Docker 安装

   sudo docker run hello-world 
   

   ​

   安装成功以后可以看到以下信息

   ​

7. 添加用户到 Docker 组

   为了避免每次运行 Docker 命令都使用 sudo，可以将当前用户添加到 Docker 组：

   sudo usermod -aG docker $USER
   

   然后退出并重新登录，或使用 newgrp docker 命令刷新组成员身份。

8. 配置 Docker 镜像加速

   为加速 Docker 镜像下载，可以配置国内的镜像源，例如使用阿里云加速器：

   sudo mkdir -p /etc/docker
   sudo tee /etc/docker/daemon.json <<-'EOF'
   {
     "registry-mirrors": ["https://<your-mirror-url>"]
   }
   EOF
   sudo systemctl daemon-reload
   sudo systemctl restart docker
   <!-- 国内常见镜像源-->
   {
     "registry-mirrors": [
     "https://********.mirror.aliyuncs.com", //阿里云加速器
     "https://dockerproxy.com",//DockerProxy
     "https://mirror.baidubce.com",//百度云加速器:
     "https://docker.m.daocloud.io",//DaoCloud加速器
     "https://docker.nju.edu.cn",//南京大学加速器
     "https://docker.mirrors.sjtug.sjtu.edu.cn"//上海交通大学加速器
     ]
   }
   

Docker底层原理

到底什么是Docker？Docker 是怎么工作的？

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问Docker守护进程。Docker守护进程从客户端接受命令，并按照命令，管理运行在主机上的容器。

Docker 通过使用 Linux 容器技术，提供了一种轻量级的虚拟化解决方案。以下是 Docker 的工作原理概述：

1. Namespaces（命名空间） ：

   • Docker 使用 Linux 的命名空间（Namespaces）技术来实现资源隔离。每个容器都有自己的网络、进程、挂载点、UTS（主机名）和 IPC（进程间通信）命名空间。这些命名空间确保了容器之间的隔离，使得一个容器中的操作不会影响到其他容器。

2. Control Groups（控制组，Cgroups） ：

   • 控制组（Cgroups）是 Linux 内核提供的另一种功能，用于限制、记录和隔离进程组的资源（CPU、内存、磁盘I/O、网络等）使用情况。Docker 使用 Cgroups 来管理每个容器可以使用的资源，确保容器之间的资源分配和使用不会相互干扰。

3. Union File Systems（联合文件系统，UnionFS） ：

   • Docker 利用联合文件系统（如 AUFS、OverlayFS、Btrfs 等）来实现高效的存储层。UnionFS 允许多个文件系统层叠加在一起，形成一个单一的可用文件系统。Docker 镜像由多层组成，每层都可以看作是一个只读的文件系统，容器运行时的写操作会创建一个新的可写层（容器层）。这种层次结构使得镜像的共享和复用变得非常高效。

4. Container Runtime（容器运行时） ：

   • Docker 使用容器运行时来管理容器的生命周期。Docker 最初使用的是自带的运行时（libcontainer），现在则是基于 OCI 标准的 runc。运行时负责创建和启动容器，并使用上面提到的命名空间和控制组来实现隔离和资源控制。

5. Docker Daemon（守护进程） ：

   • Docker 守护进程（dockerd）是 Docker 引擎的核心组件，负责处理 Docker API 请求、管理镜像和容器、网络、数据卷等。客户端（如 Docker CLI 或其他工具）通过与 Docker 守护进程通信来管理容器。

6. Docker 镜像和容器：

   • Docker 镜像是容器的蓝图，包含了运行应用程序所需的一切（代码、库、配置文件等）。Docker 容器是镜像的运行实例，每个容器都是一个独立的进程，具有自己的文件系统、网络接口和资源限制。

Docker为什么比VM虚拟机快

Docker 相对于传统的虚拟机有显著的性能优势，主要原因如下：

1. 共享主机操作系统内核：

   • Docker 容器共享主机操作系统的内核，而虚拟机则需要运行一个完整的客操作系统。共享内核减少了内存和 CPU 的开销，提高了资源利用效率。

2. 轻量级的进程隔离：

   • Docker 使用的是进程级别的隔离技术，而虚拟机需要虚拟化整个硬件环境。这使得 Docker 容器的启动和停止速度非常快，通常只需几秒钟甚至几毫秒，而虚拟机则需要几分钟。

3. 更高的资源利用率：

   • 由于 Docker 容器不需要为每个实例分配固定的资源（如 CPU、内存等），而是通过控制组动态管理，这使得资源利用率更高。虚拟机通常需要预分配资源，即使未完全使用，资源也会被占用。

4. 高效的存储层：

   • Docker 的联合文件系统使得镜像的存储和传输非常高效。只需下载和存储不同层的差异部分即可，这相比虚拟机需要完整的磁盘镜像文件要高效得多。

5. 一致的环境：

   • Docker 提供了一致的运行环境，消除了开发、测试和生产环境之间的差异，减少了环境配置和依赖问题，从而提高了开发和部署的效率。

     特性	容器	虚拟机
     启动速度	秒级	分钟级
     硬盘使用	一般为MB	一般为GB
     性能	接近原生	弱于原生

Docker 虽然在许多方面优于传统的虚拟机（VM），但也存在一些缺点：

1. 操作系统依赖性：

• Docker 容器共享宿主机的操作系统内核，这意味着容器化的应用程序必须与宿主机的操作系统兼容。如果应用程序依赖于特定版本或配置的操作系统，容器化可能会面临限制或兼容性问题。

2. 安全性：

• 虽然 Docker 提供了一定程度的隔离性，但容器共享相同的内核和部分系统资源，这可能导致容器间的安全漏洞扩散。相比之下，虚拟机能够提供更加彻底的隔离，每个虚拟机都有自己的完整操作系统。

3. 性能开销：

• Docker 容器在运行时不需要启动整个操作系统，因此通常比虚拟机启动更快并且资源消耗更少。然而，Docker 容器仍然有一定的性能开销，尤其是在涉及密集的计算或需要大量 I/O 操作时，性能可能不如直接在物理或虚拟机上运行的应用程序。

4. 持久化存储：

• Docker 容器默认情况下使用的是可写的容器层（Container Layer），这些层不适合长期存储或大量写入操作。虽然可以通过数据卷（Volumes）或者其他存储解决方案来解决这个问题，但这增加了部署和管理的复杂性。

5. 复杂性和学习曲线：

• 虽然 Docker 提供了强大的功能和灵活性，但学习如何正确地使用 Docker 和管理容器化应用程序需要一定的学习和适应时间。尤其是对于复杂的网络配置、容器编排和持续集成/持续部署（CI/CD）流程，需要额外的专业知识和经验。

6. 依赖于外部服务：

• 使用 Docker 需要依赖于 Docker Hub 或者其他容器镜像仓库来获取和管理镜像。如果依赖的镜像源不稳定或者出现问题，可能会影响到应用程序的部署和运行。

Docker常用命令

容器管理

• docker ps 查看当前正在运行的容器。

• docker create <container_id or container_name> ** 创建容器

• docker ps -a 查看所有容器，包括已停止的。

• docker start <container_id or container_name> 启动一个停止状态的容器。

• docker stop <container_id or container_name> 停止一个运行中的容器。

• docker restart <container_id or container_name> 重启一个容器。

• docker pause <container_id or container_name>

  暂停一个或多个正在运行的容器中的所有进程。

• docker rm <container_id or container_name> 删除一个停止状态的容器。

• docker logs <container_id or container_name> 查看容器的日志。

• docker exec -it <container_id or container_name> /bin/bash 进入正在运行的容器内部的交互式 shell。

镜像管理

• docker images 查看本地所有的镜像。
• docker pull image_name:tag 拉取一个镜像到本地。
• docker build -t image_name:tag <Dockerfile_path> 根据 Dockerfile 构建一个镜像。
• docker rmi <image_id or image_name:tag> 删除一个本地的镜像。
• docker tag <image_id> new_image_name:tag 给镜像打标签。

网络管理

• docker network ls 列出所有 Docker 网络。
• docker network inspect <network_id or network_name> 查看指定 Docker 网络的详细信息。
• docker network create <network_name> 创建一个新的 Docker 网络。
• docker network connect <network_id or network_name> <container_id or container_name> 连接容器到指定的网络。

数据卷管理

• docker volume ls 列出所有 Docker 数据卷。
• docker volume create <volume_name> 创建一个新的 Docker 数据卷。
• docker volume inspect <volume_name> 查看指定 Docker 数据卷的详细信息。
• docker volume rm <volume_name> 删除一个 Docker 数据卷。

其他常用命令

• docker info 查看 Docker 系统信息，包括容器和镜像的数量等。
• docker version 查看 Docker 版本信息。
• docker-compose up 使用 Docker Compose 启动应用程序。
• docker-compose down 使用 Docker Compose 停止并移除容器、网络和数据卷。

Docker镜像原理

镜像是一种轻量级、可执行的独立软件包， 用来打包软件运行环境和基于运行环境开发的软件 ，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。 ​ Docker镜像基础是UnionFS联合文件系统，一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层叠加，同时可以将不同目录挂载到同一个虚拟文件系统下，镜像可以通过分层来进行继承，基于继承镜像可以制作各种具体的应用镜像。 ​ 特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

1. 镜像结构

Docker 镜像是一个多层文件系统，每一层都是一个只读文件系统。这些层次结构被称为联合文件系统（UnionFS），允许将多个文件系统层叠在一起，形成一个单一的逻辑文件系统。

2. 分层结构

Docker 镜像的每一层都是一个文件系统的快照，包含了构成镜像的文件和目录。每个镜像都有一个基础层（Base Layer），在其基础上可以叠加多个只读层。

3. 镜像加载过程

当使用 docker run 命令启动一个容器时，Docker 容器运行时会执行以下步骤来加载镜像：

• 查找镜像： Docker 首先检查本地是否已经存在所需镜像。如果本地不存在，它会从默认的镜像注册表（如 Docker Hub）下载镜像。
• 创建容器层： Docker 创建一个新的容器层（Container Layer），这是一个可写的层，用于存储容器运行时的所有变更和修改。这个层是镜像层的顶部。
• 联合文件系统： Docker 将镜像的各个只读层和容器层通过联合文件系统（UnionFS）技术进行联合挂载。这样，容器就能够看到镜像中所有层次的文件系统，但只能修改和操作容器层上的文件系统。
• 启动容器进程： 最后，Docker 启动容器中定义的进程，该进程在容器的隔离环境中运行。这个进程可以访问整个联合文件系统，并且只能在容器层进行写操作。

4. 优势和效率

Docker 镜像加载的这种分层结构和联合文件系统带来了以下优势：

• 资源共享和节约： 多个容器可以共享相同的基础层（Base Layer），节省存储空间和带宽。
• 高效构建和部署： Docker 可以快速创建和销毁容器，因为它只需在容器层上应用变更，而不必重新复制整个镜像。
• 可复用性和版本控制： 镜像的分层结构允许开发人员创建和管理不同版本的镜像，并在不同环境中重复使用。

Docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。 ​ bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统， 在Docker镜像的最底层是bootfs。 这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system) ，在bootfs之上 。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

Docker镜像加载原理：

Docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。 ​ bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统， 在Docker镜像的最底层是bootfs。 这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。 rootfs (root file system) ，在bootfs之上 。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M？？ 对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。 平时我们安装进

虚拟机的CentOS都是好几个G，为什么docker这里才200M？？ 对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

Docker分层结构的优势

最大的一个好处就是 - 共享资源 比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。 Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

从容器生成镜像

• docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

  docker commit -m="DLF commit test" -a="DLF" a2ec9eb0e4f3 helloword:v1

数据共享–容器数据卷

为了能让docker容器产生的数据，如果不做特殊处理，容器删除后，数据也会被删除，可以通过commit或者docker cp这种笨重的方式保存，但更便捷的方法是创建数据卷。 docker容器数据卷有以下特点：

1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改可以直接生效
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止
5. 数据卷允许容器数据持久化到宿主机上

命令创建容器数据卷

• docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名:镜像标签

可以使用docker inspect 查看是否创建成功

上述命令可增加读写权限： ​ docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名:镜像标签 ​ 需要注意的是，-v主机目录的方式，在dockerfile中不能直接使用，由于宿主机是不同的，每个宿主机都不一样，不能保证所有的宿 主机上都存在这样的特定目录。

使用dockerfile创建容器数据卷

在dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷

Dockerfile:

# 基于官方的 Ubuntu 镜像作为基础镜像
FROM ubuntu:latest
# 设置工作目录
WORKDIR /app
# 在 Dockerfile 中声明多个数据卷
VOLUME ["/app/data1", "/app/data2"]
# 设置容器启动时执行的命令
CMD ["bash"]

进入Dockerfile所在目录docker build -t myimage .

使用 VOLUME 指令声明的数据卷默认情况下是匿名的，即不会显示具体的宿主机路径，但会显示容器内路径。如果你希望在容器运行时能够看到宿主机路径，需要在运行容器时使用 -v 参数来显式挂载。

docker run -it -v /host/path/data1:/app/data1 -v /host/path/data2:/app/data2 myimage

查看` docker inspect 容器ID

数据卷容器

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器 ，数据卷的生命周期一直持续到没有容器使用它为止。

我们可以使用上面dockerfile构建的镜像，先启动一个容器myimage,然后再使用以下命令启动两个容器dlf2和dlf1，能看到都有共同的数据卷，在里面创建的文件，再返回myimage查看能被看到：

docker run -it --name dlf1 --volumes-from 3f457cfbe5e5 myimage

docker run -it --name dlf2 --volumes-from 3f457cfbe5e5 myimage

Dockerfile解析

Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。 可以理解成可以一键构建镜像的脚本，编写完dockerfile后，docker build 产出镜像，docker run运行镜像

以下是Centos7Dockerfile请参考

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /
​
LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"
​
CMD ["/bin/bash"]

Dockerfile语法规则

0. 每条保留字指令都必须为大写字母，且后面要跟随至少一个参数
1. 指令按照从上到下，顺序执行
2. #表示注释
3. 每条指令都会创建一个新的镜像层，并对镜像进行提交

Docker执行Dockerfile的大致流程

0. docker 从基础镜像运行一个容器
1. 执行一条指令并对容器作出修改
2. 执行类似docker commit的操作提交一个新的镜像层
3. 基于刚提交的镜像运行一个新的容器
4. 执行dockerfile中的下一条指令直到所有指令都执行完成

一张图展示dockerfile,image,container等之间关系

Docker容器编排

一般来说，我们每一个容器中只运行一个服务，多个服务时通常需要其他措施来对多个服务保活。因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题？

如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具 ，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml， 写好多个容器之间的调用关系 。然后，只要一个命令，就能同时启动/关闭这些容器

例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。

Compose允许用户通过一个单独的 docker-compose.yml模板文件 （YAML 格式）来定义 一组相关联的应用容器为一个项目（project）。

可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

安装地址：docs.docker.com/compose/ins…

使用步骤

1. 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
2. 使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
3. 最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线

常用命令

Compose 常用命令
docker-compose -h # 查看帮助
docker-compose up # 启动所有 docker-compose服务
docker-compose up -d # 启动所有 docker-compose服务 并后台运行
docker-compose down # 停止并删除容器、网络、卷、镜像。
docker-compose exec yml里面的服务id # 进入容器实例内部 docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps # 展示当前docker-compose编排过的运行的所有容器
docker-compose top # 展示当前docker-compose编排过的容器进程
​
docker-compose logs yml里面的服务id # 查看容器输出日志
docker-compose config # 检查配置
docker-compose config -q # 检查配置，有问题才有输出
docker-compose restart # 重启服务
docker-compose start # 启动服务
docker-compose stop # 停止服务

安装docker-compose

下载 Docker Compose：
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
赋予执行权限：
sudo chmod +x /usr/local/bin/docker-compose
验证安装：
docker-compose --version

docker-compose案例

首先在docker路径下创建以上文件

[root@bogon docker]# ls
default.conf  docker-compose.yml  nginx.conf  website
[root@bogon docker]# pwd
/docker

nginx.conf

# nginx.conf
​
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
​
events {
    worker_connections 1024;
}
​
http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
​
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
​
    access_log /var/log/nginx/access.log main;
​
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
​
    keepalive_timeout 65;
​
    include /etc/nginx/conf.d/*.conf;
}
​

docker-compose.yml

version: '3'
services:
  nginx:
    image: nginx:latest
    container_name: nginx-container
    ports:
      - "80:80"
    volumes:
      - ./default.conf:/etc/nginx/conf.d/default.conf
      - ./website:/usr/share/nginx/html
    restart: always

default.conf

# default.conf
​
server {
    listen 80;          # Listen on port 80 for incoming HTTP requests
    server_name example.com;  # Server name that this block will respond to
​
    location / {
        root /usr/share/nginx/html;  # Root directory for serving static files
        index index.html;            # Default file to serve if none specified
    }
}

/docker/website/index.html

<html><body>Hello, Docker!</body></html>

最后输入http://192.168.56.102/就可以查看到网页了

在容器数量较少的场景下，我们docker-compose工具已经够用，但如果容器数量较多的情况下，我们就需要用一个更便捷的管理工具k8s了。