Men-deploy model terbuka dengan container vLLM kustom

Meskipun berbagai opsi penyajian model Gemini Enterprise Agent Platform sudah cukup untuk banyak kasus penggunaan, Anda mungkin perlu menggunakan image container Anda sendiri untuk menyajikan model di Gemini Enterprise Agent Platform. Dokumen ini menjelaskan cara menggunakan image container kustom vLLM untuk menyajikan model di Gemini Enterprise Agent Platform pada CPU, GPU, atau TPU. Untuk mengetahui informasi selengkapnya tentang model yang didukung vLLM, lihat dokumentasi vLLM.

Server API vLLM mengimplementasikan protokol OpenAI API, tetapi tidak mendukung persyaratan permintaan dan respons Gemini Enterprise Agent Platform. Oleh karena itu, Anda harus menggunakan Permintaan Inferensi Mentah Gemini Enterprise Agent Platform untuk mendapatkan inferensi dari model yang di-deploy ke Gemini Enterprise Agent Platform menggunakan Endpoint Prediksi. Untuk mengetahui informasi selengkapnya tentang metode Raw Prediction di Python SDK Gemini Enterprise Agent Platform, lihat dokumentasi Python SDK.

Anda dapat mengambil model dari Hugging Face dan Cloud Storage. Pendekatan ini menawarkan fleksibilitas, yang memungkinkan Anda memanfaatkan hub model berbasis komunitas (Hugging Face) serta kemampuan transfer data dan keamanan yang dioptimalkan dari Cloud Storage untuk pengelolaan model internal atau versi yang telah disesuaikan.

vLLM mendownload model dari Hugging Face jika token akses Hugging Face diberikan. Jika tidak, vLLM akan mengasumsikan bahwa model tersedia di disk lokal. Image container kustom memungkinkan Gemini Enterprise Agent Platform mendownload model dariCloud de Confiance by S3NS selain Hugging Face.

Sebelum memulai

  1. Di project Cloud de Confiance by S3NS Anda, aktifkan API Gemini Enterprise Agent Platform dan Artifact Registry.

    gcloud services enable aiplatform.googleapis.com \
    artifactregistry.googleapis.com

  2. Konfigurasikan Google Cloud CLI dengan project ID Anda dan lakukan inisialisasi Vertex AI SDK.

    PROJECT_ID = "PROJECT_ID"
LOCATION = "LOCATION"
import vertexai
vertexai.init(project=PROJECT_ID, location=LOCATION)

    gcloud config set project {PROJECT_ID}

  3. Buat repositori Docker di Artifact Registry.

    gcloud artifacts repositories create DOCKER_REPOSITORY \
    --repository-format=docker \
    --location=LOCATION \
    --description="Agent Platform Docker repository"

  4. Opsional: Jika mendownload model dari Hugging Face, dapatkan token Hugging Face.

    1. Buat akun Hugging Face jika Anda belum memilikinya.
    2. Untuk model yang dibatasi seperti Llama 3.2, minta dan dapatkan akses di Hugging Face sebelum melanjutkan.
    3. Buat token akses: Buka Your Profile > Settings > Access Tokens.
    4. Pilih New Token.
    5. Tentukan nama dan peran minimal Read.
    6. Pilih Buat token.
    7. Simpan token ini untuk langkah-langkah deployment.

Menyiapkan file build container

Dockerfile berikut membangun image container kustom vLLM untuk GPU, TPU, dan CPU. Container kustom ini mendownload model dari Hugging Face atau Cloud Storage.

ARG BASE_IMAGE
FROM ${BASE_IMAGE}

ENV DEBIAN_FRONTEND=noninteractive
# Install gcloud SDK
RUN apt-get update && \
    apt-get install -y apt-utils git apt-transport-https gnupg ca-certificates curl \
    && echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list \
    && curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg \
    && apt-get update -y && apt-get install google-cloud-cli -y \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /workspace/vllm

# Copy entrypoint.sh to the container
COPY ./entrypoint.sh /workspace/vllm/vertexai/entrypoint.sh
RUN chmod +x /workspace/vllm/vertexai/entrypoint.sh

ENTRYPOINT ["/workspace/vllm/vertexai/entrypoint.sh"]

Bangun image container kustom menggunakan Cloud Build. File konfigurasi cloudbuild.yaml berikut menunjukkan cara membangun image untuk beberapa platform menggunakan Dockerfile yang sama.

