Siarhei - stock.adobe.com

Anleitung: So bauen Sie einen Microservice in Kubernetes

Eine Microservices-Architektur zerlegt Anwendungen in kleine, leicht auszutauschende Komponenten. In diesem Artikel erklären wir, wie Sie das mit Kubernetes umsetzen.

Microservices zerlegen eine Anwendung in kleinere, unabhängige Teile. IT-Administratoren müssen sie dabei aber weiterhin unter Kontrolle behalten. Mit Kubernetes können sie containerisierte Microservices automatisch verwalten und skalieren.

Diese Anleitung behandelt zunächst die Vorteile von Kubernetes für Microservices, geht dann auf die technischen Schritte ein, die für das Bereitstellen von Microservices über Docker-Container erforderlich sind, und zeigt schließlich, wie man Kubernetes für die Verwaltung und Skalierung dieser Services nutzt.

Vorteile von Kubernetes für Microservices

Die Containerisierung mit Kubernetes-Orchestrierung und -Verwaltung ist darauf ausgelegt, Microservices zu unterstützen. Bevor Sie an die Arbeit gehen, sollten Sie jedoch genau überlegen, ob eine Microservices-Architektur für Ihr Projekt geeignet ist. Zu den Vorteilen gehören:

  • Selbstheilung. Wenn ein Container ausfällt oder kaputt ist, ersetzt Kubernetes ihn automatisch, um die gewünschte Zustandskonfiguration des Services und den Gesamtzustand der Anwendung zu erhalten.

  • Deklaratives Konfigurationsmanagement und Versionskontrolle. Kubernetes speichert Konfigurationen in YAML- Dateien, die sich mit Versionsmanagement-Programmen wie Git ordnen lassen. Mit den Konfigurationsdateien können Nutzer Ressourcen erstellen oder aktualisieren.

  • Multi Cloud und Hybrid Cloud. Kubernetes ermöglicht es IT-Teams, Cloud-Plattformen frei zu wählen, um auf ihnen ihre Workloads abzulegen, zum Beispiel Google Cloud Platform (GCP), Microsoft Azure oder AWS (Amazon Web Services). Sie können somit eine unerwünschte Anbieterbindung vermeiden.

  • Exposition von Services und Load Balancing Kubernetes stellt Container in Pods oder Gruppen von Pods über DNS- oder IP-Adressen zur Verfügung, damit andere Microservices diese Ressourcen nutzen können. IT-Administratoren können auch logische Pod-Gruppierungen ohne großen Aufwand einem Lastausgleich unterziehen.

  • Schutz sensibler Daten. Kubernetes hilft, die Offenlegung sensibler Informationen wie Passwörter in Container-Images zu verhindern und unterstützt geheime Objekte mit Hilfe des etcd-Datenspeichers.

  • Skalierbarkeit. Bei hoher Nachfrage oder steigender Last skaliert Kubernetes horizontal die Anzahl der Container, die einen Microservice ausführen, um Leistungsprobleme zu vermeiden.

  • Geringe Ausfallzeiten. Kubernetes-Bereitstellungen erstellen zusätzliche Pods mit einem neu freigegebenen Image, ohne die vorhandenen Container zu zerstören, um Ausfallzeiten zu vermeiden. Sobald die neuen Container funktionsfähig sind, können Teams Updates ausrollen und alte Container löschen. Wenn neue Container ausfallen, können IT-Teams die Änderungen mit minimaler Ausfallzeit zurücksetzen.

Erstellen einer golang REST API

Um mit Kubernetes für Microservices zu beginnen, erstellen wir eine REST API, die wir als Microservice in Containern auf Kubernetes bereitstellen werden.

Die Dateien, die Sie benötigen, um den Schritten zu folgen, sind in einem GitHub-Repository verfügbar. Klonen Sie das Repository mit dem folgenden Befehl, um die erforderlichen Dateien herunterzuladen:

git clone https://github.com/PrateekKumarSingh/microsvc-golang

Sobald Sie das Repository geklont haben, ändern Sie Ihren Verzeichnispfad in den Repository-Ordner, um auf die Dateien zuzugreifen.

cd .\microsvc-golang\

