Workflows를 사용하여 Batch 작업 실행


Batch는 Compute Engine 가상 머신(VM) 인스턴스에서 일괄 처리 워크로드를 예약, 큐에 추가, 실행할 수 있게 해주는 완전 관리형 서비스입니다. Batch는 자동으로 리소스를 프로비저닝하고 용량을 관리하므로 일괄 워크로드를 규모에 맞게 실행할 수 있습니다.

Workflows를 사용하면 Workflows 구문을 통해 정의한 순서대로 필요한 서비스를 실행할 수 있습니다.

이 튜토리얼에서는 Batch용 Workflows 커넥터를 사용하여 2개의 Compute Engine VM에서 6개의 태스크를 동시에 실행하는 Batch 작업을 예약하고 실행합니다. Batch와 Workflows를 모두 사용하면 이들이 제공하는 이점을 결합하고 전체 프로세스를 효율적으로 프로비저닝 및 조정할 수 있습니다.

목표

이 튜토리얼에서는 다음 단계를 진행합니다.

  1. Docker 컨테이너 이미지를 위한 Artifact Registry 저장소를 만듭니다.
  2. GitHub에서 일괄 처리 워크로드용 코드를 가져옵니다. 이 코드는 10,000개의 배치로 소수를 생성하는 샘플 프로그램입니다.
  3. 워크로드에 대한 Docker 이미지를 빌드합니다.
  4. 다음 작업을 수행하는 워크플로를 배포하고 실행합니다.
    1. 소수 생성기의 결과를 저장할 Cloud Storage 버킷 만들기
    2. 2개의 Compute Engine VM에서 Docker 컨테이너를 6개의 태스크로 동시에 실행하는 Batch 작업을 예약하고 실행하기
    3. Batch 작업이 완료되면 필요에 따라 삭제하기
  5. 결과가 예상대로 나오고 생성된 소수 배치가 Cloud Storage에 저장되었는지 확인합니다.

Google Cloud 콘솔에서 다음 명령어를 대부분 실행하거나 터미널 또는 Cloud Shell에서 Google Cloud CLI를 사용하여 모든 명령어를 실행할 수 있습니다.

비용

이 문서에서는 비용이 청구될 수 있는 다음과 같은 Google Cloud 구성요소를 사용합니다.

프로젝트 사용량을 기준으로 예상 비용을 산출하려면 가격 계산기를 사용하세요. Google Cloud를 처음 사용하는 사용자는 무료 체험판을 사용할 수 있습니다.

시작하기 전에

조직에서 정의한 보안 제약조건으로 인해 다음 단계를 완료하지 못할 수 있습니다. 문제 해결 정보는 제한된 Google Cloud 환경에서 애플리케이션 개발을 참조하세요.

