1. Prima di iniziare
L'esecuzione di siti web può essere difficile con tutto l'overhead associato alla creazione e alla gestione di istanze di macchine virtuali (VM), cluster, pod, servizi e altro ancora. Questo va bene per le app a più livelli più grandi, ma se il tuo obiettivo è aumentare la visibilità e il deployment del sito web, il carico di lavoro è elevato.
Con Cloud Run, l'implementazione Google Cloud di Knative, puoi gestire il tuo sito web ed eseguirne il deployment senza l'overhead necessario per i deployment basati su VM o Kubernetes. Questo approccio semplifica la gestione e consente anche di "scalare fino a zero" quando non arrivano richieste al sito web.
Cloud Run non solo porta lo sviluppo serverless nei container, ma può anche essere eseguito sui tuoi cluster Google Kubernetes Engine (GKE) o su una soluzione Platform as a Service (PaaS) completamente gestita fornita da Cloud Run. Testerai quest'ultimo scenario in questo codelab.
Il seguente diagramma illustra il flusso del deployment e dell'hosting in Cloud Run. Inizierai con un'immagine Docker creata tramite Cloud Build, che attivi in Cloud Shell. Quindi, esegui il deployment dell'immagine in Cloud Run con un comando in Cloud Shell.
Prerequisiti
- Familiarità generale con Docker (consulta la sezione Per iniziare sul sito web di Docker.)
Cosa imparerai a fare
- Creare un'immagine Docker con Cloud Build e caricarla su gcr.io
- Eseguire il deployment delle immagini Docker in Cloud Run
- Gestire i deployment di Cloud Run
- Configurare un endpoint per un'app in Cloud Run
Cosa creerai
- Un sito web statico eseguito all'interno di un container Docker
- Una versione di questo container presente in Container Registry
- Un deployment Cloud Run per il tuo sito web statico
Che cosa ti serve
- Un Account Google con accesso amministrativo per creare progetti o un progetto con ruolo di proprietario del progetto.
2. Configurazione dell'ambiente
Configurazione dell'ambiente autogestito
Se non disponi già di un Account Google, devi crearne uno. Quindi, accedi alla console Google Cloud e fai clic su Progetto > Crea progetto.
Ricorda l'ID progetto, che viene compilato automaticamente sotto il nome del progetto. L'ID progetto è un nome univoco per tutti i progetti Google Cloud, quindi il nome nello screenshot è già stato acquisito e non funzionerà. Ci riferiremo in seguito come PROJECT_ID.
Successivamente, devi abilitare la fatturazione nella console Cloud per utilizzare le risorse Google Cloud e abilitare l'API Cloud Run.
Abilita l'API Cloud Run
Fai clic sul menu di navigazione Џ > API e Servizi > Dashboard > Abilita API e servizi. .
Cerca "API Cloud Run" quindi fai clic su API Cloud Run > Attiva.
L'esecuzione di questo codelab non dovrebbe costare più di pochi dollari, ma potrebbe costare di più se decidi di utilizzare più risorse o se le lasci in esecuzione (vedi Pulizia alla fine). Per ulteriori informazioni, consulta la sezione Prezzi.
I nuovi utenti di Google Cloud hanno diritto a una prova senza costi di 300$.
Cloud Shell
Google Cloud e Cloud Run possono essere gestiti da remoto dal tuo laptop, ma utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione in Google Cloud. L'ambiente è preconfigurato con tutte le librerie e i framework client di cui hai bisogno.
Questa macchina virtuale basata su Debian 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. Ciò significa che per questo codelab sarà sufficiente un browser (sì, funziona su Chromebook).
- Per attivare Cloud Shell dalla console Cloud, fai clic su Attiva Cloud Shell
(il provisioning e la connessione all'ambiente dovrebbero richiedere solo pochi minuti).
Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai già eseguito l'autenticazione e che il progetto è già impostato su PROJECT_ID.
gcloud auth list
Output comando
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
Se, per qualche motivo, il progetto non è impostato, invia semplicemente il seguente comando:
gcloud config set project <PROJECT_ID>
Stai cercando il tuo PROJECT_ID? Controlla l'ID utilizzato nei passaggi di configurazione o cercalo nella dashboard della console Cloud:
Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, cosa che può essere utile quando eseguirai comandi futuri.
echo $GOOGLE_CLOUD_PROJECT
Output comando
<PROJECT_ID>
- Infine, imposta la zona e la configurazione del progetto predefinite.
gcloud config set compute/zone us-central1-f
Puoi scegliere zone diverse. Per ulteriori informazioni, consulta la sezione Regioni e zone.
3. clona il repository di codice sorgente
Dato che stai eseguendo il deployment di un sito web esistente, devi solo clonare il codice sorgente dal tuo repository per concentrarti sulla creazione di immagini Docker e sul deployment in Cloud Run.
Esegui questi comandi per clonare il repository nell'istanza di Cloud Shell e passare alla directory appropriata. Installerai anche le dipendenze Node.js in modo da poter testare l'app prima del deployment.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
Ciò clona il repository, modifica la directory e installa le dipendenze necessarie per eseguire l'app in locale. L'esecuzione dello script potrebbe richiedere alcuni minuti.
Fai la tua due diligence e testa la tua app. Esegui questo comando per avviare il server web:
cd ~/monolith-to-microservices/monolith npm start
Output:
Monolith listening on port 8080!
Puoi visualizzare l'anteprima dell'app facendo clic su Anteprima web 
e selezionando Anteprima sulla porta 8080.
Si apre una nuova finestra in cui puoi vedere il tuo Fancy Store in azione.
Puoi chiudere questa finestra dopo aver visualizzato il sito web. Per interrompere il processo del server web, premi CONTROL+C (Command+C su Macintosh) nella finestra del terminale.
4. crea il container in Docker con Cloud Build
Ora che i file sorgente sono pronti per l'uso, puoi "dockerizzare" l'app.
Normalmente, dovresti adottare un approccio in due fasi che comprende la creazione di un container Docker e il relativo push a un registry per archiviare l'immagine da cui GKE esegue il pull. Tuttavia, puoi semplificarti la vita utilizzando Cloud Build per creare il container Docker e inserire l'immagine in Container Registry con un solo comando. Per visualizzare il processo manuale di creazione di un Dockerfile e del relativo push, consulta la Guida rapida per Container Registry.
Cloud Build comprime i file dalla directory e li sposta in un bucket Cloud Storage. Il processo di compilazione prende quindi tutti i file dal bucket e utilizza il Dockerfile presente nella stessa directory per eseguire il processo di compilazione Docker. Dato che hai specificato il flag --tag con l'host gcr.io per l'immagine Docker, verrà eseguito il push dell'immagine Docker risultante in Container Registry.
Innanzitutto, devi assicurarti che l'API Cloud Build sia abilitata. Esegui il comando seguente per abilitarla:
gcloud services enable cloudbuild.googleapis.com
Dopo aver abilitato l'API, esegui questo comando in Cloud Shell per avviare il processo di compilazione:
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 .
Il processo richiede alcuni minuti, ma al termine verrà restituito nel terminale un output simile al seguente:
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID CREATE_TIME DURATION SOURCE IMAGES STATUS 1ae295d9-63cb-482c-959b-bc52e9644d53 2019-08-29T01:56:35+00:00 33S gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io/<PROJECT_ID>/monolith:1.0.0 SUCCESS
Per visualizzare la cronologia delle build o il processo in tempo reale, vai alla console Cloud e fai clic su Menu di navigazione PI > Cloud Build > Cronologia. Qui puoi vedere un elenco di tutte le build precedenti, ma dovrebbe esserci solo quella che hai creato.
Se fai clic su ID build, vedrai tutti i dettagli relativi a quella build, incluso l'output di log. Puoi visualizzare l'immagine container creata facendo clic sul link accanto a Immagine.
5. Esegui il deployment del container in Cloud Run
Ora che hai containerizzato il sito web ed eseguito il push su Container Registry, è il momento di eseguire il deployment in Cloud Run.
Per il deployment in Cloud Run è possibile scegliere tra due approcci:
- Cloud Run (completamente gestito) è il modello PaaS in cui viene gestito l'intero ciclo di vita del container. Userai questo approccio per questo codelab.
- Cloud Run for Anthos è Cloud Run con un livello di controllo aggiuntivo, che ti consente di trasferire i tuoi cluster e pod da GKE. Per ulteriori informazioni, consulta Configurazione di Cloud Run for Anthos su Google Cloud.
Gli esempi della riga di comando saranno in Cloud Shell utilizzando le variabili di ambiente che hai configurato in precedenza.
Riga di comando
Esegui questo comando per eseguire il deployment della tua app:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed
Ti verrà chiesto di specificare in quale regione vuoi eseguire l'esecuzione. Seleziona la regione più vicina a te, quindi accetta il nome del servizio suggerito predefinito (monolite).
A scopo di test, consenti le richieste non autenticate all'app. Inserisci y quando richiesto.
Verifica il deployment
Per verificare che il deployment sia stato creato correttamente, esegui questo comando. Potrebbero essere necessari alcuni istanti prima che Pod status venga Running:
gcloud run services list
Seleziona [1] Cloud Run (completamente gestito).
Output:
SERVICE REGION URL LAST DEPLOYED BY LAST DEPLOYED AT ✔ monolith us-east1 <your url> <your email> 2019-09-16T21:07:38.267Z
L'output mostra diverse cose. Puoi vedere il tuo deployment, nonché l'utente che lo ha eseguito (il tuo indirizzo email) e l'URL che puoi usare per accedere all'app. Tutti gli elementi sono stati creati correttamente.
Apri l'URL indicato nell'elenco dei servizi nel browser web. Dovresti vedere lo stesso sito web che hai visualizzato in anteprima localmente.
6. crea una nuova revisione con minore contemporaneità
Ora esegui di nuovo il deployment dell'app, ma questa volta regola uno dei parametri.
Per impostazione predefinita, un'app Cloud Run avrà un valore di contemporaneità pari a 80, il che significa che ogni istanza di container gestirà fino a 80 richieste alla volta. Si tratta di una grande differenza dal modello Functions as a Service (FaaS), in cui un'istanza gestisce una richiesta alla volta.
Esegui di nuovo il deployment della stessa immagine container con un valore di contemporaneità pari a 1 (solo a scopo di test) e osserva cosa succede.
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 1
Rispondi alle domande successive come hai fatto la prima volta. Una volta eseguito il comando, controlla la console Cloud per vedere il risultato.
Nella dashboard di Cloud Run, fai clic sul servizio monolith per visualizzare i dettagli.
Fai clic sulla scheda Revisioni. Dovresti vedere due revisioni create. Fai clic su monolith-00002 ed esamina i dettagli. Il valore della contemporaneità dovrebbe essere ridotto a 1.
]
Sebbene questa configurazione sia sufficiente per i test, nella maggior parte degli scenari di produzione saranno presenti container che supportano più richieste in parallelo.
Ora ripristina la contemporaneità originale senza eseguire nuovamente il deployment. Puoi impostare il valore predefinito di 80 o 0 per il valore di contemporaneità, il che rimuoverà eventuali limitazioni della contemporaneità e lo imposterà sul valore massimo predefinito (che al momento della stesura del presente documento è 80).
Esegui questo comando in Cloud Shell per aggiornare la revisione corrente:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 80
Nota che è stata creata un'altra revisione, il traffico è stato reindirizzato e la contemporaneità è tornata a 80.
7. apporta modifiche al sito web
Il team di marketing ti ha chiesto di modificare la home page del sito web della tua azienda. Secondo il team, dovrebbe essere più ricca di informazioni su ciò che l'azienda è e vende. In questa sezione, potrai aggiungere del testo alla home page per soddisfare la richiesta del team di marketing.
Uno dei tuoi sviluppatori ha già creato le modifiche con il nome file index.js.new. Puoi semplicemente copiare il file in index.js per applicare le modifiche. Segui le istruzioni per apportare le modifiche appropriate.
Esegui questi comandi, copia il file aggiornato con il nome file corretto e stampane il contenuto per verificare le modifiche:
cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js
Il codice risultante dovrebbe avere l'aspetto seguente:
/*
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
root: {
flexGrow: 1
},
paper: {
width: "800px",
margin: "0 auto",
padding: theme.spacing(3, 2)
}
}));
export default function Home() {
const classes = useStyles();
return (
<div className={classes.root}>
<Paper className={classes.paper}>
<Typography variant="h5">
Fancy Fashion & Style Online
</Typography>
<br />
<Typography variant="body1">
Tired of mainstream fashion ideas, popular trends and societal norms?
This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
Start shopping Fancy items now!
</Typography>
</Paper>
</div>
);
}
Hai aggiornato i componenti React, ma devi creare la build dell'app React per generare i file statici. Esegui questo comando per creare la build dell'app React e copiarla nella directory pubblica del monolite:
cd ~/monolith-to-microservices/react-app npm run build:monolith
Ora che il codice è aggiornato, devi ricreare il container Docker e pubblicarlo in Container Registry. Puoi usare lo stesso comando di prima, con la differenza che questa volta aggiornerai l'etichetta della versione.
Esegui questo comando per attivare un nuovo processo Cloud Build con una versione aggiornata 2.0.0 dell'immagine:
cd ~/monolith-to-microservices/monolith
#Feel free to test your application
npm start
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .
Nella sezione successiva, utilizzerai quell'immagine per aggiornare l'app senza tempi di inattività.
8. aggiorna il sito web senza tempi di inattività
Le modifiche sono state completate e il team di marketing è molto soddisfatto dei tuoi aggiornamenti. È il momento di aggiornare il sito web senza interruzioni per gli utenti.
Cloud Run tratta ogni deployment come una nuova revisione, che viene portata online e poi reindirizzato al traffico.
Segui le istruzioni riportate di seguito per aggiornare il tuo sito web.
Riga di comando
Dalla riga di comando, puoi rieseguire il deployment del servizio per aggiornare l'immagine a una nuova versione con il seguente comando:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --platform managed
Verifica il deployment
Convalida l'aggiornamento del deployment eseguendo questo comando:
gcloud run services describe monolith --platform managed
L'output avrà il seguente aspetto:
apiVersion: serving.knative.dev/v1alpha1
kind: Service
metadata:
annotations:
client.knative.dev/user-image: gcr.io/my-cloudrun-codelab/monolith:2.0.0
...
Vedrai che il tuo servizio utilizza la versione più recente dell'immagine di cui è stato eseguito il deployment in una nuova revisione.
Per verificare le modifiche, vai all'URL esterno del servizio Cloud Run e nota che il titolo dell'app è stato aggiornato.
Esegui questo comando per elencare i servizi e visualizzare l'indirizzo IP se lo hai dimenticato:
gcloud run services list
Il sito web dovrebbe mostrare il testo che hai aggiunto al componente della home page.
9. Esegui la pulizia
Elimina immagini di Container Registry
# Delete the container image for version 1.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --quiet
# Delete the container image for version 2.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --quiet
Elimina gli artefatti di Cloud Build da Cloud Storage
# The following command will take all source archives from all builds and delete them from cloud storage
# Run this command to print all sources:
# gcloud builds list | awk 'NR > 1 {print $4}'
gcloud builds list | awk 'NR > 1 {print $4}' | while read line; do gsutil rm $line; done
Elimina servizio Cloud Run
gcloud run services delete monolith --platform managed
10. Complimenti
Hai eseguito il deployment del sito web, lo hai reso scalabile e lo hai aggiornato con Cloud Run.