Aceda a objetos da API Kubernetes através de um conetor

Um cluster do Google Kubernetes Engine (GKE) consiste num plano de controlo e em máquinas de trabalho denominadas nós. Pode executar as suas cargas de trabalho do Kubernetes contentorizadas num cluster do GKE. Os nós são as máquinas de trabalho que executam as suas aplicações em contentores e outras cargas de trabalho, e o plano de controlo é o ponto final unificado do seu cluster. Para mais informações, consulte o artigo Arquitetura do cluster do GKE.

O servidor da API Kubernetes é executado no plano de controlo, o que lhe permite interagir com objetos do Kubernetes no cluster através de chamadas da API Kubernetes. Os objetos são entidades persistentes no sistema Kubernetes e representam o estado do seu cluster. Para mais informações, na documentação do Kubernetes, consulte Objetos no Kubernetes, e a vista geral da API, que inclui links para as páginas de "Referência da API Kubernetes".

Este documento mostra-lhe como usar o conector da API Kubernetes num fluxo de trabalho para fazer pedidos ao ponto final do serviço Kubernetes alojado no plano de controlo de um cluster do GKE. Por exemplo, pode usar o conetor para criar implementações do Kubernetes, executar tarefas, gerir pods ou aceder a apps implementadas através de um proxy. Para mais informações, consulte a vista geral do conetor da API Kubernetes.

Nota: a API Kubernetes é distinta da API Google Kubernetes Engine, que é usada para criar e gerir clusters do GKE. Para chamar a API GKE num fluxo de trabalho, use o conetor da API Kubernetes Engine.

Antes de começar

Antes de avançar com as tarefas neste documento, certifique-se de que concluiu determinados pré-requisitos.

Ativar APIs

Antes de poder aceder a objetos da API Kubernetes através do conetor da API Kubernetes, tem de ativar as seguintes APIs:

• API Google Kubernetes Engine: para criar e gerir aplicações baseadas em contentores com o GKE

• APIs Workflows: para gerir definições e execuções de fluxos de trabalho. A ativação da API Workflows ativa automaticamente a API Workflow Executions

Consola

Ative as APIs:

Ative as 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. Ative as APIs:

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

Criar uma conta de serviço

Crie uma conta de serviço gerida pelo utilizador que atua como a identidade do seu fluxo de trabalho e conceda-lhe a função Kubernetes Engine Developer (roles/container.developer) para que o fluxo de trabalho possa aceder aos objetos da API Kubernetes nos clusters.

Nota: a função de gestão de identidade e de acesso (IAM) afeta os recursos aos quais a sua conta de serviço pode aceder no seu projeto. Pode revogar esta função ou conceder funções adicionais mais tarde. Em ambientes de produção, não conceda as funções Proprietário, Editor nem Leitor. Em alternativa, conceda uma função predefinida ou uma função personalizada que satisfaça as suas necessidades.

Consola

1. Na Google Cloud consola, aceda à página Contas de serviço.

   Aceda a Contas de serviço

2. Selecione um projeto e, de seguida, clique em Criar conta de serviço.

3. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.

   No campo Descrição da conta de serviço, introduza uma descrição. Por exemplo, Service account for Kubernetes API.

4. Clique em Criar e continuar.

5. Na lista Selecionar uma função, filtre e selecione a função Kubernetes Engine Developer.

6. Clique em Continuar.

7. Para concluir a criação da conta, clique em Concluído.

gcloud

1. Crie a conta de serviço:

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Substitua SERVICE_ACCOUNT_NAME pelo nome da conta de serviço.

2. Conceda a função container.developer à sua conta de serviço:

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

   Substitua PROJECT_ID pelo seu Google Cloud ID do projeto.

Tenha em atenção que pode usar o IAM e o controlo de acesso baseado em funções (CABF) do Kubernetes para controlar o acesso ao seu cluster do GKE:

• O IAM não é específico do Kubernetes. Fornece gestão de identidades para vários Google Cloud produtos e funciona principalmente ao nível do Google Cloud projeto.

• O RBAC do Kubernetes é um componente essencial do Kubernetes e permite-lhe criar e conceder funções (conjuntos de autorizações) para qualquer objeto ou tipo de objeto no cluster. Se usar principalmente o GKE e precisar de autorizações detalhadas para cada objeto e operação no seu cluster, o RBAC do Kubernetes é a melhor escolha.

