Implémentation d'un maillage de services dans Beego à l'aide de Kubernetes et Istio

Ces dernières années, Kubernetes et Istio sont devenus deux outils indispensables sur la route des applications cloud natives. Kubernetes est un outil d'orchestration de conteneurs qui aide les utilisateurs à déployer, développer et gérer automatiquement des applications conteneurisées, tandis qu'Istio est un maillage de services qui permet aux utilisateurs de mieux gérer et surveiller les architectures de microservices. Dans cet article, nous présenterons comment implémenter un maillage de services à l'aide de Kubernetes et Istio dans le framework Beego.

Tout d'abord, nous devons déployer notre application Beego sur Kubernetes. Pour plus de commodité, nous utilisons Minikube pour exécuter un cluster Kubernetes local. Après avoir installé Minikube et le client Kubernetes, nous pouvons démarrer le cluster à l'aide de la commande suivante :

minikube start

Ensuite, nous devons créer un déploiement Kubernetes pour déployer notre application Beego. Nous pouvons définir notre déploiement à l'aide du fichier YAML suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: beego-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: beego-app
  template:
    metadata:
      labels:
        app: beego-app
    spec:
      containers:
      - name: beego-app
        image: my-beego-app-image
        ports:
        - containerPort: 8080

Dans ce fichier YAML, nous définissons un déploiement appelé "beego-app" pour exécuter notre application Beego, qui s'exécutera dans un conteneur, et exposera le service sur le port 8080.

Ensuite, nous devons créer un service Kubernetes pour accéder à notre application Beego depuis l'extérieur du cluster Kubernetes. Nous pouvons définir notre service à l'aide du fichier YAML suivant :

apiVersion: v1
kind: Service
metadata:
  name: beego-app-service
spec:
  selector:
    app: beego-app
  ports:
  - name: http
    protocol: TCP
    port: 80
    targetPort: 8080
  type: NodePort

Dans ce fichier YAML, nous définissons un service appelé "beego-app-service" qui pointera vers notre déploiement Beego et mappera le port 80 au port Container 8080. De plus, nous avons également spécifié le type de service comme NodePort, ce qui signifie que Kubernetes attribuera une adresse IP et un port de nœud pour accéder au service.

Nous pouvons maintenant créer le déploiement et le service en utilisant la commande suivante :

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Après ces étapes, notre application Beego est désormais accessible en dehors du cluster Kubernetes. Cependant, nous devons également mettre en œuvre la découverte de services et l'équilibrage de charge au sein du cluster.

C'est là qu'Istio entre en jeu. Grâce à Istio, nous pouvons facilement mettre en œuvre la communication et l'équilibrage de charge entre les services internes. Après avoir installé Istio dans le cluster Kubernetes, nous pouvons activer l'auto-injection Istio à l'aide de la commande suivante :

kubectl label namespace default istio-injection=enabled

Nous pouvons ensuite définir un service virtuel Istio pour acheminer les requêtes HTTP vers notre application Beego à l'aide du fichier YAML suivant :

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: beego-app-virtual-service
spec:
  hosts:
  - "*"
  gateways:
  - istio-system/ingressgateway
  http:
  - match:
    - uri:
        prefix: /
    route:
    - destination:
        host: beego-app-service.default.svc.cluster.local
        port:
          number: 80

dans In ce fichier YAML, nous définissons un service virtuel appelé "beego-app-virtual-service" qui achemine les requêtes HTTP vers le service "beego-app-service" que nous avons créé précédemment et le mappe au port 80.

Avec le service virtuel activé, nous pouvons désormais accéder à notre application Beego à l'intérieur du cluster. Cependant, pour mieux gérer notre maillage de services, nous pouvons également utiliser les capacités de surveillance et de traçage d’Istio. Par exemple, nous pouvons définir une règle de destination Istio à l'aide du fichier YAML suivant pour activer le suivi et les métriques de tout le trafic entrant et sortant :

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: beego-app-destination-rule
spec:
  host: beego-app-service.default.svc.cluster.local
  trafficPolicy:
    tls:
      mode: ISTIO_MUTUAL
    portLevelSettings:
    - port:
        number: 80
      tls:
        mode: ISTIO_MUTUAL
    connectionPool:
      http:
        http1MaxPendingRequests: 100
        maxRequestsPerConnection: 5
      tcp:
        maxConnections: 1000
    outlierDetection:
      consecutiveErrors: 5
      interval: 5s
      baseEjectionTime: 30s
      maxEjectionPercent: 50

Dans ce fichier YAML, nous définissons une règle de destination Istio appelée "beego-app-destination-rule". utilisé pour définir les politiques de contrôle du trafic et de détection des erreurs d'Istio.

Utiliser Kubernetes et Istio pour implémenter un maillage de services nous permet de mieux gérer et surveiller notre architecture de microservices. Dans cet article, nous avons expliqué comment déployer et gérer nos applications à l'aide de Kubernetes et Istio dans le framework Beego.

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!