Esegui il deployment dell'app ASP.NET Core in Google Kubernetes Engine con Istio (parte 1)

1. Panoramica

ASP.NET Core è un framework open source e multipiattaforma per creare applicazioni moderne basate su cloud e connesse a internet utilizzando il linguaggio di programmazione C#.

Kubernetes è un sistema open source per l'automazione del deployment, della scalabilità e della gestione delle applicazioni containerizzate. Istio è un framework aperto per connettere, proteggere, gestire e monitorare i servizi.

In questa prima parte del lab, eseguirai il deployment di una semplice app ASP.NET Core su Kubernetes in esecuzione su Google Kubernetes Engine (GKE) e la configurerai in modo che sia gestita da Istio.

Nella seconda parte del lab esplorerai ulteriormente le funzionalità di Istio, come metriche, tracciamento, gestione dinamica del traffico, fault injection e altro.

Obiettivi didattici

• Creare e pacchettizzare una semplice app ASP.NET Core in un container Docker.
• Creare un cluster Kubernetes con Google Kubernetes Engine (GKE).
• Come installare Istio su un cluster Kubernetes su GKE.
• Come eseguire il deployment dell'app ASP.NET Core e configurare il relativo traffico per la gestione da parte di Istio.

Che cosa ti serve

• Un browser, ad esempio Chrome o Firefox

Come utilizzerai questo tutorial?

Solo lettura Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con la piattaforma Google Cloud?

Principiante Livello intermedio Eccellente

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo autonomo

1. Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Nota: puoi accedere facilmente alla console Cloud memorizzando il relativo URL, che è console.cloud.google.com.

Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome precedente è già stato utilizzato e non funzionerà correttamente). Verrà indicato più avanti in questo codelab come PROJECT_ID.

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una località adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.

Eseguire questo codelab non dovrebbe costare molto. Assicurati di seguire le istruzioni nella sezione "Pulizia" in cui viene spiegato come arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione su Google Cloud.

Attiva Cloud Shell

1. 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.

