1. Panoramica
ASP.NET Core è un nuovo framework open source e multipiattaforma per la creazione di moderne applicazioni basate sul cloud e connesse a internet utilizzando il linguaggio di programmazione C#.
Kubernetes è un progetto open source eseguibile in numerosi ambienti, dai laptop ai cluster multinodo ad alta affidabilità, dai cloud pubblici ai deployment on-premise, dalle macchine virtuali alle soluzioni bare metal.
In questo lab, esegui il deployment di una semplice app ASP.NET Core in Kubernetes in esecuzione su Kubernetes Engine. Questo codelab si basa sul codelab Build and launch ASP.NET Core app from Google Cloud Shell. Ti consigliamo di svolgere prima questo lab.
Lo scopo di questo codelab è trasformare il tuo codice (in questo caso una semplice app ASP.NET Core Hello World) in un'applicazione replicata in esecuzione su Kubernetes. Prendi il codice che hai sviluppato sul tuo computer, lo trasformi in un'immagine container Docker e poi esegui l'immagine su Google Kubernetes Engine.
Ecco un diagramma delle varie parti in gioco in questo codelab per aiutarti a capire come si combinano. Utilizza questo elenco come riferimento man mano che avanzi nel codelab. Tutto dovrebbe avere senso quando arriverai alla fine (ma sentiti libero di ignorarlo per ora).
Ai fini di questo codelab, l'utilizzo di un ambiente gestito come Kubernetes Engine (una versione di Kubernetes ospitata da Google in esecuzione su Compute Engine) ti consente di concentrarti maggiormente sull'esperienza con Kubernetes anziché sulla configurazione dell'infrastruttura sottostante.
Se ti interessa eseguire Kubernetes sulla tua macchina locale, ad esempio un laptop di sviluppo, ti consigliamo di dare un'occhiata a Minikube. In questo modo è possibile configurare facilmente un cluster Kubernetes a un singolo nodo a scopo di sviluppo e test. Se vuoi, puoi utilizzare Minikube per seguire questo codelab.
Obiettivi didattici
- Come pacchettizzare una semplice app ASP.NET Core come container Docker.
- Come creare il cluster Kubernetes su Google Kubernetes Engine (GKE).
- Come eseguire il deployment dell'app ASP.NET Core in un pod.
- Come consentire il traffico esterno al pod.
- Come scalare il servizio ed eseguire il rollout di un upgrade.
- Come eseguire la dashboard grafica di Kubernetes.
Che cosa ti serve
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Google Cloud Platform?
2. Configurazione e requisiti
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi aggiornarlo in qualsiasi momento.
- L'ID progetto deve essere univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (in genere è identificato come
PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimarrà per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. L'esecuzione di questo codelab non dovrebbe costare molto, se non nulla. Per arrestare le risorse in modo da non incorrere in costi di fatturazione al termine di questo tutorial, puoi eliminare le risorse che hai creato o l'intero progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Attiva Cloud Shell
- Nella console Cloud, fai clic su Attiva Cloud Shell
.
Se non hai mai avviato Cloud Shell, viene visualizzata una schermata intermedia (sotto la piega) che ne descrive le funzionalità. In questo caso, fai clic su Continua e non comparirà più. Ecco come si presenta la schermata intermedia:
Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.
Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte del lavoro per questo codelab, se non tutto, può essere svolto semplicemente con un browser o con Chromebook.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto:
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Crea un'app ASP.NET Core in Cloud Shell
Nel prompt di Cloud Shell, puoi verificare che lo strumento a riga di comando dotnet sia già installato controllandone la versione. Dovrebbe essere stampata la versione dello strumento a riga di comando dotnet installato:
dotnet --version
Poi, crea un nuovo scheletro di app web ASP.NET Core.
dotnet new mvc -o HelloWorldAspNetCore
Viene creato un progetto e ne vengono ripristinate le dipendenze. Dovresti vedere un messaggio simile al seguente.
Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.
Restore succeeded.
4. Esegui l'app ASP.NET Core
È quasi tutto pronto per eseguire la nostra app. Vai alla cartella dell'app.
cd HelloWorldAspNetCore
Infine, esegui l'app.
dotnet run --urls=http://localhost:8080
L'applicazione inizia ad ascoltare sulla porta 8080.
Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.
Per verificare che l'app sia in esecuzione, fai clic sul pulsante di anteprima web in alto a destra e seleziona "Anteprima sulla porta 8080".
Vedrai la pagina web ASP.NET Core predefinita:
Dopo aver verificato che l'app è in esecuzione, premi Ctrl+C per chiuderla.
5. Pacchettizzare l'app ASP.NET Core come container Docker
Successivamente, prepara l'app per l'esecuzione come container. Il primo passaggio consiste nel definire il contenitore e i relativi contenuti.
Nella directory di base dell'app, crea un Dockerfile per definire l'immagine Docker.
touch Dockerfile
Aggiungi quanto segue a Dockerfile utilizzando il tuo editor preferito (vim, nano,emacs o l'editor di codice di Cloud Shell).
# 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"]
Una configurazione importante inclusa nel Dockerfile è la porta su cui l'app è in attesa di traffico in entrata (8080). Ciò si ottiene impostando la variabile di ambiente ASPNETCORE_URLS, che le app ASP.NET Core utilizzano per determinare la porta da ascoltare.
Salva questo Dockerfile. Ora creiamo l'immagine:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Al termine dell'operazione (il download e l'estrazione di tutti i file richiedono un po' di tempo), puoi vedere che l'immagine è stata creata e salvata localmente:
docker images REPOSITORY TAG gcr.io/yourproject-XXXX/hello-dotnet v1
Testa l'immagine in locale con questo comando, che eseguirà un container Docker in locale sulla porta 8080 dalla tua immagine container appena creata:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
E ancora una volta, sfrutta la funzionalità di anteprima web di Cloud Shell :
Dovresti vedere la pagina web ASP.NET Core predefinita in una nuova scheda.
Dopo aver verificato che l'app viene eseguita correttamente in locale in un container Docker, puoi arrestare il container in esecuzione Ctrl-> C.
Ora che l'immagine funziona come previsto, puoi eseguirne il push in Google Container Registry, un repository privato per le tue immagini Docker accessibile da ogni progetto Google Cloud (ma anche dall'esterno di Google Cloud) :
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Se tutto va bene e dopo un po' di tempo, dovresti essere in grado di vedere l'immagine container elencata nella sezione Container Registry. A questo punto, hai a disposizione un'immagine Docker a livello di progetto a cui Kubernetes può accedere e che può orchestrare, come vedrai tra qualche minuto.
Se vuoi, puoi esplorare le immagini dei container così come sono archiviate in Google Cloud Storage seguendo questo link: https://console.cloud.google.com/storage/browser/ (il link risultante completo dovrebbe avere questo formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. Crea cluster Kubernetes
Ok, ora puoi creare il tuo cluster GKE, ma prima vai alla sezione Google Kubernetes Engine della console web e attendi l'inizializzazione del sistema (dovrebbe richiedere solo pochi secondi).
Un cluster è costituito da un server API master Kubernetes gestito da Google e da un insieme di nodi worker. I nodi worker sono macchine virtuali Compute Engine.
Utilizziamo la CLI gcloud dalla sessione Cloud Shell per creare un cluster. Imposta la zona su una località vicina a te ( l'elenco delle zone). Il completamento dell'operazione richiede alcuni minuti:
gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b
Alla fine, dovresti vedere il cluster creato.
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
Ora dovresti avere un cluster Kubernetes completamente funzionante basato su Google Kubernetes Engine:
Ora è il momento di eseguire il deployment della tua applicazione containerizzata nel cluster Kubernetes. D'ora in poi utilizzerai la riga di comando kubectl (già configurata nel tuo ambiente Cloud Shell). Il resto di questo codelab richiede che la versione del client e del server Kubernetes sia 1.2 o successive. kubectl version mostrerà la versione attuale del comando.
7. Crea deployment
Un pod Kubernetes è un gruppo di container collegati tra loro per scopi di amministrazione e networking. Può contenere un singolo container o più container. Qui utilizzerai semplicemente un container creato con l'immagine ASP.NET Core archiviata nel tuo registro container privato. Pubblicherà i contenuti sulla porta 8080.
Crea un file hello-dotnet.yaml utilizzando il tuo editor preferito (vim, nano,emacs o l'editor di codice di Cloud Shell) e definisci il deployment Kubernetes per il 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
Esegui il deployment nello spazio dei nomi predefinito con kubectl:
kubectl apply -f hello-dotnet.yaml
deployment.apps/hello-dotnet created
Come puoi vedere, hai creato un oggetto deployment. I deployment sono il modo consigliato per creare e scalare i pod. Qui, un nuovo deployment gestisce una singola replica del pod che esegue l'immagine hello-dotnet:v1.
Per visualizzare il deployment che hai appena creato, esegui:
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 1 1 1 1 37s
Per visualizzare il pod creato dal deployment, esegui questo comando:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-ztzrb 1/1 Running 0 57s
Ora è il momento giusto per esaminare alcuni comandi kubectl interessanti (nessuno di questi cambierà lo stato del cluster, la documentazione completa è disponibile qui):
kubectl get pods kubectl cluster-info kubectl config view kubectl get events kubectl logs <pod-name>
A questo punto il container dovrebbe essere in esecuzione sotto il controllo di Kubernetes, ma devi ancora renderlo accessibile al mondo esterno.
8. Consenti traffico esterno
Per impostazione predefinita, il pod è accessibile solo tramite il suo IP interno all'interno del cluster. Per rendere accessibile il container hello-dotnet dall'esterno della rete virtuale Kubernetes, devi esporre il pod come servizio Kubernetes.
Da Cloud Shell puoi esporre il pod a internet pubblico con il comando kubectl expose combinato con il flag --type="LoadBalancer". Questo flag è obbligatorio per la creazione di un IP accessibile esternamente :
kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080
Il flag utilizzato in questo comando specifica che utilizzerai il bilanciatore del carico fornito dall'infrastruttura sottostante (in questo caso il bilanciatore del carico Compute Engine). Tieni presente che esponi il deployment e non il pod direttamente. In questo modo, il servizio risultante bilancerà il carico del traffico su tutti i pod gestiti dal deployment (in questo caso solo un pod, ma in seguito aggiungerai altre repliche).
Il master Kubernetes crea il bilanciatore del carico e le regole di forwarding, i pool di destinazione e le regole firewall di Compute Engine correlate per rendere il servizio completamente accessibile dall'esterno di Google Cloud.
Per trovare l'indirizzo IP accessibile pubblicamente del servizio, richiedi semplicemente kubectl per elencare tutti i servizi del cluster:
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
Tieni presente che per il tuo servizio sono elencati due indirizzi IP, entrambi che gestiscono la porta 8080. Uno è l'IP interno, visibile solo all'interno della rete virtuale cloud, l'altro è l'IP esterno bilanciato del carico. In questo esempio, l'indirizzo IP esterno è 104.155.20.69.
Ora dovresti essere in grado di raggiungere il servizio indirizzando il browser a questo indirizzo: http://<EXTERNAL_IP>:8080
A questo punto hai acquisito almeno diverse funzionalità passando ai container e a Kubernetes: non devi specificare su quale host eseguire il carico di lavoro e usufruisci anche del monitoraggio e del riavvio del servizio. Vediamo cos'altro puoi ottenere dalla tua nuova infrastruttura Kubernetes.
9. Scalare il servizio
Una delle potenti funzionalità offerte da Kubernetes è la facilità di scalare l'applicazione. Supponiamo che tu abbia improvvisamente bisogno di più capacità per la tua applicazione. Puoi semplicemente chiedere al controller di replica di gestire un nuovo numero di repliche per il tuo pod:
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
Tieni presente l'approccio dichiarativo: anziché avviare o arrestare nuove istanze, dichiari quante istanze devono essere in esecuzione in ogni momento. I cicli di riconciliazione di Kubernetes si limitano a verificare che la realtà corrisponda a ciò che hai richiesto e a intervenire se necessario.
Ecco un diagramma che riassume lo stato del tuo cluster Kubernetes:
Puoi anche ridurre facilmente le dimensioni del servizio. Ecco come ridurre il numero di pod da 4 a 2.
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. Testare la resilienza
Kubernetes (o più precisamente ReplicaSet) monitora i pod e, se qualcosa non va e il pod si arresta, ne crea subito uno nuovo. Proviamo a testare questa funzionalità e vediamo come funziona.
Per prima cosa, recupera l'elenco dei pod:
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
Elimina uno dei pod passando il nome del pod:
kubectl delete pod hello-dotnet-714049816-g4azy
Se esamini di nuovo l'elenco dei pod, vedrai che un nuovo pod viene creato ed eseguito immediatamente:
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. Implementa ed esegui l'upgrade del servizio
A un certo punto, l'applicazione che hai implementato in produzione richiederà correzioni di bug o funzionalità aggiuntive. Vediamo come si svolge questa procedura.
Innanzitutto, modifichiamo l'applicazione. Apri l'editor di codice da Cloud Shell.
Vai a Index.cshtml in HelloWorldAspNetCore > Views > Home e aggiorna uno dei messaggi del carosello.
Trova la seguente riga:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core
e modificalo in questo modo:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud
Salva le modifiche e torna a Cloud Shell. All'interno di HelloWorldAspNetCore, crea l'immagine Docker:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
ed esegui il push in Container Registry:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2
Ora Kubernetes è pronto per aggiornare senza problemi il controller di replica alla nuova versione dell'applicazione. Per modificare l'etichetta dell'immagine del container in esecuzione, devi modificare il hello-dotnet deployment esistente e cambiare l'immagine da gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 a gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.
Per farlo, utilizzerai il comando kubectl edit. Si aprirà un editor di testo che mostra la configurazione yaml di deployment completa. Non è necessario comprendere l'intera configurazione YAML in questo momento, ma è sufficiente capire che aggiornando il campo spec.template.spec.containers.image nella configurazione, indichi al deployment di aggiornare i pod in modo che utilizzino la nuova immagine.
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
Dopo aver apportato la modifica, salva e chiudi il file (viene utilizzato vi, quindi premi "Esc", digita :wq e premi il tasto "Invio").
deployment "hello-dotnet" edited
In questo modo, il deployment viene aggiornato con la nuova immagine, causando la creazione di nuovi pod con la nuova immagine e l'eliminazione dei vecchi pod.
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-dotnet 4 5 4 3 1h
Durante questo periodo, gli utenti dei servizi non dovrebbero riscontrare interruzioni. Dopo un po' inizieranno ad accedere alla nuova versione dell'applicazione.
Puoi trovare ulteriori dettagli sugli aggiornamenti in sequenza nella documentazione di Kubernetes.
Speriamo che con queste funzionalità di deployment, scalabilità e aggiornamento concorderai che, una volta configurato l'ambiente (il cluster GKE/Kubernetes), Kubernetes può aiutarti a concentrarti sull'applicazione anziché sulla gestione dell'infrastruttura.
12. Cloud Build
Finora abbiamo creato container con i normali comandi Docker (docker build ...) e poi abbiamo eseguito manualmente il push dell'immagine in Container Registry di Google Cloud. È anche possibile posticipare entrambi i passaggi al lato server Cloud Build, che può creare ed eseguire il push dell'immagine container senza l'installazione locale di Docker.
Innanzitutto, abilita l'API Cloud Build in API Manager > Libreria. Cerca Cloud Build e fai clic su API Cloud Build:
Fai clic su Abilita API, se non è già abilitata. Alla fine, dovresti vedere l'API abilitata come segue:
Una volta abilitata l'API Cloud Build, puoi eseguire il comando seguente per creare ed eseguire il push dell'immagine dal servizio Container Builder:
$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3
L'immagine viene archiviata automaticamente in Container Registry.
13. Esegui la dashboard grafica di Kubernetes
Nelle versioni recenti di Kubernetes è stata introdotta un'interfaccia utente web grafica (dashboard). Questa interfaccia utente ti consente di iniziare rapidamente e di utilizzare alcune delle funzionalità presenti nella CLI in modo più accessibile e rilevabile per interagire con il sistema.
Per configurare l'accesso al dashboard del cluster Kubernetes, digita questi comandi nella finestra di Cloud Shell :
gcloud container clusters get-credentials hello-dotnet-cluster \
--zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}
kubectl proxy --port 8081
Quindi, utilizza di nuovo la funzionalità di anteprima di Cloud Shell per passare alla porta 8081:
Dovresti essere reindirizzato all'endpoint API. Potresti visualizzare una pagina "Non autorizzato", ma non preoccuparti. Per accedere alla dashboard, rimuovi "?authuser=3" e sostituiscilo con "/ui".
Sfrutta la dashboard grafica di Kubernetes per eseguire il deployment di applicazioni containerizzate, nonché per monitorare e gestire i cluster.
In alternativa, puoi accedere alla dashboard da una macchina di sviluppo o locale utilizzando istruzioni simili a quelle fornite quando, dalla console web, premi il pulsante "Connetti" per il cluster che vuoi monitorare.
Al termine dell'utilizzo della dashboard, puoi premere Ctrl + C per arrestare il proxy. Scopri di più sulla dashboard Kubernetes con la visita guidata della dashboard.
14. Logging
Puoi utilizzare il comando kubectl logs per recuperare i log di un container in esecuzione all'interno di Kubernetes. Quando utilizzi Google Kubernetes Engine per eseguire cluster Kubernetes gestiti, tutti i log vengono inoltrati e archiviati automaticamente in Google Cloud Logging. Puoi visualizzare tutti gli output dei log dei pod andando su Stackdriver → Logging → Log in Google Cloud Console:
Una volta nella console Logging, puoi andare a Container GKE per visualizzare tutti i log raccolti da STDOUT:
Da qui, puoi facoltativamente esportare i log in Google BigQuery per un'ulteriore analisi dei log o configurare avvisi basati sui log. Non avremo tempo di farlo durante il lab di oggi.
15. Complimenti!
Con questo si conclude questo semplice codelab introduttivo ad ASP.NET Core e Kubernetes. Abbiamo solo scalfito la superficie di questa tecnologia e ti invitiamo a esplorarla ulteriormente con i tuoi pod, controller di replica e servizi, ma anche a dare un'occhiata ai probe di attività (controlli di integrità) e a valutare la possibilità di utilizzare direttamente l'API Kubernetes.
Esegui la pulizia
È tutto. È il momento di pulire le risorse utilizzate (per risparmiare sui costi ed essere un buon cittadino del cloud).
Elimina il deployment (che elimina anche i pod in esecuzione) e il servizio (che elimina anche il bilanciatore del carico esterno):
Innanzitutto, elimina il servizio e il deployment, che elimina anche il bilanciatore del carico esterno:
kubectl delete service,deployment hello-dotnet
service "hello-dotnet" deleted deployment "hello-dotnet" deleted
Dopodiché, elimina il 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].
Vengono eliminate tutte le istanze di Google Compute Engine che eseguono il cluster.
Infine, elimina il bucket di archiviazione del registro Docker che ospita le tue immagini:
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/...
Naturalmente, puoi anche eliminare l'intero progetto, ma perderai qualsiasi configurazione di fatturazione che hai eseguito (è necessario disattivare prima la fatturazione del progetto). Inoltre, l'eliminazione di un progetto interromperà tutta la fatturazione solo al termine del ciclo di fatturazione corrente.
Argomenti trattati
- Come pacchettizzare una semplice app ASP.NET Core come container Docker.
- Come creare il cluster Kubernetes su Google Kubernetes Engine.
- Come eseguire il deployment dell'app ASP.NET Core in un pod.
- Come consentire il traffico esterno al pod.
- Come scalare il servizio ed eseguire il rollout di un upgrade.
- Come eseguire la dashboard grafica di Kubernetes.
Passaggi successivi
- Scopri di più su Kubernetes ( http://kubernetes.io/).
- Scopri di più su Windows su Google Cloud Platform.
- Scopri di più su .NET su Google Cloud.
- Scopri di più su SQL Server su Google Cloud Platform.
- Scopri di più su Cloud Tools for Visual Studio.
- Scopri di più su Cloud Tools for PowerShell.
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.