面向数据科学家的Docker指南

Docker是什么？解决了什么问题？

一些需要拎清的概念

• 镜像：如果装过操作系统，就一定对这个词语不陌生，毕竟装系统一般都需要下载ISO或者IMG镜像文件，此处的镜像和操作系统的镜像文件的概念是一样的，就是指包含了所有运行所需的文件的而形成的一个大的文件。注意，镜像是一个“死”的东西，是一个文件。

• 容器：容器就是对应镜像运行起来之后的程序了。注意，容器是“活”的，是个程序，因此容器有多种状态，比如运行中(Running)、已退出（Exited）、暂停中（Paused）等。

• 每个容器都是从一个Docker镜像创建的，但一个镜像可以生成多个容器，就像一个windows镜像可以用来给多台主机装系统一样；

• 镜像文件是通用的，一台机器的镜像文件拷贝到另一台机器，照样可以使用，且结果一模一样。为了方便镜像的共享，一般将制作好的镜像文件上传到网上的镜像仓库，如Docker Hub，就像把写好的代码开源到GitHub上供别人使用一样。

• Volume（卷）：
• Volume 是用来在宿主机和容器之间共享数据的机制。它允许容器持久化保存数据，并且在容器被删除后数据仍然保留。
• 通过 Volume，容器可以访问宿主机上的特定目录，也可以与其他容器共享数据。可以用于存储应用程序的数据、日志文件、配置文件等，实现数据的持久化和共享。

• Network（网络）：
• Network 用于连接 Docker 容器，使得它们可以相互通信，也可以与外部网络进行通信。通过网络，容器可以相互通信，实现微服务架构或多个容器协同工作的应用场景。
• Docker 支持多种网络模式，包括桥接网络、主机网络、覆盖网络等，每种网络模式都有不同的用途和特点。具体如下：
• 桥接网络（Bridge Network）：这是 Docker 默认的网络模式，它会为每个容器分配一个独立的 IP 地址，并且容器之间可以相互通信。桥接网络也允许容器与宿主机进行通信，但默认情况下不允许外部网络访问容器。
• 主机网络（Host Network）：使用主机网络模式时，容器将直接使用宿主机的网络栈，即容器和宿主机共享同一个网络命名空间。这意味着容器可以直接使用宿主机的 IP 地址和端口，从而提供更高的网络性能。
• 覆盖网络（Overlay Network）：覆盖网络允许多个 Docker 守护进程之间的容器进行通信，通常用在跨多个主机的容器集群上。
• 无网络（None Network）：在无网络模式下，容器不会连接到任何网络，此时，容器内部的进程只能通过 Unix socket 进行通信，而无法通过http/ip网络进行通信。

简单创建一个Python容器并发布该镜像

docker pull python:3.8

REPOSITORY   TAG   IMAGE ID       CREATED        SIZE
python       3.8   415775fb4b1f   2 months ago   998MB

CONTAINER ID   IMAGE        COMMAND   CREATED          STATUS          PORTS     NAMES
06a9615824cd   python:3.8   "bash"    10 minutes ago   Up 10 minutes             py38

• -itd：分配一个伪终端（pseudo-TTY），并以后台模式（detached mode）运行容器，即在后台运行容器，并保持标准输入打开。

• --name py38：给容器指定一个名称 py38，以便后续可以通过名称来引用这个容器。

• -v ~/dataset:/data：将宿主机中的 ~/dataset 目录挂载到容器内的 /data 目录，实现宿主机和容器之间的数据共享。

• python:3.8：之前拉取镜像的标识，标签一定不能少！不然会再去拉取默认镜像。

• bash：作为容器的启动命令，这将会启动一个交互式的 Bash shell，允许用户在容器内部进行交互操作。

• docker exec: 这是Docker命令，用于在运行中的容器中执行命令。

• -it: 这是两个选项的结合，i表示交互模式（stdin开启），t表示分配一个伪终端。

• py38: 表示要执行命令的目标容器的名称或ID，此处的容器名称为py38

• /bin/bash: 这是要在容器中执行的命令，这里是启动一个bash shell，以便与容器进行交互。

mkdir -p ~/miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm -rf ~/miniconda3/miniconda.sh
~/miniconda3/bin/conda init bash

brc@DESKTOP-72HHG9G:~$ docker commit -a "bairch" -m "my py env" 06a9615824cd mypy38:v1
sha256:c2a3088898089f05803ef3dc5630a8c5bb17bdbcd43090bc753bb325fa2b01c5

brc@DESKTOP-72HHG9G:~$ docker images
REPOSITORY   TAG    IMAGE ID       CREATED              SIZE
mypy38       v1     c2a308889808   About a minute ago   1.84GB
python       3.8    415775fb4b1f   2 months ago         998MB

• -a "bairch"：使用 a 参数指定了作者信息为 "bairch"

• -m "my py env"：使用 m 参数指定了提交时的说明信息为 "my py env"

• 06a9615824cd：这是要保存为镜像的容器的 ID

• mypy38:v1：这是新镜像的名称和标签。新镜像的名称为 mypy38，标签为 v1

