Docker容器化实战：从入门到精通，附完整实战案例

lbb 小魔仙2026-03-27 10:16

Docker容器化实战：从入门到精通，附完整实战案例

在微服务时代，Docker已成为开发者的必备技能。本文将带你从零开始，通过实战案例掌握Docker的核心技术，包括容器管理、镜像构建、Docker Compose编排等，附完整可运行代码。


🌸你好呀！我是 lbb小魔仙
🌟 感谢陪伴～ 小白博主在线求友
🌿 跟着小白学Linux/Java/Python
📖 专栏汇总：
《Linux》专栏 | 《Java》专栏 | 《Python》专栏

  • Docker容器化实战：从入门到精通，附完整实战案例
    • 前言
    • 一、Docker核心概念
      • [1.1 什么是Docker？](#1.1 什么是Docker？)
      • [1.2 核心组件对比](#1.2 核心组件对比)
      • [1.3 Docker vs 虚拟机](#1.3 Docker vs 虚拟机)
    • 二、Docker安装与配置
      • [2.1 Windows安装](#2.1 Windows安装)
      • [2.2 Linux安装](#2.2 Linux安装)
      • [2.3 配置镜像加速器](#2.3 配置镜像加速器)
    • 三、Docker基础命令
      • [3.1 镜像操作](#3.1 镜像操作)
      • [3.2 容器操作](#3.2 容器操作)
      • [3.3 常用参数说明](#3.3 常用参数说明)
    • 四、Dockerfile实战
      • [4.1 Dockerfile基础语法](#4.1 Dockerfile基础语法)
      • [4.2 实战案例1：Python Flask应用](#4.2 实战案例1：Python Flask应用)
      • [4.3 实战案例2：Node.js应用](#4.3 实战案例2：Node.js应用)
      • [4.4 实战案例3：Nginx静态网站](#4.4 实战案例3：Nginx静态网站)
    • [五、Docker Compose实战](#五、Docker Compose实战)
      • [5.1 Docker Compose简介](#5.1 Docker Compose简介)
      • [5.2 docker-compose.yml基础语法](#5.2 docker-compose.yml基础语法)
      • [5.3 实战案例：完整Web应用栈](#5.3 实战案例：完整Web应用栈)
    • 六、数据持久化
      • [6.1 数据卷（Volume）](#6.1 数据卷（Volume）)
      • [6.2 绑定挂载（Bind Mount）](#6.2 绑定挂载（Bind Mount）)
      • [6.3 实战案例：MySQL数据持久化](#6.3 实战案例：MySQL数据持久化)
    • 七、网络管理
      • [7.1 Docker网络类型](#7.1 Docker网络类型)
      • [7.2 创建自定义网络](#7.2 创建自定义网络)
      • [7.3 实战案例：多服务网络通信](#7.3 实战案例：多服务网络通信)
    • 八、Docker最佳实践
      • [8.1 镜像优化](#8.1 镜像优化)
      • [8.2 安全最佳实践](#8.2 安全最佳实践)
      • [8.3 健康检查](#8.3 健康检查)
      • [8.4 日志管理](#8.4 日志管理)
    • 九、常见问题与解决方案
      • [Q1: 容器启动失败怎么办？](#Q1: 容器启动失败怎么办？)
      • [Q2: 如何清理Docker资源？](#Q2: 如何清理Docker资源？)
      • [Q3: 如何在容器和宿主机之间复制文件？](#Q3: 如何在容器和宿主机之间复制文件？)
      • [Q4: 如何限制容器资源？](#Q4: 如何限制容器资源？)
    • 十、完整实战项目
      • [10.1 项目概述](#10.1 项目概述)
      • [10.2 项目结构](#10.2 项目结构)
      • [10.3 docker-compose.yml](#10.3 docker-compose.yml)
      • [10.4 启动项目](#10.4 启动项目)
    • 十一、总结
    • 参考资源

前言

你是否遇到过这样的困扰：

  • "在我本地能跑，为什么部署到服务器就报错了？"
  • "项目依赖太多，环境配置太复杂"
  • "多个项目需要不同版本的Python/Node.js"

Docker的出现完美解决了这些问题！它通过容器化技术，将应用程序及其依赖打包成一个轻量级、可移植的容器，实现"一次构建，到处运行"。

本文将从Docker的基础概念讲起，通过多个实战案例带你掌握容器化技术，最终能够独立完成复杂应用的Docker化部署。

一、Docker核心概念

1.1 什么是Docker？

Docker是一个开源的容器化平台，它允许开发者将应用及其依赖打包到一个轻量级、可移植的容器中。

核心优势：

  • ✅ 环境一致性：开发、测试、生产环境完全一致
  • ✅ 快速部署：秒级启动应用
  • ✅ 资源隔离：进程、网络、存储隔离
  • ✅ 轻量级：相比虚拟机占用更少资源

1.2 核心组件对比

组件 说明 类比
镜像（Image） 只读的模板，包含运行应用所需的一切 类似于面向对象编程中的"类"
容器（Container） 镜像的运行实例 类似于"对象"
仓库（Registry） 存储和分发镜像的地方 类似于代码仓库（如GitHub）
Dockerfile 构建镜像的脚本 类似于Makefile或CMakeLists.txt

1.3 Docker vs 虚拟机

复制代码 
┌─────────────────────────────────────────────────┐
│                 虚拟机架构                        │
├─────────────────────────────────────────────────┤
│  应用程序A    应用程序B    应用程序C               │
├─────────────────────────────────────────────────┤
│  Guest OS    Guest OS    Guest OS               │
├─────────────────────────────────────────────────┤
│              Hypervisor                         │
├─────────────────────────────────────────────────┤
│                 Host OS                         │
├─────────────────────────────────────────────────┤
│                 硬件                             │
└─────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────┐
│                 Docker架构                       │
├─────────────────────────────────────────────────┤
│  应用程序A    应用程序B    应用程序C               │
├─────────────────────────────────────────────────┤
│              Docker Engine                      │
├─────────────────────────────────────────────────┤
│                 Host OS                         │
├─────────────────────────────────────────────────┤
│                 硬件                             │
└─────────────────────────────────────────────────┘

性能对比：

  • 启动速度：虚拟机分钟级 vs Docker秒级
  • 磁盘占用：虚拟机GB级 vs Docker MB级
  • 性能损耗：虚拟机10-20% vs Docker<5%

二、Docker安装与配置

2.1 Windows安装

bash 复制代码 
# 1. 下载Docker Desktop
# 访问 https://www.docker.com/products/docker-desktop/

# 2. 安装后验证
docker --version
docker-compose --version

# 3. 启动Docker Desktop

2.2 Linux安装

bash 复制代码 
# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

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

# 重新登录或执行
newgrp docker

# 验证安装
docker --version
docker run hello-world

2.3 配置镜像加速器

bash 复制代码 
# 编辑Docker配置文件
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}
EOF

# 重启Docker服务
sudo systemctl daemon-reload
sudo systemctl restart docker

三、Docker基础命令

3.1 镜像操作

bash 复制代码 
# 搜索镜像
docker search nginx

# 拉取镜像
docker pull nginx:latest
docker pull python:3.10-slim

# 查看本地镜像
docker images
docker image ls

# 删除镜像
docker rmi nginx:latest
docker image prune -a  # 删除未使用的镜像

# 构建镜像
docker build -t myapp:1.0 .

3.2 容器操作

bash 复制代码 
# 运行容器
docker run -d --name mynginx -p 80:80 nginx

# 查看运行中的容器
docker ps
docker container ls

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

# 停止容器
docker stop mynginx

# 启动容器
docker start mynginx

# 重启容器
docker restart mynginx

# 删除容器
docker rm mynginx
docker container prune  # 删除停止的容器

# 查看容器日志
docker logs mynginx
docker logs -f mynginx  # 实时查看

# 进入容器
docker exec -it mynginx /bin/bash
docker exec -it mynginx sh

3.3 常用参数说明

参数 说明 示例
-d 后台运行 docker run -d nginx
-p 端口映射 -p 8080:80
-v 挂载卷 -v /data:/app/data
-e 环境变量 -e MYSQL_ROOT_PASSWORD=123456
--name 容器名称 --name myapp
--restart 重启策略 --restart=always

四、Dockerfile实战

4.1 Dockerfile基础语法

dockerfile 复制代码 
# FROM: 指定基础镜像
FROM python:3.10-slim

# LABEL: 添加元数据
LABEL maintainer="your-email@example.com"
LABEL version="1.0"

# WORKDIR: 设置工作目录
WORKDIR /app

# COPY: 复制文件到容器
COPY requirements.txt .

# RUN: 执行命令
RUN pip install --no-cache-dir -r requirements.txt

# COPY: 复制应用代码
COPY . .

# EXPOSE: 声明暴露的端口
EXPOSE 8000

# ENV: 设置环境变量
ENV PYTHONUNBUFFERED=1

# CMD: 容器启动时执行的命令
CMD ["python", "app.py"]

4.2 实战案例1：Python Flask应用

项目结构：

复制代码 
flask-app/
├── app.py
├── requirements.txt
├── Dockerfile
└── .dockerignore

app.py:

python 复制代码 
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def hello():
    return jsonify({
        "message": "Hello from Docker!",
        "status": "success"
    })

@app.route('/health')
def health():
    return jsonify({"status": "healthy"})

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

requirements.txt:

复制代码 
flask==3.0.0
gunicorn==21.2.0

Dockerfile:

dockerfile 复制代码 
FROM python:3.10-slim

LABEL maintainer="your-email@example.com"

WORKDIR /app

COPY requirements.txt .

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

COPY . .

EXPOSE 8000

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "app:app"]

.dockerignore:

复制代码 
__pycache__
*.pyc
.git
.gitignore
venv

构建和运行：

bash 复制代码 
# 构建镜像
docker build -t flask-app:1.0 .

# 运行容器
docker run -d --name flask-app -p 8000:8000 flask-app:1.0

# 测试
curl http://localhost:8000

4.3 实战案例2：Node.js应用

项目结构：

复制代码 
node-app/
├── package.json
├── index.js
├── Dockerfile
└── .dockerignore

package.json:

json 复制代码 
{
  "name": "node-docker-app",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

index.js:

javascript 复制代码 
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
    res.json({
        message: 'Hello from Node.js in Docker!',
        timestamp: new Date().toISOString()
    });
});

app.get('/api/users', (req, res) => {
    res.json([
        { id: 1, name: 'Alice' },
        { id: 2, name: 'Bob' }
    ]);
});

app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

Dockerfile（多阶段构建）：

dockerfile 复制代码 
# 阶段1: 构建阶段
FROM node:18-alpine AS builder

WORKDIR /app

COPY package*.json ./

RUN npm ci --only=production

COPY . .

# 阶段2: 运行阶段
FROM node:18-alpine

WORKDIR /app

COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/index.js ./

EXPOSE 3000

CMD ["node", "index.js"]

构建和运行：

bash 复制代码 
# 构建镜像
docker build -t node-app:1.0 .

# 运行容器
docker run -d --name node-app -p 3000:3000 node-app:1.0

# 测试
curl http://localhost:3000

4.4 实战案例3：Nginx静态网站

项目结构：

复制代码 
nginx-site/
├── index.html
├── css/
│   └── style.css
├── js/
│   └── app.js
└── nginx.conf

index.html:

html 复制代码 
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Docker Nginx Demo</title>
    <link rel="stylesheet" href="css/style.css">
</head>
<body>
    <div class="container">
        <h1>🐳 Welcome to Docker Nginx</h1>
        <p>This site is served by Nginx in a Docker container!</p>
        <button id="btn">Click Me</button>
    </div>
    <script src="js/app.js"></script>
</body>
</html>

nginx.conf:

nginx 复制代码 
events {
    worker_connections 1024;
}

http {
    server {
        listen 80;
        server_name localhost;

        root /usr/share/nginx/html;
        index index.html;

        location / {
            try_files $uri $uri/ /index.html;
        }

        location /api/ {
            proxy_pass http://backend:8000;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Dockerfile:

dockerfile 复制代码 
FROM nginx:alpine

LABEL maintainer="your-email@example.com"

COPY nginx.conf /etc/nginx/nginx.conf

COPY . /usr/share/nginx/html

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

五、Docker Compose实战

5.1 Docker Compose简介

Docker Compose是用于定义和运行多容器Docker应用程序的工具。通过YAML文件配置应用的服务，然后使用一个命令创建和启动所有服务。

5.2 docker-compose.yml基础语法

yaml 复制代码 
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - app

  app:
    build: ./app
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5.3 实战案例：完整Web应用栈

项目结构：

复制代码 
fullstack-app/
├── docker-compose.yml
├── frontend/
│   ├── Dockerfile
│   └── src/
├── backend/
│   ├── Dockerfile
│   ├── requirements.txt
│   └── app.py
└── db/
    └── init.sql

docker-compose.yml:

yaml 复制代码 
version: '3.8'

services:
  # 前端服务
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network

  # 后端服务
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    environment:
      - DATABASE_HOST=db
      - DATABASE_PORT=5432
      - DATABASE_NAME=appdb
      - DATABASE_USER=appuser
      - DATABASE_PASSWORD=apppass
    depends_on:
      - db
    networks:
      - app-network
    volumes:
      - ./backend:/app

  # 数据库服务
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=appdb
      - POSTGRES_USER=appuser
      - POSTGRES_PASSWORD=apppass
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"
    networks:
      - app-network

  # Redis缓存
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    networks:
      - app-network

volumes:
  postgres_data:

networks:
  app-network:
    driver: bridge

backend/app.py:

python 复制代码 
from flask import Flask, jsonify
import psycopg2
from redis import Redis
import os

app = Flask(__name__)

def get_db_connection():
    conn = psycopg2.connect(
        host=os.getenv('DATABASE_HOST', 'db'),
        port=int(os.getenv('DATABASE_PORT', 5432)),
        database=os.getenv('DATABASE_NAME', 'appdb'),
        user=os.getenv('DATABASE_USER', 'appuser'),
        password=os.getenv('DATABASE_PASSWORD', 'apppass')
    )
    return conn

def get_redis():
    return Redis(
        host='redis',
        port=6379,
        decode_responses=True
    )

@app.route('/')
def index():
    return jsonify({
        "message": "Fullstack API",
        "services": {
            "database": "PostgreSQL",
            "cache": "Redis"
        }
    })

@app.route('/health')
def health():
    try:
        redis = get_redis()
        redis.ping()
        
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute('SELECT 1')
        cursor.close()
        conn.close()
        
        return jsonify({
            "status": "healthy",
            "database": "connected",
            "redis": "connected"
        })
    except Exception as e:
        return jsonify({
            "status": "unhealthy",
            "error": str(e)
        }), 500

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

backend/Dockerfile:

dockerfile 复制代码 
FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .

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

COPY . .

EXPOSE 8000

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

backend/requirements.txt:

复制代码 
flask==3.0.0
psycopg2-binary==2.9.9
redis==5.0.1

db/init.sql:

sql 复制代码 
CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO users (name, email) VALUES
    ('Alice', 'alice@example.com'),
    ('Bob', 'bob@example.com');

启动应用：

bash 复制代码 
# 构建并启动所有服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止服务
docker-compose down

# 停止并删除卷
docker-compose down -v

六、数据持久化

6.1 数据卷（Volume）

bash 复制代码 
# 创建数据卷
docker volume create mydata

# 查看数据卷
docker volume ls
docker volume inspect mydata

# 使用数据卷
docker run -d --name myapp -v mydata:/app/data nginx

# 删除数据卷
docker volume rm mydata

6.2 绑定挂载（Bind Mount）

bash 复制代码 
# 挂载本地目录
docker run -d --name myapp \
    -v /host/path:/container/path \
    nginx

# 只读挂载
docker run -d --name myapp \
    -v /host/path:/container/path:ro \
    nginx

6.3 实战案例：MySQL数据持久化

yaml 复制代码 
version: '3.8'

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: myapp
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppass
    volumes:
      # 数据持久化
      - mysql_data:/var/lib/mysql
      # 初始化脚本
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
      # 配置文件
      - ./my.cnf:/etc/mysql/conf.d/custom.cnf:ro
    ports:
      - "3306:3306"

volumes:
  mysql_data:

七、网络管理

7.1 Docker网络类型

网络类型 说明 使用场景
bridge 默认网络，容器间通过桥接通信 单机多容器通信
host 容器使用宿主机网络 需要高性能网络
none 无网络 完全隔离
overlay 跨主机网络 Docker Swarm集群

7.2 创建自定义网络

bash 复制代码 
# 创建bridge网络
docker network create mynetwork

# 查看网络
docker network ls
docker network inspect mynetwork

# 连接容器到网络
docker network connect mynetwork mycontainer

# 断开网络
docker network disconnect mynetwork mycontainer

# 删除网络
docker network rm mynetwork

7.3 实战案例：多服务网络通信

yaml 复制代码 
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    networks:
      - frontend
      - backend

  app:
    build: ./app
    networks:
      - backend

  db:
    image: postgres:15
    networks:
      - backend

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge

八、Docker最佳实践

8.1 镜像优化

1. 使用多阶段构建

dockerfile 复制代码 
# 构建阶段
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 运行阶段
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

2. 减少层数

dockerfile 复制代码 
# 不好的做法
RUN apt-get update
RUN apt-get install -y python3
RUN apt-get install -y pip

# 好的做法
RUN apt-get update && \
    apt-get install -y python3 pip && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

3. 使用.dockerignore

复制代码 
.git
.gitignore
node_modules
__pycache__
*.log
.env

8.2 安全最佳实践

dockerfile 复制代码 
# 使用非root用户
FROM python:3.10-slim

WORKDIR /app

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

COPY . .

# 创建非root用户
RUN useradd -m appuser && \
    chown -R appuser:appuser /app

USER appuser

EXPOSE 8000

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

8.3 健康检查

yaml 复制代码 
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  app:
    build: ./app
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

8.4 日志管理

yaml 复制代码 
version: '3.8'

services:
  app:
    image: myapp:1.0
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

九、常见问题与解决方案

Q1: 容器启动失败怎么办？

排查步骤：

bash 复制代码 
# 查看容器日志
docker logs <container_id>

# 查看容器详细信息
docker inspect <container_id>

# 进入容器调试
docker exec -it <container_id> /bin/bash

# 查看容器状态
docker ps -a

Q2: 如何清理Docker资源？

bash 复制代码 
# 清理停止的容器
docker container prune

# 清理未使用的镜像
docker image prune -a

# 清理未使用的卷
docker volume prune

# 清理未使用的网络
docker network prune

# 清理所有未使用的资源
docker system prune -a --volumes

Q3: 如何在容器和宿主机之间复制文件？

bash 复制代码 
# 从宿主机复制到容器
docker cp /host/file.txt container:/container/path/

# 从容器复制到宿主机
docker cp container:/container/file.txt /host/path/

Q4: 如何限制容器资源？

yaml 复制代码 
version: '3.8'

services:
  app:
    image: myapp:1.0
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

十、完整实战项目

10.1 项目概述

构建一个完整的博客系统，包含：

  • 前端：React应用
  • 后端：Flask API
  • 数据库：PostgreSQL
  • 缓存：Redis
  • 反向代理：Nginx

10.2 项目结构

复制代码 
blog-system/
├── docker-compose.yml
├── frontend/
│   ├── Dockerfile
│   └── src/
├── backend/
│   ├── Dockerfile
│   ├── requirements.txt
│   └── app.py
├── nginx/
│   └── nginx.conf
└── db/
    └── init.sql

10.3 docker-compose.yml

yaml 复制代码 
version: '3.8'

services:
  # 前端服务
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    depends_on:
      - backend
    networks:
      - blog-network

  # 后端服务
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    environment:
      - DATABASE_HOST=db
      - DATABASE_PORT=5432
      - DATABASE_NAME=blogdb
      - DATABASE_USER=bloguser
      - DATABASE_PASSWORD=blogpass
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    depends_on:
      - db
      - redis
    networks:
      - blog-network
    volumes:
      - ./backend:/app

  # Nginx反向代理
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - frontend
      - backend
    networks:
      - blog-network

  # PostgreSQL数据库
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=blogdb
      - POSTGRES_USER=bloguser
      - POSTGRES_PASSWORD=blogpass
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - blog-network

  # Redis缓存
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    networks:
      - blog-network

volumes:
  postgres_data:

networks:
  blog-network:
    driver: bridge

10.4 启动项目

bash 复制代码 
# 克隆项目
git clone <repository-url>
cd blog-system

# 构建并启动所有服务
docker-compose up -d --build

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 访问应用
# 前端: http://localhost:3000
# 后端: http://localhost:8000
# Nginx: http://localhost

十一、总结

本文从Docker的基础概念出发，通过多个实战案例详细介绍了容器化技术的应用：

  1. 核心概念：镜像、容器、仓库的关系
  2. 基础操作：镜像和容器的常用命令
  3. Dockerfile：构建自定义镜像的方法
  4. Docker Compose：多容器编排技术
  5. 数据持久化：卷和挂载的使用
  6. 网络管理：容器间通信配置
  7. 最佳实践：镜像优化、安全配置、健康检查
  8. 完整项目：博客系统的完整实现

通过本文的学习，你应该能够：

  • 独立使用Docker容器化应用
  • 编写高效的Dockerfile
  • 使用Docker Compose编排多服务应用
  • 实现数据持久化和网络通信
  • 遵循Docker最佳实践

记住：Docker的核心价值在于"一次构建，到处运行"，掌握它将极大提升你的开发效率！

参考资源

作者简介：专注于云原生和容器化技术研究，欢迎关注更多技术分享！

版权声明：本文为原创文章，转载请注明出处。

如果本文对你有帮助，欢迎点赞、收藏、评论支持！如有问题，欢迎在评论区交流讨论。

📕个人领域 ：Linux/C++/java/AI

🚀 个人主页 ：有点流鼻涕 · CSDN

💬 座右铭 ： "向光而行，沐光而生。"

相关推荐
XIAOHEZIcode6 小时前
Linux系统鼠标偏移常见原因以及修复方案
linux·运维·游戏
用户0328472220701 天前
如何搭建本地yum源(上)
运维
武子康1 天前
调查研究-183 Apple container：Mac 上用轻量 VM 跑 Linux 容器，Swift 会改写本地容器体验吗？
docker·容器·apple
大树884 天前
金刚石散热越强，管路越先见顶
大数据·运维·服务器·人工智能·ai
摇滚侠4 天前
Linux CentOS7 rpm 安装 MySQL 5.7
linux·运维·mysql
霸道流氓气质4 天前
领域驱动设计（DDD）在 Spring Boot 微服务中的实践指南
运维·spring boot·微服务
Inhand陈工4 天前
基于台达PLC与映翰通IG502的智慧水产养殖精准投喂与远程运维解决方案
运维·人工智能·物联网·阿里云·信息与通信
Alsn864 天前
等待学习-学习目录：Docker 容器安全攻防
学习·安全·docker
酣大智4 天前
ARP代理--工作原理
运维·网络·arp·arp代理
shushangyun_4 天前
2026年快消品B2B系统推荐：支持终端门店订货、促销政策自动化的工具？
java·运维·网络·数据库·人工智能·spring·自动化
热门推荐
012026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04【AI】2026 年具身智能模型和世界模型总结05GitHub 镜像站点06AI科技热点日报 | 2026年6月1日07AI一周事件 · 2026-06-03 至 2026-06-0908Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析09上线仅72小时被强制下架：Claude Fable 5 的短命102026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？