Mengakses objek Kubernetes API menggunakan konektor

Cluster Google Kubernetes Engine (GKE) terdiri dari bidang kontrol dan mesin pekerja yang disebut node. Anda dapat menjalankan beban kerja Kubernetes dalam container di cluster GKE. Node adalah mesin pekerja yang menjalankan aplikasi dalam container serta workload lainnya, dan bidang kontrol adalah endpoint terpadu untuk cluster Anda. Untuk mengetahui informasi selengkapnya, lihat arsitektur cluster GKE.

Server Kubernetes API berjalan di bidang kontrol, sehingga Anda dapat berinteraksi dengan objek Kubernetes di cluster melalui panggilan Kubernetes API. Objek adalah entity persisten dalam sistem Kubernetes dan mewakili status cluster Anda. Untuk informasi selengkapnya, dalam dokumentasi Kubernetes, lihat Objek di Kubernetes, dan Ringkasan API yang tertaut ke halaman "Referensi Kubernetes API".

Dokumen ini menunjukkan cara menggunakan konektor Kubernetes API dalam alur kerja untuk membuat permintaan ke endpoint layanan Kubernetes yang dihosting di bidang kontrol cluster GKE. Misalnya, Anda dapat menggunakan konektor untuk membuat Deployment Kubernetes, menjalankan Tugas, mengelola Pod, atau mengakses aplikasi yang di-deploy melalui proxy. Untuk mengetahui informasi selengkapnya, lihat Ringkasan Konektor Kubernetes API

Sebelum memulai

Sebelum melanjutkan ke tugas dalam dokumen ini, pastikan Anda telah menyelesaikan prasyarat tertentu.

Mengaktifkan API

Sebelum dapat mengakses objek Kubernetes API menggunakan konektor Kubernetes API, Anda harus mengaktifkan API berikut:

Google Kubernetes Engine API: untuk membangun dan mengelola aplikasi berbasis container menggunakan GKE
Workflows API: untuk mengelola definisi dan eksekusi alur kerja; mengaktifkan Workflows API akan otomatis mengaktifkan Workflow Executions API

Konsol

Aktifkan API:

Aktifkan API

gcloud

Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell

Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.

Aktifkan API:

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

Membuat akun layanan

Buat akun layanan yang dikelola pengguna yang bertindak sebagai identitas alur kerja Anda, dan berikan peran Kubernetes Engine Developer (roles/container.developer) agar alur kerja tersebut dapat mengakses objek Kubernetes API di dalam cluster.

Konsol

Di Konsol Google Cloud, buka halaman Service accounts.

Buka halaman Service accounts
Pilih project, lalu klik Create service account.
Di kolom Nama akun layanan, masukkan nama. Google Cloud Console mengisi kolom Service account ID berdasarkan nama ini.

Di kolom Deskripsi akun layanan, masukkan sebuah deskripsi. Misalnya, Service account for Kubernetes API.
Klik Buat dan lanjutkan.
Dalam daftar Select a role, filter, lalu pilih peran Kubernetes Engine Developer.
Klik Lanjutkan.
Untuk menyelesaikan pembuatan akun, klik Selesai.

gcloud

Buat akun layanan:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Ganti SERVICE_ACCOUNT_NAME dengan nama akun layanan.

Berikan peran container.developer ke akun layanan Anda:

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

Ganti PROJECT_ID dengan project ID Google Cloud Anda.

Perlu diperhatikan bahwa Anda dapat menggunakan IAM dan kontrol akses berbasis peran (RBAC) Kubernetes untuk mengontrol akses ke cluster GKE:

IAM tidak spesifik untuk Kubernetes; IAM menyediakan pengelolaan identitas untuk berbagai produk Google Cloud, dan beroperasi terutama pada level project Google Cloud.
Kubernetes RBAC adalah komponen inti Kubernetes dan dapat digunakan untuk membuat dan memberikan peran (serangkaian izin) untuk setiap objek atau jenis objek dalam cluster. Jika Anda mengutamakan penggunaan GKE, dan memerlukan izin yang terperinci untuk setiap objek dan operasi dalam cluster Anda, Kubernetes RBAC adalah pilihan terbaik.

Untuk mengetahui informasi selengkapnya, lihat Kontrol akses.

Membuat cluster GKE

Untuk menggunakan konektor Kubernetes API, Anda harus sudah membuat cluster GKE publik atau pribadi. Dalam cluster pribadi, node hanya memiliki alamat IP internal yang berarti node dan Pod diisolasi dari internet secara default. Untuk mengetahui informasi selengkapnya, lihat Cluster pribadi.

