Docker 部署

部署四步法：

拆分编写（写说明书）
1. 针对自己写的代码（如Go，Python目录），在各自的根目录下编写 Dockerfile
- 明确指定基础环境（FROM）、复制代码（COPY）、安装依赖（RUN）、启动命令（CMD）
- 注意：像 MySQL、Redis 这种官方现成的中间件，不需要写 Dockefile
全局编排（画设计图）
1. 在项目的最外层根目录下，编写一个 docker-compose.yml 文件
- 把 Go、Python、MySQL... 分别定义为不同的 service
- 在里面配置好它们的启动顺序（depends_on）、数据怎么存（volumes）以及哪个端口对公网开放（通常只有 Nginx 的 ports）。
代码上传（打包交货）
1. 把本地写好的代码、Dockerfile、docker-compose.yml 整体上传到你的目标服务器（或者就在你本地开发环境）。
一键启动（全自动上线）
1. 在服务器上进入 docker-compose.yml 所在的目录，执行终极命令：
```
 docker-compose up -d
```
- Docker 会自动去云端拉取 MySQL/Redis/Nginx，并在本地把 Go/Python 打包成镜像，最后让 5 个容器在后台（-d）连网运行。

检查状态：docker-compose ps
查看日志：docker-compose logs -f [服务名]
一键停止： docker-compose down
重启某个服务： docker-compose restart go-service

真实项目部署全流程（例）

塞进 Docker 并运行起来，核心只需要两步

写一份“组装说明书”（定义 Dockerfile）
执行两行命令（构建并运行）

第一步

在项目代码根目录下，新建一个名字叫做 Dockerfile 的文件（无后缀）

这个文件的作用是告诉 Docker ：怎么把代码打包

# 1. 指定基础镜像：你的项目需要什么语言环境，就找什么环境（比如 python:3.10 或 golang:1.22）
FROM python:3.10-slim

# 2. 设置容器内部的工作目录（相当于在容器里 mkdir /app 并在里面执行后续命令）
WORKDIR /app

# 3. 把你本地电脑当前目录下的所有项目文件，复制到容器的 /app 目录下
COPY . .

# 4. 在容器内部执行命令，安装你项目需要的依赖库
RUN pip install --no-cache-dir -r requirements.txt

# 5. 声明容器内部程序监听的端口（比如你的后端服务跑在 8000 端口）
EXPOSE 8000

# 6. 容器启动时默认执行的命令（真正把你的后端程序跑起来）
CMD ["python", "main.py"]

第二步

写好 Dockerfile 后，打开终端，切换到项目根目录下，依次执行一下两行命令

构建镜像（把你的代码和环境打包成一个静态的“镜像包”）

docker build -t my-app:v1.0 .

-t my-app:v1.0 给这个镜像起名字叫 my-app ，版本号是 v1.0
. 注意最后有一个点，这代表当前目录，意思是让 Docker 在当前目录下寻找 Dockerfile

运行容器

把刚刚打包好的进镜像在后台跑起来

docker run -d -p 8000:8000 --name my-running-app my-app:v1.0

-d 让容器在后台偷偷运行，不占用终端窗口
-p 8000:8000 把宿主机的 8000 端口映射到容器内部的 8000 端口，这样访问外界的 8000 就能直接打到容器的服务上
--name my-running-app 给这个运行中的实例起个名字
my-app:v1.0 指定使用刚才打包好的那个镜像

运行完这一步，项目就已经成功部署在 Docker 里了。可以在浏览器或者 Postman 里访问 http://localhost:8000 来测试接口

如果项目需要依赖数据库

如果数据库也想用 Docker 部署，千万不要把数据库和代码塞进同一个 Dockerfile 里

Docker 的核心哲学是：一个容器只做一件事。后端是一个容器，MySQL 是另一个容器。

为了让他们协同工作，我们会使用 Docker Compose。

同样是在项目根目录下，写一个 docker-compose.yml 文件：

version: '3.8'

services:
  # 1. 我们的后端服务
  web:
    build: .  # 直接读取当前目录的 Dockerfile 来构建
    ports:
      - "8000:8000"
    depends_on:
      - redis # 声明依赖关系，确保 redis 先启动

  # 2. Redis 缓存服务
  redis:
    image: "redis:7.0-alpine" # 直接从官方仓库拉取现成的 Redis 镜像
    ports:
      - "6379:6379"

写好这个文件后，上面那两条 docker build 和 docker run 都不用敲了，直接一行命令：

docker-compose up -d

Docker 会自动把后端代码打包，顺便把 Redis 下载下来，并且自动把它们安排在同一个虚拟网络里，让它们可以直接互相通信。

多组件微服务架构 Go + Python + MySQL + Redis + Nginx 部署（例）

这里使用 Docker Compose（多容器编排工具）

核心原理：

核心哲学：一个容器只做一件事。因此，你这个架构不会被打包成一个巨大的容器，而是会拆分成 5 个独立的容器。

