docker

尖齿柠檬鲨

已于 2023-07-18 11:24:47 修改

阅读量883

点赞数 1

分类专栏： Docker 文章标签： docker 容器运维

于 2023-07-18 11:21:03 首次发布

本文链接：https://blog.csdn.net/teolih/article/details/131783274

版权

Docker 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Docker

Docker是一种开源的容器化平台，用于构建、部署和运行应用程序。它允许开发人员将应用程序及其依赖项打包到一个称为容器的独立单元中，然后在任何环境中运行这些容器。Docker的主要优势在于它提供了一种轻量级、可移植和可扩展的解决方案，使应用程序能够在不同的操作系统和云平台上无缝运行。通过使用Docker，开发人员可以更快地构建、测试和部署应用程序，并且能够更好地管理应用程序的依赖关系和版本控制。

1 基本概念

1.1 容器

容器是一种标准的软件单元，它将代码及其所有依赖项打包，以便应用程序能够快速、可靠地从一个计算环境运行到另一个计算环境。Docker容器镜像是一个轻量级、独立、可执行的软件包，其中包含运行应用程序所需的一切：代码、运行时、系统工具、系统库和设置。容器映像在运行时会变成容器，对于Docker容器来说，映像在Docker引擎上运行时会变成容器。容器化软件既适用于基于Linux的应用程序，也适用于基于Windows的应用程序。容器将软件从其环境中隔离出来，并确保其在开发和暂存等不同环境中统一运行。在Docker引擎上运行的Docker容器：

标准：Docker创建了容器的行业标准，因此它们可以在任何地方移植。
轻量级：容器共享机器的操作系统内核，因此每个应用程序不需要操作系统，从而提高了服务器效率，降低了服务器和许可成本
安全：应用程序在容器中更安全，Docker提供业界最强的默认隔离功能

1.2 镜像

镜像是一个轻量级、独立的可执行软件包（或者说是一个只读的模板），它包含了运行应用程序所需的一切：代码、运行时环境、系统工具、系统库等。镜像可以被用来创建容器，容器是镜像的一个运行实例，它是一个独立、隔离的运行环境。容器可以被启动、停止、删除，它可以运行在不同的主机上，而不受主机环境的影响。

1.3 仓库

仓库（Repository）是 Docker 中用于存储和管理镜像的地方。它类似于代码仓库，可以用来存储和分享镜像。

仓库可以分为两种类型：公共仓库和私有仓库。

公共仓库：Docker Hub 是最常见的公共仓库，它包含了大量的常用镜像，开发人员可以从中选择合适的镜像来构建自己的应用程序镜像。公共仓库中的镜像可以被任何人访问和使用。
私有仓库：私有仓库用于组织内部的镜像管理，保证镜像的安全性和可控性。私有仓库可以在本地搭建，也可以使用云服务提供商提供的私有仓库。私有仓库中的镜像只能被授权的用户访问和使用。

仓库中的镜像可以通过标签（Tag）来进行版本管理。每个镜像可以有多个标签，标签可以用来区分不同的版本或不同的配置。例如，一个镜像可以有 “latest” 标签表示最新版本，也可以有 “v1.0” 标签表示特定的版本。

开发人员可以使用 Docker 命令来从仓库中拉取镜像，例如使用 “docker pull” 命令可以从仓库中下载指定的镜像。同时，开发人员也可以将自己的镜像上传到仓库，供其他人使用。上传镜像可以使用 “docker push” 命令，将本地的镜像推送到指定的仓库中。

仓库提供了一个集中化的镜像管理和分享平台，方便开发人员在不同的环境中使用和共享镜像。

2 Docker 命令

2.1 Docker服务相关命令

Docker 服务的相关命令可以使用 Docker 守护进程（Docker daemon）来管理。以下是一些常用的 Docker 服务相关命令及其作用：

启动 Docker 服务：
- Linux：sudo service docker start
- Windows（PowerShell）：Start-Service docker
- macOS：Docker Desktop 应用程序会自动启动 Docker 服务
停止 Docker 服务：
- Linux：sudo service docker stop
- Windows（PowerShell）：Stop-Service docker
- macOS：Docker Desktop 应用程序会自动停止 Docker 服务
重启 Docker 服务：
- Linux：sudo service docker restart
- Windows（PowerShell）：Restart-Service docker
- macOS：Docker Desktop 应用程序会自动重启 Docker 服务
查看 Docker 服务状态：
- Linux：sudo service docker status
- Windows（PowerShell）：Get-Service docker
- macOS：Docker Desktop 应用程序会显示 Docker 服务状态
设置 Docker 服务开机启动：
- Linux：sudo systemctl enable docker
- Windows：在服务管理器中将 Docker 服务设置为自动启动
- macOS：Docker Desktop 应用程序会自动设置 Docker 服务开机启动

