Triton 및 TensorRT-LLM으로 GKE에서 GPU를 사용하는 Gemma 개방형 모델 제공


이 튜토리얼에서는 Kubernetes 조정을 통한 효율적인 GPU 기반 추론을 위해 NVIDIA TritonTensorRT-LLM 제공 스택을 사용하여 Google Kubernetes Engine(GKE)에서 그래픽 처리 장치(GPU)로 Gemma 대규모 언어 모델(LLM)을 제공하는 방법을 보여줍니다. 이 튜토리얼에서는 2B 및 7B 매개변수 명령이 조정된 Gemma 모델을 다운로드하고 Triton 및 TensorRT-LLM을 실행하는 컨테이너를 사용하여 GKE Autopilot 또는 Standard 클러스터에 배포합니다.

이 가이드는 AI/ML 워크로드를 배포하고 제공할 때 관리형 Kubernetes의 세밀한 제어, 확장성, 복원력, 이동성, 비용 효율성이 필요한 경우 좋은 출발점이 될 수 있습니다. ML 모델을 비용 효율적으로 빠르게 빌드하고 제공할 수 있는 통합 관리형 AI 플랫폼이 필요한 경우 Vertex AI 배포 솔루션을 사용하는 것이 좋습니다.

배경

Triton 및 TensorRT-LLM과 함께 GKE에서 GPU를 사용하여 Gemma를 제공하면 효율적인 확장성 및 더 높은 가용성을 비롯하여 관리형 Kubernetes의 모든 이점을 갖춘 강력한 프로덕션에 즉시 사용 가능한 추론 제공 솔루션을 구현할 수 있습니다. 이 섹션에서는 이 가이드에서 사용되는 주요 기술을 설명합니다.

Gemma

Gemma는 오픈 라이선스로 출시된 공개적으로 사용 가능한 가벼운 생성형 인공지능(AI) 모델의 집합입니다. 이러한 AI 모델은 애플리케이션, 하드웨어, 휴대기기 또는 호스팅된 서비스에서 실행할 수 있습니다. 텍스트 생성에 Gemma 모델을 사용할 수 있지만 특수한 태스크를 위해 이러한 모델을 조정할 수도 있습니다.

자세한 내용은 Gemma 문서를 참조하세요.

GPU

GPU를 사용하면 머신러닝 및 데이터 처리와 같이 노드에서 실행되는 특정 워크로드를 가속화할 수 있습니다. GKE는 NVIDIA H100, L4, A100 GPU가 있는 머신 유형을 포함하여 노드 구성에 사용되는 다양한 머신 유형 옵션을 제공합니다.

GKE에서 GPU를 사용하기 전에 다음 학습 과정을 완료하는 것이 좋습니다.

  1. 현재 GPU 버전 가용성 알아보기
  2. GKE의 GPU 알아보기

TensorRT-LLM

NVIDIA TensorRT-LLM(TRT-LLM)은 LLM을 정의하고 NVIDIA GPU에서 효율적으로 추론을 수행하는 TensorRT 엔진을 빌드하기 위해 최적화된 솔루션을 조합하기 위한 Python API가 포함된 툴킷입니다. TensorRT-LLM에는 다음과 같은 기능이 포함됩니다.

  • 레이어 융합, 활성화 캐싱, 메모리 버퍼 재사용, PagedAttention을 통해 최적화된 Transformer 구현
  • 전체 제공 처리량을 개선하기 위한 진행 중 또는 연속적인 작업 일괄 처리
  • 여러 GPU에서 분산 제공을 위한 텐서 동시 로드 및 파이프라인 동시 로드
  • 양자화(FP16, FP8, INT8)

자세한 내용은 TensorRT-LLM 문서를 참조하세요.

Triton

NVIDIA Triton 추론 서버는 AI/ML 애플리케이션을 위한 오픈소스 추론 서버입니다. Triton은 TensorRT 및 TensorRT-LLM을 포함하여 최적화된 백엔드가 있는 NVIDIA GPU 및 CPU 모두에서 고성능 추론을 지원합니다. Triton에는 다음과 같은 기능이 포함되어 있습니다.

  • 다중 GPU, 다중 노드 추론
  • 동시 여러 모델 실행
  • 모델 앙상블 또는 체이닝
  • 예측 요청의 정적, 동적, 연속적 또는 진행 중인 작업 일괄 처리