brc@DESKTOP-72HHG9G:~$ docker ps
CONTAINER ID   IMAGE       COMMAND   CREATED         STATUS         PORTS     NAMES
28051d25b4ee   mypy38:v1   "bash"    5 minutes ago   Up 5 minutes             dreamy_stonebraker

brc@DESKTOP-72HHG9G:~$ docker push bairch/mypy38:v1
The push refers to repository [docker.io/bairch/mypy38]
f32c3e8a81ae: Pushed
02d14c5fe2c0: Mounted from library/python
f1c817089aa8: Mounted from library/python
aa19347b89d4: Mounted from library/python
a0814d1f5387: Mounted from library/python
ac7146fb6cf5: Mounted from library/python
209de9f22f2f: Mounted from library/python
777ac9f3cbb2: Pushed
ae134c61b154: Mounted from library/python
v1: digest: sha256:39b0bc01e69eed1023dd4fb89e4463f504596292ca51bcf2c72edd2633dbdc32 size: 2220

通过docker-compose安装容器（以MySql为例）

Docker-Compose将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）。Docker-Compose运行目录下的所有文件（docker-compose.yml，extends文件或环境变量文件等）组成一个工程，若无特殊指定工程名即为当前目录名。一个工程当中可包含多个服务，每个服务中定义了容器运行的镜像，参数，依赖。

Docker-Compose 通过一个配置文件来管理多个Docker容器，在配置文件 (docker-compose.yml) 中，所有的容器通过services来定义，然后使用docker-compose脚本来启动、停止和重启应用和应用中的服务以及所有依赖服务的容器。

mysql_serve
	├── conf
	│   └── my.cnf               # MySQL配置文件
	├── db                       # 数据库数据文件目录
	├── docker-compose.yml       # docker-compose.yml文件
	└── logs                     # 日志存放目录

version: '3' # 表示使用的是 Docker Compose 文件的版本. 这里使用的是版本3的语法，它定义了Docker Compose 文件的结构和支持的功能。
services:  # 这是一个关键字，用于定义服务的部分。在这个部分下，可以列出所有的服务以及它们的配置。本配置下只有mysql, 但是如果同时还有别的服务需求，都可以放到servers下。
  mysql:   # 一个服务的名称，也可以叫阿猫阿狗
    restart: always # 表示在容器退出时，Docker 会自动重启这个容器
		privileged: true # 标识容器拥有特权模式
    image: mysql:8.0.32 # 表示使用的 MySQL 镜像的名称和标签
    container_name: mysqlServer33106 # 为该容器指定了一个名称
    volumes: # 定义容器和宿主机之间的数据卷映射关系；格式为<宿主机地址>:<容器内地址>，其中宿主机地址是相对项目目录路径，容器内地址是绝对路径
      - ./db:/var/lib/mysql # 将容器内的地址映射到宿主机上，这样当容器退出了，数据库db文件还在
      - ./conf:/etc/mysql/conf.d # 同上，不会因为容器挂掉，mysql配置文件就丢失
      - ./logs:/logs # 同上，可以查看容器日志
    command: # 定义了在容器启动时要执行的命令。此处定义了MySQL服务的一些配置参数
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
    environment: # 定义了容器的环境变量，此处包括了数据库的root用户密码、用户、密码等信息。
      MYSQL_ROOT_PASSWORD: "Abc1234Q"
      MYSQL_USER: "user1"
      MYSQL_PASSWORD: "Abc1234Q"
      MYSQL_INITDB_SKIP_TZINFO: "Asia/Shanghai"
		ports: # 定义了容器的端口映射关系，此处将主机的33106端口映射到容器内的3306端口
      - 33106:3306  # <宿主机端口>:<容器端口>
    network_mode: "bridge" # 定义了容器的网络模式为桥接模式

###### [mysql]配置模块 ######
[mysql]
# 设置MySQL客户端默认字符集
default-character-set=utf8mb4
socket=/var/lib/mysql/mysql.sock


###### [mysqld]配置模块 ######
[mysqld]
port=3306
user=mysql

sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION

datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock

# MySQL8 的密码认证插件
default_authentication_plugin=mysql_native_password

# 禁用符号链接以防止各种安全风险
symbolic-links=0

# 允许最大连接数
max_connections=1000

# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8mb4

# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB

# 表名存储在磁盘是小写的，但是比较的时候是不区分大小写
lower_case_table_names=0
max_allowed_packet=16M 

# 设置时区
default-time_zone='+8:00'

# binlog 配置
log-bin = /logs/mysql-bin.log
expire-logs-days = 90
max-binlog-size = 500M

# server-id 配置
server-id = 1


###### [client]配置模块 ######
[client]
default-character-set=utf8mb4

# 进入正在运行的MySQL容器内部
docker exec -it <mysql_container_name> /bin/bash
# 使用root权限登录到MySQL服务器
mysql -u root -p
# 授予远程访问权限给特定的用户。其中的%表示允许任何地址连接
alter user '<user name>'@'%' identified with mysql_native_password by '<login password>';