这些命令可以帮助你管理 Docker 服务的启动、停止、重启以及查看状态。在不同的操作系统上，命令可能会有所不同，所以请根据你的操作系统选择相应的命令。另外，Docker Desktop 应用程序提供了图形界面来管理 Docker 服务，你也可以通过应用程序来启动、停止和重启 Docker 服务。

2.2 镜像管理相关命令

Docker 提供了一系列的命令来管理和操作镜像。以下是一些常用的 Docker 镜像管理命令及其作用：

查看本地镜像列表：
- docker images：列出本地的镜像列表，包括镜像的 ID、标签、大小等信息。
- docker images -q：列出本地的镜像ID列表
搜索镜像：
- docker search <镜像名称>：在 Docker Hub 上搜索指定名称的镜像。
拉取镜像：
- docker pull <镜像名称>[:<镜像版本号>]：从仓库中拉取指定的镜像到本地。
删除镜像：
- docker rmi <镜像名称>[:<镜像版本号>]：删除指定的镜像。如果镜像正在被使用，需要先停止相关的容器才能删除。
- docker rmi <镜像ID>：通过镜像的 ID 删除镜像。
- 删除所有本地镜像
```
docker rmi `docker images -q`
```
强制删除镜像：
- docker rmi -f <镜像名称>：强制删除指定的镜像，即使镜像正在被使用。
查看镜像详细信息：
- docker inspect <镜像名称>：查看指定镜像的详细信息，包括镜像的配置、环境变量等。
构建镜像：
- docker build -t <镜像名称> <Dockerfile路径> .：根据 Dockerfile 构建一个新的镜像。
上传镜像：
- docker push <镜像名称>：将本地的镜像推送到指定的仓库。

这些命令可以帮助你管理和操作 Docker 镜像，包括查看本地镜像列表、搜索镜像、拉取镜像、删除镜像等。通过这些命令，你可以方便地获取、使用和管理镜像。

查找版本号：docker hub

2.3 管理容器相关的命令

Docker 提供了一系列的命令来管理和操作容器。以下是一些常用的 Docker 容器管理命令及其作用：

查看正在运行的容器：
- docker ps：列出当前正在运行的容器。
- docker ps -a：列出所有容器，包括已停止的容器。
创建容器：
- docker create <镜像名称>：根据指定的镜像创建一个新的容器，但不启动它。
- docker run <镜像名称>：创建并启动一个新的容器。
进入容器：
- docker exec -it <容器名称或ID> <命令>：在运行的容器中执行指定的命令。
  - 例如：docker exec -it halo /bin/bash：在名为"halo"的容器中执行一个交互式的bash shell
- docker attach <容器名称或ID>：进入正在运行的容器的终端。
启动容器：
- docker start <容器名称或ID>：启动一个已创建但停止的容器。
停止容器：
- docker stop <容器名称或ID>：停止一个正在运行的容器。
- docker kill <容器名称或ID>：强制停止一个正在运行的容器。
删除容器：
- docker rm <容器名称或ID>：删除一个已停止的容器。
- docker rm -f <容器名称或ID>：强制删除一个正在运行的容器。
查看容器详细信息：
- docker inspect <容器名称或ID>：查看指定容器的详细信息，包括容器的配置、网络设置等。
查看容器日志：
- docker logs <容器名称或ID>：查看指定容器的日志输出。

这些命令可以帮助你管理和操作 Docker 容器，包括查看容器、创建容器、进入容器、启动容器、停止容器、删除容器、查看容器信息等。通过这些命令，你可以方便地管理和操作容器，进行应用程序的开发、测试和部署。

2.3.1 docker run

docker run 命令是用于创建并启动一个新的容器。它有许多参数可以用来配置容器的各种属性。以下是一些常用的 docker run 命令参数及其意义：

-d：在后台运行容器（以守护进程方式），不阻塞终端。
-it：以交互模式运行容器，同时分配一个伪终端（TTY）。
--name：为容器指定一个名称。
-p：将容器的端口映射到主机的端口。
-v：将主机的目录或文件挂载到容器中，实现数据卷的共享。
--network：指定容器所使用的网络。
--env：设置容器的环境变量。
--restart：设置容器的重启策略。

