Esperimento Google Cloud Deploy e Cloud Run

Questo documento è un tutorial di prova che ti consente di iniziare a utilizzare una pipeline di distribuzione in Google Cloud Deploy che esegue il deployment dei container in Cloud Run. Alla fine di questo tutorial, avrai una pipeline di CD destinata a Cloud Run con due ambienti: dev e prod. Puoi eseguire il deployment e promuovere nuove immagini container tramite le fasi della pipeline e guardare il processo su Google Cloud Console.

Questo tutorial si basa su diversi servizi Google Cloud, in particolare Config Controller e include servizi pre-GA che sono ancora in anteprima e non sono disponibili pubblicamente (API Cloud Run Admin v2). Config Controller consente di eseguire il provisioning dichiarativo delle risorse GCP utilizzando il modello di risorse Kubernetes (KRM). Google Cloud Deploy utilizza Config Controller per creare e gestire i servizi Cloud Run come parte della sua pipeline di distribuzione.

Se hai domande, trovi bug o vuoi condividere feedback, contattaci all'indirizzo clouddeploy-feedback-external@google.com.

Tutorial di Cloud Shell

Le istruzioni contenute in questo documento sono incluse anche in un tutorial facile da seguire, basato su Cloud Shell. Puoi seguire questo tutorial mentre utilizzi questo documento per ottenere indicazioni e contesto.

Configura l'ambiente

Crea un nuovo progetto e imposta il progetto predefinito per Google Cloud CLI.

Ti consigliamo di iniziare con un nuovo progetto.
```
gcloud config set project PROJECT_ID
```
Nel comando riportato sopra, sostituisci PROJECT_ID con il tuo ID progetto effettivo. In tutto il documento, il codice (comandi e file) contiene {PROJECT_ID} come segnaposto. La sua sostituzione qui viene completata in tutte le istanze di questo documento, a meno che non aggiorni la pagina.
Abilita le API richieste:
```
gcloud services enable \
    krmapihosting.googleapis.com \
    clouddeploy.googleapis.com \
    compute.googleapis.com \
    run.googleapis.com
```
Questo comando abilita le API seguenti, che devi completare per completare questo esperimento:
- Compute Engine
- Config Controller
- Google Cloud Deploy
- Cloud Build (abilitato tramite Google Cloud Deploy)
- Cloud Storage (abilitato tramite Google Cloud Deploy)
- Resource Manager
- Cloud Run
- Google Kubernetes Engine (abilitato tramite Config Controller)
Assicurati di aver installato e configurato Google Cloud CLI.

Inoltre, dovrai assicurarti che kubectl sia installato:
```
which kubectl || gcloud components install kubectl
```
Se esegui comandi da Cloud Shell, questi componenti sono già installati per te.

Configura l'account di servizio predefinito di Compute Engine

Per impostazione predefinita, Google Cloud Deploy utilizza l'account di servizio predefinito di Compute Engine. L'account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questo passaggio è incluso per le organizzazioni che disattivano la concessione automatica dei ruoli per gli account di servizio predefiniti.

Esegui questi comandi per assicurarti che l'account di servizio disponga delle autorizzazioni appropriate:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/clouddeploy.jobRunner"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/container.developer"

Consulta la panoramica di Google Cloud Deploy.

Questa panoramica ti aiuterà a comprendere il servizio e i concetti di Google Cloud Deploy.

Configurazione di Config Controller

Google Cloud Deploy utilizza un'istanza di Config Controller per il deployment dei servizi e delle revisioni Cloud Run.

Prima di creare il controller di configurazione, assicurati che sia presente una rete predefinita:
```
gcloud compute networks list
```
L'output della console riuscito avrà il seguente aspetto:
```
NAME: default
SUBNET_MODE: AUTO
BGP_ROUTING_MODE: REGIONAL
IPV4_RANGE:
GATEWAY_IPV4:
```
Se non hai una rete predefinita, esegui il seguente comando:
```
gcloud compute networks create default --subnet-mode=auto
```
Se l'output era corretto, non è necessario eseguire questo comando.

Se riscontri altri problemi, consulta la guida alla risoluzione dei problemi di Config Controller o contatta l'amministratore della tua organizzazione.