steps:
-   name: 'gcr.io/cloud-builders/docker'
  automapSubstitutions: true
  script: |
      #!/usr/bin/env bash
      set -euo pipefail
      device_type_param=${_DEVICE_TYPE}
      device_type=${device_type_param,,}
      base_image=${_BASE_IMAGE}
      image_name="vllm-${_DEVICE_TYPE}"
      if [[ $device_type == "cpu" ]]; then
        echo "Quietly building open source vLLM CPU container image"
        git clone https://github.com/vllm-project/vllm.git
        cd vllm && DOCKER_BUILDKIT=1 docker build -t $base_image -f docker/Dockerfile.cpu . -q
        cd ..
      fi
      echo "Quietly building container image for: $device_type"
      docker build -t $LOCATION-docker.pkg.dev/$PROJECT_ID/${_REPOSITORY}/$image_name --build-arg BASE_IMAGE=$base_image . -q
      docker push $LOCATION-docker.pkg.dev/$PROJECT_ID/${_REPOSITORY}/$image_name
substitutions:
    _DEVICE_TYPE: gpu
    _BASE_IMAGE: vllm/vllm-openai
    _REPOSITORY: my-docker-repo

File tersebut tersedia di repositori GitHub googlecloudplatform/vertex-ai-samples. Buat clone repositori untuk menggunakannya:

git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git

Membangun dan mengirim image container

Bangun image container kustom menggunakan Cloud Build dengan mengirimkan file cloudbuild.yaml. Gunakan substitusi untuk menentukan jenis perangkat target, yang dapat berupa GPU, TPU, atau CPU, dan image dasar yang sesuai.

GPU 

DEVICE_TYPE="gpu"
BASE_IMAGE="vllm/vllm-openai"
cd vertex-ai-samples/notebooks/official/prediction/vertexai_serving_vllm/cloud-build && \
gcloud builds submit \
    --config=cloudbuild.yaml \
    --region=LOCATION \
    --timeout="2h" \
    --machine-type=e2-highcpu-32 \
    --substitutions=_REPOSITORY=DOCKER_REPOSITORY,_DEVICE_TYPE=$DEVICE_TYPE,_BASE_IMAGE=$BASE_IMAGE

TPU 

DEVICE_TYPE="tpu"
BASE_IMAGE="vllm/vllm-tpu:nightly"
cd vertex-ai-samples/notebooks/official/prediction/vertexai_serving_vllm/cloud-build && \
gcloud builds submit \
    --config=cloudbuild.yaml \
    --region=LOCATION \
    --timeout="2h" \
    --machine-type=e2-highcpu-32 \
    --substitutions=_REPOSITORY=DOCKER_REPOSITORY,_DEVICE_TYPE=$DEVICE_TYPE,_BASE_IMAGE=$BASE_IMAGE

CPU 

DEVICE_TYPE="cpu"
BASE_IMAGE="vllm-cpu-base"
cd vertex-ai-samples/notebooks/official/prediction/vertexai_serving_vllm/cloud-build && \
gcloud builds submit \
    --config=cloudbuild.yaml \
    --region=LOCATION \
    --timeout="2h" \
    --machine-type=e2-highcpu-32 \
    --substitutions=_REPOSITORY=DOCKER_REPOSITORY,_DEVICE_TYPE=$DEVICE_TYPE,_BASE_IMAGE=$BASE_IMAGE

Setelah build selesai, konfigurasi Docker untuk melakukan autentikasi dengan Artifact Registry:

gcloud auth configure-docker LOCATION-docker.pkg.dev --quiet

Mengupload model ke Model Registry dan men-deploy

Upload model Anda ke Model Registry, buat endpoint, dan deploy model dengan menyelesaikan langkah-langkah berikut. Contoh ini menggunakan Llama 3.2 3B, tetapi Anda dapat menyesuaikannya untuk model lain.

  1. Menentukan variabel model dan deployment. Tetapkan variabel DOCKER_URI ke image yang Anda bangun di langkah sebelumnya (misalnya, untuk GPU):

    DOCKER_URI = f"LOCATION-docker.pkg.dev/PROJECT_ID/DOCKER_REPOSITORY/vllm-gpu"

    Tentukan variabel untuk token Hugging Face dan properti model. Misalnya, untuk deployment GPU:

    hf_token = "your-hugging-face-auth-token"
model_name = "gpu-llama3_2_3B-serve-vllm"
model_id = "meta-llama/Llama-3.2-3B"
machine_type = "g2-standard-8"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1

  2. Mengupload model ke Model Registry. Fungsi upload_model sedikit bervariasi bergantung pada jenis perangkat karena argumen vLLM dan variabel lingkungan yang berbeda.

    from google.cloud import aiplatform