자세한 내용은 Triton 문서를 참조하세요.

목표

이 가이드는 PyTorch를 사용하는 생성형 AI 고객, GKE의 신규 또는 기존 사용자, ML 엔지니어, MLOps(DevOps) 엔지니어, H100, A100, L4 GPU 하드웨어에서 LLM을 제공하기 위해 Kubernetes 컨테이너 조정 기능을 사용하는 데 관심이 있는 플랫폼 관리자를 대상으로 합니다.

이 가이드를 마치면 다음 단계를 수행할 수 있습니다.

  1. Autopilot 모드의 GKE 클러스터로 환경을 준비합니다.
  2. Triton 및 TritonRT-LLM이 포함된 컨테이너를 클러스터에 배포합니다.
  3. Triton 및 TensorRT-LLM을 사용하여 curl을 통해 Gemma 2B 또는 7B 모델을 제공합니다.

시작하기 전에

  • Google Cloud 계정에 로그인합니다. Google Cloud를 처음 사용하는 경우 계정을 만들고 Google 제품의 실제 성능을 평가해 보세요. 신규 고객에게는 워크로드를 실행, 테스트, 배포하는 데 사용할 수 있는 $300의 무료 크레딧이 제공됩니다.
  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다.

  • Enable the required API.

    Enable the API

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다.

  • Enable the required API.

    Enable the API

  • 프로젝트에 다음 역할이 있는지 확인합니다. roles/container.admin, roles/iam.serviceAccountAdmin

    역할 확인

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

      IAM으로 이동
    2. 프로젝트를 선택합니다.
    3. 주 구성원 열에서 이메일 주소가 있는 행을 찾습니다.

      이메일 주소가 열에 없으면 역할이 없는 것입니다.

    4. 이메일 주소가 있는 행에 대해 역할 열에서 역할 목록에 필요한 역할이 있는지 확인합니다.

    역할 부여

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

      IAM으로 이동
    2. 프로젝트를 선택합니다.
    3. 액세스 권한 부여를 클릭합니다.
    4. 새 주 구성원 필드에 이메일 주소를 입력합니다.
    5. 역할 선택 목록에서 역할을 선택합니다.
    6. 역할을 추가로 부여하려면 다른 역할 추가를 클릭하고 각 역할을 추가합니다.
    7. 저장을 클릭합니다.
  • Kaggle 계정이 없는 경우 만듭니다.
  • 프로젝트에 GPU 할당량이 충분한지 확인합니다. 자세한 내용은 GPU 정보배정 할당량을 참조하세요.

개발 환경 준비

이 튜토리얼에서는 Cloud Shell을 사용하여 Google Cloud에서 호스팅되는 리소스를 관리합니다. Cloud Shell에는 kubectlgcloud CLI를 포함하여 이 튜토리얼에 필요한 소프트웨어가 사전 설치되어 있습니다.

Cloud Shell로 환경을 설정하려면 다음 단계를 따르세요.

  1. Google Cloud 콘솔의 Google Cloud 콘솔에서 Cloud Shell 활성화 아이콘 Cloud Shell 활성화를 클릭하여 Cloud Shell 세션을 시작합니다. 그러면 Google Cloud 콘솔 하단 창에서 세션이 시작됩니다.

  2. 기본 환경 변수를 설정합니다.

    gcloud config set project PROJECT_ID
    export PROJECT_ID=$(gcloud config get project)
    export REGION=REGION
    export CLUSTER_NAME=triton
    

    다음 값을 바꿉니다.

    • PROJECT_ID: Google Cloud 프로젝트 ID입니다.
    • REGION: 사용하려는 가속기 유형을 지원하는 리전(예: L4 GPU의 경우 us-central1)입니다.

모델 액세스 권한 얻기

Gemma 모델에 액세스하려면 Kaggle 플랫폼에 로그인하고 Kaggle API 토큰을 가져와야 합니다.

