0
0
0

后端架构演进：从单体到云原生 —— 面向零基础初学者的实战教程

创新Tech
2025-06-29 19:19
阅读 329

开篇：什么是后端架构演进？为什么重要？

开篇：什么是后端架构演进？为什么重要？

很多刚接触编程的同学会问：“我写完了一个网站，怎么让它能支撑更多用户？”、“我的代码越来越多，怎么管理更高效？”——这些问题都涉及后端架构的设计。

简单来说，后端架构就是我们用来组织和部署服务的一种结构设计。就像盖房子一样，不同的“框架”会影响它能不能承受更多的重量（用户），能不能快速维修（维护更新），甚至能不能搬到更高处去住（上云）。

本篇文章将带你了解：

  • 从一个简单的单体系统出发
  • 逐步理解分层、微服务、容器化、云原生的发展过程
  • 通过最直观的代码示例来感受每一步的变化

🎯学习目标：掌握从单体架构到云原生架构的基本概念与实践思路，能用真实项目演示技术演进。

环境准备：搭建开发工具链（Python + Flask）

环境准备：搭建开发工具链（Python + Flask）

我们将使用 Python + Flask 来完成整个项目的构建，这是最适合入门的语言与框架之一。

步骤1：安装 Python 和 pip

请前往 Python官网下载最新版本（推荐3.8以上），并确保 pip 已安装。

验证是否安装成功：

python --version
pip --version

步骤2：安装 Flask

执行以下命令安装 Flask 框架：

pip install flask

步骤3：创建你的第一个项目目录

创建如下文件夹结构：

myproject/
├── app.py
└── requirements.txt

requirements.txt 内容：

flask==2.0.1

app.py 内容为：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello from backend!"

if __name__ == '__main__':
    app.run(debug=True)

运行这个应用：

cd myproject
python app.py

访问：http://localhost:5000，页面应显示 Hello from backend!

✅ 到这里，你已经准备好开始我们的架构演化之路了！

核心概念：一步步认识不同后端架构

我们来认识几个关键术语，并配合实例讲解它们的实际作用：

架构类型 特点描述
单体架构 所有功能在一个程序里
分层架构 把系统拆分为表现层、业务逻辑层、数据层等模块
微服务架构 每个功能独立成服务，可分别部署
容器化部署 使用 Docker 封装服务，实现环境一致性
云原生架构 结合 Kubernetes 实现自动化部署与弹性扩展

下面我们就一步一步从“单体”演变到“云原生”。

实战项目：跟着做，从单体到云原生

我们将通过一个简单的博客系统逐步实现这些架构变化。

💡假设需求：展示一篇文章列表，支持添加新文章。

第一步：单体架构 —— All in One

代码说明

这是一个典型的单体应用，所有功能都在 app.py 文件中完成：

from flask import Flask, request, jsonify

app = Flask(__name__)
articles = []

@app.route('/articles', methods=['GET'])
def get_articles():
    return jsonify(articles)

@app.route('/articles', methods=['POST'])
def add_article():
    data = request.json
    articles.append(data)
    return jsonify({"message": "Added article"}), 201

if __name__ == '__main__':
    app.run(debug=True)

运行效果

启动服务：

python app.py

请求测试（可用 Postman 或 curl）：

获取所有文章：

curl http://localhost:5000/articles

添加文章：

curl -X POST http://localhost:5000/articles -H "Content-Type: application/json" -d '{"title":"Hello","content":"My first post"}'

✅ 这是经典的单体架构，适合小型项目，但随着功能增加，代码会越来越难管理。

第二步：分层架构 —— 模块化设计

现在我们把数据存储逻辑抽出来作为单独一层，使得未来更换数据库更容易。

新增文件结构：

myproject/
├── app.py       # 控制器部分
├── models.py    # 数据模型
└── requirements.txt
修改后的 models.py：
articles = []

def get_all():
    return articles

def save(article):
    articles.append(article)
修改后的 app.py：
from flask import Flask, request, jsonify
import models

app = Flask(__name__)

@app.route('/articles', methods=['GET'])
def get_articles():
    return jsonify(models.get_all())

@app.route('/articles', methods=['POST'])
def add_article():
    data = request.json
    models.save(data)
    return jsonify({"message": "Added"}), 201

if __name__ == '__main__':
    app.run(debug=True)

✨这样就把数据层分离了出来，便于后期替换数据库，比如换成 Redis 或 MySQL。

第三步：微服务架构 —— 拆分功能为多个服务

在实际项目中，文章服务可能会被拆成两个服务：一个处理用户信息，一个处理文章内容。

我们先模拟一个简化版：把“文章服务”拆成一个独立的服务（后面还可以加用户服务）。

启动两个服务：

  1. 文章服务（跑在 5001）

新建文件夹 article-service/

文件结构：

article-service/
├── app.py
└── requirements.txt

app.py 内容如下：

from flask import Flask, request, jsonify

app = Flask(__name__)
articles = []

@app.route('/articles', methods=['GET'])
def get_articles():
    return jsonify(articles)

@app.route('/articles', methods=['POST'])
def add_article():
    data = request.json
    articles.append(data)
    return jsonify({"message": "Added"}), 201

if __name__ == '__main__':
    app.run(port=5001)

启动该服务：

cd article-service
python app.py

✅ 现在文章服务已跑在 5001 端口

  1. 主服务调用文章服务（跑在 5000）

新增文件夹 main-service/

结构如下：

