Accede a los objetos de la API de Kubernetes con un conector

Vista previa

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Un clúster de Google Kubernetes Engine (GKE) consta de un plano de control y máquinas de trabajo llamadas nodos. Puedes ejecutar tus cargas de trabajo de Kubernetes alojadas en contenedores en un clúster de GKE. Los nodos son las máquinas de trabajador que ejecutan tus aplicaciones alojadas en contenedores y otras cargas de trabajo, y el plano de control es la extremo unificado para tu clúster. Para obtener más información, consulta Arquitectura del clúster de GKE.

El servidor de la API de Kubernetes se ejecuta en el plano de control, lo que te permite interactuar con los objetos de Kubernetes en el clúster a través de llamadas a la API de Kubernetes. Los objetos son entidades persistentes en el sistema de Kubernetes y representan el estado de tu clúster. Para obtener más información, consulta Objetos en Kubernetes y Descripción general de la API en la documentación de Kubernetes, que incluye vínculos a las páginas de la "referencia de la API de Kubernetes".

En este documento, se muestra cómo usar el conector de la API de Kubernetes en un flujo de trabajo para realizar solicitudes al extremo del servicio de Kubernetes alojado en el plano de control de un clúster de GKE. Por ejemplo, puedes usar el conector para crear Deployments de Kubernetes, ejecutar objetos Job, administrar Pods o acceder a apps implementadas a través de un proxy. Para obtener más información, consulta la Descripción general del conector de API de Kubernetes

Nota: La API de Kubernetes es distinta de la API de Google Kubernetes Engine, que se usa para crear y administrar clústeres de GKE. Para llamar al API de GKE en un flujo de trabajo, usa el Conector de la API de Kubernetes Engine.

Antes de comenzar

Antes de continuar con las tareas de este documento, asegúrate de haber completado ciertos requisitos previos.

Habilita las APIs

Antes de que puedas acceder a los objetos de la API de Kubernetes con el conector de la API de Kubernetes, debes habilitar las siguientes APIs:

• API de Google Kubernetes Engine: Para compilar y administrar aplicaciones basadas en contenedores con GKE

• APIs de Workflows: para administrar definiciones de flujos de trabajo y executions; habilitar la API de Workflows habilita automáticamente la API de Workflow Executions

Console

Habilita las API:

Habilita las APIs

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Habilita las API:

   gcloud services enable container.googleapis.com workflows.googleapis.com

Crea una cuenta de servicio

Crea una cuenta de servicio administrada por el usuario que actúe como la identidad de tu flujo de trabajo y bríndale el rol de Desarrollador de Kubernetes Engine (roles/container.developer) para que el flujo de trabajo pueda acceder a los objetos de la API de Kubernetes dentro de los clústeres.

Nota: El rol de administración de identidades y accesos (IAM) afecta a qué recursos puede acceder tu cuenta de servicio en tu proyecto. Puedes revocar este rol o otorgar roles adicionales más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un función predefinida o rol personalizado que satisfaga tus necesidades.

Console

1. En la consola de Google Cloud, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto y haz clic en Crear cuenta de servicio.

3. Escribe un nombre en el campo Nombre de cuenta de servicio. La consola de Google Cloud completa el campo ID de cuenta de servicio según este nombre.

   Opcional: en el campo Descripción de la cuenta de servicio, escribe una descripción. Por ejemplo, Service account for Kubernetes API.

4. Haz clic en Crear y continuar.

5. En la lista Seleccionar un rol, filtra y selecciona la carpeta Kubernetes desarrollador de Compute Engine.

6. Haga clic en Continuar.

7. Para terminar de crear la cuenta, haz clic en Listo.

gcloud

1. Cree la cuenta de servicio:

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Reemplaza SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio.

2. Otorga el rol container.developer a tu cuenta de servicio.

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
       --role=roles/container.developer

   Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

Ten en cuenta que puedes usar IAM y el control de acceso basado en roles (RBAC) de Kubernetes para controlar el acceso a tu clúster de GKE:

• IAM no es específico de Kubernetes. Proporciona administración de identidades para varios productos de Google Cloud y opera sobre todo a nivel del proyecto de Google Cloud.