Gemma를 사용하려면 동의 계약에 서명해야 합니다. 다음 안내를 따르세요.

  1. Kaggle.com의 모델 동의 페이지에 액세스합니다.
  2. 아직 로그인하지 않았다면 Kaggle에 로그인합니다.
  3. 액세스 요청을 클릭합니다.
  4. 동의를 위한 계정 선택 섹션에서 Kaggle 계정을 통해 인증을 선택하여 동의를 위해 Kaggle 계정을 사용합니다.
  5. 모델 이용약관에 동의합니다.

액세스 토큰 생성

Kaggle을 통해 모델에 액세스하려면 Kaggle API 토큰이 필요합니다. 아직 토큰이 없으면 다음 단계에 따라 새 토큰을 생성합니다.

  1. 브라우저에서 Kaggle 설정으로 이동합니다.
  2. API 섹션에서 새 토큰 만들기를 클릭합니다.

kaggle.json이라는 파일이 다운로드됩니다.

Cloud Shell에 액세스 토큰 업로드

Cloud Shell에서 Kaggle API 토큰을 Google Cloud 프로젝트에 업로드합니다.

  1. Cloud Shell에서 더보기 > 업로드를 클릭합니다.
  2. 파일을 선택하고 파일 선택을 클릭합니다.
  3. kaggle.json 파일을 엽니다.
  4. 업로드를 클릭합니다.

Google Cloud 리소스 만들기 및 구성

다음 안내에 따라 필요한 리소스를 만듭니다.

GKE 클러스터 및 노드 풀 만들기

GPU를 활용하여 GKE Autopilot 또는 Standard 클러스터에서 Gemma를 제공할 수 있습니다. 완전 관리형 Kubernetes 환경을 위해서는 Autopilot을 사용하는 것이 좋습니다. 워크로드에 가장 적합한 GKE 작업 모드를 선택하려면 GKE 작업 모드 선택을 참조하세요.

Autopilot

Cloud Shell에서 다음 명령어를 실행합니다.

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.28

GKE는 배포된 워크로드의 요청에 따라 CPU 및 GPU 노드를 사용하여 Autopilot 클러스터를 만듭니다.

표준

  1. Cloud Shell에서 다음 명령어를 실행하여 Standard 클러스터를 만듭니다.

    gcloud container clusters create ${CLUSTER_NAME} \
        --project=${PROJECT_ID} \
        --location=${REGION}-a \
        --workload-pool=${PROJECT_ID}.svc.id.goog \
        --release-channel=rapid \
        --machine-type=e2-standard-4 \
        --num-nodes=1
    

    클러스터 만들기는 몇 분 정도 걸릴 수 있습니다.

  2. 다음 명령어를 실행하여 클러스터에 대해 노드 풀을 만듭니다.

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
        --project=${PROJECT_ID} \
        --location=${REGION}-a \
        --cluster=${CLUSTER_NAME} \
        --machine-type=g2-standard-12 \
        --num-nodes=1
    

    GKE는 L4 GPU 노드 하나를 포함하는 단일 노드 풀을 만듭니다.

Kaggle 사용자 인증 정보용 Kubernetes 보안 비밀 만들기

이 튜토리얼에서는 Kaggle 사용자 인증 정보에 Kubernetes 보안 비밀을 사용합니다.

Cloud Shell에서 다음을 수행합니다.

  1. 클러스터와 통신하도록 kubectl을 구성합니다.

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}
    
  2. Kaggle 사용자 인증 정보를 저장할 보안 비밀을 만듭니다.

    kubectl create secret generic kaggle-secret \
        --from-file=kaggle.json \
        --dry-run=client -o yaml | kubectl apply -f -
    

체크포인트를 저장할 PersistentVolume 리소스 만들기

이 섹션에서는 영구 디스크가 지원하는 PersistentVolume을 만들어 모델 체크포인트를 저장합니다.

  1. 다음 trtllm_checkpoint_pv.yaml 매니페스트를 만듭니다.

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: model-data
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 100G
  2. 매니페스트를 적용합니다.

    kubectl apply -f trtllm_checkpoint_pv.yaml
    

Gemma용 TensorRT-LLM 엔진 파일 다운로드