def upload_model_gpu(model_name, model_id, hf_token, accelerator_count, docker_uri):
    vllm_args = [
        "python3", "-m", "vllm.entrypoints.openai.api_server",
        "--host=0.0.0.0", "--port=8080", f"--model={model_id}",
        "--max-model-len=2048", "--gpu-memory-utilization=0.9",
        "--enable-prefix-caching", f"--tensor-parallel-size={accelerator_count}",
    ]
    env_vars = {
        "HF_TOKEN": hf_token,
        "LD_LIBRARY_PATH": "$LD_LIBRARY_PATH:/usr/local/nvidia/lib64",
    }
    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=docker_uri,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/v1/completions",
        serving_container_health_route="/health",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
        serving_container_deployment_timeout=1800,
    )
    return model

def upload_model_tpu(model_name, model_id, hf_token, tpu_count, docker_uri):
    vllm_args = [
        "python3", "-m", "vllm.entrypoints.openai.api_server",
        "--host=0.0.0.0", "--port=8080", f"--model={model_id}",
        "--max-model-len=2048", "--enable-prefix-caching",
        f"--tensor-parallel-size={tpu_count}",
    ]
    env_vars = {"HF_TOKEN": hf_token}
    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=docker_uri,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/v1/completions",
        serving_container_health_route="/health",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
        serving_container_deployment_timeout=1800,
    )
    return model

def upload_model_cpu(model_name, model_id, hf_token, docker_uri):
    vllm_args = [
        "python3", "-m", "vllm.entrypoints.openai.api_server",
        "--host=0.0.0.0", "--port=8080", f"--model={model_id}",
        "--max-model-len=2048",
    ]
    env_vars = {"HF_TOKEN": hf_token}
    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=docker_uri,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/v1/completions",
        serving_container_health_route="/health",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
        serving_container_deployment_timeout=1800,
    )
    return model

# Example for GPU:
vertexai_model = upload_model_gpu(model_name, model_id, hf_token, accelerator_count, DOCKER_URI)

  3. Buat endpoint

    endpoint = aiplatform.Endpoint.create(display_name=f"model_name-endpoint")

  4. Men-deploy model ke endpoint. Deployment model mungkin memerlukan waktu 20 hingga 30 menit.

    # Example for GPU:
vertexai_model.deploy(
    endpoint=endpoint,
    deployed_model_display_name=model_name,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    traffic_percentage=100,
    deploy_request_timeout=1800,
    min_replica_count=1,
    max_replica_count=4,
    autoscaling_target_accelerator_duty_cycle=60,
)

    Untuk TPU, hapus parameter accelerator_type dan accelerator_count, lalu gunakan autoscaling_target_request_count_per_minute=60. Untuk CPU, hapus parameter accelerator_type dan accelerator_count, lalu gunakan autoscaling_target_cpu_utilization=60.

Memuat model dari Cloud Storage

Container kustom mendownload model dari lokasi Cloud Storage, bukan mendownloadnya dari Hugging Face. Saat Anda menggunakan Cloud Storage:

  • Tetapkan parameter model_id dalam fungsi upload_model ke Cloud Storage URI, misalnya, gs://<var>my-bucket</var>/<var>my-models</var>/<var>llama_3_2_3B</var>.
  • Hilangkan variabel HF_TOKEN dari env_vars saat Anda memanggil upload_model.
  • Saat Anda memanggil model.deploy, tentukan service_account yang memiliki izin untuk membaca dari bucket Cloud Storage.

Membuat Akun Layanan IAM untuk akses Cloud Storage

Jika model Anda berada di Cloud Storage, buat akun layanan yang dapat digunakan endpoint Vertex Prediction untuk mengakses artefak model.

SERVICE_ACCOUNT_NAME = "vertexai-endpoint-sa"
SERVICE_ACCOUNT_EMAIL = f"SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com"

gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
    --display-name="Agent Platform Endpoint Service Account"

# Grant storage read permission
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SERVICE_ACCOUNT_EMAIL" \
    --role="roles/storage.objectViewer"

Saat Anda men-deploy, teruskan email akun layanan ke metode deploy: service_account=<var>SERVICE_ACCOUNT_EMAIL</var>.

Mendapatkan prediksi menggunakan endpoint

Setelah berhasil men-deploy model ke endpoint, verifikasi respons model menggunakan raw_predict.

import json

PROMPT = "Distance of moon from earth is "
request_body = json.dumps(
    {
        "prompt": PROMPT,
        "temperature": 0.0,
    },
)

raw_response = endpoint.raw_predict(
    body=request_body, headers={"Content-Type": "application/json"}
)
assert raw_response.status_code == 200
result = json.loads(raw_response.text)

for choice in result["choices"]:
    print(choice)

Contoh output:

{
  "index": 0,
  "text": "384,400 km. The moon is 1/4 of the earth's",
  "logprobs": null,
  "finish_reason": "length",
  "stop_reason": null,
  "prompt_logprobs": null
}

Langkah berikutnya