下面是一个示例，演示如何使用 docker run 命令及其参数：

docker run -d --name my-container -p 8080:80 -v /path/on/host:/path/in/container my-image

解释：

-d：容器在后台运行。
--name my-container：为容器指定名称为 “my-container”。
-p 8080:80：将容器的端口 80 映射到主机的端口 8080。
-v /path/on/host:/path/in/container：将主机上的 /path/on/host 目录挂载到容器的 /path/in/container 目录。
my-image：使用镜像名

2.4 Docker容器的数据卷

2.4.1 什么是数据卷

Docker容器的数据卷是一种特殊的目录，可以在容器和主机之间共享和持久化数据。数据卷可以在容器创建时被挂载到容器的指定路径上，并且可以在容器之间共享和重用。

数据卷的主要特点包括：

数据卷可以在容器之间共享和重用，使得容器之间可以共享数据。
数据卷可以在容器创建时被挂载到指定路径上，也可以在容器运行时进行挂载和卸载。
数据卷可以持久化数据，即使容器被删除或重新创建，数据卷中的数据仍然存在。
数据卷可以与主机文件系统进行双向的数据传输，使得容器中的数据可以与主机进行交互。

使用数据卷可以方便地进行数据的持久化和共享，同时也提供了一种灵活的方式来管理容器中的数据。

2.4.2 配置数据卷

配置和管理容器的数据卷可以通过以下几种方式进行：

使用命令行参数：在创建容器时，可以使用-v或--volume参数来指定数据卷的挂载。例如：
```
docker run -v /host/path:/container/path image_name
```
这将把主机上的/host/path目录挂载到容器中的/container/path目录。
使用Docker Compose：如果你使用Docker Compose来管理容器，可以在docker-compose.yml文件中使用volumes字段来定义数据卷的挂载。例如：
```
version: '3'
services:
  myservice:
    image: image_name
    volumes:
      - /host/path:/container/path
```
使用Dockerfile：如果你使用Dockerfile来构建镜像，可以使用VOLUME指令来定义数据卷。例如：
```
FROM image_name
VOLUME /container/path
```
动态挂载数据卷：在容器运行时，可以使用docker volume create命令创建一个匿名数据卷，并将其挂载到容器中。例如：
```
docker volume create myvolume
docker run -v myvolume:/container/path image_name
```

对于数据卷的管理，可以使用以下命令进行操作：

docker volume create：创建一个新的数据卷。
docker volume ls：列出所有的数据卷。
docker volume inspect：查看数据卷的详细信息。
docker volume rm：删除一个或多个数据卷。
docker volume prune：删除所有未被使用的数据卷。

通过这些方式，你可以方便地配置和管理容器的数据卷。

2.4.3 多容器数据共享

在多个容器之间进行数据共享可以使用Docker的数据卷功能。下面是一些方法：

共享主机路径：可以将主机上的某个路径挂载到多个容器中，这样它们就可以共享相同的数据。例如：
```
docker run -v /host/path:/container/path container1
docker run -v /host/path:/container/path container2
```
这样，container1和container2都可以访问和修改/host/path路径下的数据。
使用命名数据卷：可以创建一个命名的数据卷，并将其挂载到多个容器中。这样，多个容器就可以共享相同的数据卷。例如：
```
docker volume create myvolume
docker run -v myvolume:/container/path container1
docker run -v myvolume:/container/path container2
```
这样，container1和container2都可以访问和修改myvolume数据卷中的数据。
使用外部存储卷插件：Docker还支持使用外部存储卷插件来实现容器间的数据共享。这些插件可以将数据存储在云存储服务、网络存储设备或分布式文件系统中。你可以根据需要选择适合的存储卷插件，并将其挂载到多个容器中。

无论使用哪种方法，都可以实现容器之间的数据共享。选择合适的方法取决于你的具体需求和环境。

2.4.4 数据卷容器

使用数据卷容器是一种常见的方法来实现容器间的数据共享。下面是使用数据卷容器的步骤：

