Accéder aux objets de l'API Kubernetes à l'aide d'un connecteur

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) se compose d'un plan de contrôle et de machines de calcul appelées nœuds. Vous pouvez exécuter vos charges de travail Kubernetes conteneurisées dans un cluster GKE. Les nœuds sont des machines de calcul qui exécutent vos applications en conteneurs et d'autres charges de travail, et le plan de contrôle est le point de terminaison unifié de votre cluster. Pour en savoir plus, consultez la page Architecture d'un cluster GKE.

Le serveur d'API Kubernetes s'exécute sur le plan de contrôle, ce qui vous permet d'interagir avec les objets Kubernetes dans le cluster via des appels d'API Kubernetes. Les objets sont des entités persistantes dans le système Kubernetes et représentent l'état de votre cluster. Pour en savoir plus, consultez la section Objects in Kubernetes (Objets dans Kubernetes) et la section API Overview (Présentation de l'API) de la documentation Kubernetes, qui contient des liens vers les pages de référence de l'API Kubernetes.

Ce document explique comment utiliser le connecteur d'API Kubernetes dans un workflow pour envoyer des requêtes au point de terminaison du service Kubernetes hébergé sur le plan de contrôle d'un cluster GKE. Par exemple, vous pouvez utiliser le connecteur pour créer des déploiements Kubernetes, exécuter des jobs, gérer des pods ou accéder aux applications déployées via un proxy. Pour en savoir plus, consultez la présentation du connecteur d'API Kubernetes.

Remarque :L'API Kubernetes est distincte de l'API Google Kubernetes Engine, qui permet de créer et de gérer des clusters GKE. Pour appeler l'API GKE dans un workflow, utilisez le connecteur API Kubernetes Engine.

Avant de commencer

Avant de poursuivre les tâches décrites dans ce document, assurez-vous d'avoir rempli certaines conditions préalables.

Activer les API

Avant de pouvoir accéder aux objets de l'API Kubernetes à l'aide du connecteur de l'API Kubernetes, vous devez activer les API suivantes:

• API Google Kubernetes Engine: pour créer et gérer des applications basées sur des conteneurs à l'aide de GKE

• API Workflows: pour gérer les définitions et les exécutions de workflow. L'activation de l'API Workflows active automatiquement l'API Workflow Executions.

Console

Activer les API :

Activer les 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. Activer les API :

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

Créer un compte de service

Créez un compte de service géré par l'utilisateur qui sert d'identité à votre workflow, puis attribuez-lui le rôle Développeur Kubernetes Engine (roles/container.developer) afin que le workflow puisse accéder aux objets de l'API Kubernetes dans les clusters.

Remarque :Le rôle IAM (Identity and Access Management) détermine les ressources auxquelles votre compte de service peut accéder dans votre projet. Vous pouvez révoquer ce rôle ou attribuer des rôles supplémentaires ultérieurement. Dans les environnements de production, n'attribuez pas les rôles Propriétaire, Éditeur et Lecteur. Attribuez plutôt un rôle prédéfini ou un rôle personnalisé répondant à vos besoins.

Console

1. Dans Google Cloud Console, accédez à la page Comptes de service.

   Accéder à la page "Comptes de service"

2. Sélectionnez un projet, puis cliquez sur Créer un compte de service.

3. Dans le champ Nom du compte de service, saisissez un nom. La console Google Cloudremplit le champ ID du compte de service en fonction de ce nom.

   Dans le champ Description du compte de service, saisissez une description. Exemple : Service account for Kubernetes API.

4. Cliquez sur Créer et continuer.

5. Dans la liste Sélectionner un rôle, filtrez sur le rôle Développeur de Kubernetes Engine, puis sélectionnez-le.

6. Cliquez sur Continuer.

7. Pour terminer la création du compte, cliquez sur OK.

gcloud

1. Créez le compte de service :

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Remplacez SERVICE_ACCOUNT_NAME par le nom du compte de service.

2. Attribuez le rôle container.developer à votre compte de service :

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

   Remplacez PROJECT_ID par l'ID de votre Google Cloudprojet.

Notez que vous pouvez utiliser à la fois IAM et le contrôle des accès basé sur les rôles (RBAC) Kubernetes pour contrôler l'accès à votre cluster GKE:

• IAM n'est pas spécifique à Kubernetes. Cette solution fournit des fonctions de gestion des identités pour de nombreux Google Cloud produits et fonctionne principalement au niveau du Google Cloud projet.

• Kubernetes RBAC est un composant essentiel de Kubernetes qui vous permet de créer et d'attribuer des rôles (ensembles d'autorisations) à tout objet ou type d'objet au sein du cluster. Si vous utilisez principalement GKE et que vous avez besoin de contrôler avec précision chaque objet et opération de votre cluster, Kubernetes RBAC constitue le meilleur choix.