Dieser Ordner enthält die Datei main.go, die in Googles Sprache Go, auch golang genannt, geschrieben ist. Die Datei ermöglicht es uns, einen HTTP-Listener und Routen wie http://localhost:8080/employee zu erstellen, die als REST-Endpunkt fungieren werden. Wenn Sie Go nicht auf Ihrem lokalen System haben, laden Sie es von der golang-Webseite herunter und installieren Sie es.

Als nächstes initiieren Sie das Projekt mit dem Befehl go build, der die Datei main.go nutzt. Wenn der Build erfolgreich ist, wird eine ausführbare Datei – microsvc-golang.exe – mit dem in Abbildung 1 gezeigten Ordnernamen erzeugt.

Abbildung 1: Beim erfolgreichen Durchführen der Schritte in dieser Anleitung, erstellen Sie eine ausführbare Datei namens microsvc-golang.exe.
Abbildung 1: Beim erfolgreichen Durchführen der Schritte in dieser Anleitung, erstellen Sie eine ausführbare Datei namens microsvc-golang.exe.

Der Befehl .\microsvc-golang.exe führt die ausführbare Datei aus, erstellt den HTTP-Listener und macht den Endpunkt zugänglich. Starten Sie eine PowerShell-Konsole und verwenden Sie das Cmdlet Invoke-RestMethod auf dem Endpunkt, um Mitarbeiterdaten abzurufen, wie in Abbildung 2 gezeigt.

Invoke-RestMethod http://localhost:8080/employee

IT-Administratoren haben auch die Möglichkeit, einen curl-Befehl auf diesem Endpunkt auszuführen, der einen ähnlichen Effekt hat.

Abbildung 2: Das Invoke-RestMethod cmdlet zieht Angestellteninformationen über die PowerShell.
Abbildung 2: Das Invoke-RestMethod cmdlet zieht Angestellteninformationen über die PowerShell.

Nun ist die REST-API einsatzbereit. Sie können diesen Code auf Containern in Kubernetes jetzt bereitstellen. Um zu beginnen, erstellen Sie ein Docker-Container-Image.

Warum Microservices?

Eine Microservices-Anwendung besteht aus mehreren kleinen Diensten, von denen jeder eine bestimmte Funktion oder Anforderungen für bestimmte Aufgaben übernimmt. Dieser Aufbau schafft eine flexiblere, einfacher zu wartende und insgesamt zuverlässigere Architektur als ein eng gekoppelter monolithischer Aufbau.

Einige Vorteile der Microservices-basierten Architektur gegenüber monolithischen Anwendungen sind:

  • Schnellere Release-Zyklen. Microservices können unabhängig von der Gesamtanwendung entwickelt, aktualisiert und skaliert werden.

  • Produktivität der Entwickler. Einzelne Microservices benötigen weniger Zeit zum Aktualisieren und Testen als eine monolithische Anwendung.

  • Zusammenarbeit. Verschiedene Entwickler und Teams können gleichzeitig an verschiedenen Microservices und Komponenten arbeiten.

  • Kein Single Point of Failure. Wenn ein Microservice ausfällt, sind die restlichen Dienste immer noch in Betrieb, während bei Monolithen enge Abhängigkeiten zwischen den Diensten bestehen.

  • Skalierbarkeit. Microservices sind leicht für spezifische Anforderungen zu skalieren.

  • Wiederverwendbarkeit. Jeder Microservice führt nur eine einzelne Funktion aus, sodass er sich in verschiedene Prozesse einfügen lässt.

Containerisierung der Anwendung mit Docker

Um diesen REST-API-Code in einem Container zu verwenden, erstellen Sie Container-Images mit dem folgenden Befehl:

Get-Content .\Dockerfile

In dieser Anleitung nutzen wir Docker. Das GitHub-Repository enthält ein Dockerfile, das wie folgt aussieht:

FROM golang:1.7.4-alpine

COPY . /go/src/microsvc

RUN cd /go/src/microsvc && CGO_ENABLED=0 go install

ENV PORT 8080

EXPOSE 8080

ENTRYPOINT microsvc

Diese Datei nimmt ein bestehendes Image, in diesem Beispiel golang:1.7.4-alpine, und kopiert den Code in dieses Image. Dann wird es erstellt und auf Port 8080 exponiert. Schließlich führt der Container die Anwendung aus, um die HTTP-Listener zu starten.