创建一个数据卷容器：首先，创建一个专门用于共享数据的数据卷容器。可以使用以下命令创建一个数据卷容器：
```
docker create -v /data --name data_container busybox
```
这将创建一个名为data_container的数据卷容器，并将/data目录作为数据卷。
将数据卷容器挂载到其他容器：接下来，可以将数据卷容器挂载到其他需要共享数据的容器中。使用--volumes-from参数来实现挂载。例如：
```
docker run --volumes-from data_container --name container1 image1
docker run --volumes-from data_container --name container2 image2
```
这样，container1和container2都可以访问和修改data_container中的/data目录。
在容器中使用共享数据：在容器中，可以像使用本地文件一样使用共享的数据卷。例如，在container1中可以使用以下命令访问共享数据：
```
docker exec container1 ls /data
docker exec container1 cat /data/file.txt
```

通过使用数据卷容器，可以方便地实现容器间的数据共享。多个容器可以通过挂载同一个数据卷容器来访问和修改共享的数据。这种方法还可以使数据在容器之间保持持久化，即使容器被删除或重新创建，数据仍然存在于数据卷容器中。

3 应用部署

3.1 MySQL

当在Docker中部署MySQL并配置使得能够通过访问宿主机即可访问该MySQL服务时，可以按照以下步骤进行操作：

安装Docker：确保你的系统上已经安装了Docker。
拉取MySQL镜像：使用以下命令从Docker Hub上拉取MySQL镜像：
```
docker pull mysql:5.7
```
创建MySQL容器并配置端口映射：使用以下命令创建一个MySQL容器，并将MySQL的默认端口映射到宿主机的指定端口（例如13306）：

a. 创建mysql目录，用以存储mysql数据信息
```
mkdir ~/mysql
cd ~/mysql
```
b. 创建容器，设置端口映射、目录映射
```
docker run -id \
-p 13306:3306 \
--name mysql-container \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=<root_password> \
mysql:5.7
```
这将把MySQL容器的13306端口映射到宿主机的3306端口。
配置MySQL访问权限：默认情况下，MySQL容器只允许本地访问。为了允许宿主机访问MySQL服务，你需要在MySQL容器中进行以下配置。

a. 连接到MySQL容器：
```
docker exec -it mysql-container bash
```
b. 进入MySQL命令行界面：
```
mysql -uroot -p
```
输入之前设置的root密码。

c. 授予远程访问权限：
```
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '<root_password>' WITH GRANT OPTION;
FLUSH PRIVILEGES;
```
这将授予root用户从任何主机（%）访问MySQL的权限。记得将<root_password>替换为你设置的root密码。

5.7 version test pass

d. 退出MySQL命令行界面：
```
exit
```
e. 退出MySQL容器：
```
exit
```

现在，你可以通过访问宿主机的IP地址和指定的端口（例如localhost:13306）来访问Docker中的MySQL服务。

3.2 部署应用

在Docker中部署应用的一般步骤如下：

安装Docker：确保你的系统上已经安装了Docker。
拉取镜像：从Docker Hub或其他镜像仓库上拉取你需要的应用镜像。使用以下命令拉取镜像：
```
docker pull <image_name>
```
将<image_name>替换为你要使用的镜像名称。
创建容器：使用以下命令创建一个容器，并进行必要的配置，如端口映射、挂载目录等：
```
docker run --name <container_name> <options> <image_name>
```
将<container_name>替换为你给容器起的名称，<options>替换为容器的配置选项，如端口映射、挂载目录等，<image_name>替换为你使用的镜像名称。
配置应用：根据你的应用需求，在容器中进行必要的配置，如环境变量、数据库连接等。可以使用docker exec命令进入容器，并在容器内部进行配置。
访问应用：通过访问宿主机的IP地址和指定的端口，或者通过容器的网络地址访问应用。具体访问方式取决于你的应用和容器的配置。

以上是一般的部署步骤，具体步骤可能会因应用的不同而有所变化。在部署应用之前，建议先阅读相关的文档和指南，以了解特定应用的部署要求和最佳实践。

4 Dockerfile

4.1 Docker镜像原理

Docker镜像的原理是通过分层存储和联合文件系统来实现的。

Docker镜像是由一系列只读的文件系统层组成的。每个文件系统层都包含了一个或多个文件或目录的变更。当创建一个新的镜像时，Docker会根据已有的镜像和新的变更层来构建一个新的镜像。

这种分层存储的方式有以下几个优点：

节省存储空间：由于镜像的每个层都是只读的，多个镜像可以共享相同的层，从而节省存储空间。
快速部署：当创建一个新的容器时，Docker只需要在最上层添加一个可写层，而不需要复制整个镜像，从而加快了容器的启动速度。
简化镜像管理：由于每个层都是只读的，可以方便地复用和共享镜像的不同层，从而简化了镜像的管理和分发。

