《后端架构演进：从单体到云原生》——给零基础初学者的入门教程

数据Tech

2025-06-23 19:54

阅读 668

开篇：后端架构是做什么的？

如果你是个刚开始接触编程的新手，可能对“后端架构”这个词感到陌生。那我们先来打个比方：

想象你在一家餐厅工作。你不需要站在前台接待客人（前端），也不需要洗碗（数据库管理），而是主要负责做菜（处理业务逻辑）和设计菜单（数据结构）。在软件开发中，后端开发者就相当于这家餐厅的主厨。

而所谓的后端架构，就是厨房怎么布局、厨师如何协作、食材怎么采购、订单怎么分发等一整套组织方式。它影响着整个系统的稳定性、扩展性与效率。

这篇文章会带你从最简单的模式出发，一步一步了解后端架构的发展历程，并亲手搭建一个简单的项目，帮助你理解这些概念到底意味着什么。

环境准备：你需要安装哪些工具？

开始学习之前，我们需要准备好一套基础开发环境。别担心，这些都是免费、开源且社区活跃的工具。

所需工具列表：

工具	用途
VS Code / IntelliJ IDEA	编写代码
Node.js + NPM	运行JavaScript后端服务
Docker Desktop	本地运行容器化应用
Postman	测试接口
Git	版本控制
GitHub 账号	存储代码

步骤1：安装Node.js

前往 https://nodejs.org 下载 LTS 版本（推荐长期支持版本）。

验证是否安装成功：

node -v
npm -v

如果出现类似 v18.x.x 和 9.x.x 的版本号，说明安装成功。

步骤2：安装Docker

前往 https://www.docker.com/products/docker-desktop/ 下载适合你系统的 Docker Desktop 客户端，并安装启动。

验证Docker是否正常运行：

docker --version
docker run hello-world

如果有输出信息“Hello from Docker!”，表示你的Docker已经准备好了。

步骤3：安装Postman

访问 https://www.postman.com/downloads/，下载并安装桌面版。

核心概念：后端架构演进的几个关键阶段

我们将从最原始的架构讲起，逐步过渡到现代流行的云原生架构。

阶段一：单体架构（Monolithic Architecture）

是什么？

所有功能都放在一个程序里，比如一个 .exe 文件或一个 .jar 文件。
修改任何部分，都要重新部署整个系统。

示例项目：创建一个简单的Node.js单体服务

我们先用 Express 框架创建一个非常简单的 Web 服务：

步骤1：初始化项目

mkdir monolith-app
cd monolith-app
npm init -y
npm install express

步骤2：创建 `app.js` 文件

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('你好！这里是单体架构的首页！');
});

app.listen(port, () => {
  console.log(`服务器运行在 http://localhost:${port}`);
});

步骤3：运行服务

node app.js

打开浏览器，访问 http://localhost:3000，你应该能看到页面显示 “你好！这里是单体架构的首页！”

阶段二：模块化架构（Modular Architecture）

是什么？

把一个大程序拆成多个模块（比如用户模块、商品模块），但它们仍然运行在一个服务中。

示例：把上面的单体程序进行模块化改造

目录结构调整如下：

monolith-app/
├── modules
│   └── greeting.js
├── app.js
└── package.json

创建 `modules/greeting.js`

module.exports = {
  sayHi: () => "欢迎来到模块化时代！"
};

改造 `app.js`

const express = require('express');
const app = express();
const greeting = require('./modules/greeting');

app.get('/', (req, res) => {
  res.send(greeting.sayHi());
});

app.listen(3000, () => {
  console.log('模块化服务已启动');
});

再次运行 node app.js，刷新页面就能看到新消息。

阶段三：微服务架构（Microservices Architecture）

是什么？

每个功能模块都作为一个独立的服务运行，通过网络互相通信。
可以分别开发、部署、升级，互不影响。

示例：创建两个微服务

我们创建两个服务：用户服务（User Service）、问候服务（Greeting Service）

1. 创建问候服务（greeting-service）

mkdir greeting-service
cd greeting-service
npm init -y
npm install express

echo '
const express = require("express");
const app = express();

app.get("/", (req, res) => {
  res.send("来自问候服务的消息：你好！");
});

app.listen(3001, () => {
  console.log("问候服务正在运行于端口 3001");
});
' > index.js

node index.js

现在你可以访问 http://localhost:3001 看到内容。

2. 创建用户服务（user-service），调用问候服务

mkdir user-service
cd user-service
npm init -y
npm install express axios

echo '
const express = require("express");
const axios = require("axios");
const app = express();

