ASP.NET Core-App für Kubernetes in Google Kubernetes Engine bereitstellen

1. Übersicht

ASP.NET Core ist ein neues, plattformübergreifendes Open-Source-Framework zum Entwickeln moderner cloudbasierter und mit dem Internet verbundener Anwendungen mithilfe der Programmiersprache C#.

Kubernetes ist ein Open-Source-Projekt, das sich in vielen verschiedenen Umgebungen ausführen lässt – ob Laptop oder hochverfügbarer Cluster mit mehreren Knoten, ob öffentliche Cloud oder lokales Deployment, ob virtuelle Maschine oder Bare-Metal-Server.

In diesem Lab stellen Sie eine einfache ASP.NET Core-App in Kubernetes bereit, die in einer Kubernetes Engine ausgeführt wird. Dieses Codelab baut auf dem Codelab ASP.NET Core-App mit Google Cloud Shell erstellen und starten auf. Es empfiehlt sich, dieses Lab zuerst zu absolvieren, bevor Sie mit diesem Lab beginnen.

Ziel dieses Codelabs ist es, Ihren Code (in diesem Fall eine einfache Hello World ASP.NET Core-App) in eine replizierte Anwendung umzuwandeln, die auf Kubernetes ausgeführt wird. Dazu verwenden Sie Code, den Sie auf Ihrem Computer entwickelt haben, wandeln ihn in ein Docker-Container-Image um und führen dieses dann in Google Kubernetes Engine aus.

In diesem Diagramm sehen Sie die verschiedenen Teile dieses Codelabs, um einen Eindruck zu gewinnen, wie alles miteinander zusammenhängt. Verwenden Sie es als Referenz, während Sie das Codelab absolvieren. Am Ende des Codelabs sollte alles schlüssig sein (fürs Erste können Sie es jedoch auch einfach ignorieren).

Für dieses Codelab sollten Sie eine verwaltete Umgebung wie die Kubernetes Engine verwenden. Das ist eine bei Google gehostete Version von Kubernetes, die in der Compute Engine ausgeführt wird. Dadurch können Sie sich auf Kubernetes konzentrieren, ohne erst die zugrundeliegende Infrastruktur einrichten zu müssen.

Wenn Sie wissen möchten, wie Sie Kubernetes auf Ihrem lokalen Computer ausführen, z. B. auf einem Entwicklerlaptop, sollten Sie sich Minikube ansehen. Damit lässt sich ein Kubernetes-Cluster mit einem einzelnen Knoten zu Entwicklungs- und Testzwecken ganz einfach einrichten. Wenn Sie möchten, können Sie Minikube auch für dieses Codelab verwenden.

Lerninhalte

Eine einfache ASP.NET Core-App als Docker-Container verpacken
Einen Kubernetes-Cluster in Google Kubernetes Engine (GKE) erstellen
ASP.NET Core-App auf einem Pod bereitstellen
Externen Traffic auf einen Pod zulassen
Den Dienst skalieren und ein Upgrade bereitstellen
Kubernetes Graphical-Dashboard ausführen

Voraussetzungen

Ein Browser, z. B. Chrome oder Firefox

Wie werden Sie diese Anleitung verwenden?

Nur lesen

Lesen und Übungen durchführen

Wie würden Sie Ihre Erfahrung mit der Google Cloud Platform bewerten?

Anfänger

Mittelstufe

