通俗易懂 serverless 架构、微服务架构和云原生架构，并简单代码

Ai君臣

于 2024-08-22 11:21:48 发布

阅读量510

点赞数 4

分类专栏：架构文章标签：架构云原生 serverless

本文链接：https://blog.csdn.net/liuchenbaidu/article/details/141423354

版权

架构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

1 serverless 架构、微服务架构和云原生架构区别
2 Kubernetes 中管理多个副本和流量两个关键组件

1 serverless 架构、微服务架构和云原生架构区别

别用代码示例展示 serverless 架构、微服务架构和云原生架构的基本实现。这些示例将展示如何在这三种架构下处理一个简单的 API 请求。

1. Serverless 架构

Serverless 架构允许你运行代码而无需管理服务器或基础设施，通常通过云服务平台（如 AWS Lambda、Azure Functions）来实现。

示例：AWS Lambda + API Gateway

假设我们要实现一个简单的 API，当用户访问该 API 时，Lambda 函数将返回一个 JSON 响应。

AWS Lambda 函数代码（Python）

import json

def lambda_handler(event, context):
    # 解析请求体
    body = json.loads(event.get('body', '{}'))
    
    # 执行业务逻辑
    name = body.get('name', 'World')
    message = f"Hello, {name}!"
    
    # 返回响应
    return {
        'statusCode': 200,
        'body': json.dumps({'message': message}),
        'headers': {
            'Content-Type': 'application/json'
        }
    }

说明：

上述代码处理 HTTP 请求，并根据请求体中的 name 字段返回一个欢迎消息。
通过 API Gateway 配置 Lambda 函数触发器来处理 HTTP 请求。

2. 微服务架构

微服务 架构将应用程序拆分为多个小的、独立的服务，每个服务独立部署并通过 API 进行通信。

示例：Flask 微服务

用户服务（Flask）

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/user/<user_id>', methods=['GET'])
def get_user(user_id):
    # 模拟获取用户数据
    user_data = {"user_id": user_id, "name": "John Doe"}
    return jsonify(user_data)

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

订单服务（Flask）

from flask import Flask, jsonify
import requests

app = Flask(__name__)

@app.route('/order/<order_id>', methods=['GET'])
def get_order(order_id):
    # 调用用户服务
    user_response = requests.get(f"http://localhost:5000/user/{order_id}")
    user_data = user_response.json()
    
    # 模拟订单数据
    order_data = {"order_id": order_id, "user": user_data, "total": 99.99}
    return jsonify(order_data)

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

说明：

用户服务 提供获取用户信息的 API。
订单服务 通过调用 用户服务 的 API 获取用户信息，并返回订单数据。
这两个服务分别运行在不同的端口上，并通过 HTTP 请求进行通信。

3. 云原生架构

云原生 架构通过容器化（如 Docker）、容器编排（如 Kubernetes）和微服务来实现高效的云计算。

示例：Docker 和 Kubernetes

Dockerfile

# 使用 Python 基础镜像
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 复制代码
COPY . /app

# 安装依赖
RUN pip install flask requests

# 运行服务
CMD ["python", "app.py"]

Kubernetes Deployment YAML

用户服务部署（user-service-deployment.yaml）

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myrepo/user-service:latest
        ports:
        - containerPort: 5000

Kubernetes Service YAML

用户服务服务（user-service-service.yaml）

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000

说明：

Dockerfile 用于创建用户服务的 Docker 镜像。
Kubernetes Deployment 文件定义了如何在 Kubernetes 集群中部署 用户服务 的多个副本，并管理其生命周期。
Kubernetes Service 文件定义了如何通过集群内部的 DNS 名称访问 用户服务。

这些代码示例展示了在不同架构下如何实现相同的功能。Serverless 架构侧重于无服务器计算，微服务架构侧重于服务的独立性和可扩展性，云原生架构侧重于容器和编排的高效性。

2 Kubernetes 中管理多个副本和流量两个关键组件

在 Kubernetes 中，管理多个副本和流量通常涉及两个关键组件：

Deployment：负责管理多个副本的部署。
Service：负责将流量均匀地分发到这些副本上。

下面我将详细解释如何使用这两个组件来实现多个副本和流量管理。

1. Deployment

Deployment 是 Kubernetes 的一种控制器，用于管理应用程序的副本，确保它们按照指定的副本数运行。Deployment 可以自动处理副本的滚动更新、回滚等操作。

示例：创建一个 Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3  # 这里设置了3个副本
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: myrepo/my-app:latest
        ports:
        - containerPort: 80

解释：

replicas: 3 指定了要运行的副本数量。
selector 确定哪些 Pod 属于这个 Deployment。
template 定义了 Pod 的模板，包括容器的镜像和端口。

2. Service

Service 是 Kubernetes 中的一种资源，用于暴露应用程序的端口，并将流量负载均衡到相应的 Pod 副本上。Service 可以通过多种类型进行配置，如 ClusterIP、NodePort 和 LoadBalancer。

示例：创建一个 Service

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80          # Service 对外暴露的端口
      targetPort: 80    # 实际 Pod 中容器的端口
  type: ClusterIP  # 默认类型，仅在集群内部可访问

解释：

selector 匹配 Deployment 中定义的标签，指向相关的 Pod。
ports 映射了 Service 的端口到 Pod 中容器的端口。
type: ClusterIP 是默认设置，表示 Service 仅在集群内部可访问。如果需要外部访问，可以使用 NodePort 或 LoadBalancer 类型。

负载均衡

当多个副本部署并通过 Service 暴露时，Kubernetes 内部的负载均衡器会自动将请求均匀地分发到所有可用的副本上。这是通过 Kubernetes 的 Service 代理（kube-proxy）来实现的，它在每个节点上维护一个负载均衡表，将流量路由到对应的 Pod。

流量管理

如果你需要更高级的流量管理功能，如蓝绿部署、金丝雀发布等，可以使用以下技术：

Ingress：提供 HTTP 和 HTTPS 的路由功能，可以根据请求的 URL 路径或主机名将流量路由到不同的服务。它也支持基于流量的路由策略。

示例：Ingress 配置

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-app-service
            port:
              number: 80