TOC

Bereitstellen einer ausfallsicheren Go-Anwendung für DigitalOcean Kubernetes

Der Autor hat Girls Who Code ausgewählt, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten .

Einführung

Docker ist ein containerization -Tool, mit dem Anwendungen mit einem Dateisystem ausgestattet werden, das alles enthält, was sie zum Ausführen benötigen, um dies zu gewährleisten Die Software verfügt über eine konsistente Laufzeitumgebung und verhält sich unabhängig vom Einsatzort gleich. Kubernetes ist eine Cloud-Plattform zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen.

Indem Sie Docker nutzen, können Sie eine Anwendung auf jedem System bereitstellen, das Docker unterstützt, mit der Gewissheit, dass sie immer wie vorgesehen funktioniert. Mit Kubernetes können Sie Ihre Anwendung auf mehreren Knoten in einem Cluster bereitstellen. Darüber hinaus werden wichtige Aufgaben ausgeführt, z. B. das Aufrufen neuer Container, falls einer Ihrer Container abstürzt. Zusammen optimieren diese Tools den Prozess der Bereitstellung einer Anwendung, sodass Sie sich auf die Entwicklung konzentrieren können.

In diesem Lernprogramm erstellen Sie eine Beispielanwendung, die in Go geschrieben ist, und führen sie lokal auf Ihrem Entwicklungscomputer aus. Anschließend packen Sie die Anwendung mit Docker in einen Container, stellen sie in einem Kubernetes-Cluster bereit und erstellen einen Lastenausgleich, der als öffentlicher Einstiegspunkt für Ihre Anwendung dient.

Voraussetzungen

Bevor Sie mit diesem Lernprogramm beginnen, benötigen Sie Folgendes:

  • Ein Entwicklungsserver oder ein lokaler Computer, von dem aus Sie die Anwendung bereitstellen. Obwohl die Anweisungen in diesem Handbuch für die meisten Betriebssysteme weitgehend funktionieren, wird in diesem Lernprogramm davon ausgegangen, dass Sie Zugriff auf ein Ubuntu 18.04-System haben, das mit einem Benutzer ohne Rootberechtigung mit Sudo-Berechtigungen konfiguriert ist, wie in unserer https://www.digitalocean.com beschrieben / community / tutorials / initiales-server-setup-mit-ubuntu-18-04 [Erstes Server-Setup für Ubuntu 18.04] Tutorial.

  • Das auf Ihrem Entwicklungscomputer installierte Befehlszeilentool "+ docker +". Befolgen Sie dazu die * Schritte 1 und 2 * unseres Tutorials unter How Installieren und Verwenden von Docker unter Ubuntu 18.04.

  • Das Befehlszeilentool "+ kubectl +", das auf Ihrem Entwicklungscomputer installiert ist. Um dies zu installieren, folgen Sie dieses Handbuch aus der offiziellen Kubernetes-Dokumentation.

  • Ein kostenloses Konto in Docker Hub, auf das Sie Ihr Docker-Image übertragen. Besuchen Sie zum Einrichten die Website Docker Hub, klicken Sie oben rechts auf der Seite auf die Schaltfläche * Erste Schritte * und befolgen Sie die Registrierungsanweisungen.

  • Ein Kubernetes-Cluster. Sie können eine DigitalOcean Kubernetes cluster bereitstellen, indem Sie der Kubernetes Quickstart guide folgen. Sie können dieses Lernprogramm weiterhin ausführen, wenn Sie Ihren Cluster von einem anderen Cloud-Anbieter bereitstellen. Richten Sie immer eine Konfigurationsdatei ein, und stellen Sie sicher, dass Sie von Ihrem Entwicklungsserver aus eine Verbindung zum Cluster herstellen können.

Schritt 1 - Erstellen einer Beispielwebanwendung in Go

In diesem Schritt erstellen Sie eine in Go geschriebene Beispielanwendung. Sobald Sie diese App mit Docker gepackt haben, wird "+ My Awesome Go App " als Antwort auf Anfragen an die IP-Adresse Ihres Servers an Port " 3000 +" bereitgestellt.

