커넥터를 사용하여 Kubernetes API 객체 액세스

미리보기

이 기능에는 서비스별 약관의 일반 서비스 약관 섹션에 있는 'GA 이전 제공 서비스 약관'이 적용됩니다. GA 이전 기능은 '있는 그대로' 제공되며 지원이 제한될 수 있습니다. 자세한 내용은 출시 단계 설명을 참조하세요.

Google Kubernetes Engine(GKE) 클러스터는 제어 영역과 노드라고 부르는 작업자 머신으로 구성됩니다. GKE 클러스터에서 컨테이너화된 Kubernetes 워크로드를 실행할 수 있습니다. 노드는 컨테이너화된 애플리케이션 및 기타 워크로드를 실행하는 작업자 머신이고, 제어 영역은 클러스터의 통합 엔드포인트입니다. 자세한 내용은 GKE 클러스터 아키텍처를 참조하세요.

Kubernetes API 서버는 제어 영역에서 실행되며 Kubernetes API 호출을 통해 클러스터의 Kubernetes 객체와 상호작용할 수 있게 해줍니다. 객체는 Kubernetes 시스템에 있는 영구 항목이며 클러스터 상태를 나타냅니다. 자세한 내용은 Kubernetes 문서에서 Kubernetes 객체와 "Kubernetes API 참조" 페이지로 연결되는 API 개요를 참조하세요.

이 문서에서는 워크플로에서 Kubernetes API 커넥터를 사용하여 GKE 클러스터의 제어 영역에 호스팅되는 Kubernetes 서비스 엔드포인트를 요청하는 방법을 보여줍니다. 예를 들어 커넥터를 사용해서 Kubernetes 배포를 만들고, 작업을 실행하고, 포드를 관리하고, 프록시를 통해 배포된 앱에 액세스할 수 있습니다. 자세한 내용은 Kubernetes API 커넥터 개요를 참조하세요.

참고: Kubernetes API는 GKE 클러스터 생성 및 관리에 사용되는 Google Kubernetes Engine API와 다릅니다. 워크플로에서 GKE API를 호출하려면 Kubernetes Engine API 커넥터를 사용합니다.

시작하기 전에

이 문서의 작업을 진행하려면 특정 기본 요건이 완료되었는지 확인합니다.

API 사용 설정

Kubernetes API 커넥터를 사용하여 Kubernetes API 객체에 액세스할 수 있으려면 먼저 다음 API를 사용 설정해야 합니다.

• Google Kubernetes Engine API: GKE를 사용하여 컨테이너 기반 애플리케이션을 빌드 및 관리합니다.

• Workflows API: 워크플로 정의 및 실행을 관리합니다. Workflows API를 사용 설정하면 Workflow Executions API가 자동으로 사용 설정됩니다.

콘솔

API를 사용 설정합니다.

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. API를 사용 설정합니다.

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

서비스 계정 만들기

워크플로 ID로 작동하는 사용자 관리 서비스 계정을 만들고 워크플로가 클러스터 내부의 Kubernetes API 객체에 액세스할 수 있도록 여기에 Kubernetes Engine Developer(roles/container.developer) 역할을 부여합니다.

참고: Identity and Access Management(IAM) 역할은 서비스 계정이 프로젝트에서 액세스할 수 있는 리소스에 영향을 줍니다. 나중에 이 역할을 취소하거나 추가 역할을 부여할 수 있습니다. 프로덕션 환경에서는 소유자, 편집자 또는 뷰어 역할을 부여하지 마세요. 대신 요구사항을 충족하는 사전 정의된 역할 또는 커스텀 역할을 부여합니다.

콘솔

1. Google Cloud 콘솔에서 서비스 계정 페이지로 이동합니다.

   서비스 계정으로 이동

2. 프로젝트를 선택한 후 서비스 계정 만들기를 클릭합니다.

3. 서비스 계정 이름 필드에 이름을 입력합니다. Google Cloud 콘솔은 이 이름을 기반으로 서비스 계정 ID 필드를 채웁니다.

   서비스 계정 설명 필드에 설명을 입력합니다. 예를 들면 Service account for Kubernetes API입니다.

4. 만들고 계속하기를 클릭합니다.

5. 역할 선택 목록에서 Kubernetes Engine Developer 역할을 필터링하고 선택합니다.

6. 계속을 클릭합니다.

7. 계정 만들기를 마치려면 완료를 클릭합니다.

gcloud

1. 서비스 계정을 만듭니다.

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   SERVICE_ACCOUNT_NAME을 서비스 계정 이름으로 바꿉니다.

2. 서비스 계정에 container.developer 역할을 부여합니다.

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

   PROJECT_ID를 Google Cloud 프로젝트 ID로 바꿉니다.

IAM 및 Kubernetes 역할 기반 액세스 제어(RBAC)를 모두 사용해서 GKE 클러스터에 대한 액세스를 제어할 수 있습니다.

• IAM은 Kubernetes에 국한되지 않습니다. 다양한 Google Cloud 제품의 ID 관리 기능을 제공하며 주로 Google Cloud 프로젝트 수준에서 작동합니다.

