GPU를 사용하는 작업 만들기 및 실행

이 문서에서는 그래픽 처리 장치(GPU)를 사용하는 작업을 만들고 실행하는 방법을 설명합니다. GPU의 기능 및 제한사항에 관한 자세한 내용은 Compute Engine 문서의 GPU 정보를 참고하세요.

Batch 작업을 만들 때 원하는 경우 GPU를 사용하여 특정 워크로드를 가속화할 수 있습니다. GPU를 사용하는 작업의 일반적인 사용 사례에는 집중적인 데이터 처리 및 머신러닝 (ML)과 같은 인공지능 워크로드 (AI)가 있습니다.

시작하기 전에

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

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

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

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

GPU를 사용하는 작업 만들기

GPU를 사용하는 작업을 만들려면 다음을 수행합니다.

  1. GPU를 사용하는 작업의 요구사항 계획
  2. 식별한 요구사항 및 방법으로 작업 만들기. 권장 옵션을 사용하여 작업을 만드는 방법의 예시는 이 문서의 GPU를 사용하는 작업 예시 만들기를 참고하세요.

GPU를 사용하는 작업의 요구사항 계획

GPU를 사용하는 작업을 만들기 전에 다음 섹션에 설명된 대로 작업 요구사항을 계획합니다.

  1. GPU 머신 유형 및 프로비저닝 방법 선택
  2. GPU 드라이버 설치
  3. 호환되는 VM 리소스 정의

1단계: GPU 머신 유형 및 프로비저닝 방법 선택

작업 요구사항은 선호하는 GPU 머신 유형 및 프로비저닝 방법에 따라 다르며 각 옵션은 상호 종속적일 수 있습니다. 요구사항과 우선순위에 따라 GPU 머신 유형을 먼저 선택하거나 프로비저닝 방법을 먼저 선택할 수 있습니다. 일반적으로 GPU 머신 유형은 주로 성능 및 기본 가격에 영향을 미치고 프로비저닝 방법은 주로 리소스 가용성과 추가 비용 또는 할인에 영향을 미칩니다.

GPU 머신 유형 선택

사용 가능한 GPU 머신 유형(GPU 유형, GPU 수, 머신 유형(vCPU 및 메모리)의 유효한 조합) 및 사용 사례는 Compute Engine 문서의 GPU 머신 유형 페이지에 나와 있습니다.

작업에서 GPU 머신 유형을 지정하는 데 필요한 필드는 다음 표의 카테고리에 따라 다릅니다.

GPU 머신 유형 및 작업 요구사항

가속기 최적화 VM용 GPU: 가속기 최적화 머신 계열의 머신 유형을 사용하는 VM에는 이러한 GPU의 특정 유형과 개수가 자동으로 연결됩니다.

가속기 최적화 VM에 GPU를 사용하려면 머신 유형을 지정하는 것이 좋습니다. 각 가속기 최적화 머신 유형은 특정 유형과 개수의 GPU만 지원하므로 가속기 최적화 머신 유형 외에도 이러한 값을 지정하거나 지정하지 않는 것은 기능적으로 동일합니다.

특히 Batch는 가속기 최적화 VM의 GPU 유형과 수만 지정하는 것도 지원하지만, 그 결과 vCPU 및 메모리 옵션이 매우 제한적인 경우가 많습니다. 따라서 사용 가능한 vCPU 및 메모리 옵션이 작업의 태스크 요구사항과 호환되는지 확인하는 것이 좋습니다.

N1 VM용 GPU: 이러한 GPU는 각 VM에 연결할 유형과 개수를 지정해야 하며 N1 머신 시리즈의 머신 유형이 있는 VM에 연결해야 합니다.

