Accede a objetos de la API de Kubernetes con un conector

Un clúster de Google Kubernetes Engine (GKE) consta de un plano de control y máquinas de trabajador llamadas nodos. Puedes ejecutar tus cargas de trabajo en contenedores de Kubernetes 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 el 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 la Descripción general de la API, que vincula a las páginas de la "Referencia de la API de Kubernetes", en la documentación 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 implementaciones de Kubernetes, ejecutar trabajos, administrar Pods o acceder a apps implementadas a través de un proxy. Para obtener más información, consulta la Descripción general de Kubernetes API Connector.

Nota: La API de Kubernetes es distinta de la API de Kubernetes Engine, que se usa para crear y administrar clústeres de GKE. Para llamar a la 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 acceder a los objetos de la API de Kubernetes con el conector de la API de Kubernetes, debes habilitar las siguientes APIs:

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

• APIs de Workflows: Para administrar las definiciones y ejecuciones de flujos de trabajo. Habilitar la API de Workflows habilita automáticamente la API de Workflow Executions.

Console

Habilita las API:

Habilita las APIs

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

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 otórgale 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 Identity and Access Management (IAM) afecta a qué recursos puede acceder tu cuenta de servicio en el proyecto. Puedes revocar este rol o asignar otros más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o un 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, luego, 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 el rol Desarrollador de Kubernetes Engine.

6. Haz clic en Continuar.

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

gcloud

1. Crea 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 tanto IAM como 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, sino que proporciona administración de identidades para varios productos de Google Cloud y opera principalmente a nivel del proyecto 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 específicos para cada objeto y operación dentro de tu clúster, el RBAC de Kubernetes es la mejor opción.

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

Crea un clúster de GKE

Para usar el conector de la API de Kubernetes, ya debes haber creado un clúster de GKE público o 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 de Internet de forma predeterminada. Para obtener más información, consulta Clústeres privados.

También puedes especificar el modo de operación, que te ofrece diferentes niveles de flexibilidad, responsabilidad y control. Por ejemplo, puedes crear un clúster de Autopilot, que es un modo de operación en GKE en el que Google administra la configuración de tu clúster, incluidos los nodos, el escalamiento, la seguridad y otros parámetros de configuración ya establecidos. 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 en contenedores del servidor web en un clúster de GKE. O bien, para probar las instrucciones de este documento, puedes crear un clúster de Autopilot completando los siguientes pasos.

Console

1. En la consola de Google Cloud , accede 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, selecciona 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 a la 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 que se crea el clúster, una marca de verificación indica que está en ejecución.

gcloud

Ejecuta el siguiente comando:

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

Reemplaza lo siguiente:

• CLUSTER_NAME: Es el nombre del clúster de GKE, como hello-cluster.
• LOCATION: Es la región de tu clúster, como us-central1.
• PROJECT_ID: 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 una Deployment llamada nginx-deployment en el clúster de Kubernetes especificado. El Deployment 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, los valores predeterminados de project y location son los del flujo de trabajo).

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

Ten en cuenta lo siguiente:

• El campo path corresponde a la ruta del método de la API de Kubernetes. Para obtener más información, consulta la Descripción general de la API en la documentación de Kubernetes, que vincula a las páginas de "Referencia de la API de Kubernetes".
• Puedes detectar y controlar errores de 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 Workflows.

   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 anteriormente.

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 del clúster de GKE, como hello-cluster.
   • PROJECT_ID: 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 del clúster de GKE, como hello-cluster.
   • LOCATION: Es la región para 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 Flujos de trabajo, 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. Consulta los resultados del flujo de trabajo en el panel Resultado.

   Si se ejecuta de forma correcta, el estado de ejecución debe ser Succeeded y se devuelve 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 se devuelve el cuerpo de la respuesta.

Usa el conector para ejecutar un trabajo de Kubernetes

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

Ten en cuenta que un objeto Job se considera completo si su estado incluye un tipo de condición de Complete. Por ejemplo:

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

Si el trabajo falla, se devuelve 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 anteriormente.

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: Es la región de tu clúster, como us-central1.
   • CLUSTER_NAME: Es el nombre del clúster de GKE, 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 del clúster de GKE, como hello-cluster.
   • JOB_NAME: Es el nombre del trabajo de Kubernetes, 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 Workflows.

   Ir a Workflows

2. En la página Flujos de trabajo, 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.

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

5. Consulta 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 un par de 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