Accedi agli oggetti dell'API Kubernetes utilizzando un connettore

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Un cluster Google Kubernetes Engine (GKE) è costituito da un piano di controllo e da un chiamati nodes. Puoi eseguire i carichi di lavoro Kubernetes containerizzati in un cluster GKE. I nodi sono le macchine worker che eseguono le applicazioni containerizzate e altri carichi di lavoro e il piano di controllo endpoint unificato per il tuo 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 dell'API Kubernetes in un flusso di lavoro per inviare richieste all'endpoint di servizio Kubernetes ospitato dal piano di controllo del cluster. 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 avere aver completato determinati 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 dei flussi di lavoro e executions; l'abilitazione dell'API Workflows abilita automaticamente API Workflow Execution

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 Identity and Access Management (IAM) influisce sulle risorse del servizio a cui può accedere nel tuo progetto. Puoi revocare questo ruolo o concedere altri ruoli in un secondo momento. Negli ambienti di produzione, non concedere il ruolo Proprietario, Editor o Ruoli Visualizzatore. Concedi invece ruolo predefinito o ruolo personalizzato che soddisfa le tue esigenze.

Console

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

   Vai ad Account di servizio

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

3. Inserisci un nome nel campo Nome account di servizio. La console Google Cloud 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 e seleziona Kubernetes Sviluppatore di motori di ricerca.

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 di l'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 ID progetto Google Cloud.

Tieni presente che puoi utilizzare sia IAM che Kubernetes controllo dell'accesso basato su ruoli (RBAC, Role-Based Access Control) per controllare l'accesso a GKE cluster:

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

• 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 usi principalmente GKE e hai bisogno e in modo granulare per ogni oggetto e operazione 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, vedi 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 per il server web in un cluster GKE. In alternativa, per provare le istruzioni in questo documento, puoi creare un cluster Autopilot completando seguire.

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à 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 indirizzo IP a un endpoint accessibile, 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: il region per il tuo cluster, ad esempio us-central1
• PROJECT_ID: il tuo ID progetto Google Cloud

Il completamento della creazione del cluster potrebbe richiedere diversi minuti. Una volta alla creazione del 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 dell'API Kubernetes per inviare una richiesta HTTP a un dal piano di controllo del cluster GKE. Ad esempio, il seguente flusso di lavoro crea un deployment denominato nginx-deployment nel campo Kubernetes specificato in un cluster Kubernetes. Il deployment descrive uno stato richiesto; in questo caso, per eseguire tre pod con l'immagine nginx:1.14.2 ed espongono il proprio servizio sulla porta 80. (In caso contrario specificato, i valori project e location vengono impostati come predefiniti del flusso di lavoro.)

Per ulteriori informazioni, consulta la pagina di riferimento della funzione del connettore 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, vedi Errori del flusso di lavoro.

Esegui il deployment del flusso di lavoro

Prima di eseguire un flusso di lavoro, devi crearlo ed eseguirne il deployment.

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 creato in precedenza.

6. Fai clic su Avanti.

7. Nell'editor del flusso di lavoro, inserisci la seguente definizione per il tuo 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 ID progetto Google Cloud
   • 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 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 il 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 passare alla 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 deve essere Succeeded e il corpo del quando viene restituita la 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 il corpo della risposta viene restituito.

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 attende fino a 90 secondi per il completamento del job Kubernetes; altrimenti, viene generato un errore. Se il job viene completato, viene eliminato.

Tieni presente che un job viene considerato completato se il suo stato include una condizione. tipo di Complete. Ad esempio:

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

Se il job non riesce, 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 eseguirne il deployment.

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 creato in precedenza.

6. Fai clic su Avanti.

7. Nell'editor del flusso di lavoro, inserisci la seguente definizione per il tuo 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: il region per il tuo cluster, ad esempio us-central1
   • CLUSTER_NAME: il nome del tuo cluster GKE cluster, 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 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: il region per il tuo cluster, ad esempio us-central1
   • CLUSTER_NAME: il nome del tuo cluster GKE cluster, 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 il 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 dovrebbe essere simile 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
• Richiamare un servizio Google Cloud utilizzando un connettore