flowchart LR
    A["Docker Client<br/>(docker 命令行)"] -->|"REST API / Unix Socket"| B["Docker Daemon<br/>(dockerd)"]
    B --> C["镜像 Images"]
    B --> D["容器 Containers"]
    B --> E["数据卷 Volumes"]
    B --> F["网络 Networks"]
    B <-->|"pull / push"| G["镜像仓库 Registry<br/>(Docker Hub / 私有仓库)"]

# 1. 卸载旧版本(如果有)
sudo yum remove -y docker docker-client docker-client-latest \
  docker-common docker-latest docker-latest-logrotate \
  docker-logrotate docker-engine
 
# 2. 安装依赖工具
sudo yum install -y yum-utils
 
# 3. 添加 Docker 官方仓库(国内网络环境下可替换为国内源,如阿里云:
#    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo)
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
 
# 4. 安装 Docker Engine、CLI、containerd 及 compose/buildx 插件
sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
 
# 5. 启动并设置开机自启
sudo systemctl start docker
sudo systemctl enable docker

# 1. 安装依赖
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
 
# 2. 添加官方 GPG 密钥与仓库
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 
# 3. 安装
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
 
sudo systemctl enable --now docker

docker --version           # Docker 引擎版本
docker compose version     # Compose 插件版本
docker info                # 详细运行时信息(存储驱动、cgroup、镜像加速地址等)
docker run hello-world     # 跑一个测试容器,验证安装成功

sudo usermod -aG docker $USER
newgrp docker    # 或重新登录使其生效

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io"
  ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
 
# 验证是否生效
docker info | grep -A 5 "Registry Mirrors"

sudo mkdir -p /etc/systemd/system/docker.service.d
sudo tee /etc/systemd/system/docker.service.d/http-proxy.conf <<-'EOF'
[Service]
Environment="HTTP_PROXY=http://127.0.0.1:7890"
Environment="HTTPS_PROXY=http://127.0.0.1:7890"
Environment="NO_PROXY=localhost,127.0.0.1,.internal"
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

[仓库地址[:端口]/]用户名或命名空间/镜像名[:标签]

docker search nginx              # 在 Docker Hub 搜索镜像
docker pull nginx                # 拉取 latest 标签
docker pull nginx:1.25           # 拉取指定标签
docker pull nginx:1.25 --platform linux/amd64   # 指定架构(多架构镜像场景)

docker images                    # 等价于 docker image ls
docker images -a                 # 包含中间层镜像
docker image inspect nginx       # 查看镜像详细元数据(JSON)
docker history nginx             # 查看镜像的分层构建历史

docker rmi nginx:1.25                  # 删除指定镜像
docker rmi -f nginx:1.25               # 强制删除(即使有容器引用,谨慎使用)
docker rmi $(docker images -q)         # 删除本机全部镜像
docker image prune                     # 清理"悬空镜像"(<none>标签,通常是构建产生的中间产物)
docker image prune -a                  # 清理所有未被任何容器使用的镜像(释放空间效果更明显)

docker tag nginx:latest myrepo/nginx:v1

# 导出镜像为 tar 包(保留镜像分层、历史、元数据)
docker save -o nginx.tar nginx:latest
docker save nginx:latest | gzip > nginx.tar.gz
 
# 导入镜像
docker load -i nginx.tar
docker load < nginx.tar.gz

# 导出容器文件系统快照为 tar(不含镜像历史/分层信息,体积通常更小)
docker export -o container.tar 容器ID或容器名
 
# 将容器快照导入为新镜像
docker import container.tar 新镜像名:标签

docker login                                          # 登录 Docker Hub
docker login registry.cn-hangzhou.aliyuncs.com        # 登录私有/云厂商仓库
 
docker tag myapp:latest registry.cn-hangzhou.aliyuncs.com/myspace/myapp:latest
docker push registry.cn-hangzhou.aliyuncs.com/myspace/myapp:latest

FROM python:3.11-slim
 
WORKDIR /app
 