Im selben Ordner können Sie mit dem Befehl docker build das Image gemäß den Anweisungen in der Docker-Datei erstellen. Mit -t können Sie das Image mit einem Namen und einer Version versehen:

docker build -t prateeksingh1590/microsvc:1.1 .

Abbildung 3: Dieser Befehlssatz setzt ein existierendes Container Image auf, legt den erstellten Code hinein und startet ihn.
Abbildung 3: Dieser Befehlssatz setzt ein existierendes Container Image auf, legt den erstellten Code hinein und startet ihn.

Sobald der Build abgeschlossen ist, verwenden Sie den folgenden Befehl, um zu überprüfen, ob das Image erstellt wurde:

docker images prateeksingh1590/microsvc:1.1

Melden Sie sich an und verschieben Sie das Image in das Docker Hub Repository, um es öffentlich verfügbar zu machen:

docker login -u prateeksingh1590

docker push prateeksingh1590/microsvc:1.1

Abbildung 4: Das Image aus diesem Tutorial ist nun öffentlich über das Docker Hub Repository verfügbar.
Abbildung 4: Das Image aus diesem Tutorial ist nun öffentlich über das Docker Hub Repository verfügbar.

Die Zeit, um den Docker Image Push abzuschließen, hängt von der Größe des Images ab. Führen Sie in der Zwischenzeit den folgenden Befehl aus, um das Docker-Image lokal zu testen:

docker run -p 8080:8080 prateeksingh1590/microsvc:1.1

Dieser Befehl führt die Go-Anwendung innerhalb des Docker-Containers aus und stellt sie auf Port 8080 bereit. Wenn der Zugriff auf den Endpunkt die gewünschte Ausgabe liefert, ist das Docker-Image betriebsbereit. Abbildung 5 zeigt die Bestätigung, dass der Endpunkt nicht verfügbar ist, wenn Sie das Docker-Image nicht in einem Container ausführen.

Abbildung 5: Die Ausgabe bestätigt, dass der Endpunkt nicht verfügbar ist, weil das Docker-Image nicht in einem Container lief.
Abbildung 5: Die Ausgabe bestätigt, dass der Endpunkt nicht verfügbar ist, weil das Docker-Image nicht in einem Container lief.

Lokales Bereitstellen des Go Microservice in Kubernetes

Nun haben wir ein funktionierendes Container-Image, das eine aktive Instanz der Go-Anwendung hostet, die innerhalb der Microservices-Architektur als REST-Endpunkt dienen kann.

Im letzten Schritt dieser Anleitung verwenden Sie das erstellte Image, um einen Container in Kubernetes als Microservice bereitzustellen.

Das geklonte GitHub-Repository enthält auch eine Deployment.yml-Datei für das Bereitstellen von Docker-Images mit Kubernetes, die wie das folgende Codebeispiel aussieht:

apiVersion: apps/v1

kind: Deployment

metadata:

  name: microsvc

  labels:

    app: microsvc

spec:

  replicas: 1

  revisionHistoryLimit: 10

  minReadySeconds: 5

  selector:

    matchLabels:

      app: microsvc

  strategy:

    type: RollingUpdate

    rollingUpdate:

      maxUnavailable: 1

      maxSurge: 2

  template:

    metadata:

      labels:

        app: microsvc

        tier: service

    spec:

      containers:

      - name: microsvc

        image: "prateeksingh1590/microsvc:1.1"

        imagePullPolicy: Always

        resources:

          requests:

            memory: "64Mi"

            cpu: "125m"

          limits:

            memory: "128Mi"

            cpu: "250m"

        ports:

        - containerPort: 8080

        readinessProbe:

          httpGet:

            path: /

            port: 8080

          initialDelaySeconds: 5

          timeoutSeconds: 5

        livenessProbe:

          httpGet:

            path: /

            port: 8080

          initialDelaySeconds: 5

          timeoutSeconds: 5       

        env:

        - name: PORT

          value: "8080"

---

apiVersion: v1

kind: Service

metadata:

  name: microsvc

  labels:

    app: microsvc

    tier: service

spec:

  type: NodePort

  ports:

  - port: 8080

  selector:

    app: microsvc

---

apiVersion: extensions/v1beta1

kind: Ingress

