從基礎到高階應用，詳解用Python實現容器化和微服務架構

华为云开发者联盟發表於2024-07-17
Python微服務架構

本文分享自華為雲社群《Python微服務與容器化實踐詳解【從基礎到高階應用】》，作者： 檸檬味擁抱。

Python中的容器化和微服務架構實踐

在現代軟體開發中，容器化和微服務架構已經成為主流。容器化技術使得應用程式可以在任何環境中一致執行，而微服務架構透過將應用拆分成多個獨立的服務，從而提升了系統的可擴充套件性和維護性。本文將介紹如何在Python中實踐容器化和微服務架構，並提供相關程式碼例項。

一、容器化概述

容器化技術主要依賴於Docker。Docker透過將應用及其依賴打包在一個獨立的環境中，確保應用在不同環境中的一致性。以下是一個簡單的Python應用Docker化的例子。

1.1 建立Python應用

首先，我們建立一個簡單的Flask應用。

# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Docker!'

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

1.2 建立Dockerfile

接下來，我們建立一個Dockerfile來定義這個應用的容器。

# 使用官方Python基礎映象
FROM python:3.9-slim

# 設定工作目錄
WORKDIR /app

# 複製當前目錄內容到工作目錄
COPY . /app

# 安裝依賴
RUN pip install flask

# 暴露應用埠
EXPOSE 5000

# 執行應用
CMD ["python", "app.py"]

1.3 構建和執行容器

構建Docker映象：

docker build -t python-flask-app .

執行容器：

docker run -d -p 5000:5000 python-flask-app

現在，可以在瀏覽器中訪問http://localhost:5000，你將看到"Hello, Docker!"。

二、微服務架構概述

微服務架構將一個單體應用拆分為多個獨立的服務，每個服務負責特定的功能。這些服務透過HTTP或訊息佇列進行通訊。以下示例展示瞭如何使用Flask構建簡單的微服務架構。

2.1 使用者服務

# user_service.py
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/users')
def get_users():
    users = [
        {'id': 1, 'name': 'Alice'},
        {'id': 2, 'name': 'Bob'}
    ]
    return jsonify(users)

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

2.2 訂單服務

# order_service.py
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/orders')
def get_orders():
    orders = [
        {'id': 1, 'item': 'Laptop', 'price': 1200},
        {'id': 2, 'item': 'Phone', 'price': 800}
    ]
    return jsonify(orders)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5002)

2.3 建立Docker Compose檔案

為了管理多個容器，我們使用Docker Compose。

# docker-compose.yml
version: '3'
services:
  user-service:
    build:
      context: .
      dockerfile: Dockerfile-user
    ports:
      - "5001:5001"
  order-service:
    build:
      context: .
      dockerfile: Dockerfile-order
    ports:
      - "5002:5002"

2.4 構建和啟動服務

構建並啟動服務：

docker-compose up --build

現在，使用者服務和訂單服務分別執行在http://localhost:5001/users和http://localhost:5002/orders。

三、服務間通訊

在微服務架構中，服務之間的通訊通常透過HTTP或訊息佇列進行。以下示例展示瞭如何使用HTTP通訊。

3.1 API閘道器

建立一個API閘道器來整合使用者服務和訂單服務。

# api_gateway.py
from flask import Flask, jsonify
import requests

app = Flask(__name__)

@app.route('/users')
def get_users():
    response = requests.get('http://user-service:5001/users')
    return jsonify(response.json())

@app.route('/orders')
def get_orders():
    response = requests.get('http://order-service:5002/orders')
    return jsonify(response.json())

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

3.2 更新Docker Compose檔案

將API閘道器新增到Docker Compose檔案中。

version: '3'
services:
  user-service:
    build:
      context: .
      dockerfile: Dockerfile-user
    ports:
      - "5001:5001"
  order-service:
    build:
      context: .
      dockerfile: Dockerfile-order
    ports:
      - "5002:5002"
  api-gateway:
    build:
      context: .
      dockerfile: Dockerfile-gateway
    ports:
      - "5000:5000"