콘솔

  1. Google Cloud 콘솔의 프로젝트 선택기 페이지에서 Google Cloud 프로젝트를 만들거나 선택합니다.

    프로젝트 선택기로 이동

  2. Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다. 프로젝트에 결제가 사용 설정되어 있는지 확인하는 방법을 알아보세요.

  3. Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions, Workflows API를 사용 설정합니다.

    API 사용 설정

  4. 다른 Google Cloud 서비스 인증에 사용할 워크플로의 서비스 계정을 만들고 적절한 역할을 부여합니다.

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

      서비스 계정 만들기로 이동

    2. 프로젝트를 선택합니다.

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

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

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

    5. 역할 선택 목록에서 다음 역할을 필터링하여 이전 단계에서 만든 사용자 관리 서비스 계정에 부여합니다.

      • Batch 작업 편집자: Batch 작업을 수정합니다.
      • 로그 작성자: 로그를 작성합니다.
      • 스토리지 관리자: Cloud Storage 리소스를 제어합니다.

      역할을 추가하려면 다른 역할 추가를 클릭하고 각 역할을 추가합니다.

    6. 계속을 클릭합니다.

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

  5. 기본 서비스 계정에 대한 IAM 서비스 계정 사용자 역할을 이전 단계에서 만든 사용자 관리 서비스 계정에 부여합니다. Compute Engine API를 사용 설정하면 기본 서비스 계정은 Compute Engine 기본 서비스 계정(PROJECT_NUMBER-compute@developer.gserviceaccount.com)이며 일반적으로 roles/iam.serviceAccountUser 역할을 통해 권한이 할당됩니다.

    1. 서비스 계정 페이지에서 기본 서비스 계정의 이메일 주소(PROJECT_NUMBER-compute@developer.gserviceaccount.com)를 클릭합니다.

    2. 권한 탭을 클릭합니다.

    3. 액세스 권한 부여 버튼을 클릭합니다.

    4. 새 주 구성원을 추가하려면 서비스 계정의 이메일 주소(SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com)를 입력합니다.

    5. 역할 선택 목록에서 서비스 계정 > 서비스 계정 사용자 역할을 선택합니다.

    6. 저장을 클릭합니다.

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. Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다. 프로젝트에 결제가 사용 설정되어 있는지 확인하는 방법을 알아보세요.

  3. Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions, Workflows API를 사용 설정합니다.

    gcloud services enable artifactregistry.googleapis.com \
      batch.googleapis.com \
      cloudbuild.googleapis.com \
      compute.googleapis.com \
      workflowexecutions.googleapis.com \
      workflows.googleapis.com
    
  4. 다른 Google Cloud 서비스 인증에 사용할 워크플로의 서비스 계정을 만들고 적절한 역할을 부여합니다.

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

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
      

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

    2. 이전 단계에서 만든 사용자 관리 서비스 계정에 역할을 부여합니다. 다음 IAM 역할마다 다음 명령어를 1회 실행합니다.

      • roles/batch.jobsEditor: Batch 작업을 수정합니다.
      • roles/logging.logWriter: 로그를 작성합니다.
      • roles/storage.admin: Cloud Storage 리소스를 제어합니다.
      gcloud projects add-iam-policy-binding PROJECT_ID \
        --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
        --role=ROLE
      

      다음을 바꿉니다.

      • PROJECT_ID: 서비스 계정을 만든 프로젝트 ID입니다.
      • ROLE: 부여할 역할입니다.
  5. 기본 서비스 계정에 대한 IAM 서비스 계정 사용자 역할을 이전 단계에서 만든 사용자 관리 서비스 계정에 부여합니다. Compute Engine API를 사용 설정하면 기본 서비스 계정은 Compute Engine 기본 서비스 계정(PROJECT_NUMBER-compute@developer.gserviceaccount.com)이며 일반적으로 roles/iam.serviceAccountUser 역할을 통해 권한이 할당됩니다.

    PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
    gcloud iam service-accounts add-iam-policy-binding \
      $PROJECT_NUMBER-compute@developer.gserviceaccount.com \
      --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
      --role=roles/iam.serviceAccountUser
    

Artifact Registry 저장소 만들기

Docker 컨테이너 이미지를 저장할 저장소를 만듭니다.

콘솔

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

    저장소로 이동

  2. 저장소 만들기를 클릭합니다.

  3. 저장소 이름으로 containers를 입력합니다.

  4. 형식에서 Docker를 선택합니다.

  5. 위치 유형으로 Region을 선택합니다.

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

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

gcloud

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

  gcloud artifacts repositories create containers \
    --repository-format=docker \
    --location=us-central1

us-central1 리전에 containers라는 Artifact Registry 저장소를 만들었습니다. 지원되는 리전에 대한 자세한 내용은 Artifact Registry 위치를 참고하세요.

코드 샘플 가져오기

Google Cloud는 이 튜토리얼의 애플리케이션 소스 코드를 GitHub에 저장합니다. 이 저장소를 클론하거나 샘플을 다운로드할 수 있습니다.

  1. 샘플 앱 저장소를 로컬 머신에 클론합니다.

    git clone https://github.com/GoogleCloudPlatform/batch-samples.git
    

    또는 main.zip 파일에 샘플을 다운로드하고 압축을 풉니다.

  2. 샘플 코드가 있는 디렉토리로 변경합니다.

    cd batch-samples/primegen
    

이제 개발 환경에서 애플리케이션의 소스 코드가 준비되었습니다.

Cloud Build를 사용하여 Docker 이미지 빌드

Dockerfile에는 Cloud Build를 사용하여 Docker 이미지를 빌드하는 데 필요한 정보가 포함되어 있습니다. 다음 명령어를 실행하여 빌드합니다.

gcloud builds submit \
  -t us-central1-docker.pkg.dev/PROJECT_ID/containers/primegen-service:v1 PrimeGenService/

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

빌드가 완료되면 다음과 비슷한 출력이 표시됩니다.

DONE
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID: a54818cc-5d14-467b-bfda-5fc9590af68c
CREATE_TIME: 2022-07-29T01:48:50+00:00
DURATION: 48S
SOURCE: gs://project-name_cloudbuild/source/1659059329.705219-17aee3a424a94679937a7200fab15bcf.tgz
IMAGES: us-central1-docker.pkg.dev/project-name/containers/primegen-service:v1
STATUS: SUCCESS