补充

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=131
      - USER_GID=138
      - GITEA__database__DB_TYPE=mysql
      - GITEA__database__HOST=db:3306
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"
    depends_on:
      - db

  db:
    image: mysql:8
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=gitea
      - MYSQL_USER=gitea
      - MYSQL_PASSWORD=gitea
      - MYSQL_DATABASE=gitea
    networks:
      - gitea
    volumes:
      - ./mysql:/var/lib/mysql

• 通过depends_on来定义了服务之间的依赖关系，这样在docker-compose up的时候，会自动先启动被依赖的容器。当然，如果确实没有依赖关系也可以不用定义。

• 通过networks创建了一个名称为gitea的内部网络，供server和db这两个服务在同一个网络中进行通信。external: false表示这个网络是由docker-compose创建的内部网络，而不是外部已存在的网络。（设置这个就是方便且容易定制，不设置也没问题的，直接使用默认的bridge网络也可以。

打包Python项目为镜像

1. FROM: 所有Dockerfile的第一个指令都必须是 FROM ，用于指定一个构建镜像的基础源镜像，如果本地没有就会从公共库中拉取

2. WORKDIR：指明应用在容器中的工作目录。

3. COPY: 复制本机文件或目录到指定的容器目录，格式为 <src> <dest>

4. RUN：用于运行安装任务从而向映像中添加额外的内容。比如说安装Python依赖包等。

5. CMD：容器启动后运行的命令

fastapp  
    ├── requirements.txt
    ├── Dockerfile
    └── app
        └── app.py
        └── <other .py files>

from typing import Union
from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

FROM python:3.9

WORKDIR /fastapp # 在容器内创建一个工作目录

COPY ./requirements.txt /fastapp/requirements.txt

RUN pip install -r requirements.txt # 在容器的/app目录下安装依赖

COPY ./app /fastapp/app

CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "80"] # 在容器的/app目录下运行python main.py命令

brc@DESKTOP-72HHG9G:~/project/fastapp$ docker build -t dfast-app:0.1 .
[+] Building 14.4s (10/10) FINISHED                                                                                   docker:default
 => [internal] load .dockerignore                                                                                               0.0s
 => => transferring context: 2B                                                                                                 0.0s
 => [internal] load build definition from Dockerfile                                                                            0.0s
 => => transferring dockerfile: 259B                                                                                            0.0s
 => [internal] load metadata for docker.io/library/python:3.9                                                                   0.8s
 => [1/5] FROM docker.io/library/python:3.9@sha256:30678bb79d9eeaf98ec0ce83cdcd4d6f5301484ef86873a711e69df2ca77e8ac             0.0s
 => [internal] load build context                                                                                               0.0s
 => => transferring context: 311B                                                                                               0.0s
 => CACHED [2/5] WORKDIR /fastapp                                                                                               0.0s
 => [3/5] COPY ./requirements.txt /fastapp/requirements.txt                                                                     0.1s
 => [4/5] RUN pip install -r requirements.txt                                                                                  13.1s
 => [5/5] COPY ./app /fastapp/app                                                                                               0.1s
 => exporting to image                                                                                                          0.2s
 => => exporting layers                                                                                                         0.2s
 => => writing image sha256:e4c65f0dac1caf5a8b4a82c5e84412c15dd03f54240ea15d5f69169c838ad3fe                                    0.0s
 => => naming to docker.io/library/dfast-app:0.1                                                                                0.0s

What's Next?
  View a summary of image vulnerabilities and recommendations → docker scout quickview

brc@DESKTOP-72HHG9G:~/project/fastapp$ docker run --name myfastapp -p 800:80 dfast-app:0.1
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
INFO:     172.17.0.1:35006 - "GET /items/5?q=somequery HTTP/1.1" 200 OK
INFO:     172.17.0.1:35006 - "GET /favicon.ico HTTP/1.1" 404 Not Found
INFO:     172.17.0.1:35010 - "GET /items/5?q=som2 HTTP/1.1" 200 OK

补充

CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "80", "--reload"]

docker run --name myfastapp -v $PWD/app:/fastapp/app -p 800:80 dfast-app:0.1

一些技巧

• 由于一些原因，国内访问官方镜像仓库dockerhub的速度捉襟见肘，因此一般会换源。以下是Ubuntu中Docker仓库换源方法：

打开/etc/default/docker文件（需要sudo权限），在文件的底部追加如下一行:
DOCKER_OPTS="--registry-mirror=https://registry.docker-cn.com"

• docker需要管理员权限，要么每次都在所执行的命令前面加上 sudo，要么可以将自己的linux用户名添加到docker组中

sudo usermod -aG docker $USER

一些常用的docker命令

# 查看所有的docker容器，不加参数-a时，仅查看当前正在运行的容器
docker ps -a
# 查看所有的镜像
docker images
# 删除某个镜像
docker rmi <image id>
# 删除某个容器
docker rm <contaimer id>
# 运行某个停止的容器
docker start <container id>
# 停止某个容器
docker stop <container id>
# 进入某个运行容器的命令行
docker exec -it <container id> /bin/bash

总结

参考

• What is Docker? - GeeksforGeeks