Mengakses objek Kubernetes API menggunakan konektor

Preview

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

Cluster Google Kubernetes Engine (GKE) terdiri dari bidang kontrol dan mesin pekerja yang disebut node. Anda dapat menjalankan workload Kubernetes dalam container di cluster GKE. Node adalah mesin pekerja yang menjalankan aplikasi dalam container dan beban kerja 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 informasi selengkapnya, lihat Ringkasan Konektor Kubernetes API

Catatan: Kubernetes API berbeda dengan Google Kubernetes Engine API, yang digunakan untuk membuat dan mengelola cluster GKE. Untuk memanggil GKE API dalam alur kerja, gunakan konektor Kubernetes Engine API.

Sebelum memulai

Sebelum melanjutkan 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 mem-build 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

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. 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) sehingga alur kerja dapat mengakses objek Kubernetes API di dalam cluster.

Catatan: Peran Identity and Access Management (IAM) memengaruhi resource mana yang dapat diakses oleh akun layanan Anda di project Anda. Anda dapat mencabut peran ini atau memberikan peran tambahan di lain waktu. Dalam lingkungan produksi, jangan berikan peran Pemilik, Editor, atau Viewer. Sebagai gantinya, berikan peran standar atau peran khusus yang memenuhi kebutuhan Anda.

Konsol

1. Di Konsol Google Cloud, buka halaman Service accounts.

   Buka halaman Service accounts

2. Pilih project, lalu klik Buat akun layanan.

3. Di kolom Nama akun layanan, masukkan nama. Konsol Google Cloud akan mengisi kolom ID akun layanan berdasarkan nama ini.

   Di kolom Deskripsi akun layanan, masukkan sebuah deskripsi. Contoh, Service account for Kubernetes API.

4. Klik Buat dan lanjutkan.

5. Dalam daftar Select a role, filter, lalu pilih peran Kubernetes Engine Developer.

6. Klik Lanjutkan.

7. Untuk menyelesaikan pembuatan akun, klik Selesai.

gcloud

1. Buat akun layanan:

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   Ganti SERVICE_ACCOUNT_NAME dengan nama akun layanan.

2. 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.

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

• IAM tidak spesifik pada Kubernetes; sistem ini menyediakan pengelolaan identitas untuk beberapa produk Google Cloud , dan beroperasi terutama di tingkat project Google Cloud .

• RBAC Kubernetes adalah komponen inti Kubernetes untuk membuat dan memberikan peran (serangkaian izin) untuk objek atau jenis objek dalam cluster. Jika Anda mengutamakan penggunaan GKE, dan memerlukan izin terperinci untuk setiap objek dan operasi dalam cluster Anda, Kubernetes RBAC adalah pilihan terbaik.

Untuk 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

1. Di konsol Google Cloud, buka halaman Kubernetes clusters.

   Buka cluster Kubernetes

2. Klik Create.

3. Jika Anda diminta untuk memilih mode cluster, pilih Autopilot.

4. Di bagian Cluster basics, selesaikan langkah-langkah berikut:

   1. Masukkan Name untuk cluster Anda, seperti hello-cluster.
   2. Pilih region untuk cluster Anda, seperti us-central1.

5. Klik Berikutnya: Jaringan.

6. Di bagian IPv4 network access, untuk membuat cluster dengan endpoint yang dapat diakses secara publik, pilih Public cluster.

7. Untuk semua setelan lainnya, terima setelan default.

8. Klik Buat.

Mungkin perlu waktu beberapa menit hingga pembuatan cluster selesai. Setelah cluster dibuat, tanda centang menunjukkan bahwa cluster tersebut 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: Google Cloud project ID Anda

Mungkin perlu waktu beberapa menit hingga pembuatan cluster selesai. Setelah cluster dibuat, output-nya 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 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 layanannya di port 80. (Jika tidak ditentukan, project dan location akan ditetapkan secara default ke alur kerja.)

Untuk 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 informasi selengkapnya, dalam dokumentasi Kubernetes, lihat Ringkasan API yang tertaut ke halaman "Referensi Kubernetes API".
• Anda dapat menangkap dan menangani error permintaan HTTP dalam alur kerja Anda. Untuk mengetahui informasi selengkapnya, lihat Error alur kerja.

Men-deploy alur kerja

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

Konsol

1. Di konsol Google Cloud, buka halaman Workflows.

   Buka Workflows

2. Klik Buat.

3. Masukkan nama untuk alur kerja baru, seperti kubernetes-api-request.

4. Dalam daftar Region, pilih us-central1.

5. Pilih Service account yang sebelumnya Anda buat.

6. Klik Berikutnya.

7. 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: Google Cloud project ID Anda
   • LOCATION: region untuk cluster Anda, seperti us-central1

8. Klik Deploy.

gcloud

1. 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.

2. 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

3. 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

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

Konsol

1. Di konsol Google Cloud, buka halaman Workflows.

   Buka Workflows

2. Di halaman Workflows, pilih alur kerja Anda untuk membuka halaman detailnya.

3. Di halaman Workflow details, klik Execute.

4. Klik Execute lagi.

5. Lihat hasil alur kerja di panel Output.

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

gcloud

Menjalankan alur kerja:

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

Jika berhasil, statusnya harus 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 hingga Tugas Kubernetes selesai; jika tidak, error akan ditampilkan. Jika 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 informasi selengkapnya, lihat halaman referensi untuk fungsi konektor Kubernetes API berikut:

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

Men-deploy alur kerja

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

Konsol

1. Di konsol Google Cloud, buka halaman Workflows.

   Buka Workflows

2. Klik Buat.

3. Masukkan nama untuk alur kerja baru, seperti kubernetes-api-job.

4. Dalam daftar Region, pilih us-central1.

5. Pilih Service account yang sebelumnya Anda buat.

6. Klik Berikutnya.

7. 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

8. Klik Deploy.

gcloud

1. 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.

2. 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

3. 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

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

Konsol

1. Di konsol Google Cloud, buka halaman Workflows.

   Buka Workflows

2. Di halaman Workflows, pilih alur kerja Anda untuk membuka halaman detailnya.

3. Di halaman Workflow details, klik Execute.

4. Klik Execute lagi.

   Eksekusi alur kerja mungkin memerlukan waktu beberapa menit.

5. Lihat hasil alur kerja di panel Output.

   Hasilnya akan mirip dengan berikut ini:

   {
   ...
     },
     "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 mirip dengan berikut ini:

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

Langkah selanjutnya

• Memahami konektor
• Memanggil layanan Google Cloud menggunakan konektor