1. Prima di iniziare
Google fornisce un potente strumento di creazione di immagini con cui puoi creare e pubblicare facilmente un'immagine container Docker ottimizzata per le app Java in pochissimo tempo e senza Docker o Dockerfile. Inoltre, Google Cloud introduce il serverless nei container con Cloud Run, una piattaforma di computing gestita che scala automaticamente i tuoi container stateless. In questo codelab, vedrai quanto è facile containerizzare la tua app Spring Boot Kotlin, pubblicare su Container Registry ed eseguire l'immagine su Google Cloud in modo semplice.
Questo codelab ti guida nella configurazione di un'app semplice in Kotlin, che dimostra l'utilizzo di servizi e strumenti Google Cloud tra cui Jib, Container Registry e Cloud Run.
Prerequisiti
- Familiarità con il linguaggio di programmazione e gli strumenti Java
- Conoscenza degli editor di testo standard Linux, quali Vim, Emacs e nano
In questo lab proverai a:
- Configura un'app Kotlin di Spring Boot.
- Creare un'immagine Docker ottimizzata.
- Pubblica l'immagine in Container Registry.
- Esegui l'app containerizzata in Cloud Run.
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Google Chrome
2. Preparazione
Configurazione dell'ambiente da seguire in modo autonomo
- 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.
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
.
- 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$.
Cloud Shell
Mentre Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione in Google 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. Inizializzare un'app Spring Boot
- Genera una nuova app Spring Boot con Spring Initializr.
$ curl https://start.spring.io/starter.tgz \ -d language=kotlin \ -d dependencies=web \ -d baseDir=kotlin-jib-cloud-run | tar -xzvf -
Tieni presente che l'inizializzazione aggiungerà automaticamente spring-boot-starter-web
alle tue dipendenze in pom.xml
dell'app modello.
- Passa alla directory dell'app modello.
$ cd kotlin-jib-cloud-run
- Crea ed esegui l'app utilizzando Maven.
$ ./mvnw -DskipTests spring-boot:run
- Una volta avviata, l'app inizierà ad ascoltare sulla porta 8080. Fai clic su Anteprima web nella barra degli strumenti di Cloud Shell e seleziona Anteprima sulla porta 8080 per accedere all'app.
- Dovresti ricevere una risposta 404 perché l'app non fa ancora nulla di utile. Interrompi l'app con
Control+C
.
4. Aggiungi un controller web
- Crea la seguente classe
Controller
nel pacchetto demo:
$ vi src/main/kotlin/com/example/demo/Controller.kt or $ nano src/main/kotlin/com/example/demo/Controller.kt
src/main/kotlin/com/example/demo/Controller.kt
package com.example.demo
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController
@RestController
class Controller {
@GetMapping("/")
fun saySomething(): String {
return "Kotlin app on Cloud Run, containerized by Jib!"
}
}
- Ricrea ed esegui l'app.
$ ./mvnw spring-boot:run
- Controlla di nuovo l'app utilizzando Anteprima web . Questa volta dovresti vedere il messaggio "
Kotlin app on Cloud Run, containerized by Jib!
". Interrompi l'app conControl+C
.
5. Containerizza la tua app e pubblicala in Container Registry
Con Jib, puoi containerizzare la tua app in modo ottimizzato senza Docker e pubblicare in qualsiasi Container Registry.
- Prima di procedere, devi attivare l'API Container Registry. Questa operazione deve essere eseguita una sola volta per progetto per rendere accessibile l'API.
$ gcloud services enable containerregistry.googleapis.com
- Esegui Jib per creare un'immagine Docker e pubblicarla in Container Registry.
$ ./mvnw com.google.cloud.tools:jib-maven-plugin:3.1.1:build \ -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/kotlin-jib-cloud-run
Alla fine, vedrai il seguente messaggio che indica che l'app è containerizzata e inviata a Container Registry.
[INFO] Built and pushed image as gcr.io/PROJECT_ID/kotlin-jib-cloud-run ... [INFO] BUILD SUCCESS
Se viene visualizzato un errore, verifica che $GOOGLE_CLOUD_PROJECT
sia impostato correttamente per il tuo ID progetto Google Cloud (PROJECT_ID
).
- Prima di andare avanti, controlla se l'immagine è stata pubblicata correttamente. Torna alla console Cloud, fai clic su Menu di navigazione e seleziona Container Registry.
Vedrai che l'immagine è stata pubblicata.
6. Esegui l'app containerizzata in Cloud Run
Cloud Run porta l'ambiente serverless nei container, scalando automaticamente i container stateless.
- Fai di nuovo clic su Menu di navigazione e seleziona Cloud Run.
Se è la prima volta che accedi a Cloud Run, verrà visualizzata la seguente finestra di dialogo per la configurazione una tantum. Fai clic su Inizia a utilizzare Cloud Run se viene visualizzata.
- Nella pagina Cloud Run, fai clic su Crea servizio.
- Nella schermata successiva, fai clic su Seleziona in Origine. L'origine è l'immagine da eseguire su Cloud Run.
- La finestra di dialogo mostrerà l'immagine che hai creato in precedenza. Seleziona l'immagine e fai clic su Continua.
- Ti mancano solo un paio di clic per iniziare subito a implementare l'app. In Piattaforma di deployment, scegli Cloud Run (completamente gestito) per gestire completamente il servizio su Google Cloud. Scegli una regione appropriata per la tua località, seleziona Consenti chiamate non autenticate e fai clic su Crea. È tutto.
Una volta completato il deployment dell'immagine, nella pagina di Cloud Run viene visualizzato un URL per accedere all'app. Dagli un'occhiata.
Alla fine vedrai il messaggio che ti aspetti dall'app.
Kotlin app on Cloud Run, containerized by Jib!
È tutto. Se in futuro dovrai eseguire il deployment di nuove versioni dell'app, fai clic su Deployment di nuova revisione nella pagina.
7. Esegui la pulizia
- Per ripulire l'ambiente, devi eliminare l'app di cui è stato eseguito il deployment in Cloud Run e l'immagine pubblicata su Container Registry. Vai a Cloud Run, seleziona l'app e fai clic su Elimina.
- Analogamente, vai alla pagina di Container Registry ed elimina l'immagine.
8. Complimenti
Complimenti! Hai containerizzato l'app Spring Boot Kotlin e ne hai eseguito il deployment in Cloud Run.
Con Jib, hai creato un'immagine container ottimizzata senza Docker installato o scritto un Dockerfile e l'hai pubblicata in Container Registry. Jib ottimizza la creazione di immagini, in modo che chiunque non abbia una conoscenza approfondita di Docker possa containerizzare le app Java in modo rapido ed efficiente. Poi, con pochi clic, hai eseguito il deployment dell'app in Cloud Run per iniziare la distribuzione in pochissimo tempo.
Scopri di più
- Esegui il deployment di un'app Java in Kubernetes su Google Kubernetes Engine
- Documentazione di Cloud Run
- Panoramica di Cloud Run
- Introduzione a Jib per migliorare la creazione di immagini Java Docker
- Crea container più velocemente con Jib, uno strumento di creazione di immagini di Google per app Java
- Jib: containerizza la tua app Java
- Canale Jib Gitter
- Mailing list degli utenti Jib