Pour en savoir plus, consultez la page Contrôle des accès.

Créer un cluster GKE

Pour utiliser le connecteur d'API Kubernetes, vous devez déjà avoir créé un cluster GKE public ou privé. Dans un cluster privé, les nœuds ne disposent que d'adresses IP internes, ce qui signifie que les nœuds et les pods sont isolés par défaut d'Internet. Pour en savoir plus, consultez la section Clusters privés.

Vous pouvez également spécifier le mode de fonctionnement, qui vous offre différents niveaux de flexibilité, de responsabilité et de contrôle. Par exemple, vous pouvez créer un cluster Autopilot, qui est un mode de fonctionnement de GKE dans lequel Google gère la configuration de votre cluster, y compris vos nœuds, le scaling, la sécurité et d'autres paramètres préconfigurés. Pour en savoir plus, consultez la section Choisir un mode de fonctionnement GKE.

Si vous n'avez pas encore créé de cluster GKE, vous pouvez déployer une application conteneurisée de serveur Web sur un cluster GKE. Pour tester les instructions de ce document, vous pouvez également créer un cluster Autopilot en procédant comme suit.

Console

1. Dans Cloud Console, accédez à la page des clusters Kubernetes.

   Accéder à la page "Clusters Kubernetes"

2. Cliquez sur Créer.

3. Si vous êtes invité à sélectionner un mode de cluster, sélectionnez Autopilot.

4. Dans la section Paramètres de base du cluster, procédez comme suit :

   1. Saisissez le nom de votre cluster, par exemple hello-cluster.
   2. Sélectionnez une région pour votre cluster, par exemple us-central1.

5. Cliquez sur Suivant: Mise en réseau.

6. Dans la section Accès réseau IPv4, pour créer un cluster avec un point de terminaison accessible publiquement, sélectionnez Cluster public.

7. Pour tous les autres paramètres, acceptez les valeurs par défaut.

8. Cliquez sur Créer.

La création du cluster peut prendre plusieurs minutes. Une fois le cluster créé, une coche indique qu'il est en cours d'exécution.

gcloud

Exécutez la commande ci-dessous.

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

Remplacez les éléments suivants :

• CLUSTER_NAME: nom de votre cluster GKE, par exemple hello-cluster
• LOCATION: région de votre cluster, par exemple us-central1
• PROJECT_ID: ID de votre Google Cloud projet

La création du cluster peut prendre plusieurs minutes. Une fois le cluster créé, le résultat doit ressembler à ce qui suit :

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

Utiliser le connecteur pour envoyer une requête HTTP

