Acessar objetos da API Kubernetes usando um conector

Visualização

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Um cluster do Google Kubernetes Engine (GKE) consiste em um plano de controle e um worker de máquinas virtuais chamadas nós. É possível executar cargas de trabalho do Kubernetes conteinerizadas em um cluster do GKE. Nós são as máquinas de worker que executam aplicativos conteinerizados e outras cargas de trabalho, e o plano de controle é a um endpoint unificado para o cluster. Para mais informações, consulte Arquitetura de cluster do GKE.

O servidor da API Kubernetes é executado no plano de controle, permitindo que você interaja com os objetos do Kubernetes no cluster por meio de chamadas da API Kubernetes. Objetos são entidades persistentes no sistema Kubernetes e representam o estado cluster. Para saber mais, na documentação do Kubernetes, consulte Objetos no Kubernetes e a Visão geral da API, que links para a "Referência da API Kubernetes" páginas de destino.

Este documento mostra como usar o conector da API Kubernetes em um fluxo de trabalho para fazer solicitações ao endpoint do serviço Kubernetes hospedado no plano de controle de um cluster do GKE. Por exemplo, é possível usar o conector para criar implantações do Kubernetes, executar jobs, gerenciar pods ou acessar apps implantados por meio de um proxy. Para mais informações, consulte a Visão geral do conector para a API Kubernetes.

Observação: a API Kubernetes é diferente da API Google Kubernetes Engine, que é usada para criar e gerenciar clusters do GKE. Para chamar a API GKE em um fluxo de trabalho, use o conector da API Kubernetes Engine.

Antes de começar

Antes de prosseguir com as tarefas neste documento, verifique se você tem ou cumpriu alguns pré-requisitos.

Ativar APIs

Antes de acessar os objetos da API Kubernetes usando o conector, ative as seguintes APIs:

• API Google Kubernetes Engine: crie e gerencie aplicativos baseados em contêiner usando o GKE.

• APIs Workflows: para gerenciar definições e execuções de fluxos de trabalho. Ativar a API Workflows ativa automaticamente a API Workflow Executions.

Console

Ative as APIs:

Ativar 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

Crie uma conta de serviço

Crie uma conta de serviço gerenciada pelo usuário que funcione como a identidade do seu fluxo de trabalho e conceda a ela o papel de desenvolvedor do Kubernetes Engine (roles/container.developer) para que o fluxo de trabalho possa acessar objetos da API do Kubernetes dentro de clusters.

Observação: o papel de gerenciamento de identidade e acesso (IAM) afeta quais recursos a conta de serviço pode acessar no projeto. É possível revogar esse papel ou conceder papéis mais tarde. Em ambientes de produção, não conceda os papéis de proprietário, editor ou visualizador. Em vez disso, conceda papel predefinido ou um papel personalizado que atenda às suas necessidades.

Console

1. No console do Google Cloud, acesse a página Contas de serviço.

   Acesse as Contas de serviço

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

3. No campo Nome da conta de serviço, insira um nome. O console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.

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

4. Clique em Criar e continuar.

5. Na lista Selecionar um papel, filtre e selecione as opções do Kubernetes Developer Engine.

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. Atribua o papel container.developer à conta de usuário:

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

   Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

É possível usar o controle de acesso baseado em função (RBAC) do IAM e do Kubernetes para controlar o acesso ao seu cluster do GKE:

• O IAM não é específico do Kubernetes. ele fornece identidade gerenciamento de vários produtos do Google Cloud e opera principalmente no nível do projeto do Google Cloud.

• O RBAC do Kubernetes é um componente principal do Kubernetes e permite criar e conceder papéis (conjuntos de permissões) para qualquer objeto ou tipo de objeto no cluster. Se você usa principalmente o GKE e precisa de permissões refinadas para cada objeto e operação no cluster, o RBAC do Kubernetes é a melhor escolha.

Para mais informações, consulte Controle de acesso.

Criar um cluster do GKE

Para usar o conector da API Kubernetes, é preciso ter criado um cluster particular do GKE. Em um cluster particular, os nós têm apenas endereços IP internos, o que significa que os nós e os pods estão isolados da Internet por padrão. Para mais informações, consulte Clusters particulares.

Você também pode especificar o modo de operação, que oferece diferentes níveis de flexibilidade, responsabilidade e controle. Por exemplo, é possível criar cluster do Autopilot, que é um modo de operação no GKE em como o Google gerencia a configuração do cluster, incluindo nós, escalonamento, segurança e outras configurações predefinidas. Para mais informações, consulte Escolher um modo de operação do GKE.

Se você ainda não criou um cluster do GKE, é possível implantar um aplicativo conteinerizado de servidor da Web em um cluster do GKE. Ou, para testar as instruções neste documento, crie um cluster do Autopilot seguindo as instruções abaixo.

Console

1. No Console do Google Cloud, acesse a página de clusters do Kubernetes.

   Acessar os clusters do Kubernetes

