Esegui il deployment di un'app Java Spring Boot in Kubernetes su Google Kubernetes Engine

1. Prima di iniziare

Kubernetes è un progetto open source che può essere eseguito in molti ambienti diversi, dai laptop ai cluster multinodo ad alta disponibilità, dai cloud pubblici alle implementazioni on-premise e dalle istanze di macchine virtuali (VM) al bare metal.

In questo codelab, eseguirai il deployment di una semplice app web Java Spring Boot in Kubernetes su GKE, con l'obiettivo di eseguire l'app web come app replicata su Kubernetes. Prenderai il codice che sviluppi sulla tua macchina, lo trasformerai in un'immagine container Docker ed eseguirai l'immagine su GKE.

Utilizzerai GKE, un servizio Kubernetes completamente gestito su Google Cloud, per consentirti 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, dai un'occhiata a Minikube, che offre una semplice configurazione di un cluster Kubernetes a nodo singolo a scopo di sviluppo e test. Se vuoi, puoi usare Minikube per seguire il codelab.

Nel codelab verrà utilizzato il codice campione della guida sulla creazione di un'app con Spring Boot.

Prerequisiti

• Familiarità con il linguaggio di programmazione e gli strumenti Java
• Conoscenza degli editor di testo standard Linux, quali Vim, Emacs e nano

Attività previste

• Creare una semplice app Java come container Docker.
• Crea il tuo cluster Kubernetes su GKE.
• Esegui il deployment della tua app Java in Kubernetes su GKE.
• Fai lo scale up del servizio e implementa un upgrade.
• Accedi alla dashboard, un'interfaccia utente Kubernetes basata sul web.

Che cosa ti serve

• Un progetto Google Cloud
• Un browser, ad esempio Google Chrome.

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo autonomo

1. 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 sempre aggiornarla.
• L'ID progetto è 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 al tuo ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane 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.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da nessun altro utente dopo essere stato selezionato. Sei l'unico utente di quell'ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

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 nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Attiva Cloud Shell

1. Dalla console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.

Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.

Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. 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 con un browser.

Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che il progetto è 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].

Nota:se stai completando questo tutorial al di fuori di Cloud Shell, segui la procedura per la configurazione delle credenziali predefinite dell'applicazione.

3. Recupera codice sorgente

Dopo il lancio di Cloud Shell, puoi utilizzare la riga di comando per clonare il codice sorgente di esempio nella home directory.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

4. Eseguire l'app in locale

1. Assicurati che JAVA_HOME sia impostata sulla versione corretta:

$ export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

2. Puoi avviare l'app Spring Boot normalmente con il plug-in Spring Boot.

$ ./mvnw -DskipTests spring-boot:run

3. Dopo l'avvio dell'app, fai clic su Anteprima web nella barra degli strumenti di Cloud Shell e seleziona Anteprima sulla porta 8080.

Si apre una scheda del browser che si collega al server appena avviato.

5. Pacchettizzazione dell'app Java come container Docker

Il prossimo passo è preparare l'app per l'esecuzione su Kubernetes. Il primo passaggio consiste nel definire il container e i suoi contenuti.

1. Crea il JAR di cui è possibile eseguire il deployment per l'app.

$ ./mvnw -DskipTests package

2. Abilita l'API Artifact Registry per archiviare l'immagine container che creerai.

$ gcloud services enable artifactregistry.googleapis.com

3. Crea un nuovo repository Docker se non ne esiste uno. Prima di eseguire il push delle immagini, devi creare un repository:

$ gcloud artifacts repositories create codelabrepo     --repository-format=docker --location=us-central1 

4. L'immagine avrà questo formato:

{LOCATION}-docker.pkg.dev/{PROJECT-ID}/{REPOSITORY}/{IMAGE-NAME}

Ad esempio, se hai creato il repository nella località us-central1 denominata codelabrepo e vuoi assegnare il nome hello-java:v1 alla tua immagine, l'immagine sarà:

us-central1-docker.pkg.dev/{PROJECT-ID}/codelabrepo/hello-java:v1