# 先只拷贝依赖清单,充分利用构建缓存:
# 只要 requirements.txt 不变,下面这层就不会重新执行 pip install
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
# 再拷贝其余代码(改动频率更高,放在后面)
COPY . .
 
EXPOSE 8000
 
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# ---- 构建阶段 ----
FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp
 
# ---- 运行阶段 ----
FROM alpine:latest
COPY --from=builder /app/myapp /usr/local/bin/myapp
CMD ["myapp"]

__pycache__/
*.pyc
.git
.venv
.env
node_modules
*.log

docker build -t myapp:v1 .                          # 使用当前目录下的 Dockerfile 构建
docker build -t myapp:v1 -f Dockerfile.prod .        # 指定其他文件名的 Dockerfile
docker build --no-cache -t myapp:v1 .                # 不使用缓存,完全重新构建
docker build --build-arg VERSION=1.0 -t myapp:v1 .   # 传入 ARG 变量

docker run [选项] 镜像名[:标签] [启动命令]

# 后台启动一个 nginx,映射端口
docker run -d --name my_nginx -p 8080:80 nginx:1.25
 
# 启动 MySQL,挂载数据卷,设置开机自启
docker run -d \
  --name mysql8 \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -p 3306:3306 \
  -v mysql_data:/var/lib/mysql \
  --restart always \
  mysql:8.0
 
# 临时启动一个交互式容器,退出后自动清理
docker run -it --rm ubuntu:22.04 /bin/bash

docker ps                    # 查看运行中的容器
docker ps -a                 # 查看所有容器(含已停止)
docker ps -q                 # 只输出容器 ID,常配合 xargs/$() 批量操作
docker inspect 容器名或ID     # 查看完整元数据(网络、挂载、环境变量等,JSON格式)
docker stats                 # 实时查看各容器 CPU/内存/网络占用
docker top 容器名             # 查看容器内正在运行的进程
docker port 容器名            # 查看该容器的端口映射情况

docker start 容器名
docker stop 容器名                 # 优雅停止(先发SIGTERM,超时后SIGKILL)
docker restart 容器名
docker pause 容器名                # 暂停容器内所有进程
docker unpause 容器名
docker kill 容器名                 # 立即强制终止(SIGKILL)
 
docker rm 容器名                   # 删除已停止的容器
docker rm -f 容器名                # 强制删除(含运行中的容器)
docker rm $(docker ps -aq)         # 删除所有容器(⚠️慎用)

docker exec -it 容器名 /bin/bash    # 进入容器交互式 shell(容器需自带bash)
docker exec -it 容器名 sh           # 精简镜像(如alpine)通常没有bash,用sh
docker exec 容器名 ls /app          # 在容器内执行单条命令并返回结果
docker attach 容器名                # 直接连接到容器主进程的输入输出

docker logs 容器名
docker logs -f 容器名           # 实时滚动跟踪(follow)
docker logs --tail 100 容器名   # 只看最后100行
docker logs -t 容器名           # 附带时间戳
docker logs --since 30m 容器名  # 只看最近30分钟的日志

docker cp 容器名:/app/config.yml ./config.yml     # 从容器复制到本机
docker cp ./config.yml 容器名:/app/config.yml      # 从本机复制到容器

docker run -d --memory=512m --cpus=1.5 nginx     # 启动时限制
docker update --memory=1g 容器名                   # 对已运行容器动态调整
docker update --restart=always 容器名              # 动态修改重启策略

docker inspect 容器名
docker inspect -f '{{.State.Status}}' 容器名        # 用 Go 模板只提取某个字段
docker inspect -f '{{.NetworkSettings.IPAddress}}' 容器名
docker diff 容器名                                  # 查看容器相对镜像新增/修改/删除了哪些文件

docker volume create my_volume
docker volume ls
docker volume inspect my_volume
docker volume rm my_volume
docker volume prune          # 清理所有未被任何容器使用的卷(⚠️会真正删除数据,谨慎执行)

# 具名卷(named volume)——推荐方式
docker run -d -v my_volume:/var/lib/mysql mysql:8.0
 