• El RBAC de Kubernetes es un componente central de Kubernetes y te permite crear y otorgar roles (conjuntos de permisos) para cualquier objeto o tipo de objeto dentro del clúster. Si usas GKE y necesitas permisos detallados para cada objeto y operación dentro del clúster, el RBAC de Kubernetes es la mejor opción.

Para obtener más información, consulta Control de acceso.

Cree un clúster de GKE

Para usar el conector de la API de Kubernetes, debes haber creado un bucket clúster de GKE privado. En un clúster privado, los nodos solo tienen direcciones IP internas, lo que significa que los nodos y los Pods están aislados del a Internet de forma predeterminada. Para obtener más información, consulta Clústeres privados.

También puedes especificar el modo de funcionamiento, que te ofrece diferentes niveles de flexibilidad, responsabilidad y control. Por ejemplo, puedes crear un Autopilot, que es un modo de operación en GKE en que Google administra la configuración de tu clúster, incluidos los nodos, el escalamiento, seguridad y otros parámetros preconfigurados. Para obtener más información, consulta Elige un modo de operación de GKE.

Si aún no creaste un clúster de GKE, puedes implementar una aplicación alojada en contenedores de servidor web en un clúster de GKE. Si quieres probar las instrucciones de esta puedes crear un clúster de Autopilot completando el siguientes.

Console

1. En la consola de Google Cloud, ve a la página Clústeres de Kubernetes.

   Ir a Clústeres de Kubernetes

2. Haz clic en Crear.

3. Si se te solicita que selecciones un modo de clúster, elige Autopilot.

4. En la sección Aspectos básicos del clúster, completa lo siguiente:

   1. Ingresa el Nombre de tu clúster, como hello-cluster.
   2. Selecciona una región para tu clúster, como us-central1.

5. Haz clic en Siguiente: Herramientas de redes.

6. En la sección Acceso de red IPv4, para crear un clúster con un extremo de acceso público, elige Clúster público.

7. Para todos los demás parámetros de configuración, acepta los valores predeterminados.

8. Haz clic en Crear.

La creación del clúster puede tardar varios minutos en completarse. Una vez creado el clúster, aparecerá una marca de verificación indica que se está ejecutando.

gcloud

Ejecuta el comando siguiente:

gcloud container clusters create-auto CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID

Reemplaza lo siguiente:

• CLUSTER_NAME: Es el nombre de tu GKE. clúster, como hello-cluster
• LOCATION: el region para el clúster, como us-central1
• PROJECT_ID: El ID del proyecto de Google Cloud.

La creación del clúster puede tardar varios minutos en completarse. Una vez que se crea el clúster, el resultado debe ser similar al siguiente:

Creating cluster hello-cluster...done.
Created [https://container.googleapis.com/v1/projects/MY_PROJECT/zones/us-central1/clusters/hello-cluster].
[...]
STATUS: RUNNING

Usa el conector para enviar una solicitud HTTP

Puedes usar el conector de la API de Kubernetes para enviar una solicitud HTTP al plano de control de un clúster de GKE. Por ejemplo, el siguiente flujo de trabajo crea un objeto Deployment llamado nginx-deployment en el entorno de Kubernetes especificado clúster. La implementación describe un estado obligatorio; en este caso, ejecutar tres Pods con la imagen nginx:1.14.2 y exponer su servicio en el puerto 80. (Si no se especifica, project y location se establecen de forma predeterminada en el flujo de trabajo).

Para obtener más información, consulta la página de referencia del conector de la API de Kubernetes gke.request.

Ten en cuenta lo siguiente:

• El campo path corresponde a la ruta de acceso del método de la API de Kubernetes. Para ver más en la documentación de Kubernetes, consulta el Descripción general de la API, que incluye vínculos la “referencia de la API de Kubernetes” páginas.
• Puedes detectar y controlar los errores de las solicitudes HTTP en tu flujo de trabajo. Para obtener más información, consulta Errores de flujo de trabajo.

Implementa tu flujo de trabajo

Antes de ejecutar un flujo de trabajo, debes crearlo e implementarlo.

Console

1. En la consola de Google Cloud, ve a la página Flujos de trabajo.

   Ir a Workflows

2. Haz clic en  Crear.

3. Ingresa un nombre para el flujo de trabajo nuevo, como kubernetes-api-request.

4. En la lista Región, selecciona us-central1.

5. Selecciona la Cuenta de servicio que creaste antes.

6. Haz clic en Siguiente.

7. En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

   YAML

   main:
     steps:
       - create_deployment:
           call: gke.request
           args:
             cluster_id: "CLUSTER_NAME"
             project: "PROJECT_ID"
             location: "LOCATION"
             method: "POST"
             path: "/apis/apps/v1/namespaces/default/deployments"
             body:
               kind: Deployment
               metadata:
                 name: nginx-deployment
                 labels:
                   app: nginx
               spec:
                 replicas: 3
                 selector:
                   matchLabels:
                     app: nginx
                 template:
                   metadata:
                     labels:
                       app: nginx
                   spec:
                     containers:
                       - name: nginx
                         image: nginx:1.14.2
                         ports:
                           - containerPort: 80
           result: result
       - returnResult:
           return: '${result}'

   JSON

   {
     "main": {
       "steps": [
         {
           "create_deployment": {
             "call": "gke.request",
             "args": {
               "cluster_id": "CLUSTER_NAME",
               "project": "PROJECT_ID",
               "location": "LOCATION",
               "method": "POST",
               "path": "/apis/apps/v1/namespaces/default/deployments",
               "body": {
                 "kind": "Deployment",
                 "metadata": {
                   "name": "nginx-deployment",
                   "labels": {
                     "app": "nginx"
                   }
                 },
                 "spec": {
                   "replicas": 3,
                   "selector": {
                     "matchLabels": {
                       "app": "nginx"
                     }
                   },
                   "template": {
                     "metadata": {
                       "labels": {
                         "app": "nginx"
                       }
                     },
                     "spec": {
                       "containers": [
                         {
                           "name": "nginx",
                           "image": "nginx:1.14.2",
                           "ports": [
                             {
                               "containerPort": 80
                             }
                           ]
                         }
                       ]
                     }
                   }
                 }
               }
             },
             "result": "result"
           }
         },
         {
           "returnResult": {
             "return": "${result}"
           }
         }
       ]
     }
   }
   

   Reemplaza lo siguiente:

   • CLUSTER_NAME: Es el nombre de tu clúster de GKE, como hello-cluster.
   • PROJECT_ID: El ID del proyecto de Google Cloud.
   • LOCATION: Es la región de tu clúster, como us-central1.

8. Haz clic en Implementar.

gcloud

1. Crea un archivo de código fuente para tu flujo de trabajo:

   touch kubernetes-api-request.JSON_OR_YAML

   Reemplaza JSON_OR_YAML por yaml o json. según el formato de tu flujo de trabajo.

2. En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

   YAML

   main:
     steps:
       - create_deployment:
           call: gke.request
           args:
             cluster_id: "CLUSTER_NAME"
             project: "PROJECT_ID"
             location: "LOCATION"
             method: "POST"
             path: "/apis/apps/v1/namespaces/default/deployments"
             body:
               kind: Deployment
               metadata:
                 name: nginx-deployment
                 labels:
                   app: nginx
               spec:
                 replicas: 3
                 selector:
                   matchLabels:
                     app: nginx
                 template:
                   metadata:
                     labels:
                       app: nginx
                   spec:
                     containers:
                       - name: nginx
                         image: nginx:1.14.2
                         ports:
                           - containerPort: 80
           result: result
       - returnResult:
           return: '${result}'

   JSON

   {
     "main": {
       "steps": [
         {
           "create_deployment": {
             "call": "gke.request",
             "args": {
               "cluster_id": "CLUSTER_NAME",
               "project": "PROJECT_ID",
               "location": "LOCATION",
               "method": "POST",
               "path": "/apis/apps/v1/namespaces/default/deployments",
               "body": {
                 "kind": "Deployment",
                 "metadata": {
                   "name": "nginx-deployment",
                   "labels": {
                     "app": "nginx"
                   }
                 },
                 "spec": {
                   "replicas": 3,
                   "selector": {
                     "matchLabels": {
                       "app": "nginx"
                     }
                   },
                   "template": {
                     "metadata": {
                       "labels": {
                         "app": "nginx"
                       }
                     },
                     "spec": {
                       "containers": [
                         {
                           "name": "nginx",
                           "image": "nginx:1.14.2",
                           "ports": [
                             {
                               "containerPort": 80
                             }
                           ]
                         }
                       ]
                     }
                   }
                 }
               }
             },
             "result": "result"
           }
         },
         {
           "returnResult": {
             "return": "${result}"
           }
         }
       ]
     }
   }
   

   Reemplaza lo siguiente:

   • CLUSTER_NAME: Es el nombre de tu GKE. clúster, como hello-cluster
   • LOCATION: Es la región de tu clúster, como us-central1.

3. Implementa el flujo de trabajo:

   gcloud workflows deploy kubernetes-api-request \
       --source=kubernetes-api-request.JSON_OR_YAML \
       --location=LOCATION \
       --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Ejecuta tu flujo de trabajo

Después de implementar correctamente tu flujo de trabajo, puedes ejecutarlo. Ejecuta la definición actual del flujo de trabajo asociada con el flujo de trabajo.

Console

1. En la consola de Google Cloud, ve a la página Flujos de trabajo.

   Ir a Workflows

2. En la página Recomendaciones, selecciona tu flujo de trabajo para ir a su página de detalles.

3. En la página Detalles del flujo de trabajo, haz clic en Ejecutar.

4. Haz clic de nuevo en Ejecutar.

5. Observa los resultados del flujo de trabajo en el panel Output.

   Si se ejecuta de forma correcta, el estado de ejecución debe ser Succeeded y se muestra el cuerpo de la respuesta.

gcloud

Ejecuta el flujo de trabajo:

gcloud workflows run kubernetes-api-request \
    --location=LOCATION

Si se ejecuta correctamente, el estado debe ser SUCCEEDED y el cuerpo de la respuesta el resultado.

Usa el conector para ejecutar una tarea de Kubernetes

Puedes usar el conector de API de Kubernetes para implementar y ejecutar un objeto Job de Kubernetes en un clúster de GKE. El siguiente flujo de trabajo crea un trabajo de Kubernetes que ejecuta una secuencia de comandos Bash que se itera a través de una secuencia de números. El flujo de trabajo espera hasta 90 segundos a que se complete el trabajo de Kubernetes. De lo contrario, se genera un error. Si el trabajo se completa, se borra.

Tenga en cuenta que un trabajo se considera completo si su estado incluye una condición. tipo de Complete. Por ejemplo:

  "status": {
    "conditions": [
      {
        "type": "Complete",
        "status": "True"
      }
    ]
  }

Si el trabajo falla, se muestra una etiqueta FailedJobError. Por ejemplo:

{
  "tags": ["FailedJobError"]
  "job": {...}
  "message":"Kubernetes job failed"
}

Para obtener más información, consulta las páginas de referencia de las siguientes funciones del conector de la API de Kubernetes:

• gke.create_job
• gke.await_job
• gke.delete_job

Implementa tu flujo de trabajo

Antes de ejecutar un flujo de trabajo, debes crearlo e implementarlo.

Console

1. En la consola de Google Cloud, ve a la página Flujos de trabajo.

   Ir a Workflows

2. Haz clic en  Crear.

3. Ingresa un nombre para el flujo de trabajo nuevo, como kubernetes-api-job.

4. En la lista Región, selecciona us-central1.

5. Selecciona la Cuenta de servicio que creaste antes.

6. Haz clic en Siguiente.

7. En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

   YAML

   main:
     steps:
       - init:
           assign:
             - project: "PROJECT_ID"
             - location: "LOCATION"
             - cluster_id: "CLUSTER_NAME"
             - job_name: "JOB_NAME"
             - namespace: "default"
       - create_job:
           call: gke.create_job
           args:
             cluster_id: '${cluster_id}'
             location: '${location}'
             project: '${project}'
             namespace: '${namespace}'
             job:
               apiVersion: batch/v1
               kind: Job
               metadata:
                 name: "${job_name}"
               spec:
                 template:
                   spec:
                     containers:
                       - name: counter
                         image: centos:7
                         command:
                           - "bin/bash"
                           - "-c"
                           - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                     restartPolicy: Never
           result: job
       - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
           call: gke.await_job
           args:
             cluster_id: '${cluster_id}'
             job_name: '${job_name}'
             location: '${location}'
             project: '${project}'
             timeout: 90  # 90 seconds
           result: completed_job
       - cleanup_job:
           call: gke.delete_job
           args:
             cluster_id: '${cluster_id}'
             job_name: '${job_name}'
             location: '${location}'
             project: '${project}'
             query:
               propagationPolicy: "Foreground"  # delete child Pods
       - return_job:
           return: '${completed_job}'

   JSON

   {
     "main": {
       "steps": [
         {
           "init": {
             "assign": [
               {
                 "project": "PROJECT_ID"
               },
               {
                 "location": "LOCATION"
               },
               {
                 "cluster_id": "CLUSTER_NAME"
               },
               {
                 "job_name": "JOB_NAME"
               },
               {
                 "namespace": "default"
               }
             ]
           }
         },
         {
           "create_job": {
             "call": "gke.create_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "location": "${location}",
               "project": "${project}",
               "namespace": "${namespace}",
               "job": {
                 "apiVersion": "batch/v1",
                 "kind": "Job",
                 "metadata": {
                   "name": "${job_name}"
                 },
                 "spec": {
                   "template": {
                     "spec": {
                       "containers": [
                         {
                           "name": "counter",
                           "image": "centos:7",
                           "command": [
                             "bin/bash",
                             "-c",
                             "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                           ]
                         }
                       ],
                       "restartPolicy": "Never"
                     }
                   }
                 }
               }
             },
             "result": "job"
           }
         },
         {
           "wait_for_job": {
             "call": "gke.await_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "job_name": "${job_name}",
               "location": "${location}",
               "project": "${project}",
               "timeout": 90
             },
             "result": "completed_job"
           }
         },
         {
           "cleanup_job": {
             "call": "gke.delete_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "job_name": "${job_name}",
               "location": "${location}",
               "project": "${project}",
               "query": {
                 "propagationPolicy": "Foreground"
               }
             }
           }
         },
         {
           "return_job": {
             "return": "${completed_job}"
           }
         }
       ]
     }
   }
   

   Reemplaza lo siguiente:

   • LOCATION: el region para el clúster, como us-central1
   • CLUSTER_NAME: Es el nombre de tu GKE. clúster, como hello-cluster
   • JOB_NAME: Es el nombre del trabajo de Kubernetes, como hello-job.