main-service/
├── app.py
├── requirements.txt

其中 app.py 内容如下：

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

ARTICLE_SERVICE_URL = 'http://localhost:5001'

@app.route('/articles', methods=['GET'])
def proxy_get_articles():
    response = requests.get(f"{ARTICLE_SERVICE_URL}/articles")
    return jsonify(response.json())

@app.route('/articles', methods=['POST'])
def proxy_add_article():
    data = request.json
    response = requests.post(f"{ARTICLE_SERVICE_URL}/articles", json=data)
    return jsonify(response.json()), response.status_code

if __name__ == '__main__':
    app.run()

运行主服务：

cd main-service
python app.py

现在你可以通过访问 http://localhost:5000/articles 来操作文章数据，实际上它是转发给 5001 的服务处理的。

🎉 你已经实现了微服务的一个基本雏形：多个服务各自独立运行并协作完成任务！

第四步：容器化部署 —— 使用 Docker

我们用 Docker 把每个服务打包成镜像，方便移植与发布。

目标：把两个服务分别打包成 Docker 镜像并运行。

创建 Dockerfile for article-service

在 article-service 下创建文件 Dockerfile：

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

同理，在 main-service 下也创建一个 Dockerfile：

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

构建镜像：

# 在 article-service 目录下
docker build -t article-service .

# 在 main-service 目录下
docker build -t main-service .

启动容器：

docker run -p 5001:5001 --name article article-service
docker run -p 5000:5000 --name main main-service

✅ 现在你已经用容器化方式运行了两个微服务。

第五步：云原生部署 —— 使用 Kubernetes 管理容器

⚠️ 本小节为演示性步骤，建议在拥有 Kubernetes 集群的环境下操作（如 Minikube）

Kubernetes 能帮助我们自动管理容器的启动、扩容、重启等操作。

1. 创建 Deployment YAML（部署服务）

创建 article-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: article-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: article
  template:
    metadata:
      labels:
        app: article
    spec:
      containers:
      - name: article
        image: article-service
        ports:
        - containerPort: 5001

运行部署：

kubectl apply -f article-deployment.yaml

同样，为主服务创建 main-deployment.yaml 并部署。

2. 创建 Service（供外界访问）

为 article-service 创建 service：

apiVersion: v1
kind: Service
metadata:
  name: article-service
spec:
  selector:
    app: article
  ports:
    - protocol: TCP
      port: 5001
      targetPort: 5001

同样配置主服务的 service。

✨成果

通过 Kubernetes，我们可以轻松地：

  • 部署服务
  • 设置自动恢复
  • 横向扩缩容（只需改 replicas 数量）
  • 负载均衡 & 外网访问控制

这就是云原生的魅力所在。

常见问题答疑

Q1：什么时候应该考虑用微服务？

当你的项目规模变大、团队成员变多、需要灵活部署或扩展时，就可以开始考虑微服务。否则，保持单体架构更易维护。

Q2：微服务之间怎么通信？

常见做法是 HTTP 接口调用，也可以使用 gRPC、消息队列等方式。但在初期阶段，建议从 REST API 开始。

Q3：容器和虚拟机的区别？

容器比虚拟机轻量得多，它不包含操作系统，只封装应用程序和依赖，启动快、资源占用低。

Q4：学云原生必须会 Kubernetes 吗？

Kubernetes 是目前主流选择，但你也可以先熟悉 Docker，再过渡到 K8s。掌握核心思想更重要。

Q5：我该怎么调试多个微服务？

可以通过日志聚合系统（如 ELK）、分布式追踪工具（如 Jaeger）或者使用本地调试代理。

学习建议：下一步做什么？

恭喜你走完了从单体到云原生的完整路径！

接下来你可以继续深入这些方向：

1. 深入微服务生态

  • 学习 Spring Cloud、Consul、Nacos（服务发现）
  • 熟悉 OpenFeign、Ribbon（服务间通信）
  • 了解 API 网关（Gateway）

2. 掌握 DevOps 自动化流程

  • CI/CD 流程（Jenkins、GitLab CI）
  • 使用 GitHub Actions 部署容器
  • 了解 Helm（K8s 的包管理工具）

3. 学习数据库相关知识

  • 单体项目常用 SQLite、MySQL
  • 微服务中常用 PostgreSQL、MongoDB
  • 学习数据库迁移（Alembic、Flyway）

4. 深入云平台（AWS/GCP/Aliyun）

  • 如何在 AWS 上部署容器
  • 使用 ECS/EKS 替代本地 Kubernetes
  • 搭建完整的 Serverless 项目

总结

今天我们完成了：

  • 理解后端架构的核心发展脉络
  • 通过实际项目代码体验了单体 → 微服务 → 容器化 → 云原生的全过程
  • 提供了清晰的实操指引与新手常见问题解答

如果你是刚入门的新手，请记住一句话：

不要急着掌握全部细节，而是先动手做一个能跑的小项目。

只要肯实践，你就已经在成为“合格开发者”的路上！

如需本文源码或后续课程配套资料，欢迎关注公众号「码上成长」获取免费资源！

作者：张老师，从事后端开发教育工作多年，专注架构设计与工程实践教学

标签:实战经验JavascriptPython求职

评论 0

最热最新
暂无评论

为你推荐

暂无相关推荐
匿名用户Lv.1
0
影响力
0
文章
0
粉丝

相关推荐

暂无相关推荐

精选内容

暂无精选内容