Anda juga dapat menentukan mode operasi yang menawarkan berbagai tingkat fleksibilitas, tanggung jawab, dan kontrol. Misalnya, Anda dapat membuat cluster Autopilot, yang merupakan mode operasi di GKE tempat Google mengelola konfigurasi cluster Anda, termasuk node, penskalaan, keamanan, dan setelan lainnya yang telah dikonfigurasi sebelumnya. Untuk mengetahui informasi selengkapnya, lihat Memilih mode operasi GKE.

Jika belum membuat cluster GKE, Anda dapat men-deploy aplikasi dalam container server web ke cluster GKE. Atau, untuk mencoba petunjuk dalam dokumen ini, Anda dapat membuat cluster Autopilot dengan menyelesaikan hal berikut.

Konsol

Di konsol Google Cloud, buka halaman Cluster Kubernetes.

Buka cluster Kubernetes
Klik Create.
Jika Anda diminta untuk memilih mode cluster, pilih Autopilot.
Di bagian Cluster basics, selesaikan langkah-langkah berikut:
1. Masukkan Nama untuk cluster Anda, seperti hello-cluster.
2. Pilih region untuk cluster Anda, seperti us-central1.
Klik Next: Networking.
Di bagian IPv4 network access, untuk membuat cluster dengan endpoint yang dapat diakses secara publik, pilih Public cluster.
Untuk semua setelan lainnya, terima setelan default.
Klik Create.

Mungkin diperlukan waktu beberapa menit untuk menyelesaikan pembuatan cluster. Setelah cluster dibuat, tanda centang menunjukkan bahwa cluster sedang berjalan.

gcloud

Jalankan perintah berikut:

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

Ganti kode berikut:

CLUSTER_NAME: nama cluster GKE Anda, seperti hello-cluster
LOCATION: region untuk cluster Anda, seperti us-central1
PROJECT_ID: project ID Google Cloud Anda

Mungkin diperlukan waktu beberapa menit untuk menyelesaikan pembuatan cluster. Setelah cluster dibuat, outputnya akan terlihat seperti berikut:

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

Menggunakan konektor untuk mengirim permintaan HTTP

Anda dapat menggunakan konektor Kubernetes API untuk mengirim permintaan HTTP ke bidang kontrol cluster GKE. Misalnya, alur kerja berikut akan membuat Deployment bernama nginx-deployment di cluster Kubernetes yang ditentukan. Deployment menjelaskan status yang diperlukan; dalam hal ini, untuk menjalankan tiga Pod dengan image nginx:1.14.2 dan mengekspos layanan mereka di port 80. (Jika tidak ditentukan, project dan location akan ditetapkan secara default ke alur kerja.)

Untuk mengetahui informasi selengkapnya, lihat halaman referensi untuk fungsi konektor Kubernetes API, gke.request.

Perhatikan hal-hal berikut:

Kolom path sesuai dengan jalur metode Kubernetes API. Untuk mengetahui informasi selengkapnya, dalam dokumentasi Kubernetes, lihat Ringkasan API yang berisi link ke halaman "Referensi Kubernetes API".
Anda dapat menangkap dan menangani error permintaan HTTP dalam alur kerja. Untuk mengetahui informasi selengkapnya, lihat Error alur kerja.

Men-deploy alur kerja Anda

Sebelum menjalankan alur kerja, Anda harus membuat dan men-deploy-nya.

Konsol

Di konsol Google Cloud, buka halaman Workflows.

Buka Workflows
Klik Buat.
Masukkan nama untuk alur kerja baru, seperti kubernetes-api-request.
Pada daftar Region, pilih us-central1.
Pilih Akun layanan yang telah dibuat sebelumnya.
Klik Next.

Di editor alur kerja, masukkan definisi berikut untuk alur kerja Anda:

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

Ganti kode berikut:

CLUSTER_NAME: nama cluster GKE Anda, seperti hello-cluster
PROJECT_ID: project ID Google Cloud Anda
LOCATION: region untuk cluster Anda, seperti us-central1

Klik Deploy.

gcloud

Buat file kode sumber untuk alur kerja Anda:
```
touch kubernetes-api-request.JSON_OR_YAML
```
Ganti JSON_OR_YAML dengan yaml atau json, bergantung pada format alur kerja Anda.

Di editor teks, salin alur kerja berikut ke file kode sumber Anda:

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

Ganti kode berikut:

CLUSTER_NAME: nama cluster GKE Anda, seperti hello-cluster
LOCATION: region untuk cluster Anda, seperti us-central1

Deploy alur kerja:

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

Menjalankan alur kerja Anda

