Accedere agli oggetti dell'API Kubernetes utilizzando un connettore

Preview

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

Un cluster Google Kubernetes Engine (GKE) è costituito da un piano di controllo e da macchine worker denominate nodi. Puoi eseguire i workload Kubernetes containerizzati in un cluster GKE. I nodi sono le macchine worker che eseguono le tue applicazioni containerizzate e altri carichi di lavoro, mentre il piano di controllo è l'endpoint unificato per il cluster. Per maggiori informazioni, consulta Architettura del cluster GKE.

Il server API Kubernetes viene eseguito nel piano di controllo e ti consente di interagire con gli oggetti Kubernetes nel cluster tramite le chiamate API Kubernetes. Gli oggetti sono entità permanenti nel sistema Kubernetes e rappresentano lo stato del cluster. Per ulteriori informazioni, nella documentazione di Kubernetes consulta Objects in Kubernetes e la Panoramica dell'API che contiene i link alle pagine "Riferimenti dell'API Kubernetes".

Questo documento mostra come utilizzare il connettore API Kubernetes in un flusso di lavoro per effettuare richieste all'endpoint del servizio Kubernetes ospitato nel piano di controllo di un cluster GKE. Ad esempio, puoi utilizzare il connettore per creare deployment Kubernetes, eseguire job, gestire pod o accedere alle app di cui è stato eseguito il deployment tramite un proxy. Per ulteriori informazioni, consulta la Panoramica del connettore API Kubernetes

Nota: l'API Kubernetes è diversa dall'API Google Kubernetes Engine, che viene utilizzata per creare e gestire i cluster GKE. Per chiamare l'API GKE in un flusso di lavoro, utilizza il connettore API Kubernetes Engine.

Prima di iniziare

Prima di procedere con le attività descritte in questo documento, assicurati di aver completato alcuni prerequisiti.

Abilita API

Prima di poter accedere agli oggetti dell'API Kubernetes utilizzando il connettore dell'API Kubernetes, devi abilitare le seguenti API:

• API Google Kubernetes Engine: per creare e gestire applicazioni basate su container utilizzando GKE

• API Workflows: per gestire le definizioni e le esecuzioni dei flussi di lavoro. L'attivazione dell'API Workflows attiva automaticamente l'API Workflow Executions

Console

Abilita le API:

Abilita le API

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. Abilita le API:

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

Crea un account di servizio

Crea un account di servizio gestito dall'utente che funga da identità del tuo flusso di lavoro e concedigli il ruolo Sviluppatore Kubernetes Engine (roles/container.developer) in modo che il flusso di lavoro possa accedere agli oggetti dell'API Kubernetes all'interno dei cluster.

Nota: il ruolo IAM (Identity and Access Management) influisce sulle risorse a cui può accedere il tuo account di servizio nel progetto. Puoi revocare questo ruolo o concedere altri ruoli in un secondo momento. Negli ambienti di produzione, non concedere i ruoli Proprietario, Editor o visualizzatore. Assegna invece un ruolo predefinito o un ruolo personalizzato che soddisfi le tue esigenze.

Console

1. Nella console Google Cloud, vai alla pagina Account di servizio.

   Vai ad Account di servizio

2. Seleziona un progetto, poi fai clic su Crea account di servizio.

3. Inserisci un nome nel campo Nome account di servizio. La Google Cloud console compila il campo ID account di servizio in base a questo nome.

   Nel campo Descrizione account di servizio, inserisci una descrizione. Ad esempio, Service account for Kubernetes API.

4. Fai clic su Crea e continua.

5. Nell'elenco Seleziona un ruolo, filtra per il ruolo Sviluppatore Kubernetes Engine e selezionalo.

6. Fai clic su Continua.

7. Per completare la creazione dell'account, fai clic su Fine.

gcloud

1. Crea l'account di servizio:

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Sostituisci SERVICE_ACCOUNT_NAME con il nome dell'account di servizio.

2. Concedi il ruolo container.developer al tuo account di servizio:

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

   Sostituisci PROJECT_ID con il tuo Google Cloud ID progetto.

Tieni presente che puoi utilizzare sia il controllo degli accessi basato sui ruoli (RBAC) di IAM che di Kubernetes per controllare l'accesso al tuo cluster GKE:

• IAM non è specifico di Kubernetes; fornisce la gestione delle identità per più Google Cloud prodotti e opera principalmente a livello di Google Cloud progetto.

• Kubernetes RBAC è un componente fondamentale di Kubernetes e ti consente di creare e assegnare ruoli (insiemi di autorizzazioni) per qualsiasi oggetto o tipo di oggetto all'interno del cluster. Se utilizzi principalmente GKE e hai bisogno di autorizzazioni granulari per ogni oggetto e operazione all'interno del tuo cluster, Kubernetes RBAC è la scelta migliore.