联合文件系统是Docker镜像的另一个重要组成部分。它将不同层的文件系统以一种透明的方式合并在一起，使得用户可以像访问一个完整的文件系统一样访问镜像中的文件。

总结起来，Docker镜像的原理是通过分层存储和联合文件系统来实现高效的存储和部署。这种方式使得Docker能够快速创建、部署和管理容器，并节省存储空间。

4.2 制作镜像

制作镜像有两种方式：1. 将已有容器转换为镜像 2. 使用dockerfile制作镜像

将已有容器转换为镜像：
1. 确保已停止容器：首先，确保要转换为镜像的容器已经停止运行。可以使用docker ps命令来查看正在运行的容器，并使用docker stop命令停止容器。
2. 获取容器ID：使用docker ps -a命令来查看所有容器的列表，找到要转换为镜像的容器的ID。
3. 提交容器为镜像：使用docker commit命令来提交容器为镜像。该命令的基本语法如下：
  
  docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
  
  示例：docker commit mycontainer myimage:latest
  
  这将把名为mycontainer的容器提交为名为myimage的镜像，标签为latest。
4. 等待提交完成：Docker引擎会根据容器的状态和文件系统的变化生成一个新的镜像。等待提交过程完成。
5. 保存镜像文件：docker save -o <FILE_NAME> <CONTAINER>[:TAG]
6. 加载镜像文件：docker load -i <FILE_NAME>
7. 查看镜像：使用docker images命令来查看已生成的镜像列表。
  
  示例：docker images
8. 运行容器：使用docker run命令来运行基于新生成的镜像的容器。
  
  示例：docker run -d -p 8080:80 myimage:latest
  
  这将在后台运行一个基于myimage镜像的容器，并将容器的80端口映射到主机的8080端口。
通过以上步骤，你可以将已有的容器转换为镜像，并基于该镜像运行新的容器。请注意，转换为镜像后的容器将不再保留原有容器的状态和数据，而是生成一个全新的镜像。
使用dockerfile制作：
1. 创建一个Dockerfile：在你的项目目录下创建一个名为Dockerfile的文本文件。
2. 编写Dockerfile：在Dockerfile中编写构建镜像的指令和参数，包括基础镜像、安装软件、复制文件等操作。
3. 构建镜像：使用docker build命令来构建镜像，指定Dockerfile的路径和镜像的名称和标签。
  
  示例：docker build -t myimage:latest .
  
  这将在当前目录下的Dockerfile中构建一个名为myimage的镜像，标签为latest。
  
  注意：该命令后有一个空格+英文小数点
4. 等待构建完成：Docker引擎会根据Dockerfile的内容自动执行构建过程，下载所需的基础镜像，执行指令，并生成一个新的镜像。
5. 查看镜像：使用docker images命令来查看已构建的镜像列表。
  
  示例：docker images
6. 运行容器：使用docker run命令来运行基于新构建的镜像的容器。
  
  示例：docker run -d -p 8080:80 myimage:latest
  
  这将在后台运行一个基于myimage镜像的容器，并将容器的80端口映射到主机的8080端口。
以上是一个基本的制作Docker镜像的流程。你可以根据自己的需求和项目的特点，在Dockerfile中添加适当的指令和参数来构建自定义的镜像。

4.2.1 Docker build

Docker build命令用于构建Docker镜像，它有许多参数可以用来定制构建过程。下面是一些常用的参数及其用法的示例：

-t 或 --tag：为镜像指定一个标签。示例：docker build -t myimage:1.0 .
-f 或 --file：指定Dockerfile的路径。示例：docker build -f /path/to/Dockerfile .
--build-arg：传递构建时的参数给Dockerfile。示例：docker build --build-arg VERSION=1.0 .
--no-cache：禁用缓存，每次构建都会重新下载依赖。示例：docker build --no-cache .
--network：指定构建过程中使用的网络。示例：docker build --network host .
--pull：在构建之前拉取最新的基础镜像。示例：docker build --pull .
--target：指定构建过程中的目标阶段。示例：docker build --target production .
--squash：将构建过程中的每个层压缩成一个层。示例：docker build --squash .
--progress：设置构建过程中的进度输出格式。示例：docker build --progress plain .
--label：为镜像添加标签。示例：docker build --label maintainer="John Doe" .

这些参数可以根据实际需求进行组合使用，以满足构建过程的定制化需求。