Para mais informações, consulte o artigo Controlo de acesso.

Crie um cluster do GKE

Para usar o conector da API Kubernetes, já tem de ter criado um cluster do GKE público ou privado. Num cluster privado, os nós só têm endereços IP internos, o que significa que os nós e os pods estão isolados da Internet por predefinição. Para mais informações, consulte o artigo Clusters privados.

Também pode especificar o modo de funcionamento que lhe oferece diferentes níveis de flexibilidade, responsabilidade e controlo. Por exemplo, pode criar um cluster do Autopilot, que é um modo de funcionamento no GKE em que a Google gere a configuração do cluster, incluindo os nós, o escalonamento, a segurança e outras definições pré-configuradas. Para mais informações, consulte o artigo Escolha um modo de funcionamento do GKE.

Se ainda não criou um cluster do GKE, pode implementar uma aplicação contentorizada de servidor Web num cluster do GKE. Em alternativa, para experimentar as instruções neste documento, pode criar um cluster do Autopilot concluindo os seguintes passos.

Consola

1. Na Google Cloud consola, aceda à página Clusters do Kubernetes.

   Aceda aos clusters do Kubernetes

2. Clique em Criar.

3. Se lhe for pedido que selecione um modo de cluster, selecione Autopilot.

4. Na secção Noções básicas do cluster, conclua o seguinte:

   1. Introduza o Nome do cluster, como hello-cluster.
   2. Selecione uma região para o seu cluster, como us-central1.

5. Clique em Seguinte: rede.

6. Na secção Acesso à rede IPv4, para criar um cluster com um ponto final acessível publicamente, escolha Cluster público.

7. Para todas as outras definições, aceite as predefinições.

8. Clique em Criar.

A criação do cluster pode demorar vários minutos a ser concluída. Depois de criar o cluster, é apresentada uma marca de verificação a indicar que está em execução.

gcloud

Execute o seguinte comando:

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

Substitua o seguinte:

• CLUSTER_NAME: o nome do seu cluster do GKE, como hello-cluster
• LOCATION: a região do seu cluster, como us-central1
• PROJECT_ID: o ID do seu Google Cloud projeto

A criação do cluster pode demorar vários minutos a ser concluída. Depois de criar o cluster, o resultado deve ser semelhante ao seguinte:

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

Use o conetor para enviar um pedido HTTP

Pode usar o conector da API Kubernetes para enviar um pedido HTTP para o plano de controlo de um cluster do GKE. Por exemplo, o fluxo de trabalho seguinte cria uma implementação denominada nginx-deployment no cluster do Kubernetes especificado. A implementação descreve um estado necessário; neste caso, para executar três pods com a imagem nginx:1.14.2 e expor o respetivo serviço na porta 80. (Se não for especificado, os valores project e location são os do fluxo de trabalho por predefinição.)

Para mais informações, consulte a página de referência da função do conector da API Kubernetes, gke.request.

Tenha em conta o seguinte:

• O campo path corresponde ao caminho do método da API Kubernetes. Para mais informações, na documentação do Kubernetes, consulte a vista geral da API, que inclui links para as páginas de "referência da API Kubernetes".
• Pode capturar e processar erros de pedidos HTTP no seu fluxo de trabalho. Para mais informações, consulte o artigo Erros de fluxo de trabalho.

Implemente o seu fluxo de trabalho

Antes de executar um fluxo de trabalho, tem de o criar e implementar.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Clique em Criar.

3. Introduza um nome para o novo fluxo de trabalho, como kubernetes-api-request.

4. Na lista Região, selecione us-central1.

5. Selecione a conta de serviço que criou anteriormente.

6. Clicar em Seguinte.

7. No editor de fluxos de trabalho, introduza a seguinte definição para o seu fluxo de trabalho:

   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}"
           }
         }
       ]
     }
   }
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do seu cluster do GKE, como hello-cluster
   • PROJECT_ID: o ID do seu Google Cloud projeto
   • LOCATION: a região do seu cluster, como us-central1

8. Clique em Implementar.

gcloud

1. Crie um ficheiro de código-fonte para o seu fluxo de trabalho:

   touch kubernetes-api-request.JSON_OR_YAML

   Substitua JSON_OR_YAML por yaml ou json, consoante o formato do seu fluxo de trabalho.

