Docker & Docker Compose 完全指南：从入门到精通

┌─────────────────────────────────────────────────────────────────┐
│                     虚拟机 vs 容器 对比图                         │
├─────────────────────────────────┬───────────────────────────────┤
│         虚拟机架构               │          容器架构              │
├─────────────────────────────────┼───────────────────────────────┤
│  ┌─────┐ ┌─────┐ ┌─────┐       │  ┌─────┐ ┌─────┐ ┌─────┐     │
│  │App A│ │App B│ │App C│       │  │App A│ │App B│ │App C│     │
│  ├─────┤ ├─────┤ ├─────┤       │  ├─────┤ ├─────┤ ├─────┤     │
│  │Bins │ │Bins │ │Bins │       │  │Bins │ │Bins │ │Bins │     │
│  │Libs │ │Libs │ │Libs │       │  │Libs │ │Libs │ │Libs │     │
│  ├─────┤ ├─────┤ ├─────┤       │  └──┬──┘ └──┬──┘ └──┬──┘     │
│  │Guest│ │Guest│ │Guest│       │     └───────┼───────┘         │
│  │ OS  │ │ OS  │ │ OS  │       │      ┌──────┴──────┐          │
│  └──┬──┘ └──┬──┘ └──┬──┘       │      │   Docker    │          │
│     └───────┼───────┘          │      │   Engine    │          │
│      ┌──────┴──────┐           │      └──────┬──────┘          │
│      │ Hypervisor  │           │             │                  │
│      └──────┬──────┘           │      ┌──────┴──────┐          │
│      ┌──────┴──────┐           │      │   Host OS   │          │
│      │   Host OS   │           │      └──────┬──────┘          │
│      └──────┬──────┘           │      ┌──────┴──────┐          │
│      ┌──────┴──────┐           │      │  Hardware   │          │
│      │  Hardware   │           │      └─────────────┘          │
│      └─────────────┘           │                                │
├─────────────────────────────────┼───────────────────────────────┤
│  特点：                         │  特点：                        │
│  • 每个 VM 有完整 OS            │  • 共享宿主机内核               │
│  • 启动时间：分钟级             │  • 启动时间：秒级               │
│  • 内存占用：GB 级              │  • 内存占用：MB 级              │
│  • 隔离性：强                   │  • 隔离性：较强                 │
└─────────────────────────────────┴───────────────────────────────┘

┌──────────────────────────────────────────────────────────────┐
│                   Docker 三大核心概念                         │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   镜像 (Image)          容器 (Container)        仓库 (Registry)│
│   ┌─────────┐           ┌─────────┐            ┌─────────┐  │
│   │ 📦      │           │ 🚚      │            │ 🏭      │  │
│   │ 货物的   │  ──────>  │ 运输中的 │  <──────   │ 物流    │  │
│   │ 标准包装 │  实例化    │ 集装箱   │   存储     │ 仓库    │  │
│   └─────────┘           └─────────┘            └─────────┘  │
│                                                              │
│   • 只读模板             • 镜像的运行实例        • 存储和分发镜像│
│   • 包含运行环境          • 可以启动/停止        • 公有/私有    │
│   • 分层存储             • 有自己的文件系统       • Docker Hub  │
│                                                              │
└──────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────┐
│                        Docker 架构图                               │
├───────────────────────────────────────────────────────────────────┤
│                                                                   │
│  Client (客户端)                      Docker Host (Docker 主机)    │
│  ┌─────────────────┐                 ┌───────────────────────────┐│
│  │ docker build    │                 │     Docker Daemon         ││
│  │ docker pull     │  ──REST API──>  │     (dockerd)             ││
│  │ docker run      │                 │  ┌─────────────────────┐  ││
│  └─────────────────┘                 │  │    Containers       │  ││
│                                      │  │ ┌───┐ ┌───┐ ┌───┐   │  ││
│                                      │  │ │ C │ │ C │ │ C │   │  ││
│                                      │  │ └───┘ └───┘ └───┘   │  ││
│                                      │  └─────────────────────┘  ││
│                                      │  ┌─────────────────────┐  ││
│                                      │  │      Images         │  ││
│                                      │  │ ┌───┐ ┌───┐ ┌───┐   │  ││
│                                      │  │ │ I │ │ I │ │ I │   │  ││
│                                      │  │ └───┘ └───┘ └───┘   │  ││
│                                      │  └─────────────────────┘  ││
│                                      └───────────────────────────┘│
│                                                    ▲               │
│                                                    │               │
│                                               pull/push            │
│                                                    │               │
│                                                    ▼               │
│                                      ┌───────────────────────────┐│
│                                      │       Registry            ││
│                                      │     (Docker Hub)          ││
│                                      │  ┌─────────────────────┐  ││
│                                      │  │ nginx, mysql, redis │  ││
│                                      │  │ node, python, ...   │  ││
│                                      │  └─────────────────────┘  ││
│                                      └───────────────────────────┘│
└───────────────────────────────────────────────────────────────────┘

