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-Anwendung in Kubernetes bereit, die in Kubernetes Engine ausgeführt wird. Dieses Codelab baut auf dem Codelab ASP.NET Core-App mit Google Cloud Shell erstellen und starten auf. Bevor Sie mit diesem Lab beginnen, sollten Sie dieses Lab absolvieren.
Ziel dieses Codelabs ist es, Ihren Code (hier eine einfache Hello World ASP.NET Core-App) in eine replizierte Anwendung umzuwandeln, die auf Kubernetes ausgeführt wird. Sie verwenden Code, den Sie auf Ihrem Computer entwickelt haben, wandeln ihn in ein Docker-Container-Image um und führen dieses Image dann in Google Kubernetes Engine aus.
Im Folgenden finden Sie ein Diagramm der verschiedenen Teile in diesem Codelab, damit Sie besser verstehen, wie die einzelnen Teile zusammenpassen. Verwenden Sie es als Referenz, während Sie das Codelab durcharbeiten. Am Ende sollte alles einen Sinn ergeben (aber fürs Erste können Sie dies ignorieren).
In diesem Codelab können Sie sich mit einer verwalteten Umgebung wie Kubernetes Engine (einer von Google gehosteten Version von Kubernetes, die auf Compute Engine ausgeführt wird) mehr auf die Arbeit mit Kubernetes konzentrieren, anstatt die zugrunde liegende Infrastruktur einzurichten.
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 dieses Codelab mit Minikube durchgehen.
Lerninhalte
- Eine einfache ASP.NET Core-App als Docker-Container verpacken
- So erstellen Sie einen Kubernetes-Cluster in der Google Kubernetes Engine (GKE).
- 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
Wie möchten Sie diese Anleitung nutzen?
<ph type="x-smartling-placeholder">Wie würden Sie Ihre Erfahrung mit der Google Cloud Platform bewerten?
<ph type="x-smartling-placeholder">2. Einrichtung und Anforderungen
Umgebung für das selbstbestimmte 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 Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf die Projekt-ID verweisen, die üblicherweise als
PROJECT_IDgekennzeichnet ist. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID erstellen. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab sollte möglichst wenig kosten. Wenn Sie Ressourcen herunterfahren möchten, um über diese Anleitung hinaus keine Kosten zu verursachen, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion mit 300$Guthaben.
Cloud Shell starten
Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Cloud Shell aktivieren
- Klicken Sie in der Cloud Console auf Cloud Shell aktivieren
.
Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Zwischenbildschirm (below the fold) angezeigt, in dem beschrieben wird, worum es sich dabei handelt. Klicken Sie in diesem Fall auf Weiter. Der Chat wird nie wieder angezeigt. So sieht dieser einmalige Bildschirm aus:
Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.
Diese virtuelle Maschine verfügt über alle Entwicklungstools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können Sie ganz einfach mit einem Browser oder Ihrem Chromebook erledigen.
Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre Projekt-ID eingestellt ist.
- Führen Sie in 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 in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob 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 überprüfen, ob das dotnet-Befehlszeilentool bereits installiert ist, indem Sie die Version prüfen. Damit sollte die Version des installierten dotnet-Befehlszeilentools angezeigt werden:
dotnet --version
Erstellen Sie als Nächstes das Grundgerüst einer 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
Wir sind fast bereit, unsere App auszuführen. Rufen Sie den App-Ordner auf.
cd HelloWorldAspNetCore
Abschließend führen Sie die App 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.
Wenn Sie prüfen möchten, ob die App ausgeführt wird, klicken Sie oben rechts auf die Schaltfläche „Webvorschau“ und wählen Sie „Vorschau auf Port 8080“ aus.
Sie sehen die standardmäßige ASP.NET Core-Webseite:
Sobald Sie überprüft haben, dass die Anwendung 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 für die Ausführung als Container vor. Dazu legen Sie zuerst den Container und seine Inhalte fest.
Erstellen Sie im Basisverzeichnis der Anwendung einen Dockerfile, um das Docker-Image zu definieren.
touch Dockerfile
Fügen Sie mit Ihrem bevorzugten Editor (vim, nano,emacs oder Cloud Shell-Codeeditor) Folgendes zu Dockerfile 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). Dazu wird die Umgebungsvariable ASPNETCORE_URLS festgelegt, mit der ASP.NET Core-Apps bestimmen, welcher Port überwacht werden soll.
Dockerfile speichern. Jetzt erstellen wir das Image:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Sobald der Vorgang abgeschlossen ist (es dauert einige Zeit, bis alles heruntergeladen und extrahiert werden kann) können Sie sehen, 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, der einen Docker-Container lokal auf Port 8080 aus Ihrem neu erstellten Container-Image ausführt:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Nutzen Sie auch hier wieder die Webvorschaufunktion von Cloud Shell :
Die standardmäßige ASP.NET Core-Webseite sollte in einem neuen Tab angezeigt werden.
Nachdem Sie sichergestellt haben, dass die Anwendung lokal in einem Docker-Container problemlos ausgeführt wird, können Sie den ausgeführten Container mit Ctrl-> C beenden.
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, und nach kurzer Zeit sollten Sie das Container-Image im Abschnitt Container Registry sehen können. Jetzt steht Ihnen ein projektweites Docker-Image zur Verfügung, auf das Kubernetes zugreifen und es orchestrieren kann, wie Sie gleich sehen werden.
Bei Interesse können Sie sich die in Google Cloud Storage gespeicherten Container-Images ansehen. Klicken Sie dazu auf diesen Link: https://console.cloud.google.com/storage/browser/. Der vollständige Link sollte folgendes Format haben: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/.
6. Kubernetes-Cluster erstellen
Sie können jetzt Ihren GKE-Cluster erstellen. Gehen Sie vorher in der Webkonsole zum Abschnitt „Google Kubernetes Engine“ und warten Sie, bis das System initialisiert wurde. 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.
Verwenden Sie die gcloud-Befehlszeile aus Ihrer Cloud Shell-Sitzung, um einen Cluster zu erstellen. Legen Sie einen Bereich in Ihrer Nähe fest ( Liste der Zonen). Dies kann einige Minuten dauern:
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 kubectl-Befehlszeile, die bereits in Ihrer Cloud Shell-Umgebung eingerichtet ist. Für den Rest dieses Codelabs müssen sowohl der Kubernetes-Client als auch die Serverversion 1.2 oder höher sein. kubectl version zeigt Ihnen die aktuelle Version des Befehls an.
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 Ihrem bevorzugten Editor (vim, nano,emacs oder dem Code-Editor von Cloud Shell) eine hello-dotnet.yaml-Datei 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 sie im Standard-Namespace mit kubectl 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. Hier verwaltet ein neues Deployment ein einzelnes Pod-Replikat, auf dem das hello-dotnet:v1-Image ausgeführt wird.
Führen Sie einfach den folgenden Befehl aus, um die soeben erstellte Bereitstellung anzuzeigen:
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
Jetzt ist ein guter Zeitpunkt, einige interessante kubectl-Befehle durchzugehen (keine davon ändert den Status des Clusters. Eine vollständige Dokumentation finden Sie hier):
kubectl get pods kubectl cluster-info kubectl config view kubectl get events kubectl logs <pod-name>
Zu diesem Zeitpunkt sollte Ihr Container unter der Kontrolle von Kubernetes ausgeführt werden, Sie müssen ihn aber noch für die Außenwelt zugänglich machen.
8. Externen Traffic zulassen
Standardmäßig kann nur die interne IP innerhalb des Clusters auf den Pod zugreifen. Um den hello-dotnet-Container von außerhalb des virtuellen Kubernetes-Netzwerks zugänglich zu machen, muss der Pod als Kubernetes-Dienst verfügbar gemacht werden.
Über Cloud Shell können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type="LoadBalancer" für das öffentliche Internet freigeben. 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.
Wenn Sie die öffentlich zugängliche IP-Adresse des Dienstes ermitteln möchten, fordern Sie einfach kubectl an, um alle Clusterdienste aufzulisten:
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
Beachten Sie, dass für Ihren Dienst zwei IP-Adressen aufgeführt sind, 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, indem Sie Ihren Browser auf diese Adresse verweisen: http://<EXTERNAL_IP>:8080
Bisher haben Sie durch den Wechsel zu Containern und Kubernetes mindestens einige Funktionen erhalten. Sie müssen nicht angeben, auf welchem Host die Arbeitslast ausgeführt werden soll. Außerdem profitieren Sie von Dienstmonitoring und 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. Angenommen, Sie benötigen plötzlich mehr Kapazität für Ihre Anwendung. können Sie den Replikations-Controller einfach 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
Beachten Sie hier den deklarativen Ansatz. Anstatt neue Instanzen zu starten oder zu beenden, geben Sie an, wie viele Instanzen gleichzeitig ausgeführt werden sollen. Die Abgleichsschleifen von Kubernetes sorgen einfach dafür, dass die Realität Ihren Anforderungen entspricht, und ergreifen bei Bedarf Maßnahmen.
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 der Pod etwas nicht stimmt und dieser ausfällt, wird sofort ein neuer erstellt. Lassen Sie uns dies testen, um zu sehen, wie es 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 sofort ein neuer Pod erstellt und 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 dieser Prozess aussieht.
Ändern wir zuerst die Anwendung. Öffnen Sie den Code-Editor von Cloud Shell.
Gehen Sie unter HelloWorldAspNetCore > Views > Home zu Index.cshtml und aktualisieren Sie eine der Karussell-Nachrichten.
Suche nach der folgenden 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 zu Cloud Shell zurück. Erstellen Sie in HelloWorldAspNetCore, das Docker-Image:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
Und laden Sie die Datei per Push in Container Registry hoch:
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. Wenn Sie das Image-Label für Ihren laufenden Container ändern möchten, müssen Sie das vorhandene hello-dotnet deployment bearbeiten und das Image von gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 in gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 ändern.
Dazu verwenden Sie den Befehl kubectl edit. Dadurch wird ein Texteditor geöffnet, in dem die vollständige YAML-Konfiguration angezeigt wird. Sie müssen nicht sofort die vollständige yaml-Konfiguration verstehen. Sie müssen lediglich verstehen, dass Sie durch Aktualisieren des Felds spec.template.spec.containers.image in der Konfiguration das Deployment anweisen, die Pods zu aktualisieren, sodass das neue Image verwendet wird.
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
Nachdem Sie die Änderung vorgenommen haben, speichern und schließen Sie die Datei. Dazu wird „vi“ verwendet. 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, wodurch neue Pods mit dem neuen Image erstellt und alte Pods gelöscht werden.
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.
Weitere Informationen zu Rolling Updates finden Sie in der Kubernetes-Dokumentation.
Mit diesen Features zum Bereitstellen, Skalieren und Aktualisieren stimmen Sie zu, dass Sie sich nach der Einrichtung Ihrer Umgebung (hier Ihren GKE/Kubernetes-Cluster) mit Kubernetes auf Ihre Anwendung konzentrieren können, anstatt die Infrastruktur zu verwalten.
12. Cloud Build
Bisher haben wir Container mit regulären Docker-Befehlen (docker build ...) erstellt und das Image dann manuell in die Container Registry der Google Cloud Platform verschoben. Es ist auch möglich, beide Schritte auf das serverseitige Cloud Build zu übertragen, wo das Container-Image ohne lokale Installation von Docker erstellt und per Push übertragen werden kann.
Aktivieren Sie zuerst die Cloud Build API unter API Manager > Mediathek. Suchen Sie nach Cloud Build und klicken Sie auf Cloud Build API:
Klicken Sie auf API aktivieren, falls die API noch nicht aktiviert ist. Am Ende sollte die API wie folgt aktiviert sein:
Sobald die Cloud Build API aktiviert ist, können Sie den folgenden Befehl ausführen, um Ihr Image aus 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
Und dann verwenden Sie noch einmal die Cloud Shell-Vorschaufunktion, um zu Port 8081 zu wechseln:
Dies sollte Sie an den API-Endpunkt weiterleiten. Möglicherweise erhalten Sie die Meldung „Nicht autorisiert“ aber keine Sorge. Entfernen Sie "?authuser=3", um zum Dashboard zu gelangen. 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 von einem Entwicklungs- oder lokalen Computer aus auf das Dashboard zugreifen. Verwenden Sie dazu eine ähnliche Anleitung, wenn Sie in der Webkonsole auf „Verbinden“ klicken. für den Cluster, den Sie überwachen möchten.
Wenn Sie mit dem Dashboard fertig sind, drücken Sie Strg+C, um den Proxy 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 finden die gesamte Logausgabe der Pods unter Stackdriver → Logging → Logs in der Google Cloud Console:
Wenn Sie sich in der Logging-Konsole befinden, können Sie zu GKE-Container gehen, um alle von STDOUT erfassten Logs anzuzeigen:
Von hier aus können Sie die Protokolle optional zur weiteren Protokollanalyse in Google BigQuery exportieren oder logbasierte Benachrichtigungen einrichten. Das können wir heute während des Labs nicht machen.
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
Fertig! 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 ausgeführten Pods gelöscht werden) und den Dienst (dadurch wird auch Ihr externer Load-Balancer gelöscht):
Löschen Sie zuerst den Dienst und die Bereitstellung, wodurch auch Ihr externer Load-Balancer gelöscht wird:
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 abschließend den Storage-Bucket der Docker-Registry, in dem Ihre Images gehostet werden:
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/...
Natürlich können Sie auch das gesamte Projekt löschen. Dadurch würden jedoch alle vorgenommenen Abrechnungseinstellungen verloren gehen. Dazu muss die Projektabrechnung zuerst deaktiviert werden. Außerdem werden beim Löschen eines Projekts erst nach Ablauf des aktuellen Abrechnungszeitraums alle Abrechnungen beendet.
Behandelte Themen
- Eine einfache ASP.NET Core-App als Docker-Container verpacken
- So erstellen Sie einen Kubernetes-Cluster in Google Kubernetes Engine.
- 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.