好的，我们继续第十三课。今天学习Docker容器技术，这是现代应用部署的重要技术。

第一部分：Docker基础概念

1.1 什么是Docker？

Docker是一个开源的容器化平台，可以将应用程序及其依赖项打包到一个标准化的单元中，这个单元叫做容器。

与传统虚拟机的区别：

text

虚拟机：硬件 -> 主机操作系统 -> 虚拟机管理程序 -> 每个虚拟机有自己的操作系统 -> 应用

Docker：硬件 -> 主机操作系统 -> Docker引擎 -> 容器（共享主机操作系统内核）-> 应用

优势：

轻量级（容器共享主机内核）

快速启动（秒级）

一致性（开发、测试、生产环境一致）

资源利用率高

易于扩展

1.2 Docker核心概念

镜像（Image）：只读模板，包含运行应用所需的所有内容

容器（Container）：镜像的运行实例

仓库（Registry）：存储镜像的地方（Docker Hub是官方仓库）

Dockerfile：构建镜像的脚本文件

第二部分：Docker安装和配置

2.1 在Ubuntu上安装Docker

bash

# 1. 卸载旧版本

sudo apt remove docker docker-engine docker.io containerd runc

# 2. 更新软件包索引

sudo apt update

# 3. 安装依赖包

sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release

# 4. 添加Docker官方GPG密钥

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 5. 添加Docker仓库

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 6. 安装Docker引擎

sudo apt update

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 7. 验证安装

sudo docker --version

sudo docker run hello-world

2.2 配置Docker

bash

# 1. 启动Docker服务

sudo systemctl start docker

sudo systemctl enable docker

# 2. 查看Docker状态

sudo systemctl status docker

# 3. 将当前用户加入docker组（避免每次都使用sudo）

sudo usermod -aG docker $USER

# 需要重新登录或执行以下命令使组更改生效

newgrp docker

# 4. 验证非sudo权限

docker run hello-world

# 5. 配置Docker守护进程

sudo vim /etc/docker/daemon.json

daemon.json示例配置：

json

{

 "registry-mirrors": ["https://registry.docker-cn.com"],

 "log-driver": "json-file",

 "log-opts": {

   "max-size": "10m",

   "max-file": "3"

 },

 "storage-driver": "overlay2",

 "live-restore": true

}

bash

# 6. 重启Docker使配置生效

sudo systemctl restart docker

# 7. 查看Docker信息

docker info

第三部分：Docker镜像管理

3.1 镜像基本操作

bash

# 搜索镜像

docker search ubuntu

docker search nginx --filter "is-official=true"

# 拉取镜像

docker pull ubuntu:20.04

docker pull nginx:latest

docker pull mysql:8.0

# 查看本地镜像

docker images

docker image ls

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

# 查看镜像详细信息

docker image inspect ubuntu:20.04

# 删除镜像

docker rmi ubuntu:20.04

docker image rm nginx:latest

docker rmi $(docker images -q)  # 删除所有镜像（危险！）

# 清理未使用的镜像

docker image prune

docker image prune -a  # 删除所有未使用的镜像

# 给镜像打标签

docker tag ubuntu:20.04 myubuntu:v1

3.2 构建镜像（Dockerfile）

创建第一个Dockerfile：

bash

# 创建项目目录

mkdir myapp && cd myapp

# 创建应用文件

cat > app.py << 'EOF'

from flask import Flask

import os

app = Flask(__name__)

@app.route('/')

def hello():

   return f"Hello from Docker! Hostname: {os.uname().nodename}"

@app.route('/health')

def health():

   return 'OK'

if __name__ == '__main__':

   app.run(host='0.0.0.0', port=5000)

EOF

# 创建requirements.txt

cat > requirements.txt << 'EOF'

Flask==2.3.0

EOF

# 创建Dockerfile

cat > Dockerfile << 'EOF'

# 使用官方Python基础镜像

FROM python:3.9-slim

# 设置工作目录

WORKDIR /app

# 设置环境变量

ENV PYTHONDONTWRITEBYTECODE=1

ENV PYTHONUNBUFFERED=1

ENV FLASK_APP=app.py

ENV FLASK_RUN_HOST=0.0.0.0

# 安装系统依赖