4.3 Dockerfile的概念及作用

Dockerfile是一个文本文件，用于定义Docker镜像的构建过程。它包含了一系列的指令和参数，用于指导Docker引擎在构建镜像时执行的操作。

Dockerfile的作用是自动化地构建Docker镜像。通过编写Dockerfile，可以定义镜像的基础操作系统、安装软件、配置环境变量、复制文件等一系列操作。当执行docker build命令时，Docker引擎会根据Dockerfile的内容自动执行这些操作，并生成一个新的镜像。

Dockerfile的优点包括：

可重复性：通过编写Dockerfile，可以确保每次构建的镜像都是一致的，避免了手动操作的不确定性。
可维护性：Dockerfile是一个文本文件，易于阅读和修改。通过修改Dockerfile，可以快速更新和维护镜像。
可扩展性：Dockerfile支持使用变量和参数，可以根据不同的需求构建不同的镜像，提高了镜像的可扩展性。
可分享性：Dockerfile可以与他人分享，使得其他人可以轻松地构建相同的镜像。

总结起来，Dockerfile是一个用于定义Docker镜像构建过程的文本文件，它的作用是自动化地构建Docker镜像，提高了镜像的可重复性、可维护性、可扩展性和可分享性。

4.4 Dockerfile 关键字

Dockerfile中有一些关键字（指令）用于定义构建镜像的操作。以下是一些常用的Dockerfile关键字及其作用和使用方法的示例：

FROM：指定基础镜像，用于构建新镜像。
示例：FROM ubuntu:latest
RUN：在镜像中执行命令。
示例：RUN apt-get update && apt-get install -y curl
COPY：将文件从主机复制到镜像中。
示例：COPY app.py /app/
ADD：将文件或URL从主机复制到镜像中，支持自动解压缩。
示例：ADD https://example.com/file.tar.gz /app/
WORKDIR：设置工作目录，后续的指令将在该目录下执行。
示例：WORKDIR /app
ENV：设置环境变量。
示例：ENV PORT=8080
EXPOSE：声明容器运行时监听的端口。
示例：EXPOSE 8080
CMD：指定容器启动时要执行的命令。
示例：CMD ["python", "app.py"]
ENTRYPOINT：指定容器启动时要执行的命令，与CMD不同的是，ENTRYPOINT的参数不会被覆盖。
示例：ENTRYPOINT ["python", "app.py"]
VOLUME：声明容器中的目录为挂载点，用于持久化数据。
示例：VOLUME /data
MAINTAINER：指明作者信息

示例: MAINTAINER heat <heat@11.tc>

这些关键字可以按照需要组合使用，以定义构建镜像的过程。例如，以下是一个简单的Dockerfile示例：

FROM ubuntu:latest
RUN apt-get update && apt-get install -y curl
COPY app.py /app/
WORKDIR /app
CMD ["python", "app.py"]

这个Dockerfile首先指定了基础镜像为最新的Ubuntu版本，然后在镜像中执行了更新和安装curl的操作，接着将主机上的app.py文件复制到镜像的/app/目录下，设置/app/为工作目录，最后指定容器启动时要执行的命令为运行app.py文件。

5 服务编排

5.1 什么是服务编排

Docker的服务编排是指使用Docker技术来管理和部署多个容器化应用程序的过程。它允许用户定义和管理多个容器之间的关系、依赖和规模，以实现高可用性、负载均衡和自动扩展等功能。

Docker的服务编排可以通过多种方式实现，包括使用Docker Compose、Docker Swarm和Kubernetes等工具。这些工具提供了一种声明式的方式来定义和管理容器化应用程序的部署和运行，使用户能够轻松地管理和扩展容器化应用程序的规模和复杂性。

通过使用Docker的服务编排，用户可以轻松地部署和管理多个容器化应用程序，提高应用程序的可靠性和可扩展性，并实现自动化的容器管理和部署流程。

5.2 Docker Compose

Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。它使用YAML文件来配置应用程序的服务、网络和卷等方面的设置，并提供了一个简单的命令行界面来管理和操作这些容器。

使用Docker Compose，用户可以通过一个单独的配置文件定义多个容器之间的关系和依赖关系。这个配置文件可以包含多个服务，每个服务对应一个容器，可以指定容器的镜像、端口映射、环境变量、卷挂载等设置。用户还可以定义网络和卷等资源，以便容器之间进行通信和数据共享。

