Docker

为什么用Docker

一些概念：

1. 镜像（Image）：可以将镜像视为软件打包的模板。
1. 功能：镜像是一个只读的文件，其中包含了运行应用程序所需的一切，包括代码、运行时环境、依赖项和配置。

2. 容器（Container）：容器是基于镜像创建的一个运行实例。
1. 工能：可以将容器视为镜像的运行时进程，它是一个隔离的环境，其中可以运行应用程序和服务。
2. 特性：每个容器都具有自己的文件系统、网络和进程空间，可以独立运行应用程序。
📌
镜像和容器关系的例子： 1. 莎士比亚心中的哈姆雷特就像是一个镜像，观众在看了这个戏剧之后，在自己心中就有了一个哈姆雷特，观众心中的哈姆雷特就是容器。 2. Python 中类和实例的关系，类是一个模板，实例是类的具体实现。

3. 仓库（Repository）：仓库是用于存储和组织镜像的地方。Docker Registry服务器专门用来存放仓库，一个 Docker Registry 中可以包含多个 仓库；每个仓库可以包含多个 标签；每个标签对应一个镜像。
通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。可以通过 <仓库名>:<标签> 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。

Docker安装

版本选择

• 在有图形界面的系统中（Windows 或 macOS等），推荐使用：Docker Desktop；它集成 Docker Engine、Docker CLI、Docker Compose、Kubernetes（可选），以及一个图形化界面，适合 Windows 和 macOS 用户。

• 在没有图形界面的系统中（Linux），推荐使用：Docker Engine；
• Docker CE（Community Edition，社区版）：开源免费
• Docker EE（Enterprise Edition，企业版，现已并入 Mirantis）：商业付费

仓库安装（Ubuntu）

卸载旧的可能有冲突的包

for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done

# 卸载 Docker Engine、CLI、containerd 和 Docker Compose 软件包：
sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

# 手动删除任何已编辑的配置文件
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

仓库配置

# 更新软件包列表
sudo apt-get update

# 安装必要的证书和工具：ca-certificates：提供系统用来验证 SSL 证书的证书；curl：用于从网络上下载文件的工具。
sudo apt-get install ca-certificates curl

# 创建目录以存储 GPG 密钥，-m 0755 设置目录权限，以便所有用户可以读取和进入该目录，但只有目录所有者可以修改。
sudo install -m 0755 -d /etc/apt/keyrings

# 下载 Docker 的官方 GPG 密钥
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
# -fsSL 参数的含义：
#    -f：在下载过程中遇到错误时，curl 会失败。
#    -s：以静默模式运行，避免输出进度信息。
#    -S：即使在静默模式下，也显示错误信息。
#    -L：如果遇到重定向，则跟随重定向。

# 设置密钥的权限，a+r 表示所有用户都可以读取
sudo chmod a+r /etc/apt/keyrings/docker.asc


# 添加 Docker 存储库到 APT 源
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# $(dpkg --print-architecture)：获取当前系统的架构（如 amd64）。
# $(. /etc/os-release && echo "$VERSION_CODENAME")：获取当前 Ubuntu 版本的代号（如 jammy）。
# signed-by=/etc/apt/keyrings/docker.asc：指定用于验证存储库签名的 GPG 密钥路径。
# 将生成的内容通过 echo 输出并通过 tee 命令写入到 /etc/apt/sources.list.d/docker.list 文件中。> /dev/null 确保 tee 命令的输出不会显示在终端上。

# 更新软件包列表
sudo apt-get update

安装Docker

# 直接安装最新版本
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin


# 列出所有可用版本
apt-cache madison docker-ce | awk '{ print $3 }'

# 设置版本进行安装
VERSION_STRING=5:20.10.24~3-0~ubuntu-jammy
sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-buildx-plugin docker-compose-plugin

验证Docker

sudo docker run hello-world

安装包安装

实操查找版本

1. 进入：https://download.docker.com/linux/ubuntu/ 这个网址，包含目录如下：
• dists/：
• 这是 Docker APT 存储库的核心目录，包含了不同的 Ubuntu 版本和架构的文件包。
• 进入 dists/ 目录后，你会看到各个 Ubuntu 发行版的名称，如 bionic/（Ubuntu 18.04）、focal/（Ubuntu 20.04）、jammy/（Ubuntu 22.04）等。
• 进一步进入每个发行版的目录，可以看到 stable/、test/ 等子目录，这些目录中包含了对应版本的 Docker Engine 及其相关组件的安装包。
• gpg ：
• 包含 Docker APT 仓库的 GPG 密钥，用于验证从这个仓库下载的软件包的真实性和完整性。安装 Docker 时，通常需要添加这个 GPG 密钥到系统中。