Dockerfile을 사용하여 primegen-service라는 Docker 이미지를 빌드하고 containers라는 Artifact Registry 저장소에 이미지를 푸시했습니다.

Batch 작업을 예약하고 실행하는 워크플로 배포

다음 워크플로는 2개의 Compute Engine VM에서 Docker 컨테이너를 6개의 태스크로 동시에 실행하는 Batch 작업을 예약하고 실행합니다. 그 결과 Cloud Storage 버킷에 저장된 6개의 소수 배치가 생성됩니다.

콘솔

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

    Workflows로 이동

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

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

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

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

  6. 다음을 클릭합니다.

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

    YAML

    main:
      params: [args]
      steps:
        - init:
            assign:
              - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
              - region: "us-central1"
              - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
              - jobId: ${"job-primegen-" + string(int(sys.now()))}
              - bucket: ${projectId + "-" + jobId}
        - createBucket:
            call: googleapis.storage.v1.buckets.insert
            args:
              query:
                project: ${projectId}
              body:
                name: ${bucket}
        - logCreateBucket:
            call: sys.log
            args:
              data: ${"Created bucket " + bucket}
        - logCreateBatchJob:
            call: sys.log
            args:
              data: ${"Creating and running the batch job " + jobId}
        - createAndRunBatchJob:
            call: googleapis.batch.v1.projects.locations.jobs.create
            args:
                parent: ${"projects/" + projectId + "/locations/" + region}
                jobId: ${jobId}
                body:
                  taskGroups:
                    taskSpec:
                      runnables:
                        - container:
                            imageUri: ${imageUri}
                          environment:
                            variables:
                              BUCKET: ${bucket}
                    # Run 6 tasks on 2 VMs
                    taskCount: 6
                    parallelism: 2
                  logsPolicy:
                    destination: CLOUD_LOGGING
            result: createAndRunBatchJobResponse
        # You can delete the batch job or keep it for debugging
        - logDeleteBatchJob:
            call: sys.log
            args:
              data: ${"Deleting the batch job " + jobId}
        - deleteBatchJob:
            call: googleapis.batch.v1.projects.locations.jobs.delete
            args:
                name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
            result: deleteResult
        - returnResult:
            return:
              jobId: ${jobId}
              bucket: ${bucket}

    JSON

    {
      "main": {
        "params": [
          "args"
        ],
        "steps": [
          {
            "init": {
              "assign": [
                {
                  "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
                },
                {
                  "region": "us-central1"
                },
                {
                  "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
                },
                {
                  "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
                },
                {
                  "bucket": "${projectId + \"-\" + jobId}"
                }
              ]
            }
          },
          {
            "createBucket": {
              "call": "googleapis.storage.v1.buckets.insert",
              "args": {
                "query": {
                  "project": "${projectId}"
                },
                "body": {
                  "name": "${bucket}"
                }
              }
            }
          },
          {
            "logCreateBucket": {
              "call": "sys.log",
              "args": {
                "data": "${\"Created bucket \" + bucket}"
              }
            }
          },
          {
            "logCreateBatchJob": {
              "call": "sys.log",
              "args": {
                "data": "${\"Creating and running the batch job \" + jobId}"
              }
            }
          },
          {
            "createAndRunBatchJob": {
              "call": "googleapis.batch.v1.projects.locations.jobs.create",
              "args": {
                "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
                "jobId": "${jobId}",
                "body": {
                  "taskGroups": {
                    "taskSpec": {
                      "runnables": [
                        {
                          "container": {
                            "imageUri": "${imageUri}"
                          },
                          "environment": {
                            "variables": {
                              "BUCKET": "${bucket}"
                            }
                          }
                        }
                      ]
                    },
                    "taskCount": 6,
                    "parallelism": 2
                  },
                  "logsPolicy": {
                    "destination": "CLOUD_LOGGING"
                  }
                }
              },
              "result": "createAndRunBatchJobResponse"
            }
          },
          {
            "logDeleteBatchJob": {
              "call": "sys.log",
              "args": {
                "data": "${\"Deleting the batch job \" + jobId}"
              }
            }
          },
          {
            "deleteBatchJob": {
              "call": "googleapis.batch.v1.projects.locations.jobs.delete",
              "args": {
                "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
              },
              "result": "deleteResult"
            }
          },
          {
            "returnResult": {
              "return": {
                "jobId": "${jobId}",
                "bucket": "${bucket}"
              }
            }
          }
        ]
      }
    }
    
  8. 배포를 클릭합니다.