現在，可以透過API閘道器訪問使用者服務和訂單服務：

  • 使用者服務: http://localhost:5000/users
  • 訂單服務: http://localhost:5000/orders

四、服務發現與負載均衡

在微服務架構中，服務發現和負載均衡是關鍵元件。服務發現用於跟蹤執行中的服務例項，負載均衡則在多個服務例項之間分發請求。以下示例展示瞭如何在Python微服務架構中實現服務發現和負載均衡。

4.1 使用Consul進行服務發現

Consul是一個流行的服務發現和配置工具。我們將使用Consul來註冊和發現我們的服務。

首先，啟動Consul代理：

docker run -d --name=consul -p 8500:8500 consul

4.2 註冊服務

我們需要在每個服務啟動時將其註冊到Consul。可以使用Python的requests庫進行註冊。

在user_service.py中新增註冊邏輯：

# user_service.py
import requests
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/users')
def get_users():
    users = [
        {'id': 1, 'name': 'Alice'},
        {'id': 2, 'name': 'Bob'}
    ]
    return jsonify(users)

def register_service():
    payload = {
        "ID": "user-service",
        "Name": "user-service",
        "Address": "user-service",
        "Port": 5001
    }
    requests.put('http://consul:8500/v1/agent/service/register', json=payload)

if __name__ == '__main__':
    register_service()
    app.run(host='0.0.0.0', port=5001)

在order_service.py中新增註冊邏輯：

# order_service.py
import requests
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/orders')
def get_orders():
    orders = [
        {'id': 1, 'item': 'Laptop', 'price': 1200},
        {'id': 2, 'item': 'Phone', 'price': 800}
    ]
    return jsonify(orders)

def register_service():
    payload = {
        "ID": "order-service",
        "Name": "order-service",
        "Address": "order-service",
        "Port": 5002
    }
    requests.put('http://consul:8500/v1/agent/service/register', json=payload)

if __name__ == '__main__':
    register_service()
    app.run(host='0.0.0.0', port=5002)

4.3 更新Docker Compose檔案

更新Docker Compose檔案以包含Consul服務，並確保其他服務可以訪問Consul。

version: '3'
services:
  consul:
    image: consul
    ports:
      - "8500:8500"
  user-service:
    build:
      context: .
      dockerfile: Dockerfile-user
    depends_on:
      - consul
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5001:5001"
  order-service:
    build:
      context: .
      dockerfile: Dockerfile-order
    depends_on:
      - consul
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5002:5002"
  api-gateway:
    build:
      context: .
      dockerfile: Dockerfile-gateway
    depends_on:
      - consul
      - user-service
      - order-service
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5000:5000"

4.4 實現負載均衡

為了實現負載均衡，可以使用Traefik，它是一個現代的HTTP反向代理和負載均衡器。

首先，新增Traefik到Docker Compose檔案中：

version: '3'
services:
  consul:
    image: consul
    ports:
      - "8500:8500"
  traefik:
    image: traefik:v2.5
    command:
      - "--api.insecure=true"
      - "--providers.consulcatalog=true"
      - "--entrypoints.web.address=:80"
    ports:
      - "80:80"
      - "8080:8080"
    depends_on:
      - consul
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    networks:
      - web
  user-service:
    build:
      context: .
      dockerfile: Dockerfile-user
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.user-service.rule=Host(`user-service.local`)"
      - "traefik.http.services.user-service.loadbalancer.server.port=5001"
    depends_on:
      - consul
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5001:5001"
    networks:
      - web
  order-service:
    build:
      context: .
      dockerfile: Dockerfile-order
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.order-service.rule=Host(`order-service.local`)"
      - "traefik.http.services.order-service.loadbalancer.server.port=5002"
    depends_on:
      - consul
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5002:5002"
    networks:
      - web
  api-gateway:
    build:
      context: .
      dockerfile: Dockerfile-gateway
    depends_on:
      - consul
      - user-service
      - order-service
    environment:
      - CONSUL_HTTP_ADDR=consul:8500
    ports:
      - "5000:5000"
    networks:
      - web