一旦配置文件定义完成，用户可以使用Docker Compose命令来启动、停止、重启和删除整个应用程序。Docker Compose会根据配置文件中的定义，自动创建和管理容器，并确保它们按照正确的顺序启动和停止。

Docker Compose的优势在于它简化了多容器应用程序的部署和管理过程，使用户能够轻松地定义和管理复杂的容器化应用程序。它还提供了一种可重复使用的方式来定义和部署应用程序，使得应用程序的部署过程更加可靠和可维护。

5.3 Docker Compose使用步骤

使用Docker Compose来定义和启动应用程序的步骤如下：

安装Docker Compose：首先，确保已经安装了Docker和Docker Compose。Docker Compose通常与Docker一起安装，但也可以单独安装。可以通过运行docker-compose --version命令来检查是否已成功安装。
创建Docker Compose配置文件：在项目的根目录下创建一个名为docker-compose.yml的文件。这个文件将用于定义应用程序的服务、网络和卷等设置。
定义服务：在docker-compose.yml文件中，使用YAML语法来定义应用程序的服务。每个服务对应一个容器，可以指定容器的镜像、端口映射、环境变量、卷挂载等设置。可以定义多个服务，每个服务使用一个独立的块来描述。
定义网络和卷：除了服务，还可以在docker-compose.yml文件中定义网络和卷等资源。网络可以用于容器之间的通信，卷可以用于容器之间的数据共享。
启动应用程序：在项目的根目录下，使用docker-compose up命令来启动应用程序。Docker Compose将根据配置文件中的定义，自动创建和管理容器，并确保它们按照正确的顺序启动和停止。
停止应用程序：要停止应用程序，可以使用docker-compose down命令。这将停止并删除所有由Docker Compose创建的容器。

通过以上步骤，您可以使用Docker Compose来定义和启动应用程序。可以根据需要进行配置文件的修改和调整，以满足应用程序的需求。

5.3.1 Docker-compose up

当使用docker-compose up命令启动应用程序时，可以使用一些参数来自定义启动行为。以下是一些常用的参数及其解释：

-d：以后台模式启动容器。默认情况下，docker-compose up会在前台启动容器，并将容器的输出打印到终端。使用-d参数可以将容器在后台启动，不会将输出打印到终端。
--build：在启动容器之前构建镜像。如果在docker-compose.yml文件中定义的服务使用了自定义的Dockerfile，使用--build参数可以在启动容器之前重新构建镜像。
--force-recreate：强制重新创建容器。如果容器已经存在，使用--force-recreate参数可以强制删除现有容器并重新创建。
--no-deps：不启动依赖的服务。默认情况下，docker-compose up会启动所有在docker-compose.yml文件中定义的服务及其依赖的服务。使用--no-deps参数可以只启动指定的服务，而不启动其依赖的服务。
--scale SERVICE=NUM：扩展指定服务的副本数。使用--scale参数可以指定要启动的服务的副本数。例如，--scale web=3将启动3个web服务的副本。
--remove-orphans：删除孤立的容器。如果在docker-compose.yml文件中定义的服务依赖的服务已经不存在，使用--remove-orphans参数可以删除孤立的容器。

这些参数可以根据需要进行组合使用，以满足特定的启动需求。可以通过运行docker-compose up --help命令来查看更多参数和其用法的详细信息。

5.4 案例

参考：[Halo docker-compose 部署](使用 Docker Compose 部署 | Halo 文档)

6 Docker私有仓库

要搭建Docker私有仓库，可以按照以下步骤进行操作：

安装Docker：首先，确保你的服务器上已经安装了Docker。你可以根据你的操作系统选择合适的安装方式。
创建一个新的目录用于存储仓库数据：在服务器上创建一个新的目录，用于存储私有仓库的数据。例如，你可以创建一个名为/data/docker-registry的目录。
启动私有仓库容器：使用以下命令启动一个私有仓库容器：
```
docker run -d -p 5000:5000 --restart=always --name registry -v /data/docker-registry:/var/lib/registry registry:2
```
这个命令会从Docker Hub上下载最新的registry:2镜像，并将容器的5000端口映射到主机的5000端口。/data/docker-registry目录会被挂载到容器的/var/lib/registry目录，用于存储仓库数据。
配置Docker客户端：在你的开发机上，编辑Docker配置文件/etc/docker/daemon.json（如果文件不存在，则创建它），添加以下内容：
```
{
  "insecure-registries": ["your-server-ip:5000"]
}
```
将your-server-ip替换为你的服务器的IP地址。
重启Docker服务：重启Docker服务，使配置生效。在大多数Linux发行版上，可以使用以下命令重启Docker服务：
```
sudo systemctl restart docker
```
测试私有仓库：现在，你可以使用Docker客户端测试私有仓库是否正常工作。首先，从Docker Hub上拉取一个镜像：
```
docker pull hello-world
```
然后，给这个镜像打上私有仓库的标签：
```
docker tag hello-world your-server-ip:5000/hello-world
```
最后，将这个镜像推送到私有仓库：
```
docker push your-server-ip:5000/hello-world
```
如果一切正常，你应该能够看到镜像被成功推送到私有仓库。
在搭建好私有仓库后，你可以使用以下步骤从私有仓库中拉取镜像：

