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

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 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 des 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. Par exemple, vous pouvez utiliser le connecteur pour créer Déploiements Kubernetes, exécuter des jobs, gérer les pods ou accéder aux applications déployées via un proxy. Pour en savoir plus, consultez les Présentation du connecteur d'API Kubernetes

Avant de commencer

Avant de réaliser les tâches de 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 d'API Kubernetes, vous devez activer les API suivantes:

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

  • API Workflows: pour gérer les définitions et les workflows executions; l'activation de l'API Workflows active automatiquement 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éer un compte de service géré par l'utilisateur sert d'identité de votre workflow et lui accorde Développeur sur Kubernetes Engine (roles/container.developer) pour que le workflow puisse accéder à Kubernetes d'objets API dans des clusters.

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. Google Cloud dans la console remplit le champ ID de compte de service à partir 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électionnez un rôle, filtrez et sélectionnez le rôle Kubernetes Développeur sur Google Engine.

  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 projet Google Cloud.

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

  • IAM n'est pas spécifique à Kubernetes. elle fournit l'identité pour la gestion de multiples produits Google Cloud, principalement au niveau du projet Google Cloud.

  • Kubernetes RBAC est un composant essentiel de Kubernetes. Il vous permet de créer et d'attribuer des rôles (ensembles d'autorisations) pour tout objet ou type d'objet dans le cluster. Si vous utilisez principalement GKE et que vous avez besoin des autorisations précises pour chaque objet et opération de votre Kubernetes RBAC est 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 les adresses IP internes, ce qui signifie que les nœuds et les pods sont isolés Internet par défaut. Pour en savoir plus, consultez la section Clusters privés.

Vous pouvez également spécifier le mode de fonctionnement, qui propose 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 Choisissez un mode de fonctionnement GKE.

Si vous n'avez pas encore créé de cluster GKE, vous pouvez Déployer une application conteneurisée sur un serveur Web à un cluster GKE. Pour suivre 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 au réseau IPv4, vous pouvez créer un cluster avec un point de terminaison accessible, choisissez 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 GKE cluster, tel que hello-cluster
  • LOCATION : région de votre cluster, par exemple us-central1
  • PROJECT_ID : ID de votre projet Google Cloud

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 d'API Kubernetes pour envoyer une requête HTTP à le plan de contrôle du 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, pour exécuter les pods avec l'image nginx:1.14.2 et exposent 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 :

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 GKE cluster, tel que hello-cluster
    • PROJECT_ID : ID de votre projet Google Cloud
    • 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

    Remplacer JSON_OR_YAML par yaml ou json en fonction du format de votre flux de travail.

  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 GKE cluster, tel que 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

Après avoir déployé votre workflow, 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, 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 un job 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 se termine ; Sinon, une 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 une condition. Type de 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 de l'API Kubernetes suivante Fonctions du connecteur:

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, tel que en tant que 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

    Remplacer JSON_OR_YAML par yaml ou json en fonction du format de votre flux de travail.

  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, tel que en tant que 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

Après avoir déployé votre workflow, 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, 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