2. 进入对应的系统（我的是jammy/（Ubuntu 22.04）），进入：https://download.docker.com/linux/ubuntu/dists/jammy/ 之后，目录包含如下
• stable/、test/、nightly/:
• 这些是 Docker 的不同发布渠道（release channel）。每个目录中包含不同类型的 Docker 软件包。
• stable/：包含稳定版本的 Docker 软件包，适合生产环境使用。
• test/：包含测试版的 Docker 软件包，用于开发者在发布正式版本之前测试新功能。
• nightly/：包含每日构建版本，提供最新的功能和更新，但可能不稳定，仅用于实验和测试。
• 通常，建议使用 stable/ 版本，因为它是经过充分测试和验证的。
• Release、InRelease、Release.gpg:
• Release：描述该发行版中可用软件包的元数据文件，包含每个软件包的版本信息、依赖关系等。
• InRelease：包含了 Release 文件的内容以及其 GPG 签名，提供了一种验证文件完整性和真实性的方式。
• Release.gpg：是对 Release 文件的独立 GPG 签名，用于确认文件的完整性和来源。
• pool/：
• 该目录包含了所有 Docker 包文件的实际存放位置，按软件包的名称进行组织。
• 包括 docker-ce（Docker 社区版）、containerd.io（容器运行时）等。
• 这些 .deb 文件可以直接下载，用于在没有网络连接的情况下进行离线安装。

3. 进入pool/目录，选择稳定版stable/， 然后选择系统架构类型
• amd64/：用于 64 位架构的包文件（也称为 x86_64 架构）。
• arm64/：用于 ARM 架构的包文件。
• s390x/：用于 IBM 系统 z 架构的包文件。

4. 我Ubuntu是安装在Mac M1电脑上的，所以选择arm64/架构，进去之后包含以下类型文件：
• containerd.io（必须）：容器运行时，这是 Docker 引擎所依赖的组件。
• docker-ce（必须）：Docker 社区版的核心包，即 Docker 引擎。
• docker-ce-cli（必须）：Docker 命令行工具。
• docker-compose-plugin（可选-推荐） ：：用于多容器管理的插件。
• docker-buildx-plugin （可选-推荐）：用于多平台构建的插件。
• docker-ce-rootless-extras （可选）：用于支持 无特权（rootless）模式 的 Docker 运行。

选择合适的版本

• 推荐版本：20.10…

• 兼容性：选择与其他软件包兼容的版本。例如，docker-ce、docker-ce-cli 和 containerd.io 通常需要保持版本兼容。如果选择 docker-ce 的最新版本，也要选择与之匹配的 docker-ce-cli 和 containerd.io 版本。

开始安装（Ubuntu）

# 创建一个目录来存放下载的包
mkdir -p ~/docker_install && cd ~/docker_install

# 下载 Docker CE、CLI、containerd 和 Docker Compose 插件（根据需要）
wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-ce_<version>_amd64.deb
wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-ce-cli_<version>_amd64.deb
wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/containerd.io_<version>_amd64.deb
wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-buildx-plugin_<version>_amd64.deb
wget https://download.docker.com/linux/ubuntu/dists/focal/pool/stable/amd64/docker-compose-plugin_<version>_amd64.deb

# 注意： 请将 <version> 替换为要下载的具体版本号。您可以在 Docker 官方下载页面上找到这些版本，并替换相应的链接。

sudo dpkg -i *.deb

# 或者执行：
sudo dpkg -i ./containerd.io_<version>_<arch>.deb \
  ./docker-ce_<version>_<arch>.deb \
  ./docker-ce-cli_<version>_<arch>.deb \
  ./docker-buildx-plugin_<version>_<arch>.deb \
  ./docker-compose-plugin_<version>_<arch>.deb

sudo apt-get install -f

sudo dpkg -i *.deb

sudo service docker start
docker --version
sudo docker run hello-world