RUN apt-get update && apt-get install -y \

   gcc \

   && rm -rf /var/lib/apt/lists/*

# 复制依赖文件

COPY requirements.txt .

# 安装Python依赖

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

# 复制应用代码

COPY . .

# 创建非root用户

RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app

USER appuser

# 暴露端口

EXPOSE 5000

# 健康检查

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \

   CMD curl -f http://localhost:5000/health || exit 1

# 启动命令

CMD ["flask", "run"]

EOF

构建镜像：

bash

# 构建镜像

docker build -t myapp:v1 .

# 查看构建历史

docker history myapp:v1

# 使用多阶段构建优化镜像大小

cat > Dockerfile.multistage << 'EOF'

# 构建阶段

FROM python:3.9 AS builder

WORKDIR /app

COPY requirements.txt .

RUN pip install --user -r requirements.txt

# 运行阶段

FROM python:3.9-slim

WORKDIR /app

COPY --from=builder /root/.local /root/.local

COPY . .

ENV PATH=/root/.local/bin:$PATH

EXPOSE 5000

CMD ["flask", "run"]

EOF

第四部分：Docker容器管理

4.1 容器生命周期

bash

# 运行容器（前台）

docker run ubuntu:20.04 echo "Hello Docker"

docker run -it ubuntu:20.04 /bin/bash  # 交互式运行

# 运行容器（后台）

docker run -d --name mynginx nginx:latest

# 运行容器并暴露端口

docker run -d -p 8080:80 --name webserver nginx

# 运行容器并挂载数据卷

docker run -d -p 5000:5000 -v $(pwd):/app --name flaskapp myapp:v1

# 查看运行中的容器

docker ps

docker ps -a  # 查看所有容器（包括停止的）

# 查看容器详细信息

docker inspect webserver

# 查看容器日志

docker logs webserver

docker logs -f webserver  # 实时查看

docker logs --tail 10 webserver  # 查看最后10行

docker logs --since 10m webserver  # 查看10分钟内的日志

# 查看容器资源使用

docker stats

docker stats --no-stream  # 单次查看

docker stats webserver mysql  # 查看特定容器

# 进入运行中的容器

docker exec -it webserver /bin/bash

docker exec -it webserver sh  # 如果bash不可用

# 执行命令（不进入交互模式）

docker exec webserver nginx -t

# 停止容器

docker stop webserver

docker stop $(docker ps -q)  # 停止所有容器

# 启动已停止的容器

docker start webserver

# 重启容器

docker restart webserver

# 暂停容器

docker pause webserver

docker unpause webserver

# 删除容器

docker rm webserver

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

docker container prune  # 删除所有停止的容器

4.2 容器资源限制

bash

# 限制CPU使用

docker run -d --name limited-cpu --cpus="0.5" nginx  # 最多使用0.5个CPU核心

docker run -d --name cpu-shares --cpu-shares=512 nginx  # 相对权重（默认1024）

# 限制内存使用

docker run -d --name limited-mem --memory="512m" nginx  # 限制512MB内存

docker run -d --name mem-swap --memory="512m" --memory-swap="1g" nginx  # 包括交换空间

# 限制磁盘I/O

docker run -d --name limited-io \

   --device-write-bps /dev/sda:10mb \

   --device-read-bps /dev/sda:10mb \

   nginx

# 限制进程数

docker run -d --name limited-pid --pids-limit=100 nginx

第五部分：Docker网络

5.1 Docker网络基础

bash

# 查看Docker网络

docker network ls

docker network inspect bridge

# 创建自定义网络

docker network create mynetwork

docker network create --driver bridge --subnet 172.20.0.0/16 --gateway 172.20.0.1 mynet

# 运行容器时指定网络

docker run -d --name web1 --network mynetwork nginx

docker run -d --name web2 --network mynetwork nginx

# 在容器中测试网络连通性

docker exec web1 ping web2  # 可以使用容器名直接访问

# 将现有容器连接到网络

docker network connect mynetwork existing_container

# 断开网络连接

docker network disconnect bridge container_name

# 删除网络

docker network rm mynetwork

5.2 网络模式

bash

# 桥接模式（默认）

docker run -d --name bridge-container --network bridge nginx

# 主机模式（共享主机网络命名空间）

docker run -d --name host-container --network host nginx

# 无网络模式

docker run -d --name none-container --network none alpine sleep 3600

# 容器模式（共享另一个容器的网络）

docker run -d --name parent-container nginx

docker run -d --name child-container --network container:parent-container alpine sleep 3600

# 自定义网络

docker run -d --name custom-net --network mynetwork --ip 172.20.0.100 nginx

第六部分：数据持久化

6.1 Docker卷（Volumes）

bash

# 创建数据卷

docker volume create mydata

# 查看数据卷

docker volume ls

docker volume inspect mydata

# 使用数据卷

docker run -d --name db \

   -v mydata:/var/lib/mysql \

   -e MYSQL_ROOT_PASSWORD=123456 \

   mysql:8.0

# 挂载主机目录作为数据卷

docker run -d --name app \

   -v /host/path:/container/path \

   -v $(pwd)/app:/app \

   nginx

# 只读挂载

docker run -d --name ro-app \

   -v /host/path:/container/path:ro \

   nginx

# 清理未使用的数据卷

docker volume prune

6.2 数据卷容器

bash

# 创建数据卷容器

docker create --name data-container \

   -v /data \

   -v /config \

   ubuntu:20.04

# 从数据卷容器挂载数据

docker run -d --name app1 \

   --volumes-from data-container \

   nginx

docker run -d --name app2 \

   --volumes-from data-container \

   nginx

# 备份数据卷

docker run --rm \

   --volumes-from data-container \

   -v $(pwd):/backup \

   ubuntu:20.04 \

   tar czf /backup/backup.tar.gz /data

# 恢复数据卷

docker run --rm \

   --volumes-from data-container \

   -v $(pwd):/backup \

   ubuntu:20.04 \

   tar xzf /backup/backup.tar.gz -C /

第七部分：Docker Compose

7.1 Docker Compose安装

bash

# 安装Docker Compose（如果未安装）

sudo apt install docker-compose-plugin

# 验证安装

docker compose version

# 或使用独立版本

sudo curl -L "https://github.com/docker/compose/releases/download/v2.23.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

7.2 编写docker-compose.yml

bash

# 创建项目目录

mkdir myproject && cd myproject

# 创建docker-compose.yml

cat > docker-compose.yml << 'EOF'

version: '3.8'

services:

 # Web应用服务

 web:

   build: .

   container_name: flask_app

   ports:

     - "5000:5000"

   environment:

     - DATABASE_URL=postgresql://user:password@db:5432/mydb

     - REDIS_URL=redis://redis:6379

   volumes:

     - ./app:/app

     - static_data:/app/static

   depends_on:

     - db

     - redis

   networks:

     - backend

   restart: unless-stopped

   healthcheck:

     test: ["CMD", "curl", "-f", "http://localhost:5000/health"]

     interval: 30s

     timeout: 10s

     retries: 3

 # 数据库服务

 db:

   image: postgres:15

   container_name: postgres_db

   environment:

     POSTGRES_USER: user

     POSTGRES_PASSWORD: password

     POSTGRES_DB: mydb

   volumes:

     - postgres_data:/var/lib/postgresql/data

     - ./init.sql:/docker-entrypoint-initdb.d/init.sql

   networks:

     - backend

   restart: unless-stopped

   healthcheck:

     test: ["CMD-SHELL", "pg_isready -U user"]

     interval: 10s

     timeout: 5s

     retries: 5

 # Redis缓存服务

 redis:

   image: redis:7-alpine

   container_name: redis_cache

   command: redis-server --appendonly yes

   volumes:

     - redis_data:/data

   networks:

     - backend

   restart: unless-stopped

 # Nginx反向代理

 nginx:

   image: nginx:alpine

   container_name: nginx_proxy

   ports:

     - "80:80"

     - "443:443"

   volumes:

     - ./nginx.conf:/etc/nginx/nginx.conf

     - static_data:/usr/share/nginx/html/static

     - ./ssl:/etc/nginx/ssl

   depends_on:

     - web

   networks:

     - backend

   restart: unless-stopped

# 网络配置

networks:

 backend:

   driver: bridge

   ipam:

     config:

       - subnet: 172.20.0.0/16

# 数据卷配置

volumes:

 postgres_data:

   driver: local

 redis_data:

   driver: local

 static_data:

   driver: local

EOF

7.3 Docker Compose常用命令

bash

# 启动所有服务

docker-compose up -d

docker compose up -d  # 新版本

# 查看服务状态

docker-compose ps

docker compose ps

# 查看服务日志

docker-compose logs

docker-compose logs -f  # 实时查看

docker-compose logs web  # 查看特定服务

# 停止服务

docker-compose down

docker compose down

# 停止并删除数据卷

docker-compose down -v

# 重新构建服务

docker-compose build

docker compose build

# 重启服务

docker-compose restart

docker compose restart

# 暂停服务

docker-compose pause

docker compose pause

# 恢复服务

docker-compose unpause

docker compose unpause

# 执行命令

docker-compose exec web python manage.py migrate

docker compose exec db psql -U user -d mydb

# 查看服务资源使用

docker-compose top

docker compose top

# 拉取镜像

docker-compose pull

docker compose pull

第八部分：Docker实践案例

8.1 部署WordPress网站

bash

mkdir wordpress && cd wordpress

cat > docker-compose.yml << 'EOF'

version: '3.8'

services:

 db:

   image: mysql:8.0

   container_name: wordpress_db

   environment:

     MYSQL_ROOT_PASSWORD: rootpassword

     MYSQL_DATABASE: wordpress

     MYSQL_USER: wordpress

     MYSQL_PASSWORD: wordpresspassword

   volumes:

     - db_data:/var/lib/mysql

   networks:

     - wp_network

   restart: always

   healthcheck:

     test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]

     timeout: 20s

     retries: 10

 wordpress:

   image: wordpress:php8.2-apache

   container_name: wordpress_app

   depends_on:

     - db

   ports:

     - "8080:80"

   environment:

     WORDPRESS_DB_HOST: db:3306

     WORDPRESS_DB_USER: wordpress

     WORDPRESS_DB_PASSWORD: wordpresspassword

     WORDPRESS_DB_NAME: wordpress

   volumes:

     - wp_data:/var/www/html

     - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini

   networks:

     - wp_network

   restart: always

 phpmyadmin:

   image: phpmyadmin/phpmyadmin

   container_name: phpmyadmin

   depends_on:

     - db

   environment:

     PMA_HOST: db

     PMA_PORT: 3306

     UPLOAD_LIMIT: 300M

   ports:

     - "8081:80"

   networks:

     - wp_network

   restart: always

networks:

 wp_network:

   driver: bridge

volumes:

 db_data:

   driver: local

 wp_data:

   driver: local

EOF

# 启动服务

docker compose up -d

# 访问WordPress

# http://localhost:8080

# http://localhost:8081 (phpMyAdmin)

8.2 部署监控系统

bash

mkdir monitoring && cd monitoring

cat > docker-compose.yml << 'EOF'

version: '3.8'

services:

 # Prometheus监控

 prometheus:

   image: prom/prometheus:latest

   container_name: prometheus

   ports:

     - "9090:9090"

   volumes:

     - ./prometheus.yml:/etc/prometheus/prometheus.yml

     - prometheus_data:/prometheus

   command:

     - '--config.file=/etc/prometheus/prometheus.yml'

     - '--storage.tsdb.path=/prometheus'

     - '--web.console.libraries=/etc/prometheus/console_libraries'

     - '--web.console.templates=/etc/prometheus/consoles'

     - '--storage.tsdb.retention.time=200h'

     - '--web.enable-lifecycle'

   networks:

     - monitoring

   restart: unless-stopped

 # Grafana可视化

 grafana:

   image: grafana/grafana:latest

   container_name: grafana

   ports:

     - "3000:3000"

   volumes:

     - grafana_data:/var/lib/grafana

     - ./grafana/provisioning:/etc/grafana/provisioning

   environment:

     - GF_SECURITY_ADMIN_PASSWORD=admin

     - GF_USERS_ALLOW_SIGN_UP=false

   networks:

     - monitoring

   depends_on:

     - prometheus

   restart: unless-stopped

 # Node Exporter（监控主机）

 node-exporter:

   image: prom/node-exporter:latest

   container_name: node-exporter

   volumes:

     - /proc:/host/proc:ro

     - /sys:/host/sys:ro

     - /:/rootfs:ro

   command:

     - '--path.procfs=/host/proc'

     - '--path.rootfs=/rootfs'

     - '--path.sysfs=/host/sys'

     - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'

   networks:

     - monitoring

   restart: unless-stopped

   ports:

     - "9100:9100"

networks:

 monitoring:

   driver: bridge

volumes:

 prometheus_data:

   driver: local

 grafana_data:

   driver: local

EOF

# 创建Prometheus配置

cat > prometheus.yml << 'EOF'

global:

 scrape_interval: 15s

 evaluation_interval: 15s

scrape_configs:

 - job_name: 'prometheus'

   static_configs:

     - targets: ['localhost:9090']

 - job_name: 'node-exporter'

   static_configs:

     - targets: ['node-exporter:9100']

 - job_name: 'docker'

   static_configs:

     - targets: ['docker.for.mac.host.internal:9323']

EOF

# 启动监控系统

docker compose up -d

# 访问Grafana: http://localhost:3000 (admin/admin)

# 访问Prometheus: http://localhost:9090

第九部分：Docker最佳实践

9.1 安全最佳实践

bash

# 1. 使用非root用户运行容器

# 在Dockerfile中：

# RUN useradd -r -u 1001 -g root appuser

# USER appuser

# 2. 定期更新基础镜像

FROM ubuntu:20.04

RUN apt update && apt upgrade -y

# 3. 扫描镜像安全漏洞

docker scan myapp:v1

# 4. 使用最小化基础镜像

FROM alpine:3.18  # 而不是 ubuntu:20.04

FROM python:3.9-slim  # 而不是 python:3.9

# 5. 限制容器资源

docker run --memory=512m --cpus=1.0

# 6. 设置只读文件系统

docker run --read-only

# 7. 避免在镜像中存储敏感信息

# 使用环境变量或Docker secrets

9.2 性能优化实践

bash

# 1. 使用多阶段构建减小镜像大小

# 2. 合理使用.dockerignore文件

cat > .dockerignore << 'EOF'

.git

__pycache__

*.pyc

*.pyo

*.pyd

.env

.DS_Store

README.md

EOF

# 3. 合并RUN命令减少镜像层数

RUN apt update && apt install -y \

   package1 \

   package2 \

   && rm -rf /var/lib/apt/lists/*

# 4. 使用特定的标签而不是latest

FROM nginx:1.25-alpine  # 而不是 nginx:latest

# 5. 使用数据卷存储变化数据

9.3 Docker生产环境配置

bash

# 1. 配置Docker守护进程

sudo vim /etc/docker/daemon.json

json

{

 "log-driver": "json-file",

 "log-opts": {

   "max-size": "10m",

   "max-file": "3"

 },

 "storage-driver": "overlay2",

 "live-restore": true,

 "userland-proxy": false,

 "iptables": true,

 "ip-forward": true,

 "ip-masq": true,

 "exec-opts": ["native.cgroupdriver=systemd"],

 "registry-mirrors": [

   "https://docker.mirrors.ustc.edu.cn",

   "https://hub-mirror.c.163.com"

 ]

}

第十部分：练习项目

项目1：构建个人博客系统

使用Docker Compose部署包含以下服务的个人博客：

Ghost博客平台

MySQL数据库

Nginx反向代理

Redis缓存

备份服务

项目2：微服务应用部署

部署一个简单的微服务应用：

API网关（Kong）

用户服务（Python/Flask）

产品服务（Node.js/Express）

订单服务（Java/Spring Boot）

数据库（PostgreSQL）

消息队列（RabbitMQ）

项目3：CI/CD流水线

创建自动化的CI/CD流水线：

Git仓库（代码管理）

Jenkins（持续集成）

Docker镜像构建

自动化测试

部署到生产环境

项目4：容器监控告警系统

部署完整的监控系统：

Prometheus（指标收集）

Grafana（可视化）

Alertmanager（告警）

cAdvisor（容器监控）

Loki（日志聚合）

今日总结

今天我们学习了Docker容器技术：

Docker基础：概念、安装、配置

镜像管理：拉取、构建、优化

容器管理：生命周期、资源限制

网络：网络模式、自定义网络

存储：数据卷、持久化

Docker Compose：多容器应用编排

实践案例：WordPress、监控系统

最佳实践：安全、性能、生产配置

重要提示：

容器不是虚拟机，而是进程级别的隔离

使用Dockerfile构建可重复的镜像

数据持久化要使用卷而不是容器内部

生产环境要关注安全和性能

Docker Compose适合开发和测试环境

Docker是现代应用部署的标准工具，掌握它将大大提高你的开发和运维效率。

有问题吗？完成练习项目后，我们可以继续第十四课：Linux系统故障排查和恢复。

推荐阅读：

Linux基础教程 第20课：Linux安全攻防和渗透测试基础

Linux基础教程 第19课：性能调优和容量规划

Linux基础教程 第18课：Linux云计算基础

Linux基础教程 第17课：自动化运维工具

Linux基础教程 第16课：集群和高可用性

Linux基础教程 第15课：Linux内核和驱动管理