Aktualisieren Sie zunächst die Paketlisten Ihres Servers, falls Sie dies noch nicht getan haben:

sudo apt update

Installieren Sie dann Go, indem Sie Folgendes ausführen:

sudo apt install golang

Stellen Sie als Nächstes sicher, dass Sie sich in Ihrem Ausgangsverzeichnis befinden, und erstellen Sie ein neues Verzeichnis, das alle Ihre Projektdateien enthält:

cd && mkdir go-app

Navigieren Sie dann zu diesem neuen Verzeichnis:

cd go-app/

Verwenden Sie "+ nano " oder Ihren bevorzugten Texteditor, um eine Datei mit dem Namen " main.go +" zu erstellen, die den Code für Ihre Go-Anwendung enthält:

nano main.go

Die erste Zeile in einer Go-Quelldatei ist immer eine "+ package " - Anweisung, die definiert, zu welchem ​​Code-Bundle die Datei gehört. Für ausführbare Dateien wie diese muss die Anweisung " package" auf das Paket "+ main" verweisen:

go-app / main.go

Fügen Sie anschließend eine "+ import " - Anweisung hinzu, in der Sie alle Bibliotheken auflisten können, die die Anwendung benötigt. Hierzu gehören " fmt ", das die formatierte Texteingabe und -ausgabe verarbeitet, und " net / http +", das HTTP-Client- und Serverimplementierungen bereitstellt:

go-app / main.go

package main

Definieren Sie als nächstes eine "+ homePage " - Funktion, die zwei Argumente akzeptiert: " http.ResponseWriter " und einen Zeiger auf " http.Request ". In Go wird eine " ResponseWriter" -Schnittstelle zum Erstellen einer HTTP-Antwort verwendet, während "+ http.Request" ein Objekt ist, das eine eingehende Anforderung darstellt. Somit liest dieser Block eingehende HTTP-Anforderungen und erstellt dann eine Antwort:

go-app / main.go

. . .

import (
 "fmt"
 "net/http"
)

Fügen Sie danach eine "+ setupRoutes " - Funktion hinzu, die eingehende Anforderungen ihren vorgesehenen HTTP-Handlerfunktionen zuordnet. Fügen Sie im Hauptteil dieser Funktion " setupRoutes " eine Zuordnung der Route " / " zu Ihrer neu definierten Funktion " homePage " hinzu. Dies weist die Anwendung an, die Meldung " My Awesome Go App +" auch für Anfragen an unbekannte Endpunkte zu drucken:

go-app / main.go

. . .

func homePage(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "My Awesome Go App")
}

Fügen Sie abschließend die folgende Funktion hinzu: "+ main ". Dadurch wird eine Zeichenfolge ausgedruckt, die angibt, dass Ihre Anwendung gestartet wurde. Anschließend wird die Funktion " setupRoutes " aufgerufen, bevor Ihre Go-Anwendung an Port " 3000 +" abgehört und ausgeführt wird.

go-app / main.go

. . .

func setupRoutes() {
 http.HandleFunc("/", homePage)
}

Nach dem Hinzufügen dieser Zeilen sieht die endgültige Datei folgendermaßen aus:

go-app / main.go

package main

import (
 "fmt"
 "net/http"
)

func homePage(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "My Awesome Go App")
}

func setupRoutes() {
 http.HandleFunc("/", homePage)
}

func main() {
 fmt.Println("Go Web App Started on Port 3000")
 setupRoutes()
 http.ListenAndServe(":3000", nil)
}

Speichern und schließen Sie diese Datei. Wenn Sie diese Datei mit + nano + erstellt haben, drücken Sie dazu + STRG + X +, + Y + und dann + ENTER +.

Führen Sie anschließend die Anwendung mit dem folgenden Befehl + go run + aus. Dadurch wird der Code in Ihrer + main.go + - Datei kompiliert und lokal auf Ihrem Entwicklungscomputer ausgeführt:

go run main.go
OutputGo Web App Started on Port 3000

