Test di un servizio Cloud Run in locale

Durante lo sviluppo, puoi eseguire e testare la tua immagine container in locale, prima del deployment. Puoi utilizzare Cloud Code o Docker installato localmente per eseguire e testare localmente, anche eseguendo localmente con accesso ai servizi Google Cloud.

Emulatore di Cloud Code

Il plug-in Cloud Code per IDE VS e IDE JetBrains ti consente di eseguire ed eseguire il debug a livello locale dell'immagine container in un emulatore di Cloud Run all'interno dell'IDE. L'emulatore consente di configurare un ambiente che rappresenta il servizio in esecuzione su Cloud Run.

Puoi configurare proprietà come allocazione di CPU e memoria, specificare le variabili di ambiente e impostare le connessioni ai database Cloud SQL.

Installa Cloud Code per VS Code o un IDE JetBrains.
Segui le istruzioni per lo sviluppo e il debug a livello locale nel tuo IDE.
Codice VS: sviluppo e debug a livello locale
IntelliJ: sviluppo e debug a livello locale

Interfaccia a riga di comando gcloud

Google Cloud CLI contiene un ambiente di sviluppo locale per emulare Cloud Run in grado di creare un container dall'origine, eseguire il container sulla tua macchina locale, e ricrearlo automaticamente alle modifiche del codice sorgente.

Per avviare l'ambiente di sviluppo locale:

Cambia la directory in quella contenente il codice sorgente del tuo servizio.
Richiama il comando:
```
gcloud beta code dev
```

Se un Dockerfile è presente nella directory locale, viene utilizzato per creare il container. Se non è presente alcun Dockerfile, il container viene creato con i buildpack di Google Cloud.

Per vedere il servizio in esecuzione, visita http://localhost:8080/ nel browser. Se hai specificato una porta personalizzata con l'opzione --local-port, ricorda di aprire il browser su quella porta.

Per arrestare il server locale:

Mac OS e Linux: Ctrl + C
Windows: interruzione di controllo

Personalizzazione della configurazione del servizio

Puoi personalizzare la configurazione Cloud Run del servizio in esecuzione localmente utilizzando un file YAML Il formato YAML è lo stesso che può essere utilizzato per il deployment di un servizio Cloud Run, ma supporta solo un sottoinsieme delle impostazioni del servizio Cloud Run. gcloud beta code dev cerca e utilizza qualsiasi file che termina con *.service.dev.yaml nella directory corrente. Se non ne viene trovato nessuno, utilizzerà qualsiasi file che termina con *.service.yaml.

Puoi configurare le seguenti impostazioni per lo sviluppo locale:

Il campo image del container non è obbligatorio per lo sviluppo locale, perché l'immagine viene creata e fornita al servizio quando viene eseguito il comando.

Puoi utilizzare il seguente file service.dev.yaml di esempio per lo sviluppo locale:

  apiVersion: serving.knative.dev/v1
  kind: Service
  metadata:
    name: my-service-name
  spec:
    template:
      spec:
        containers:
        - env:
          - name: FOO
            value: bar

Utilizzo delle credenziali

Per concedere al container l'utilizzo dei servizi Google Cloud, devi concedere al container una credenziale di accesso.

Per concedere al container l'accesso a una credenziale mediante il tuo account, accedi utilizzando gcloud e utilizza il flag --application-default-credential:
```
gcloud auth application-default login
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --application-default-credential
```
Per assegnare le credenziali dell'applicazione come account di servizio, utilizza il flag --service-account:
```
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --service-account=SERVICE_ACCOUNT_EMAIL
```
Il flag --service-account comporta il download e la memorizzazione nella cache di una chiave dell'account di servizio localmente. L'utente è responsabile della sicurezza della chiave e della sua eliminazione quando non è più necessaria.

Docker

Per testare l'immagine del container in locale usando Docker:

Utilizza il comando Docker:
```
PORT=8080 && docker run -p 9090:${PORT} -e PORT=${PORT} IMAGE_URL
```
Sostituisci IMAGE_URL con un riferimento all'immagine container, ad esempio us-docker.pkg.dev/cloudrun/container/hello:latest.

La variabile di ambiente PORT specifica la porta che la tua applicazione utilizzerà per ascoltare le richieste HTTP o HTTPS. Questo è un requisito del contratto di runtime del container. In questo esempio, viene utilizzata la porta 8080.

Importante: quando viene eseguito localmente la prima volta:
Se è la prima volta che provi a eseguire l'esecuzione localmente, potresti non avere tutte le autorizzazioni necessarie per accedere all'immagine dal registro delle immagini che stai utilizzando. Se utilizzi Artifact Registry, segui le istruzioni di autenticazione di Artifact Registry. Se utilizzi Container Registry, segui le istruzioni per l'autenticazione di Container Registry. Dopo aver configurato il registro in modo appropriato, prova a eseguire di nuovo il container Cloud Run in locale.
Attenzione: utilizza l'account di servizio predefinito:
Se utilizzi l'account di servizio predefinito durante il deployment in Cloud Run, tieni presente che non è disponibile localmente, per cui devi avere un account di servizio e una coppia di chiavi pubblica/privata salvata in locale per eseguire l'immagine localmente con Docker. Per ulteriori informazioni, consulta la scheda successiva Accesso a Docker con Google Cloud.
Apri http://localhost:9090 nel browser.

Se non hai mai utilizzato i container, consulta la Guida introduttiva di Docker. Per scoprire di più sui comandi Docker, consulta la documentazione di Docker.

Docker con accesso a Google Cloud

Se utilizzi le librerie client di Google Cloud per integrare la tua applicazione con i servizi Google Cloud e non hai ancora protetto tali servizi per controllare l'accesso esterno, puoi configurare il container locale per l'autenticazione con i servizi Google Cloud utilizzando le credenziali predefinite dell'applicazione.

Per l'esecuzione a livello locale:

Consulta la Guida introduttiva all'autenticazione per istruzioni su come generare, recuperare e configurare le credenziali dell'account di servizio.
I seguenti flag di esecuzione di Docker inseriscono le credenziali e la configurazione dal sistema locale al container locale:
1. Utilizza il flag --volume (-v) per inserire il file delle credenziali nel container (presupponendo che tu abbia già impostato la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sulla tua macchina):
```
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro
```
2. Utilizza il flag --environment (-e) per impostare la variabile GOOGLE_APPLICATION_CREDENTIALS all'interno del container:
```
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json
```
Facoltativamente, utilizza questo comando Docker run completamente configurato:
```
PORT=8080 && docker run \
-p 9090:${PORT} \
-e PORT=${PORT} \
-e K_SERVICE=dev \
-e K_CONFIGURATION=dev \
-e K_REVISION=dev-00001 \
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json \
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro \
IMAGE_URL
```
Tieni presente che il percorso
```
/tmp/keys/FILE_NAME.json
```
mostrato nell'esempio sopra è una posizione ragionevole in cui posizionare le credenziali all'interno del container.

Tuttavia, è possibile utilizzare anche altre posizioni della directory. Il requisito fondamentale è che la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS deve corrispondere alla posizione di montaggio del bind all'interno del container.

Tieni inoltre presente che, con alcuni servizi Google Cloud, potresti voler utilizzare una configurazione alternativa per isolare la risoluzione dei problemi locali dalle prestazioni e dai dati di produzione.

Passaggi successivi

Per scoprire come risolvere i problemi di un'applicazione Cloud Run non funzionante, consulta il tutorial Risoluzione dei problemi locali di un servizio Cloud Run.
Per scoprire come eseguire il deployment dei container creati, consulta Deployment dei servizi.