Accedere agli oggetti dell'API Kubernetes utilizzando un connettore

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

Il server API Kubernetes viene eseguito sul control plane, consentendoti di interagire con gli oggetti Kubernetes nel cluster tramite chiamate API Kubernetes. Gli oggetti sono entità permanenti nel sistema Kubernetes e rappresentano lo stato del tuo cluster. Per ulteriori informazioni, consulta le sezioni Oggetti in Kubernetes e Panoramica dell'API nella documentazione di Kubernetes, che rimanda alle pagine "Riferimento dell'API Kubernetes".

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

Prima di iniziare

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

Abilita API

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

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

  • API Workflows: per gestire le definizioni e le esecuzioni dei workflow; l'attivazione dell'API Workflows attiva automaticamente l'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 service account gestito dall'utente che funge da identità del flusso di lavoro e concedigli il ruolo Sviluppatore Kubernetes Engine (roles/container.developer) in modo che il flusso di lavoro possa accedere agli oggetti API Kubernetes all'interno dei cluster.

Console

  1. Nella Google Cloud console, vai alla pagina Service account.

    Vai ad Account di servizio

  2. Seleziona un progetto e poi fai clic su Crea service account.

  3. Nel campo Nome account di servizio, inserisci un nome. La Google Cloud console compila il campo ID service account in base a questo nome.

    Nel campo Descrizione service account, 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 il ruolo Sviluppatore Kubernetes Engine.

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

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

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

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

Per ulteriori informazioni, consulta Controllo dell'accesso.

Crea un cluster GKE

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

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

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

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 Impostazioni di base del cluster, completa quanto segue:

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

  5. Fai clic su Avanti: networking.

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

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

  8. Fai clic su Crea.

Il processo di creazione del cluster potrebbe richiedere alcuni 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 cluster GKE, ad esempio hello-cluster
  • LOCATION: la regione del cluster, ad esempio us-central1
  • PROJECT_ID: il tuo ID progetto Google Cloud

Il processo di creazione del cluster potrebbe richiedere alcuni minuti. Una volta creato il cluster, l'output dovrebbe essere simile al seguente:

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

Utilizzare il connettore per inviare una richiesta HTTP

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

Per saperne di più, consulta la pagina di riferimento della funzione del connettore API Kubernetes gke.request.

Tieni presente quanto segue:

Esegui il deployment del flusso di lavoro

Prima di eseguire un flusso di lavoro, devi crearlo e implementarlo.

Console

  1. Nella Google Cloud console, vai alla pagina Workflows.

    Vai a Flussi di lavoro

  2. Fai clic su Crea.

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

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

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

  6. Fai clic su Avanti.

  7. Nell'editor del workflow, inserisci la seguente definizione per il 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}"
        }
      }
    ]
  }
}

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del 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 workflow:

    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 del 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 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 workflow esegue la definizione attuale del workflow associata al workflow.

Console

  1. Nella Google Cloud console, vai alla pagina Workflows.

    Vai a Flussi di lavoro

  2. Nella pagina Flussi di lavoro, seleziona il flusso di lavoro per andare 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 dovrebbe essere Succeeded e viene restituito il corpo della risposta.

gcloud

Esegui il flusso di lavoro:

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

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

Utilizzare il connettore per eseguire un job Kubernetes

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

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

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

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

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

Per saperne di più, consulta le pagine di riferimento per le seguenti funzioni del connettore dell'API Kubernetes:

Esegui il deployment del flusso di lavoro

Prima di eseguire un flusso di lavoro, devi crearlo e implementarlo.

Console

  1. Nella Google Cloud console, vai alla pagina Workflows.

    Vai a Flussi di lavoro

  2. Fai clic su Crea.

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

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

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

  6. Fai clic su Avanti.

  7. Nell'editor del workflow, inserisci la seguente definizione per il 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}"
        }
      }
    ]
  }
}

    Sostituisci quanto segue:

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

  8. Fai clic su Esegui il deployment.

gcloud

  1. Crea un file di codice sorgente per il workflow:

    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 del codice sorgente:

    YAML

    main:
  steps:
    - init:
        assign:
          - project: "PROJECT_ID"
          - location: "LOCATION"
          - cluster_id: "CLUSTER_NAME"
          - job_name: "JOB_NAME"
          - namespace: "default"
    - create_job:
        call: gke.create_job
        args:
          cluster_id: '${cluster_id}'
          location: '${location}'
          project: '${project}'
          namespace: '${namespace}'
          job:
            apiVersion: batch/v1
            kind: Job
            metadata:
              name: "${job_name}"
            spec:
              template:
                spec:
                  containers:
                    - name: counter
                      image: centos:7
                      command:
                        - "bin/bash"
                        - "-c"
                        - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                  restartPolicy: Never
        result: job
    - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
        call: gke.await_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          timeout: 90  # 90 seconds
        result: completed_job
    - cleanup_job:
        call: gke.delete_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          query:
            propagationPolicy: "Foreground"  # delete child Pods
    - return_job:
        return: '${completed_job}'

    JSON

    {
  "main": {
    "steps": [
      {
        "init": {
          "assign": [
            {
              "project": "PROJECT_ID"
            },
            {
              "location": "LOCATION"
            },
            {
              "cluster_id": "CLUSTER_NAME"
            },
            {
              "job_name": "JOB_NAME"
            },
            {
              "namespace": "default"
            }
          ]
        }
      },
      {
        "create_job": {
          "call": "gke.create_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "location": "${location}",
            "project": "${project}",
            "namespace": "${namespace}",
            "job": {
              "apiVersion": "batch/v1",
              "kind": "Job",
              "metadata": {
                "name": "${job_name}"
              },
              "spec": {
                "template": {
                  "spec": {
                    "containers": [
                      {
                        "name": "counter",
                        "image": "centos:7",
                        "command": [
                          "bin/bash",
                          "-c",
                          "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                        ]
                      }
                    ],
                    "restartPolicy": "Never"
                  }
                }
              }
            }
          },
          "result": "job"
        }
      },
      {
        "wait_for_job": {
          "call": "gke.await_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "timeout": 90
          },
          "result": "completed_job"
        }
      },
      {
        "cleanup_job": {
          "call": "gke.delete_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "query": {
              "propagationPolicy": "Foreground"
            }
          }
        }
      },
      {
        "return_job": {
          "return": "${completed_job}"
        }
      }
    ]
  }
}

    Sostituisci quanto segue:

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

  3. Esegui il deployment del flusso di lavoro:

    gcloud workflows deploy kubernetes-api-job \
    --source=kubernetes-api-job.JSON_OR_YAML \
    --location=LOCATION \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Esegui il flusso di lavoro

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

Console

  1. Nella Google Cloud console, vai alla pagina Workflows.

    Vai a Flussi di lavoro

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

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

  4. Fai di nuovo clic su Esegui.

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

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

    I risultati dovrebbero essere simili ai seguenti:

    {
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

gcloud

Esegui il flusso di lavoro:

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

L'esecuzione del flusso di lavoro potrebbe richiedere un paio di minuti. I risultati dovrebbero essere simili 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": {}
  }
}

Passaggi successivi