스토리지 볼륨을 사용하는 작업 만들기 및 실행

이 문서에서는 하나 이상의 외부 저장소 볼륨을 사용하는 Batch 작업을 만들고 실행하는 방법을 설명합니다. 외부 저장소 옵션에는 신규 또는 기존 영구 디스크, 새로운 로컬 SSD, 기존 Cloud Storage 버킷, Filestore 파일 공유와 같은 기존 네트워크 파일 시스템(NFS)이 포함되어 있습니다.

외부 저장소 볼륨의 추가 여부와 상관없이 작업의 각 Compute Engine VM에는 작업의 운영체제(OS) 이미지와 안내를 제공하는 부팅 디스크가 있습니다. 작업의 부팅 디스크 구성에 대한 자세한 내용은 대신 VM OS 환경 개요를 참조하세요.

시작하기 전에

  1. Batch를 사용한 적이 없으면 Batch 시작하기를 검토하고 프로젝트 및 사용자 기본 요건을 완료하여 Batch를 사용 설정하세요.

  2. 작업을 만드는 데 필요한 권한을 얻으려면 관리자에게 다음 IAM 역할을 부여해 달라고 요청하세요.

    역할 부여에 대한 자세한 내용은 프로젝트, 폴더, 조직에 대한 액세스 관리를 참조하세요.

    커스텀 역할이나 다른 사전 정의된 역할을 통해 필요한 권한을 얻을 수도 있습니다.

스토리지 볼륨을 사용하는 작업 만들기

필요한 경우 작업에서 다음 유형의 외부 저장소 볼륨 중 하나 이상을 사용할 수 있습니다. 모든 스토리지 볼륨 유형 및 각 유형의 차이 및 제한에 대한 자세한 내용은 Compute Engine VM 스토리지 옵션 문서를 참조하세요.

작업 정의에 스토리지 볼륨을 포함하고 실행 가능한 항목에 마운트 경로(mountPath)를 지정하여 작업이 각 스토리지 볼륨을 사용하도록 허용할 수 있습니다. 스토리지 볼륨을 사용하는 작업을 만드는 방법을 알아보려면 다음 섹션 중 하나 이상의 참조하세요.

영구 디스크 사용

영구 디스크를 사용하는 작업에는 다음과 같은 제한사항이 있습니다.

  • 모든 영구 디스크: 모든 영구 디스크의 제한사항을 검토하세요.

  • 새 영구 디스크와 기존 영구 디스크 비교: 작업의 각 영구 디스크는 새 영구 디스크(작업에 정의되고 작업에서 생성됨)이거나 기존 영구 디스크(프로젝트에서 이미 만들어지고 작업에 지정됨)일 수 있습니다. 영구 디스크를 사용하려면 작업의 VM에 포맷하고 마운트해야 하며, VM은 영구 디스크와 동일한 위치에 있어야 합니다. Batch는 작업에 포함하는 모든 영구 디스크를 마운트하고 새 영구 디스크를 포맷하지만, 작업에 사용하려는 기존 영구 디스크는 포맷하고 마운트를 해제해야 합니다.

    지원되는 위치 옵션, 형식 옵션, 마운트 옵션은 다음 표의 설명처럼 신규 및 기존 영구 디스크 간에 다릅니다.

    새로운 영구 디스크 기존 영구 디스크
    형식 옵션

    영구 디스크는 ext4 파일 시스템으로 자동 포맷됩니다.

    작업에 사용하려면 먼저 ext4 파일 시스템을 사용할 수 있도록 영구 디스크를 포맷해야 합니다.

    마운트 옵션

    모든 옵션이 지원됩니다.

    쓰기를 제외한 모든 옵션이 지원됩니다. 이는 멀티 작성자 모드의 제한 사항 때문입니다.

    작업에 사용하려면 먼저 연결된 모든 VM에서 영구 디스크를 분리해야 합니다.
    위치 옵션

    영역별 영구 디스크만 만들 수 있습니다.

    작업의 모든 위치를 선택할 수 있습니다. 영구 디스크는 프로젝트가 실행되는 영역에 생성됩니다.

    영역별 및 리전별 영구 디스크를 선택할 수 있습니다.


    작업의 위치(지정된 경우 해당 작업의 허용된 위치)를 작업의 모든 영구 디스크가 포함된 위치만으로 설정해야 합니다. 예를 들어, 영역별 영구 디스크의 경우 작업 위치가 디스크 영역이어야 합니다. 각각의 기존 리전별 영구 디스크의 경우에는 작업 위치가 디스크 리전이어야 하고, 영역을 지정할 경우에는 리전별 영구 디스크가 위치한 특정 영역 중 하나 또는 모두여야 합니다.

  • 인스턴스 템플릿. 이 작업을 만드는 동안 VM 인스턴스 템플릿을 사용하려면 이 작업의 영구 디스크를 인스턴스 템플릿에 연결해야 합니다. 인스턴스 템플릿을 사용하지 않으려면 작업 정의에 영구 디스크를 직접 연결해야 합니다.

Google Cloud 콘솔, gcloud CLI, Batch API, C++, Go, Java, Node.js 또는 Python을 사용하여 영구 디스크를 사용하는 작업을 만들 수 있습니다.

콘솔

다음 예시에서는 Google Cloud 콘솔을 사용하여 us-central1-a 영역에 있는 기존 영역 영구 디스크에서 파일을 읽는 스크립트를 실행하는 작업을 만듭니다. 예시 스크립트는 루트 디렉터리에 example.txt라는 텍스트 파일이 포함된 기존 영역 영구 디스크가 작업에 있다고 가정합니다.

선택사항: 영역 영구 디스크 예시 만들기

예시 스크립트를 실행하는 데 사용할 수 있는 영역 영구 디스크를 만들려면 작업을 만들기 전에 다음을 수행합니다.

  1. example-disk라는 새로운 빈 영구 디스크를 us-central1-a 영역의 Linux VM에 연결한 후 VM에서 명령어를 실행하여 디스크를 포맷하고 마운트합니다. 자세한 내용은 VM에 영구 디스크 추가를 참조하세요.

    아직 VM에서 연결 해제하지 마세요.

  2. 영구 디스크에 example.txt를 만들려면 VM에서 다음 명령어를 실행합니다.

    1. 현재 작업 디렉터리를 영구 디스크의 루트 디렉터리로 변경하려면 다음 명령어를 입력합니다.

      cd VM_MOUNT_PATH

      VM_MOUNT_PATH를 이전 단계에서 영구 디스크를 이 VM에 마운트한 디렉터리의 경로로 바꿉니다(예: /mnt/disks/example-disk).

    2. Enter 키를 누릅니다.

    3. example.txt라는 파일을 만들어 정의하려면 다음 명령어를 입력합니다.

      cat > example.txt

    4. Enter 키를 누릅니다.

    5. 파일 콘텐츠를 입력합니다. 예를 들어 Hello world!를 입력합니다.

    6. 파일을 저장하려면 Ctrl+D(또는 macOS의 경우 Command+D)를 누릅니다.

    완료되면 VM에서 연결 해제할 수 있습니다.

  3. VM에서 영구 디스크를 분리합니다.

    • VM이 더 이상 필요하지 않으면 VM을 삭제하면 됩니다. 그러면 영구 디스크가 자동으로 분리됩니다.

    • 그렇지 않으면 영구 디스크를 분리하세요. 자세한 내용은 부팅 디스크 분리 및 재연결을 참조하여 VM의 부팅 디스크 대신 example-disk 영구 디스크를 분리하세요.