N1 VM에 GPU를 사용하려면 GPU 유형과 GPU 수를 적어도 지정하는 것이 좋습니다. 값 조합이 유효한 N1 머신 유형의 GPU 옵션 중 하나와 일치하는지 확인합니다. 특정 유형 및 수의 GPU를 사용하는 N1 VM의 vCPU 및 메모리 옵션은 매우 유연하므로 원하는 경우 Batch가 작업의 태스크 요구사항을 충족하는 머신 유형을 선택하도록 할 수 있습니다.
프로비저닝 방법 선택

Batch는 작업에서 요청하는 리소스 유형에 따라 GPU를 사용하는 작업의 VM 리소스를 프로비저닝하는 데 다양한 방법을 사용합니다. 사용 가능한 프로비저닝 방법과 요구사항은 다음 표에 설명되어 있으며, 이 표에는 사용 사례에 따라 리소스 가용성이 가장 높은 순서부터 가장 낮은 순서로 나열되어 있습니다.

요약하면 대부분의 사용자는 다음을 수행하는 것이 좋습니다.

  • 예약 없이 A3 GPU 머신 유형을 사용하려면 Batch용 동적 워크로드 스케줄러(미리보기)를 사용하세요.

  • 다른 모든 GPU 머신 유형에는 기본 프로비저닝 방법을 사용합니다. 기본 프로비저닝 방법은 일반적으로 주문형입니다. 예외는 프로젝트에 작업이 자동으로 사용할 수 있는 사용되지 않은 예약이 있는 경우입니다.

프로비저닝 방법 및 작업 요구사항

예약

  • 사용 사례: 리소스 가용성을 매우 높은 수준으로 보장하려는 경우 또는 사용하지 않을 수 있는 기존 예약이 이미 있는 경우 작업을 예약하는 것이 좋습니다.

  • 세부정보: 예약을 삭제할 때까지 예약된 VM에는 VM을 실행할 때와 동일한 가격으로 지정된 VM의 비용이 청구됩니다. 예약을 사용하는 VM에는 별도의 비용이 발생하지 않지만 예약에는 사용량과 관계없이 비용이 발생합니다.

일괄 처리는 사용되지 않은 예약을 사용할 수 있는 작업에 예약을 사용합니다. 예약 및 요구사항에 관한 자세한 내용은 VM 예약을 사용하여 리소스 가용성 확보 페이지를 참고하세요.

배치용 동적 워크로드 스케줄러(미리보기)

  • 사용 사례: 예약을 사용하지 않고 A3 머신 시리즈의 머신 유형이 있는 VM에 GPU를 사용하려면 Dynamic Workload Scheduler를 사용하는 것이 좋습니다.

  • 세부정보: 동적 워크로드 스케줄러를 사용하면 AI 및 ML 워크로드를 가속화하는 여러 리소스에 동시에 더 쉽게 액세스할 수 있습니다. 예를 들어 동적 워크로드 스케줄러는 리소스 사용 불가로 인한 지연이나 문제를 완화하여 작업 예약에 도움이 될 수 있습니다.

Batch는 다음 작업을 모두 실행하는 작업에 동적 워크로드 스케줄러를 사용합니다.

  • A3 GPU 머신 유형을 지정합니다.
  • 예약 차단. 특히 작업은 reservation 필드를 NO_RESERVATION로 설정해야 합니다. 자세한 내용은 예약된 VM을 사용할 수 없는 작업 만들기 및 실행을 참고하세요.
  • Spot VM을 사용하지 마세요. 특히 작업은 provisioningModel 필드를 생략하거나 provisioningModel 필드를 STANDARD로 설정할 수 있습니다.

주문형

  • 사용 사례: 다른 모든 작업에는 주문형을 사용하는 것이 좋습니다.

  • 세부정보: 주문형은 일반적으로 Compute Engine VM에 액세스하는 기본 방법입니다. 주문형을 사용하면 한 번에 하나의 VM씩 리소스를 요청하고(가능한 경우) 즉시 액세스할 수 있습니다.

Batch는 다른 모든 작업에 주문형을 사용합니다.

