La pratique du go-zero et de Kubernetes : créer une architecture de microservices conteneurisés avec une haute disponibilité, de hautes performances et une grande évolutivité

Avec l'expansion continue de l'échelle d'Internet et les besoins croissants des utilisateurs, les avantages de l'architecture des microservices reçoivent de plus en plus d'attention. Par la suite, l'architecture de microservices conteneurisés est devenue particulièrement importante, car elle peut mieux répondre aux besoins de haute disponibilité, de hautes performances, de haute évolutivité et d'autres aspects. Dans le cadre de cette tendance, go-zero et Kubernetes sont devenus les frameworks de microservices conteneurisés les plus populaires.

Cet article expliquera comment utiliser le framework go-zero et l'outil d'orchestration de conteneurs Kubernetes pour créer une architecture de microservices conteneurisés à haute disponibilité, hautes performances et haute évolutivité. Tout d’abord, comprenons brièvement les concepts de base du go-zero et de Kubernetes.

go-zero est un framework de microservices développé sur la base de Golang. Il présente les avantages de légèreté, de hautes performances, de simplicité et de facilité d'utilisation. Il prend en charge la génération automatique de code, l'intégration avec un large éventail de bibliothèques de composants et la construction rapide de microservices hautes performances.

Kubernetes est un outil d'orchestration de conteneurs portable, extensible et open source. Ses principales fonctions incluent la gestion du déploiement, de la mise à l'échelle, de l'exploitation et de la maintenance des conteneurs. Il peut grandement simplifier le processus de conteneurisation des applications et améliorer l'efficacité de la gestion et de la maintenance des applications. efficacité.

Nous commençons maintenant à présenter comment combiner ces deux outils pour créer une architecture de microservices conteneurisés à haute disponibilité, hautes performances et haute évolutivité.

Première étape : concevoir une application de microservice

Avant d'utiliser go-zero et Kubernetes pour créer une application de microservice, vous devez d'abord concevoir l'application. Étant donné qu'une des caractéristiques du framework go-zero est la capacité de générer automatiquement du code basé sur les spécifications de conception d'entrée, les spécifications de conception de l'application doivent être aussi claires que possible.

Lors de la conception d'une application, vous pouvez prendre en compte les aspects suivants :

1. Division des microservices : divisez l'application en plusieurs microservices en fonction de la logique métier de l'application.
2. Responsabilités du microservice : Déterminez les fonctions et les responsabilités de chaque microservice.
3. Conception de l'interface : définissez l'interface de chaque microservice, y compris l'entrée, la sortie, etc.
4. Conception de base de données : concevez la structure de table de base de données requise par l'application.

Étape 2 : Utilisez le framework go-zero pour générer du code de microservice

Le framework go-zero prend en charge la génération automatique de code de microservice basé sur gRPC basé sur le modèle de domaine, ce qui peut réduire considérablement le temps et la charge de travail d'écriture manuelle de code.

Lors du choix du framework go-zero pour une application, vous devez vous assurer que l'application présente les caractéristiques suivantes :

1. Communication microservice basée sur gRPC : gRPC est un RPC hautes performances, multilingue et multiplateforme. cadre efficace, sécurisé, fiable et autres caractéristiques.
2. Prend en charge la conception déclarative d'API : définissez les spécifications de l'API via Swagger2, générez la documentation de l'API et le SDK.
3. Génération automatique de code : générez automatiquement du code de microservice basé sur gRPC en fonction du modèle de domaine.

En utilisant l'outil goctl pour générer du code de microservice, l'efficacité du développement peut être considérablement améliorée. Supposons que nous souhaitions développer un microservice nommé order. La commande de code générée est la suivante :

$ goctl api new -o order

La structure des fichiers générés est la suivante :

order
├── api
│   └── order.api
├── etc
└── internal
    ├── config
    │   └── config.go
    └── logic
        ├── orderlogic.go
        └── orderlogic_test.go

Parmi eux, order.api définit la spécification API du microservice, et orderlogic.go. implémente le microservice de commande. Logique métier, config.go définit les informations de configuration du microservice.

Étape 3 : Conteneuriser les microservices

La conteneurisation des microservices est un processus nécessaire pour déployer des applications go-zero sur un cluster Kubernetes. Les applications conteneurisées peuvent être déployées et gérées de manière plus flexible, évolutive et efficace. Nous allons ensuite créer une image de conteneur pour le microservice de commande.

1. Créez un Dockerfile dans le répertoire racine de l'application pour créer l'image du conteneur.

# 基于golang的官方镜像构建
FROM golang:1.13.8-alpine

# 在容器中创建一个工作目录
RUN mkdir -p /go/src/order
WORKDIR /go/src/order

# 将当前目录下的所有文件复制到容器中的 /go/src/order 目录下
COPY . /go/src/order

# 安装go-zero框架和依赖项
RUN cd /go/src/order && 
    go get -u github.com/tal-tech/go-zero && 
    go mod download

