Accede a los 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 de 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 el Resumen de la API en la documentación de Kubernetes, que vincula 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 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 del conector de la API de Kubernetes.

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

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 Google Cloudcompleta 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 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 principalmente 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 principalmente y necesitas permisos detallados 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 de servidor web en un clúster de GKE. También puedes crear un clúster de Autopilot si completas los siguientes pasos para probar las instrucciones de este documento.

Console

  1. En la consola de Google Cloud , ve a la página de 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 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 se está ejecutando.

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 de tu clúster de GKE, como hello-cluster.
  • LOCATION: Es la región de tu clúster, como us-central1.
  • PROJECT_ID: El ID de tu 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 Deployment llamado nginx-deployment en el clúster de Kubernetes especificado. El Deployment describe un estado requerido; 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:

Implementa tu flujo de trabajo

Antes de ejecutar un flujo de trabajo, debes crearlo y, luego, implementarlo.

Console

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

    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 el 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 de tu 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 clúster de GKE, 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 Recomendaciones.

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

    Si se ejecuta correctamente, 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 una secuencia de comandos de Bash que 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 objeto Job se completa, se borra.

Ten en cuenta que un trabajo se considera completo si su estado incluye un tipo de condición 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:

Implementa tu flujo de trabajo

Antes de ejecutar un flujo de trabajo, debes crearlo y, luego, implementarlo.

Console

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

    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 el 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 de tu 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 de tu 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 Recomendaciones.

    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 un par de 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?