스팟 VM

  • 사용 사례: 스팟 VM을 사용하여 내결함성 워크로드의 비용을 줄이는 것이 좋습니다.

  • 세부정보: 스팟 VM은 상당한 할인을 제공하지만 항상 제공되는 것은 아니며 언제든지 선점할 수 있습니다. 자세한 내용은 Compute Engine 문서의 스팟 VM을 참고하세요.

Batch는 provisioningModel 필드를 SPOT로 설정하는 작업에 스팟 VM을 사용합니다.

2단계: GPU 드라이버 설치

필요한 GPU 드라이버를 설치하려면 다음 방법 중 하나를 선택합니다.

  • GPU 드라이버 자동 설치 (가능한 경우 권장됨): 예시에 표시된 것처럼 Batch가 서드 파티 위치에서 필요한 GPU 드라이버를 가져와 사용자를 대신하여 설치하도록 하려면 작업의 installGpuDrivers 필드를 true로 설정합니다. 이 방법은 작업에서 드라이버를 수동으로 설치할 필요가 없는 경우에 권장됩니다.

    원하는 경우 Batch가 설치할 GPU 드라이버 버전을 지정해야 하는 경우 driverVersion 필드도 설정합니다.

  • GPU 드라이버 수동 설치: 이 방법은 다음 중 하나라도 해당하는 경우에 필요합니다.

    • 작업이 스크립트와 컨테이너 실행 가능 항목을 모두 사용하며 인터넷 액세스 권한이 없는 경우. 작업에 있는 액세스 권한에 대한 자세한 내용은 Batch 네트워킹 개요를 참조하세요.
    • 작업이 커스텀 VM 이미지를 사용하는 경우. VM OS 이미지 및 사용할 수 있는 VM OS 이미지에 관한 자세한 내용은 VM OS 환경 개요를 참고하세요.

    필요한 GPU 드라이버를 수동으로 설치하려면 다음 방법을 사용하는 것이 좋습니다.

    1. GPU 드라이버가 포함된 맞춤 VM 이미지를 만듭니다.

      1. GPU 드라이버를 설치하려면 사용하려는 OS에 따라 설치 스크립트를 실행합니다.

      2. 작업에 컨테이너 실행 가능 항목이 있고 Container-Optimized OS를 사용하지 않는 경우 NVIDIA Container Toolkit도 설치해야 합니다.

    2. GPU를 사용하는 작업을 만들고 제출할 때는 GPU 드라이버가 포함된 커스텀 VM 이미지를 지정하고 작업의 installGpuDrivers 필드를 false (기본값)로 설정합니다.

3단계: 호환되는 VM 리소스 정의

작업의 VM 리소스를 정의하기 위한 요구사항 및 옵션에 대해 알아보려면 작업 리소스를 참고하세요.

요약하면 GPU를 사용하는 작업의 VM 리소스를 정의할 때 다음 작업을 모두 실행해야 합니다.

  • 작업의 VM이 있는 위치에서 GPU 머신 유형을 사용할 수 있는지 확인.

    GPU 머신 유형을 사용할 수 있는 위치를 알아보려면 Compute Engine 문서의 리전 및 영역별 GPU 가용성을 참고하세요.

  • 작업의 머신 유형을 지정하는 경우 머신 유형에 작업의 태스크 요구사항에 충분한 vCPU 및 메모리가 있는지 확인. 가속기 최적화 VM에 GPU를 사용하는 경우 작업의 머신 유형을 지정하는 것이 좋으며 N1 VM에 GPU를 사용하는 경우에는 선택사항입니다.

  • 유효한 메서드를 사용하여 작업의 VM 리소스 정의

    • instances[].policy 필드를 사용하여 VM 리소스를 직접 정의합니다(가능한 경우 권장). 이 메서드는 예에 나와 있습니다.
    • instances[].instanceTemplate 필드를 사용하여 템플릿을 통해 VM 리소스를 정의합니다. 이 방법은 맞춤 이미지를 통해 GPU 드라이버를 수동으로 설치하는 데 필요합니다. 자세한 내용은 VM 인스턴스 템플릿을 사용하여 작업 리소스 정의를 참고하세요.