# 构建容器镜像
RUN cd /go/src/order && 
    CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo

# 启动容器时运行的命令
CMD ["/go/src/order/order"]

2. Créez l'image du conteneur

$ docker build -t order:v1.0.0 .

3. Exécutez le conteneur

$ docker run -d -p 8080:8080 order:v1.0.0

Vous pouvez utiliser la commande curl localement pour tester si le microservice de commande fonctionne correctement.

Étape 4 : Utiliser Kubernetes pour déployer des microservices

Avant d'utiliser Kubernetes pour déployer des microservices conteneurisés, vous devez pousser les microservices vers l'entrepôt Docker.

1. Poussez l'image vers Docker Hub

$ docker tag order:v1.0.0 <dockerhub-username>/order:v1.0.0
$ docker push <dockerhub-username>/order:v1.0.0

2. Créer un déploiement

Le déploiement est utilisé pour gérer l'ensemble de répliques de pods et peut contrôler le nombre de pods, les mises à niveau de sécurité, les restaurations, etc.

Vous pouvez créer un ordre de déploiement nommé via le fichier YAML de déploiement ci-dessous.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order
spec:
  replicas: 2
  selector:
    matchLabels:
      app: order
  template:
    metadata:
      labels:
        app: order
    spec:
      containers:
      - name: order
        image: <dockerhub-username>/order:v1.0.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080

Ce fichier définit un ordre nommé de déploiement, qui comprend le nombre de copies, le nom du conteneur, l'adresse du miroir et d'autres informations.

3. Créer un service

Le service est utilisé pour acheminer les requêtes du réseau externe vers le conteneur correspondant au Pod et fournit une adresse IP statique et un nom DNS pour que le Pod puisse accéder au Pod.

Vous pouvez créer un service nommé order via le fichier YAML de service suivant.

apiVersion: v1
kind: Service
metadata:
  name: order
spec:
  selector:
    app: order
  ports:
  - name: http
    port: 8080
    protocol: TCP
    targetPort: 8080
  type: ClusterIP

Ce fichier définit un service nommé order, qui comprend le nom du service, les paramètres de port, le protocole d'accès et d'autres informations.

4. Déployer l'application

Exécutez la commande suivante pour déployer l'application.

$ kubectl apply -f order.yaml

Cette commande lira les informations de configuration de déploiement et de service à partir du fichier order.yaml et créera les objets de déploiement et de service correspondants.

Utilisez ensuite la commande suivante pour vérifier l'état du Pod.

$ kubectl get pod -l app=order

Cette commande affichera la liste des pods en cours d'exécution et leur statut.

Étape 5 : Mettre en œuvre l'équilibrage de charge et la mise à l'échelle automatique

Afin d'améliorer l'évolutivité et la fiabilité des microservices, nous devons mettre en œuvre une mise à l'échelle et un équilibrage de charge automatiques. Dans Kubernetes, Horizontal Pod Autoscaler et Service sont utilisés pour implémenter ces deux fonctions.

1. 实现负载均衡

在使用Kubernetes部署微服务时，Service用于将外部网络请求路由到Pod对应的容器中，可以提供均衡负载的功能。可以使用loadBalancer配置实现负载均衡。

可以通过下面的Service YAML文件的loadBalancer配置实现负载均衡。

apiVersion: v1
kind: Service
metadata:
  name: order
spec:
  selector:
    app: order
  ports:
  - name: http
    port: 8080
    protocol: TCP
    targetPort: 8080
  type: LoadBalancer

2. 实现自动伸缩

在Kubernetes中，使用Horizontal Pod Autoscaler（HPA）可以实现自动伸缩。HPA使用指标来监控Pod的CPU利用率和其他资源使用情况，并根据阈值进行自动扩展或缩小。

可以通过下面的HPA YAML文件来实现自动伸缩。

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: order
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60

该文件定义了一个名为order的HPA，其中包括目标Deployment、最少Pod副本数、最多Pod副本数、监控指标等信息。

第六步：应用调试和监控

在微服务应用部署后，需要对应用进行调试和监控。这可以帮助检测和解决应用中出现的问题，并对应用进行优化调整。

对于go-zero框架，可以使用goctl工具生成API文档和Swagger接口文档。由于Swagger定义了API规范，因此可以使用Swagger UI来可视化展示API接口。

对于Kubernetes，可以使用Prometheus、Grafana和ELK等工具进行集群监控和日志分析。Kubernetes还支持Ingress对象来管理HTTP/HTTPS路由，可以用Ingress-Nginx实现日志收集和代理。

结论

go-zero与Kubernetes是构建容器化微服务架构的最佳组合之一，能够提供高可用性、高性能、高扩展性等优势。在实践中，需要进行应用设计、go-zero代码生成、容器化、Kubernetes部署、负载均衡和自动伸缩等步骤，并对应用进行调试和监控。通过这些步骤，可以构建出一个高度可靠、安全、高效的微服务应用程序。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!