1. Introduzione
Perché è così difficile gestire le applicazioni?
Uno dei motivi principali è che spesso gli sviluppatori devono essere amministratori di sistema part-time. Considera questo elenco (parziale) di problemi per sviluppare, eseguire il deployment e gestire una moderna applicazione web di produzione :
Non so tu, ma non voglio preoccuparmi di queste cose. Quello che voglio davvero pensare è la logica della mia applicazione:
Questo, in breve, è lo scopo di Cloud Run: ti offre la possibilità di concentrarti sulla tua app, lasciando tutta l'amministrazione e la manutenzione a qualcun altro, ovvero Google, che ha investito milioni di ore per perfezionare e perfezionare le proprie competenze in questo dominio.
Oltre alle sfide amministrative menzionate sopra, devi anche affrontare:
- Dipendenze: l'ambiente in cui viene eseguita l'app, ove possibile, deve corrispondere esattamente all'ambiente in cui è stata testata. Può comprendere diverse dimensioni, tra cui sistema operativo, librerie di supporto, interprete o compilatore di lingue, configurazione hardware e molti altri fattori.
- Distribuzione: passare da una versione locale di un'app a una condivisa ampiamente su internet richiede spesso un cambiamento dell'ambiente di runtime, un salto di qualità nella complessità e una curva di apprendimento ripida.
Cloud Run si occupa di questi e molti altri problemi per te. Ma anziché crederci sulla parola, creiamo insieme un'app e vediamo com'è facile passare da un ambiente di sviluppo locale a un'app cloud di produzione in pochi semplici passaggi.
Attività previste
- Dovrai creare una semplice app web e verificare che venga eseguita come previsto nel tuo ambiente di sviluppo.
- Quindi passerai a una versione containerizzata della stessa app. Lungo il percorso, scoprirai cosa significa containerizzazione e perché è così utile.
- Infine, eseguirai il deployment della tua app nel cloud e vedrai quanto è facile gestire il tuo servizio Cloud Run utilizzando la riga di comando e la console Google Cloud.
Cosa imparerai...
- Creare una semplice app server web in Python
- Come pacchettizzare la tua app in un container Docker eseguito ovunque
- Come eseguire il deployment della tua app nel cloud in modo che chiunque possa provare la tua nuova creazione
- Come semplificare ulteriormente i passaggi precedenti utilizzando Buildpacks
- Utilizzare lo strumento a riga di comando di Google Cloud e la UI web della console Cloud
Che cosa ti serve...
- Un browser web
- Un Account Google
Questo lab è rivolto a sviluppatori di tutti i livelli, inclusi i principianti. Anche se utilizzerai Python, non è necessario avere familiarità con la programmazione Python per capire cosa sta succedendo, perché ti spiegheremo tutto il codice che utilizzi.
2. Configurazione
Questa sezione illustra tutto ciò che devi fare per iniziare a utilizzare questo lab.
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$.
Avvia Cloud Shell
In questo lab lavorerai in una sessione di Cloud Shell, un interprete di comandi ospitato da una macchina virtuale in esecuzione nel cloud di Google. Potresti eseguire facilmente questa sezione in locale sul tuo computer, ma l'utilizzo di Cloud Shell offre a chiunque l'accesso a un'esperienza riproducibile in un ambiente coerente. Dopo il lab, puoi riprovare questa sezione sul tuo computer.
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].
Imposta alcune variabili di ambiente nel terminale che semplificano la vita nei passaggi successivi:
export PROJ=$GOOGLE_CLOUD_PROJECT export APP=hello export PORT=8080 export REGION="us-central1" export TAG="gcr.io/$PROJ/$APP"
Abilita le API
Nei passaggi successivi vedrai dove (e perché) sono necessari questi servizi, ma per il momento esegui questo comando per concedere al tuo progetto l'accesso ai servizi Cloud Build, Container Registry e Cloud Run:
gcloud services enable cloudbuild.googleapis.com \
containerregistry.googleapis.com \
run.googleapis.com
Dovrebbe essere visualizzato un messaggio di operazione riuscita simile a questo:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. Crea una semplice app web
Per iniziare, fai clic sul pulsante Open Editor nella parte superiore del riquadro di Cloud Shell. Ha questo aspetto:
Ti troverai quindi in un ambiente IDE simile a Visual Studio Code, in cui puoi creare progetti, modificare il codice sorgente, eseguire programmi e così via. Se lo schermo è troppo ristretto, puoi espandere o ridurre la linea di demarcazione tra la console e la finestra di modifica/terminale trascinando la barra orizzontale tra queste due regioni, evidenziata qui:
Puoi spostarti tra l'editor e il terminale facendo clic rispettivamente sui pulsanti Open Editor e Open Terminal. Prova a passare da un ambiente all'altro ora.
Quindi, crea una cartella in cui archiviare il lavoro per questo lab, selezionando File->Nuova cartella, inserisci hello e fai clic su OK. Tutti i file creati in questo lab, così come tutto il lavoro che svolgi in Cloud Shell, si svolgeranno in questa cartella.
Ora crea un file requirements.txt. Questo indica a Python le librerie da cui dipende la tua app. Per questa semplice app web, utilizzerai un popolare modulo Python per creare server web chiamato Flask e un framework per server web chiamato gunicorn. Nella finestra dell'editor di Cloud, fai clic sul menu File->Nuovo file per creare un nuovo file. Quando viene richiesto il nome del nuovo file, inserisci requirements.txt e premi il pulsante OK. Assicurati che il nuovo file finisca nella cartella del progetto hello.
Inserisci le righe seguenti nel nuovo file per specificare che la tua app dipende dal pacchetto Python Flask e dal server web gunicorn.
Flask gunicorn
Non è necessario salvare esplicitamente questo file perché Cloud Editor salverà automaticamente le modifiche.
Versione 1: Hello world!
Utilizzando la stessa tecnica, crea un altro nuovo file denominato main.py. Questo sarà il file di origine Python principale (e unico) della tua app. Anche in questo caso, assicurati che il nuovo file finisca nella cartella del progetto hello.
Inserisci il seguente codice in questo file:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
html = "<h1>Hello world!</h1>"
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Torna al terminale e passa alla cartella del progetto con questo comando:
cd hello
Esegui questo comando per installare le dipendenze del progetto:
pip3 install -r requirements.txt
Ora avvia l'app eseguendo questo comando nel terminale:
python3 main.py
A questo punto, l'app è in esecuzione sulla macchina virtuale dedicata alla sessione di Cloud Shell. Cloud Shell include un meccanismo di proxy che ti permette di accedere ai server web (come quello appena avviato) in esecuzione sulla tua macchina virtuale da qualsiasi luogo sulla rete internet globale.
Fai clic sul pulsante web preview e poi sulla voce di menu Preview on Port 8080 in questo modo:
Nell'app in esecuzione viene aperta una scheda del browser web, che dovrebbe avere un aspetto simile a questo:
Versione 2: Ripetizione del percorso dell'URL
Torna all'Editor Cloud (tramite il pulsante Open Editor) e aggiungi il supporto per l'eco di un suffisso URL facoltativo aggiornando il file main.py come segue:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"]) # ← NEW
def say_hello(name="world"): # ← MODIFIED
html = f"<h1>Hello {name}!</h1>" # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Torna al Terminale (tramite il pulsante Open Terminal) e inserisci control-C (tieni premuto il tasto Ctrl mentre premi "C") per interrompere l'app in esecuzione, quindi riavviala inserendo:
python3 main.py
Fai di nuovo clic sul pulsante web preview e poi sulla voce di menu Preview on Port 8080 per aprire una scheda del browser web sull'app in esecuzione. Dovresti vedere di nuovo il messaggio "Hello World!" ma ora sostituisci il testo dell'URL che segue la barra con qualsiasi stringa di tua scelta (ad es. /your-name) e verifica che venga visualizzato qualcosa di simile a questo:
Versione 3: colori casuali
Ora aggiungi il supporto per colori di sfondo casuali tornando a Cloud Editor (tramite il pulsante Open Editor) e aggiornando il file main.py come segue:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb): # ← NEW
sum = round( # ← NEW
(int(rgb[0]) * 0.299) # ← NEW
+ (int(rgb[1]) * 0.587) # ← NEW
+ (int(rgb[2]) * 0.114) # ← NEW
) # ← NEW
return "black" if sum > 186 else "white" # ← NEW
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
bg = random.sample(range(1, 255), 3) # ← NEW
hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2]) # ← NEW
fg_color = set_text_color(bg) # ← NEW
bg_color = f"#{hex:06x}" # ← NEW
style = f"color:{fg_color}; background-color:{bg_color}" # ← NEW
html = f'<h1 style="{style}">Hello {name}!</h1>' # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Torna al Terminale (tramite il pulsante Open Terminal) e inserisci control-C (tieni premuto il tasto Ctrl mentre premi "C") per interrompere l'app in esecuzione, quindi riavviala inserendo:
python3 main.py
Fai di nuovo clic sul pulsante web preview e poi sulla voce di menu Preview on Port 8080 per aprire una scheda del browser web sull'app in esecuzione. Dovresti vedere il testo generato, con qualsiasi suffisso specificato o il valore predefinito "Hello world!". stringa, visualizzata davanti a uno sfondo di colore casuale, come il seguente:
Ricarica la pagina alcune volte per vedere che il colore di sfondo casuale cambia ogni volta che visiti l'app.
Complimenti, la tua app è pronta. Nel passaggio successivo, scoprirai come pacchettizzare la tua app in un container e perché è una cosa utile da fare.
4. Containerizza la tua app
Che cos'è un container?
I container in generale e Docker in particolare, ci danno la possibilità di creare una casella modulare in cui eseguire un'applicazione con tutte le sue dipendenze raggruppate insieme. Chiamiamo il risultato un'immagine container. In questa sezione creerai un'immagine container che utilizzerai per incapsulare la tua applicazione e tutte le sue dipendenze.
A proposito di dipendenze, in un passaggio precedente, quando eseguivi l'app in un ambiente di sviluppo dovevi eseguire pip3 install -r requirements.txt e assicurarti che il file requirements.txt contenga tutte le librerie dipendenti e le versioni corrispondenti. Con i container, questi requisiti vengono installati quando generi l'immagine container, quindi il consumatore del container non deve preoccuparsi di installare nulla.
Questa immagine container costituirà il componente di base di base per il deployment dell'applicazione in Cloud Run. Poiché i container possono essere utilizzati su quasi tutti i server virtuali o reali, questo ci permette di eseguire il deployment della tua applicazione ovunque tu voglia e di spostare la tua applicazione da un fornitore di servizi a un altro oppure da on-premise al cloud.
I container consentono alle tue applicazioni di:
- riproducibili: i container sono autonomi e completi
- portatili: i container sono componenti di base per più settori, che consentono la portabilità delle applicazioni tra fornitori di servizi cloud e ambienti
In breve, i container offrono la possibilità di "scrivere una volta ed eseguire ovunque". Un'eccezione a questa regola è che il container generato è vincolato all'esecuzione sul tipo di processore su cui è stato creato, ma esistono modi per generare versioni di container anche per altre configurazioni hardware.
Ne ho abbastanza di parlare, creiamo un container! Utilizzerai una tecnologia specifica per creare un container chiamato Docker.
Nell'editor di Cloud, crea un nuovo file denominato Dockerfile. Questo file è uno schema per costruire la tua immagine. Illustra a Docker il tuo ambiente operativo, il codice sorgente e come installare le dipendenze, creare l'app ed eseguire il codice.
# Use an official lightweight Python image.
FROM python:3.9-slim
# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .
# Install dependencies into this container so there's no need to
# install anything at container run time.
RUN pip install -r requirements.txt
# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080
# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments
# with multiple CPU cores, increase the number of workers to match
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app
Nel terminale Cloud, crea la tua immagine container utilizzando Cloud Build, eseguendo questo comando:
gcloud builds submit --tag $TAG
Una volta eseguito il push nel registry, vedrai un messaggio SUCCESS contenente il nome dell'immagine, che dovrebbe avere un aspetto simile al seguente: gcr.io/<project-id>/hello. L'immagine è ora archiviata in Google Container Registry e può essere riutilizzata quando e dove vuoi.
Puoi utilizzare questo comando per elencare tutte le immagini container associate al tuo progetto attuale:
gcloud container images list
Ora esegui e testa l'applicazione in locale da Cloud Shell, utilizzando questi comandi docker:
docker run -p $PORT:$PORT -e PORT=$PORT $TAG
L'opzione -p $PORT:$PORT indica a Docker di mappare la porta esterna $PORT (impostata su 8080 sopra) nell'ambiente host allo stesso numero di porta all'interno del container in esecuzione. Questo semplifica la vita perché il codice server che scrivi e il numero di porta esterna a cui ti connetti quando testi la tua app sono gli stessi (8080), ma potresti utilizzare altrettanto facilmente l'opzione -p per mappare qualsiasi porta esterna arbitraria sull'host a qualsiasi porta interna desiderata all'interno del container.
L'opzione -e PORT=$PORT indica a Docker di rendere disponibile la variabile di ambiente $PORT (impostata su 8080 sopra) per la tua app in esecuzione all'interno del container.
Ora è tutto pronto per testare l'app puntando un browser web al codice Python in esecuzione all'interno del container. Nella finestra di Cloud Shell, fai clic su "Anteprima web". e seleziona "Anteprima sulla porta 8080", come hai fatto nel passaggio precedente.
Il risultato dovrebbe essere familiare: dovresti vedere il testo generato su uno sfondo di colore casuale, proprio come facevi quando eseguivi l'app direttamente nel tuo terminale Cloud Shell. Ricarica la pagina alcune volte per vedere che il colore di sfondo casuale cambia ogni volta che visiti l'app.
Complimenti! Hai eseguito una versione containerizzata della tua app. Nella sezione successiva, senza toccare una riga di codice, trasformerai l'immagine container in un'app web di qualità per la produzione.
5. Al cloud...
Ora che hai containerizzato la tua app, vuoi condividere questa meraviglia con il resto del mondo, quindi è il momento di eseguirne il deployment nel cloud. ma vorresti fare di più che condividerli. Devi assicurarti che:
- funziona in modo affidabile: ottieni la tolleranza di errore automatica nel caso in cui un computer su cui la tua app si arresti in modo anomalo
- scalabilità automatica: la tua app rimarrà al passo con ampi livelli di traffico e ridurrà automaticamente la sua impronta se inutilizzata
- riduce al minimo i costi, evitando di addebitarti risorse che non utilizzi: ti verranno addebitate solo le risorse utilizzate durante la risposta al traffico
- è accessibile tramite un nome di dominio personalizzato. Puoi utilizzare una soluzione che richiede un solo clic per assegnare un nome di dominio personalizzato al tuo servizio
- Offre un tempo di risposta eccellente: gli avvii a freddo sono ragionevolmente reattivi, ma puoi ottimizzarlo specificando una configurazione di istanza minima
- supporta la crittografia end-to-end mediante la sicurezza web SSL/TLS standard. Quando distribuisci un servizio, ottieni la crittografia web standard e i certificati richiesti corrispondenti, senza costi e automaticamente
Eseguendo il deployment della tua app in Google Cloud Run, ottieni tutto quanto indicato sopra e altro ancora.
Esegui il deployment dell'app in Cloud Run
Modifica l'app in modo da poter distinguere la nuova revisione da quella precedente. Per farlo, modifica il file main.py in modo che il messaggio predefinito cambi da "Hello world!". in "Hello from Cloud Run!". In altre parole, modifica questa riga in main.py da questa:
def say_hello(name="world"):
a questo:
def say_hello(name="from Cloud Run"):
Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione. Nella sezione "Configurazione" precedente, hai definito una regione predefinita tramite la variabile di ambiente REGION.
Ricrea l'immagine container ed esegui il deployment dell'applicazione containerizzata su Cloud Run con il seguente comando:
gcloud builds submit --tag $TAG gcloud run deploy "$APP" \ --image "$TAG" \ --platform "managed" \ --region "$REGION" \ --allow-unauthenticated
- Puoi anche definire una regione predefinita con
gcloud config set run/region $REGION. - L'opzione
--allow-unauthenticatedrende il servizio disponibile pubblicamente. Per evitare richieste non autenticate, utilizza invece--no-allow-unauthenticated.
L'immagine specificata qui è l'immagine Docker creata nell'ultimo passaggio. Grazie al servizio Cloud Build, che ha archiviato l'immagine risultante in Google Container Registry, il servizio Cloud Run può trovarla ed eseguirne il deployment per te.
Attendi qualche istante fino al completamento del deployment. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio:
Deploying container to Cloud Run service [hello] in project [PROJECT_ID... ✓ Deploying new service... Done. ✓ Creating Revision... Revision deployment finished. Waiting for health check... ✓ Routing traffic... ✓ Setting IAM Policy... Done. Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic. Service URL: https://hello-....a.run.app
Puoi anche recuperare l'URL del tuo servizio con questo comando:
gcloud run services describe hello \ --platform managed \ --region $REGION \ --format "value(status.url)"
Il risultato dovrebbe essere simile al seguente:
https://hello-....a.run.app
Questo link è un URL dedicato, con sicurezza TLS, per il tuo servizio Cloud Run. Questo link è permanente (a condizione che non disattivi il servizio) e utilizzabile ovunque su internet. Non utilizza il meccanismo di proxy di Cloud Shell citato in precedenza, che dipendeva da una macchina virtuale temporanea.
Fai clic sulla Service URL evidenziata per aprire una scheda del browser web con l'app in esecuzione. Il risultato dovrebbe visualizzare il messaggio "Hello from Cloud Run!" messaggio davanti a uno sfondo di colore casuale.
Complimenti! La tua app è ora in esecuzione nel cloud di Google. Senza pensarci bene, la tua app è disponibile pubblicamente, con la crittografia TLS (HTTPS) e la scalabilità automatica a livelli di traffico incredibili.
Ma penso che questo processo potrebbe essere ancora più semplice...
6. Crea automaticamente il container
È tutto davvero bello, ma cosa succede se non voglio nemmeno pensare a Dockerfile e container? E se, come la maggior parte degli sviluppatori, voglio concentrarmi sulla scrittura del codice della mia applicazione e lasciare che qualcun altro si occupi di containerizzarla. Sei fortunato perché Cloud Run supporta uno standard open source chiamato Buildpacks, che esiste proprio per questo motivo: automatizzare il processo di produzione di un container da una raccolta di file di origine.
Tieni presente che in alcuni casi uno sviluppatore potrebbe preferire utilizzare un Dockerfile esplicito, ad esempio se vuole un elevato grado di personalizzazione nella creazione del container. Tuttavia, in casi comuni come questo esercizio, i buildpack funzionano perfettamente ed evitano la necessità di creare un Dockerfile a mano. Modifica il codice per utilizzare i buildpack.
Modifica l'app in modo da poter distinguere la nuova revisione da quella precedente. Per farlo, modifica il file main.py in modo che il messaggio predefinito cambi da "Hello from Cloud Run!". in "Hello from Cloud Run with Buildpacks!". In altre parole, modifica questa riga in main.py da questa:
def say_hello(name="from Cloud Run"):
a questo:
def say_hello(name="from Cloud Run with Buildpacks"):
Ora utilizziamo i buildpack creando un nuovo file denominato Procfile. Crea il file in Cloud Editor e inserisci questa riga di testo:
web: python3 main.py
Questo indica al sistema di buildback come eseguire l'app nel contenitore generato automaticamente. Con queste istruzioni, non hai nemmeno più bisogno di un Dockerfile. Per verificarlo, elimina il Dockerfile ed esegui questo comando nel terminale Cloud Shell:
gcloud beta run deploy "$APP" \
--source . \
--platform "managed" \
--region "$REGION" \
--allow-unauthenticated
È simile al comando che hai eseguito per eseguire il deployment dell'app nell'ultimo passaggio, ma questa volta hai sostituito l'opzione --image con l'opzione --source .. Questo indica al comando gcloud che vuoi che utilizzi buildpack per creare la tua immagine container, in base ai file di origine che trova nella directory corrente (dot in --source . è un'abbreviazione della directory corrente). Poiché il servizio si occupa dell'immagine container in modo implicito, non è necessario specificare un'immagine in questo comando gcloud.
Ancora una volta, verifica che il deployment sia stato eseguito facendo clic sull'icona Service URL evidenziata per aprire una scheda del browser web sull'app in esecuzione e assicurati che nel servizio sia visualizzato il messaggio "Hello from Cloud Run with Buildpacks". su uno sfondo di colore casuale.
Tieni presente che, utilizzando i buildpack per produrre il tuo Dockerfile, hai sostanzialmente ridotto i tre semplici passaggi a due:
- Crea un'app nell'ambiente di sviluppo.
- Esegui il deployment di esattamente lo stesso codice nel cloud con un solo comando.
7. Devo utilizzare la riga di comando?
No! Come quasi tutti i servizi Google Cloud, esistono tre modi per interagire con Cloud Run:
- Lo strumento a riga di comando gcloud, che hai appena visto.
- Una ricca interfaccia utente web, tramite la console Cloud, che supporta uno stile intuitivo di interazione point-and-click.
- In modo programmatico, utilizzando le librerie client di Google disponibili per molti dei linguaggi più diffusi, tra cui Java, C#, Python, Go, JavaScript, Ruby, C/C++ e altri.
Esegui il deployment di un'istanza aggiuntiva della tua app Cloud Run utilizzando l'interfaccia utente della console. Vai alla pagina di destinazione del servizio Cloud Run tramite il menu in alto a sinistra:
Dovresti quindi vedere un riepilogo dei tuoi servizi Cloud Run, come il seguente:
Fai clic sul pulsante "Crea servizio" link per avviare il processo di deployment:
Inserisci "ciao di nuovo" come nome del servizio, seleziona la piattaforma e la regione di deployment predefinite e fai clic su "Avanti".
Inserisci questo URL per l'immagine del contenitore: gcr.io/cloudrun/hello, un contenitore creato da Google a scopo di test, poi fai clic su "Impostazioni avanzate" per visualizzare alcune delle numerose impostazioni di configurazione disponibili. Ecco alcuni esempi di cosa puoi personalizzare:
- numero di porta e punto di ingresso del container (che sostituirà il punto di ingresso specificato durante la creazione del container).
- hardware: memoria e numero di CPU
- scalabilità: numero minimo e massimo di istanze
- variabili di ambiente
- altri: impostazione di timeout della richiesta, numero massimo di richieste per container, HTTP/2
Fai clic sul pulsante "Avanti" per avanzare nella finestra di dialogo. La finestra di dialogo successiva consente di specificare come viene attivato il servizio. Per "In entrata", seleziona "Consenti tutto il traffico" e "Consenti traffico non autenticato" per "Autenticazione".
Queste sono le impostazioni più liberali, in quanto consentono a chiunque di accedere alla tua app Cloud Run da qualsiasi luogo sulla rete internet pubblica, senza specificare le credenziali di autenticazione. Anche se potresti voler impostare impostazioni più restrittive per la tua app, cerchiamo di semplificare questo esercizio di apprendimento.
Ora fai clic sul pulsante Create per creare il tuo servizio Cloud Run. Dopo alcuni secondi, il nuovo servizio dovrebbe apparire nell'elenco di riepilogo dei servizi Cloud Run. La riga di riepilogo fornisce il deployment più recente (data/ora e da chi) insieme ad alcune impostazioni di configurazione chiave. Fai clic sul link del nome del servizio per visualizzare in dettaglio i dettagli del nuovo servizio.
Per verificare il servizio, fai clic sull'URL mostrato nella parte superiore della pagina di riepilogo, come evidenziato nell'esempio seguente:
Il risultato dovrebbe essere simile a questo:
Ora che hai eseguito il deployment di un nuovo servizio Cloud Run, seleziona la scheda REVISIONS per visualizzare alcuni modi per gestire più deployment.
Per eseguire il deployment delle nuove revisioni direttamente dalla console, puoi fare clic sul pulsante EDIT & DEPLOY NEW REVISION, come evidenziato nello screenshot di esempio riportato di seguito:
Fai clic sul pulsante per creare una nuova revisione. In prossimità dell'URL del contenitore, fai clic sul pulsante SELECT, come mostrato di seguito:
Nella finestra di dialogo visualizzata, trova la semplice app web di cui hai eseguito il deployment da Cloud Build in precedenza utilizzando Buildpacks, quindi fai clic su Seleziona. Assicurati di scegliere l'immagine container nel
gcr.io/<project>/cloud-run-source-deploy
cartella , in questo modo:
Una volta selezionato, scorri fino in fondo e fai clic sul pulsante DEPLOY. Hai eseguito il deployment di una nuova revisione dell'app. Per verificarlo, visita di nuovo l'URL del servizio e verifica di aver visualizzato il colorato "Hello from Cloud Run with Buildpacks!". nell'app web di Google.
Come puoi vedere, la scheda Revisioni fornisce un riepilogo di tutte le revisioni di cui hai eseguito il deployment. Ora dovresti vedere due revisioni per questo servizio. Puoi selezionare una determinata revisione facendo clic sul pulsante di opzione a sinistra del nome della revisione. Sul lato destro dello schermo verrà visualizzato un riepilogo dei dettagli della revisione. Selezionando questi pulsanti, puoi vedere che le due revisioni derivano da due diverse immagini container.
Il pulsante MANAGE TRAFFIC consente di modificare la distribuzione delle richieste in entrata inviate a una determinata revisione. Questa capacità di ottimizzare la quantità di traffico inviato a una determinata revisione consente diversi casi d'uso preziosi:
- eseguire il test canary di una nuova versione della tua app con una piccola porzione di traffico in entrata
- ripristinare il traffico da una release problematica a una revisione precedente
- Test A/B
Trova il pulsante MANAGE TRAFFIC qui:
Configura una suddivisione del traffico 50/50 tra le due revisioni specificando una suddivisione del traffico 50/50 in questo modo:
Ora fai clic sul pulsante SALVA e verifica la suddivisione 50/50 visitando ripetutamente l'URL del servizio e controlla che, in media, metà delle richieste siano gestite dalla revisione corrente ("Hello from Cloud Run with Buildpacks!") e metà dalla revisione precedente ("È in esecuzione!").
Altre schede nella pagina Dettagli servizio consentono di monitorare prestazioni, traffico e log, che forniscono informazioni preziose sul livello e sul funzionamento del servizio. Hai anche la possibilità di ottimizzare l'accesso al tuo servizio tramite la sezione "Autorizzazioni" . Dedica qualche istante a esplorare le schede di questa pagina per avere un'idea delle funzionalità disponibili.
Interfaccia programmatica
Come indicato in precedenza, hai anche la possibilità di creare, eseguire il deployment e gestire i servizi Cloud Run in modo programmatico. Per le attività manuali, questa opzione è più avanzata della riga di comando o della console web, ma è sicuramente la strada da seguire per automatizzare i servizi Cloud Run. Puoi utilizzare le librerie client di Google in diversi linguaggi di programmazione comuni.
8. Testa l'app
In questo passaggio finale, eseguirai un test di carico artificiale per sottoporre la tua app a stress test e osservare come si adatta alla domanda in arrivo. Utilizzerai uno strumento chiamato hey, che è preinstallato in Cloud Shell e ci offre la possibilità di eseguire test di carico e presentare i risultati.
Esegui il test
Nel terminale Cloud Shell, esegui questo comando per eseguire un test di carico:
hey -q 1000 -c 200 -z 30s https://hello-...run.app
Gli argomenti del comando vengono interpretati come segue:
-q 1000: prova a guidare il carico a circa 1000 richieste al secondo-c 200- alloca 200 worker paralleli-z 30s: esegui il test di carico per 30 secondi- assicurati di utilizzare l'URL del servizio come ultimo argomento in questa riga di comando
I risultati del test dovrebbero essere simili ai seguenti:
Summary:
Total: 30.2767 secs
Slowest: 3.3633 secs
Fastest: 0.1071 secs
Average: 0.1828 secs
Requests/sec: 1087.2387
Total data: 3028456 bytes
Size/request: 92 bytes
Response time histogram:
0.107 [1] |
0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.758 [1472] |■■
1.084 [82] |
1.410 [4] |
...
Latency distribution:
...
50% in 0.1528 secs
75% in 0.1949 secs
90% in 0.2442 secs
95% in 0.4052 secs
99% in 0.7062 secs
Details (average, fastest, slowest):
...
req write: 0.0000 secs, 0.0000 secs, 0.0232 secs
resp wait: 0.1824 secs, 0.1070 secs, 3.2953 secs
resp read: 0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
[200] 32918 responses
Questo riepilogo ci segnala diversi elementi di interesse:
- Sono state inviate 32.918 richieste a circa 1000 al secondo per 30 secondi.
- Non si sono verificati errori (solo 200 risposte HTTP).
- La latenza media è stata di 180 ms.
- La latenza minima è stata di 107 ms, il caso peggiore è stato di 3,3 s
- La latenza al 90° percentile è stata di 244 ms.
Se controlli la scheda METRICS nella console Cloud Run, puoi vedere il lato server dell'analisi delle prestazioni:
9. Pulizia
Sebbene non siano previsti addebiti per Cloud Run quando il servizio non è in uso, ti potrebbero comunque essere addebitati i costi di archiviazione dell'immagine container creata.
Puoi eliminare il tuo progetto Google Cloud per evitare addebiti, interrompendo così la fatturazione per tutte le risorse utilizzate all'interno di quel progetto, o semplicemente eliminare l'immagine container utilizzando questo comando:
gcloud container images delete $TAG
Per eliminare i servizi Cloud Run, utilizza questi comandi:
gcloud run services delete hello --platform managed --region $REGION --quiet gcloud run services delete hello-again --platform managed --region $REGION --quiet
10. Ce l'hai fatta!
Congratulazioni: hai creato ed eseguito correttamente il deployment di un'app Cloud Run di produzione. Lungo il percorso, hai appreso cosa sono i container e come creare i tuoi container. Hai visto quanto è facile eseguire il deployment della tua app con Cloud Run, utilizzando sia lo strumento a riga di comando gcloud sia la console Cloud. Ora sai come condividere le tue fantastiche creazioni con il mondo intero.
Voglio lasciarti con una domanda importante:
Una volta che la tua app funzionava nell'ambiente di sviluppo, quante righe di codice hai dovuto modificare per eseguirne il deployment nel cloud, con tutti gli attributi di livello enterprise offerti da Cloud Run?
La risposta, ovviamente, è zero.
Codelab da provare...
- Crea un bot Slack con Node.js su Cloud Run
- Attiva Cloud Run con eventi da Eventarc
- Ciao codelab su Cloud Run for Anthos
- Esegui il deployment di un container ed eseguilo con Cloud Run su Node.js
- Altri codelab di Cloud Run
Altre funzionalità interessanti da scoprire...
- Deployment continuo da Git con Cloud Build
- Utilizzo dei secret di Secret Manager
- Introduzione a WebSocket, flussi bidirezionali HTTP/2 e gRPC per Cloud Run
- Numero minimo di istanze Cloud Run: riduci al minimo gli avvii a freddo serverless
- Gestire il traffico da più regioni
Documenti di riferimento...
11. Invito all'azione
Se hai apprezzato questo codelab e probabilmente passerai più tempo a fare pratica con Google Cloud, ti consigliamo di partecipare a Google Cloud Innovators oggi stesso.
Google Cloud Innovators è senza costi e include:
- Discussioni dal vivo, AMA e sessioni di roadmap per conoscere le ultime novità direttamente dai Googler
- le ultime novità su Google Cloud direttamente nella tua posta in arrivo
- Sfondo con badge digitale e videoconferenze
- 500 crediti di lab e apprendimento su Skills Boost
Fai clic qui per registrarti.