Implementierung eines Service Mesh in Beego mit Kubernetes und Istio

Kubernetes und Istio haben sich in den letzten Jahren zu zwei unverzichtbaren Werkzeugen auf dem Weg zu Cloud-nativen Anwendungen entwickelt. Kubernetes ist ein Container-Orchestrierungstool, das Benutzern hilft, Containeranwendungen automatisch bereitzustellen, zu erweitern und zu verwalten, während Istio ein Service Mesh ist, das Benutzern eine bessere Verwaltung und Überwachung von Microservice-Architekturen ermöglicht. In diesem Artikel stellen wir vor, wie man ein Service Mesh mit Kubernetes und Istio im Beego-Framework implementiert.

Zuerst müssen wir unsere Beego-Anwendung auf Kubernetes bereitstellen. Der Einfachheit halber verwenden wir Minikube, um einen lokalen Kubernetes-Cluster auszuführen. Nach der Installation von Minikube und dem Kubernetes-Client können wir den Cluster mit dem folgenden Befehl starten:

minikube start

Dann müssen wir eine Kubernetes-Bereitstellung für die Bereitstellung unserer Beego-Anwendung erstellen. Wir können unsere Bereitstellung mithilfe der folgenden YAML-Datei definieren:

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

In dieser YAML-Datei definieren wir eine Bereitstellung namens „beego-app“ zum Ausführen unserer Beego-Anwendung, die in einem Container ausgeführt wird, und stellen den Dienst auf Port 8080 bereit.

Als nächstes müssen wir einen Kubernetes-Dienst erstellen, um von außerhalb des Kubernetes-Clusters auf unsere Beego-Anwendung zuzugreifen. Wir können unseren Dienst mithilfe der folgenden YAML-Datei definieren:

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

In dieser YAML-Datei definieren wir einen Dienst namens „beego-app-service“, der auf unsere Beego-Bereitstellung verweist und Port 80 dem Container-Port 8080 zuordnet. Darüber hinaus haben wir den Diensttyp auch als NodePort angegeben, was bedeutet, dass Kubernetes eine Knoten-IP und einen Knoten-Port für den Zugriff auf den Dienst zuweist.

Wir können nun die Bereitstellung und den Dienst erstellen, indem wir den folgenden Befehl verwenden:

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

Nach diesen Schritten ist unsere Beego-Anwendung jetzt außerhalb des Kubernetes-Clusters zugänglich. Allerdings müssen wir auch Service Discovery und Load Balancing innerhalb des Clusters implementieren.

Hier kommt Istio ins Spiel. Mit Istio können wir die Kommunikation und den Lastausgleich zwischen internen Diensten einfach implementieren. Nach der Installation von Istio in unserem Kubernetes-Cluster können wir die automatische Istio-Injektion mit dem folgenden Befehl aktivieren:

kubectl label namespace default istio-injection=enabled

Anschließend können wir einen virtuellen Istio-Dienst definieren, um HTTP-Anfragen an unsere Beego-Anwendung weiterzuleiten, indem wir die folgende YAML-Datei verwenden:

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

in In In dieser YAML-Datei definieren wir einen virtuellen Dienst namens „beego-app-virtual-service“, der HTTP-Anfragen an den zuvor erstellten Dienst „beego-app-service“ weiterleitet und ihn Port 80 zuordnet.

Wenn der virtuelle Dienst aktiviert ist, können wir jetzt innerhalb des Clusters auf unsere Beego-Anwendung zugreifen. Um unser Service Mesh jedoch besser zu verwalten, können wir auch die Überwachungs- und Tracing-Funktionen von Istio nutzen. Beispielsweise können wir mithilfe der folgenden YAML-Datei eine Istio-Zielregel definieren, um Tracking und Metriken für den gesamten ein- und ausgehenden Datenverkehr zu ermöglichen:

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

In dieser YAML-Datei definieren wir eine Istio-Zielregel mit dem Namen „beego-app-destination-rule“. Wird zum Definieren der Verkehrskontroll- und Fehlererkennungsrichtlinien von Istio verwendet.

Durch die Verwendung von Kubernetes und Istio zur Implementierung eines Service Mesh können wir unsere Microservice-Architektur besser verwalten und überwachen. In diesem Beitrag haben wir erläutert, wie wir unsere Anwendungen mithilfe von Kubernetes und Istio im Beego-Framework bereitstellen und verwalten.

Das obige ist der detaillierte Inhalt vonImplementierung eines Service Mesh in Beego mit Kubernetes und Istio. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!