Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment canary di un'applicazione in una destinazione

Questa guida rapida mostra come utilizzare Cloud Deploy per fornire un'immagine di applicazione di esempio in un deployment canary a Google Kubernetes Engine o a Cloud Run. Puoi anche eseguire un deployment canary in GKE Enterprise, ma in questa guida rapida vengono mostrati solo GKE e Cloud Run.

Un deployment canary suddivide il traffico tra una versione dell'applicazione già implementata e la nuova versione. Cloud Run distribuisce il traffico in base alle percentuali che configuri nella pipeline di distribuzione. GKE esegue il deployment della nuova versione in una parte dei pod. Questa guida rapida viene implementata prima al 50%, poi al 100%.

In questa guida rapida è presente un solo target, (prod). Pertanto, creiamo un solo cluster GKE o un solo servizio Cloud Run per eseguire l'applicazione.

In questa guida rapida imparerai a:

Crea un cluster GKE o definisci un servizio Cloud Run.

Puoi eseguire il deployment canary anche nei cluster GKE Enterprise, ma questa guida rapida utilizza solo GKE e Cloud Run.
Crea una configurazione Skaffold e un manifest Kubernetes per specificare l'immagine container (precompilata) da eseguire il deployment.
Definisci la pipeline di distribuzione e la destinazione di deployment di Cloud Deploy.
Richiama la pipeline di distribuzione creando una release, che viene automaticamente implementata in un target.

Questa prima release salta la fase canary.
Visualizza la pipeline di distribuzione e la release nella console Google Cloud .
Crea una seconda release, questa volta eseguendo la fase canary per eseguire il deployment dell'applicazione al 50%.
Fai avanzare la release per il deployment al 100%.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Se hai già installato la CLI, assicurati di utilizzare l'ultima versione:

gcloud components update

Assicurati che l'account di servizio Compute Engine predefinito disponga delle autorizzazioni necessarie.
Il account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disattivano la concessione automatica dei ruoli per i service account predefiniti.
1. Per prima cosa, aggiungi il ruolo 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/clouddeploy.jobRunner"
```
2. Aggiungi il ruolo di sviluppatore per il runtime specifico.
3. Aggiungi il ruolo iam.serviceAccountUser, che include l'autorizzazione actAs per eseguire il deployment nel runtime:
```
gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/iam.serviceAccountUser" \
    --project=PROJECT_ID
```
Crea l'ambiente di runtime
GKE
Crea un cluster GKE Autopilot:
```
 gcloud container clusters create-auto canary-quickstart-cluster \
                  --project=PROJECT_ID \
                  --region=us-central1