brew install --cask docker

# 更新包索引
sudo apt-get update

# 安装依赖
sudo apt-get install ca-certificates curl gnupg

# 添加 Docker 官方 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
sudo chmod a+r /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

# 安装 Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 将当前用户加入 docker 组（避免每次 sudo）
sudo usermod -aG docker $USER

# 安装依赖
sudo yum install -y yum-utils

# 添加仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装 Docker Engine
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 启动 Docker
sudo systemctl start docker
sudo systemctl enable docker

# 将当前用户加入 docker 组
sudo usermod -aG docker $USER

# 查看版本
docker --version
# Docker version 24.0.7, build afdd53b

# 查看详细信息
docker info

# 运行测试容器
docker run hello-world

docker run hello-world

┌─────────────────────────────────────────────────────────────┐
│                docker run hello-world 执行流程               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Docker 客户端发送命令给 Docker Daemon                    │
│                    │                                        │
│                    ▼                                        │
│  2. Docker Daemon 检查本地是否有 hello-world 镜像            │
│                    │                                        │
│           ┌───────┴───────┐                                 │
│           │  本地有镜像？  │                                 │
│           └───────┬───────┘                                 │
│           No      │       Yes                               │
│           │       └────────────────┐                        │
│           ▼                        │                        │
│  3. 从 Docker Hub 拉取镜像          │                        │
│           │                        │                        │
│           └────────────────────────┤                        │
│                                    ▼                        │
│  4. 基于镜像创建容器                                         │
│                    │                                        │
│                    ▼                                        │
│  5. 运行容器，输出 Hello from Docker!                        │
│                    │                                        │
│                    ▼                                        │
│  6. 容器执行完毕，自动停止                                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# 搜索 nginx 镜像
docker search nginx

# 拉取官方 nginx 镜像
docker pull nginx:latest

# 查看本地镜像
docker images

# 查看镜像详情
docker inspect nginx:latest

# 查看镜像历史（各层信息）
docker history nginx:latest

# 删除镜像
docker rmi nginx:latest

# 运行一个 nginx 容器
# -d: 后台运行
# -p: 端口映射 (宿主机端口:容器端口)
# --name: 容器名称
docker run -d -p 8080:80 --name my-nginx nginx

# 查看运行中的容器
docker ps

# 查看容器日志
docker logs my-nginx

# 实时查看日志
docker logs -f my-nginx

# 进入容器内部
docker exec -it my-nginx bash

# 在容器中执行命令
docker exec my-nginx cat /etc/nginx/nginx.conf

# 停止容器
docker stop my-nginx

# 启动容器
docker start my-nginx

# 删除容器（需要先停止）
docker stop my-nginx && docker rm my-nginx

# 强制删除运行中的容器
docker rm -f my-nginx

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