• Kubernetes RBAC는 Kubernetes의 핵심 구성요소로, 클러스터에 속한 객체 또는 객체 유형에 대한 역할(권한 집합)을 만들고 부여할 수 있습니다. 주로 GKE를 사용하고 클러스터 내 모든 객체 및 작업에 세분화된 권한이 필요한 경우 Kubernetes RBAC를 사용하는 것이 가장 좋습니다.

자세한 내용은 액세스 제어를 참조하세요.

GKE 클러스터 만들기

Kubernetes API 커넥터를 사용하려면 공개 또는 비공개 GKE 클러스터가 이미 생성되어 있어야 합니다. 비공개 클러스터의 노드에는 내부 IP 주소만 있습니다. 즉, 노드와 포드는 기본적으로 인터넷에서 격리되어 있습니다. 자세한 내용은 비공개 클러스터를 참조하세요.

또한 다른 수준의 유연성, 책임, 제어를 부여하는 작업 모드를 지정할 수 있습니다. 예를 들어 노드, 확장, 보안, 기타 사전 구성된 설정을 포함하여 Google이 클러스터 구성을 관리하는 GKE의 작업 모드인 Autopilot 클러스터를 만들 수 있습니다. 자세한 내용은 GKE 작업 모드 선택을 참조하세요.

GKE 클러스터를 아직 만들지 않았으면 GKE 클러스터에 웹 서버 컨테이너화된 애플리케이션을 배포할 수 있습니다. 또는 이 문서의 안내를 시도하기 위해 다음을 수행하여 Autopilot 클러스터를 만들 수 있습니다.

콘솔

1. Google Cloud 콘솔에서 Kubernetes 클러스터 페이지로 이동합니다.

   Kubernetes 클러스터로 이동

2. 만들기를 클릭합니다.

3. 클러스터 모드를 선택하라는 메시지가 표시되면 Autopilot을 선택합니다.

4. 클러스터 기본사항 섹션에서 다음을 완료합니다.

   1. 클러스터의 이름을 입력합니다(예: hello-cluster).
   2. 클러스터에 사용할 리전(예: us-central1)을 선택합니다.

5. 다음: 네트워킹을 클릭합니다.

6. IPv4 네트워크 액세스 섹션에서 공개적으로 액세스할 수 있는 엔드포인트로 클러스터를 만들려면 공개 클러스터를 선택합니다.

7. 다른 모든 설정은 기본값을 그대로 사용합니다.

8. 만들기를 클릭합니다.

클러스터 생성이 완료되는 데 몇 분이 걸릴 수 있습니다. 클러스터가 생성되었으면 실행 중임을 나타내는 체크표시가 나타납니다.

gcloud

다음 명령어를 실행합니다.

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

다음을 바꿉니다.

• CLUSTER_NAME: GKE 클러스터의 이름입니다(예: hello-cluster).
• LOCATION: 클러스터에 사용할 리전입니다(예: us-central1).
• PROJECT_ID: Google Cloud 프로젝트 ID입니다.

클러스터 생성이 완료되는 데 몇 분이 걸릴 수 있습니다. 클러스터가 생성되면 다음과 유사한 출력이 표시됩니다.

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

커넥터를 사용하여 HTTP 요청 전송

Kubernetes API 커넥터를 사용하여 GKE 클러스터 제어 영역에 HTTP 요청을 전송할 수 있습니다. 예를 들어 다음 워크플로는 지정된 Kubernetes 클러스터에 nginx-deployment라는 배포를 만듭니다. 배포는 필요한 상태를 설명합니다. 여기에서는 nginx:1.14.2 이미지로 3개 포드를 실행하고 서비스를 포트 80으로 노출합니다. project 및 location을 지정하지 않으면 해당 워크플로의 기본값으로 지정됩니다.

자세한 내용은 Kubernetes API 커넥터 함수 gke.request의 참조 페이지를 확인하세요.

다음에 유의하세요.

• path 필드는 Kubernetes API 메서드 경로에 해당합니다. 자세한 내용은 Kubernetes 문서에서 "Kubernetes API 참조" 페이지로 연결되는 API 개요를 참조하세요.
• 워크플로에서 HTTP 요청 오류를 파악하고 처리할 수 있습니다. 자세한 내용은 워크플로 오류를 참조하세요.

워크플로 배포

워크플로를 실행하기 전에 이를 만들고 배포해야 합니다.

콘솔

1. Google Cloud 콘솔에서 Workflows 페이지로 이동합니다.

   Workflows로 이동

2. 만들기를 클릭합니다.

3. 새 워크플로의 이름을 입력합니다(예: kubernetes-api-request).

4. 리전 목록에서 us-central1을 선택합니다.

5. 이전에 만든 서비스 계정을 선택합니다.

6. 다음을 클릭합니다.

7. 워크플로 편집기에서 다음 워크플로 정의를 입력합니다.

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

   다음을 바꿉니다.

   • CLUSTER_NAME: GKE 클러스터의 이름입니다(예: hello-cluster).
   • PROJECT_ID: Google Cloud 프로젝트 ID입니다.
   • LOCATION: 클러스터에 사용할 리전입니다(예: us-central1).