sudo systemctl start docker
sudo systemctl status docker
sudo systemctl enable docker

遇到问题（Ubuntu）

1. 运行测试镜像：sudo docker run hello-world

2. 报错：

Unable to find image 'hello-world:latest' locally
docker: Error response from daemon: Get "https://registry-1.docker.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers).
See 'docker run --help'.

3. 原因：网络不能访问docker 的镜像源

4. 方案1：配置国内镜像源
• 更改或新增配置文件：vim /etc/docker/daemon.json

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://registry.docker-cn.com",
    "https://hub-mirror.c.163.com",
    "https://mirror.iscas.ac.cn"
  ]
}

• 重启服务：service docker restart
• 检查镜像源：docker info|grep Mirrors -A 5 ——匹配到 "Mirrors" 的行后，再额外显示匹配行后面的 5 行内容（-A 表示 "After"）

5. 方案2：去阿里云官方申请了镜像地址也加速失败
• https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

6. 结果：更新完之后发现还是不行，网上一搜才知道是很多镜像源已经停止服务了（放弃）

开始安装（CentOS 7.9）

sudo yum localinstall containerd.io-1.6.33-3.1.el7.x86_64.rpm docker-ce-26.1.4-1.el7.x86_64.rpm docker-ce-cli-26.1.4-1.el7.x86_64.rpm docker-buildx-plugin-0.14.1-1.el7.x86_64.rpm docker-compose-plugin-2.27.1-1.el7.x86_64.rpm -y

• 手动下载 gpg 文件：https://download.docker.com/linux/centos/gpg

• 导入 gpg 密钥：sudo rpm --import gpg

• 验证 gpg 密钥：rpm -qa gpg-pubkey*

• 重新执行安装命令即可安装成功

启动设置

# 单次启动
sudo systemctl start docker

# 重载配置文件
sudo systemctl daemon-reload

# 重启docker（二选一）
sudo systemctl restart docker
service docker restart

# 设置开机启动docker
sudo systemctl enable docker

# 查看docker状态
sudo systemctl status docker

快速制作Python环境镜像

1、创建 Dockerfile 文件

# 选择基础镜像
FROM python:3.9

# 设置工作目录
WORKDIR /app

# 复制 requirements.txt 文件到容器中的工作目录（否则在构建镜像时会报找不到requirements.txt文件的错）
COPY requirements.txt .

# 安装所需的 Python 包
RUN pip install --no-cache-dir -r requirements.txt     # 文件安装（如果使用文件安装则必须使用COPY指令复制文件到容器中）
# RUN pip install --no-cache-dir flask                 # 单独安装

2、构建镜像

docker build -f Dockerfile -t test_image .

# -f：使用指定文件来构建，不写-f则默认使用Dockerfile文件
# -t：指定镜像的名称为 test_image。
# .：表示上下文路径，即 Dockerfile 所在目录。

3、导出与导入

# 1. 使用 save 命令导出镜像为 tar 文件
docker save -o my-image.tar my-image         # 将 my-image 镜像导出为 my-image.tar 文件，保存到当前路径下

# 2. 将 tar 文件传输到新机器上

# 3. 使用 load 命令加载镜像
docker load -i my-image.tar                  # 在新机器上拿到 tar 文件后，使用 load 命令加载镜像

4、从镜像创建容器

docker images          # 查看镜像列表

# 创建容器：-d：后台运行；--name：指定容器名称；-v：设置挂载路径；-it：以交互模式进入；/bin/bash：在容器内提供一个交互式的终端环境
# -it test_image /bin/bash    与 exec 命令中的相同，但不可省略
docker run -d --name test_container -v /home/anjhon/project/python_app_docker:/app/python_app_docker -it test_image /bin/bash

# 进入容器；-it：以交互模式进入；/bin/bash：在容器内提供一个交互式的终端环境
docker exec -it test_image /bin/bash     

# 退出容器
exit                   

Python 镜像对比

镜像操作

docker search python                       # 搜索镜像（如果配置了镜像源，那么就是在镜像源内搜索）
# 也可以去官方找：https://hub.docker.com/_/python/tags

docker pull (镜像ID | 镜像名[:标签])         # 拉取镜像（不指定标签则拉取最新版本的）
docker pull python:3.9-alpine3.20          # 拉取指定版本的镜像
docker push my-image:latest                # 将本地镜像上传到 Docker 仓库
docker inspect my-image                    # 查看镜像的详细信息，包括配置和层信息