# 常用 OPTIONS
-d, --detach          # 后台运行
-p, --publish         # 端口映射，格式：宿主机端口:容器端口
-v, --volume          # 挂载数据卷，格式：宿主机路径:容器路径
-e, --env             # 设置环境变量
--name                # 容器名称
--restart             # 重启策略：no, on-failure, always, unless-stopped
--network             # 指定网络
-it                   # 交互式终端（-i 保持 STDIN 打开，-t 分配伪终端）
--rm                  # 容器停止后自动删除

# 创建数据卷
docker volume create my-data

# 查看数据卷
docker volume ls

# 使用数据卷
docker run -d \
  --name mysql-db \
  -v my-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# 查看数据卷详情
docker volume inspect my-data

# 删除数据卷
docker volume rm my-data

# 删除未使用的数据卷
docker volume prune

# 挂载当前目录到容器
docker run -d \
  --name nginx-web \
  -p 8080:80 \
  -v $(pwd)/html:/usr/share/nginx/html \
  nginx

# 只读挂载（容器无法修改）
docker run -d \
  --name nginx-web \
  -p 8080:80 \
  -v $(pwd)/html:/usr/share/nginx/html:ro \
  nginx

# 查看网络列表
docker network ls

# 创建自定义网络
docker network create my-network

# 运行容器时指定网络
docker run -d --name app --network my-network nginx

# 将容器连接到网络
docker network connect my-network container_name

# 查看网络详情
docker network inspect my-network

# 删除网络
docker network rm my-network

# 创建网络
docker network create app-network

# 启动 MySQL
docker run -d \
  --name mysql \
  --network app-network \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# 启动应用，可以通过 "mysql" 这个名字访问数据库
docker run -d \
  --name app \
  --network app-network \
  -e DATABASE_HOST=mysql \
  my-app

# 这是一个简单的 Dockerfile 示例
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

# 使用官方 Node.js 镜像
FROM node:18-alpine

# 使用官方 Python 镜像
FROM python:3.11-slim

# 使用最小化镜像
FROM alpine:3.18

# 从零开始构建
FROM scratch

# Shell 格式
RUN apt-get update && apt-get install -y curl

# Exec 格式
RUN ["apt-get", "install", "-y", "curl"]