8. Haz clic en Implementar.

gcloud

1. Crea un archivo de código fuente para tu flujo de trabajo:

   touch kubernetes-api-job.JSON_OR_YAML

   Reemplaza JSON_OR_YAML por yaml o json. según el formato de tu flujo de trabajo.

2. En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

   YAML

   main:
     steps:
       - init:
           assign:
             - project: "PROJECT_ID"
             - location: "LOCATION"
             - cluster_id: "CLUSTER_NAME"
             - job_name: "JOB_NAME"
             - namespace: "default"
       - create_job:
           call: gke.create_job
           args:
             cluster_id: '${cluster_id}'
             location: '${location}'
             project: '${project}'
             namespace: '${namespace}'
             job:
               apiVersion: batch/v1
               kind: Job
               metadata:
                 name: "${job_name}"
               spec:
                 template:
                   spec:
                     containers:
                       - name: counter
                         image: centos:7
                         command:
                           - "bin/bash"
                           - "-c"
                           - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                     restartPolicy: Never
           result: job
       - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
           call: gke.await_job
           args:
             cluster_id: '${cluster_id}'
             job_name: '${job_name}'
             location: '${location}'
             project: '${project}'
             timeout: 90  # 90 seconds
           result: completed_job
       - cleanup_job:
           call: gke.delete_job
           args:
             cluster_id: '${cluster_id}'
             job_name: '${job_name}'
             location: '${location}'
             project: '${project}'
             query:
               propagationPolicy: "Foreground"  # delete child Pods
       - return_job:
           return: '${completed_job}'

   JSON

   {
     "main": {
       "steps": [
         {
           "init": {
             "assign": [
               {
                 "project": "PROJECT_ID"
               },
               {
                 "location": "LOCATION"
               },
               {
                 "cluster_id": "CLUSTER_NAME"
               },
               {
                 "job_name": "JOB_NAME"
               },
               {
                 "namespace": "default"
               }
             ]
           }
         },
         {
           "create_job": {
             "call": "gke.create_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "location": "${location}",
               "project": "${project}",
               "namespace": "${namespace}",
               "job": {
                 "apiVersion": "batch/v1",
                 "kind": "Job",
                 "metadata": {
                   "name": "${job_name}"
                 },
                 "spec": {
                   "template": {
                     "spec": {
                       "containers": [
                         {
                           "name": "counter",
                           "image": "centos:7",
                           "command": [
                             "bin/bash",
                             "-c",
                             "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                           ]
                         }
                       ],
                       "restartPolicy": "Never"
                     }
                   }
                 }
               }
             },
             "result": "job"
           }
         },
         {
           "wait_for_job": {
             "call": "gke.await_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "job_name": "${job_name}",
               "location": "${location}",
               "project": "${project}",
               "timeout": 90
             },
             "result": "completed_job"
           }
         },
         {
           "cleanup_job": {
             "call": "gke.delete_job",
             "args": {
               "cluster_id": "${cluster_id}",
               "job_name": "${job_name}",
               "location": "${location}",
               "project": "${project}",
               "query": {
                 "propagationPolicy": "Foreground"
               }
             }
           }
         },
         {
           "return_job": {
             "return": "${completed_job}"
           }
         }
       ]
     }
   }
   

   Reemplaza lo siguiente:

   • LOCATION: Es la región de tu clúster, como us-central1.
   • CLUSTER_NAME: Es el nombre de tu GKE. clúster, como hello-cluster
   • JOB_NAME: Es el nombre del trabajo de Kubernetes, como como hello-job