# 查看镜像列表（以下两个命令功能相同）: 结果包含了仓库名、标签、镜像ID、创建时间以及所占用的空间（这里显示的是解压后的大小，Docker Hub 中显示的是压缩体积）
docker images                              
docker image ls                            # Docker 1.13 及以后的版本中引入的更具可读性的命令格式
# REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
# hello-world   latest    ee301c921b8a   7 months ago   9.14kB
docker image ls 可选参数：
# -a（--all）：列出所有镜像，包括中间层镜像；如：docker image ls -a
# -q（--quiet）：只显示镜像的 ID；如：docker image ls -q
# -f (--filter)：根据条件过滤输出的镜像；如：docker image ls -f dangling=true; docker image ls --filter "dangling=true"（只显示悬空镜像）
# --format：自定义输出格式；如：docker image ls --format "{{.Repository}}: {{.Tag}}"（以指定格式输出镜像信息）
# --no-trunc：不截断输出的镜像 ID 和其他信息；如：docker image ls --no-trunc
# --digests：显示镜像的摘要信息；如：docker image ls --digests
# --help：显示帮助信息；如：docker image ls --help
docker image ls ubuntu                     # 根据仓库名列出不同标签的镜像     
docker image ls ubuntu:18.04               # 指定仓库名和标签查看镜像
docker image ls -f since=mongo:3.2         # 根据条件筛选镜像，列出 mongo:3.2 以后的版本
docker image ls -f before=mongo:3.2        # 根据条件筛选镜像，列出 mongo:3.2 之前的版本

# 悬空镜像（Dangling Images）是指那些没有任何标签（tag）或没有被任何容器使用的 Docker 镜像。这些镜像通常是由于镜像的更新或构建过程中的中间层而产生的；虽然它们不再被使用，但仍然占用磁盘空间，可能导致存储资源的浪费。
docker image ls -f dangling=true           # 只显示悬空镜像
docker image prune                         # 清除悬空镜像

# 查看 Docker 系统的磁盘使用情况，包括镜像、容器、数据卷所占用的空间，返回类型、数量、大小、百分比等
docker system df
TYPE                TOTAL               ACTIVE              SIZE                RECLAIMABLE
Images              24                  0                   1.992GB             1.992GB (100%)
Containers          1                   0                   62.82MB             62.82MB (100%)
Local Volumes       9                   0                   652.2MB             652.2MB (100%)
Build Cache                                                 0B                  0B

# 删除镜像
docker rmi [选项] <镜像1> [<镜像2> ...]
docker image rm [选项] <镜像1> [<镜像2> ...]                 
# <镜像> 可以是镜像短 ID、镜像长 ID、镜像名或者镜像摘要（默认列出的是短 ID）
# 有些删除操作可能有 Untagged 提示，说明是取消了镜像的标签，因为除了当前要删除的标签，可能还有其他标签指向这个镜像；也可能某个其他镜像正依赖于当前镜像的某一层；或者有用这个镜像启动的容器存在（即使容器没有运行）
# 所以并非所有的 docker image rm 都会真正删除镜像，有可能仅仅是取消某个标签
docker image rm <镜像>@<镜像摘要>                            # 根据镜像摘要删除
docker image rm $(docker image ls -q redis)                 # 根据条件查询删除
docker image rm $(docker image ls -q -f before=mongo:3.2)   # 根据条件查询删除
docker image rm 可选参数：
# -f, --force：强制删除镜像，即使该镜像被一个或多个容器使用；如：docker image rm -f my-image
# -no-prune：在删除镜像时不删除其父镜像；如：docker image rm --no-prune my-image
# --help：显示帮助信息；如：docker image rm --help

# 查看镜像历史
docker history nginx:v2

容器操作

创建容器

docker run --help
docker run (镜像ID | 镜像名[:标签])                         # 从镜像创建一个容器，
docker run -d -p 88:80 -v /app/nghtml:/user/shar/nginx/html --name app1 -- restart always nginx    