기존 영역 영구 디스크를 사용하는 작업 만들기

Google Cloud 콘솔을 사용하여 기존 영역 영구 디스크를 사용하는 작업을 만들려면 다음을 수행합니다.

  1. Google Cloud 콘솔에서 작업 목록 페이지로 이동합니다.

    작업 목록으로 이동

  2. 만들기를 클릭합니다. 일괄 작업 만들기 페이지가 열립니다. 왼쪽 창에서 작업 세부정보 페이지가 선택됩니다.

  3. 작업 세부정보 페이지를 구성합니다.

    1. 선택사항: 작업 이름 필드에서 작업 이름을 맞춤설정합니다.

      예를 들어 example-disk-job를 입력합니다.

    2. 태스크 세부정보 섹션을 구성합니다.

      1. 새 실행 가능 항목 창에서 이 작업을 실행할 스크립트 또는 컨테이너를 하나 이상 추가합니다.

        예를 들어 이름이 example.txt이고 이 작업에서 사용하는 영구 디스크의 루트 디렉터리에 있는 파일의 콘텐츠를 출력하는 스크립트를 실행하려면 다음을 수행합니다.

        1. 스크립트 체크박스를 선택합니다. 텍스트 상자가 나타납니다.

        2. 텍스트 상자에 다음 스크립트를 입력합니다.

          echo "Here is the content of the example.txt file in the persistent disk."
cat MOUNT_PATH/example.txt

          MOUNT_PATH를 이 작업의 VM에 영구 디스크를 마운트할 경로로 바꿉니다(예: /mnt/disks/example-disk).

        3. 완료를 클릭합니다.

      2. 태스크 수 필드에 이 작업의 태스크 수를 입력합니다.

        예를 들어 1(기본값)을 입력합니다.

      3. 동시 로드 필드에 동시에 실행할 작업 수를 입력합니다.

        예를 들어 1(기본값)을 입력합니다.

  4. 리소스 사양 페이지를 구성합니다.

    1. 왼쪽 창에서 리소스 사양을 클릭합니다. 리소스 사양 페이지가 열립니다.

    2. 이 작업의 위치를 선택합니다. 기존 영역 영구 디스크를 사용하려면 작업의 VM이 같은 영역에 있어야 합니다.

      1. 리전 필드에서 리전을 선택합니다.

        예를 들어 영역별 영구 디스크 예시를 사용하려면 us-central1 (Iowa)(기본값)을 선택합니다.

      2. 영역 필드에서 영역을 선택합니다.

        예를 들어 us-central1-a (Iowa)를 선택하세요.

  5. 추가 구성 페이지를 구성합니다.

    1. 왼쪽 창에서 추가 구성을 클릭합니다. 추가 구성 페이지가 열립니다.

    2. 이 작업에 마운트하려는 기존 영역 영구 디스크마다 다음을 수행합니다.

      1. 스토리지 볼륨 섹션에서 새 볼륨 추가를 클릭합니다. 새 볼륨 창이 나타납니다.

      2. 새 볼륨 창에서 다음을 수행합니다.

        1. 볼륨 유형 섹션에서 영구 디스크(기본값)를 선택합니다.

        2. 디스크 목록에서 이 작업에 마운트하려는 기존 영역 영구 디스크를 선택합니다. 디스크는 이 작업과 같은 영역에 있어야 합니다.

          예를 들어 준비한 기존 영역 영구 디스크를 선택합니다. 이 디스크는 us-central1-a 영역에 위치하고 example.txt 파일이 포함되어 있습니다.

        3. 선택사항: 이 영역 영구 디스크의 이름을 바꾸려면 다음을 수행합니다.

          1. 기기 이름 맞춤설정을 선택합니다.

          2. 기기 이름 필드에 디스크의 새 이름을 입력합니다.

        4. 마운트 경로 필드에 이 영구 디스크의 마운트 경로(MOUNT_PATH)를 입력합니다.

          예를 들어 다음을 입력합니다.

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

          EXISTING_PERSISTENT_DISK_NAME을 디스크 이름으로 바꿉니다. 영역 영구 디스크 이름을 바꿨으면 새 이름을 사용합니다.

          예를 들어 EXISTING_PERSISTENT_DISK_NAME을 example-disk로 바꿉니다.

        5. 완료를 클릭합니다.

  6. 선택사항: 이 작업의 다른 필드를 구성합니다.

  7. 선택사항: 작업 구성을 검토하려면 왼쪽 창에서 미리보기를 클릭합니다.

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

작업 세부정보 페이지에 자신이 만든 작업이 표시됩니다.

gcloud

다음 예시에서는 gcloud CLI를 사용하여 기존 영구 디스크와 새 영구 디스크를 연결하고 마운트하는 작업을 만듭니다. 작업에는 3개의 태스크가 있으며, 각 태스크는 스크립트를 실행하여 output_task_TASK_INDEX.txt라는 새로운 영구 디스크에 파일을 만듭니다. 여기서 TASK_INDEX는 각 태스크의 색인 0, 1, 2에 해당합니다.

gcloud CLI를 사용하여 영구 디스크를 사용하는 작업을 만들려면 gcloud batch jobs submit 명령어를 사용합니다. 작업의 JSON 구성 파일에서 instances 필드에 영구 디스크를 지정하고 volumes 필드에 영구 디스크를 마운트합니다.

  1. JSON 파일을 만듭니다.

    • 이 작업에 인스턴스 템플릿을 사용하지 않는 경우 다음 콘텐츠로 JSON 파일을 만드세요.

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      다음을 바꿉니다.

      • PROJECT_ID: 프로젝트의 프로젝트 ID
      • EXISTING_PERSISTENT_DISK_NAME: 기존 영구 디스크의 이름
      • EXISTING_PERSISTENT_DISK_LOCATION: 기존 영구 디스크의 위치. 기존 영역별 영구 디스크의 경우 작업 위치가 디스크 영역이어야 합니다. 각각의 기존 리전별 영구 디스크의 경우에는 작업 위치가 디스크 리전이어야 하고, 영역을 지정할 경우에는 리전별 영구 디스크가 위치한 특정 영역 중 하나 또는 모두여야 합니다. 기존 영구 디스크를 지정하지 않는 경우 아무 위치나 선택할 수 있습니다. allowedLocations 필드에 대해 자세히 알아보세요.
      • NEW_PERSISTENT_DISK_SIZE: 새 영구 디스크의 크기(GB)입니다. 허용되는 크기는 영구 디스크 유형에 따라 다르지만 최솟값은 보통 10GB(10)이고 최댓값은 보통 64TB(64000)입니다.
      • NEW_PERSISTENT_DISK_TYPE: 새 영구 디스크의 디스크 유형으로 pd-standard, pd-balanced, pd-ssd, pd-extreme 중 하나입니다. 비부팅 영구 디스크의 기본 디스크 유형은 pd-standard입니다.
      • NEW_PERSISTENT_DISK_NAME: 새 영구 디스크의 이름입니다.

    • 이 작업에 인스턴스 템플릿을 사용하는 경우 instances 필드를 다음과 같이 바꾸는 것을 제외하고는 이전에 표시된 대로 JSON 파일을 만듭니다.

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      여기서 INSTANCE_TEMPLATE_NAME은 이 작업의 인스턴스 템플릿 이름입니다. 영구 디스크를 사용하는 작업의 경우 이 인스턴스 템플릿이 작업에 사용하려는 영구 디스크를 정의하고 연결해야 합니다. 이 예시에서는 템플릿이 NEW_PERSISTENT_DISK_NAME이라는 새 영구 디스크를 정의 및 연결하고 EXISTING_PERSISTENT_DISK_NAME이라는 기존 영구 디스크를 연결해야 합니다.

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

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름입니다.

    • LOCATION: 작업의 위치

    • JSON_CONFIGURATION_FILE: 작업의 구성 세부정보가 포함된 JSON 파일의 경로

