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

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

相关推荐
大灰狼来喽2 小时前
OpenClaw 自动化工作流实战：用 Hooks + 定时任务 + Multi-MCP 构建“数字员工“
大数据·运维·人工智能·自动化·aigc·ai编程
by————组态2 小时前
Ricon组态系统：物联网时代的连接桥梁
运维·物联网·数学建模·组态·组态软件
溜达的大象2 小时前
极空间 NAS 玩童年游戏：Docker 部署马里奥
游戏·docker·容器
java资料站2 小时前
笔记本安装Ubuntu20.04(详细
运维
jessecyj2 小时前
Nginx中$http_host、$host、$proxy_host的区别
运维·nginx·http
skiy2 小时前
Nginx搭建负载均衡
运维·nginx·负载均衡
珠海西格电力2 小时前
零碳园区能源互联的落地保障措施
大数据·运维·网络·人工智能·能源
Alphapeople2 小时前
安装华为CANN模型导出工具
linux·运维·服务器
Yupureki2 小时前
《Linux系统编程》16.进程间通信-共享内存
linux·运维·服务器·c语言·数据结构·c++
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南05班级宠物园部署指南06小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）07UV安装并设置国内源08OpenClaw 使用和管理 MCP 完全指南09【计算机一级WPSoffice】小黑课堂题库软件下载安装教程（2026年3月最新版）10PostgreSQL 超详细安装与使用教程：从入门到实战