docker run 可选参数：
# -d（--detach）：后台运行；如：docker run -d my-image
# -p（--publish） ：将容器的端口映射到主机的端口；如：docker run -p 8080:80 my-image（将容器的 80 端口映射到主机的 8080 端口）
# --name：为容器指定一个名称；如：docker run --name my-container my-image
# -e（--env）：设置环境变量；如：docker run -e MY_ENV_VAR=value my-image
# -v（--volume）：将主机目录或文件挂载到容器中；如：docker run -v /host/path:/container/path my-image 第一个是服务器主机目录，第二个是容器目录；挂载之后服务就会以服务器目录为准，如果其中没有内容就会报错，需要将内容迁移到挂载目录。
# --restart：设置容器的重启策略；如：docker run --restart unless-stopped my-image
	# --restart no：默认值。容器退出时不会自动重启。
	# --restart always：无论容器是正常退出还是异常退出，都会自动重启容器。
	# --restart unless-stopped：容器会在异常退出时自动重启，但如果容器被手动停止（使用 docker stop），则不会重启。
	# --restart on-failure：仅在容器非零退出状态时重启容器。可以指定一个可选的最大重启次数；--restart on-failure:5（最多重启 5 次）
# --rm：在容器停止后自动删除容器；如：docker run --rm my-image；
# --network：指定容器连接的网络；如：docker run --network my-network my-image
# -it：以交互模式运行容器，并分配一个伪终端；如：docker run -it my-image /bin/bash
# --memory：设置容器的内存限制（默认使用主机系统的所有可用内存）；如：docker run --memory 512m my-image

• 检查本地是否存在指定的镜像，不存在就从 registry 下载

• 利用镜像创建并启动一个容器

• 分配一个文件系统，并在只读的镜像层外面挂载一层可读写层

• 从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去

• 从地址池配置一个 ip 地址给容器

• 执行用户指定的应用程序

• 执行完毕后容器被终止

容器状态与启停

docker ps                                                 # 查看运行中的容器
docker ps 可选参数：
# -a, --all：列出所有容器，包括已停止的容器；如：docker ps -a
# -q, --quiet：只显示容器的 ID；如：docker ps -q
# -f, --filter：根据条件过滤输出的容器；如：docker ps --filter "status=exited"（只显示已退出的容器）
# --format：自定义输出格式；如：docker ps --format "{{.ID}}: {{.Names}}"（以指定格式输出容器信息）
# --no-trunc：不截断输出的容器 ID 和其他信息；如：docker ps --no-trunc
# -n, --last：显示最近创建的 N 个容器；如：docker ps -n 5（显示最近的 5 个容器）
# --size：显示容器的大小；如：docker ps --size
# --help：显示帮助信息；如：docker ps --help

docker stop <container_id|container_name>
docker start <container_id|container_name>
docker restart <container_id|container_name>
docker stats <container_id|container_name>                                # 显示容器的实时资源使用情况
docker logs <container_id|container_name>                                 # 查看容器日志
docker rm <container_id|container_name>                                   # 删除容器，需要先停止容器
docker rm -f <container_id|container_name>                                # 删除容器，运行中的也能删除
docker rm -f $(docker ps -aq)                                             # 删除所有容器；docker ps -aq 会返回所有容器的 ID 列表；$(...) 替换语法
docker logs <container_id|container_name>                                 # 查看容器的日志输出
docker inspect <container_id|container_name>                              # 查看容器的详细信息
docker top <container_id|container_name>                                  # 显示容器内正在运行的进程
docker cp <container_id|container_name>:/path/in/container /path/on/host  # 在主机和容器之间复制文件或目录
docker exec -it <container_id|container_name> /bin/bash                   # 进入容器；-it：以交互模式进入；/bin/bash：在容器内提供一个交互式的终端环境
exit                                                                      # 退出容器，回到服务器

docker commit <container_id|container_name> <image_name[:tag]>            # 将容器的当前状态保存为一个新的镜像
docker commit 可选参数：
# -m, --message：为提交添加说明；如：docker commit -m "Update app" my-container my-new-image
# -a, --author：指定作者信息；如：docker commit -a "Author Name" my-container my-new-image
# -p, --pause：在提交时暂停容器；如：docker commit -p my-container my-new-image（默认值为 true，表示在提交时暂停容器）
# --change：应用 Dockerfile 指令的变化；如：docker commit --change "ENV MY_ENV_VAR=value" my-container my-new-image
# --help：显示帮助信息；如：docker commit --help
docker commit -m "更新了一些东西" mynginx mynginx:v1.0                      # 将容器打包成镜像（会自动生成镜像ID）
docker commit -m "Added python setuptool pip numpy" -a "wangxiaolei" 0c28c802c5e6 mycentos:mydev