Diese Ausgabe bestätigt, dass die Anwendung wie erwartet funktioniert. Es wird jedoch auf unbestimmte Zeit ausgeführt. Schließen Sie es, indem Sie die Tastenkombination STRG + C + drücken.

In diesem Handbuch verwenden Sie diese Beispielanwendung, um mit Docker und Kubernetes zu experimentieren. Lesen Sie zu diesem Zweck weiter, um zu erfahren, wie Sie Ihre Anwendung mit Docker containerisieren können.

Schritt 2 - Andocken Ihrer Go-Anwendung

Im aktuellen Status wird die gerade erstellte Go-Anwendung nur auf Ihrem Entwicklungsserver ausgeführt. In diesem Schritt machen Sie diese neue Anwendung portabel, indem Sie sie mit Docker containerisieren. Auf diese Weise kann es auf jedem Computer ausgeführt werden, der Docker-Container unterstützt. Sie erstellen ein Docker-Image und verschieben es in ein zentrales öffentliches Repository in Docker Hub. Auf diese Weise kann Ihr Kubernetes-Cluster das Image zurückziehen und als Container innerhalb des Clusters bereitstellen.

Der erste Schritt zur Containerisierung Ihrer Anwendung besteht darin, ein spezielles Skript mit dem Namen Dockerfile zu erstellen. Eine Docker-Datei enthält normalerweise eine Liste von Anweisungen und Argumenten, die in sequenzieller Reihenfolge ausgeführt werden, um bestimmte Aktionen für ein Basis-Image automatisch auszuführen oder ein neues Image zu erstellen.

Erstellen Sie eine neue Datei mit dem Namen "+ Dockerfile +":

nano Dockerfile

Geben Sie oben in der Datei das für die Go-App erforderliche Basisimage an:

go-app / Dockerfile

Erstellen Sie anschließend ein "+ app +" - Verzeichnis im Container, das die Quelldateien der Anwendung enthält:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9

Fügen Sie darunter die folgende Zeile ein, die alles aus dem Verzeichnis + root + in das Verzeichnis + app + kopiert:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app

Fügen Sie als nächstes die folgende Zeile hinzu, die das Arbeitsverzeichnis in "+ app +" ändert, was bedeutet, dass alle folgenden Befehle in dieser Docker-Datei von diesem Ort aus ausgeführt werden:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app

Fügen Sie eine Zeile hinzu, die Docker anweist, den Befehl + go build -o main + auszuführen, mit dem die ausführbare Binärdatei der Go-App kompiliert wird:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app
WORKDIR /app

Fügen Sie dann die letzte Zeile hinzu, in der die ausführbare Binärdatei ausgeführt wird:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app
WORKDIR /app
RUN go build -o main .

Speichern und schließen Sie die Datei, nachdem Sie diese Zeilen hinzugefügt haben.

Nachdem Sie diese Docker-Datei im Stammverzeichnis Ihres Projekts haben, können Sie mit dem folgenden Befehl ein Docker-Image erstellen, das darauf basiert. Dieser Befehl enthält das Flag "+ -t ", das bei Übergabe des Werts " go-web-app " das Docker-Image " go-web-app +" und tag it benennt.

Das letzte Argument, das Sie übergeben, ist der Pfad: ". +". Dies gibt an, dass Sie das Docker-Image aus dem Inhalt des aktuellen Arbeitsverzeichnisses erstellen möchten. Stellen Sie außerdem sicher, dass "+" auf Ihren Docker Hub-Benutzernamen aktualisiert wird:

docker build -t /go-web-app .

Dieser Build-Befehl liest alle Zeilen in Ihrer Docker-Datei, führt sie der Reihe nach aus und speichert sie im Cache, sodass zukünftige Builds viel schneller ausgeführt werden können:

Output. . .
Successfully built
Successfully tagged go-web-app:latest

Sobald dieser Befehl fertig ist, können Sie Ihr Bild sehen, wenn Sie den Befehl + docker images + wie folgt ausführen:

docker images
OutputREPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
/go-web-app   latest                      3 seconds ago       355MB