gcloud

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

    touch batch-workflow.JSON_OR_YAML
    

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

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

    YAML

    main:
      params: [args]
      steps:
        - init:
            assign:
              - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
              - region: "us-central1"
              - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
              - jobId: ${"job-primegen-" + string(int(sys.now()))}
              - bucket: ${projectId + "-" + jobId}
        - createBucket:
            call: googleapis.storage.v1.buckets.insert
            args:
              query:
                project: ${projectId}
              body:
                name: ${bucket}
        - logCreateBucket:
            call: sys.log
            args:
              data: ${"Created bucket " + bucket}
        - logCreateBatchJob:
            call: sys.log
            args:
              data: ${"Creating and running the batch job " + jobId}
        - createAndRunBatchJob:
            call: googleapis.batch.v1.projects.locations.jobs.create
            args:
                parent: ${"projects/" + projectId + "/locations/" + region}
                jobId: ${jobId}
                body:
                  taskGroups:
                    taskSpec:
                      runnables:
                        - container:
                            imageUri: ${imageUri}
                          environment:
                            variables:
                              BUCKET: ${bucket}
                    # Run 6 tasks on 2 VMs
                    taskCount: 6
                    parallelism: 2
                  logsPolicy:
                    destination: CLOUD_LOGGING
            result: createAndRunBatchJobResponse
        # You can delete the batch job or keep it for debugging
        - logDeleteBatchJob:
            call: sys.log
            args:
              data: ${"Deleting the batch job " + jobId}
        - deleteBatchJob:
            call: googleapis.batch.v1.projects.locations.jobs.delete
            args:
                name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
            result: deleteResult
        - returnResult:
            return:
              jobId: ${jobId}
              bucket: ${bucket}

    JSON

    {
      "main": {
        "params": [
          "args"
        ],
        "steps": [
          {
            "init": {
              "assign": [
                {
                  "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
                },
                {
                  "region": "us-central1"
                },
                {
                  "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
                },
                {
                  "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
                },
                {
                  "bucket": "${projectId + \"-\" + jobId}"
                }
              ]
            }
          },
          {
            "createBucket": {
              "call": "googleapis.storage.v1.buckets.insert",
              "args": {
                "query": {
                  "project": "${projectId}"
                },
                "body": {
                  "name": "${bucket}"
                }
              }
            }
          },
          {
            "logCreateBucket": {
              "call": "sys.log",
              "args": {
                "data": "${\"Created bucket \" + bucket}"
              }
            }
          },
          {
            "logCreateBatchJob": {
              "call": "sys.log",
              "args": {
                "data": "${\"Creating and running the batch job \" + jobId}"
              }
            }
          },
          {
            "createAndRunBatchJob": {
              "call": "googleapis.batch.v1.projects.locations.jobs.create",
              "args": {
                "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
                "jobId": "${jobId}",
                "body": {
                  "taskGroups": {
                    "taskSpec": {
                      "runnables": [
                        {
                          "container": {
                            "imageUri": "${imageUri}"
                          },
                          "environment": {
                            "variables": {
                              "BUCKET": "${bucket}"
                            }
                          }
                        }
                      ]
                    },
                    "taskCount": 6,
                    "parallelism": 2
                  },
                  "logsPolicy": {
                    "destination": "CLOUD_LOGGING"
                  }
                }
              },
              "result": "createAndRunBatchJobResponse"
            }
          },
          {
            "logDeleteBatchJob": {
              "call": "sys.log",
              "args": {
                "data": "${\"Deleting the batch job \" + jobId}"
              }
            }
          },
          {
            "deleteBatchJob": {
              "call": "googleapis.batch.v1.projects.locations.jobs.delete",
              "args": {
                "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
              },
              "result": "deleteResult"
            }
          },
          {
            "returnResult": {
              "return": {
                "jobId": "${jobId}",
                "bucket": "${bucket}"
              }
            }
          }
        ]
      }
    }
    
  3. 다음 명령어를 입력하여 워크플로를 배포합니다.

    gcloud workflows deploy batch-workflow \
      --source=batch-workflow.yaml \
      --location=us-central1 \
      --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
    

    SERVICE_ACCOUNT_NAME을 이전에 만든 서비스 계정의 이름으로 바꿉니다.

워크플로 실행

워크플로를 실행하면 워크플로와 연결된 현재 워크플로 정의가 실행됩니다.