打包传输

文件形式

docker save -o  filename.tar <image_id|image_name[:tag]>                  # 将镜像保存成文件（一般是tar文件）
docker save -o mynginx.tar mynginx:v1.0                                   # 将镜像保存成文件（最终生成mynginx.tar文件）

# 文件传输之后
docker load -i mynginx.tar                                                # 加载文件为镜像

线上形式

docker login                                   # 登陆docker-hub（输入账号密码）

docker tag mynginx:v1.0 anjhon/mynginx:v1.0    # 创建一个新名称的镜像（docker-hub上要求镜像名是用户名+镜像名）这个镜像是应用了原来的镜像的
docker push anjhon/mynginx:v1.0                # 推送镜像到docker-hub

Docker存储

• 修改数据需要先进入容器内部，操作繁琐

• 容器崩溃后数据丢失

目录挂载

docker run -d -p 80:80 -v /app/nghtml:/user/shar/nginx/html --name app1 nginx

# -v：目录挂载（挂载就像外接U盘）；第一个是服务器目录，第二个是容器目录；挂载之后服务就会以服务器目录为准，如果其中没有内容就会报错，需要将内容迁移到挂载目录

卷映射

docker run -d -p 88:80 -v /app/nghtml:/user/shar/nginx/html -v ngconfig:/etc/nginx --name app2 nginx
 
 # 第一个-v是挂载目录，他需要提供 ——> 服务器路径：容器路径
 # 第二个-v是卷映射，它需要提供 ——> 卷名：容器路径
 # 这个命令会在服务器的：/var/lib/docker/volumes/ 文件夹中生成一个同名的卷，其中有一个_data文件夹包含了容器文件夹中的内容，在这里修改文件内容，容器内部也会发生变化
 
 
docker volume ls               # 查看所有的卷
docker volume inspect 卷名      # 查看卷的详情（包含卷的位置） 

# 旧容器崩溃后，运行新的容器时可以直接将卷和挂载目录配置到新容器，这时数据用的还是旧容器的数据

docker run -d -p 89:80 -v /app/nghtml:/user/shar/nginx/html -v ngconfig:/etc/nginx --name app3 nginx

Docker 网络

docker run -d -p 88:80 --name app1 nginx
docker run -d -p 99:80 --name app2 nginx

docker container inspect app1       # 查看容器app1的信息，能看到他的局域网IP地址
docker container inspect app2       # 查看容器app2的信息，能看到他的局域网IP地址

# 在app1容器内访问app2
docker exec -it app1 /bin/bash
curl http://172.17.0.3:80

docker network create mynet     # 创建自定义网络
docker network ls               # 查看所有网络

docker run -d -p 88:80 --name app1 --network mynet nginx          # 启动容器并加入自定义网络
docker run -d -p 88:80 --name app2 --network mynet nginx

docker container inspect app1       # 查看容器app1的信息，能看到他的局域网IP地址
docker container inspect app2       # 查看容器app2的信息，能看到他的局域网IP地址

# 在app1容器内访问app2
docker exec -it app1 /bin/bash
curl http://app2:80

Docker Compose

命令式启动

#创建网络
docker network create blog

#启动mysql
docker run -d -p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=wordpress \
-v mysql-data:/var/lib/mysql \
-v /app/myconf:/etc/mysql/conf.d \
--restart always --name mysql \
--network blog \
mysql:8.0

#启动wordpress
docker run -d -p 8080:80 \
-e WORDPRESS_DB_HOST=mysql \
-e WORDPRESS_DB_USER=root \
-e WORDPRESS_DB_PASSWORD=123456 \
-e WORDPRESS_DB_NAME=wordpress \
-v wordpress:/var/www/html \
--restart always --name wordpress-app \
--network blog \
wordpress:latest

Compose启动

compose.yaml配置文件的编写

name: myblog
services:
  mysql:
    container_name: mysql
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=wordpress
    volumes:
      - mysql-data:/var/lib/mysql
      - /app/myconf:/etc/mysql/conf.d
    restart: always
    networks:
      - blog

  wordpress:
    image: wordpress
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: 123456
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress:/var/www/html
    restart: always
    networks:
      - blog
    depends_on:
      - mysql