Setelah berhasil men-deploy alur kerja, Anda dapat menjalankannya. Mengeksekusi alur kerja akan menjalankan definisi alur kerja saat ini yang terkait dengan alur kerja tersebut.

Konsol

Di konsol Google Cloud, buka halaman Workflows.

Buka Workflows
Di halaman Workflows, pilih alur kerja Anda untuk membuka halaman detailnya.
Di halaman Workflow details, klik Execute.
Klik Execute lagi.
Lihat hasil alur kerja di panel Output.

Jika berhasil, status eksekusi akan menjadi Succeeded dan isi respons akan ditampilkan.

gcloud

Menjalankan alur kerja:

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

Jika berhasil, status harus menjadi SUCCEEDED dan isi respons akan ditampilkan.

Menggunakan konektor untuk menjalankan Tugas Kubernetes

Anda dapat menggunakan konektor Kubernetes API untuk men-deploy dan menjalankan Tugas Kubernetes di cluster GKE. Alur kerja berikut membuat Tugas Kubernetes yang menjalankan skrip Bash yang melakukan iterasi melalui urutan angka. Alur kerja menunggu hingga 90 detik sampai Tugas Kubernetes selesai; jika tidak, error akan muncul. Jika Tugas sudah selesai, Tugas akan dihapus.

Perhatikan bahwa Tugas dianggap selesai jika statusnya menyertakan jenis kondisi Complete. Contoh:

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

Jika Tugas gagal, tag FailedJobError akan ditampilkan. Contoh:

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

Untuk mengetahui informasi selengkapnya, lihat halaman referensi untuk fungsi konektor Kubernetes API berikut:

Men-deploy alur kerja Anda

Sebelum menjalankan alur kerja, Anda harus membuat dan men-deploy-nya.

Konsol

Di konsol Google Cloud, buka halaman Workflows.

Buka Workflows
Klik Buat.
Masukkan nama untuk alur kerja baru, seperti kubernetes-api-job.
Pada daftar Region, pilih us-central1.
Pilih Akun layanan yang telah dibuat sebelumnya.
Klik Next.

Di editor alur kerja, masukkan definisi berikut untuk alur kerja Anda:

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

Ganti kode berikut:

LOCATION: region untuk cluster Anda, seperti us-central1
CLUSTER_NAME: nama cluster GKE Anda, seperti hello-cluster
JOB_NAME: nama Tugas Kubernetes, seperti hello-job

Klik Deploy.

gcloud

Buat file kode sumber untuk alur kerja Anda:
```
touch kubernetes-api-job.JSON_OR_YAML
```
Ganti JSON_OR_YAML dengan yaml atau json, bergantung pada format alur kerja Anda.

Di editor teks, salin alur kerja berikut ke file kode sumber Anda:

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

Ganti kode berikut:

LOCATION: region untuk cluster Anda, seperti us-central1
CLUSTER_NAME: nama cluster GKE Anda, seperti hello-cluster
JOB_NAME: nama Tugas Kubernetes, seperti hello-job

Deploy alur kerja:

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

Menjalankan alur kerja Anda

Setelah berhasil men-deploy alur kerja, Anda dapat menjalankannya. Mengeksekusi alur kerja akan menjalankan definisi alur kerja saat ini yang terkait dengan alur kerja tersebut.

Konsol

Di konsol Google Cloud, buka halaman Workflows.

Buka Workflows
Di halaman Workflows, pilih alur kerja Anda untuk membuka halaman detailnya.
Di halaman Workflow details, klik Execute.
Klik Execute lagi.

Eksekusi alur kerja mungkin memerlukan waktu beberapa menit.

Lihat hasil alur kerja di panel Output.

Hasilnya akan terlihat seperti berikut:

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

Menjalankan alur kerja:

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

Eksekusi alur kerja mungkin memerlukan waktu beberapa menit. Hasilnya akan terlihat seperti berikut:

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

Mengakses objek Kubernetes API menggunakan konektor

Sebelum memulai

Mengaktifkan API

Konsol

gcloud

Membuat akun layanan

Konsol

gcloud

Membuat cluster GKE

Konsol

gcloud

Menggunakan konektor untuk mengirim permintaan HTTP

Men-deploy alur kerja Anda

Konsol

YAML

JSON

gcloud

YAML

JSON

Menjalankan alur kerja Anda

Konsol

gcloud

Menggunakan konektor untuk menjalankan Tugas Kubernetes

Men-deploy alur kerja Anda

Konsol

YAML

JSON

gcloud

YAML

JSON

Menjalankan alur kerja Anda

Konsol

gcloud

Langkah selanjutnya