Acceder a objetos de la API de Kubernetes mediante 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 de Kubernetes en contenedores en un clúster de GKE. Los nodos son las máquinas de trabajador que ejecutan tus aplicaciones en contenedores y otras cargas de trabajo, y el plano de control es el endpoint unificado de tu clúster. Para obtener más información, consulta la arquitectura de clústeres 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 mediante 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 los artículos Objetos en Kubernetes y Descripción general de la API de la documentación de Kubernetes, que incluye enlaces a las páginas de 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 hacer solicitudes al endpoint 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, gestionar pods o acceder a aplicaciones implementadas a través de un proxy. Para obtener más información, consulta el artículo Descripción general de Kubernetes API Connector.

Nota: La API de Kubernetes es distinta de la API de Google Kubernetes Engine, que se usa para crear y gestionar 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 empezar

Antes de llevar a cabo las tareas que se describen en este documento, asegúrate de que has completado ciertos requisitos previos.

Habilitar APIs

Para poder acceder a los objetos de la API de Kubernetes mediante el conector de la API de Kubernetes, debes habilitar las siguientes APIs:

• API de Google Kubernetes Engine: para crear y gestionar aplicaciones basadas en contenedores con GKE

• APIs de Workflows: para gestionar definiciones y ejecuciones de flujos de trabajo. Si habilitas la API Workflows, se habilitará automáticamente la API Workflow Executions.

Consola

Habilita las APIs:

Habilitar 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 APIs:

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

Crear una cuenta de servicio

Crea una cuenta de servicio gestionada por el usuario que actúe como identidad de tu flujo de trabajo y concédele el rol 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 Gestión de Identidades y Accesos (IAM) afecta a los recursos a los que puede acceder tu cuenta de servicio en tu proyecto. Puedes revocar este rol o conceder otros más adelante. En entornos de producción, no concedas los roles Propietario, Editor o Lector. En su lugar, concede un rol predefinido o un rol personalizado que se ajuste a tus necesidades.

Consola

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

   Ir a Cuentas de servicio

2. Selecciona un proyecto y, a continuación, haz clic en Crear cuenta de servicio.

3. En el campo Nombre de cuenta de servicio, escribe un nombre. La consola rellena el campo ID de cuenta de servicio en función de este nombre. Google Cloud

   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 Selecciona un rol, busca y selecciona el rol Desarrollador de Kubernetes Engine.

6. Haz clic en Continuar.

7. Para terminar de crear la cuenta, haga clic en Hecho.

gcloud

1. Crea la cuenta de servicio:

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Sustituye SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio.

2. Asigna 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

   Sustituye PROJECT_ID por el ID de tu proyecto. 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:

• La gestión de identidades y accesos no es específica de Kubernetes, sino que proporciona gestión de identidades para varios productos Google Cloud y opera principalmente a nivel de proyecto Google Cloud .

• El control de acceso basado en roles de Kubernetes es un componente principal de Kubernetes que te permite crear y asignar roles (conjuntos de permisos) a cualquier objeto o tipo de objeto del clúster. Si usas principalmente GKE y necesitas permisos detallados para cada objeto y operación de tu clúster, RBAC de Kubernetes es la mejor opción.

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

Crear un clúster de GKE

Para usar el conector de la API de Kubernetes, 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 la sección 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 clúster Autopilot, que es un modo de funcionamiento de GKE en el que Google gestiona la configuración de tu clúster, incluidos los nodos, el escalado, la seguridad y otros ajustes preconfigurados. Para obtener más información, consulta Elegir un modo de funcionamiento de GKE.

Si aún no has creado un clúster de GKE, puedes desplegar una aplicación en un contenedor de servidor web en un clúster de GKE. También puedes crear un clúster de Autopilot siguiendo las instrucciones de este documento.

Consola

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

   Ir a clústeres de Kubernetes

2. Haz clic en Crear.

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