volumes:
  mysql-data:
  wordpress:

networks:
  blog:

compose批量启动

docker compose up -d                                           # up表示上线（第一次启动），-d：后台运行

docker compose -f compose.yaml up -d                           # 修改了配置文件，对其进行更新（只会重启修改过的容器）

docker compose -f compose.yaml down                            # 下线（移除）容器，【会保留卷】
docker compose -f compose.yaml down --rmi -v                   # 下线（移除）容器；--rmi：同时删除容器对应的镜像；-v：同时删除容器映射的卷

# -f：使用指定文件来构建，不写-f则默认使用Dockerfile文件

制作镜像

Dockerfile文件

docker builder通过dockerfile文件的内容来制作镜像，所以制作镜像最主要的就是编写Dockerfile文件。

通常，Dockerfile 的第一行是 FROM 指令，它定义了镜像的基础环境。然而，如果你的机器不能联网，那么不能直接从官方 Docker Hub 或其他在线仓库拉取基础镜像。解决这个问题的办法有以下几种：

方法 1: 使用已有的本地基础镜像

方法 2: 离线获取基础镜像

• 在可联网的机器上拉取镜像

• 在联网机器上将镜像保存为 .tar 文件

• 将镜像传输到离线机器

• 在离线机器上加载镜像

方法 3：配置一个可用镜像源，阿里云主机可以参考这里配置

Dockerfile 中的指令是按顺序执行的，某些指令依赖于之前的指令的结果，所以编写时需要按照顺序编写。

# 选择基础镜像
FROM python:3.9

# 维护者信息（已被 LABEL 替代）
LABEL maintainer="your_email@example.com"

# 设置构建时变量
ARG APP_VERSION=1.0

# 设置环境变量
ENV APP_HOME=/app

# 创建工作目录
WORKDIR $APP_HOME

# 复制当前目录的内容到容器中的工作目录
COPY . .

# 安装所需的 Python 包
RUN pip install --no-cache-dir -r requirements.txt

# 声明容器监听的端口
EXPOSE 5000

# 创建数据卷
VOLUME ["/data"]

# 指定容器启动时运行的命令
CMD ["python", "app.py"]

# 设置容器的入口点
ENTRYPOINT ["python"]

# 指定运行容器时的用户
USER nobody

构建镜像

docker build -f Dockerfile -t my_python_app:v1.0 .
# .：表示上下文路径，Docker 会在这个目录中查找 Dockerfile 和其他需要的文件。

docker build 可选参数：
# -t（--tag）：为镜像指定一个名称和标签；如：docker build -t my-image:latest .（将镜像命名为 my-image，标签为 latest）
# -f（--file）：指定 Dockerfile 的路径；如：docker build -f /path/to/Dockerfile .（使用指定路径的 Dockerfile 构建镜像）
# --no-cache：在构建时不使用缓存；如：docker build --no-cache -t my-image .（强制重新构建所有层）
# --pull：在构建之前尝试拉取最新的基础镜像；如：docker build --pull -t my-image .（确保使用最新的基础镜像）
# --build-arg：传递构建时变量；如：docker build --build-arg MY_VAR=value .（在 Dockerfile 中使用 ARG 指令接收该变量）
# --label：为镜像添加元数据标签；如：docker build --label version=1.0 .（为镜像添加版本标签）
# --quiet（-q）：只输出镜像 ID，不显示构建过程的详细信息；如：docker build -q -t my-image .（构建完成后只输出镜像 ID）
# --rm：在构建完成后自动删除中间容器（默认值为 true）；如：docker build --rm -t my-image .（构建完成后删除中间容器）
# --target：指定多阶段构建中的目标阶段；如：docker build --target builder -t my-image .（构建指定的阶段）
# --squash：将所有层压缩为一层（需要 Docker 版本支持）；如：docker build --squash -t my-image .（减少镜像大小）

实操

推荐连接

1. 官方文档

2. DockerHub

3. Docker一从入门到实践

4. 使用Docker安装配置Jupyter并配置R语言与Python环境

5. docker desktop ubuntu镜像_基于docker的python数据挖掘环境搭建（Jupyter notebook））