5. Utilizza Jib per creare l'immagine container ed eseguirne il push ad Artifact Registry.

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format="value(core.project)"`

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/codelabrepo/hello-java:v1

6. Per visualizzare l'immagine container nella console, vai alla pagina Immagini Artifacts Registry nella console Cloud. Ora hai a disposizione un'immagine Docker a livello di progetto, a cui Kubernetes può accedere e orchestrare come vedrai tra pochi minuti.
7. (Facoltativo) Dopo il completamento (il download e l'estrazione di tutti i dati richiedono del tempo), testa l'immagine con il comando seguente, che eseguirà un container Docker come daemon sulla porta 8080 dall'immagine container appena creata. Se riscontri problemi relativi alle autorizzazioni, esegui prima gcloud auth configure-docker us-central1-docker.pkg.dev:

$ docker run -ti --rm -p 8080:8080 \
  us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

8. Anche in questo caso, sfrutta la funzionalità di anteprima web di Cloud Shell.

9. Dovresti vedere la pagina predefinita in una nuova scheda. Dopo aver verificato che l'app sia in esecuzione localmente in un container Docker, puoi arrestare il container in esecuzione premendo Control+C.

6. Crea il tuo cluster

È tutto pronto per creare il tuo cluster GKE. Un cluster è costituito da un server API Kubernetes gestito da Google e da un insieme di nodi worker. I nodi worker sono VM di Compute Engine.

1. Innanzitutto, assicurati che le funzionalità API correlate siano abilitate.

$ gcloud services enable compute.googleapis.com container.googleapis.com

2. Crea un cluster con due nodi n1-standard-1 (il completamento richiederà alcuni minuti).

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Alla fine dovresti vedere il cluster creato.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Nota:in alternativa, puoi creare il cluster nella console Cloud. Per accedervi, fai clic sul menu di navigazione > Kubernetes Engine > Cluster > Crea cluster. Puoi creare un cluster in un'altra zona, ma è consigliabile rimanere nella stessa regione del bucket di archiviazione utilizzato da Container Registry.

A questo punto dovresti avere un cluster Kubernetes completamente funzionante basato su GKE.

È il momento di eseguire il deployment dell'app containerizzata nel cluster Kubernetes. D'ora in poi utilizzerai la riga di comando kubectl (già configurata nel tuo ambiente Cloud Shell). Il resto del codelab richiede che il client e la versione del server Kubernetes siano 1.2 o successivi. kubectl version mostrerà la versione corrente del comando.

7. Esegui il deployment dell'app in Kubernetes

1. Un deployment Kubernetes può creare, gestire e scalare più istanze della tua app utilizzando l'immagine container che hai creato. Esegui il deployment di un'istanza della tua app in Kubernetes utilizzando il comando kubectl run.

$ kubectl create deployment hello-java --image=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

2. Per visualizzare il deployment che hai creato, esegui semplicemente questo comando:

$ kubectl get deployments

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

3. Per visualizzare le istanze dell'app create dal deployment, esegui questo comando:

$ kubectl get pods

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

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-java accessibile dall'esterno della rete virtuale Kubernetes, devi esporre il pod come servizio Kubernetes.

1. In Cloud Shell, puoi esporre il pod alla rete internet pubblica creando un servizio Kubernetes LoadBalancer.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Tieni presente che sei tu a esporre direttamente il deployment, non 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 un 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.

2. Per trovare l'indirizzo IP del servizio accessibile pubblicamente, richiedi semplicemente a kubectl di elencare tutti i servizi cluster.

$ kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Nota: potrebbero essere necessari diversi minuti prima che EXTERNAL-IP sia disponibile e visibile. Se l'EXTERNAL-IP non è presente, attendi qualche minuto e riprova.

3. Ora dovresti essere in grado di accedere al servizio aprendo con il browser la pagina http://<EXTERNAL_IP>:8080.

9. Scala il servizio

Una delle potenti funzionalità offerte da Kubernetes è la facilità di scalabilità della tua app. Supponiamo che tu abbia improvvisamente bisogno di più capacità per la tua app. Puoi semplicemente indicare al controller di replica di gestire un nuovo numero di repliche per le istanze dell'app.

$ kubectl scale deployment hello-java --replicas=3

deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Nota l'approccio dichiarativo. Anziché avviare o arrestare nuove istanze, devi dichiarare quante istanze devono essere sempre in esecuzione. I loop di riconciliazione di Kubernetes si limitano ad assicurarsi che la realtà corrisponda a quanto richiesto e agiscono se necessario.

10. Implementa un upgrade del servizio

A un certo punto, l'app di cui hai eseguito il deployment in produzione richiederà correzioni di bug o funzionalità aggiuntive. Kubernetes può aiutarti a eseguire il deployment di una nuova versione in produzione senza influire sugli utenti.

1. Apri l'editor di codice facendo clic su Apri editor nel menu di Cloud Shell.
2. Vai a src/main/java/com/example/springboot/HelloController.java e aggiorna il valore della risposta.

package com.example.springboot;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Utilizza Jib per creare una nuova versione dell'immagine container ed eseguirne il push. La creazione e il push dell'immagine aggiornata dovrebbero essere molto più rapidi man mano che sfrutti appieno la memorizzazione nella cache.

$ ./mvnw -DskipTests package com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

Kubernetes può aggiornare senza problemi il controller di replica alla nuova versione dell'app.

4. Per cambiare l'etichetta dell'immagine per il container in esecuzione, devi modificare il deployment hello-java esistente e cambiare l'immagine da us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v1

verso us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v2

5. Puoi utilizzare il comando kubectl set image per chiedere a Kubernetes di eseguire il deployment della nuova versione dell'app nell'intero cluster un'istanza alla volta con aggiornamenti in sequenza.

$ kubectl set image deployment/hello-java hello-java=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

deployment "hello-java" image updated

Nota:durante questa azione, gli utenti dei servizi potrebbero riscontrare interruzioni, ma il motivo è che non è stato configurato alcun controllo di integrità. Si tratta di una configurazione leggermente più avanzata che esula dall'ambito del codelab.

6. Controlla di nuovo http://EXTERNAL_IP:8080 per verificare che stia restituendo la nuova risposta.

11. Rollback

Spiacenti. Hai commesso un errore con la nuova versione dell'app? Forse la nuova versione conteneva un errore e dovrai eseguirne rapidamente il rollback. Con Kubernetes, puoi facilmente eseguirne il rollback allo stato precedente. Esegui il rollback dell'app eseguendo questo comando:

$ kubectl rollout undo deployment/hello-java

Dovresti vedere la risposta precedente quando controlli di nuovo http://EXTERNAL_IP:8080.

12. Complimenti

Hai imparato a creare ed eseguire il deployment di una nuova app web basata su Java in Kubernetes su GKE.

Pulizia

$ gcloud container clusters delete hello-java-cluster --zone us-central1-c

$ gcloud container images delete us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1 us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

Scopri di più

• Java su Google Cloud
• Esempi di codice Java
• Kubernetes su GKE: dalle basi a quella avanzata