GPU를 사용하는 예시 작업 만들기

다음 섹션에서는 권장 옵션을 사용하여 각 GPU 머신 유형의 예시 작업을 만드는 방법을 설명합니다. 특히 예시 작업은 모두 GPU 드라이버를 자동으로 설치하고, 모두 VM 리소스를 직접 정의하며, 프로비저닝 방법을 지정하거나 기본 프로비저닝 방법을 사용합니다.

일괄 처리용 동적 워크로드 스케줄러 (미리보기)를 통해 A3 VM에 GPU 사용

gcloud CLI 또는 Batch API를 사용하여 동적 워크로드 스케줄러를 통해 A3 VM에 GPU를 사용하는 작업을 만들 수 있습니다.

gcloud

  1. GPU 드라이버를 설치하고, A3 머신 계열의 머신 유형을 지정하고, 예약을 차단하고, GPU 머신 유형이 있는 위치에서 실행되는 JSON 파일을 만듭니다.

    예를 들어 동적 워크로드 스케줄러를 통해 A3 VM에 GPU를 사용하는 기본 스크립트 작업을 만들려면 다음 콘텐츠로 JSON 파일을 만듭니다.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

    • MACHINE_TYPE: A3 머신 계열의 머신 유형입니다.

    • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

  2. 작업을 만들고 실행하려면 gcloud batch jobs submit 명령어를 사용합니다.

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

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름

    • LOCATION: 작업의 위치

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

API

GPU 드라이버를 설치하고, A3 머신 시리즈에서 머신 유형을 지정하고, 예약을 차단하고, GPU 머신 유형이 있는 위치에서 실행하는 jobs.create 메서드에 POST 요청을 보냅니다.

예를 들어 동적 워크로드 스케줄러를 통해 A3 VM에 GPU를 사용하는 기본 스크립트 작업을 만들려면 다음 요청을 실행합니다.

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트의 프로젝트 ID

  • LOCATION: 작업의 위치

  • JOB_NAME: 작업의 이름

  • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

  • MACHINE_TYPE: A3 머신 계열의 머신 유형입니다.

  • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

가속기 최적화 VM에 GPU 사용하기

gcloud CLI, Batch API, Java, Node.js 또는 Python을 사용하여 가속기 최적화 VM에 GPU를 사용하는 작업을 만들 수 있습니다.

gcloud

  1. GPU 드라이버를 설치하고, 가속기 최적화 머신 계열의 머신 유형을 지정하고, GPU 머신 유형이 있는 위치에서 실행되는 JSON 파일을 만듭니다.

    예를 들어 가속기 최적화 VM에 GPU를 사용하는 기본 스크립트 작업을 만들려면 다음 콘텐츠로 JSON 파일을 만듭니다.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

    • MACHINE_TYPE: 가속기 최적화 머신 계열의 머신 유형

    • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

  2. 작업을 만들고 실행하려면 gcloud batch jobs submit 명령어를 사용합니다.

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

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름

    • LOCATION: 작업의 위치

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

API

GPU 드라이버를 설치하고, 가속기 최적화 머신 계열의 머신 유형을 지정하고, GPU 머신 유형이 있는 위치에서 실행되는 jobs.create 메서드에 POST 요청을 보냅니다.

예를 들어 가속기 최적화 VM에 GPU를 사용하는 기본 스크립트 작업을 만들려면 다음 요청을 실행합니다.

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트의 프로젝트 ID

  • LOCATION: 작업의 위치

  • JOB_NAME: 작업의 이름

  • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

  • MACHINE_TYPE: 가속기 최적화 머신 계열의 머신 유형

  • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