```
GKE + API Gateway
1. Crea un cluster GKE con le impostazioni consigliate per supportare l'utilizzo con Istio:
  gcloud container clusters create canary-quickstart-cluster \ --machine-type=n1-standard-1 \ --num-nodes 4 \ --region=us-central1 \ --project=PROJECT_ID
2. Recupera le credenziali del cluster:
  gcloud container clusters get-credentials canary-quickstart-cluster \ --project=PROJECT_ID \ --region=us-central1
3. Installa i CRD dell'API Kubernetes Gateway se non sono già presenti nel cluster.
  kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v0.6.2/standard-install.yaml
4. Attiva l'implementazione del controller Gateway di Istio installando Istio.
  curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.17.2 sh - \ && ./istio-1.17.2/bin/istioctl install --set profile=minimal -y
Cloud Run
Se utilizzi Cloud Run, puoi saltare questo comando, non devi fare nulla qui.
Prepara la configurazione di Skaffold e il manifest dell'applicazione

Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e come eseguirlo correttamente nel tuo target.

In questa guida rapida, crei un file skaffold.yaml, che identifica la configurazione del servizio Cloud Run o il manifest Kubernetes da eseguire il deployment.
1. Apri una finestra del terminale.
2. Crea una nuova directory e accedi alla directory.
  GKE
  mkdir deploy-canary-quickstart-gke cd deploy-canary-quickstart-gke
  GKE + API Gateway
  mkdir deploy-canary-quickstart-gke-gatewayapi cd deploy-canary-quickstart-gke-gatewayapi
  Cloud Run
  mkdir deploy-canary-quickstart-run cd deploy-canary-quickstart-run
3. Crea un file denominato skaffold.yaml con i seguenti contenuti:
  GKE
  apiVersion: skaffold/v4beta7 kind: Config manifests: rawYaml: - kubernetes.yaml deploy: kubectl: {}
  GKE + API Gateway
  apiVersion: skaffold/v4beta7 kind: Config manifests: rawYaml: - kubernetes.yaml deploy: kubectl: {}
  Cloud Run
  apiVersion: skaffold/v4beta7 kind: Config manifests: rawYaml: - run.yaml deploy: cloudrun: {}
  Questo file è una configurazione Skaffold minima che identifica il manifest. Per questa guida rapida, crei il file. ma puoi anche chiedere a Cloud Deploy di crearne uno per te, per applicazioni semplici non di produzione.
  
  Per ulteriori informazioni su questo file, consulta il riferimento skaffold.yaml.
4. Crea il manifest dell'applicazione.
  GKE
  Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke con il seguente contenuto:
  
  apiVersion: apps/v1 kind: Deployment metadata: name: my-deployment labels: app: my-app namespace: default spec: replicas: 1 selector: matchLabels: app: my-app template: metadata: labels: app: my-app spec: containers: - name: nginx image: my-app-image --- apiVersion: v1 kind: Service metadata: name: my-service namespace: default spec: selector: app: my-app ports: - protocol: TCP port: 80
  
  Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a una risorsa HTTPRoute e Gateway necessaria per l'utilizzo dell'API Gateway.
  
  L'immagine container da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito con l'immagine specifica quando crei la release.
  GKE + API Gateway
  Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke-gatewayapi con il seguente contenuto:
  
  kind: Gateway apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: my-gateway annotations: networking.istio.io/service-type: "ClusterIP" spec: gatewayClassName: istio listeners: - name: default hostname: "*.example.com" port: 80 protocol: HTTP allowedRoutes: namespaces: from: All --- kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: my-httproute spec: parentRefs: - kind: Gateway name: my-gateway hostnames: - "test.example.com" rules: - backendRefs: - name: my-service port: 80 --- apiVersion: v1 kind: Service metadata: name: my-service spec: selector: app: my-app ports: - name: tcp-port protocol: TCP port: 80 targetPort: 8080 --- apiVersion: apps/v1 kind: Deployment metadata: name: my-deployment labels: app: my-app spec: replicas: 1 selector: matchLabels: app: my-app template: metadata: labels: app: my-app spec: containers: - name: nginx image: my-app-image
  
  Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a una risorsa HTTPRoute e Gateway necessaria per l'utilizzo dell'API Gateway.
  
  L'immagine container da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito con l'immagine specifica quando crei la release.
  Cloud Run
  Crea un file denominato run.yaml nella directory deploy-canary-quickstart-run con il seguente contenuto:
  
  apiVersion: serving.knative.dev/v1 kind: Service metadata: name: my-canary-run-service spec: template: spec: containers: - image: my-app-image
  
  Questo file è una definizione di base del servizio Cloud Run, che viene applicata al momento del deployment per creare il servizio in Cloud Run. L'immagine del container di cui eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito con l'immagine specifica quando crei la release.
Nota: se vuoi utilizzare manifest diversi per ogni target, leggi questo articolo sulla gestione dei manifest per scoprire di più sull'utilizzo dei profili Skaffold.

Crea la pipeline di distribuzione e i target

Puoi definire la pipeline di pubblicazione e i target in un unico file o in file separati. In questa guida rapida, creiamo un file per la pipeline e un singolo target:
GKE
Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-gke con il seguente contenuto:
apiVersion: deploy.cloud.google.com/v1 kind: DeliveryPipeline metadata: name: my-canary-demo-app-1 description: main application pipeline serialPipeline: stages: - targetId: prod profiles: [] strategy: canary: runtimeConfig: kubernetes: serviceNetworking: service: "my-service" deployment: "my-deployment" canaryDeployment: percentages: [50] verify: false --- apiVersion: deploy.cloud.google.com/v1 kind: Target metadata: name: prod description: prod GKE cluster gke: cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster
GKE + API Gateway
Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-gke-gatewayapi con il seguente contenuto:
apiVersion: deploy.cloud.google.com/v1 kind: DeliveryPipeline metadata: name: my-canary-demo-app-1 description: main application pipeline serialPipeline: stages: - targetId: prod profiles: [] strategy: canary: runtimeConfig: kubernetes: gatewayServiceMesh: httpRoute: "my-httproute" service: "my-service" deployment: "my-deployment" canaryDeployment: percentages: [50] verify: false --- apiVersion: deploy.cloud.google.com/v1 kind: Target metadata: name: prod description: prod GKE cluster gke: cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster
Cloud Run
Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-run con il seguente contenuto:
apiVersion: deploy.cloud.google.com/v1 kind: DeliveryPipeline metadata: name: my-canary-demo-app-1 description: main application pipeline serialPipeline: stages: - targetId: prod profiles: [] strategy: canary: runtimeConfig: cloudRun: automaticTrafficControl: true canaryDeployment: percentages: [50] verify: false --- apiVersion: deploy.cloud.google.com/v1 kind: Target metadata: name: prod description: prod Run Service run: location: projects/PROJECT_ID/locations/us-central1
1. Registra la pipeline e i target con il servizio Cloud Deploy:
```
gcloud deploy apply --file=clouddeploy.yaml --region=us-central1 --project=PROJECT_ID
```
  Ora hai una pipeline, con un target configurato per una strategia di deployment canary.
2. Conferma la pipeline e i target:
  
  Nella console Google Cloud , vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare un elenco delle pipeline di distribuzione disponibili.
  
  Apri la pagina Pipeline di distribuzione
  
  Viene visualizzata la pipeline di distribuzione appena creata e il target che hai configurato è elencato nella colonna Target.
Crea una release

Una release è la risorsa centrale di Cloud Deploy che rappresenta le modifiche di cui viene eseguito il deployment. La pipeline di distribuzione definisce il ciclo di vita di questa release. Per i dettagli su questo ciclo di vita, consulta Architettura del servizio Cloud Deploy.

Per creare una risorsa release che rappresenti l'immagine container da eseguire il deployment, esegui il comando seguente dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-run:
GKE
gcloud deploy releases create test-release-001 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
GKE + API Gateway
gcloud deploy releases create test-release-001 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
Cloud Run
gcloud deploy releases create test-release-001 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nel manifest o nella definizione del servizio con l'immagine specifica qualificata con SHA. Google consiglia di creare modelli per i manifest in questo modo e di utilizzare nomi di immagini qualificati SHA al momento della creazione della release.

Quando crei una release, Cloud Deploy crea automaticamente anche una risorsa di rollout per il deployment immediato nel tuo unico target, prod.

Passiamo alla fase stabile

Con questa prima release, saltiamo la fase canary ed eseguiamo il deployment al 100% (fase stabile). Questo perché l'applicazione non è stata sottoposta a deployment in precedenza, quindi non è possibile calcolare il 50% dei pod (per GKE) o come il traffico viene suddiviso per il servizio (per Cloud Run). I pod (GKE) o le revisioni (Cloud Run) non esistono ancora.

Dopo aver saltato la fase canary, siamo ora pronti per iniziare la fase stabile, che porta il traffico al 100%. Dopodiché, creeremo un'altra release, che eseguirà la canary.

In una situazione reale, in genere esegui un deployment canary in cui l'applicazione è già in esecuzione, quindi questo passaggio sarà raro.

Visualizzare la release nella console Google Cloud

Ora che hai creato la prima release, il lancio è stato creato e puoi visualizzare la release e il lancio nella console. Google Cloud Puoi anche visualizzare la visualizzazione della pipeline, che mostra lo stato attuale del rilascio.
1. Nella console Google Cloud , vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare la pipeline di distribuzione my-canary-demo-app-1.
  
  Apri la pagina Pipeline di distribuzione
2. Fai clic sul nome della pipeline di distribuzione "my-canary-demo-app-1".
  
  La visualizzazione della pipeline mostra lo stato del deployment dell'app. Poiché la pipeline contiene una sola fase, la visualizzazione mostra un solo nodo.
  
  La tua uscita è elencata nella scheda Uscite in Dettagli della pipeline di distribuzione.
3. Fai clic sul nome della release, test-release-001.
  
  I rollout vengono visualizzati nella sezione Rollout. Puoi fare clic su un'implementazione per visualizzarne i dettagli, incluso il log di deployment.
  
  Nota che lo stato di implementazione è "Avanzamento in attesa" e che la destinazione mostrata nella visualizzazione della pipeline ha un link ad "Avanza alla versione stabile".
Avanza alla fase di implementazione

Dopo la prima release, la fase canary è stata ignorata e l'implementazione è in attesa di iniziare la fase "stabile", che esegue il deployment dell'applicazione al 100%:
1. Nella visualizzazione della pipeline, fai clic su Passa alla versione stabile.
2. Quando richiesto, fai clic su Continua per confermare.
Dopo alcuni minuti, l'implementazione è nella fase "stabile" e l'applicazione viene implementata al 100%.

Esegui il deployment canary

Poiché la prima release ha saltato la fase canary, ora creeremo un'altra release, che questa volta esegue un deployment canary.
1. Per creare un nuovo release, esegui il comando seguente dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-run:
  GKE
  gcloud deploy releases create test-release-002 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
  GKE + API Gateway
  gcloud deploy releases create test-release-002 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
  Cloud Run
  gcloud deploy releases create test-release-002 \ --project=PROJECT_ID \ --region=us-central1 \ --delivery-pipeline=my-canary-demo-app-1 \ --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
  Dopo alcuni minuti, viene creata un'implementazione e questa volta viene eseguita la fase canary:
  
  Al termine della prima fase di implementazione, l'implementazione si trova ora nella fase canary:
  
  Ciò significa che l'applicazione è ora implementata al 50%. Per GKE basato su serviceNetworking, viene eseguito il deployment sulla metà dei tuoi pod. Per GKE e Cloud Run basati sull'API Gateway, il traffico viene allocato al 50%.
2. Fai clic su Implementazione avanzata, quindi su Avanza quando richiesto.
  
  In questo modo, l'implementazione passa alla fase "stabile", eseguendo il deployment dell'applicazione al 100%.
Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.
1. Elimina il cluster canary-quickstart-cluster (solo GKE):
```
gcloud container clusters delete canary-quickstart-cluster --region=us-central1 --project=PROJECT_ID
```
2. Elimina il servizio my-canary-run-service (solo Cloud Run):
```
gcloud run services delete my-canary-run-service --region=us-central1 --project=PROJECT_ID
```
3. Elimina la pipeline di distribuzione, la destinazione e tutte le risorse di release e implementazione:
```
gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
```
4. Elimina i bucket Cloud Storage creati da Cloud Deploy.
  
  Uno termina con _clouddeploy e l'altro è [region].deploy-artifacts.[project].appspot.com.
  
  Apri la pagina del browser Cloud Storage
Ecco fatto, hai completato questa guida rapida.
Passaggi successivi

Esegui il deployment canary di un'applicazione in una destinazione

Prima di iniziare

Crea l'ambiente di runtime

GKE

GKE + API Gateway

Cloud Run

Prepara la configurazione di Skaffold e il manifest dell'applicazione

GKE

GKE + API Gateway

Cloud Run

GKE

GKE + API Gateway

Cloud Run

GKE

GKE + API Gateway

Cloud Run

Crea la pipeline di distribuzione e i target

GKE

GKE + API Gateway

Cloud Run

Crea una release

GKE

GKE + API Gateway

Cloud Run

Passiamo alla fase stabile

Visualizzare la release nella console Google Cloud

Avanza alla fase di implementazione

Esegui il deployment canary

GKE

GKE + API Gateway

Cloud Run

Esegui la pulizia

Passaggi successivi