Crea la tua istanza di Config Controller.

gcloud anthos config controller create cc-deployrun --location=us-central1

Concedi le autorizzazioni di Config Controller all'interno dei progetti in cui vuoi eseguire il deployment. Il comando seguente fornisce le autorizzazioni minime necessarie per configurare e gestire i servizi Cloud Run nel tuo progetto.

export SA_EMAIL="$(kubectl get ConfigConnectorContext -n config-control -o jsonpath='{.items[0].spec.googleServiceAccount}' 2> /dev/null)"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/run.admin" \
    --project "PROJECT_ID"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/iam.serviceAccountUser" \
    --project "PROJECT_ID"

Creare i file di configurazione

Google Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e su come eseguirne il deployment correttamente per i tuoi target separati. Per questo esperimento, abbiamo due target: run-dev e run-prod.

Target dell'esperimento Cloud Run, deployment e sviluppo di Google Cloud Deploy

In questa sezione creerai un file skaffold.yaml, che identifica i manifest di Cloud Run di cui verrà eseguito il deployment della tua applicazione tramite una pipeline di distribuzione di Google Cloud Deploy. Creerai anche i manifest per i tuoi servizi Cloud Run, uno per ciascun ambiente di destinazione (run-dev-service.yaml e run-prod-service.yaml, rispettivamente).

Crea una nuova directory per i tuoi manifest e vai al suo interno:
```
mkdir deploy-cloudrun
cd deploy-cloudrun
```

Crea il file skaffold.yaml in questa directory.

skaffold.yaml indica a Google Cloud Deploy quali manifest devono essere sottoposti a deployment per ogni destinazione della pipeline, per una determinata release.

apiVersion: skaffold/v2beta26
kind: Config
profiles:
 - name: prod
   deploy:
     kubectl:
       manifests:
         - run-prod-*.yaml
 - name: dev
   deploy:
     kubectl:
       manifests:
         - run-dev-*.yaml

Crea il file run-dev-service.yaml in questa stessa directory.

Questo manifest dichiarativo rappresenta la versione dell'ambiente dev del tuo servizio Cloud Run.

Osserva le impostazioni personalizzate per questo ambiente, ad esempio limitando la scalabilità dei container a due istanze. Le etichette e il nome vengono utilizzati per distinguere questa versione del servizio nel tuo progetto. Tieni presente che il nome dell'immagine è una variabile run-container anziché un'immagine container specifica. che viene sostituito con un'immagine container specifica quando crei una release in Google Cloud Deploy.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-dev
  name: deploytest-dev
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: dev
        image: run-container
    scaling:
      maxInstanceCount: 2
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Crea il file run-prod-service.yaml in questa stessa directory

Questo manifest rappresenta la versione prod del tuo servizio Cloud Run. Osserva il nome, le etichette e le impostazioni di scalabilità aggiornati, quindi riutilizza anche run-container.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-prod
  name: deploytest-prod
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: prod
        image: run-container
    scaling:
      maxInstanceCount: 10
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Crea pipeline di distribuzione e target

Puoi definire la pipeline di distribuzione e le destinazioni di Google Cloud Deploy in un file o in file separati. In questo tutorial, per semplicità, creerai un singolo file.

Nella directory con i manifest creati di recente (/deploy-cloudrun/), crea il file clouddeploy.yaml:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
 name: my-run-app-1
description: main application pipeline
serialPipeline:
 stages:
 - targetId: run-dev
   profiles:
   - dev
 - targetId: run-prod
   profiles:
   - prod
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-dev
description: Cloud Run development environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-prod
description: Cloud Run production environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun

cloudeploy.yaml definisce una sequenza di avanzamento di due fasi nella pipeline di distribuzione: run-dev e run-prod. Il file definisce anche le destinazioni in ciascuna di queste due fasi.

Tieni presente che entrambi i target puntano allo stesso Config Controller di un cluster GKE. Questo controller di configurazione, supportato da un cluster GKE sottostante creato al momento della creazione di Config Controller, crea i servizi Cloud Run per ogni ambiente utilizzando il rispettivo manifest.

Il tuo cluster GKE