1
2
3
4
5
6

docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  mysql

1
2
3
4
5

# Docker开机自启
systemctl enable docker

# Docker容器开机自启
docker update --restart=always [容器名/容器id]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 第1步，去DockerHub查看nginx镜像仓库及相关信息

# 第2步，拉取Nginx镜像
docker pull nginx

# 第3步，查看镜像
docker images
# 结果如下：
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
nginx        latest    605c77e624dd   16 months ago   141MB
mysql        latest    3218b38490ce   17 months ago   516MB

# 第4步，创建并允许Nginx容器
docker run -d --name nginx -p 80:80 nginx

# 第5步，查看运行中容器
docker ps
# 也可以加格式化方式访问，格式会更加清爽
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

# 第6步，访问网页，地址：http://虚拟机地址

# 第7步，停止容器
docker stop nginx

# 第8步，查看所有容器
docker ps -a --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

# 第9步，再次启动nginx容器
docker start nginx

# 第10步，再次查看容器
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"

# 第11步，查看容器详细信息
docker inspect nginx

# 第12步，进入容器,查看容器内目录
docker exec -it nginx bash
# 或者，可以进入MySQL
docker exec -it mysql mysql -uroot -p

# 第13步，删除容器
docker rm nginx
# 发现无法删除，因为容器运行中，强制删除容器
docker rm -f nginx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 修改/root/.bashrc文件
vi /root/.bashrc
内容如下：
# .bashrc

# User specific aliases and functions

alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias dps='docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Ports}}\t{{.Status}}\t{{.Names}}"'
alias dis='docker images'

# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 1.首先创建容器并指定数据卷，注意通过 -v 参数来指定数据卷
docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx

# 2.然后查看数据卷
docker volume ls
# 结果
DRIVER    VOLUME NAME
local     29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f
local     html

# 3.查看数据卷详情
docker volume inspect html
# 结果
[
    {
        "CreatedAt": "2024-05-17T19:57:08+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/html/_data",
        "Name": "html",
        "Options": null,
        "Scope": "local"
    }
]

# 4.查看/var/lib/docker/volumes/html/_data目录
ll /var/lib/docker/volumes/html/_data
# 可以看到与nginx的html目录内容一样，结果如下：
总用量 8
-rw-r--r--. 1 root root 497 12月 28 2021 50x.html
-rw-r--r--. 1 root root 615 12月 28 2021 index.html

# 5.进入该目录，并随意修改index.html内容
cd /var/lib/docker/volumes/html/_data
vi index.html

# 6.打开页面，查看效果

# 7.进入容器内部，查看/usr/share/nginx/html目录内的文件是否变化
docker exec -it nginx bash

1
2
3

# 查看MySQL容器详细信息
docker inspect mysql
# 关注其中.Config.Volumes部分和.Mounts部分

1
2
3
4
5
6
7
8
9