networks:
  web:
    external: true

現在，Traefik將自動從Consul獲取服務資訊並執行負載均衡。訪問http://user-service.local和http://order-service.local將透過Traefik進行請求分發。

五、日誌管理和監控

在微服務架構中，日誌管理和監控是確保系統健康和排查問題的重要手段。以下示例展示瞭如何在Python微服務架構中實現日誌管理和監控。

5.1 整合ELK Stack

ELK（Elasticsearch、Logstash、Kibana）是一個流行的日誌管理解決方案。我們將使用ELK Stack來收集和分析日誌。

首先，新增ELK服務到Docker Compose檔案中：

version: '3'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.13.3
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"
      - "9300:9300"
  logstash:
    image: docker.elastic.co/logstash/logstash:7.13.3
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    ports:
      - "5044:5044"
  kibana:
    image: docker.elastic.co/kibana/kibana:7.13.3
    ports:
      - "5601:5601"

5.2 配置Logstash

建立logstash.conf檔案來配置Logstash：

input {
  file {
    path => "/var/log/*.log"
    start_position => "beginning"
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
  }
}

5.3 整合Python日誌

在Python應用中整合日誌庫（如logging）並將日誌傳送到Logstash。

在user_service.py和order_service.py中新增日誌配置：

import logging

logging.basicConfig(filename='/var/log/user_service.log', level=logging.INFO)
logger = logging.getLogger(__name__)

@app.route('/users')
def get_users():
    users = [
        {'id': 1, 'name': 'Alice'},
        {'id': 2, 'name': 'Bob'}
    ]
    logger.info('Fetched users: %s', users)
    return jsonify(users)
import logging

logging.basicConfig(filename='/var/log/order_service.log', level=logging.INFO)
logger = logging.getLogger(__name__)

@app.route('/orders')
def get_orders():
    orders = [
        {'id': 1, 'item': 'Laptop', 'price': 1200},
        {'id': 2, 'item': 'Phone', 'price': 800}
    ]
    logger.info('Fetched orders: %s', orders)
    return jsonify(orders)

5.4 監控

可以使用Prometheus和Grafana進行系統監控。

首先，新增Prometheus和Grafana到Docker Compose檔案中：

version: '3'
services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"

建立prometheus.yml檔案配置Prometheus：

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'flask'
 static_configs:
      - targets: ['user-service:5001', 'order-service:5002']

六、持續整合與持續部署（CI/CD）

持續整合和持續部署（CI/CD）是現代軟體開發流程的重要組成部分。透過自動化的構建、測試和部署流程，CI/CD能夠顯著提升開發效率和軟體質量。以下是如何在Python微服務架構中實現CI/CD的示例。

6.1 使用GitHub Actions進行CI/CD

GitHub Actions是GitHub提供的CI/CD平臺，可以輕鬆整合到GitHub倉庫中。我們將使用GitHub Actions來自動化構建和部署流程。

首先，在專案根目錄下建立一個.github/workflows目錄，並在其中建立一個CI/CD配置檔案ci_cd.yml。

# .github/workflows/ci_cd.yml
name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v1

    - name: Build and push Docker images
      uses: docker/build-push-action@v2
      with:
        push: true
        tags: |
          user-service:latest
          order-service:latest
          api-gateway:latest

    - name: Deploy to Docker Hub
      env:
        DOCKER_HUB_USERNAME: ${{ secrets.DOCKER_HUB_USERNAME }}
        DOCKER_HUB_PASSWORD: ${{ secrets.DOCKER_HUB_PASSWORD }}
      run: |
        echo $DOCKER_HUB_PASSWORD | docker login -u $DOCKER_HUB_USERNAME --password-stdin
        docker push user-service:latest
        docker push order-service:latest
        docker push api-gateway:latest