Verwenden Sie als Nächstes den folgenden Befehl, um einen Container basierend auf dem soeben erstellten Image zu erstellen und zu starten. Dieser Befehl enthält das Flag "+ -it ", das angibt, dass der Container im interaktiven Modus ausgeführt wird. Es hat auch die Markierung " -p ", die den Port, auf dem die Go-Anwendung auf Ihrem Entwicklungscomputer ausgeführt wird - Port " 3000 " - auf Port " 3000 +" in Ihrem Docker-Container abbildet:

docker run -it -p 3000:3000 /go-web-app
OutputGo Web App Started on Port 3000

Wenn auf diesem Port nichts anderes ausgeführt wird, können Sie die Anwendung in Aktion sehen, indem Sie einen Browser öffnen und zur folgenden URL navigieren:

http://:3000

image: https://assets.digitalocean.com/articles/resilient_go_kubernetes/resilient_screenshot_1.png [Ihre containerisierte Go-App]

Nachdem Sie überprüft haben, ob die Anwendung in Ihrem Browser wie erwartet funktioniert, beenden Sie sie, indem Sie auf Ihrem Terminal die Tastenkombination STRG + C + drücken.

Wenn Sie Ihre containerisierte Anwendung in Ihrem Kubernetes-Cluster bereitstellen, müssen Sie in der Lage sein, das Image von einem zentralen Speicherort abzurufen. Zu diesem Zweck können Sie Ihr neu erstelltes Image in Ihr Docker Hub-Image-Repository verschieben.

Führen Sie den folgenden Befehl aus, um sich von Ihrem Terminal aus bei Docker Hub anzumelden:

docker login

Daraufhin werden Sie zur Eingabe Ihres Docker Hub-Benutzernamens und -Kennworts aufgefordert. Nach korrekter Eingabe wird in der Ausgabe des Befehls "+ Anmeldung erfolgreich +" angezeigt.

Schieben Sie nach dem Anmelden Ihr neues Image mit dem Befehl + docker push + auf Docker Hub:

docker push /go-web-app

Sobald dieser Befehl erfolgreich ausgeführt wurde, können Sie Ihr Docker Hub-Konto eröffnen und dort Ihr Docker-Image anzeigen.

Nachdem Sie Ihr Image an einen zentralen Ort verschoben haben, können Sie es in Ihrem Kubernetes-Cluster bereitstellen. Zunächst werden wir jedoch einen kurzen Prozess durchlaufen, der die Ausführung von + kubectl + - Befehlen erheblich vereinfacht.

Schritt 3 - Verbesserung der Benutzerfreundlichkeit für + kubectl +

Zu diesem Zeitpunkt haben Sie eine funktionsfähige Go-Anwendung erstellt und diese mit Docker gepackt. Die Anwendung ist jedoch immer noch nicht öffentlich zugänglich. Um dieses Problem zu beheben, stellen Sie Ihr neues Docker-Image mit dem Befehlszeilentool + kubectl + in Ihrem Kubernetes-Cluster bereit. Bevor Sie dies tun, nehmen Sie eine kleine Änderung an der Kubernetes-Konfigurationsdatei vor, um die Ausführung von "+ kubectl +" - Befehlen zu vereinfachen.