자바


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, 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();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .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.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .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-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// 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}.'],
  }),
});

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.
// In this case, we tell the system to use "g2-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,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, 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_gpu_job(project_id: str, region: str, job_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 on GPU machines.

    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.

    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."
    # 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]

    # We can 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"

    # 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 "g2-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 = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    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": "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_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)

N1 VM에 GPU 사용하기

gcloud CLI, Batch API, Java, Node.js 또는 Python을 사용하여 N1 VM에 GPU를 사용하는 작업을 만들 수 있습니다.

gcloud

  1. GPU 드라이버를 설치하고, accelerators[] 필드의 type 및 count 하위 필드를 정의하고, GPU 머신 유형이 있는 위치에서 실행되는 JSON 파일을 만듭니다.

    예를 들어 N1 VM에 GPU를 사용하고 Batch가 정확한 N1 머신 유형을 선택할 수 있는 기본 스크립트 작업을 만들려면 다음 콘텐츠로 JSON 파일을 만듭니다.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    다음을 바꿉니다.

    • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

    • GPU_TYPE: GPU 유형. gcloud compute accelerator-types list 명령어를 사용하여 사용 가능한 GPU 유형 목록을 볼 수 있습니다. N1 VM의 GPU에만 이 필드를 사용하세요.

    • GPU_COUNT: 지정된 유형의 GPU 수 유효한 옵션에 관한 자세한 내용은 N1 머신 시리즈의 GPU 머신 유형을 참고하세요. N1 VM의 GPU에만 이 필드를 사용하세요.

    • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

  2. 작업을 만들고 실행하려면 gcloud batch jobs submit 명령어를 사용합니다.

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

    다음을 바꿉니다.

    • JOB_NAME: 작업의 이름

    • LOCATION: 작업의 위치

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

API

GPU 드라이버를 설치하고, accelerators[] 필드의 type 및 count 하위 필드를 정의하고, GPU 머신 유형이 있는 위치를 사용하는 jobs.create 메서드에 POST 요청을 보냅니다.

예를 들어 N1 VM에 GPU를 사용하고 Batch가 정확한 N1 머신 유형을 선택할 수 있는 기본 스크립트 작업을 만들려면 다음 요청을 실행합니다.

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트의 프로젝트 ID

  • LOCATION: 작업의 위치

  • JOB_NAME: 작업의 이름

  • INSTALL_GPU_DRIVERS: true로 설정되면 Batch가 타사 위치에서 policy 필드에 지정한 GPU 유형에 필요한 드라이버를 가져오고 Batch가 이를 자동으로 설치합니다. 이 필드를 false(기본값)로 설정하면 이 작업에 GPU를 사용하도록 GPU 드라이버를 수동으로 설치해야 합니다.

  • GPU_TYPE: GPU 유형. gcloud compute accelerator-types list 명령어를 사용하여 사용 가능한 GPU 유형 목록을 볼 수 있습니다. N1 VM의 GPU에만 이 필드를 사용하세요.

  • GPU_COUNT: 지정된 유형의 GPU 수 유효한 옵션에 관한 자세한 내용은 N1 머신 시리즈의 GPU 머신 유형을 참고하세요. N1 VM의 GPU에만 이 필드를 사용하세요.

  • ALLOWED_LOCATIONS: 원하는 경우 allowedLocations[] 필드를 사용하여 작업의 VM을 실행할 수 있는 리전 또는 리전의 특정 영역을 지정할 수 있습니다. 예를 들어 regions/us-central1은 us-central1 리전의 모든 영역을 허용합니다. 이 작업에 사용할 GPU 머신 유형을 제공하는 위치를 지정해야 합니다. 그렇지 않고 이 필드를 생략하는 경우 작업 위치에 GPU 머신 유형이 제공되는지 확인합니다.

자바


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      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();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .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();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .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-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// 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}.'],
  }),
});

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.
// In this case, we tell the system to use "g2-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,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, 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 callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_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 on GPU machines.

    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
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    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."
    # 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]

    # We can 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"

    # 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.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    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_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)

다음 단계