app.get("/user", async (req, res) => {
  try {
    const response = await axios.get("http://localhost:3001/");
    res.send("用户请求收到：" + response.data);
  } catch (error) {
    res.status(500).send("服务调用失败");
  }
});

app.listen(3002, () => {
  console.log("用户服务正在运行于端口 3002");
});
' > index.js

node index.js

访问 http://localhost:3002/user，你应该能看到来自问候服务的结果。

这就是典型的微服务间通信。

阶段四：容器化 + 编排（Docker + Kubernetes）

是什么？

使用 Docker 把每个服务打包成镜像。
使用 Kubernetes 来统一管理这些服务的部署、扩容和故障恢复。

示例：将上面的两个服务容器化

创建 `greeting-service/Dockerfile`

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3001
CMD ["node", "index.js"]

构建镜像并运行：

cd greeting-service
docker build -t greeting-svc .
docker run -p 3001:3001 greeting-svc

同样，为 user-service 做同样的操作，创建以下 Dockerfile：

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3002
CMD ["node", "index.js"]

然后构建并运行：

cd user-service
docker build -t user-svc .
docker run -p 3002:3002 user-svc

这时候你依然可以使用之前的地址访问这两个服务。

小提示：实际开发中我们通常会用 Docker Compose 来同时启动多个容器，这里就不展开讲了。

阶段五：云原生架构（Cloud Native）

是什么？

利用云平台的能力（如 AWS、阿里云、腾讯云、Google Cloud）自动伸缩、负载均衡、日志分析等功能。
强调 DevOps、自动化部署、监控和弹性伸缩。

虽然完整实现云原生较为复杂，但我们可以通过一些简单的实践了解它的特点。

比如使用 GitHub Actions 实现自动部署：

将你的代码推送到 GitHub 仓库；
创建 .github/workflows/deploy.yml 文件；
设置当 push 到 main 分支时自动部署。

GitHub Actions 配置示例（简化版）：

name: Deploy App
on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '18'

      - name: Install dependencies and build
        run: |
          npm install
          npm run build

      - name: Run container
        run: |
          docker build -t myapp .
          docker run -d -p 3000:3000 myapp

这个流程就模拟了一个最基本的 CI/CD（持续集成 / 持续部署）过程。

实战项目：一步步做一个云原生风格的小型博客系统

我们来一起完成一个实战小项目：一个简单的博客系统。

目标功能：

用户可以发布文章
文章展示页
使用微服务架构，拆分为 API 服务和前端服务

第一步：创建API服务（Node.js）

新建文件夹 blog-api，并在其中创建如下文件：

// blog-api/index.js
const express = require('express');
const app = express();
let posts = [];

app.use(express.json());

app.get('/posts', (req, res) => {
  res.json(posts);
});

app.post('/posts', (req, res) => {
  const post = req.body;
  posts.push(post);
  res.status(201).json(post);
});

app.listen(3000, () => {
  console.log('博客API服务启动在3000端口');
});

运行：

cd blog-api
npm init -y
npm install express
node index.js

使用 Postman 测试一下 POST 请求是否能够成功添加文章。

第二步：创建前端服务（HTML静态页）

新建文件夹 blog-ui，在其中创建 index.html：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>我的博客</title>
</head>
<body>
  <h1>发布一篇文章</h1>
  <form id="postForm">
    <input type="text" id="title" placeholder="标题" required />
    <br/>
    <textarea id="content" placeholder="内容"></textarea>
    <button type="submit">提交</button>
  </form>

  <h2>所有文章</h2>
  <ul id="postList"></ul>

  <script>
    document.getElementById("postForm").addEventListener("submit", async function(e) {
      e.preventDefault();
      const title = document.getElementById("title").value;
      const content = document.getElementById("content").value;

      const res = await fetch("http://localhost:3000/posts", {
        method: "POST",
        headers: {"Content-Type": "application/json"},
        body: JSON.stringify({title, content})
      });

      if (res.ok) {
        alert("发布成功！");
        loadPosts();
      }
    });

    async function loadPosts() {
      const res = await fetch("http://localhost:3000/posts");
      const posts = await res.json();
      const list = document.getElementById("postList");
      list.innerHTML = "";
      posts.forEach(p => {
        const li = document.createElement("li");
        li.textContent = p.title + ": " + p.content;
        list.appendChild(li);
      });
    }

    loadPosts();
  </script>
</body>
</html>

你可以使用任意 HTTP 服务器（例如 Live Server 插件）在浏览器中运行该 HTML 页面。