metadata:

  name: microsvc

  labels:

    app: microsvc

    tier: backend

spec:

  backend:

    serviceName: microsvc

    servicePort: 8080

Führen Sie den folgenden Befehl mit dem Dateinamen aus, um das erstellte Image in Containern bereitzustellen.

kubectl create -f .\deployment.yml

Sie können überprüfen, welche Container aktiv sind. Der folgende Befehl listet die Pods auf, die den REST-Endpunkt ausführen, der als Microservice auf Kubernetes läuft. Sobald der Status der Pods Running lautet, leiten Sie den Container an den lokalen Port 8080 weiter, um auf den Endpunkt zuzugreifen.

kubectl get pods

kubectl port-forward microsvc-6cff79b878-qpd7j 8080:8080

Sobald die Ports freigelegt sind, haben Sie Zugang auf die containerisierten, auf der Sprache Go basierenden REST-Endpunkte auf dem lokalen Rechner an Port 8080. Wenn Sie das Cmdlet "Invoke-RestMethod" http://127.0.0.1:8080/employee von einer PowerShell-Konsole aus ausführen, sollten die Ergebnisse wie in Abbildung 7 aussehen.

Abbildung 7: Die erfolgreiche Bereitstellung der REST API überprüfen Sie mit der PowerShell mit dem cmdlet Invoke-RestMethod.
Abbildung 7: Die erfolgreiche Bereitstellung der REST API überprüfen Sie mit der PowerShell mit dem cmdlet Invoke-RestMethod.

Außerdem können Sie einen Webbrowser starten und http://127.0.0.1:8080/employee aufrufen, um die JSON-Ergebnisse vom REST-Endpunkt des Containers anzuzeigen. Mit Kubernetes können Sie die Anzahl der Pod-Instanzen horizontal skalieren, indem Sie die Kubernetes-ReplicaSets erhöhen, so dass Sie die Bereitstellungen aktualisieren können, um sie an etwaige Anfragespitzen anzupassen.

Sie können ähnliche Microservices im Kubernetes-Cluster bereitstellen, darunter MongoDB-Datenbanken, einen Webserver oder jeden anderen REST-Endpunkt. Sobald Sie ein Netzwerk von Microservices aufgebaut haben, ist die Kommunikation zwischen ihnen ein wichtiger Aspekt.

Kommunikation zwischen Microservices auf Kubernetes

Es gibt mehrere Möglichkeiten, eine in Kubernetes laufende Anwendung zu exponieren:

Abbildung 8: Die erfolgreiche Bereitstellung der REST API können Sie ohne die PowerShell auch im Browser verifizieren.
Abbildung 8: Die erfolgreiche Bereitstellung der REST API können Sie ohne die PowerShell auch im Browser verifizieren.

Der bekannteste Ansatz ist es, einen der verschiedenen Kubernetes-Dienste zu verwenden. Sie bieten im Grunde eine Abstraktion – oder eine logische Einheit – von Pods in einem Netzwerk. Es gibt verschiedene Arten von Diensten, die unterschiedliche Funktionen erfüllen. Dazu gehören:

  • ClusterIP exponiert den Dienst auf einer clusterinternen IP und ist die Standarddienstoption von Kubernetes.
  • NodePort exponiert die Anwendung auf einer statischen IP und einem Port auf Knotenebene, sodass sie außerhalb des Clusters mit einer IP-Adress- und Port-Kombination erreichbar ist.
  • LoadBalancer stellt die Anwendung als Dienst einer in der Cloud gehosteten Load-Balancer-Komponente zur Verfügung.
  • ExternalName bildet den Dienst <IPAdresse:Port> über einen CNAME-Eintrag auf externe Adressen und Namen ab.

Für die interne Kommunikation können Sie die Dienste ClusterIP und DNS verwenden, um voll qualifizierte Domänennamen wie http://get-employee-microsvc.default.svc.cluster.local und http://new-employee-microsvc.default.svc.cluster.local zu konfigurieren, die eindeutig identifizierbar sind und auf die von innerhalb des Clusters zugegriffen werden kann.

Neben Diensten können Sie auch Kubernetes Ingress verwenden, um HTTP-/ HTTPS-Dienste extern zu exportieren.

Erfahren Sie mehr über Softwareentwicklung

ComputerWeekly.de

Close