Per ulteriori informazioni, consulta Controllo dell'accesso.

Crea un cluster GKE

Per utilizzare il connettore API Kubernetes, devi aver già creato un cluster GKE pubblico o privato. In un cluster privato, i nodi hanno solo indirizzi IP interni, il che significa che i nodi e i pod sono isolati da internet per impostazione predefinita. Per ulteriori informazioni, consulta Cluster privati.

Puoi anche specificare la modalità di funzionamento, che offre diversi livelli di flessibilità, responsabilità e controllo. Ad esempio, puoi creare un cluster Autopilot, che è una modalità operativa in GKE in cui Google gestisce la configurazione del cluster, inclusi nodi, scalabilità, sicurezza e altre impostazioni preconfigurate. Per ulteriori informazioni, consulta Scegliere una modalità di funzionamento di GKE.

Se non hai ancora creato un cluster GKE, puoi eseguire il deployment di un'applicazione containerizzata del server web in un cluster GKE. In alternativa, per provare le istruzioni riportate in questo documento, puoi creare un cluster Autopilot completando quanto segue.

Console

1. Nella console Google Cloud, vai alla pagina Cluster Kubernetes.

   Vai ai cluster Kubernetes

2. Fai clic su Crea.

3. Se ti viene chiesto di selezionare una modalità di cluster, seleziona Autopilot.

4. Nella sezione Nozioni di base sul cluster, completa quanto segue:

   1. Inserisci il nome del cluster, ad esempio hello-cluster.
   2. Seleziona una regione per il cluster, ad esempio us-central1.

5. Fai clic su Successivo: Networking.

6. Nella sezione Accesso alla rete IPv4, per creare un cluster con un endpoint accessibile pubblicamente, scegli Cluster pubblico.

7. Per tutte le altre impostazioni, accetta i valori predefiniti.

8. Fai clic su Crea.

La creazione del cluster potrebbe richiedere diversi minuti. Una volta creato il cluster, un segno di spunta indica che è in esecuzione.

gcloud

Esegui questo comando:

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

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del tuo cluster GKE, ad esempio hello-cluster
• LOCATION: la regione del cluster, ad esempio us-central1
• PROJECT_ID: il tuo Google Cloud ID progetto

La creazione del cluster potrebbe richiedere diversi minuti. Una volta creato il cluster, l'output dovrebbe essere simile al seguente:

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

Utilizzare il connettore per inviare una richiesta HTTP

Puoi utilizzare il connettore API Kubernetes per inviare una richiesta HTTP al piano di controllo di un cluster GKE. Ad esempio, il seguente flusso di lavoro crea un deployment denominato nginx-deployment nel cluster Kubernetes specificato. Il deployment descrive uno stato richiesto; in questo caso, eseguire tre pod con l'immagine nginx:1.14.2 ed esporre il servizio sulla porta 80. Se non specificato, i valori project e location predefiniti sono quelli del flusso di lavoro.

Per ulteriori informazioni, consulta la pagina di riferimento della funzione del connettore dell'API Kubernetes gke.request.

Tieni presente quanto segue:

• Il campo path corrisponde al percorso del metodo dell'API Kubernetes. Per ulteriori informazioni, consulta la Panoramica dell'API nella documentazione di Kubernetes, che rimanda alle pagine "Riferimento all'API Kubernetes".
• Puoi rilevare e gestire gli errori delle richieste HTTP nel tuo flusso di lavoro. Per ulteriori informazioni, consulta Errori di flusso di lavoro.

Esegui il deployment del flusso di lavoro

Prima di eseguire un flusso di lavoro, devi crearlo ed eseguirlo.

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Fai clic su Crea.

3. Inserisci un nome per il nuovo flusso di lavoro, ad esempio kubernetes-api-request.

4. Nell'elenco Regione, seleziona us-central1.

5. Seleziona l'account di servizio che hai creato in precedenza.

6. Fai clic su Avanti.

7. Nell'editor del flusso di lavoro, inserisci la seguente definizione per il flusso di lavoro:

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

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del tuo cluster GKE, ad esempio hello-cluster
   • PROJECT_ID: il tuo Google Cloud ID progetto
   • LOCATION: la regione del cluster, ad esempio us-central1

8. Fai clic su Esegui il deployment.

gcloud

1. Crea un file di codice sorgente per il tuo flusso di lavoro:

   touch kubernetes-api-request.JSON_OR_YAML

   Sostituisci JSON_OR_YAML con yaml o json a seconda del formato del flusso di lavoro.