# 多行命令（推荐，减少层数）
RUN apt-get update && \
    apt-get install -y \
    curl \
    vim \
    git && \
    rm -rf /var/lib/apt/lists/*

# COPY - 简单复制文件
COPY package.json /app/
COPY . /app/

# ADD - 额外支持解压和远程 URL（不推荐，建议用 COPY）
ADD archive.tar.gz /app/
ADD https://example.com/file.txt /app/

WORKDIR /app
# 后续命令都在 /app 目录下执行

ENV NODE_ENV=production
ENV APP_PORT=3000

# 多个环境变量
ENV NODE_ENV=production \
    APP_PORT=3000

# 声明容器监听的端口（仅作文档用途）
EXPOSE 3000
EXPOSE 80 443

# CMD - 容器启动时执行的默认命令（可被覆盖）
CMD ["node", "app.js"]
CMD ["npm", "start"]

# ENTRYPOINT - 容器启动时执行的固定命令（不易被覆盖）
ENTRYPOINT ["python", "app.py"]

ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]

# docker run myapp                  -> python app.py --port 8080
# docker run myapp --port 3000      -> python app.py --port 3000

# 第一阶段：构建
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 第二阶段：运行
FROM node:18-alpine
WORKDIR /app
# 只复制构建产物
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package*.json ./
RUN npm install --production
EXPOSE 3000
CMD ["node", "dist/index.js"]

# 1. 使用 alpine 基础镜像
FROM node:18-alpine  # 而不是 node:18

# 2. 多阶段构建（见上文）

# 3. 合并 RUN 命令，清理缓存
RUN apt-get update && \
    apt-get install -y curl && \
    rm -rf /var/lib/apt/lists/*

# 4. 使用 .dockerignore 排除不需要的文件

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
*.md

FROM node:18-alpine
WORKDIR /app

# 先复制 package.json（不常变化）
COPY package*.json ./
RUN npm install

# 再复制源代码（经常变化）
COPY . .

RUN npm run build

# 1. 不使用 root 用户运行
FROM node:18-alpine
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# 2. 不在镜像中存储敏感信息
# 使用环境变量或密钥管理工具

# 3. 使用特定版本标签，而不是 latest
FROM node:18.19.0-alpine  # 而不是 node:latest

# 手动管理多个容器的噩梦
docker network create myapp
docker run -d --name mysql --network myapp -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0
docker run -d --name redis --network myapp redis:alpine
docker run -d --name app --network myapp -p 3000:3000 -e DB_HOST=mysql -e REDIS_HOST=redis myapp

docker compose version

# 版本声明（可选，新版本可省略）
version: "3.8"

# 服务定义
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: 123456

# 网络定义（可选）
networks:
  default:
    driver: bridge

# 数据卷定义（可选）
volumes:
  db-data:

services:
  # 服务名称
  app:
    # 使用镜像
    image: node:18-alpine

    # 或者构建
    build:
      context: .
      dockerfile: Dockerfile

    # 容器名称
    container_name: my-app

    # 端口映射
    ports:
      - "3000:3000"      # 宿主机端口:容器端口
      - "3001:3001"

    # 环境变量
    environment:
      - NODE_ENV=production
      - DB_HOST=mysql
    # 或从文件加载
    env_file:
      - .env

    # 数据卷挂载
    volumes:
      - ./src:/app/src        # 挂载目录
      - node_modules:/app/node_modules  # 命名卷

    # 依赖关系
    depends_on:
      - mysql
      - redis

    # 重启策略
    restart: unless-stopped

    # 网络
    networks:
      - app-network

    # 资源限制
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M

services:
  app:
    networks:
      - frontend
      - backend

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # 内部网络，无法访问外部

services:
  mysql:
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:
    driver: local

version: "3.8"

services:
  app:
    build: .
    container_name: my-app
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: production
      DB_HOST: mysql
      DB_PORT: 3306
      DB_NAME: myapp
      REDIS_HOST: redis
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./logs:/app/logs
    networks:
      - app-network
    restart: unless-stopped

  mysql:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-123456}
      MYSQL_DATABASE: myapp
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - app-network
    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
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

project/
├── docker-compose.yml
└── html/
    └── index.html

version: "3.8"

services:
  nginx:
    image: nginx:alpine
    container_name: nginx-web
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    restart: unless-stopped

<!DOCTYPE html>
<html>
<head>
    <title>Hello Docker</title>
</head>
<body>
    <h1>Hello from Docker!</h1>
</body>
</html>

docker compose up -d
# 访问 http://localhost

version: "3.8"

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress_password
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress-data:/var/www/html
    depends_on:
      mysql:
        condition: service_healthy
    networks:
      - wp-network
    restart: unless-stopped

  mysql:
    image: mysql:8.0
    container_name: wordpress-db
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress_password
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - wp-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

networks:
  wp-network:
    driver: bridge

volumes:
  wordpress-data:
  mysql-data:

docker compose up -d
# 访问 http://localhost:8080 完成 WordPress 安装

project/
├── docker-compose.yml
├── .env
├── Dockerfile
├── package.json
└── src/
    └── index.js

version: "3.8"

services:
  app:
    build: .
    container_name: node-app
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: development
      DB_HOST: mysql
      DB_PORT: 3306
      DB_NAME: ${DB_NAME:-myapp}
      DB_USER: ${DB_USER:-root}
      DB_PASSWORD: ${DB_PASSWORD:-123456}
      REDIS_HOST: redis
      REDIS_PORT: 6379
    volumes:
      - ./src:/app/src          # 热重载：源码挂载
      - /app/node_modules       # 保护 node_modules
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - dev-network
    restart: unless-stopped

  mysql:
    image: mysql:8.0
    container_name: mysql-db
    ports:
      - "3306:3306"  # 开发时方便本地连接
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD:-123456}
      MYSQL_DATABASE: ${DB_NAME:-myapp}
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - dev-network
    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
    ports:
      - "6379:6379"  # 开发时方便本地连接
    volumes:
      - redis-data:/data
    networks:
      - dev-network
    restart: unless-stopped

networks:
  dev-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

FROM node:18-alpine

WORKDIR /app

# 安装依赖
COPY package*.json ./
RUN npm install

# 复制源码
COPY . .

EXPOSE 3000

# 开发模式使用 nodemon 热重载
CMD ["npm", "run", "dev"]

DB_NAME=myapp
DB_USER=root
DB_PASSWORD=123456

version: "3.8"

services:
  # 日志聚合
  loki:
    image: grafana/loki:2.9.0
    container_name: loki
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yml:/etc/loki/local-config.yaml
      - loki-data:/loki
    command: -config.file=/etc/loki/local-config.yaml
    networks:
      - monitoring
    restart: unless-stopped

  # 日志收集代理
  promtail:
    image: grafana/promtail:2.9.0
    container_name: promtail
    volumes:
      - ./promtail-config.yml:/etc/promtail/config.yml
      - /var/log:/var/log:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
    command: -config.file=/etc/promtail/config.yml
    networks:
      - monitoring
    restart: unless-stopped

  # 可视化面板
  grafana:
    image: grafana/grafana:10.0.0
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin123
    volumes:
      - grafana-data:/var/lib/grafana
    depends_on:
      - loki
    networks:
      - monitoring
    restart: unless-stopped

  # 示例应用（产生日志）
  app:
    image: nginx:alpine
    container_name: demo-app
    ports:
      - "80:80"
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
    networks:
      - monitoring
    restart: unless-stopped

networks:
  monitoring:
    driver: bridge

volumes:
  loki-data:
  grafana-data:

auth_enabled: false

server:
  http_listen_port: 3100

ingester:
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
  chunk_idle_period: 5m
  chunk_retain_period: 30s

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /loki/index
    cache_location: /loki/cache
    shared_store: filesystem
  filesystem:
    directory: /loki/chunks

limits_config:
  enforce_metric_name: false
  reject_old_samples: true
  reject_old_samples_max_age: 168h

chunk_store_config:
  max_look_back_period: 0s

table_manager:
  retention_deletes_enabled: false
  retention_period: 0s

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: containers
    static_configs:
      - targets:
          - localhost
        labels:
          job: containerlogs
          __path__: /var/lib/docker/containers/*/*log
    pipeline_stages:
      - json:
          expressions:
            output: log
            stream: stream
            time: time
      - output:
          source: output

services:
  app:
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 1G
        reservations:
          cpus: '0.5'
          memory: 512M

services:
  app:
    logging:
      driver: json-file
      options:
        max-size: "100m"   # 单个日志文件最大
        max-file: "5"      # 保留文件数量

services:
  app:
    # 以非 root 用户运行
    user: "1000:1000"

    # 只读文件系统
    read_only: true

    # 临时文件目录
    tmpfs:
      - /tmp

    # 安全选项
    security_opt:
      - no-new-privileges:true

# 查看容器日志
docker logs container_name

# 查看详细信息
docker inspect container_name

# 常见原因：
# 1. 端口冲突
# 2. 数据卷权限问题
# 3. 依赖服务未就绪

# 检查网络
docker network ls
docker network inspect network_name

# 测试容器间连通性
docker exec container1 ping container2

# 常见原因：
# 1. 容器不在同一网络
# 2. 服务名拼写错误
# 3. 端口未暴露

# 查看磁盘使用
docker system df

# 清理未使用资源
docker system prune

# 清理所有（包括未使用的镜像）
docker system prune -a

# 清理数据卷
docker volume prune

# 初始化 Swarm
docker swarm init

# 部署服务
docker stack deploy -c docker-compose.yml myapp