Anleitung: So bauen Sie einen Microservice in Kubernetes

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.

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.

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.

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 .

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

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.

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.

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:

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.