API

다음 예시에서는 Batch API를 사용하여 기존 영구 디스크와 새 영구 디스크를 연결하고 마운트하는 작업을 만듭니다. 작업에는 3개의 태스크가 있으며, 각 태스크는 스크립트를 실행하여 output_task_TASK_INDEX.txt라는 새로운 영구 디스크에 파일을 만듭니다. 여기서 TASK_INDEX는 각 태스크의 색인 0, 1, 2에 해당합니다.

Batch API를 사용하여 영구 디스크를 사용하는 작업을 만들려면 jobs.create 메서드를 사용합니다. 요청에서 instances 필드에 영구 디스크를 지정하고 volumes 필드에 영구 디스크를 마운트합니다.

  • 이 작업에 인스턴스 템플릿을 사용하지 않으려면 다음 요청을 수행하세요.

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • PROJECT_ID: 프로젝트의 프로젝트 ID
    • LOCATION: 작업의 위치
    • JOB_NAME: 작업의 이름
    • EXISTING_PERSISTENT_DISK_NAME: 기존 영구 디스크의 이름
    • EXISTING_PERSISTENT_DISK_LOCATION: 기존 영구 디스크의 위치. 기존 영역별 영구 디스크의 경우 작업 위치가 디스크 영역이어야 합니다. 각각의 기존 리전별 영구 디스크의 경우에는 작업 위치가 디스크 리전이어야 하고, 영역을 지정할 경우에는 리전별 영구 디스크가 위치한 특정 영역 중 하나 또는 모두여야 합니다. 기존 영구 디스크를 지정하지 않는 경우 아무 위치나 선택할 수 있습니다. allowedLocations 필드에 대해 자세히 알아보세요.
    • NEW_PERSISTENT_DISK_SIZE: 새 영구 디스크의 크기(GB)입니다. 허용되는 크기는 영구 디스크 유형에 따라 다르지만 최솟값은 보통 10GB(10)이고 최댓값은 보통 64TB(64000)입니다.
    • NEW_PERSISTENT_DISK_TYPE: 새 영구 디스크의 디스크 유형으로 pd-standard, pd-balanced, pd-ssd, pd-extreme 중 하나입니다. 비부팅 영구 디스크의 기본 디스크 유형은 pd-standard입니다.
    • NEW_PERSISTENT_DISK_NAME: 새 영구 디스크의 이름입니다.

  • 이 작업에 인스턴스 템플릿을 사용하는 경우 instances 필드를 다음과 같이 바꾸는 것을 제외하고는 이전에 표시된 대로 JSON 파일을 만듭니다.

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    여기서 INSTANCE_TEMPLATE_NAME은 이 작업의 인스턴스 템플릿 이름입니다. 영구 디스크를 사용하는 작업의 경우 이 인스턴스 템플릿이 작업에 사용하려는 영구 디스크를 정의하고 연결해야 합니다. 이 예시에서는 템플릿이 NEW_PERSISTENT_DISK_NAME이라는 새 영구 디스크를 정의 및 연결하고 EXISTING_PERSISTENT_DISK_NAME이라는 기존 영구 디스크를 연결해야 합니다.

C++

C++용 Cloud 클라이언트 라이브러리를 사용하여 새 영구 디스크 또는 기존 영구 디스크를 사용하는 Batch 작업을 만들려면 CreateJob 함수를 사용하고 다음을 포함합니다.

  • 영구 디스크를 작업의 VM에 연결하려면 다음 중 하나를 포함합니다.
    • 이 작업에 VM 인스턴스 템플릿을 사용하지 않는 경우 set_remote_path 메서드를 사용합니다.
    • 이 작업에 VM 인스턴스 템플릿을 사용하는 경우 set_instance_template 메서드를 사용합니다.
  • 영구 디스크를 작업에 마운트하려면 volumes 필드를 deviceName 및 mountPath 필드와 함께 사용합니다. 새 영구 디스크의 경우 mountOptions 필드도 사용하여 쓰기를 사용 설정합니다.

유사한 사용 사례의 코드 샘플은 Cloud Storage 버킷 사용을 참조하세요.

Go

Go용 Cloud 클라이언트 라이브러리를 사용하여 새 영구 디스크 또는 기존 영구 디스크를 사용하는 Batch 작업을 만들려면 CreateJob 함수를 사용하고 다음을 포함합니다.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job with persistent disk
func createJobWithPD(w io.Writer, projectID, jobName, pdName string) error {
	// jobName := job-name
	// pdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", pdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: pdName,
		},
	}

	// The disk type of the new persistent disk, either pd-standard,
	// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "pd-balanced",
		SizeGb: 10,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	labels := map[string]string{"env": "testing", "type": "container"}

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: pdName,
						},
					},
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

	created_job, err := batchClient.CreateJob(ctx, request)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)
	return nil
}

자바

자바용 Cloud 클라이언트 라이브러리를 사용하여 새 영구 디스크 또는 기존 영구 디스크를 사용하는 Batch 작업을 만들려면 CreateJobRequest 클래스를 사용하고 다음을 포함합니다.