Vous pouvez utiliser le connecteur de l'API Kubernetes pour envoyer une requête HTTP au plan de contrôle d'un cluster GKE. Par exemple, le workflow suivant crée un déploiement nommé nginx-deployment dans le cluster Kubernetes spécifié. Le déploiement décrit un état requis. Dans ce cas, il s'agit d'exécuter trois pods avec l'image nginx:1.14.2 et d'exposer leur service sur le port 80. (Si aucune valeur n'est spécifiée, project et location sont définis par défaut sur ceux du workflow.)

Pour en savoir plus, consultez la page de référence de la fonction de connecteur d'API Kubernetes, gke.request.

Veuillez noter les points suivants :

• Le champ path correspond au chemin d'accès à la méthode de l'API Kubernetes. Pour en savoir plus, consultez la présentation de l'API dans la documentation Kubernetes, qui contient des liens vers les pages de référence de l'API Kubernetes.
• Vous pouvez détecter et gérer les erreurs de requête HTTP dans votre workflow. Pour en savoir plus, consultez la section Erreurs de workflow.

Déployer votre workflow

Avant d'exécuter un workflow, vous devez le créer et le déployer.

Console

1. Dans la console Google Cloud, accédez à la page Workflows.

   Accéder à "Workflows"

2. Cliquez sur  Créer.

3. Saisissez un nom pour le nouveau workflow, par exemple kubernetes-api-request.

4. Dans la liste Région, sélectionnez us-central1.

5. Sélectionnez le compte de service que vous avez créé précédemment.

6. Cliquez sur Suivant.

7. Dans l'éditeur de workflow, saisissez la définition suivante pour votre workflow:

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

   Remplacez les éléments suivants :

   • CLUSTER_NAME: nom de votre cluster GKE, par exemple hello-cluster
   • PROJECT_ID: ID de votre Google Cloud projet
   • LOCATION: région de votre cluster, par exemple us-central1

8. Cliquez sur Déployer.

gcloud

1. Créez un fichier de code source pour votre workflow:

   touch kubernetes-api-request.JSON_OR_YAML

   Remplacez JSON_OR_YAML par yaml ou json en fonction du format de votre workflow.

2. Dans un éditeur de texte, copiez le workflow suivant dans votre fichier de code source:

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

   Remplacez les éléments suivants :

   • CLUSTER_NAME: nom de votre cluster GKE, par exemple hello-cluster
   • LOCATION: région de votre cluster, par exemple us-central1

3. Déployez le workflow :

   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

Exécuter votre workflow

Une fois votre workflow déployé, vous pouvez l'exécuter. L'exécution d'un workflow exécute la définition actuelle du workflow associé au workflow.

Console

1. Dans la console Google Cloud, accédez à la page Workflows.

   Accéder à "Workflows"

2. Sur la page Workflows (Workflows), sélectionnez votre workflow pour accéder à sa page d'informations.

3. Sur la page Détails du workflow, cliquez sur Exécuter.

4. Cliquez à nouveau sur Exécuter.

5. Affichez les résultats du workflow dans le volet Output (Résultat).

   Si la requête aboutit, l'état d'exécution doit être Succeeded et le corps de la réponse est renvoyé.

gcloud

Exécutez le workflow :

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

Si la requête aboutit, l'état doit être SUCCEEDED et le corps de la réponse est renvoyé.

Utiliser le connecteur pour exécuter une tâche Kubernetes

Vous pouvez utiliser le connecteur d'API Kubernetes pour déployer et exécuter une tâche Kubernetes dans un cluster GKE. Le workflow suivant crée un job Kubernetes qui exécute un script Bash qui itère sur une séquence de nombres. Le workflow attend jusqu'à 90 secondes que la tâche Kubernetes soit terminée. Sinon, une erreur est générée. Si la tâche est terminée, elle est supprimée.

Notez qu'une tâche est considérée comme terminée si son état inclut un type de condition Complete. Exemple :

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

Si la tâche échoue, une balise FailedJobError est renvoyée. Exemple :

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

Pour en savoir plus, consultez les pages de référence des fonctions de connecteur d'API Kubernetes suivantes:

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

Déployer votre workflow

Avant d'exécuter un workflow, vous devez le créer et le déployer.

Console

1. Dans la console Google Cloud, accédez à la page Workflows.

   Accéder à "Workflows"

2. Cliquez sur  Créer.

3. Saisissez un nom pour le nouveau workflow, par exemple kubernetes-api-job.

4. Dans la liste Région, sélectionnez us-central1.

5. Sélectionnez le compte de service que vous avez créé précédemment.

6. Cliquez sur Suivant.

7. Dans l'éditeur de workflow, saisissez la définition suivante pour votre workflow:

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

   Remplacez les éléments suivants :

   • LOCATION: région de votre cluster, par exemple us-central1
   • CLUSTER_NAME: nom de votre cluster GKE, par exemple hello-cluster
   • JOB_NAME: nom de la tâche Kubernetes, par exemple hello-job

8. Cliquez sur Déployer.

gcloud

1. Créez un fichier de code source pour votre workflow:

   touch kubernetes-api-job.JSON_OR_YAML

   Remplacez JSON_OR_YAML par yaml ou json en fonction du format de votre workflow.

2. Dans un éditeur de texte, copiez le workflow suivant dans votre fichier de code source:

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

   Remplacez les éléments suivants :

   • LOCATION: région de votre cluster, par exemple us-central1
   • CLUSTER_NAME: nom de votre cluster GKE, par exemple hello-cluster
   • JOB_NAME: nom de la tâche Kubernetes, par exemple hello-job

3. Déployez le workflow :

   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

Exécuter votre workflow

Une fois votre workflow déployé, vous pouvez l'exécuter. L'exécution d'un workflow exécute la définition actuelle du workflow associé au workflow.

Console

1. Dans la console Google Cloud, accédez à la page Workflows.

   Accéder à "Workflows"

2. Sur la page Workflows (Workflows), sélectionnez votre workflow pour accéder à sa page d'informations.

3. Sur la page Détails du workflow, cliquez sur Exécuter.

4. Cliquez à nouveau sur Exécuter.

   L'exécution du workflow peut prendre quelques minutes.

5. Affichez les résultats du workflow dans le volet Output (Résultat).

   Les résultats doivent ressembler à ce qui suit:

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

Exécutez le workflow :

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

L'exécution du workflow peut prendre quelques minutes. Les résultats doivent ressembler à ceci:

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

Étape suivante

• Comprendre les connecteurs
• Appeler un service Google Cloud à l'aide d'un connecteur