이 섹션에서는 작업을 실행하여 TensorRT-LLM 엔진 파일을 다운로드하고 앞에서 만든 PersistentVolume에 파일을 저장합니다. 또한 다음 단계에서 Triton 서버에 모델을 배포하기 위한 구성 파일을 준비합니다. 이 프로세스는 몇 분 정도 걸릴 수 있습니다.

Gemma 2B-it

TensorRT-LLM 엔진은 bfloat16 활성화, 입력 시퀀스 길이=2,048, 출력 시퀀스 길이=1,024를 대상으로 하는 L4 GPU를 사용하여 Gemma의 Gemma 2B-it(명령 조정) PyTorch 체크포인트에서 빌드됩니다. 단일 L4 GPU에 모델을 배포할 수 있습니다.

  1. 다음 job-download-gemma-2b.yaml 매니페스트를 만듭니다.

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fetch-model-scripts
    data:
      fetch_model.sh: |-
        #!/usr/bin/bash -x
        pip install kaggle --break-system-packages && \
    
        MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
        VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
        ACTIVATION_DTYPE=bfloat16 && \
    
        TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
        ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
        TRITON_MODEL_REPO=/data/triton/model_repository && \
    
        mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
        mkdir -p ${ENGINE_PATH} && \
        mkdir -p ${TRITON_MODEL_REPO} && \
    
        kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
        rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
        find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
        find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
    
        # copying configuration files
        echo -e "\nCreating configuration files" && \
        cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
    
        # updating configuration files
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
    
        echo -e "\nCompleted extraction to ${ENGINE_PATH}"
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: data-loader-gemma-2b
      labels:
        app: data-loader-gemma-2b
    spec:
      ttlSecondsAfterFinished: 120
      template:
        metadata:
          labels:
            app: data-loader-gemma-2b
        spec:
          restartPolicy: OnFailure
          containers:
          - name: gcloud
            image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
            command:
            - /scripts/fetch_model.sh
            env:
            - name: KAGGLE_CONFIG_DIR
              value: /kaggle
            - name: MODEL_PATH
              value: "google/gemma/tensorrtllm/2b-it/2"
            - name: WORLD_SIZE
              value: "1"
            volumeMounts:
            - mountPath: "/kaggle/"
              name: kaggle-credentials
              readOnly: true
            - mountPath: "/scripts/"
              name: scripts-volume
              readOnly: true
            - mountPath: "/data"
              name: data
          volumes:
          - name: kaggle-credentials
            secret:
              defaultMode: 0400
              secretName: kaggle-secret
          - name: scripts-volume
            configMap:
              defaultMode: 0700
              name: fetch-model-scripts
          - name: data
            persistentVolumeClaim:
              claimName: model-data
          tolerations:
          - key: "key"
            operator: "Exists"
            effect: "NoSchedule"
  2. 매니페스트를 적용합니다.

    kubectl apply -f job-download-gemma-2b.yaml
    
  3. 작업의 로그를 봅니다.

    kubectl logs -f job/data-loader-gemma-2b
    

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

    ...
    Creating configuration files
    + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
    + echo -e '\nCreating configuration files'
    ...
    
  4. 작업이 완료될 때까지 기다립니다.

    kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b
    

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

    job.batch/data-loader-gemma-2b condition met
    
  5. 작업이 성공적으로 완료되었는지 확인합니다(몇 분 정도 걸릴 수 있음).

    kubectl get job/data-loader-gemma-2b
    

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

    NAME             COMPLETIONS   DURATION   AGE
    data-loader-gemma-2b   1/1           ##s        #m##s
    

Gemma 7B-it