2. Num editor de texto, copie o seguinte fluxo de trabalho para o ficheiro de código-fonte:

   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}"
           }
         }
       ]
     }
   }
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do seu cluster do GKE, como hello-cluster
   • LOCATION: a região do seu cluster, como us-central1

3. Implemente o fluxo de trabalho:

   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

Execute o seu fluxo de trabalho

Depois de implementar o fluxo de trabalho com êxito, pode executá-lo. A execução de um fluxo de trabalho executa a definição do fluxo de trabalho atual associada ao fluxo de trabalho.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Na página Fluxos de trabalho, selecione o fluxo de trabalho para aceder à respetiva página de detalhes.

3. Na página Detalhes do fluxo de trabalho, clique em Executar.

4. Clique novamente em Executar.

5. Veja os resultados do fluxo de trabalho no painel Saída.

   Se for bem-sucedido, o estado de execução deve ser Succeeded e o corpo da resposta é devolvido.

gcloud

Execute o fluxo de trabalho:

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

Se for bem-sucedido, o estado deve ser SUCCEEDED e o corpo da resposta é devolvido.

Use o conetor para executar uma tarefa do Kubernetes

Pode usar o conector da API Kubernetes para implementar e executar uma tarefa Kubernetes num cluster do GKE. O fluxo de trabalho seguinte cria um trabalho do Kubernetes que executa um script Bash que itera através de uma sequência de números. O fluxo de trabalho aguarda até 90 segundos pela conclusão da tarefa do Kubernetes; caso contrário, é gerado um erro. Se a tarefa for concluída, é eliminada.

Tenha em atenção que um trabalho é considerado concluído se o respetivo estado incluir um tipo de condição Complete. Por exemplo:

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

Se a tarefa falhar, é devolvida uma etiqueta FailedJobError. Por exemplo:

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

Para mais informações, consulte as páginas de referência das seguintes funções do conetor da API Kubernetes:

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

Implemente o seu fluxo de trabalho

Antes de executar um fluxo de trabalho, tem de o criar e implementar.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Clique em Criar.

3. Introduza um nome para o novo fluxo de trabalho, como kubernetes-api-job.

4. Na lista Região, selecione us-central1.

5. Selecione a conta de serviço que criou anteriormente.

6. Clicar em Seguinte.

7. No editor de fluxos de trabalho, introduza a seguinte definição para o seu fluxo de trabalho:

   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}"
           }
         }
       ]
     }
   }
   

   Substitua o seguinte:

   • LOCATION: a região do seu cluster, como us-central1
   • CLUSTER_NAME: o nome do seu cluster do GKE, como hello-cluster
   • JOB_NAME: o nome da tarefa do Kubernetes, como hello-job

8. Clique em Implementar.

gcloud

1. Crie um ficheiro de código-fonte para o seu fluxo de trabalho:

   touch kubernetes-api-job.JSON_OR_YAML

   Substitua JSON_OR_YAML por yaml ou json, consoante o formato do seu fluxo de trabalho.

2. Num editor de texto, copie o seguinte fluxo de trabalho para o ficheiro de código-fonte:

   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}"
           }
         }
       ]
     }
   }
   

   Substitua o seguinte:

   • LOCATION: a região do seu cluster, como us-central1
   • CLUSTER_NAME: o nome do seu cluster do GKE, como hello-cluster
   • JOB_NAME: o nome da tarefa do Kubernetes, como hello-job

3. Implemente o fluxo de trabalho:

   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

Execute o seu fluxo de trabalho

Depois de implementar o fluxo de trabalho com êxito, pode executá-lo. A execução de um fluxo de trabalho executa a definição do fluxo de trabalho atual associada ao fluxo de trabalho.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Na página Fluxos de trabalho, selecione o fluxo de trabalho para aceder à respetiva página de detalhes.

3. Na página Detalhes do fluxo de trabalho, clique em Executar.

4. Clique novamente em Executar.

   A execução do fluxo de trabalho pode demorar alguns minutos.

5. Veja os resultados do fluxo de trabalho no painel Saída.

   Os resultados devem ser semelhantes aos seguintes:

   {
   ...
     },
     "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

Execute o fluxo de trabalho:

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

A execução do fluxo de trabalho pode demorar alguns minutos. Os resultados devem ser semelhantes aos seguintes:

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

O que se segue?

• Compreenda os conetores
• Invocar um serviço Google Cloud através de um conector