6.2 配置環境變數和Secrets

為了確保安全性，我們使用GitHub Secrets儲存敏感資訊，例如Docker Hub的憑據。在GitHub倉庫中，進入Settings > Secrets and variables > Actions，新增以下Secrets：

  • DOCKER_HUB_USERNAME
  • DOCKER_HUB_PASSWORD

6.3 部署到Kubernetes

在微服務架構中，Kubernetes是一個流行的容器編排平臺。我們將使用Kubernetes部署我們的微服務。

首先，建立Kubernetes配置檔案。

# k8s/user-service.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:latest
        ports:
        - containerPort: 5001

---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5001
# k8s/order-service.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
      - name: order-service
        image: order-service:latest
        ports:
        - containerPort: 5002

---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5002
# k8s/api-gateway.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-gateway
spec:
  replicas: 2
  selector:
    matchLabels:
      app: api-gateway
  template:
    metadata:
      labels:
        app: api-gateway
    spec:
      containers:
      - name: api-gateway
        image: api-gateway:latest
        ports:
        - containerPort: 5000

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

6.4 使用kubectl部署

確保Kubernetes叢集已經配置好，並且kubectl工具可以訪問叢集。執行以下命令將服務部署到Kubernetes：

kubectl apply -f k8s/user-service.yaml
kubectl apply -f k8s/order-service.yaml
kubectl apply -f k8s/api-gateway.yaml

6.5 自動化部署

在GitHub Actions配置中新增步驟，以在推送到主分支時自動部署到Kubernetes。

- name: Set up K8s
  uses: azure/setup-kubectl@v1
  with:
    version: 'v1.18.0'

- name: Deploy to Kubernetes
  run: |
    kubectl apply -f k8s/user-service.yaml
    kubectl apply -f k8s/order-service.yaml
    kubectl apply -f k8s/api-gateway.yaml

七、故障排除和除錯

在微服務架構中，故障排除和除錯是非常重要的。我們可以透過日誌管理、分散式追蹤和除錯工具來實現。

7.1 使用Elastic Stack進行日誌管理

我們之前已經整合了Elastic Stack進行日誌管理。透過Kibana，我們可以方便地檢視和分析日誌。

7.2 使用Jaeger進行分散式追蹤

Jaeger是一個開源的端到端分散式追蹤工具。它可以幫助我們追蹤請求在各個服務中的流轉情況，方便排查效能瓶頸和故障點。

首先，新增Jaeger到Docker Compose檔案中：

version: '3'
services:
  jaeger:
    image: jaegertracing/all-in-one:1.21
    ports:
      - "6831:6831/udp"
      - "16686:16686"

在Python應用中整合Jaeger Client：

from jaeger_client import Config

def init_tracer(service):
    config = Config(
        config={
            'sampler': {'type': 'const', 'param': 1},
            'logging': True,
        },
        service_name=service,
        validate=True,
    )
    return config.initialize_tracer()

tracer = init_tracer('user-service')

透過這種方式，我們可以在Kibana中檢視日誌，在Jaeger中追蹤請求，輕鬆定位問題。

八、總結

透過本文的深入分析和實踐示例，我們詳細介紹瞭如何在Python中實現容器化和微服務架構。從基礎的Docker和Flask入門，到使用Consul進行服務發現、Traefik進行負載均衡，再到Elastic Stack日誌管理和Jaeger分散式追蹤，涵蓋了微服務架構的各個關鍵環節。透過這些實踐，開發者可以構建出高可用、高擴充套件性的微服務系統，提升開發效率和軟體質量。

點選關注，第一時間瞭解華為雲新鮮技術~

相關文章