Eseguire siti web può essere difficile, con il sovraccarico di creazione e gestione di istanze di macchine virtuali (VM), cluster, pod, servizi e altro ancora. Questo va bene per le app più grandi, su più livelli, ma se stai solo cercando di rendere il tuo sito web implementato e visibile, il sovraccarico sarà molto elevato.
Con Cloud Run, l'implementazione di Google Cloud di Knative, puoi gestire ed eseguire il deployment del tuo sito web senza l'overhead necessario per i deployment basati su VM o Kubernetes. Un approccio più semplice non solo offre una gestione, ma offre anche la possibilità di scalare fino a zero quando non ci sono richieste in arrivo al vostro 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 PaaS (Platform as a Service) completamente gestita fornita da Cloud Run. Testerai il secondo scenario in questo codelab.
Il seguente diagramma illustra il flusso del deployment e dell'hosting 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 Guida introduttiva del sito web di Docker).
Obiettivi didattici
- Come creare un'immagine Docker con Cloud Build e caricarla in gcr.io
- Eseguire il deployment delle immagini Docker in Cloud Run
- Gestire i deployment di Cloud Run
- Come configurare un endpoint per un'app su Cloud Run
Cosa devi creare
- Un sito web statico eseguito all'interno di un container Docker
- Una versione di questo container che si trova 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 il ruolo di proprietario del progetto
Configurazione dell'ambiente autogestito
Se non hai ancora un Account Google, devi crearne uno. Quindi, accedi a Google Cloud Console e fai clic su Progetto > Crea progetto.
Ricorda l'ID progetto, che viene completato automaticamente sotto il nome del progetto. L'ID progetto è un nome univoco in tutti i progetti Google Cloud, quindi il nome nello screenshot è già stato creato e non funzionerà. Vi verrà fatto riferimento in un secondo momento come PROJECT_ID.
Successivamente, devi attivare la fatturazione in Cloud Console per utilizzare le risorse di Google Cloud e attivare 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 > Abilita.
L'esecuzione di questo codelab non dovrebbe costare più di qualche euro, ma potrebbe esserlo se decidi di utilizzare altre risorse o se le lasci in esecuzione (vedi Pulizia alla fine). Per ulteriori informazioni, consulta la sezione Prezzi.
I nuovi utenti di Google Cloud sono idonei per una prova senza costi di 300$.
Cloud Shell
Anche se Google Cloud e Cloud Run possono essere utilizzati da remoto dal tuo laptop, puoi utilizzare Cloud Shell, un ambiente a riga di comando in esecuzione in Google Cloud. L'ambiente è preconfigurato con tutte le librerie client e i framework di cui hai bisogno.
Questa macchina virtuale basata su Debian viene caricata con tutti gli strumenti di sviluppo di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Ciò significa che ti servirà solo un browser (sì, funziona su Chromebook).
Per attivare Google Cloud Shell, nella Console per gli sviluppatori basta fare clic sul pulsante in alto a destra (il provisioning e la connessione all'ambiente devono essere pochi minuti):
Fai clic sul pulsante "Avvia Cloud Shell":
Dopo aver effettuato la connessione a Cloud Shell, dovresti vedere che sei già autenticato 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>
Per impostazione predefinita, Cloud Shell imposta anche alcune variabili di ambiente, che possono essere utili durante l'esecuzione di comandi futuri.
echo $GOOGLE_CLOUD_PROJECT
Output comando
<PROJECT_ID>
Se per qualche motivo il progetto non è configurato, esegui semplicemente il seguente comando :
gcloud config set project <PROJECT_ID>
Stai cercando il tuo dispositivo PROJECT_ID? Controlla quale ID hai utilizzato nei passaggi di configurazione o cercalo nella dashboard della console:
IMPORTANTE: infine, imposta la zona e la configurazione del progetto predefinite:
gcloud config set compute/zone us-central1-f
Puoi scegliere una varietà di zone. Scopri di più nella documentazione relativa ad aree geografiche e zone.
Dato che stai eseguendo il deployment di un sito web esistente, devi solo clonare il codice sorgente dal tuo repository, in modo che tu possa concentrarti sulla creazione di immagini Docker e sul deployment in Cloud Run.
Esegui il comando seguente per clonare il repository nella tua 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
Viene clonato il repository, modificato la directory e installato le dipendenze necessarie per eseguire l'app localmente. L'esecuzione dello script potrebbe richiedere alcuni minuti.
Esegui le operazioni di due diligence e testa la tua app. Esegui il seguente comando per avviare il tuo server web:
cd ~/monolith-to-microservices/monolith npm start
Output:
Monolith listening on port 8080!
Per visualizzare l'anteprima della tua app, fai clic su Anteprima web 
e seleziona Anteprima sulla porta 8080.
Si aprirà una nuova finestra in cui puoi vedere il negozio 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.
Ora che i file di origine sono pronti, è il momento di Dockerizzare la tua app.
Normalmente, dovresti adottare un approccio in due fasi che prevede la creazione di un container Docker ed il push in un registro per archiviare l'immagine da cui GKE deve eseguire il pull. Tuttavia, puoi semplificarla utilizzando Cloud Build per creare il container Docker e inserire l'immagine in Container Registry con un unico comando. Per visualizzare il processo manuale di creazione di un Dockerfile e del push, consulta Quickstart 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 l'esecuzione del processo di build Docker. Poiché hai specificato il flag --tag con l'host come gcr.io per l'immagine Docker, verrà eseguito il push dell'immagine Docker risultante in Container Registry.
Per prima cosa, assicurati di avere abilitato l'API Cloud Build. Esegui il comando seguente per abilitarla:
gcloud services enable cloudbuild.googleapis.com
Una volta abilitata 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 un output simile al seguente nel terminale:
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 della build o controllare il processo in tempo reale, puoi accedere a Cloud Console, quindi fare clic su Menu di navigazione ☰ > Cloud Build > Cronologia. Qui puoi vedere un elenco di tutte le build precedenti, ma dovrebbe esserci solo quella creata da te.
Se fai clic sull'ID build, puoi visualizzare tutti i dettagli relativi alla build, incluso l'output del log. Puoi visualizzare l'immagine container creata facendo clic sul link accanto a Immagine.
Ora che hai containerizzato il sito web e ne hai eseguito il push a Container Registry, è il momento di eseguire il deployment su Cloud Run.
Per il deployment in Cloud Run è possibile scegliere tra due approcci:
- Cloud Run (completamente gestito) è il modello PaaS in cui è gestito l'intero ciclo di vita del container. Utilizzerai questo approccio per questo codelab.
- Cloud Run for Anthos è Cloud Run con un ulteriore livello di controllo, che ti permette di trasferire i tuoi cluster e pod da GKE. Per saperne di più, vedi Configurazione di Cloud Run for Anthos su Google Cloud.
Gli esempi a riga di comando si troveranno in Cloud Shell utilizzando le variabili di ambiente che hai configurato in precedenza.
Riga di comando
Esegui questo comando per eseguire il deployment dell'app:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed
Ti verrà chiesto di specificare in quale area geografica vuoi pubblicare. Seleziona l'area geografica più vicina a te, quindi accetta il nome del servizio consigliato predefinito (monolith).
A scopo di test, consenti le richieste non autenticate all'app. Inserisci y nel messaggio.
Verifica il deployment
Per verificare che il deployment sia stato creato correttamente, esegui il comando seguente. Potrebbero essere necessari alcuni istanti prima che l'elemento Pod status sia 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 diversi elementi. Puoi vedere il deployment, nonché l'utente che lo ha eseguito (il tuo indirizzo email) e l'URL che puoi utilizzare per accedere all'app. Sembra che tutto sia stato creato.
Apri l'URL fornito nell'elenco di servizi del browser web e dovresti vedere lo stesso sito web di cui hai visualizzato l'anteprima locale.
Ora esegui nuovamente il deployment della tua app, ma questa volta modifica uno dei parametri.
Per impostazione predefinita, un'app Cloud Run avrà un valore di contemporaneità di 80, il che significa che ogni istanza di container pubblicherà fino a 80 richieste alla volta. Questa è una grande deviazione dal modello Functions as a Service (FaaS), in cui un'istanza gestisce una richiesta alla volta.
Esegui nuovamente il deployment della stessa immagine container con un valore di contemporaneità pari a 1 (solo a scopo di test) e scopri 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 Cloud Console per vedere il risultato.
Nella dashboard di Cloud Run, fai clic sul servizio monolith per vedere i dettagli.
Fai clic sulla scheda Revisioni. Dovresti vedere due revisioni create. Fai clic su monolith-00002 e rivedi i dettagli. Dovresti vedere il valore di contemporaneità ridotto a 1.
]
Sebbene questa configurazione sia sufficiente per i test, nella maggior parte degli scenari di produzione saranno disponibili container che supportano più richieste in parallelo.
Ora ripristina la contemporaneità originale senza eseguire nuovamente il deployment. Puoi impostare il valore di contemporaneità su 80 o 0 in modo da rimuovere qualsiasi limitazione di contemporaneità e impostarlo sul valore massimo predefinito (che al momento della scrittura è pari a 80).
Esegui il seguente comando in Cloud Shell per aggiornare la revisione attuale:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 80
Nota che è stata creata un'altra revisione, che il traffico è stato reindirizzato e che la contemporaneità è di nuovo 80.
Il tuo team di marketing ti ha chiesto di modificare la home page del sito web della tua azienda. Ritengono che dovrebbe essere più informativo sull'azienda e sulla vendita. In questa sezione aggiungerai del testo alla home page per rendere felice il team di marketing.
Sembra che uno dei tuoi sviluppatori abbia già creato le modifiche con il nome file index.js.new. Puoi semplicemente copiare il file in index.js per riflettere le modifiche. Segui le istruzioni per apportare le modifiche appropriate.
Esegui i seguenti comandi, copia il file aggiornato nel nome file corretto e stampane i contenuti 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 il comando seguente 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 tuo codice è aggiornato, devi ricreare il tuo container Docker e pubblicarlo in Container Registry. Puoi utilizzare lo stesso comando di prima, ma questa volta aggiornerà l'etichetta della versione.
Esegui il comando seguente 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 questa immagine per aggiornare l'app 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 considera ogni deployment come una nuova revisione, che verrà portata online e a cui verrà reindirizzato il traffico.
Segui le istruzioni seguenti per aggiornare il tuo sito web.
Riga di comando
Dalla riga di comando puoi eseguire nuovamente il deployment del servizio per aggiornare l'immagine a una nuova versione con il comando seguente:
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 ha 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 ora l'ultima versione dell'immagine di cui hai eseguito il deployment in una nuova revisione.
Per verificare le modifiche, passa di nuovo 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
Ora il tuo sito web dovrebbe mostrare il testo che hai aggiunto al componente Home page.
Elimina immagini 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
Hai eseguito il deployment del sito web, lo hai scalato e aggiornato con Cloud Run.