예를 들어 다음 코드 샘플을 사용하세요.


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.AllocationPolicy.LocationPolicy;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.common.collect.Lists;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreatePersistentDiskJob {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // The size of the new persistent disk in GB.
    // The allowed sizes depend on the type of persistent disk,
    // but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
    int diskSize = 10;
    // The name of the new persistent disk.
    String newPersistentDiskName = "DISK-NAME";
    // The name of an existing persistent disk.
    String existingPersistentDiskName = "EXISTING-DISK-NAME";
    // The location of an existing persistent disk. For more info :
    // https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
    String location = "regions/us-central1";
    // The disk type of the new persistent disk, either pd-standard,
    // pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
    String newDiskType = "pd-balanced";

    createPersistentDiskJob(projectId, region, jobName, newPersistentDiskName,
            diskSize, existingPersistentDiskName, location, newDiskType);
  }

  // Creates a job that attaches and mounts an existing persistent disk and a new persistent disk
  public static Job createPersistentDiskJob(String projectId, String region, String jobName,
                                            String newPersistentDiskName, int diskSize,
                                            String existingPersistentDiskName,
                                            String location, String newDiskType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      String text = "echo Hello world from task ${BATCH_TASK_INDEX}. "
              + ">> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt";
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(text)
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addAllVolumes(volumes(newPersistentDiskName, existingPersistentDiskName))
              .addRunnables(runnable)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define the type of virtual machines the tasks will run on.
      InstancePolicy policy = InstancePolicy.newBuilder()
              .addAllDisks(attachedDisks(newPersistentDiskName, diskSize, newDiskType,
                  projectId, location, existingPersistentDiskName))
              .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy))
                  .setLocation(LocationPolicy.newBuilder().addAllowedLocations(location))
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out-of-the-box option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }

  // Creates link to existing disk and creates configuration for new disk
  private static Iterable<AttachedDisk> attachedDisks(String newPersistentDiskName, int diskSize,
                                                      String newDiskType, String projectId,
                                                      String existingPersistentDiskLocation,
                                                      String existingPersistentDiskName) {
    AttachedDisk newDisk = AttachedDisk.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setNewDisk(Disk.newBuilder().setSizeGb(diskSize).setType(newDiskType))
            .build();

    String diskPath = String.format("projects/%s/%s/disks/%s", projectId,
            existingPersistentDiskLocation, existingPersistentDiskName);

    AttachedDisk existingDisk = AttachedDisk.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setExistingDisk(diskPath)
            .build();

    return Lists.newArrayList(existingDisk, newDisk);
  }

  // Describes a volume and parameters for it to be mounted to a VM.
  private static Iterable<Volume> volumes(String newPersistentDiskName,
                                          String existingPersistentDiskName) {
    Volume newVolume = Volume.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setMountPath("/mnt/disks/" + newPersistentDiskName)
            .addMountOptions("rw")
            .addMountOptions("async")
            .build();

    Volume existingVolume = Volume.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setMountPath("/mnt/disks/" + existingPersistentDiskName)
            .build();

    return Lists.newArrayList(newVolume, existingVolume);
  }
}

Node.js