2. Clique em Criar.

3. Se for solicitado que você escolha um modo de cluster, selecione Autopilot.

4. Na seção Princípios básicos do cluster, conclua o seguinte:

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

5. Clique em Próxima: Rede.

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

7. Para todas as outras configurações, aceite os padrões.

8. Clique em Criar.

A criação do cluster pode levar vários minutos para ser concluída. Depois que o cluster é criado, uma marca de seleção indica que ele está em execução.

gcloud

Execute este comando:

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

Substitua:

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

A criação do cluster pode levar vários minutos para ser concluída. Depois que o cluster é criado, a saída fica mais ou menos assim:

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

Usar o conector para enviar uma solicitação HTTP

Você pode usar o conector da API Kubernetes para enviar uma solicitação HTTP ao plano de controle de um cluster do GKE. Por exemplo, o fluxo de trabalho a seguir cria uma implantação chamada nginx-deployment no objeto especificado cluster. A implantação descreve um estado obrigatório. nesse caso, executar três Pods com a imagem nginx:1.14.2 e expor o serviço na porta 80. (Caso contrário, especificado, project e location são padronizados para o fluxo de trabalho.

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

Observe o seguinte:

• O campo path corresponde ao caminho do método da API Kubernetes. Para mais mais informações, na documentação do Kubernetes, consulte a Visão geral da API, que contém a "Referência da API Kubernetes" páginas de destino.
• É possível detectar e processar erros de solicitação HTTP no seu fluxo de trabalho. Para mais informações, consulte Erros de fluxo de trabalho.

Implantar seu fluxo de trabalho

Antes de executar um fluxo de trabalho, você precisa criá-lo e implantá-lo.

Console

1. No console do Google Cloud, abra a página Workflows.

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira 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 você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição para 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:

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

8. Clique em Implantar.

gcloud

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

   touch kubernetes-api-request.JSON_OR_YAML

   Substitua JSON_OR_YAML por yaml ou json. dependendo do formato do seu fluxo de trabalho.

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo 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:

   • CLUSTER_NAME: o nome do GKE cluster, como hello-cluster
   • LOCATION: o region para seu cluster, como us-central1

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

Executar seu fluxo de trabalho

Depois de implantar o fluxo de trabalho, você pode executá-lo. Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

1. No console do Google Cloud, abra a página Workflows.

   Acessar fluxos de trabalho

2. Na página Fluxos de trabalho, selecione o fluxo de trabalho para acessar a página de detalhes dele.

3. Na página Detalhes do fluxo de trabalho, clique em Execução.

4. Clique em Executar novamente.

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

   Se for bem-sucedido, o estado de execução deverá ser Succeeded e o corpo do a resposta será retornada.

gcloud

Execute o fluxo de trabalho:

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

Se for bem-sucedido, o estado precisará ser SUCCEEDED e o corpo da resposta é retornado.

Usar o conector para executar um job do Kubernetes

Você pode usar o conector da API Kubernetes para implantar e executar um job do Kubernetes em um do cluster do GKE. O fluxo de trabalho a seguir cria um job do Kubernetes que executa um script Bash que faz iterações em uma sequência de números. O fluxo de trabalho aguarda até 90 segundos para que o job do Kubernetes seja concluído; caso contrário, um é gerado. Se o job for concluído, ele será excluído.

Um job será considerado concluído se o status dele incluir uma condição tipo de Complete. Exemplo:

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

Se o job falhar, uma tag FailedJobError será retornada. Exemplo:

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

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

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

Implantar seu fluxo de trabalho

Antes de executar um fluxo de trabalho, você precisa criá-lo e implantá-lo.

Console

1. No console do Google Cloud, abra a página Workflows.

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira 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 você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição para 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:

   • LOCATION: o region para seu cluster, como us-central1
   • CLUSTER_NAME: o nome do GKE cluster, como hello-cluster
   • JOB_NAME: o nome do job do Kubernetes, como hello-job

8. Clique em Implantar.

gcloud

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

   touch kubernetes-api-job.JSON_OR_YAML

   Substitua JSON_OR_YAML por yaml ou json. dependendo do formato do seu fluxo de trabalho.

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo 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:

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

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

Executar seu fluxo de trabalho

Depois de implantar o fluxo de trabalho, você pode executá-lo. Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

1. No console do Google Cloud, abra a página Workflows.

   Acessar fluxos de trabalho

2. Na página Fluxos de trabalho, selecione seu fluxo de trabalho para acessar a página de detalhes.

3. Na página Detalhes do fluxo de trabalho, clique em Execução.

4. Clique em Executar novamente.

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

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

   Os resultados serão semelhantes a estes:

   {
   ...
     },
     "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 levar alguns minutos. Os resultados serão semelhantes a este:

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

A seguir

• Conceitos básicos sobre os conectores
• Invocar um serviço do Google Cloud usando um conector