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

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

Informazioni su questo codelab

Ultimo aggiornamento: apr 22, 2020

Scritto da un Googler

1. Prima di iniziare

Kubernetes è un progetto open source eseguibile in molti ambienti diversi, dai laptop ai cluster multinodo ad alta disponibilità, dai cloud pubblici ai deployment on-premise, dalle istanze delle macchine virtuali (VM) al bare metal.

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

Userai GKE, un servizio Kubernetes completamente gestito su Google Cloud, per concentrarti più sull'esperienza Kubernetes, anziché sulla configurazione dell'infrastruttura sottostante.

Se ti interessa eseguire Kubernetes sulla tua macchina locale, ad esempio un laptop per lo sviluppo, dai un'occhiata a Minikube, che offre una configurazione semplice di un cluster Kubernetes a nodo singolo per scopi di sviluppo e test. Se vuoi, puoi utilizzare Minikube per esplorare il codelab.

Il codelab utilizzerà il codice di esempio della guida Building a App with Spring Boot.

Prerequisiti

• Dimestichezza con gli strumenti e il linguaggio di programmazione Java
• Conoscenza degli editor di testo standard di Linux, ad esempio Vim, Emacs e nano

Attività previste

• Pacchettizza una semplice app Java come container Docker.
• Crea il cluster Kubernetes su GKE.
• Eseguire il deployment dell'app Java in Kubernetes su GKE.
• Fai lo scale up del servizio e implementa un upgrade.
• Accedere alla dashboard, un'interfaccia utente di Kubernetes basata sul Web.

Che cosa ti serve

• Un progetto Google Cloud
• Un browser, come Google Chrome

2. Configurazione e requisiti

Configurazione automatica dell'ambiente

1. Accedi a Cloud Console e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o G Suite, devi crearne uno.

Nota: puoi accedere facilmente a Cloud Console memorizzandone l'URL, ovvero console.cloud.google.com.

Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome sopra riportato è già stato utilizzato e non funzionerà per te). Vi verrà fatto riferimento più avanti in questo codelab come PROJECT_ID.

Nota: se utilizzi un account Gmail, puoi lasciare impostata la posizione predefinita su Nessuna organizzazione. Se utilizzi un account G Suite, scegli una sede adatta all'organizzazione.

2. Il prossimo passaggio consiste nell'attivare la fatturazione in Cloud Console per poter utilizzare le risorse Google Cloud.

L'esecuzione di questo codelab non dovrebbe costare più di qualche euro, ma potrebbe essere di più se decidi di utilizzare più risorse o se le lasci in esecuzione.

I nuovi utenti di Google Cloud sono idonei per una prova senza costi di 300 $.

Attiva Cloud Shell

1. In Cloud Console, fai clic su Attiva Cloud Shell .

Se non hai mai avviato Cloud Shell prima d'ora, ti verrà proposto uno schermo intermedio (below the fold) che descrive quello che è. In tal caso, fai clic su Continua (e non lo vedrai più). Ecco come si presenta la schermata una tantum:

Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.

Questa macchina virtuale è dotata di 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 e l'autenticazione della rete. Gran parte del lavoro in questo codelab, se non tutto, può essere svolto 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.

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 è lo strumento a riga di comando potente e unificato di Google Cloud. È già installato in Cloud Shell. Noterai il relativo supporto per il completamento delle schede. Per ulteriori informazioni, consulta la panoramica dello strumento a riga di comando gcloud.

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. Ottieni 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. Esegui l'app localmente

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

$ ./mvnw -DskipTests spring-boot:run

2. 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 e si connette al server appena avviato.

5. Pacchettizzazione dell'app Java come container Docker

Ora devi preparare la tua app per l'esecuzione su Kubernetes. Il primo passaggio consiste nel definire il container e i relativi contenuti.

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

$ ./mvnw -DskipTests package

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

$ gcloud services enable containerregistry.googleapis.com

3. Utilizza Jib per creare l'immagine container ed eseguirne il push in Container Registry.

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Se tutto funziona correttamente, dovresti essere in grado di visualizzare l'immagine container elencata nella console andando su Container Registry > Immagini. Ora è disponibile un'immagine Docker a livello di progetto a cui Kubernetes può accedere e orchestrare i contenuti come vedrai in pochi minuti.

Nota: anche se hai utilizzato un dominio generico per il Registro di sistema (gcr.io), puoi anche essere più specifico sulla zona e sul bucket da utilizzare. Per saperne di più, consulta la documentazione di Container Registry.