3. Implementa el flujo de trabajo:

   gcloud workflows deploy kubernetes-api-job \
       --source=kubernetes-api-job.JSON_OR_YAML \
       --location=LOCATION \
       --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Ejecuta tu flujo de trabajo

Después de implementar correctamente tu flujo de trabajo, puedes ejecutarlo. Ejecuta la definición actual del flujo de trabajo asociada con el flujo de trabajo.

Console

1. En la consola de Google Cloud, ve a la página Flujos de trabajo.

   Ir a Workflows

2. En la página Flujos de trabajo, selecciona tu flujo de trabajo para ir a la página de detalles.

3. En la página Detalles del flujo de trabajo, haz clic en Ejecutar.

4. Haz clic de nuevo en Ejecutar.

   La ejecución del flujo de trabajo puede tardar unos minutos.

5. Observa los resultados del flujo de trabajo en el panel Output.

   Los resultados deberían ser similares a los siguientes:

   {
   ...
     },
     "status": {
       "completionTime": "2023-10-31T17:04:32Z",
       "conditions": [
         {
           "lastProbeTime": "2023-10-31T17:04:33Z",
           "lastTransitionTime": "2023-10-31T17:04:33Z",
           "status": "True",
           "type": "Complete"
         }
       ],
       "ready": 0,
       "startTime": "2023-10-31T17:04:28Z",
       "succeeded": 1,
       "uncountedTerminatedPods": {}
     }
   }
   

gcloud

Ejecuta el flujo de trabajo:

gcloud workflows run kubernetes-api-job \
    --location=LOCATION

La ejecución del flujo de trabajo puede tardar unos minutos. Los resultados deberían ser similares a los siguientes:

{
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

¿Qué sigue?

• Información sobre los conectores
• Invoca un servicio de Google Cloud con un conector