# 绑定挂载(bind mount)——指定宿主机绝对路径
docker run -d -v /home/user/mysql_data:/var/lib/mysql mysql:8.0
 
# 匿名卷(只写容器内路径,Docker自动生成一个随机名字的卷)
docker run -d -v /var/lib/mysql mysql:8.0
 
# --mount 语法:更明确、可读性更好,生产环境推荐
docker run -d --mount type=volume,source=my_volume,target=/var/lib/mysql mysql:8.0
docker run -d --mount type=bind,source=/home/user/mysql_data,target=/var/lib/mysql mysql:8.0
 
# 只读挂载(容器内无法修改该目录内容)
docker run -d -v my_volume:/var/lib/mysql:ro mysql:8.0

# 借助一个临时容器,把数据卷打包备份到当前目录
docker run --rm -v my_volume:/data -v $(pwd):/backup alpine \
  tar czf /backup/backup.tar.gz -C /data .
 
# 恢复:反向解包回数据卷
docker run --rm -v my_volume:/data -v $(pwd):/backup alpine \
  tar xzf /backup/backup.tar.gz -C /data

# 导出
docker exec mysql8 mysqldump -u root -p密码 数据库名 > backup.sql
 
# 导入(注意用 -i 而非 -it,因为这里是标准输入重定向,不需要分配伪终端)
docker exec -i mysql8 mysql -u root -p密码 数据库名 < backup.sql

docker network ls
docker network create my_network
docker network create --driver bridge --subnet 172.20.0.0/16 my_network
docker network inspect my_network
docker network rm my_network
docker network connect my_network 容器名        # 让已运行的容器加入某网络
docker network disconnect my_network 容器名
docker network prune                            # 清理未使用的网络

docker network create app_net
 
docker run -d --name db --network app_net mysql:8.0
docker run -d --name web --network app_net -p 8000:8000 myapp

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DEBUG=1
    volumes:
      - ./app:/app
    depends_on:
      - db
    networks:
      - app_net
 
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_DATABASE: mydb
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app_net
    restart: always
 
volumes:
  mysql_data:
 
networks:
  app_net:

DB_PASSWORD=your_secure_password
APP_PORT=8000

services:
  web:
    env_file:
      - .env

flowchart TD
    USER(("用户 / 浏览器")) -->|"8000端口"| APP
    subgraph net["Docker 网络: app_net"]
        APP["app 容器<br/>FastAPI :8000"]
        DB["db 容器<br/>MySQL :3306"]
        REDIS["redis 容器<br/>Redis :6379"]
        APP --> DB
        APP --> REDIS
    end
    DB -.-> VOL[("mysql_data 数据卷")]

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: app
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      db:
        condition: service_healthy
    volumes:
      - ./app:/app
    networks:
      - app_net
    restart: unless-stopped
 
  db:
    image: mysql:8.0
    container_name: mysql_db
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app_net
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
 
  redis:
    image: redis:7-alpine
    container_name: redis_cache
    networks:
      - app_net
    restart: unless-stopped
 
volumes:
  mysql_data:
 
networks:
  app_net:
    driver: bridge

#!/bin/bash
set -e
alembic upgrade head
exec uvicorn main:app --host 0.0.0.0 --port 8000

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

# 叠加多个 compose 文件(常用于区分开发/生产环境配置)
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
 
# 水平扩容某个服务(需注意端口冲突,通常要配合负载均衡使用)
docker compose up -d --scale web=3

docker system df                       # 查看 Docker 各类资源占用的磁盘空间
docker system prune                    # 清理:已停止的容器 + 未使用的网络 + 悬空镜像 + 构建缓存
docker system prune -a                 # 连同"未被任何容器使用的镜像"一起清理(会更彻底)
docker system prune -a --volumes       # ⚠️连同未使用的数据卷一起清理,会真正丢失数据,极其谨慎使用
 
docker container prune                 # 只清理已停止的容器
docker image prune -a                  # 只清理无用镜像
docker volume prune                    # 只清理无用数据卷
docker network prune                   # 只清理无用网络
docker builder prune                   # 清理构建缓存