Wenn Sie Befehle mit dem Befehlszeilentool "+ kubectl " ausführen, müssen Sie den Pfad der Cluster-Konfigurationsdatei standardmäßig mit dem Flag " - kubeconfig " angeben. Wenn Ihre Konfigurationsdatei jedoch den Namen " config " trägt und in einem Verzeichnis mit dem Namen " ~ / .kube " gespeichert ist, weiß " kubectl +", wo Sie nach der Konfigurationsdatei suchen müssen, und kann diese ohne das "" abrufen + - kubeconfig + `Fahne zeigt darauf.

Erstellen Sie zu diesem Zweck, falls Sie dies noch nicht getan haben, ein neues Verzeichnis mit dem Namen "+ ~ / .kube +":

mkdir ~/.kube

Verschieben Sie dann Ihre Cluster-Konfigurationsdatei in dieses Verzeichnis und benennen Sie sie dabei in "+ config +" um:

mv .yaml ~/.kube/config

In Zukunft müssen Sie den Speicherort der Konfigurationsdatei Ihres Clusters nicht mehr angeben, wenn Sie "+ kubectl " ausführen, da der Befehl sie jetzt am Standardspeicherort finden kann. Testen Sie dieses Verhalten, indem Sie den folgenden Befehl ` get nodes +` ausführen:

kubectl get nodes

Dadurch werden alle Nodes angezeigt, die sich in Ihrem Kubernetes-Cluster befinden. Im Kontext von Kubernetes ist ein Knoten ein Server oder ein Arbeitscomputer, auf dem ein oder mehrere Pods bereitgestellt werden können:

OutputNAME                                        STATUS    ROLES     AGE       VERSION
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfd   Ready     <none>    1m        v1.13.5
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfi   Ready     <none>    1m        v1.13.5
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfv   Ready     <none>    1m        v1.13.5

Damit können Sie fortfahren und Ihre Anwendung auf Ihrem Kubernetes-Cluster bereitstellen. Dazu erstellen Sie zwei Kubernetes-Objekte: eines, mit dem die Anwendung für einige Pods in Ihrem Cluster bereitgestellt wird, und eines, mit dem ein Lastenausgleich erstellt wird, der einen Zugriffspunkt für Ihre Anwendung bereitstellt.

Schritt 4 - Erstellen einer Bereitstellung

RESTful resources bilden alle persistenten Entitäten in einem Kubernetes-System und werden in diesem Zusammenhang allgemein als Kubernetes objects bezeichnet. Es ist hilfreich, sich Kubernetes-Objekte als Arbeitsaufträge vorzustellen, die Sie an Kubernetes senden: Sie listen auf, welche Ressourcen Sie benötigen und wie sie funktionieren sollen, und dann wird Kubernetes ständig arbeiten, um sicherzustellen, dass sie in Ihrem Cluster vorhanden sind.

Eine Art von Kubernetes-Objekt, das als "Deployment" bezeichnet wird, ist eine Reihe identischer, nicht unterscheidbarer Hülsen. In Kubernetes ist ein pod eine Gruppierung von einem oder mehreren Containern, die über dasselbe freigegebene Netzwerk kommunizieren und mit demselben freigegebenen Speicher interagieren können . Eine Bereitstellung führt mehr als ein Replikat der übergeordneten Anwendung gleichzeitig aus und ersetzt automatisch alle fehlgeschlagenen Instanzen, um sicherzustellen, dass Ihre Anwendung immer für Benutzeranforderungen verfügbar ist.

In diesem Schritt erstellen Sie eine Kubernetes-Objektbeschreibungsdatei, auch als "Manifest" bezeichnet, für eine Bereitstellung. Dieses Manifest enthält alle Konfigurationsdetails, die zum Bereitstellen der Go-App auf Ihrem Cluster erforderlich sind.

Beginnen Sie mit der Erstellung eines Bereitstellungsmanifests im Stammverzeichnis Ihres Projekts: + go-app / +. Bei kleinen Projekten wie diesem wird die Komplexität minimiert, wenn sie im Stammverzeichnis gespeichert werden. Bei größeren Projekten kann es jedoch hilfreich sein, Ihre Manifeste in einem separaten Unterverzeichnis zu speichern, um die Organisation zu gewährleisten.

Erstellen Sie eine neue Datei mit dem Namen "+ deployment.yml +":

nano deployment.yml

Verschiedene Versionen der Kubernetes-API enthalten unterschiedliche Objektdefinitionen. Daher müssen Sie oben in dieser Datei das "+ apiVersion " definieren, mit dem Sie dieses Objekt erstellen. In diesem Lernprogramm verwenden Sie die Gruppierung " apps / v1 ", da sie viele der wichtigsten Kubernetes-Objektdefinitionen enthält, die Sie zum Erstellen einer Bereitstellung benötigen. Fügen Sie ein Feld unter " apiVersion " hinzu, das die " Art " des von Ihnen erstellten Kubernetes-Objekts beschreibt. In diesem Fall erstellen Sie ein " Deployment":

go-app / deployment.yml

Definieren Sie dann die "+ Metadaten " für Ihre Bereitstellung. Ein " Metadaten" -Feld ist für jedes Kubernetes-Objekt erforderlich, da es Informationen wie das eindeutige "+ Name " des Objekts enthält. Dieses " name +" ist nützlich, da Sie verschiedene Bereitstellungen voneinander unterscheiden und anhand von Namen identifizieren können, die für den Menschen lesbar sind:

go-app / deployment.yml

---
apiVersion: apps/v1
kind: Deployment

Als nächstes bauen Sie den "+ spec " - Block Ihrer " deployment.yml " auf. Ein " spec " - Feld ist für jedes Kubernetes-Objekt erforderlich, sein genaues Format unterscheidet sich jedoch für jeden Objekttyp. Im Falle einer Bereitstellung kann sie Informationen enthalten, z. B. die Anzahl der _Replikate_, die Sie ausführen möchten. In Kubernetes gibt eine Replik die Anzahl der Pods an, die in Ihrem Cluster ausgeführt werden sollen. Stellen Sie hier die Anzahl der " Replikate " auf " 5 +" ein:

go-app / deployment.yml

. . .
metadata:
   name: go-web-app

Als nächstes erstellen Sie einen "+ selector " - Block, der unter dem " spec +" - Block verschachtelt ist. Dies dient als Label-Selektor für Ihre Pods. Kubernetes verwendet Label-Selektoren, um zu definieren, wie die Bereitstellung die Pods findet, die verwaltet werden müssen.

Definieren Sie in diesem "+ Selector" -Block "+ MatchLabels" und fügen Sie das "+ Name" -Label hinzu. Im Wesentlichen teilt das Feld "+ matchLabels " Kubernetes mit, für welche Pods die Bereitstellung gilt. In diesem Beispiel gilt die Bereitstellung für alle Pods mit dem Namen " go-web-app +":

go-app / deployment.yml

. . .
spec:
 replicas: 5

Danach fügen Sie einen + template + Block hinzu. Bei jeder Bereitstellung wird eine Reihe von Pods mit den in einem "+ template " - Block angegebenen Bezeichnungen erstellt. Das erste Unterfeld in diesem Block ist " Metadaten ", das die " Bezeichnungen " enthält, die auf alle Pods in dieser Bereitstellung angewendet werden. Diese Bezeichnungen sind Schlüssel / Wert-Paare, die als Identifizierungsattribute von Kubernetes-Objekten verwendet werden. Wenn Sie Ihren Service später definieren, können Sie festlegen, dass alle Pods mit diesem " name " - Label unter diesem Service gruppiert werden sollen. Setze diese ` name` Bezeichnung auf` + go-web-app`:

go-app / deployment.yml

. . .
spec:
 replicas: 5
 selector:
   matchLabels:
     name: go-web-app

Der zweite Teil dieses + template + Blocks ist der + spec + Block. Dies unterscheidet sich von dem zuvor hinzugefügten "+ spec " - Block, da dieser nur für die vom " template +" - Block erstellten Pods und nicht für die gesamte Bereitstellung gilt.

Fügen Sie in diesem Block "+ spec " ein Feld " containers " hinzu und definieren Sie erneut ein Attribut " name ". Dieses Feld ` name ` definiert den Namen aller Container, die von dieser bestimmten Bereitstellung erstellt wurden. Definieren Sie darunter das ` image `, das Sie herunterladen und bereitstellen möchten. Stellen Sie sicher, dass Sie "+" in Ihren eigenen Docker Hub-Benutzernamen ändern:

go-app / deployment.yml

. . .
 template:
   metadata:
     labels:
       name: go-web-app



       sammy

Fügen Sie anschließend ein Feld + imagePullPolicy + hinzu, das auf + IfNotPresent + gesetzt ist. Dadurch wird die Bereitstellung angewiesen, ein Image nur dann abzurufen, wenn dies noch nicht geschehen ist. Als letztes fügen Sie einen + ports + Block hinzu. Definieren Sie dort den + containerPort +, der mit der Portnummer übereinstimmen soll, die Ihre Go-Anwendung abhört. In diesem Fall lautet die Portnummer "+ 3000 +":

go-app / deployment.yml

. . .
   spec:
     containers:
     - name: application
       image: /go-web-app

Die Vollversion Ihrer + deployment.yml + sieht folgendermaßen aus:

go-app / deployment.yml

---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: go-web-app
spec:
 replicas: 5
 selector:
   matchLabels:
     name: go-web-app
 template:
   metadata:
     labels:
       name: go-web-app
   spec:
     containers:
     - name: application
       image: /go-web-app
       imagePullPolicy: IfNotPresent
       ports:
         - containerPort: 3000

Speichern und schließen Sie die Datei.

Wenden Sie als Nächstes Ihre neue Bereitstellung mit dem folgenden Befehl an:

kubectl apply -f deployment.yml

Im nächsten Schritt erstellen Sie eine andere Art von Kubernetes-Objekt, das den Zugriff auf die in Ihrer neuen Bereitstellung vorhandenen Pods verwaltet. Dieser Dienst erstellt einen Lastenausgleich, der dann eine einzelne IP-Adresse verfügbar macht, und Anforderungen an diese IP-Adresse werden an die Replikate in Ihrer Bereitstellung verteilt. Dieser Dienst behandelt auch Regeln für die Portweiterleitung, sodass Sie über HTTP auf Ihre Anwendung zugreifen können.

Schritt 5 - Erstellen eines Dienstes

Nachdem Sie eine erfolgreiche Kubernetes-Bereitstellung durchgeführt haben, können Sie Ihre Anwendung der Außenwelt zugänglich machen. Dazu müssen Sie eine andere Art von Kubernetes-Objekt definieren: einen Service. Dieser Dienst stellt auf allen Knoten Ihres Clusters denselben Port zur Verfügung. Ihre Knoten leiten den eingehenden Datenverkehr auf diesem Port an die Pods weiter, auf denen Ihre Anwendung ausgeführt wird.

Erstellen Sie eine neue Datei mit dem Namen "+ service.yml +":

nano service.yml

Beginnen Sie diese Datei, indem Sie die Felder "+ apiVersion " und " kind " auf ähnliche Weise wie Ihre Datei " deployment.yml " definieren. Zeigen Sie dieses Mal mit dem Feld " apiVersion " auf " v1 +", die für Dienste häufig verwendete Kubernetes-API:

go-app / service.yml

Fügen Sie als Nächstes den Namen Ihres Dienstes in einem Metadatenblock hinzu, wie Sie es in der Datei deployment.yml getan haben. Dies könnte alles sein, was Sie möchten, aber der Übersichtlichkeit halber nennen wir es "+ go-web-service +":

go-app / service.yml

---
apiVersion: v1
kind: Service

Als nächstes erstellen Sie einen + spec + Block. Dieser "+ spec " - Block unterscheidet sich von dem in Ihrer Bereitstellung enthaltenen und enthält den " type " dieses Dienstes sowie die Portweiterleitungskonfiguration und den " selector +".

Fügen Sie ein Feld hinzu, das diesen Service definiert, "+ type" und setzen Sie es auf "+ Load Balancer". Dadurch wird automatisch ein Lastenausgleich bereitgestellt, der als Haupteinstiegspunkt für Ihre Anwendung fungiert.

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service

Fügen Sie anschließend einen "+ ports +" - Block hinzu, in dem Sie definieren, wie auf Ihre Apps zugegriffen werden soll. Fügen Sie in diesem Block die folgenden Felder hinzu:

  • + name + und zeigt auf + http

  • + port + zeigt auf port + 80 +

  • + targetPort + zeigt auf Port + 3000 +

Dies nimmt eingehende HTTP-Anfragen auf Port "+ 80 " entgegen und leitet sie an den " targetPort " von " 3000 " weiter. Dieser ` targetPort +` ist derselbe Port, auf dem Ihre Go-Anwendung ausgeführt wird:

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service
spec:
 type: LoadBalancer

Zuletzt fügen Sie einen "+ Selector" -Block hinzu, wie Sie es in der "+ deployment.yaml" -Datei getan haben. Dieser "+ Selector" -Block ist wichtig, da er alle bereitgestellten Pods mit dem Namen "+ go-web-app" diesem Service zuordnet:

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service
spec:
 type: LoadBalancer
 ports:
 - name: http
   port: 80
   targetPort: 3000

Speichern und schließen Sie die Datei, nachdem Sie diese Zeilen hinzugefügt haben. Wenden Sie anschließend diesen Service erneut mit dem Befehl + kubectl apply + auf Ihren Kubernetes-Cluster an:

kubectl apply -f service.yml

Dieser Befehl wendet den neuen Kubernetes-Dienst an und erstellt einen Lastenausgleich. Dieser Lastenausgleich dient als öffentlicher Einstiegspunkt für Ihre Anwendung, die im Cluster ausgeführt wird.

Zum Anzeigen der Anwendung benötigen Sie die IP-Adresse des neuen Load Balancers. Finden Sie es, indem Sie den folgenden Befehl ausführen:

kubectl get services
OutputNAME             TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)        AGE
go-web-service   LoadBalancer   10.245.107.189      80:30533/TCP   10m
kubernetes       ClusterIP      10.245.0.1       <none>            443/TCP        3h4m

Möglicherweise wird mehr als ein Dienst ausgeführt, Sie finden jedoch den Dienst mit der Bezeichnung "+ go-web-service ". Suchen Sie die Spalte " EXTERNAL-IP " und kopieren Sie die IP-Adresse, die dem " go-web-service " zugeordnet ist. In dieser Beispielausgabe lautet diese IP-Adresse "+". Fügen Sie dann die IP-Adresse in die URL-Leiste Ihres Browsers ein, um die auf Ihrem Kubernetes-Cluster ausgeführte Anwendung anzuzeigen.

Der Load Balancer nimmt die Anforderung an Port "+ 80 +" auf und leitet sie an einen der Pods weiter, die in Ihrem Cluster ausgeführt werden.

image: https://assets.digitalocean.com/articles/resilient_go_kubernetes/resilient_screenshot_2.png [Ihre funktionierende Go App!]

Damit haben Sie einen Kubernetes-Dienst in Verbindung mit einem Load Balancer erstellt, der Ihnen einen einzigen stabilen Einstiegspunkt in die Anwendung bietet.

Fazit

In diesem Lernprogramm haben Sie eine Go-Anwendung erstellt, diese mit Docker in Container umgewandelt und anschließend in einem Kubernetes-Cluster bereitgestellt. Anschließend haben Sie einen Lastenausgleich erstellt, der einen ausfallsicheren Einstiegspunkt für diese Anwendung bietet und sicherstellt, dass er auch dann hoch verfügbar bleibt, wenn einer der Knoten in Ihrem Cluster ausfällt. Mit diesem Lernprogramm können Sie Ihre eigene Go-Anwendung in einem Kubernetes-Cluster bereitstellen oder mit der in Schritt 1 erstellten Beispielanwendung weitere Kubernetes- und Docker-Konzepte erlernen.

Zukünftig könnten Sie https://www.digitalocean.com/community/tutorials/how-to-point-to-digitalocean-nameservers-from-common-domain-registrars‹ die IP-Adresse Ihres Load Balancers einem Domain-Namen zuordnen, der Sie steuern], sodass Sie auf die Anwendung über eine für Menschen lesbare Webadresse zugreifen können, anstatt über die IP-Adresse des Lastenausgleichs. Darüber hinaus könnten die folgenden Kubernetes-Tutorials für Sie von Interesse sein:

Wenn Sie mehr über Go erfahren möchten, empfehlen wir Ihnen, unsere Reihe unter How To Code in zu lesen Gehen.

Related