Node.js용 Cloud 클라이언트 라이브러리를 사용하여 새 영구 디스크 또는 기존 영구 디스크를 사용하는 Batch 작업을 만들려면 createJob 메서드를 사용하고 다음을 포함합니다.

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-create-persistent-disk-job';
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of an existing persistent disk.
const existingPersistentDiskName = 'existing-persistent-disk-name';
// The name of the new persistent disk.
const newPersistentDiskName = 'new-persistent-disk-name';
// The size of the new persistent disk in GB.
// The allowed sizes depend on the type of persistent disk,
// but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
const diskSize = 10;
// The location of an existing persistent disk. For more info :
// https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
const location = 'regions/us-central1';
// The disk type of the new persistent disk, either pd-standard,
// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
const newDiskType = 'pd-balanced';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: [
      '-c',
      'echo Hello world! This is task ${BATCH_TASK_INDEX}.' +
        '>> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define volumes and their parameters to be mounted to a VM.
const newVolume = new batch.Volume({
  deviceName: newPersistentDiskName,
  mountPath: `/mnt/disks/${newPersistentDiskName}`,
  mountOptions: ['rw', 'async'],
});

const existingVolume = new batch.Volume({
  deviceName: existingPersistentDiskName,
  mountPath: `/mnt/disks/${existingPersistentDiskName}`,
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  volumes: [newVolume, existingVolume],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

const newDisk = new batch.AllocationPolicy.Disk({
  type: newDiskType,
  sizeGb: diskSize,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  disks: [
    // Create configuration for new disk
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: newPersistentDiskName,
      newDisk,
    }),
    // Create link to existing disk
    new batch.AllocationPolicy.AttachedDisk({
      existingDisk: `projects/${projectId}/${location}/disks/${existingPersistentDiskName}`,
      deviceName: existingPersistentDiskName,
    }),
  ],
});

const locationPolicy = new batch.AllocationPolicy.LocationPolicy({
  allowedLocations: [location],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
  location: locationPolicy,
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchPersistentDiskJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchPersistentDiskJob();

Python

Python용 Cloud 클라이언트 라이브러리를 사용하여 새 영구 디스크 또는 기존 영구 디스크를 사용하는 Batch 작업을 만들려면 CreateJob 함수를 사용하고 다음을 포함합니다.

  • 영구 디스크를 작업의 VM에 연결하려면 다음 중 하나를 포함합니다.
  • 영구 디스크를 작업에 마운트하려면 device_name 속성 및 mount_path 속성과 함께 Volume 클래스를 사용합니다. 새 영구 디스크의 경우 mount_options 속성도 사용하여 쓰기를 사용 설정합니다.

예를 들어 다음 코드 샘플을 사용하세요.

from google.cloud import batch_v1


def create_with_pd_job(
    project_id: str,
    region: str,
    job_name: str,
    disk_name: str,
    zone: str,
    existing_disk_name=None,
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances with mounted persistent disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        disk_name: name of the disk to be mounted for your Job.
        existing_disk_name(optional): existing disk name, which you want to attach to a job

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = (
        "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/"
        + disk_name
        + "/output_task_${BATCH_TASK_INDEX}.txt"
    )
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = disk_name
    volume.mount_path = f"/mnt/disks/{disk_name}"
    task.volumes = [volume]

    if existing_disk_name:
        volume2 = batch_v1.Volume()
        volume2.device_name = existing_disk_name
        volume2.mount_path = f"/mnt/disks/{existing_disk_name}"
        task.volumes.append(volume2)

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    disk = batch_v1.AllocationPolicy.Disk()
    # The disk type of the new persistent disk, either pd-standard,
    # pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
    disk.type_ = "pd-balanced"
    disk.size_gb = 10

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-1"

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = disk_name
    policy.disks = [attached_disk]

    if existing_disk_name:
        attached_disk2 = batch_v1.AllocationPolicy.AttachedDisk()
        attached_disk2.existing_disk = (
            f"projects/{project_id}/zones/{zone}/disks/{existing_disk_name}"
        )
        attached_disk2.device_name = existing_disk_name
        policy.disks.append(attached_disk2)

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy

    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = [f"zones/{zone}"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

로컬 SSD 사용

로컬 SSD를 사용하는 작업에는 다음과 같은 제한사항이 있습니다.

gcloud CLI, Batch API, Java 또는 Python을 사용하여 로컬 SSD를 사용하는 작업을 만들 수 있습니다. 다음 예시에서는 로컬 SSD를 만들고, 연결, 마운트하는 작업을 만드는 방법을 설명합니다. 또한 이 작업에는 3개의 태스크가 있으며, 각 태스크는 스크립트를 실행하여 output_task_TASK_INDEX.txt라는 로컬 SSD에 파일을 만듭니다. 여기서 TASK_INDEX는 각 태스크 0, 1, 2의 색인입니다.

gcloud

gcloud CLI를 사용하여 로컬 SSD를 사용하는 작업을 만들려면 gcloud batch jobs submit 명령어를 사용합니다. 작업의 JSON 구성 파일에서 instances 필드에 로컬 SS를 만들어 연결하고 volumes 필드에 로컬 SSD를 마운트합니다.

  1. JSON 파일을 만듭니다.

    • 이 작업에 인스턴스 템플릿을 사용하지 않는 경우 다음 콘텐츠로 JSON 파일을 만드세요.

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      다음을 바꿉니다.

      • MACHINE_TYPE: 작업의 VM에 대해 사전 정의되거나 커스텀일 수 있는 머신 유형. 허용되는 로컬 SSD 수는 작업 VM의 머신 유형에 따라 다릅니다.
      • LOCAL_SSD_NAME: 이 작업에 대해 생성된 로컬 SSD의 이름
      • LOCAL_SSD_SIZE: 모든 로컬 SSD의 크기(GB). 각 로컬 SSD는 375GB이므로 이 값은 375GB의 배수여야 합니다. 예를 들어 2개의 로컬 SSD의 경우 이 값을 750GB로 설정합니다.

    • 이 작업에 인스턴스 템플릿을 사용하는 경우 instances 필드를 다음과 같이 바꾸는 것을 제외하고는 이전에 표시된 대로 JSON 파일을 만듭니다.

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      여기서 INSTANCE_TEMPLATE_NAME은 이 작업의 인스턴스 템플릿 이름입니다. 로컬 SSD를 사용하는 작업의 경우 이 인스턴스 템플릿은 작업에 사용하려는 로컬 SSD를 정의하고 연결해야 합니다. 이 예시에서는 템플릿이 LOCAL_SSD_NAME이라는 로컬 SSD를 정의하고 연결해야 합니다.

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

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름입니다.
    • LOCATION: 작업의 위치
    • JSON_CONFIGURATION_FILE: 작업의 구성 세부정보가 포함된 JSON 파일의 경로

API

Batch API를 사용하여 로컬 SSD를 사용하는 작업을 만들려면 jobs.create 메서드를 사용합니다. 요청에서 instances 필드에 로컬 SSD를 생성하여 연결하고 volumes 필드에 로컬 SSD를 마운트합니다.

  • 이 작업에 인스턴스 템플릿을 사용하지 않으려면 다음 요청을 수행하세요.

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • PROJECT_ID: 프로젝트의 프로젝트 ID
    • LOCATION: 작업의 위치
    • JOB_NAME: 작업의 이름
    • MACHINE_TYPE: 작업의 VM에 대해 사전 정의되거나 커스텀일 수 있는 머신 유형. 허용되는 로컬 SSD 수는 작업 VM의 머신 유형에 따라 다릅니다.
    • LOCAL_SSD_NAME: 이 작업에 대해 생성된 로컬 SSD의 이름
    • LOCAL_SSD_SIZE: 모든 로컬 SSD의 크기(GB). 각 로컬 SSD는 375GB이므로 이 값은 375GB의 배수여야 합니다. 예를 들어 2개의 로컬 SSD의 경우 이 값을 750GB로 설정합니다.

  • 이 작업에 인스턴스 템플릿을 사용하는 경우 instances 필드를 다음과 같이 바꾸는 것을 제외하고는 이전에 표시된 대로 JSON 파일을 만듭니다.

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    여기서 INSTANCE_TEMPLATE_NAME은 이 작업의 인스턴스 템플릿 이름입니다. 로컬 SSD를 사용하는 작업의 경우 이 인스턴스 템플릿은 작업에 사용하려는 로컬 SSD를 정의하고 연결해야 합니다. 이 예시에서는 템플릿이 LOCAL_SSD_NAME이라는 로컬 SSD를 정의하고 연결해야 합니다.

Go

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job with local SSD
// Note: local SSD does not guarantee Local SSD data persistence.
// More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence
func createJobWithSSD(w io.Writer, projectID, jobName, ssdName string) error {
	// jobName := job-name
	// ssdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", ssdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: ssdName,
		},
	}

	// The size of all the local SSDs in GB. Each local SSD is 375 GB,
	// so this value must be a multiple of 375 GB.
	// For example, for 2 local SSDs, set this value to 750 GB.
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "local-ssd",
		SizeGb: 375,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	labels := map[string]string{"env": "testing", "type": "container"}

	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					// The allowed number of local SSDs depends on the machine type for your job's VMs.
					// In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
					// Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: ssdName,
						},
					},
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

	created_job, err := batchClient.CreateJob(ctx, request)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)
	return nil
}

