1. Panoramica
ASP.NET Core è un nuovo framework open source e multipiattaforma per creare applicazioni moderne basate su cloud e connesse a internet utilizzando il linguaggio di programmazione C#.
Kubernetes è un progetto open source eseguibile in molti ambienti diversi, dai laptop ai cluster multinodo ad alta disponibilità, dai cloud pubblici alle implementazioni on-premise, dalle macchine virtuali alle soluzioni bare metal.
In questo lab eseguirai il deployment di una semplice app ASP.NET Core in Kubernetes in esecuzione su Kubernetes Engine. Questo codelab si basa sul codelab Crea e avvia l'app ASP.NET Core da Google Cloud Shell. Ti consigliamo di eseguire questo lab prima di iniziare questo.
L'obiettivo di questo codelab è trasformare il tuo codice (una semplice app Hello World ASP.NET Core qui) in un'applicazione replicata in esecuzione su Kubernetes. Devi trasformare il codice che hai sviluppato sulla macchina in un'immagine container Docker ed eseguirla su Google Kubernetes Engine.
Ecco un diagramma delle varie parti in gioco in questo codelab per aiutarti a capire come si incastrano i vari pezzi. usalo come riferimento man mano che procedi nel codelab. dovrebbe essere tutto chiaro quando arrivi alla fine (ma ignora pure questo 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'utilizzo di Kubernetes anziché sulla configurazione dell'infrastruttura sottostante.
Se vuoi eseguire Kubernetes sulla tua macchina locale, ad esempio un laptop per lo sviluppo, probabilmente dovresti prendere in considerazione Minikube. Questa opzione offre una semplice configurazione di un cluster Kubernetes a nodo singolo per scopi di sviluppo e test. Se vuoi, puoi usare Minikube per seguire questo codelab.
Obiettivi didattici
- Pacchettizzare una semplice app ASP.NET Core come container Docker.
- Creare un cluster Kubernetes su Google Kubernetes Engine (GKE).
- Eseguire il deployment dell'app ASP.NET Core in un pod.
- Come consentire il traffico esterno al pod.
- Come fare lo scale up del servizio e implementare un upgrade.
- Come eseguire la dashboard grafica di Kubernetes.
Che cosa ti serve
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con la piattaforma Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo 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 progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi aggiornarla 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 importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere è identificato come
PROJECT_ID). Se l'ID generato non ti soddisfa, puoi generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimarrà per tutta la durata del progetto. - Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. Eseguire questo codelab non dovrebbe costare molto. Per arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial, puoi eliminare le risorse che hai creato o eliminare l'intero progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Avvia Cloud Shell
Anche se Google Cloud può essere utilizzato 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
- Dalla console Cloud, fai clic su Attiva Cloud Shell
.
Se non hai mai avviato Cloud Shell, ti viene mostrata una schermata intermedia (below the fold) che descrive di cosa si tratta. In tal caso, fai clic su Continua (e non la vedrai più). Ecco come appare quella singola schermata:
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto semplicemente con un browser o 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 confermare che il comando gcloud è a conoscenza del 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. Verrà visualizzata la versione dello strumento a riga di comando dotnet installato:
dotnet --version
Quindi, crea uno scheletro di app web ASP.NET Core.
dotnet new mvc -o HelloWorldAspNetCore
Questo dovrebbe creare un progetto e ripristinare le sue 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
Siamo quasi pronti 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 l'ascolto 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 Anteprima web in alto a destra e seleziona "Anteprima sulla porta 8080".
Verrà visualizzata la pagina web predefinita di ASP.NET Core:
Dopo aver verificato che l'app sia in esecuzione, premi Ctrl+C per arrestarla.
5. Pacchettizzazione dell'app ASP.NET Core come container Docker
A questo punto, prepara l'app per l'esecuzione come container. Il primo passaggio consiste nel definire il container e i suoi contenuti.
Nella directory di base dell'app, crea un Dockerfile per definire l'immagine Docker.
touch Dockerfile
Aggiungi quanto segue a Dockerfile usando 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 rimane in ascolto del traffico in entrata (8080). A questo scopo, imposta la variabile di ambiente ASPNETCORE_URLS, che viene usata dalle app ASP.NET Core per determinare quale porta ascoltare.
Salva Dockerfile. Ora creiamo l'immagine:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Al termine (il download e l'estrazione di tutti i dati richiederà un po' di tempo), vedrai 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 il comando seguente che eseguirà un container Docker localmente sulla porta 8080 dall'immagine container appena creata:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Sfrutta di nuovo la funzionalità di anteprima web di CloudShell :
Dovresti vedere la pagina web predefinita di ASP.NET Core in una nuova scheda.
Dopo aver verificato che l'app funziona correttamente localmente in un container Docker, puoi arrestare il container in esecuzione entro il giorno 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 accessibili da ogni progetto Google Cloud (ma anche dall'esterno della piattaforma Google Cloud) :
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Se tutto funziona correttamente, dopo un po' di tempo dovresti riuscire a 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 orchestrare, come vedrai tra qualche minuto.
Se vuoi saperne di più, puoi esplorare le immagini container man mano che sono archiviate in Google Cloud Storage seguendo questo link: https://console.cloud.google.com/storage/browser/ (il link completo risultante deve essere in questo formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. crea un cluster Kubernetes
Ora tutto è pronto per creare il tuo cluster GKE, ma prima vai alla sezione Google Kubernetes Engine della console web e attendi l'inizializzazione del sistema (l'operazione 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.
Utilizza l'interfaccia a riga di comando gcloud della sessione di CloudShell per creare un cluster. Regola la zona in una posizione 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
A questo punto dovresti avere un cluster Kubernetes completamente funzionante basato su Google Kubernetes Engine:
È ora 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 successiva. kubectl version mostrerà la versione corrente del comando.
7. Crea deployment
Un pod di Kubernetes è un gruppo di container, collegati tra loro ai fini dell'amministrazione e del networking. Può contenere uno o più container. Qui utilizzerai semplicemente un container creato con la tua immagine ASP.NET Core archiviata nel tuo Container Registry privato. I contenuti verranno pubblicati sulla porta 8080.
Crea un file hello-dotnet.yaml usando 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 metodo consigliato per creare e scalare i pod. Qui, un nuovo deployment gestisce una singola replica di pod che esegue l'immagine hello-dotnet:v1.
Per visualizzare il deployment appena creato, esegui semplicemente:
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 è un buon momento per eseguire alcuni comandi kubectl interessanti (nessuno di questi modificherà 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 comunque renderlo accessibile al mondo esterno.
8. Consenti traffico esterno
Per impostazione predefinita, il pod è accessibile solo dal suo IP interno all'interno del cluster. Per rendere il container hello-dotnet accessibile dall'esterno della rete virtuale Kubernetes, devi esporre il pod come servizio Kubernetes.
Da Cloud Shell puoi esporre il pod alla rete internet pubblica con il comando kubectl expose combinato con il flag --type="LoadBalancer". Questo flag è obbligatorio per la creazione di un IP accessibile dall'esterno :
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 di Compute Engine). Tieni presente che esponi il deployment, non direttamente il pod. Ciò farà sì che il servizio risultante bilancia il carico del traffico tra tutti i pod gestiti dal deployment (in questo caso solo 1 pod, ma aggiungerai altre repliche in un secondo momento).
Il master Kubernetes crea il bilanciatore del carico e le relative regole di forwarding di Compute Engine, i pool di destinazione e le regole firewall per rendere il servizio completamente accessibile dall'esterno di Google Cloud Platform.
Per trovare l'indirizzo IP del servizio accessibile pubblicamente, richiedi semplicemente a kubectl di 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 sono elencati due indirizzi IP per il tuo servizio, entrambi sulla porta 8080. uno è l'IP interno visibile solo all'interno della tua rete virtuale cloud; mentre l'altro è IP esterno con bilanciamento del carico. In questo esempio, l'indirizzo IP esterno è 104.155.20.69.
Ora dovresti essere in grado di accedere al servizio puntando il browser all'indirizzo: http://<EXTERNAL_IP>:8080
A questo punto hai acquisito almeno diverse funzionalità dal passaggio ai container e a Kubernetes: non devi specificare su quale host eseguire il carico di lavoro. Inoltre, puoi sfruttare il monitoraggio e il riavvio del servizio. Vediamo cos'altro puoi ottenere dalla tua nuova infrastruttura Kubernetes.
9. Scala il servizio
Una delle potenti funzionalità offerte da Kubernetes è la facilità di scalabilità dell'applicazione. Supponiamo che tu abbia improvvisamente bisogno di più capacità per la tua applicazione. puoi semplicemente indicare 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
Qui puoi notare l'approccio dichiarativo: anziché avviare o arrestare nuove istanze, devi dichiarare quante istanze devono essere in esecuzione in qualsiasi momento. I loop di riconciliazione di Kubernetes si limitano ad assicurarsi che la realtà corrisponda a quanto richiesto e intervengono, se necessario.
Ecco un diagramma che riassume lo stato del tuo cluster Kubernetes:
Puoi anche fare lo scale down del servizio molto facilmente. Ecco come fare lo scale down da 4 pod a 2 pod.
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. Testa la resilienza
Kubernetes (o più specificamente ReplicaSet) controlla i pod e, se si verifica un problema nel pod, ne crea subito uno nuovo. Proviamolo e vediamo come funziona.
Innanzitutto, 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, noterai che un nuovo pod viene creato ed eseguito nuovamente subito:
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 un upgrade del servizio
A un certo punto, l'applicazione di cui hai eseguito il deployment in produzione richiederà correzioni di bug o funzionalità aggiuntive. Vediamo come funziona questo processo.
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
Modificalo con questo:
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 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 è tutto pronto per consentire a Kubernetes di aggiornare senza problemi il controller di replica alla nuova versione dell'applicazione. Per cambiare l'etichetta dell'immagine per il container in esecuzione, devi modificare il valore 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 del deployment completa. Al momento non è necessario comprendere la configurazione YAML completa. Tieni solo presente che aggiornando il campo spec.template.spec.containers.image nella configurazione, dici 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
Questo aggiorna il deployment con la nuova immagine, causando la creazione di nuovi pod con la nuova immagine e i vecchi pod.
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-dotnet 4 5 4 3 1h
Durante questa operazione, gli utenti dei servizi non dovrebbero riscontrare alcuna interruzione. Dopo un po' di tempo inizieranno ad accedere alla nuova versione dell'applicazione.
Per ulteriori dettagli sugli aggiornamenti in sequenza, consulta la documentazione di Kubernetes.
Con queste funzionalità di deployment, scalabilità e aggiornamento, ci auguriamo che una volta configurato il tuo ambiente (qui il tuo 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 il push manuale dell'immagine in Container Registry della piattaforma Google Cloud. È anche possibile rimandare entrambi i passaggi a Cloud Build lato server, che può creare ed eseguire il push dell'immagine container senza dover installare locale di Docker.
Innanzitutto, abilita l'API Cloud Build in Gestore API > Raccolta. 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 nel seguente modo:
Una volta abilitata l'API Cloud Build, puoi eseguire questo comando per creare l'immagine ed eseguirne il push dal servizio Container Builder:
$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3
L'immagine viene archiviata automaticamente su Container Registry.
13. esegui la dashboard grafica di Kubernetes
Con le recenti versioni di Kubernetes, è stata introdotta una Graphic Web User Interface (dashboard). Questa interfaccia utente consente di iniziare rapidamente e attiva alcune delle funzionalità presenti nell'interfaccia a riga di comando in modo da poter interagire con il sistema in modo più accessibile e rilevabile.
Per configurare l'accesso alla 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:
Dovrebbe aprirsi l'endpoint API. Potresti ricevere l'etichetta "Non autorizzato" ma non preoccuparti. Per accedere al pannello, rimuovi "?authuser=3" e sostituiscilo con "/ui".
Goditi la dashboard grafica di Kubernetes e utilizzala per il deployment di applicazioni containerizzate, nonché per il monitoraggio e la gestione dei cluster.
In alternativa, puoi accedere alla dashboard da un computer locale o di sviluppo utilizzando istruzioni simili fornite quando, dalla console web, premi il pulsante "Connetti" per il cluster che vuoi monitorare.
Una volta terminato di lavorare con la dashboard, premi Ctrl + C per arrestare il proxy. Scopri di più sulla dashboard di Kubernetes partecipando al tour della dashboard.
14. Logging
Puoi utilizzare il comando kubectl logs per recuperare i log di un container in esecuzione all'interno di Kubernetes. Quando usi Google Kubernetes Engine per eseguire cluster Kubernetes gestiti, tutti i log vengono inoltrati e archiviati in Google Cloud Logging. Per visualizzare tutti gli output di log dai pod, vai a Stackdriver → Logging → Log nella console Google Cloud:
Nella console di logging, puoi accedere al container GKE per visualizzare tutti i log raccolti da STDOUT:
Da qui, puoi facoltativamente esportare i log in Google BigQuery per ulteriori analisi dei log o configurare avvisi basati su log. Oggi non lo faremo durante il lab.
15. Complimenti!
Questo conclude questo semplice codelab per iniziare con ASP.NET Core e Kubernetes. Abbiamo solo scalfito la superficie di questa tecnologia e ti invitiamo a esplorare ulteriormente la possibilità di utilizzare pod, controller di replica e servizi di tua proprietà, ma anche di dare un'occhiata ai probe di attività (controlli di integrità) e di valutare l'utilizzo diretto dell'API Kubernetes.
Esegui la pulizia
È tutto. È il momento di ripulire le risorse utilizzate (per risparmiare sui costi ed essere una buona cittadinanza del cloud).
Elimina il deployment (che elimina anche i pod in esecuzione) e il servizio (che elimina anche il bilanciatore del carico esterno):
Prima di tutto, elimina il servizio e il deployment, il che comporta anche l'eliminazione del bilanciatore del carico esterno:
kubectl delete service,deployment hello-dotnet
service "hello-dotnet" deleted deployment "hello-dotnet" deleted
Quindi, 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].
Questa operazione elimina tutte le istanze di Google Compute Engine che eseguono il cluster.
Infine, elimina il bucket di archiviazione del Docker Registry 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/...
Ovviamente, puoi anche eliminare l'intero progetto, ma perderai tutte le impostazioni di fatturazione (è necessario disattivare prima la fatturazione del progetto). Inoltre, l'eliminazione di un progetto interromperà la fatturazione solo al termine del ciclo di fatturazione corrente.
Argomenti trattati
- Pacchettizzare una semplice app ASP.NET Core come container Docker.
- Come creare un cluster Kubernetes su Google Kubernetes Engine.
- Eseguire il deployment dell'app ASP.NET Core in un pod.
- Come consentire il traffico esterno al pod.
- Come fare lo scale up del servizio e implementare 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.
- 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.