Implementa una aplicación de forma canary en un destino

Prepara tu configuración de Skaffold y el manifiesto de la aplicación

Cloud Deploy usa Skaffold para proporcionar detalles sobre qué implementar y cómo hacerlo correctamente en tu objetivo.

En esta guía de inicio rápido, debes crear un archivo skaffold.yaml, que identifica el manifiesto de Kubernetes o la configuración del servicio de Cloud Run cuando se implementa un plan.

1. Abre una ventana de terminal.

2. Crea un directorio nuevo y navega hasta él.

   GKE

   mkdir deploy-canary-quickstart-gke
   cd deploy-canary-quickstart-gke
   

   GKE + API de 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 archivo llamado skaffold.yaml con el siguiente contenido:

   GKE

   apiVersion: skaffold/v4beta7
   kind: Config
   manifests:
     rawYaml:
     - kubernetes.yaml
   deploy:
     kubectl: {}
   

   GKE + API de 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: {}
   

   Este archivo es una configuración mínima de Skaffold que identifica tu manifiesto. Para este de inicio rápido, crearás el archivo. Pero también puedes hacer que Cloud Deploy cree uno por ti para aplicaciones simples que no son de producción.

   Consulta la referencia de skaffold.yaml. para obtener más información sobre este archivo.

4. Crea el manifiesto de tu aplicación.

   GKE

   Crea un archivo llamado kubernetes.yaml en el directorio deploy-canary-quickstart-gke con el siguiente contenido:

   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
   

   Este archivo es un archivo de Kubernetes manifiesto, que se aplica al clúster para implementar la aplicación.

   GKE + API de Gateway

   Crea un archivo llamado kubernetes.yaml en el archivo deploy-canary-quickstart-gke-gatewayapi. con el siguiente contenido:

   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
   

   Este archivo es un manifiesto, que se aplica al clúster para implementar la aplicación. Este manifiesto incluye los recursos de Deployment y servicio necesarios para además de una HTTPRoute y el recurso Gateway necesarios para usar API de puerta de enlace.

   Cloud Run

   Crea un archivo llamado run.yaml en el archivo deploy-canary-quickstart-run. con el siguiente contenido:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: my-canary-run-service
   spec:
     template:
       spec:
         containers:
         - image: my-app-image
   

   Este es un archivo de configuración del servicio de Cloud Run, que se aplica en el momento de la implementación para crear tu servicio en Cloud Run.

Crea la canalización de entrega y los destinos

Puedes definir la canalización de entrega y los destinos en un archivo o en archivos. En esta guía de inicio rápido, crearemos un archivo para nuestra canalización y nuestro único objetivo:

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

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

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 tu canalización y destinos con el servicio de Cloud Deploy:

   gcloud deploy apply --file=clouddeploy.yaml --region=us-central1 --project=PROJECT_ID
   

   Ahora tienes una canalización con un destino configurado para una implementación de versiones canary de administración de amenazas.

2. Confirma tu canalización y tus destinos:

   En la consola de Google Cloud, navega a Cloud Deploy La página Canalizaciones de entrega para ver la lista de tus entregas disponibles canalizaciones.

   Abrir la página Canalizaciones de entrega

   Se muestran la canalización de entrega que acabas de crear y la ruta de destino se muestra en la columna Destinos.

   

Crea una versión

Un lanzamiento es el recurso central de Cloud Deploy que representa el cambios que se están implementando. La canalización de entrega define el ciclo de vida de esa lanzamiento. Consulta Arquitectura de servicios de Cloud Deploy para obtener detalles sobre ese ciclo de vida.

Para crear un recurso release que represente la imagen del contenedor que se implementará, ejecuta el siguiente comando desde el directorio deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-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=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

 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

 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Cuando creas una versión, Cloud Deploy también crea automáticamente un recurso de lanzamiento para implementarlo de inmediato en tu único destino, prod.

Nos saltamos a la fase estable

Con esta primera versión, omitimos la fase de versiones canary y, luego, implementamos el 100% (estable fase). Esto se debe a que la aplicación no se implementó anteriormente, por lo que no hay forma de calcular el 50% de los Pods (para GKE) ni de cómo el tráfico se divide por el servicio (para Cloud Run). Los Pods (GKE) o las revisiones (Cloud Run) no existen aún.

Ahora que omitimos la fase de versiones canary, podemos comenzar la estable lo que lleva el tráfico al 100%. Después de eso, crearemos otra versión que ejecutará la canary.

Por lo general, en una situación real, ejecutarás una de implementación de versiones canary en la que tu aplicación ya se está ejecutando, por lo que esta fase omitir será raro.

Ver la versión en la consola de Google Cloud

Ahora que creaste la primera versión, se creará el lanzamiento y podrás ver la versión y el lanzamiento en la consola de Google Cloud. También puedes ver la visualización de la canalización, que muestra el estado actual del lanzamiento.

1. En la consola de Google Cloud, navega a Cloud Deploy Página Canalizaciones de entrega para ver tu my-canary-demo-app-1 canalización de entrega continua.

   Abrir la página Canalizaciones de entrega

2. Haz clic en el nombre de la canalización de entrega “my-canary-demo-app-1”.

   La visualización de la canalización muestra el estado de implementación de la app. Porque no existe en una sola etapa de la canalización, la visualización solo muestra un nodo.

   

   Y la versión aparece en la pestaña Versiones, en Detalles de la canalización de entrega.

3. Haz clic en el nombre de la versión, test-release-001.

   Tus lanzamientos aparecen en Lanzamientos. Puedes hacer clic en un lanzamiento para ver sus más detallados, incluido el registro de la implementación.

   

   Observen que el estado del lanzamiento es "Pendiente de avance" y el objetivo que se muestra en la visualización de la canalización tiene un vínculo para “Avanzar a estable”.

Avanzar en la fase de lanzamiento

Después de la primera versión, se omitió la fase canary, y el lanzamiento está esperando para iniciar la fase "estable", que implementa la aplicación al 100%:

1. En la visualización de la canalización, haz clic en Avanzar a estable.

2. Cuando se te solicite, haz clic en Advance para confirmar.

Después de unos minutos, el lanzamiento se encontrará “estable” fase, y el aplicación se implementa al 100%.

Ejecuta la implementación de versiones canary

Como el primer lanzamiento omitió la fase de versión canary, Ahora crearemos otro lanzamiento que, esta vez, ejecuta un comando de Google Workspace.

1. Para crear un release nuevo, ejecuta el siguiente comando desde deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o Directorio 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 de 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4
   

   Después de unos minutos, se crea un lanzamiento y, esta vez, la etapa de versión canary ejecutado:

   

   Cuando finaliza la primera fase de lanzamiento, este ahora se encuentra en la fase de versión canary:

   

   Esto significa que la aplicación ahora se implementó al 50%. Para GKE basado en serviceNetworking, se implementa en la mitad Pods. Para las instancias de GKE basadas en la API de puerta de enlace El tráfico de Cloud Run se asigna al 50%.

2. Haz clic en Lanzamiento avanzado y, luego, en Avanzado cuando se te solicite.

   Esto hace que el lanzamiento avance a un nivel “estable” de implementación de la aplicación 100%