8. 배포를 클릭합니다.

gcloud

1. 워크플로의 소스 코드 파일을 만듭니다.

   touch kubernetes-api-request.JSON_OR_YAML

   워크플로 형식에 따라 JSON_OR_YAML을 yaml 또는 json으로 바꿉니다.

2. 텍스트 편집기에서 다음 워크플로를 소스 코드 파일에 복사합니다.

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

   다음을 바꿉니다.

   • CLUSTER_NAME: GKE 클러스터의 이름입니다(예: hello-cluster).
   • LOCATION: 클러스터에 사용할 리전입니다(예: us-central1).

3. 워크플로를 배포합니다.

   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

워크플로 실행

워크플로를 성공적으로 배포한 후 이를 실행할 수 있습니다. 워크플로를 실행하면 워크플로와 연결된 현재 워크플로 정의가 실행됩니다.

콘솔

1. Google Cloud 콘솔에서 Workflows 페이지로 이동합니다.

   Workflows로 이동

2. Workflows 페이지에서 워크플로를 선택하여 세부정보 페이지로 이동합니다.

3. Workflows 세부정보 페이지에서 실행을 클릭합니다.

4. 실행을 다시 클릭합니다.

5. 출력 창에서 워크플로 결과를 확인합니다.

   성공하면 실행 상태가 Succeeded로 표시되고 응답 본문이 반환됩니다.

gcloud

워크플로를 실행합니다.

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

성공하면 상태가 SUCCEEDED로 표시되고 응답 본문이 반환됩니다.

커넥터를 사용하여 Kubernetes 작업 실행

Kubernetes API 커넥터를 사용하여 GKE 클러스터에서 Kubernetes 작업을 배포하고 실행할 수 있습니다. 다음 워크플로는 일련의 숫자를 반복 처리하는 Bash 스크립트를 실행하는 Kubernetes 작업을 만듭니다. 이 워크플로는 Kubernetes 작업이 완료될 때까지 최대 90초 동안 기다립니다. 그렇지 않으면 오류가 발생합니다. 작업이 완료된 다음에는 삭제됩니다.

상태에 Complete 유형의 조건이 포함되면 작업이 완료된 것으로 간주됩니다. 예를 들면 다음과 같습니다.

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

작업이 실패하면 FailedJobError 태그가 반환됩니다. 예를 들면 다음과 같습니다.

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

자세한 내용은 다음 Kubernetes API 커넥터 함수에 대한 참조 페이지를 확인하세요.

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

워크플로 배포

워크플로를 실행하기 전에 이를 만들고 배포해야 합니다.

콘솔

1. Google Cloud 콘솔에서 Workflows 페이지로 이동합니다.

   Workflows로 이동

2. 만들기를 클릭합니다.

3. 새 워크플로의 이름을 입력합니다(예: kubernetes-api-job).

4. 리전 목록에서 us-central1을 선택합니다.

5. 이전에 만든 서비스 계정을 선택합니다.

6. 다음을 클릭합니다.

7. 워크플로 편집기에서 다음 워크플로 정의를 입력합니다.

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

   다음을 바꿉니다.

   • LOCATION: 클러스터에 사용할 리전입니다(예: us-central1).
   • CLUSTER_NAME: GKE 클러스터의 이름입니다(예: hello-cluster).
   • JOB_NAME: Kubernetes 작업의 이름입니다(예: hello-job).

8. 배포를 클릭합니다.

gcloud

1. 워크플로의 소스 코드 파일을 만듭니다.

   touch kubernetes-api-job.JSON_OR_YAML

   워크플로 형식에 따라 JSON_OR_YAML을 yaml 또는 json으로 바꿉니다.

2. 텍스트 편집기에서 다음 워크플로를 소스 코드 파일에 복사합니다.

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

   다음을 바꿉니다.

   • LOCATION: 클러스터에 사용할 리전입니다(예: us-central1).
   • CLUSTER_NAME: GKE 클러스터의 이름입니다(예: hello-cluster).
   • JOB_NAME: Kubernetes 작업의 이름입니다(예: hello-job).

3. 워크플로를 배포합니다.

   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

워크플로 실행

워크플로를 성공적으로 배포한 후 이를 실행할 수 있습니다. 워크플로를 실행하면 워크플로와 연결된 현재 워크플로 정의가 실행됩니다.

콘솔

1. Google Cloud 콘솔에서 Workflows 페이지로 이동합니다.

   Workflows로 이동

2. Workflows 페이지에서 워크플로를 선택하여 세부정보 페이지로 이동합니다.

3. Workflows 세부정보 페이지에서 실행을 클릭합니다.

4. 실행을 다시 클릭합니다.

   워크플로를 실행하는 데 몇 분 정도 걸릴 수 있습니다.

5. 출력 창에서 워크플로 결과를 확인합니다.

   결과는 다음과 비슷하게 표시됩니다.

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

워크플로를 실행합니다.

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

워크플로를 실행하는 데 몇 분 정도 걸릴 수 있습니다. 결과는 다음과 비슷하게 표시됩니다.

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

다음 단계

• 커넥터 이해
• 커넥터를 사용하여 Google Cloud 서비스 호출