TensorRT-LLM 엔진은 bfloat16 활성화, 입력 시퀀스 길이=1,024, 출력 시퀀스 길이=512를 대상으로 하는 L4 GPU를 사용하여 Gemma의 Gemma 7B-it(명령 조정) PyTorch 체크포인트에서 빌드됩니다. 단일 L4 GPU에 모델을 배포할 수 있습니다.

  1. 다음 job-download-gemma-7b.yaml 매니페스트를 만듭니다.

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fetch-model-scripts
    data:
      fetch_model.sh: |-
        #!/usr/bin/bash -x
        pip install kaggle --break-system-packages && \
    
        MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
        VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
        ACTIVATION_DTYPE=bfloat16 && \
    
        TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
        ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
        TRITON_MODEL_REPO=/data/triton/model_repository && \
    
        mkdir -p ${ENGINE_PATH} && \
        mkdir -p ${TRITON_MODEL_REPO} && \
    
        kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
        rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
        find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
        find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
    
        # copying configuration files
        echo -e "\nCreating configuration files" && \
        cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
    
        # updating configuration files
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
        python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
    
        echo -e "\nCompleted extraction to ${ENGINE_PATH}"
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: data-loader-gemma-7b
      labels:
        app: data-loader-gemma-7b
    spec:
      ttlSecondsAfterFinished: 120
      template:
        metadata:
          labels:
            app: data-loader-gemma-7b
        spec:
          restartPolicy: OnFailure
          containers:
          - name: gcloud
            image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
            command:
            - /scripts/fetch_model.sh
            env:
            - name: KAGGLE_CONFIG_DIR
              value: /kaggle
            - name: MODEL_PATH
              value: "google/gemma/tensorrtllm/7b-it/2"
            - name: WORLD_SIZE
              value: "1"
            volumeMounts:
            - mountPath: "/kaggle/"
              name: kaggle-credentials
              readOnly: true
            - mountPath: "/scripts/"
              name: scripts-volume
              readOnly: true
            - mountPath: "/data"
              name: data
          volumes:
          - name: kaggle-credentials
            secret:
              defaultMode: 0400
              secretName: kaggle-secret
          - name: scripts-volume
            configMap:
              defaultMode: 0700
              name: fetch-model-scripts
          - name: data
            persistentVolumeClaim:
              claimName: model-data
          tolerations:
          - key: "key"
            operator: "Exists"
            effect: "NoSchedule"
  2. 매니페스트를 적용합니다.

    kubectl apply -f job-download-gemma-7b.yaml
    
  3. 작업의 로그를 봅니다.

    kubectl logs -f job/data-loader-gemma-7b
    

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

    ...
    Creating configuration files
    + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
    + echo -e '\nCreating configuration files'
    ...
    
  4. 작업이 완료될 때까지 기다립니다.

    kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b
    

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

    job.batch/data-loader-gemma-7b condition met
    
  5. 작업이 성공적으로 완료되었는지 확인합니다(몇 분 정도 걸릴 수 있음).

    kubectl get job/data-loader-gemma-7b
    

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

    NAME             COMPLETIONS   DURATION   AGE
    data-loader-gemma-7b   1/1           ##s        #m##s
    

다음 섹션으로 이동하기 전에 작업이 성공적으로 완료되었는지 확인합니다.

Triton 배포