콘솔

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

    Workflows로 이동

  2. Workflows 페이지에서 batch-workflow 워크플로를 클릭하여 세부정보 페이지로 이동합니다.

  3. 워크플로 세부정보 페이지에서 실행을 클릭합니다.

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

    워크플로를 실행하는 데 몇 분 정도 걸립니다.

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

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

    {
      "bucket": "project-name-job-primegen-TIMESTAMP",
      "jobId": "job-primegen-TIMESTAMP"
    }
    

gcloud

  1. 워크플로를 실행합니다.

    gcloud workflows run batch-workflow \
      --location=us-central1

    워크플로를 실행하는 데 몇 분 정도 걸립니다.

  2. 장기 실행 상태를 확인할 수 있습니다.

  3. 마지막으로 완료된 실행 상태를 가져오려면 다음 명령어를 실행합니다.

    gcloud workflows executions describe-last

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

    name: projects/PROJECT_NUMBER/locations/us-central1/workflows/batch-workflow/executions/EXECUTION_ID
    result: '{"bucket":"project-name-job-primegen-TIMESTAMP","jobId":"job-primegen-TIMESTAMP"}'
    startTime: '2022-07-29T16:08:39.725306421Z'
    state: SUCCEEDED
    status:
      currentSteps:
      - routine: main
        step: returnResult
    workflowRevisionId: 000001-9ba
    

출력 버킷의 객체 나열

Cloud Storage 출력 버킷의 객체를 나열하여 결과가 예상대로 작동하는지 확인할 수 있습니다.

콘솔

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

    버킷으로 이동

  2. 버킷 목록에서 콘텐츠를 볼 버킷의 이름을 클릭합니다.

    결과는 총 6개의 파일로, 각 파일에는 소수 10,000개가 일괄적으로 나열되며 다음과 비슷합니다.

    primes-1-10000.txt
    primes-10001-20000.txt
    primes-20001-30000.txt
    primes-30001-40000.txt
    primes-40001-50000.txt
    primes-50001-60000.txt
    

gcloud

  1. 출력 버킷 이름을 검색합니다.

    gcloud storage ls

    출력은 다음과 비슷합니다.

    gs://PROJECT_ID-job-primegen-TIMESTAMP/

  2. 출력 버킷의 객체 나열

    gcloud storage ls gs://PROJECT_ID-job-primegen-TIMESTAMP/** --recursive

    TIMESTAMP를 이전 명령어에서 반환된 타임스탬프로 바꿉니다.

    출력은 총 6개의 파일로, 각 파일에는 소수 10,000개가 일괄적으로 나열되며 다음과 비슷합니다.

    gs://project-name-job-primegen-TIMESTAMP/primes-1-10000.txt
    gs://project-name-job-primegen-TIMESTAMP/primes-10001-20000.txt
    gs://project-name-job-primegen-TIMESTAMP/primes-20001-30000.txt
    gs://project-name-job-primegen-TIMESTAMP/primes-30001-40000.txt
    gs://project-name-job-primegen-TIMESTAMP/primes-40001-50000.txt
    gs://project-name-job-primegen-TIMESTAMP/primes-50001-60000.txt
    

삭제

이 튜토리얼용으로 새 프로젝트를 만든 경우 이 프로젝트를 삭제합니다. 기존 프로젝트를 사용한 경우 이 튜토리얼에 추가된 변경사항은 제외하고 보존하려면 튜토리얼용으로 만든 리소스를 삭제합니다.

프로젝트 삭제

비용이 청구되지 않도록 하는 가장 쉬운 방법은 튜토리얼에서 만든 프로젝트를 삭제하는 것입니다.

프로젝트를 삭제하는 방법은 다음과 같습니다.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

이 튜토리얼에서 만든 리소스 삭제

  1. Batch 작업을 삭제합니다.

    1. 먼저 다음과 같이 작업 이름을 가져옵니다.

      gcloud batch jobs list --location=us-central1
      

      출력은 다음과 비슷하게 표시됩니다.

      NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
      STATE: SUCCEEDED
      

      여기서 job-primegen-TIMESTAMP는 Batch 작업의 이름입니다.

    2. 작업 삭제:

      gcloud batch jobs delete BATCH_JOB_NAME --location us-central1
      
  2. 워크플로 삭제:

    gcloud workflows delete WORKFLOW_NAME
    
  3. 컨테이너 저장소를 삭제합니다.:

    gcloud artifacts repositories delete REPOSITORY_NAME --location=us-central1
    
  4. Cloud Build는 Cloud Storage를 사용하여 빌드 리소스를 저장합니다. Cloud Storage 버킷을 삭제하려면 버킷 삭제를 참조하세요.

다음 단계