5. Dopodiché, occorrerà un po' di tempo per scaricare ed estrarre tutto. Puoi testare localmente l'immagine con il comando seguente, che eseguirà un container Docker come daemon sulla porta 8080 dall'immagine container appena creata:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

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

7. La pagina predefinita dovrebbe essere visualizzata in una nuova scheda. Dopo aver verificato che l'app è in esecuzione localmente in un container Docker, puoi interrompere il container in esecuzione premendo Control+C.

6. Crea il cluster

Puoi creare il tuo cluster GKE. Un cluster è composto da un server API Kubernetes gestito da Google e da un set di nodi worker. I nodi worker sono VM di Compute Engine.

1. Innanzitutto, assicurati che le funzionalità dell'API correlate siano attivate.

$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully

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

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

Infine, 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 in Cloud Console. Per accedervi, fai clic sul Menu di navigazione > Kubernetes Engine > Cluster > Crea cluster. Puoi creare un cluster in un'altra zona, ma consigliamo di rimanere nella stessa area geografica del bucket di archiviazione utilizzato da Container Registry.

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

È ora di eseguire il deployment della tua 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 successive. kubectl version mostrerà la versione corrente del comando.

7. Eseguire il deployment dell'app in Kubernetes

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

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

2. Per visualizzare il deployment che hai creato, esegui 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 di 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 tuo container dovrebbe essere in esecuzione sotto il controllo di Kubernetes, ma devi 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 a Internet pubblico con il comando kubectl expose combinato con il flag --type=LoadBalancer. Il flag è necessario per la creazione di un IP accessibile dall'esterno.

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

Il flag utilizzato nel comando specifica che utilizzerai il bilanciatore del carico fornito dall'infrastruttura sottostante. Tieni presente che esponerai direttamente il deployment, non il pod. In questo modo, il servizio risultante bilancia il carico del traffico tra tutti i pod gestiti dal deployment (in questo caso, solo un pod, ma ne aggiungerai altre in un secondo momento).

Il master Kubernetes crea il bilanciatore del carico e le regole di forwarding di Compute Engine correlate, 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 accessibile pubblicamente del servizio, è sufficiente richiedere kubectl per elencare tutti i servizi del 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: EXTERNAL-IP potrebbero essere necessari alcuni minuti prima che la disponibilità diventi disponibile e visibile. Se EXTERNAL-IP non è presente, attendi qualche minuto e riprova.

3. Nota che sono presenti due indirizzi IP per il tuo servizio e che entrambi utilizzano la porta 8080. Uno è l'indirizzo IP interno visibile solo all'interno del Virtual Private Cloud. L'altro è l'indirizzo IP esterno con bilanciamento del carico. Nell'esempio, l'indirizzo IP esterno è aaa.bbb.ccc.ddd. Ora dovresti essere in grado di raggiungere il servizio puntando il browser su http://<EXTERNAL_IP>:8080.

9. Scala il tuo servizio

Una delle potenti funzionalità offerte da Kubernetes è la facilità di scalabilità della tua app. Supponiamo che improvvisamente tu abbia bisogno di una maggiore capacità per la tua app. Puoi semplicemente chiedere al controller di replica di gestire un nuovo numero di repliche per le tue istanze di 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, dichiari quante istanze devono essere sempre in esecuzione. I loop di riconciliazione di Kubernetes garantiscono semplicemente che la realtà corrisponda a quanto richiesto e che intervenga, se necessario.

10. Implementare 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 alcun impatto sugli utenti.

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

package hello;

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.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Nota: la creazione e il push dell'immagine aggiornata dovrebbero essere molto più rapidi poiché puoi sfruttare appieno la memorizzazione nella cache.

Kubernetes è pronto per aggiornare facilmente il tuo 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 l'immagine da gcr.io/PROJECT_ID/hello-java:v1 a gcr.io/PROJECT_ID/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=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Nota: anche se ciò accade, gli utenti dei servizi potrebbero riscontrare delle interruzioni, ma questo è dovuto al fatto che non era configurato alcun controllo di integrità. Questa configurazione è leggermente più avanzata e non rientra nell'ambito del codelab.

6. Controlla nuovamente http://EXTERNAL_IP:8080 per verificare che restituisca la nuova risposta.

11. Rollback

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

$ kubectl rollout undo deployment/hello-java

12. Complimenti

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

Scopri di più

• Java su Google Cloud
• Esempi di codice Java
• Kubernetes su GKE: nozioni di base e avanzati