4. En la sección Información básica de los clústeres, haz lo siguiente:

   1. Introduce el nombre del clúster, como hello-cluster.
   2. Selecciona una región para tu clúster, como us-central1.

5. Haz clic en Siguiente: Redes.

6. En la sección Acceso a la red IPv4, para crear un clúster con un endpoint accesible públicamente, elige Clúster público.

7. En el resto de los ajustes, acepta los valores predeterminados.

8. Haz clic en Crear.

La creación del clúster puede tardar varios minutos. Una vez creado el clúster, aparecerá una marca de verificación para indicar que está en funcionamiento.

gcloud

Ejecuta el siguiente comando:

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

Haz los cambios siguientes:

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

La creación del clúster puede tardar varios minutos. Una vez creado el clúster, la salida debería ser similar a la siguiente:

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

Usar 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 necesario; 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 definen de forma predeterminada como 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 incluye enlaces a las páginas de referencia de la API de Kubernetes.
• Puedes detectar y gestionar errores de solicitudes HTTP en tu flujo de trabajo. Para obtener más información, consulta la sección Errores de flujo de trabajo.

Desplegar un flujo de trabajo

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

Consola

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

   Ve a Workflows

2. Haz clic en Crear.

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

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

5. Selecciona la cuenta de servicio que has creado anteriormente.

6. Haz clic en Siguiente.

7. En el editor del flujo de trabajo, introduce 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}"
           }
         }
       ]
     }
   }
   

   Haz los cambios siguientes:

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

8. Haz clic en Desplegar.

gcloud

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

   touch kubernetes-api-request.JSON_OR_YAML

   Sustituye JSON_OR_YAML por yaml o json en función del 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}"
           }
         }
       ]
     }
   }
   

   Haz los cambios siguientes:

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

3. Despliega 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

Ejecutar el flujo de trabajo

Una vez que hayas implementado correctamente el flujo de trabajo, podrás ejecutarlo. Al ejecutar un flujo de trabajo, se ejecuta la definición del flujo de trabajo actual asociada al flujo de trabajo.

Consola

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

   Ve a Workflows

2. En la página Workflows (Flujos de trabajo), selecciona el 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. Vuelve a hacer clic en Ejecutar.

5. Consulta los resultados del flujo de trabajo en el panel Información.

   Si la ejecución se realiza correctamente, el estado 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 la solicitud se hace correctamente, el estado debe ser SUCCEEDED y se devuelve el cuerpo de la respuesta.

Usar el conector para ejecutar un trabajo de Kubernetes

Puedes usar el conector de la API de Kubernetes para desplegar 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 a que se complete el trabajo de Kubernetes. De lo contrario, se produce un error. Si el trabajo se completa, se elimina.

Ten en cuenta que un trabajo se considera completado 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:

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

Desplegar un flujo de trabajo

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

Consola

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

   Ve a Workflows

2. Haz clic en Crear.

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

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

5. Selecciona la cuenta de servicio que has creado anteriormente.

6. Haz clic en Siguiente.

7. En el editor del flujo de trabajo, introduce 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}"
           }
         }
       ]
     }
   }
   

   Haz los cambios siguientes:

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

8. Haz clic en Desplegar.

gcloud

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

   touch kubernetes-api-job.JSON_OR_YAML

   Sustituye JSON_OR_YAML por yaml o json en función del 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}"
           }
         }
       ]
     }
   }
   

   Haz los cambios siguientes:

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

3. Despliega 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

Ejecutar el flujo de trabajo

Una vez que hayas implementado correctamente el flujo de trabajo, podrás ejecutarlo. Al ejecutar un flujo de trabajo, se ejecuta la definición del flujo de trabajo actual asociada al flujo de trabajo.

Consola

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

   Ve a Workflows

2. En la página Workflows (Flujos de trabajo), selecciona el 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. Vuelve a hacer clic 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 Información.

   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": {}
  }
}

Siguientes pasos

• Información sobre los conectores
• Invocar un Google Cloud servicio mediante un conector