2. 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`

Nota:lo strumento a riga di comando gcloud è uno strumento a riga di comando potente e unificato disponibile in Google Cloud. È già installato in Cloud Shell. Noterai che supporta il completamento della scheda. Per ulteriori informazioni, consulta la panoramica dello strumento a riga di comando gcloud.

3. 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 in un 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:5.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:5.0-alpine 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.

Tieni presente che anche se in questo caso abbiamo utilizzato un dominio generico per il registry (gcr.io), puoi anche essere più specifico sulla zona e sul bucket da utilizzare. I dettagli sono documentati qui: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

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/GKE con Istio

Innanzitutto, assicurati che l'API Kubernetes Engine sia abilitata:

gcloud services enable container.googleapis.com

Creare un cluster Kubernetes. Puoi modificare la regione impostandola in una zona più vicina a te, se vuoi:

gcloud container clusters create hello-istio \
  --cluster-version=latest \
  --machine-type=n1-standard-2 \
  --num-nodes=4 \
  --region europe-west1

Attendi qualche istante mentre il cluster è configurato per te. Sarà visibile nella sezione Kubernetes Engine della console della piattaforma Google Cloud.

Per questo codelab, scaricheremo e installeremo Istio da istio.io. Esistono altre opzioni di installazione, tra cui il componente aggiuntivo Istio per GKE e Anthos Service Mesh. I passaggi dell'applicazione successivi a questo funzioneranno su qualsiasi installazione di Istio.

Prima di tutto scarica il client Istio e gli esempi. La pagina di rilascio di Istio offre gli artefatti di download per diversi sistemi operativi. Nel nostro caso, possiamo usare un comodo comando per scaricare ed estrarre la release più recente per la nostra piattaforma attuale:

curl -L https://istio.io/downloadIstio | sh -

Lo script indicherà la versione di Istio scaricata:

Istio has been successfully downloaded into the istio-1.8.1 folder on your system.

La directory di installazione contiene applicazioni di esempio e il programma binario del client istioctl. Passa alla directory:

cd istio-1.8.1

Copia e incolla il comando fornito per aggiungere la directory bin a PATH, in modo da poter utilizzare istioctl:

export PATH="$PATH:/home/<YOURHOMEID>/istio-1.8.1/bin"

Verifica che istioctl sia disponibile controllando che il cluster sia pronto per Istio:

istioctl x precheck

Dovresti vedere il messaggio Install Pre-Check passed! The cluster is ready for Istio installation.

Installa Istio con il profilo demo:

istioctl install --set profile=demo

Istio è ora installato nel tuo cluster.

Inserimento automatico di file collaterali

Per iniziare a utilizzare Istio, non è necessario apportare modifiche all'applicazione. Quando configuri ed esegui i servizi, i file collaterali di Envoy vengono automaticamente inseriti in ogni pod per il servizio.

Affinché questo comando funzioni, devi abilitare l'inserimento di file collaterali per lo spazio dei nomi ("predefinito") che utilizzi per i tuoi microservizi. Per farlo, devi applicare un'etichetta:

kubectl label namespace default istio-injection=enabled

Per verificare che l'etichetta sia stata applicata correttamente, esegui questo comando:

kubectl get namespace -L istio-injection

L'output conferma che l'inserimento del file collaterale è abilitato per lo spazio dei nomi predefinito:

NAME              STATUS   AGE    ISTIO-INJECTION
default           Active   3m     enabled
istio-system      Active   63s    disabled
...

7. Verifica l'installazione

Istio include tre servizi: il piano di controllo istiod e i gateway in entrata e in uscita (che possono essere considerati "proxy sidecar per il resto di internet"), denominati rispettivamente istio-ingressgateway e istio-egressgateway.

kubectl get svc -n istio-system

L'output dovrebbe avere il seguente aspetto:

NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP                                                                     AGE
istio-egressgateway    ClusterIP      10.55.252.182   <none>
istio-ingressgateway   LoadBalancer   10.55.250.185   35.233.118.42
istiod                 ClusterIP      10.55.253.217   <none>

Il gateway di Ingress è di tipo LoadBalancer, pertanto è accessibile da internet; gli altri devono essere accessibili solo dall'interno del cluster.

Dopodiché, assicurati che venga eseguito il deployment dei pod Kubernetes corrispondenti e che tutti i container siano attivi e in esecuzione:

kubectl get pods -n istio-system

Quando tutti i pod sono in esecuzione, puoi procedere.

NAME                                    READY   STATUS
istio-egressgateway-674988f895-m6tk4    1/1     Running
istio-ingressgateway-6996f7dcc8-7lvm2   1/1     Running
istiod-6bf5fc8b64-j79hj                 1/1     Running

• istiod: il piano di controllo Istio. Gestisce la configurazione e la programmazione dei file collaterali del proxy, la scoperta dei servizi, la distribuzione dei certificati e l'inserimento dei file collaterali
• ingress gateway: gestisce le richieste in arrivo dall'esterno del cluster.
• egress gateway: gestisce le richieste in uscita agli endpoint esterni al cluster.

8. Esegui il deployment dell'applicazione

Ora che hai verificato che Istio sia installato e in esecuzione, puoi eseguire il deployment dell'app ASP.NET Core.

Deployment e servizi

Per prima cosa, crea un file aspnetcore.yaml usando il tuo editor preferito (vim, nano,emacs o l'editor di codice di Cloud Shell) e definisci il deployment e il servizio Kubernetes per l'app:

Assicurati di sostituire YOUR-PROJECT-ID con l'ID del tuo progetto

apiVersion: v1
kind: Service
metadata:
  name: aspnetcore-service
  labels:
    app: aspnetcore
spec:
  ports:
  - port: 8080
    name: http
  selector:
    app: aspnetcore
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aspnetcore-v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aspnetcore
      version: v1
  template:
    metadata:
      labels:
        app: aspnetcore
        version: v1
    spec:
      containers:
      - name: aspnetcore
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

I contenuti del file sono deployment e servizi standard per il deployment dell'applicazione e non contengono nulla di specifico per Istio.

Esegui il deployment dei servizi nello spazio dei nomi predefinito con kubectl:

kubectl apply -f aspnetcore.yaml

service "aspnetcore-service" created
deployment.extensions "aspnetcore-v1" created

Verifica che i pod siano in esecuzione:

kubectl get pods

NAME                          READY     STATUS    RESTARTS   AGE
aspnetcore-v1-6cf64748-mddb   2/2       Running   0          34s

Hai notato che ogni pod include due container? Questi sono il container dell'applicazione e il container sidecar del proxy Istio. I proxy sono stati inseriti automaticamente all'avvio dei pod.

Gateway e VirtualService

Per consentire al traffico in entrata di raggiungere il mesh, devi creare un gateway e un VirtualService.

Un gateway configura un bilanciatore del carico per il traffico HTTP/TCP, normalmente operato a livello perimetrale del mesh per abilitare il traffico in entrata per un'applicazione. Un servizio VirtualService definisce le regole che controllano il modo in cui le richieste di un servizio vengono instradate all'interno di un mesh di servizi Istio.

Crea un file aspnetcore-gateway.yaml per definire il gateway:

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: aspnetcore-gateway
spec:
  selector:
    istio: ingressgateway # use istio default controller
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"

Crea un file aspnetcore-virtualservice.yaml per definire il servizio VirtualService:

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: aspnetcore-virtualservice
spec:
  hosts:
  - "*"
  gateways:
  - aspnetcore-gateway
  http:
  - route:
    - destination:
        host: aspnetcore-service

Esegui il comando kubectl per eseguire il deployment del gateway con:

kubectl apply -f aspnetcore-gateway.yaml

Il comando produce il seguente output:

gateway.networking.istio.io "aspnetcore-gateway" created

Quindi, esegui questo comando per eseguire il deployment di VirtualService:

kubectl apply -f aspnetcore-virtualservice.yaml

Il comando produce il seguente output:

virtualservice.networking.istio.io "aspnetcore-virtualservice" created

Verifica che tutto sia in esecuzione:

kubectl get gateway

NAME                      AGE
aspnetcore-gateway   28s

kubectl get virtualservice

NAME                             AGE
aspnetcore-virtualservice   33s

Complimenti! Hai appena eseguito il deployment di un'applicazione abilitata per Istio. Poi vedrai l'applicazione in uso.

9. testa l'applicazione

Puoi finalmente vedere l'applicazione in azione. Devi ottenere l'IP esterno e la porta del gateway. È elencato sotto EXTERNAL-IP:

kubectl get svc istio-ingressgateway -n istio-system

Esporta l'IP e la porta esterni in una variabile GATEWAY_URL:

export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')

export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')

export GATEWAY_URL=$INGRESS_HOST:$INGRESS_PORT

Usa curl per testare l'app. Il servizio deve rispondere con un codice di risposta 200:

curl -o /dev/null -s -w "%{http_code}\n" http://${GATEWAY_URL}/

In alternativa, puoi aprire il browser e andare a http://<gatewayurl> per visualizzare l'app:

10. Complimenti!

Hai appena eseguito il deployment di una semplice app ASP.NET Core in Kubernetes in esecuzione su Google Kubernetes Engine (GKE) e l'hai configurata per la gestione da parte di Istio.

Forse ti starai chiedendo: "Qual è il vantaggio di Istio?". È un'ottima domanda. Finora, non è vantaggioso far gestire a Istio questa app. Nella seconda parte del lab, esploreremo ulteriormente le funzionalità di Istio, come metriche, tracciamento, gestione dinamica del traffico, visualizzazione dei servizi e fault injection.

Passaggi successivi

• Esegui il deployment dell'app ASP.NET Core su GKE con Istio (parte 2).
• Scopri di più su Istio.
• Scopri di più su Kubernetes.
• Scopri di più su Google Kubernetes Engine.
• Scopri di più su .NET su Google Cloud.

Licenza

Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.

11. Esegui la pulizia

Se non prosegui con la seconda parte del lab, puoi eliminare l'app e disinstallare Istio oppure puoi semplicemente eliminare il cluster Kubernetes.

Eliminare l'app

Per eliminare l'app:

kubectl delete -f aspnetcore-gateway.yaml
Kubectl delete -f aspnetcore-virtualservice.yaml
kubectl delete -f aspnetcore.yaml

Per verificare che l'app sia stata rimossa:

kubectl get gateway 
kubectl get virtualservices 
kubectl get pods

Disinstallare Istio

Per eliminare Istio:

kubectl delete -f install/kubernetes/istio-demo-auth.yaml

Per verificare che Istio non sia più disponibile:

kubectl get pods -n istio-system

Elimina cluster Kubernetes

gcloud container clusters delete hello-istio