이 섹션에서는 TensorRT-LLM 백엔드와 함께 Triton을 사용하여, 사용하려는 Gemma 모델을 제공하는 컨테이너를 배포합니다.

  1. 다음 deploy-triton-server.yaml 매니페스트를 만듭니다.

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: launch-tritonserver
    data:
      entrypoint.sh: |-
        #!/usr/bin/bash -x
        # Launch Triton Inference server
    
        WORLD_SIZE=1
        TRITON_MODEL_REPO=/data/triton/model_repository
    
        python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
          --world_size ${WORLD_SIZE} \
          --model_repo ${TRITON_MODEL_REPO}
    
        tail -f /dev/null
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: triton-gemma-deployment
      labels:
        app: gemma-server
        version: v1 
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: gemma-server 
          version: v1
      template:
        metadata:
          labels:
            app: gemma-server
            ai.gke.io/model: gemma
            ai.gke.io/inference-server: triton
            examples.ai.gke.io/source: user-guide
            version: v1
        spec:
          containers:
          - name: inference-server 
            image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
            imagePullPolicy: IfNotPresent
            resources:
              requests:
                ephemeral-storage: "40Gi"
                memory: "40Gi"
                nvidia.com/gpu: 1
              limits:
                ephemeral-storage: "40Gi"
                memory: "40Gi"
                nvidia.com/gpu: 1
            command:
            - /scripts/entrypoint.sh
            volumeMounts:
            - mountPath: "/scripts/"
              name: scripts-volume
              readOnly: true
            - mountPath: "/data"
              name: data
            ports:
              - containerPort: 8000
                name: http
              - containerPort: 8001
                name: grpc
              - containerPort: 8002
                name: metrics
            livenessProbe:
              failureThreshold: 60
              initialDelaySeconds: 600
              periodSeconds: 5
              httpGet:
                path: /v2/health/live
                port: http
            readinessProbe:
              failureThreshold: 60
              initialDelaySeconds: 600
              periodSeconds: 5
              httpGet:
                path: /v2/health/ready
                port: http
          securityContext:
            runAsUser: 1000
            fsGroup: 1000
          volumes:
          - name: scripts-volume
            configMap:
              defaultMode: 0700
              name: launch-tritonserver
          - name: data
            persistentVolumeClaim:
              claimName: model-data
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
          tolerations:
          - key: "key"
            operator: "Exists"
            effect: "NoSchedule"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: triton-server
      labels:
        app: gemma-server 
    spec:
      type: ClusterIP
      ports:
        - port: 8000
          targetPort: http
          name: http-inference-server
        - port: 8001
          targetPort: grpc
          name: grpc-inference-server
        - port: 8002
          targetPort: metrics
          name: http-metrics
      selector:
        app: gemma-server
  2. 매니페스트를 적용합니다.

    kubectl apply -f deploy-triton-server.yaml
    
  3. 배포를 사용할 수 있을 때까지 기다립니다.

    kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment
    
  4. 매니페스트에서 로그를 봅니다.

    kubectl logs -f -l app=gemma-server
    

    배포 리소스는 Triton 서버를 시작하고 모델 데이터를 로드합니다. 이 프로세스는 몇 분 정도 걸릴 수 있습니다(최대 20분 이상). 출력은 다음과 비슷합니다.

    I0216 03:24:57.387420 29 server.cc:676]
    +------------------+---------+--------+
    | Model            | Version | Status |
    +------------------+---------+--------+
    | ensemble         | 1       | READY  |
    | postprocessing   | 1       | READY  |
    | preprocessing    | 1       | READY  |
    | tensorrt_llm     | 1       | READY  |
    | tensorrt_llm_bls | 1       | READY  |
    +------------------+---------+--------+
    
    ....
    ....
    ....
    
    I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
    I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
    I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002
    

모델 제공

이 섹션에서는 모델과 상호작용합니다.

포트 전달 설정

다음 명령어를 실행하여 모델에 대한 포트 전달을 설정합니다.

kubectl port-forward service/triton-server 8000:8000

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

Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000

curl을 사용하여 모델과 상호작용

이 섹션에서는 기본 스모크 테스트를 수행하여 배포된 명령 조정 모델을 확인하는 방법을 보여줍니다. 편의를 위해 이 섹션에서는 2B 명령 조정 모델만 사용하는 테스트 접근 방식을 설명합니다.

새 터미널 세션에서 curl을 사용해서 모델과 채팅합니다.

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST localhost:8000/v2/models/ensemble/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.9,
    "max_tokens": 128
}
EOF

다음 출력에는 모델 응답 예시가 표시됩니다.

{
  "context_logits": 0,
  "cum_log_probs": 0,
  "generation_logits": 0,
  "model_name": "ensemble",
  "model_version": "1",
  "output_log_probs": [0.0,0.0,...],
  "sequence_end": false,
  "sequence_id": 0,
  "sequence_start": false,
  "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}

문제 해결하기

  • Empty reply from server 메시지가 표시되면 컨테이너에서 모델 데이터 다운로드가 완료되지 않았을 수 있습니다. 모델을 제공할 준비가 되었음을 나타내는 Connected 메시지가 있는지 포드의 로그를 다시 확인합니다.
  • Connection refused가 표시되면 포트 전달이 활성 상태인지 확인합니다.

삭제

이 튜토리얼에서 사용된 리소스 비용이 Google Cloud 계정에 청구되지 않도록 하려면 리소스가 포함된 프로젝트를 삭제하거나 프로젝트를 유지하고 개별 리소스를 삭제하세요.

배포된 리소스 삭제

이 가이드에서 만든 리소스 비용이 Google Cloud 계정에 청구되지 않도록 하려면 다음 명령어를 실행합니다.

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

다음 단계