{
  "Config": {
    // ... 略
    "Volumes": {
      "/var/lib/mysql": {}
    }
    // ... 略
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{
  "Mounts": [
    {
      "Type": "volume",
      "Name": "29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f",
      "Source": "/var/lib/docker/volumes/29524ff09715d3688eae3f99803a2796558dbd00ca584a25a4bbc193ca82459f/_data",
      "Destination": "/var/lib/mysql",
      "Driver": "local",
    }
  ]
}

1
2
3
4

# 挂载本地目录
-v 本地目录:容器内目录
# 挂载本地文件
-v 本地文件:容器内文件

1
2

-v mysql:/var/lib/mysql # 会被识别为一个数据卷叫mysql，运行时会自动创建这个数据卷
-v ./mysql:/var/lib/mysql # 会被识别为当前目录下的mysql目录，运行时如果不存在会创建目录

1
2
3
4
5
6
7

rust@bird:~/docker-demo$ ll
总计 20
drwxrwxr-x  2 rust rust 4096  4月 11 14:24 ./
drwxr-xr-x 24 rust rust 4096  4月 11 14:24 ../
-rw-rw-r--  1 rust rust  246  4月 11 14:14 app.py
-rw-rw-r--  1 rust rust  463  4月 11 14:24 dockerfile
-rw-rw-r--  1 rust rust    7  4月 11 14:13 requirements.txt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from flask import Flask
import os

app = Flask(__name__)

@app.route("/")
def hello():
    return f"Hello from Docker! Python works. Hostname={os.uname().nodename}\n"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 指定基础镜像（这里没有从Linux镜像开始）
FROM python:3.11-slim

# 时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 设置工作目录
WORKDIR /app

# 先拷贝依赖清单，利用 Docker 分层缓存
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 再拷贝代码
COPY app.py .

# 声明监听端口
EXPOSE 8000

# 入口命令
CMD ["python", "app.py"]

1
2
3
4

# 进入镜像目录
cd ~/docker-demo
# 开始构建
docker build -t docker-demo:1.0 .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

rust@bird:~/docker-demo$ docker build -t docker-demo:1.0 .
[+] Building 100.4s (11/11) FINISHED                                                            docker:default
 => [internal] load build definition from dockerfile                                                      0.0s
 => => transferring dockerfile: 502B                                                                      0.0s
 => [internal] load metadata for docker.io/library/python:3.11-slim                                      52.3s
 => [internal] load .dockerignore                                                                         0.0s
 => => transferring context: 2B                                                                           0.0s
 => [1/6] FROM docker.io/library/python:3.11-slim@sha256:233de06753d30d120b1a3ce359d8d3be8bda78524cd8f5  32.6s
 => => resolve docker.io/library/python:3.11-slim@sha256:233de06753d30d120b1a3ce359d8d3be8bda78524cd8f52  0.0s
 => => sha256:5435b2dcdf5cb7faa0d5b1d4d54be2c72a776fab9a605336f5067d6e9ecb5976 29.78MB / 29.78MB         18.3s
 => => sha256:37ffa6577b04e98598e2c10432eb8c66cfc1af6c7698b21c6163f8334606aa14 1.29MB / 1.29MB           18.0s
 => => sha256:d98f36ba21593a4014243f41ec9c5370abd34f4f65a5d074e41bce23f5f6a165 14.37MB / 14.37MB         23.9s
 => => sha256:233de06753d30d120b1a3ce359d8d3be8bda78524cd8f520c99883bfe33964cf 10.37kB / 10.37kB          0.0s
 => => sha256:ad65166ad2583036804a3f772ec8f1cad733cf77d631c6840ab1ea9231b6b350 1.75kB / 1.75kB            0.0s
 => => sha256:d1a45c0fb43d72e0c013ee97d460aa8f49f2c1bbd588b17a558cc6f7078b4276 5.48kB / 5.48kB            0.0s
 => => sha256:0816ee351b60c03c7a77a3f50c717891eedd927f4e6a1d59f6cce05268065606 251B / 251B               32.6s
 => => extracting sha256:5435b2dcdf5cb7faa0d5b1d4d54be2c72a776fab9a605336f5067d6e9ecb5976                 1.0s
 => => extracting sha256:37ffa6577b04e98598e2c10432eb8c66cfc1af6c7698b21c6163f8334606aa14                 0.1s
 => => extracting sha256:d98f36ba21593a4014243f41ec9c5370abd34f4f65a5d074e41bce23f5f6a165                 0.7s
 => => extracting sha256:0816ee351b60c03c7a77a3f50c717891eedd927f4e6a1d59f6cce05268065606                 0.0s
 => [internal] load build context                                                                         0.0s
 => => transferring context: 333B                                                                         0.0s
 => [2/6] RUN ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo Asia/Shanghai > /etc/time  0.7s
 => [3/6] WORKDIR /app                                                                                    0.0s
 => [4/6] COPY requirements.txt .                                                                         0.0s
 => [5/6] RUN pip install --no-cache-dir -r requirements.txt                                             14.5s
 => [6/6] COPY app.py .                                                                                   0.0s
 => exporting to image                                                                                    0.1s
 => => exporting layers                                                                                   0.1s
 => => writing image sha256:da9e550b6449667879ae1a72189501bb49522ccc2aa21c34108fdeb89b4bb976              0.0s
 => => naming to docker.io/library/docker-demo:1.0   

1
2
3
4
5
6
7
8

# 查看镜像列表：
docker images
# 结果
rust@bird:~/docker-demo$ docker images
REPOSITORY                  TAG               IMAGE ID       CREATED         SIZE
docker-demo                 1.0               da9e550b6449   4 minutes ago   140MB
mysql                       8.0.32            412b8cc72e4a   3 years ago     531MB
nginx                       latest            3f8a4339aadd   8 years ago     108MB

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1.创建并运行容器
docker run -d --name pyweb2 -p 8000:8000 -e TZ=Asia/Shanghai docker-demo:1.0
# 2.查看容器
rust@bird:~/docker-demo$ docker ps
CONTAINER ID   IMAGE             COMMAND                   CREATED          STATUS          PORTS                                                  NAMES
d8e3a9172300   docker-demo:1.0   "python app.py"           3 seconds ago    Up 3 seconds    0.0.0.0:8000->8000/tcp, :::8000->8000/tcp              pyweb2
0de3d38b0e0f   mysql:8.0.32      "docker-entrypoint.s…"   42 minutes ago   Up 42 minutes   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   mysql

# 3.访问
curl http://localhost:8000/
# 结果
rust@bird:~/docker-demo$ curl http://localhost:8000/
Hello from Docker! Python works. Hostname=d8e3a9172300

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 1.用基本命令，寻找Networks.bridge.IPAddress属性
docker inspect mysql
# 也可以使用format过滤结果
docker inspect --format='{{range .NetworkSettings.Networks}}{{println .IPAddress}}{{end}}' mysql
# 得到IP地址如下：
172.19.0.2

# 2.然后通过命令进入dd容器
docker exec -it pyweb2 bash

# 3.在容器内，通过ping命令测试网络
apt-get update
apt-get install -y iputils-ping
ping 172.19.0.2
# 结果
PING 172.19.0.2 (172.19.0.2) 56(84) bytes of data.
64 bytes from 172.19.0.2: icmp_seq=1 ttl=64 time=0.053 ms
64 bytes from 172.19.0.2: icmp_seq=2 ttl=64 time=0.059 ms
64 bytes from 172.19.0.2: icmp_seq=3 ttl=64 time=0.058 ms

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 1.首先通过命令创建一个网络
docker network create demo-net

# 2.然后查看网络
docker network ls
# 结果：
rust@bird:~/docker-demo$ docker network ls
NETWORK ID     NAME       DRIVER    SCOPE
3d0ccb61692f   bridge     bridge    local
bb2fa2b35127   demo-net   bridge    local
89a54c5d5b83   host       host      local
23a70f2198b6   none       null      local
# 其中，除了demo-net以外，其它都是默认的网络

# 3.让pyweb2和mysql都加入该网络，注意，在加入网络时可以通过--alias给容器起别名
# 这样该网络内的其它容器可以用别名互相访问！
# 3.1.mysql容器，指定别名为db，另外每一个容器都有一个别名是容器名
docker network connect demo-net mysql --alias db
# 3.2.db容器，也就是我们的python项目
docker network connect demo-net pyweb2

# 4.进入pyweb2容器，尝试利用别名访问db
# 4.1.进入容器
docker exec -it pyweb2 bash
# 4.2.用db别名访问
ping db
# 结果
root@d8e3a9172300:/app# ping db
PING db (172.19.0.2) 56(84) bytes of data.
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=1 ttl=64 time=0.079 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=2 ttl=64 time=0.044 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=3 ttl=64 time=0.067 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=4 ttl=64 time=0.058 ms
# 4.3.用容器名访问
ping mysql
# 结果：
root@d8e3a9172300:/app# ping mysql
PING mysql (172.19.0.2) 56(84) bytes of data.
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=1 ttl=64 time=0.036 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=2 ttl=64 time=0.055 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=3 ttl=64 time=0.054 ms
64 bytes from mysql.demo-net (172.19.0.2): icmp_seq=4 ttl=64 time=0.064 ms

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

~/docker-demo/compose/
  app/
    app.py
    requirements.txt
    Dockerfile
  docker-compose.yml
  mysql/
    init/
      01-init.sql
    conf/
      (可选自定义配置)

1
2

flask
PyMysql

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FROM python:3.11-slim

ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

EXPOSE 8008

CMD ["python", "app.py"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

from flask import Flask, jsonify
import os
import pymysql

app = Flask(__name__)

def get_conn():
    return MySQLdb.connect(
        host=os.getenv("DB_HOST", "mysql"),
        port=int(os.getenv("DB_PORT", "3306")),
        user=os.getenv("DB_USER", "root"),
        passwd=os.getenv("DB_PASSWORD", "123456"),
        db=os.getenv("DB_NAME", "demo"),
        charset="utf8mb4"
    )

@app.route("/api/health")
def health():
    return jsonify({"status": "ok", "service": "python"})

@app.route("/api/db")
def db_test():
    conn = get_conn()
    cur = conn.cursor()
    cur.execute("SELECT VERSION()")
    row = cur.fetchone()
    cur.close()
    conn.close()
    return jsonify({"mysql_version": row[0] if row else None})

@app.route("/api/users")
def users():
    conn = get_conn()
    cur = conn.cursor()
    cur.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));")
    cur.execute("INSERT INTO users (name) VALUES ('Alice'),('Bob');")
    conn.commit()
    cur.execute("SELECT id, name FROM users;")
    rows = cur.fetchall()
    cur.close()
    conn.close()
    return jsonify([{"id": r[0], "name": r[1]} for r in rows])

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

services:
  mysql:
    image: mysql:8.0.32
    container_name: mysql
    restart: always
    ports:
      - "3306:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: "123456"
      MYSQL_DATABASE: "demo"
    volumes:
      - ./mysql/init:/docker-entrypoint-initdb.d   # 初始化 SQL
      - mysql-data:/var/lib/mysql                   # 持久化数据
    networks:
      - demo-net

  python:
    build: ./app            # 使用上面的 Dockerfile 构建
    container_name: python
    restart: always
    ports:
      - "8008:8000"        # 之前的pyweb2练习占用了虚拟机的8000端口，映射到虚拟机的8008端口
    environment:
      TZ: Asia/Shanghai
      DB_HOST: "mysql"     # 在同一网络中用服务名访问
      DB_PORT: "3306"
      DB_USER: "root"
      DB_PASSWORD: "123456"
      DB_NAME: "demo"
    depends_on:
      - mysql              # 确保 MySQL 先启动
    networks:
      - demo-net

volumes:
  mysql-data:

networks:
  demo-net:
    name: demo-net
    external: true       # 声明：这是外部网络，Compose 不会自己去建(复用前面建的网络)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

cd ~/docker-demo/compose
# 清理残留的mysql
docker container stop mysql
docker container rm mysql

# 启动所有服务
docker compose up -d

# 查看容器状态
docker compose ps

# 查看日志
docker compose logs -f python
docker compose logs -f mysql

# 访问 Python 接口
curl http://localhost:8008/api/health
curl http://localhost:8008/api/db
curl http://localhost:8008/api/users

# 进入 Python 容器查看网络
docker compose exec python bash
# 在容器内
apt-get update
apt-get install -y iputils-ping
ping mysql

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 停止并移除容器/网络（保留卷）
docker compose down

# 停止并移除容器、网络、卷（清空数据）
docker compose down -v

# 清理之前的练习
docker container stop pyweb2
docker container stop mysql

docker container rm pyweb2
docker container rm mysql

docker network rm demo-net

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v ./mysql/data:/var/lib/mysql \
  -v ./mysql/conf:/etc/mysql/conf.d \
  -v ./mysql/init:/docker-entrypoint-initdb.d \
  --network demo-net
  mysql

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

version: "3.8"

services:
  mysql:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123456
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"
      - "./mysql/data:/var/lib/mysql"
    networks:
      - new
networks:
  new:
    name: demo-net