2. In un editor di testo, copia il seguente flusso di lavoro nel file di codice sorgente:

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

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del tuo cluster GKE, ad esempio hello-cluster
   • LOCATION: la regione del cluster, ad esempio us-central1

3. Esegui il deployment del flusso di lavoro:

   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

Esegui il flusso di lavoro

Dopo aver eseguito il deployment del flusso di lavoro, puoi eseguirlo. L'esecuzione di un flusso di lavoro esegue la definizione attuale del flusso di lavoro associata al flusso di lavoro.

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Nella pagina Flussi di lavoro, seleziona il flusso di lavoro per accedere alla relativa pagina dei dettagli.

3. Nella pagina Dettagli flusso di lavoro, fai clic su Esegui.

4. Fai di nuovo clic su Esegui.

5. Visualizza i risultati del flusso di lavoro nel riquadro Output.

   In caso di esito positivo, lo stato di esecuzione dovrebbe essere Succeeded e viene restituito il corpo della risposta.

gcloud

Esegui il flusso di lavoro:

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

In caso di esito positivo, lo stato deve essere SUCCEEDED e viene restituito il corpo della risposta.

Utilizzare il connettore per eseguire un job Kubernetes

Puoi utilizzare il connettore API Kubernetes per eseguire il deployment ed eseguire un job Kubernetes in un cluster GKE. Il seguente flusso di lavoro crea un job Kubernetes che esegue uno script Bash che esegue l'iterazione di una sequenza di numeri. Il flusso di lavoro aspetta fino a 90 secondi per il completamento del job Kubernetes. In caso contrario, viene generato un errore. Se il job viene completato, viene eliminato.

Tieni presente che un job è considerato completato se il relativo stato include un tipo di condizione Complete. Ad esempio:

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

Se il job non va a buon fine, viene restituito un tag FailedJobError. Ad esempio:

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

Per ulteriori informazioni, consulta le pagine di riferimento per le seguenti funzioni del connettore API Kubernetes:

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

Esegui il deployment del flusso di lavoro

Prima di eseguire un flusso di lavoro, devi crearlo ed eseguirlo.

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Fai clic su Crea.

3. Inserisci un nome per il nuovo flusso di lavoro, ad esempio kubernetes-api-job.

4. Nell'elenco Regione, seleziona us-central1.

5. Seleziona l'account di servizio che hai creato in precedenza.

6. Fai clic su Avanti.

7. Nell'editor del flusso di lavoro, inserisci la seguente definizione per il flusso di lavoro:

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

   Sostituisci quanto segue:

   • LOCATION: la regione del cluster, ad esempio us-central1
   • CLUSTER_NAME: il nome del tuo cluster GKE, ad esempio hello-cluster
   • JOB_NAME: il nome del job Kubernetes, ad esempio hello-job

8. Fai clic su Esegui il deployment.

gcloud

1. Crea un file di codice sorgente per il tuo flusso di lavoro:

   touch kubernetes-api-job.JSON_OR_YAML

   Sostituisci JSON_OR_YAML con yaml o json a seconda del formato del flusso di lavoro.

2. In un editor di testo, copia il seguente flusso di lavoro nel file di codice sorgente:

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

   Sostituisci quanto segue:

   • LOCATION: la regione del cluster, ad esempio us-central1
   • CLUSTER_NAME: il nome del tuo cluster GKE, ad esempio hello-cluster
   • JOB_NAME: il nome del job Kubernetes, ad esempio hello-job

3. Esegui il deployment del flusso di lavoro:

   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

Esegui il flusso di lavoro

Dopo aver eseguito il deployment del flusso di lavoro, puoi eseguirlo. L'esecuzione di un flusso di lavoro esegue la definizione attuale del flusso di lavoro associata al flusso di lavoro.

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Nella pagina Flussi di lavoro, seleziona il flusso di lavoro per accedere alla relativa pagina dei dettagli.

3. Nella pagina Dettagli flusso di lavoro, fai clic su Esegui.

4. Fai di nuovo clic su Esegui.

   L'esecuzione del flusso di lavoro potrebbe richiedere un paio di minuti.

5. Visualizza i risultati del flusso di lavoro nel riquadro Output.

   I risultati dovrebbero essere simili ai seguenti:

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

Esegui il flusso di lavoro:

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

L'esecuzione del flusso di lavoro potrebbe richiedere un paio di minuti. I risultati dovrebbero essere simili al seguente:

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

Passaggi successivi

• Informazioni sui connettori
• Eseguire l'invocazione di un Google Cloud servizio utilizzando un connettore