Fortgeschritten

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können ihn jederzeit aktualisieren.
Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich (kann nach der Festlegung nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (sie wird in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen versuchen und sehen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit Ihnen nach Abschluss dieser Anleitung keine Kosten mehr in Rechnung gestellt werden, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Nutzer von Google Cloud kommen für das Programm für kostenlose Testversionen mit einem Guthaben von 300$ infrage.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie die Cloud Shell zuvor noch nicht gestartet haben, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter. So sieht dieses Fenster aus:

Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.

Auf dieser virtuellen Maschine sind alle Entwicklungstools installiert, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser oder Ihrem Chromebook erledigt werden.

Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie bereits authentifiziert sind und für das Projekt schon Ihre Projekt-ID eingestellt ist.

Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

3. ASP.NET Core-App in Cloud Shell erstellen

In der Cloud Shell-Eingabeaufforderung können Sie prüfen, ob das dotnet-Befehlszeilentool bereits installiert ist, indem Sie die Version abrufen. Dadurch sollte die Version des installierten dotnet-Befehlszeilentools ausgegeben werden:

dotnet --version

Erstellen Sie als Nächstes das Grundgerüst für eine neue ASP.NET Core-Web-App.

dotnet new mvc -o HelloWorldAspNetCore

Dadurch sollte ein Projekt mit wiederhergestellten Abhängigkeiten erstellt werden, was durch eine Meldung wie die folgende bestätigt wird.

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. ASP.NET Core-App ausführen

Die Anwendung ist fast einsatzbereit. Rufen Sie den App-Ordner auf.

cd HelloWorldAspNetCore

Führen Sie die App zum Schluss aus.

dotnet run --urls=http://localhost:8080

Die Anwendung überwacht nun Port 8080.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

Klicken Sie oben rechts auf die Schaltfläche „Webvorschau“ und wählen Sie „Vorschau auf Port 8080“ aus, um zu prüfen, ob die App ausgeführt wird.

Sie sehen die ASP.NET Core-Standardwebseite:

Wenn Sie bestätigt haben, dass die App ausgeführt wird, drücken Sie Strg + C, um sie zu beenden.

5. ASP.NET Core-App als Docker-Container verpacken

Als Nächstes bereiten Sie Ihre App darauf vor, als Container ausgeführt zu werden. Dazu legen Sie zuerst den Container und seine Inhalte fest.

Erstellen Sie im Basisverzeichnis der App eine Dockerfile, um das Docker-Image zu definieren.

touch Dockerfile

Fügen Sie mithilfe eines Editors Ihrer Wahl (vim,, nano,emacs oder der Code-Editor von Cloud Shell) dem Dockerfile den folgenden Code hinzu.

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

Eine wichtige Konfiguration im Dockerfile ist der Port, von dem eingehender Traffic abgerufen wird (8080). Dafür wird die Umgebungsvariable ASPNETCORE_URLS festgelegt, die von ASP.NET Core-Apps verwendet wird, um den relevanten Port zu erkennen.

Speichere diese Dockerfile. Erstellen Sie nun das Image:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

Sobald dies abgeschlossen ist (es dauert einige Zeit, bis alles heruntergeladen und extrahiert wurde), sehen Sie, dass das Image erstellt und lokal gespeichert wurde:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1

Testen Sie das Image lokal mit dem folgenden Befehl, durch den ein Docker-Container lokal von Ihrem neu erstellten Container-Image auf Port 8080 ausgeführt wird:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Sie können dazu wieder die Webvorschau von Cloud Shell nutzen :

Screenshot vom 03.11.2015, 17:20:22.png

Sie sollten die ASP.NET Core-Webseite in einem neuen Tab sehen.

Nachdem Sie überprüft haben, dass die App lokal in einem Docker-Container ausgeführt wird, können Sie den Container mit Ctrl-> C stoppen.

Wenn nun das Image wie gewünscht funktioniert, laden Sie es in die Google Container Registry hoch. Das ist ein privates Repository für Ihre Docker-Images, auf die von jedem Google Cloud-Projekt aus (aber auch von außerhalb der Google Cloud Platform) zugegriffen werden kann:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Wenn alles gut geht, sollte das Container-Image nach einiger Zeit im Abschnitt Container Registry aufgeführt sein. Ihnen steht nun ein Docker-Image für das gesamte Projekt zur Verfügung, das sich mit Kubernetes aufrufen und orchestrieren lässt, wie Sie gleich sehen werden.

Wenn Sie wissen möchten, welche Container-Images in Google Cloud Storage gespeichert sind, wählen Sie den folgenden Link aus: https://console.cloud.google.com/storage/browser/. Der vollständige Link sollte dieses Format haben: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/.

6. Kubernetes-Cluster erstellen

Sie können jetzt Ihren GKE-Cluster erstellen. Rufen Sie dazu den Bereich „Google Kubernetes Engine“ in der Webkonsole auf und warten Sie, bis das System initialisiert ist. Das sollte nur wenige Sekunden dauern.

Ein Cluster besteht aus einem von Google verwalteten Kubernetes Master API-Server und einer Reihe von Worker-Knoten. Bei den Worker-Knoten handelt es sich um virtuelle Compute Engine-Maschinen.

Wir verwenden die gcloud CLI in Ihrer Cloud Shell-Sitzung, um einen Cluster zu erstellen. Passen Sie die Zone an einen Ort in Ihrer Nähe an ( Liste der Zonen). Das dauert einige Minuten:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

Am Ende sollten Sie den erstellten Cluster sehen.

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

Sie sollten jetzt einen voll funktionsfähigen Kubernetes-Cluster haben, der von Google Kubernetes Engine bereitgestellt wird:

Und nun stellen Sie Ihre eigene containerisierte Anwendung auf den Kubernetes-Clustern bereit. Ab jetzt verwenden Sie die Befehlszeile kubectl, die bereits in Ihrer Cloud Shell-Umgebung eingerichtet ist. Für den Rest dieses Codelabs ist es erforderlich, dass sowohl der Kubernetes-Client als auch der Server mindestens die Versionsnummer 1.2 hat. Mit kubectl version wird die aktuelle Version des Befehls angezeigt.

7. Bereitstellung erstellen

Bei einem Kubernetes-Pod handelt es sich um eine Gruppe von Containern, die zu Administrations- und Netzwerkzwecken zusammengebunden sind. Er kann einen oder mehrere Container enthalten. Hier verwenden Sie einfach einen Container, der mit Ihrem ASP.NET Core-Image erstellt wurde, das in Ihrer privaten Container-Registry gespeichert ist. Er stellt Inhalte auf Port 8080 bereit.

Erstellen Sie mit einem Editor Ihrer Wahl (vim, nano,emacs oder dem Code-Editor von Cloud Shell) eine Datei mit dem Namen hello-dotnet.yaml und definieren Sie das Kubernetes-Deployment für den Pod:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

Stellen Sie die Anwendung mit kubectl im Standard-Namespace bereit:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

Wie Sie sehen, haben Sie ein Deployment-Objekt erstellt. Zum Erstellen und Skalieren von Pods werden Deployments empfohlen. Ein neues Deployment verwaltet hier ein einzelnes Pod-Replikat, auf dem das Image hello-dotnet:v1 ausgeführt wird.

Führen Sie einfach den folgenden Befehl aus, um sich das gerade erstellte Deployment anzeigen zu lassen:

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

Um sich den Pod anzusehen, der vom Deployment erstellt wurde, führen Sie diesen Befehl aus:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

An dieser Stelle empfiehlt es sich, einige interessante kubectl-Befehle durchzugehen, die sich nicht auf den Status des Clusters auswirken. Die vollständige Dokumentation ist hier verfügbar:

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

Der Container wird nun unter Kubernetes ausgeführt. Sie müssen ihn jedoch noch für die Öffentlichkeit zugänglich machen.

8. Externen Traffic zulassen

Standardmäßig kann nur die interne IP innerhalb des Clusters auf den Pod zugreifen. Damit der hello-dotnet-Container von außerhalb des virtuellen Kubernetes-Netzwerks zugänglich wird, müssen Sie den Pod als Kubernetes-Dienst zur Verfügung stellen.

Von Cloud Shell aus können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type="LoadBalancer" dem öffentlichen Internet zugänglich machen. Dieses Flag wird für die Erstellung einer extern zugänglichen IP benötigt:

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

Das Flag in diesem Befehl gibt an, dass Sie das Lastenausgleichsmodul verwenden, das von der zugrunde liegenden Infrastruktur bereitgestellt wird (in diesem Fall das Lastenausgleichsmodul von Compute Engine). Hinweis: Sie machen das Deployment und nicht den Pod direkt verfügbar. Als Folge führt der resultierende Dienst den Traffic-Lastenausgleich für alle vom Deployment verwalteten Pods durch (in diesem Fall nur für einen Pod, später werden jedoch weitere Replikate hinzugefügt).

Der Kubernetes-Master erstellt den Lastenausgleich und die zugehörigen Compute Engine-Weiterleitungsregeln, Zielpools und Firewallregeln, um den Dienst von außerhalb der Google Cloud Platform vollständig zugänglich zu machen.

Die öffentlich zugängliche IP-Adresse des Dienstes erhalten Sie, wenn Sie den Befehl kubectl ausführen. Damit können Sie sich alle Clusterdienste auflisten lassen:

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Hinweis: Für den Dienst sind zwei IP-Adressen aufgelistet, die beide Port 8080 bedienen. Eine davon ist die interne IP, die nur in Ihrem virtuellen Cloudnetzwerk sichtbar ist. Die andere ist die externe Load-Balancer-IP. In diesem Beispiel lautet die externe IP-Adresse 104.155.20.69.

Sie sollten den Dienst jetzt erreichen können. Verweisen Sie dazu Ihren Browser auf diese Adresse: http://<EXTERNAL_IP>:8080

Jetzt haben Sie schon einige zusätzliche Funktionen dadurch erhalten, dass Sie zu Containern und Kubernetes übergegangen sind. Sie müssen nicht festlegen, auf welchem Host die Arbeitslast ausgeführt werden soll, und profitieren außerdem von der Dienstüberwachung und dem Neustart. Mal sehen, welche Vorteile Ihnen die neue Kubernetes-Infrastruktur noch bringt.

9. Dienst skalieren

Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierbarkeit Ihrer Anwendung. Falls Sie plötzlich mehr Kapazität für Ihre Anwendung benötigen, können Sie den Replikationscontroller anweisen, eine neue Anzahl von Replikaten für Ihren Pod zu verwalten:

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

Hier wird ein deklarativer Ansatz verwendet. Anstatt neue Instanzen zu starten oder anzuhalten, bestimmen Sie, wie viele Instanzen zu jeder Zeit ausgeführt werden sollen. Die Abstimmungsschleifen von Kubernetes sorgen dafür, dass dies tatsächlich passiert und bei Bedarf Maßnahmen ergriffen werden.

Im folgenden Diagramm ist der Zustand Ihres Kubernetes-Clusters zusammengefasst:

Sie können Ihren Dienst auch ganz einfach herunterskalieren. So skalieren Sie von 4 Pods auf 2 Pods herunter.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. Ausfallsicherheit testen

Kubernetes (oder genauer gesagt ReplicaSet) überwacht Ihre Pods. Wenn mit einem Pod etwas nicht stimmt und er ausfällt, wird sofort ein neuer Pod erstellt. Sehen wir uns an, wie das funktioniert.

Rufen Sie zuerst die Liste der Pods ab:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

Löschen Sie einen der Pods, indem Sie den Pod-Namen übergeben:

kubectl delete pod hello-dotnet-714049816-g4azy

Wenn Sie sich die Liste der Pods noch einmal ansehen, sehen Sie, dass ein neuer Pod erstellt und sofort wieder ausgeführt wird:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. Upgrade für Ihren Dienst bereitstellen

Früher oder später sind für die Anwendung, die Sie für die Produktion bereitgestellt haben, Fehlerbehebungen oder zusätzliche Funktionen erforderlich. Sehen wir uns an, wie das funktioniert.

Ändern wir zuerst die Anwendung. Öffnen Sie den Code-Editor über Cloud Shell.

Öffnen Sie Index.cshtml unter HelloWorldAspNetCore > Views > Home und aktualisieren Sie eine der Karussellnachrichten.

Suchen Sie die folgende Zeile:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core

Ändern Sie sie in Folgendes:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

Speichern Sie die Änderungen und kehren Sie dann zu Cloud Shell zurück. Erstellen Sie das Docker-Image in HelloWorldAspNetCore,:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .

Übertragen Sie das Image per Push in die Container Registry:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2

Sie können nun mit Kubernetes den Replikations-Controller problemlos auf die neue App-Version aktualisieren. Um das Image-Label Ihres Containers zu ändern, müssen Sie das bestehende hello-dotnet deployment bearbeiten und das Image von gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 zu gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 ändern.

Dazu verwenden Sie den Befehl kubectl edit. Dadurch öffnet sich ein Texteditor, der die vollständige yaml-Konfiguration anzeigt. Sie brauchen im Augenblick die YAML-Konfiguration nicht komplett zu verstehen, sollten aber nachvollziehen können, dass Sie durch das Aktualisieren des Felds spec.template.spec.containers.image in der Konfiguration festlegen, dass die Pods für das Deployment das neue Image verwenden.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Speichern Sie die Änderung und schließen Sie die Datei. Da Sie sich derzeit in vi befinden, drücken Sie die Esc-Taste, geben Sie :wq ein und drücken Sie die Eingabetaste.

deployment "hello-dotnet" edited

Dadurch wird das Deployment mit dem neuen Image aktualisiert. Alte Pods werden gelöscht und neue mit dem neuen Image erstellt.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

Während dies geschieht, sollten die Nutzer der Dienste keine Unterbrechung wahrnehmen. Nach kurzer Zeit greifen sie auf die neue Version Ihrer Anwendung zu.

Detaillierte Informationen zu Rolling Updates finden Sie in der Kubernetes-Dokumentation.

Dank der Funktionen für das Deployment, die Skalierung und die Aktualisierung mit Kubernetes können Sie sich nach dem Einrichten Ihrer Umgebung (GKE-/Kubernetes-Cluster) ganz auf Ihre Anwendung statt auf die Infrastruktur konzentrieren.

12. Cloud Build

Bisher haben wir Container mit regulären Docker-Befehlen (docker build …) erstellt und das Image dann manuell in die Container Registry von Google Cloud Platform übertragen. Es ist auch möglich, beide Schritte an den Server zu delegieren (Cloud Build). Damit kann das Container-Image erstellt und übertragen werden, ohne dass Docker lokal installiert sein muss.

Aktivieren Sie zuerst die Cloud Build API in API Manager > Bibliothek. Suchen Sie nach Cloud Build und klicken Sie auf Cloud Build API:

Klicken Sie auf API aktivieren, wenn sie noch nicht aktiviert ist. Am Ende sollte die API wie folgt aktiviert sein:

Sobald die Cloud Build API aktiviert ist, können Sie das folgende Kommando ausführen, um Ihr Image mit dem Container Builder-Dienst zu erstellen und per Push zu übertragen:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

Das Image wird automatisch in Container Registry gespeichert.

13. Kubernetes Graphical-Dashboard ausführen

Bei den aktuellen Kubernetes-Versionen wurde eine grafische Web-Benutzeroberfläche (Dashboard) eingeführt. Damit können Nutzer schnell und unproblematisch einsteigen. Außerdem wird ein Teil der CLI-Funktionalität aktiviert, da damit eine bessere Interaktion mit dem System möglich ist.

Geben Sie im Cloud Shell-Fenster die folgenden Befehle ein, um den Zugriff auf das Kubernetes-Cluster-Dashboard zu konfigurieren :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

Verwenden Sie dann noch einmal die Cloud Shell-Vorschaufunktion, um den Port 8081 aufzurufen:

Dies sollte Sie an den API-Endpunkt weiterleiten. Möglicherweise wird die Seite „Nicht autorisiert“ angezeigt. Das ist aber kein Problem. Um zum Dashboard zu gelangen, entfernen Sie „?authuser=3“ und ersetzen Sie es durch „/ui“.

Viel Spaß mit dem grafischen Dashboard von Kubernetes. Sie können es für das Deployment von Container-Anwendungen sowie für die Überwachung und Verwaltung Ihrer Cluster verwenden.

Alternativ können Sie über einen Entwicklercomputer oder über einen lokalen Computer auf das Dashboard zugreifen. Dazu drücken Sie in der Webkonsole für den gewünschten Cluster auf die Schaltfläche „Verbinden“.

Wenn Sie im Dashboard fertig sind, drücken Sie Strg + C, um den Proxyserver anzuhalten. Weitere Informationen zum Kubernetes-Dashboard erhalten Sie über die Dashboard-Tour.

14. Logging

Mit dem Befehl kubectl logs können Sie die Logs eines Containers abrufen, der in Kubernetes ausgeführt wird. Wenn Sie Google Kubernetes Engine zum Ausführen verwalteter Kubernetes-Cluster verwenden, werden alle Logs automatisch weitergeleitet und in Google Cloud Logging gespeichert. Sie können die gesamte Logausgabe der Pods in der Google Cloud Console unter Stackdriver → Logging → Logs aufrufen:

In der Logging-Konsole können Sie zu GKE Container navigieren, um alle aus STDOUT erfassten Logs aufzurufen:

Von hier aus können Sie die Logs optional zur weiteren Log-Analyse in Google BigQuery exportieren oder logbasierte Benachrichtigungen einrichten. Das ist heute im Lab nicht möglich.

15. Glückwunsch!

Damit ist das einfache Codelab für den Start mit ASP.NET Core und Kubernetes beendet. Wir haben uns bisher nur an der Oberfläche dieser Technologie bewegt und möchten Sie ermutigen, diese durch eigene Pods, Replikationscontroller und Dienste weiter zu erkunden. Informieren Sie sich außerdem über Aktivitätsprüfungen (Systemdiagnosen) und verwenden Sie eventuell die Kubernetes API.

Bereinigen

Geschafft! Sie können nun die genutzten Ressourcen wieder entfernen. So sparen Sie Kosten und geben nicht mehr benötigte Ressourcen für andere frei.

Löschen Sie das Deployment (wodurch auch die laufenden Pods gelöscht werden) und den Dienst (wodurch auch der externe Load Balancer gelöscht wird):

Löschen Sie zuerst den Dienst und das Deployment. Dadurch wird auch der externe Load-Balancer gelöscht:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

Löschen Sie als Nächstes Ihren Cluster:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

Dadurch werden alle Google Compute Engine-Instanzen gelöscht, auf denen der Cluster ausgeführt wird.

Löschen Sie schließlich den Docker-Registrierungs-Storage-Bucket, in dem sich Ihre Bilder befinden:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Sie können natürlich auch das gesamte Projekt löschen. In diesem Fall gehen jedoch alle Abrechnungseinstellungen verloren, die Sie vorgenommen haben. Dazu müssen Sie zuerst die Projektabrechnung deaktivieren. Außerdem wird durch das Löschen eines Projekts die gesamte Abrechnung erst nach Ablauf des aktuellen Abrechnungszeitraums beendet.

Behandelte Themen

Eine einfache ASP.NET Core-App als Docker-Container verpacken
Einen Kubernetes-Cluster in Google Kubernetes Engine erstellen
ASP.NET Core-App auf einem Pod bereitstellen
Externen Traffic auf einen Pod zulassen
Den Dienst skalieren und ein Upgrade bereitstellen
Kubernetes Graphical-Dashboard ausführen

Nächste Schritte

Weitere Informationen zu Kubernetes (http://kubernetes.io/)
Windows auf der Google Cloud Platform
.NET auf der Google Cloud Platform
SQL Server auf der Google Cloud Platform
Cloud Tools for Visual Studio
Cloud Tools for PowerShell

Lizenz

Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.