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

Un cluster Google Kubernetes Engine (GKE) est composé 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 les machines de calcul qui exécutent vos applications conteneurisées et d'autres charges de travail, tandis que 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 du 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 page Objets dans Kubernetes dans la documentation Kubernetes et la présentation de l'API qui renvoie vers les pages de la documentation 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 de 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 tâches, 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.

Avant de commencer

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

Activer les API

Pour pouvoir accéder aux objets d'API Kubernetes à l'aide du connecteur d'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 des workflows. L'activation de l'API Workflows active automatiquement l'API Workflow Executions.

Console

Activer les API :

Activer les API

gcloud

  1. Dans la console Google Cloud, activez Cloud Shell.

    Activer Cloud Shell

    En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

  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 constitue l'identité de votre workflow, puis attribuez-lui le rôle Développeur sur Kubernetes Engine (roles/container.developer) afin que le workflow puisse accéder aux objets d'API Kubernetes dans les 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. La console Google Cloud 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électionner un rôle, filtrez et sélectionnez le rôle Développeur sur Kubernetes 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 contrôler l'accès à votre cluster GKE à l'aide d'IAM et du contrôle des accès basé sur les rôles Kubernetes (RBAC) :

  • IAM n'est pas spécifique à Kubernetes. Il fournit des fonctionnalités de gestion des identités pour plusieurs produits Google Cloud et fonctionne 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 au sein du cluster. Si vous utilisez principalement GKE et que vous avez besoin d'autorisations précises pour 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 n'ont que des 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 page Clusters privés.

Vous pouvez également spécifier le mode de fonctionnement, qui offre différents niveaux de flexibilité, de responsabilité et de contrôle. Par exemple, vous pouvez créer un cluster Autopilot. Il s'agit d'un mode de fonctionnement dans 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 page 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 essayer 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é à choisir 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 Next: Networking (Suivant : Mise en réseau).

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

  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, tel que hello-cluster
  • LOCATION: région de votre cluster, telle que 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 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, les champs project et location sont définis par défaut sur ceux du workflow.)

Pour en savoir plus, consultez la page de référence sur la fonction du 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 cluster GKE, tel que hello-cluster
    • PROJECT_ID : ID de votre projet Google Cloud
    • LOCATION: région de votre cluster, telle que us-central1

  8. Cliquez sur Deploy (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 selon le 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, tel que hello-cluster
    • LOCATION: région de votre cluster, telle que 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 du workflow actuel qui lui est associé.

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 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 une tâche Kubernetes qui exécute un script Bash qui parcourt une séquence de nombres. Le workflow attend jusqu'à 90 secondes que la tâche Kubernetes se termine. 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 sur les fonctions suivantes du connecteur d'API Kubernetes:

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, telle que us-central1
    • CLUSTER_NAME: nom de votre cluster GKE, tel que hello-cluster
    • JOB_NAME: nom de la tâche Kubernetes, par exemple hello-job

  8. Cliquez sur Deploy (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 selon le 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, telle que us-central1
    • CLUSTER_NAME: nom de votre cluster GKE, tel que 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 du workflow actuel qui lui est associé.

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

Étapes suivantes