자바 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateLocalSsdJob {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // The name of a local SSD created for this job.
    String localSsdName = "SSD-NAME";
    // The machine type, which can be predefined or custom, of the job's VMs.
    // The allowed number of local SSDs depends on the machine type
    // for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
    String machineType = "c3d-standard-8-lssd";
    // The size of all the local SSDs in GB. Each local SSD is 375 GB,
    // so this value must be a multiple of 375 GB.
    // For example, for 2 local SSDs, set this value to 750 GB.
    int ssdSize = 375;

    createLocalSsdJob(projectId, region, jobName, localSsdName, ssdSize, machineType);
  }

  // Create a job that uses local SSDs
  public static Job createLocalSsdJob(String projectId, String region, String jobName,
                                      String localSsdName, int ssdSize, String machineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      Volume volume = Volume.newBuilder()
          .setDeviceName(localSsdName)
          .setMountPath("/mnt/disks/" + localSsdName)
          .addMountOptions("rw")
          .addMountOptions("async")
          .build();

      TaskSpec task = TaskSpec.newBuilder()
          // Jobs can be divided into tasks. In this case, we have only one task.
          .addVolumes(volume)
          .addRunnables(runnable)
          .setMaxRetryCount(2)
          .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
          .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      InstancePolicy policy = InstancePolicy.newBuilder()
          .setMachineType(machineType)
          .addDisks(AttachedDisk.newBuilder()
              .setDeviceName(localSsdName)
              // For example, local SSD uses type "local-ssd".
              // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
              // or "pd-standard".
              .setNewDisk(Disk.newBuilder().setSizeGb(ssdSize).setType("local-ssd")))
          .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-local-ssd-job';
// The name of a local SSD created for this job.
const localSsdName = 'ssd-name';
// The machine type, which can be predefined or custom, of the job's VMs.
// The allowed number of local SSDs depends on the machine type
// for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
const machineType = 'c3d-standard-8-lssd';
// The size of all the local SSDs in GB. Each local SSD is 375 GB,
// so this value must be a multiple of 375 GB.
// For example, for 2 local SSDs, set this value to 750 GB.
const ssdSize = 375;

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: [
      '-c',
      'echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
    ],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  disks: [
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: localSsdName,
      // For example, local SSD uses type "local-ssd".
      // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
      // or "pd-standard".
      newDisk: new batch.AllocationPolicy.AttachedDisk({
        type: 'local-ssd',
        sizeGb: ssdSize,
      }),
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_local_ssd_job(
    project_id: str, region: str, job_name: str, ssd_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances with mounted local SSD.
    Note: local SSD does not guarantee Local SSD data persistence.
    More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        ssd_name: name of the local ssd to be mounted for your Job.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = ssd_name
    volume.mount_path = f"/mnt/disks/{ssd_name}"
    task.volumes = [volume]

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    disk = batch_v1.AllocationPolicy.Disk()
    disk.type_ = "local-ssd"
    # The size of all the local SSDs in GB. Each local SSD is 375 GB,
    # so this value must be a multiple of 375 GB.
    # For example, for 2 local SSDs, set this value to 750 GB.
    disk.size_gb = 375
    assert disk.size_gb % 375 == 0

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # The allowed number of local SSDs depends on the machine type for your job's VMs.
    # In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-1"

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = ssd_name
    policy.disks = [attached_disk]

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy

    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Cloud Storage 버킷 사용

기존 Cloud Storage 버킷을 사용하는 작업을 만들려면 다음 방법 중 하나를 선택합니다.

  • 권장사항: 이 섹션에 나와 있는 것처럼 작업 정의에 버킷을 지정하여 작업의 VM에 버킷을 직접 마운트합니다. 작업이 실행되면 Cloud Storage FUSE를 사용하여 작업의 VM에 버킷이 자동으로 마운트됩니다.
  • gcloud CLI 또는 Cloud Storage API용 클라이언트 라이브러리를 사용하여 Cloud Storage 버킷에 직접 액세스하는 태스크로 작업을 만듭니다. VM에서 직접 Cloud Storage 버킷에 액세스하는 방법은 Cloud Storage 버킷에서 데이터 읽기 및 읽기에 대한 Compute Engine 문서를 참조하세요.

버킷을 사용하는 작업을 만들기 전에 버킷을 만들거나 기존 버킷을 식별합니다. 자세한 내용은 버킷 만들기 및 버킷 나열을 참조하세요.

Google Cloud 콘솔, gcloud CLI, Batch API, C++, Go, 자바, Node.js 또는 Python을 사용하여 Cloud Storage 버킷을 사용하는 작업을 만들 수 있습니다.

다음 예시에서는 Cloud Storage 버킷을 마운트하는 작업을 만드는 방법을 설명합니다. 또한 이 작업에는 3개의 태스크가 있으며, 각 태스크는 스크립트를 실행하여 output_task_TASK_INDEX.txt라는 버킷에 파일을 만듭니다. 여기서 TASK_INDEX는 각 태스크 색인 0, 1, 2입니다.

콘솔

Google Cloud 콘솔을 사용하여 Cloud Storage 버킷을 사용하는 작업을 만들려면 다음을 수행합니다.

  1. Google Cloud 콘솔에서 작업 목록 페이지로 이동합니다.

    작업 목록으로 이동

  2. 만들기를 클릭합니다. 일괄 작업 만들기 페이지가 열립니다. 왼쪽 창에서 작업 세부정보 페이지가 선택됩니다.

  3. 작업 세부정보 페이지를 구성합니다.

    1. 선택사항: 작업 이름 필드에서 작업 이름을 맞춤설정합니다.

      예를 들어 example-bucket-job를 입력합니다.

    2. 태스크 세부정보 섹션을 구성합니다.

      1. 새 실행 가능 항목 창에서 이 작업을 실행할 스크립트 또는 컨테이너를 하나 이상 추가합니다.

        예를 들어 다음을 수행합니다.

        1. 스크립트 체크박스를 선택합니다. 텍스트 상자가 나타납니다.

        2. 텍스트 상자에 다음 스크립트를 입력합니다.

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          MOUNT_PATH를 이 작업의 실행 가능 항목에서 기존 Cloud Storage 버킷에 액세스하는 데 사용하는 마운트 경로로 바꿉니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 버킷을 my-bucket이라는 디렉터리로 표시하려면 마운트 경로를 /mnt/disks/my-bucket으로 설정합니다.

        3. 완료를 클릭합니다.

      2. 태스크 수 필드에 이 작업의 태스크 수를 입력합니다.

        예를 들어 3를 입력합니다.

      3. 동시 로드 필드에 동시에 실행할 작업 수를 입력합니다.

        예를 들어 1(기본값)을 입력합니다.

  4. 추가 구성 페이지를 구성합니다.

    1. 왼쪽 창에서 추가 구성을 클릭합니다. 추가 구성 페이지가 열립니다.

    2. 이 작업에 마운트할 각 Cloud Storage 버킷에 대해 다음을 수행합니다.

      1. 스토리지 볼륨 섹션에서 새 볼륨 추가를 클릭합니다. 새 볼륨 창이 나타납니다.

      2. 새 볼륨 창에서 다음을 수행합니다.

        1. 볼륨 유형 섹션에서 Cloud Storage 버킷을 선택합니다.

        2. 스토리지 버킷 이름 필드에 기존 버킷 이름을 입력합니다.

          예를 들어 이 작업의 실행 가능 항목에 지정된 버킷을 입력합니다.

        3. 마운트 경로 필드에 실행 파일에 지정된 버킷의 마운트 경로(MOUNT_PATH)를 입력합니다.

        4. 완료를 클릭합니다.

  5. 선택사항: 이 작업의 다른 필드를 구성합니다.

  6. 선택사항: 작업 구성을 검토하려면 왼쪽 창에서 미리보기를 클릭합니다.

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

작업 세부정보 페이지에 자신이 만든 작업이 표시됩니다.

gcloud

gcloud CLI를 사용하여 Cloud Storage 버킷을 사용하는 작업을 만들려면 gcloud batch jobs submit 명령어를 사용합니다. 작업의 JSON 구성 파일에서 volumes 필드에 버킷을 마운트합니다.

예를 들어 Cloud Storage에 파일을 출력하는 작업을 만들려면 다음 안내를 따르세요.

  1. 다음 콘텐츠로 JSON 파일을 만듭니다.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • BUCKET_PATH: 이 작업에서 액세스할 버킷 디렉터리의 경로이며 버킷 이름으로 시작해야 합니다. 예를 들어 이름이 BUCKET_NAME인 버킷의 경우 BUCKET_NAME 경로는 버킷의 루트 디렉터리를 나타내고 BUCKET_NAME/subdirectory 경로는 subdirectory 하위 디렉터리를 나타냅니다.
    • MOUNT_PATH: 작업의 실행 가능 항목이 이 버킷에 액세스하는 데 사용하는 마운트 경로입니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 버킷을 my-bucket이라는 디렉터리로 표시하려면 마운트 경로를 /mnt/disks/my-bucket으로 설정합니다.

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

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름입니다.
    • LOCATION: 작업의 위치
    • JSON_CONFIGURATION_FILE: 작업의 구성 세부정보가 포함된 JSON 파일의 경로

API

Batch API를 사용하여 Cloud Storage 버킷을 사용하는 작업을 만들려면 jobs.create 메서드를 사용하고 volumes 필드에 버킷을 마운트합니다.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트의 프로젝트 ID
  • LOCATION: 작업의 위치
  • JOB_NAME: 작업의 이름
  • BUCKET_PATH: 이 작업에서 액세스할 버킷 디렉터리의 경로. 버킷 이름으로 시작해야 합니다. 예를 들어 이름이 BUCKET_NAME인 버킷의 경우 BUCKET_NAME 경로는 버킷의 루트 디렉터리를 나타내고 BUCKET_NAME/subdirectory 경로는 subdirectory 하위 디렉터리를 나타냅니다.
  • MOUNT_PATH: 작업의 실행 가능 항목이 이 버킷에 액세스하는 데 사용하는 마운트 경로입니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 버킷을 my-bucket이라는 디렉터리로 표시하려면 마운트 경로를 /mnt/disks/my-bucket으로 설정합니다.

C++

C++

자세한 내용은 Batch C++ API 참고 문서를 확인하세요.

Batch에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요. 

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id, std::string const& bucket_name) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it, and then override the GCS remote path.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Go

Go

자세한 내용은 Batch Go API 참고 문서를 확인하세요.

Batch에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요. 

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Volumes:       []*batchpb.Volume{volume},
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// In this case, we tell the system to use "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

자바

Java

자세한 내용은 Batch Java API 참고 문서를 확인하세요.

Batch에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요. 

import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.GCS;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithMountedBucket {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .addVolumes(volume)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());
    }
  }
}