容器间网络互通
- Docker Compose 在启动时，会在后台自动创建一个虚拟的“局域网”。这 5 个容器都会加入这个网络。在网络内部，容器的服务名就是它们的域名。
  - 例如：Go 项目想连 Redis，代码里的连接地址直接写 http://redis:6379 就行，不需要知道具体的 IP 地址。
端口隔离与映射
- 内部互通：MySQL(3306)、Redis(6379)、Go(8000)、Python(5000) 之间在虚拟网络内部是完全开放访问的。
- 外部防火墙：默认情况下，外界（比如公网用户）是无法访问这些容器的。我们只把 Nginx 的 80/443 端口暴露给外面的世界。
反向代理与负载均衡
- Nginx 充当整个架构的“门卫”。外界所有的流量统一打到 Nginx，Nginx 根据路由规则进行分发
  - 请求 /api/v1/go -> 转发给 Go 容器
  - 请求 /api/v1/py -> 转发给 Python 容器
  - 请求静态网页 -> Nginx 自己直接处理

部署过程

整个部署过程分为三步：准备环境 -> 编写配置文件 -> 一键启动。

准备工作（项目目录结构）

把代码和配置文件梳理成类似下面的结构：

my-project/
│
├── go-app/          # Go 项目目录
│   ├── main.go
│   └── Dockerfile   # Go 的说明书
│
├── py-app/          # Python 项目目录
│   ├── main.py
│   └── Dockerfile   # Python 的说明书
│
├── nginx/           # Nginx 配置目录
│   └── default.conf # Nginx 路由规则
│
└── docker-compose.yml # 整个大系统的“总指挥官”

编写各自的 Dockerfile

Go 项目的 go-app/Dockerfile：

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o main .
CMD ["./main"]

Python 项目的 py-app/Dockerfile：

FROM python:3.10-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "main.py"]

编写 Nginx 配置文件（nginx/default.conf）

告诉 Nginx 流量怎么分发（注意：proxy_pass 后面直接写 Docker 服务名）：

server {
    listen 80;

    location /api/go/ {
        proxy_pass http://go-service:8000/; # 转发给 Go 容器
    }

    location /api/py/ {
        proxy_pass http://py-service:5000/; # 转发给 Python 容器
    }
}

编写总指挥官文件 (docker-compose.yml)

这是最核心的一步，把所有组件拼装在一起：

version: '3.8'

services:
  # 1. MySQL 数据库
  mysql-db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: my_db
    volumes:
      - mysql_data:/var/lib/mysql # 数据持久化，防止容器删了数据丢失

  # 2. Redis 缓存
  redis-cache:
    image: redis:7.0-alpine

  # 3. Go 后端
  go-service:
    build: ./go-app            # 寻找 go-app 目录下的 Dockerfile 构建
    depends_on:
      - mysql-db               # 确保数据库先启动
      - redis-cache            # 确保 Redis 先启动

  # 4. Python 后端
  py-service:
    build: ./py-app            # 寻找 py-app 目录下的 Dockerfile 构建
    depends_on:
      - mysql-db
      - redis-cache

  # 5. Nginx 网关
  nginx-gateway:
    image: nginx:alpine
    ports:
      - "80:80"                # 真正对公网开放的端口！
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf # 挂载配置文件
    depends_on:
      - go-service
      - py-service

volumes:
  mysql_data:                  # 声明一个持久化数据卷

执行部署

把上面这些文件放到服务器上，在 docker-compose.yml 所在的根目录下，执行唯一的一条命令：

docker-compose up -d

Docker 会自动下载 MySQL/Redis/Nginx，自动构建 Go/Python 镜像，自动创建虚拟网络，并按照依赖顺序把它们全部在后台跑起来。

posted @ 2026-06-11 16:38 Lunor 阅读(17) 评论(0) 收藏举报

刷新页面返回顶部

liunor

Docker 部署

部署四步法：

真实项目部署全流程（例）

第一步

第二步

构建镜像（把你的代码和环境打包成一个静态的“镜像包”）

运行容器

如果项目需要依赖数据库

多组件微服务架构 Go + Python + MySQL + Redis + Nginx 部署（例）

部署过程

准备工作（项目目录结构）

编写各自的 Dockerfile

编写 Nginx 配置文件（nginx/default.conf）

编写总指挥官文件 (docker-compose.yml)

执行部署

公告

liunor

Docker 部署

部署 四步法：

真实项目部署全流程（例）

第一步

第二步

构建镜像（把你的代码和环境打包成一个静态的“镜像包”）

运行容器

如果项目需要依赖数据库

多组件微服务架构 Go + Python + MySQL + Redis + Nginx 部署（例）

部署过程

准备工作（项目目录结构）

编写各自的 Dockerfile

编写 Nginx 配置文件（nginx/default.conf）

编写总指挥官文件 (docker-compose.yml)

执行部署

公告

部署四步法：