例如，如果你的私有仓库中有一个名为myapp的镜像，标签为latest，你可以使用以下命令拉取该镜像：
```
docker pull your-server-ip:5000/myapp:latest
```
Docker客户端会从私有仓库中拉取镜像，并将其保存在本地。

现在，你已经成功从私有仓库中拉取了镜像。你可以使用docker images命令查看本地的镜像列表，确认镜像已经成功拉取。

现在，你已经成功搭建了一个Docker私有仓库。你可以使用类似的步骤来搭建多个私有仓库，并根据需要进行配置和管理。

7 Docker和虚拟机对比

Docker和虚拟机是两种不同的虚拟化技术，它们有以下区别和各自的优势和劣势：

架构差异：
- Docker：Docker利用操作系统级别的虚拟化技术，通过容器化来实现应用程序的隔离。Docker容器共享主机操作系统的内核，每个容器运行在独立的用户空间中。
- 虚拟机：虚拟机则是在物理硬件上运行一个完整的操作系统，通过虚拟化技术模拟硬件资源，每个虚拟机都有自己的操作系统内核。
启动速度：
- Docker：Docker容器的启动速度非常快，通常只需要几秒钟。这是因为容器共享主机操作系统的内核，不需要启动完整的操作系统。
- 虚拟机：虚拟机的启动速度相对较慢，通常需要几分钟。这是因为每个虚拟机都需要启动一个完整的操作系统。
资源利用率：
- Docker：由于容器共享主机操作系统的内核，容器的资源利用率非常高。多个容器可以在同一台主机上运行，共享主机的资源，从而提高资源利用效率。
- 虚拟机：每个虚拟机都需要独立的操作系统和资源，因此虚拟机的资源利用率相对较低。
隔离性：
- Docker：Docker容器提供了良好的应用程序隔离性，每个容器运行在独立的用户空间中，相互之间隔离。但是容器共享主机操作系统的内核，因此容器之间可能存在一定的安全风险。
- 虚拟机：虚拟机提供了更高级别的隔离性，每个虚拟机都有自己的操作系统内核，相互之间完全隔离。虚拟机之间的安全性更高。
管理和部署：
- Docker：Docker提供了简单易用的容器管理和部署工具，可以快速构建、发布和管理容器化应用程序。容器可以通过镜像进行版本控制和分发，使得应用程序的部署更加简单和可靠。
- 虚拟机：虚拟机的管理和部署相对复杂，需要额外的虚拟化管理工具。虚拟机镜像的管理和分发也相对繁琐。

综上所述，Docker相对于虚拟机具有更快的启动速度、更高的资源利用率和更简单的管理和部署。但是虚拟机提供了更高级别的隔离性和安全性。因此，在选择使用Docker还是虚拟机时，需要根据具体的需求和场景来进行权衡和选择。

8 参考

视频参考：黑马程序员Docker容器化技术，从零学会Docker教程_哔哩哔哩_bilibili

笔记来源：作者整理+OpenAI.ChatGPT

尖齿柠檬鲨

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
docker

Docker是一种开源的容器化平台，它通过利用操作系统级别的虚拟化技术，实现了应用程序的隔离和打包。Docker的核心概念是容器，它是一个轻量级、可移植的软件单元，包含了应用程序及其所有的依赖项。与传统的虚拟机相比，Docker容器具有更快的启动速度、更高的资源利用率和更简单的管理和部署。通过使用Docker，开发人员可以快速构建、发布和管理容器化应用程序，实现了应用程序的可移植性和可扩展性。Docker生态系统非常丰富，提供了大量的镜像和工具，使得容器的使用变得更加简单和便捷。因此，Docker已经成为现
复制链接

扫一扫