Node.js

Node.js

자세한 내용은 Batch Node.js API 참고 문서를 확인하세요.

Batch에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요. 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_NAME';

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  'echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// You can also run a script from a file. Just remember, that needs to be a script that's
// already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
// exclusive.
// runnable.script.path = '/tmp/test.sh'
task.runnables = [runnable];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = task;

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.logsPolicy.destination = batch.LogsPolicy.Destination.CLOUD_LOGGING;

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const response = await batchClient.createJob(request);
  console.log(response);
}

await callCreateJob();

Python

Python

자세한 내용은 Batch Python API 참고 문서를 확인하세요.

Batch에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요. 

from google.cloud import batch_v1


def create_script_job_with_bucket(
    project_id: str, region: str, job_name: str, bucket_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        bucket_name: name of the bucket to be mounted for your Job.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = "/mnt/share"
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
    resources.memory_mib = 16
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script", "mount": "bucket"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

네트워크 파일 시스템 사용

Google Cloud 콘솔, gcloud CLI 또는 Batch API를 사용하여 Filestore 파일 공유와 같은 기존 네트워크 파일 시스템(NFS)을 사용하는 작업을 만들 수 있습니다.

NFS를 사용하는 작업을 만들기 전에 작업의 VM과 NFS 사이에 트래픽을 허용하도록 네트워크 방화벽이 올바르게 구성되었는지 확인합니다. 자세한 내용은 Filestore의 방화벽 규칙 구성을 참조하세요.

다음 예시는 NFS를 지정하고 마운트하는 작업을 만드는 방법을 설명합니다. 또한 이 작업에는 3개의 태스크가 있으며, 각 태스크는 스크립트를 실행하여 output_task_TASK_INDEX.txt라는 NFS에 파일을 만듭니다. 여기서 TASK_INDEX는 각 태스크 0, 1, 2의 색인입니다.

콘솔

Google Cloud 콘솔을 사용하여 NFS를 사용하는 작업을 만들려면 다음을 수행합니다.

  1. Google Cloud 콘솔에서 작업 목록 페이지로 이동합니다.

    작업 목록으로 이동

  2. 만들기를 클릭합니다. 일괄 작업 만들기 페이지가 열립니다. 왼쪽 창에서 작업 세부정보 페이지가 선택됩니다.

  3. 작업 세부정보 페이지를 구성합니다.

    1. 선택사항: 작업 이름 필드에서 작업 이름을 맞춤설정합니다.

      예를 들어 example-nfs-job를 입력합니다.

    2. 태스크 세부정보 섹션을 구성합니다.

      1. 새 실행 가능 항목 창에서 이 작업을 실행할 스크립트 또는 컨테이너를 하나 이상 추가합니다.

        예를 들어 다음을 수행합니다.

        1. 스크립트 체크박스를 선택합니다. 텍스트 상자가 나타납니다.

        2. 텍스트 상자에 다음 스크립트를 입력합니다.

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          MOUNT_PATH를 작업에서 실행 가능한 NFS에 액세스하는 데 사용하는 마운트 경로로 바꿉니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 NFS를 my-nfs라는 디렉터리로 나타내려면 마운트 경로를 /mnt/disks/my-nfs로 설정합니다.

        3. 완료를 클릭합니다.

      2. 태스크 수 필드에 이 작업의 태스크 수를 입력합니다.

        예를 들어 3를 입력합니다.

      3. 동시 로드 필드에 동시에 실행할 작업 수를 입력합니다.

        예를 들어 1(기본값)을 입력합니다.

  4. 추가 구성 페이지를 구성합니다.

    1. 왼쪽 창에서 추가 구성을 클릭합니다. 추가 구성 페이지가 열립니다.

    2. 이 작업에 마운트할 각 Cloud Storage 버킷에 대해 다음을 수행합니다.

      1. 스토리지 볼륨 섹션에서 새 볼륨 추가를 클릭합니다. 새 볼륨 창이 나타납니다.

      2. 새 볼륨 창에서 다음을 수행합니다.

        1. 볼륨 유형 섹션에서 네트워크 파일 시스템을 선택합니다.

        2. 파일 서버 필드에 이 작업의 실행 가능한 항목에 지정된 NFS가 있는 서버의 IP 주소를 입력합니다.

          예를 들어 NFS가 Filestore 파일 공유인 경우 Filestore 인스턴스를 기술하여 가져올 Filestore 인스턴스의 IP 주소를 지정할 수 있습니다.

        3. 원격 경로 필드에 이전 단계에서 지정한 NFS에 액세스할 수 있는 경로를 입력합니다.

          NFS 디렉터리 경로는 /로 시작하고 그 뒤에 NFS 루트 디렉터리가 와야 합니다.

        4. 마운트 경로 필드에 이전 단계에서 지정한 NFS의 마운트 경로(MOUNT_PATH)를 입력합니다.

    3. 완료를 클릭합니다.

  5. 선택사항: 이 작업의 다른 필드를 구성합니다.

  6. 선택사항: 작업 구성을 검토하려면 왼쪽 창에서 미리보기를 클릭합니다.

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

작업 세부정보 페이지에 자신이 만든 작업이 표시됩니다.

gcloud

gcloud CLI를 사용하여 NFS를 사용하는 작업을 만들려면 gcloud batch jobs submit 명령어를 사용합니다. 작업의 JSON 구성 파일에서 volumes 필드에 NFS를 마운트합니다.

  1. 다음 콘텐츠로 JSON 파일을 만듭니다.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • NFS_IP_ADDRESS: NFS의 IP 주소입니다. 예를 들어 NFS가 Filestore 파일 공유인 경우 Filestore 인스턴스를 기술하여 Filestore 인스턴스의 IP 주소를 지정할 수 있습니다.
    • NFS_PATH: 이 작업에서 액세스할 NFS 디렉터리의 경로이며 /로 시작한 다음 NFS의 루트 디렉터리가 와야 합니다. 예를 들어 FILE_SHARE_NAME이라는 Filestore 파일 공유의 경우 /FILE_SHARE_NAME 경로는 파일 공유의 루트 디렉터리를 나타내고 /FILE_SHARE_NAME/subdirectory 경로는 subdirectory 하위 디렉터리를 나타냅니다.
    • MOUNT_PATH: 작업의 실행 가능 항목이 이 NFS에 액세스하는 데 사용하는 마운트 경로입니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 NFS를 my-nfs라는 디렉터리로 나타내려면 마운트 경로를 /mnt/disks/my-nfs로 설정합니다.

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

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름입니다.
    • LOCATION: 작업의 위치
    • JSON_CONFIGURATION_FILE: 작업의 구성 세부정보가 포함된 JSON 파일의 경로

API

Batch API를 사용하여 NFS를 사용하는 작업을 만들려면 jobs.create 메서드를 사용하고 volumes 필드에 NFS를 마운트합니다.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

   {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트의 프로젝트 ID
  • LOCATION: 작업의 위치
  • JOB_NAME: 작업의 이름
  • NFS_IP_ADDRESS: 네트워크 파일 시스템의 IP 주소. 예를 들어 NFS가 Filestore 파일 공유인 경우 Filestore 인스턴스를 기술하여 Filestore 인스턴스의 IP 주소를 지정할 수 있습니다.
  • NFS_PATH: 이 작업에서 액세스할 NFS 디렉터리의 경로이며 /로 시작한 다음 NFS의 루트 디렉터리가 와야 합니다. 예를 들어 FILE_SHARE_NAME이라는 Filestore 파일 공유의 경우 /FILE_SHARE_NAME 경로는 파일 공유의 루트 디렉터리를 나타내고 /FILE_SHARE_NAME/subdirectory 경로는 하위 디렉터리를 나타냅니다.
  • MOUNT_PATH: 작업의 실행 가능 항목이 이 NFS에 액세스하는 데 사용하는 마운트 경로입니다. 경로는 /mnt/disks/로 시작한 다음 선택한 디렉터리 또는 경로가 와야 합니다. 예를 들어 이 NFS를 my-nfs라는 디렉터리로 나타내려면 마운트 경로를 /mnt/disks/my-nfs로 설정합니다.

자바


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.NFS;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateScriptJobWithNfs {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    // The path of the NFS directory that you want this job to access.
    String nfsPath = "NFS_PATH";
    // The IP address of the Network File System.
    String nfsIpAddress = "NFS_IP_ADDRESS";

    createScriptJobWithNfs(projectId, region, jobName, nfsPath, nfsIpAddress);
  }

  // This method shows how to create a batch script job that specifies and mounts a NFS.
  public static Job createScriptJobWithNfs(String projectId, String region, String jobName,
                                            String nfsPath, String nfsIpAddress)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Runnable.Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      // Describes a volume and parameters for it to be mounted to a VM.
      Volume volume = Volume.newBuilder()
          .setNfs(NFS.newBuilder()
              .setServer(nfsIpAddress)
              .setRemotePath(nfsPath)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .addVolumes(volume)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here:
      // https://cloud.google.com/compute/docs/machine-types
      AllocationPolicy.InstancePolicy instancePolicy =
          AllocationPolicy.InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(AllocationPolicy.InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(LogsPolicy.newBuilder()
                      .setDestination(LogsPolicy.Destination.CLOUD_LOGGING).build())
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-nfs-job';
// The path of the NFS directory that you want this job to access.
const nfsPath = '/your_nfs_path';
// The IP address of the Network File System.
const nfsIpAddress = '0.0.0.0';
// The mount path that the job's tasks use to access the NFS.
const mountPath = '/mnt/disks';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: [
      '-c',
      'echo Hello world from task ${BATCH_TASK_INDEX}. >> ' +
        '/mnt/share/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define a volume that uses NFS.
const volume = new batch.Volume({
  nfs: new batch.NFS({
    server: nfsIpAddress,
    remotePath: nfsPath,
  }),
  mountPath,
});

// Specify what resources are requested by each task.
const computeResource = new batch.ComputeResource({
  // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
  cpuMilli: 500,
  // In MiB.
  memoryMib: 16,
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  volumes: [volume],
  computeResource,
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType: 'e2-standard-4',
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  allocationPolicy,
  labels: {env: 'testing', type: 'script'},
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchNfsJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchNfsJob();

Python 

from google.cloud import batch_v1


def create_job_with_network_file_system(
    project_id: str,
    region: str,
    job_name: str,
    mount_path: str,
    nfs_ip_address: str,
    nfs_path: str,
) -> batch_v1.Job:
    """
    Creates a Batch job with status events that mounts a Network File System (NFS).
    Function mounts an NFS volume using the provided NFS server, IP address and path.

    Args:
        project_id (str): project ID or project number of the Cloud project you want to use.
        region (str): name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/locations
        job_name (str): the name of the job that will be created.
            It needs to be unique for each project and region pair.
        mount_path (str): The mount path that the job's tasks use to access the NFS.
        nfs_ip_address (str): The IP address of the NFS server (e.g., Filestore instance).
            Documentation on how to create a
            Filestore instance is available here: https://cloud.google.com/filestore/docs/create-instance-gcloud
        nfs_path (str): The path of the NFS directory that the job accesses.
            The path must start with a / followed by the root directory of the NFS.

    Returns:
        batch_v1.Job: The created Batch job object containing configuration details.
    """
    client = batch_v1.BatchServiceClient()

    # Create a runnable with a script that writes a message to a file
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = f"echo Hello world from task ${{BATCH_TASK_INDEX}}. >> {mount_path}/output_task_${{BATCH_TASK_INDEX}}.txt"

    # Define a volume that uses NFS
    volume = batch_v1.Volume()
    volume.nfs = batch_v1.NFS(server=nfs_ip_address, remote_path=nfs_path)
    volume.mount_path = mount_path

    # Create a task specification and assign the runnable and volume to it
    task = batch_v1.TaskSpec()
    task.runnables = [runnable]
    task.volumes = [volume]

    # Specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Create a task group and assign the task specification to it
    group = batch_v1.TaskGroup()
    group.task_count = 1
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    # Create the job and assign the task group and allocation policy to it
    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    # Create the job request and set the job and job ID
    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

다음 단계