这样你就完成了一个最简的前后端分离博客系统！

常见问题解答（FAQ）

Q1：微服务之间怎么通信？为什么要这么麻烦？

答：微服务各自独立运行，它们之间靠 HTTP 或 gRPC 协议通信。这样做可以让每个服务灵活扩展、方便维护，但也增加了网络调用的复杂度。所以我们会配合 API网关、服务注册发现等机制来解决这些问题。

Q2：Docker 有什么好处？我为什么不能直接运行程序？

答：Docker 给你一个标准化的“盒子”，无论在哪台机器上跑程序，只要盒子一致，就不会出错。特别适合团队协作和生产上线。

Q3：学完这些，我能不能去找工作？

答：这是入门的第一步。要胜任初级后端开发岗位，还需要掌握数据库、权限控制、RESTful 接口设计、Git 协作等内容。后面我会给出学习建议。

学习建议：接下来应该学什么？

完成了这篇教程，恭喜你迈出了成为后端工程师的第一步。接下来建议你继续学习以下几个方向：

方向1：数据库与持久层

学习 MySQL / MongoDB 基础
ORM 框架使用（如 TypeORM、Sequelize）
设计合理的数据模型

方向2：RESTful API 设计规范

掌握状态码（如 200、404、500）
URL命名规则（资源导向式）
认证机制（JWT）

方向3：DevOps & 自动化部署

学习 Git 分支管理
掌握 CI/CD 工具（如 Jenkins、GitHub Actions）
了解 Docker Compose、Kubernetes 入门

方向4：深入后端框架

选择一种主流语言进一步深造，如 Java(Spring Boot)、Python(Django/Flask)、Go(Fiber/gin)
掌握中间件（如 Redis、MQ）

总结

通过这篇文章，你已经了解了后端架构的发展历史，并亲手实践了从单体应用到云原生服务的演变过程。每一个步骤我们都尽可能用最简单的例子来演示真实场景，让你能真正理解这些“高大上的术语”。

记住一句话：最好的学习方法是动手实践。希望你能继续深入研究，最终成为一名合格的后端开发工程师！

📌 附：配套练习源码仓库（虚构示例）

https://github.com/example/backend-evolution-demo
包含每个阶段的完整项目代码，适合对照练习

📌 扩展阅读推荐：

《云原生101》 – CNCF 官方文档
《深入浅出Node.js》 – 国内经典Node书籍
《Kubernetes权威指南》 – 容器编排圣经

祝你学习愉快，早日写出自己的“云原生”作品！🚀

标签:Python运营开发心得实战经验

最热最新

暂无评论

为你推荐

暂无相关推荐

《后端架构演进：从单体到云原生》——给零基础初学者的入门教程

开篇：后端架构是做什么的？

环境准备：你需要安装哪些工具？

所需工具列表：

步骤1：安装Node.js

步骤2：安装Docker

步骤3：安装Postman

核心概念：后端架构演进的几个关键阶段

阶段一：单体架构（Monolithic Architecture）

是什么？

示例项目：创建一个简单的Node.js单体服务

步骤1：初始化项目

步骤2：创建 app.js 文件

步骤3：运行服务

阶段二：模块化架构（Modular Architecture）

是什么？

示例：把上面的单体程序进行模块化改造

目录结构调整如下：

创建 modules/greeting.js

改造 app.js

阶段三：微服务架构（Microservices Architecture）

是什么？

示例：创建两个微服务

1. 创建问候服务（greeting-service）

2. 创建用户服务（user-service），调用问候服务

阶段四：容器化 + 编排（Docker + Kubernetes）

是什么？

示例：将上面的两个服务容器化

创建 greeting-service/Dockerfile

阶段五：云原生架构（Cloud Native）

是什么？

实战项目：一步步做一个云原生风格的小型博客系统

第一步：创建API服务（Node.js）

第二步：创建前端服务（HTML静态页）

常见问题解答（FAQ）

Q1：微服务之间怎么通信？为什么要这么麻烦？

Q2：Docker 有什么好处？我为什么不能直接运行程序？

Q3：学完这些，我能不能去找工作？

学习建议：接下来应该学什么？

方向1：数据库与持久层

方向2：RESTful API 设计规范

方向3：DevOps & 自动化部署

方向4：深入后端框架

推荐学习路径图：

总结

评论 0

为你推荐

相关推荐

精选内容

步骤2：创建 `app.js` 文件

创建 `modules/greeting.js`

改造 `app.js`

创建 `greeting-service/Dockerfile`