Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Menggunakan vLLM di GKE untuk menjalankan inferensi dengan DeepSeek-V3.1-Base

Tutorial ini menunjukkan cara men-deploy dan menyajikan model bahasa DeepSeek-V3.1-Base menggunakan framework vLLM. Anda men-deploy model ini di cluster autopilot edisi Google Kubernetes Engine (GKE) Enterprise dan menggunakan satu virtual machine A4 (VM) yang memiliki 8 GPU B200.

Tutorial ini ditujukan untuk engineer machine learning (ML), administrator dan operator platform, serta spesialis data dan AI yang tertarik menggunakan kemampuan orkestrasi container Kubernetes untuk menangani workload inferensi.

Tujuan

Akses DeepSeek-V3.1-Base menggunakan Hugging Face.
Siapkan lingkungan Anda.
Buat cluster GKE dalam mode Autopilot.
Buat secret Kubernetes untuk kredensial Hugging Face.
Membuat bucket Cloud Storage.
Download model ke bucket Cloud Storage Anda.
Deploy container vLLM ke cluster GKE Anda.
Berinteraksi dengan DeepSeek-V3.1-Base menggunakan curl.
Jalankan pembersihan.

Biaya

Tutorial ini menggunakan komponen Google Cloudyang dapat ditagih, termasuk:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan Kalkulator Harga.

Sebelum memulai

Instal Google Cloud CLI.
Konfigurasi gcloud CLI agar menggunakan identitas gabungan Anda.

Untuk mengetahui informasi selengkapnya, lihat Login ke gcloud CLI dengan identitas gabungan Anda.
Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:
```
gcloud init
```
Buat atau pilih Google Cloud project.
Peran yang diperlukan untuk memilih atau membuat project
- Pilih project: Memilih project tidak memerlukan peran IAM tertentu—Anda dapat memilih project mana pun yang telah diberi peran.
- Membuat project: Untuk membuat project, Anda memerlukan peran Project Creator (roles/resourcemanager.projectCreator), yang berisi izin resourcemanager.projects.create. Pelajari cara memberikan peran.
Catatan: Jika Anda tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.
- Buat Google Cloud project:
```
gcloud projects create PROJECT_ID
```
  Ganti PROJECT_ID dengan nama untuk Google Cloud project yang Anda buat.
- Pilih project Google Cloud yang Anda buat:
```
gcloud config set project PROJECT_ID
```
  Ganti PROJECT_ID dengan nama project Google Cloud Anda.
Verifikasi bahwa penagihan diaktifkan untuk project Google Cloud Anda.
Aktifkan API yang diperlukan:
Peran yang diperlukan untuk mengaktifkan API
Untuk mengaktifkan API, Anda memerlukan izin serviceusage.services.enable. Jika Anda membuat project, kemungkinan Anda sudah memiliki izin ini melalui peran Pemilik (roles/owner). Jika tidak, Anda bisa mendapatkan izin ini melalui peran Admin Penggunaan Layanan (roles/serviceusage.serviceUsageAdmin). Pelajari cara memberikan peran.
```
gcloud services enable container.googleapis.com
```

Memberikan peran ke akun pengguna Anda. Jalankan perintah berikut satu kali untuk setiap peran IAM berikut: roles/container.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Ganti kode berikut:
- PROJECT_ID: Project ID Anda.
- USER_IDENTIFIER: ID untuk akun akun. Untuk melihat contoh, lihat Merepresentasikan pengguna workforce pool dalam kebijakan IAM.
- ROLE: Peran IAM yang Anda berikan ke akun pengguna Anda.
Login atau buat akun Hugging Face.

Mengakses DeepSeek menggunakan Hugging Face

Untuk menggunakan Hugging Face guna mengakses DeepSeek, lakukan langkah-langkah berikut:

Login ke Hugging Face dan jelajahi model DeepSeek-V3.1-Base.
Buat token akses read Hugging Face.
Salin dan simpan nilai token read access. Anda akan menggunakannya nanti dalam tutorial ini.

Menyiapkan lingkungan Anda

Untuk menyiapkan lingkungan Anda, tetapkan variabel lingkungan default:

export PROJECT_ID="YOUR_PROJECT_ID"
export RESERVATION_URL="YOUR_RESERVATION_NAME"
export REGION="YOUR_REGION"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export GCS_BUCKET="YOUR_GCS_BUCKET"
export HUGGING_FACE_TOKEN="YOUR_HF_TOKEN"
export NETWORK="YOUR_NETWORK_NAME"
export SUBNETWORK="YOUR_SUBNETWORK_NAME"
export PROJECT_NUMBER=$(gcloud projects describe "${PROJECT_ID}" --format="value(projectNumber)")

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Ganti kode berikut:

YOUR_PROJECT_ID: ID Google Cloud project tempat Anda ingin membuat cluster GKE.
YOUR_RESERVATION_NAME: URL reservasi yang ingin Anda gunakan untuk membuat cluster GKE. Berdasarkan project tempat pemesanan berada, tentukan salah satu nilai berikut:
- Reservasi ada di project Anda: RESERVATION_NAME
- Pemesanan ada di project lain, dan project Anda dapat menggunakan pemesanan tersebut: projects/RESERVATION_PROJECT_ID/reservations/RESERVATION_NAME
YOUR_REGION: region tempat Anda ingin membuat cluster GKE. Anda hanya dapat membuat cluster di region tempat reservasi Anda berada.
YOUR_CLUSTER_NAME: nama cluster GKE yang akan dibuat.
YOUR_GCS_BUCKET: nama bucket Cloud Storage tempat Anda mendownload model.
YOUR_HF_TOKEN: token akses Hugging Face yang Anda buat di bagian sebelumnya.
YOUR_NETWORK_NAME: jaringan yang digunakan cluster GKE. Tentukan salah satu nilai berikut:
- Jika Anda membuat jaringan kustom, tentukan nama jaringan Anda.
- Jika tidak, tentukan default.
YOUR_SUBNETWORK_NAME: subnetwork yang digunakan cluster GKE. Tentukan salah satu nilai berikut:
- Jika Anda membuat subnetwork kustom, tentukan nama subnetwork Anda. Anda hanya dapat menentukan subnet yang ada di region yang sama dengan reservasi.
- Jika tidak, tentukan default.

Membuat cluster GKE dalam mode Autopilot

Untuk membuat cluster GKE dalam mode Autopilot, jalankan perintah berikut:

gcloud container clusters create-auto $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --region=$REGION \
    --release-channel=rapid \
    --network=$NETWORK \
    --subnetwork=$SUBNETWORK

Mungkin perlu waktu beberapa saat untuk menyelesaikan pembuatan cluster GKE. Untuk memverifikasi bahwa Google Cloud telah selesai membuat cluster Anda, buka Kubernetes clusters di konsol Google Cloud .

Buat secret Kubernetes untuk kredensial Hugging Face

Untuk membuat secret Kubernetes untuk kredensial Hugging Face, lakukan langkah berikut:

Konfigurasi kubectl untuk berkomunikasi dengan cluster GKE Anda:

gcloud container clusters get-credentials $CLUSTER_NAME \
    --location=$REGION

Buat secret Kubernetes untuk menyimpan token Hugging Face Anda:

kubectl create secret generic hf-secret \
    --from-literal=hf_token=${HUGGING_FACE_TOKEN} \
    --dry-run=client -o yaml | kubectl apply -f -

Membuat bucket Cloud Storage

Jika Anda ingin menggunakan bucket baru untuk menyimpan model, jalankan perintah berikut:

gcloud storage buckets create gs://$GCS_BUCKET --location=$REGION --uniform-bucket-level-access

Berikan izin write pada bucket Cloud Storage ke akun layanan default:

gcloud storage buckets add-iam-policy-binding gs://$GCS_BUCKET \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
    --role="roles/storage.objectAdmin"

Jika ingin menggunakan bucket Cloud Storage yang sudah ada, Anda dapat melewati langkah ini. Namun, Anda harus memastikan bahwa bucket Anda berada di region yang sama dengan cluster Anda dan akun layanan memiliki izin write yang diperlukan untuk bucket tersebut.

Download model ke bucket Cloud Storage Anda

Buat file deepseek-download-job.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: deepseek-download-job
  namespace: default
spec:
  template:
    metadata:
      labels:
        app: deepseek-oss-downloader
    spec:
      restartPolicy: OnFailure
      containers:
      - name: downloader
        image: google/cloud-sdk:slim
        resources:
          requests:
            cpu: "8"
            memory: "32Gi"
          limits:
            cpu: "8"
            memory: "32Gi"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_XET_HIGH_PERFORMANCE
          value: "0"
        - name: PIP_BREAK_SYSTEM_PACKAGES
          value: "1"
        command: ["/bin/sh", "-c"]
        args:
        - |
          set -e
          echo "Installing Hugging Face Hub CLI..."
          pip install -U "huggingface_hub[cli]"

          LOCAL_DIR="/mnt/model-download/deepseek-v3-1"
          mkdir -p "$LOCAL_DIR"

          echo "Downloading model from HF to local SSD using parallel workers..."
          hf download deepseek-ai/DeepSeek-V3.1-Base \
            --token "$HUGGING_FACE_HUB_TOKEN" \
            --local-dir "$LOCAL_DIR" \
            --max-workers 8

          DOWNLOAD_STATUS=$?

          if [ $DOWNLOAD_STATUS -ne 0 ]; then
            echo "ERROR: Model download failed with exit code $DOWNLOAD_STATUS"
            exit $DOWNLOAD_STATUS
          fi

          echo "Download to SSD complete. Syncing to GCS..."
          gcloud storage rsync "$LOCAL_DIR" "gs://$GCS_BUCKET/deepseek-v3-1" --recursive

          echo "Process successfully completed!"
        volumeMounts:
        - mountPath: /mnt/model-download
          name: download-storage
      volumes:
      - name: download-storage
        ephemeral:
          volumeClaimTemplate:
            spec:
              accessModes: [ "ReadWriteOnce" ]
              storageClassName: premium-rwo
              resources:
                requests:
                  storage: 800Gi

Terapkan manifes deepseek-download-job.yaml untuk memulai tugas download:

envsubst '$GCS_BUCKET' < deepseek-download-job.yaml | kubectl apply -f -

Untuk melihat status penyelesaian, jalankan perintah berikut:
```
kubectl wait \
    --for=condition=Complete \
    --timeout=7200s job/deepseek-download-job
```
Flag --timeout menentukan berapa lama perintah memantau tugas sebelum waktu tunggu habis.

Resource tugas mendownload bobot model DeepSeek-V3.1-Base dari Hugging Face ke bucket Google Cloud Storage Anda menggunakan volume SSD. Proses download akan selesai dalam waktu sekitar 40 menit. Setelah download selesai, lanjutkan ke bagian berikutnya untuk meluncurkan deployment model.
Untuk menghapus tugas, jalankan perintah berikut:
```
kubectl delete job deepseek-download-job
```

Men-deploy container vLLM ke cluster GKE Anda

Setelah mendownload model ke bucket Cloud Storage, deploy container vLLM ke cluster GKE dengan menyelesaikan langkah-langkah berikut:

Buat file vllm-deepseek3-1-base.yaml dengan deployment vLLM pilihan Anda:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek3-1-deploy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: deepseek
  template:
    metadata:
      labels:
        app: deepseek
        ai.gke.io/model: deepseek-v3-1-base
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      containers:
      - name: vllm-inference
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250819_0916_RC01
        resources:
          requests:
            cpu: "10"
            memory: "1000Gi"
            ephemeral-storage: "1Ti"
            nvidia.com/gpu: "8"
          limits:
            cpu: "10"
            memory: "1000Gi"
            ephemeral-storage: "1Ti"
            nvidia.com/gpu: "8"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/mnt/gcs/deepseek-v3-1
        - --tensor-parallel-size=8
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=8192
        - --max-num-seqs=4
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
          readOnly: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 1800
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 1800
          periodSeconds: 5
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      - name: gcs-bucket-volume
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: $GCS_BUCKET
            mountOptions: "implicit-dirs,file-cache:max-size-mb:-1,file-cache:enable-parallel-downloads:true,file-cache:max-parallel-downloads:32,file-cache:parallel-downloads-per-file:8,file-cache:download-chunk-size-mb:16"
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-b200
        cloud.google.com/reservation-name: $RESERVATION_URL
        cloud.google.com/reservation-affinity: "specific"
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: deepseek-service
spec:
  selector:
    app: deepseek
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: deepseek-monitoring
spec:
  selector:
    matchLabels:
      app: deepseek
  endpoints:
  - port: 8000
    path: /metrics
    interval: 30s

Terapkan file vllm-deepseek3-1-base.yaml ke cluster GKE Anda:

envsubst < vllm-deepseek3-1-base.yaml | kubectl apply -f -

Untuk melihat status penyelesaian, jalankan perintah berikut:
```
kubectl wait \
  --for=condition=Available \
  --timeout=7200s deployment/deepseek3-1-deploy
```
Flag --timeout memungkinkan perintah memantau deployment selama jangka waktu yang ditentukan.

Berinteraksi dengan DeepSeek-V3.1-Base menggunakan curl

Untuk memverifikasi model DeepSeek-V3.1-Base yang Anda deploy, lakukan hal berikut:

Siapkan penerusan port ke DeepSeek-V3.1-Base:

kubectl port-forward service/deepseek-service 8000:8000

Buka jendela terminal baru. Kemudian, Anda dapat melakukan percakapan dengan model menggunakancurl:

curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
  "model": "deepseek-ai/DeepSeek-V3.1-Base",
  "messages": [
    {
      "role": "user",
      "content": "Describe how generative AI works in one short and easy to understand sentence"
    }
  ],
"stream":false
}' | jq .

Output yang Anda lihat mirip dengan berikut ini:

{
  "id": "chatcmpl-1a47172070544a5d83199ed5548befca",
  "object": "chat.completion",
  "created": 1755891024,
  "model": "deepseek-ai/DeepSeek-V3.1-Base",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\nGenerative AI uses patterns from existing data to create new, similar content, like text, images, or music.\n",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning_content": null
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 17,
    "total_tokens": 42,
    "completion_tokens": 25,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "kv_transfer_params": null
}

Mengamati performa model

Jika ingin mengamati performa model, Anda dapat menggunakan integrasi dasbor vLLM di Cloud Monitoring. Dasbor ini membantu Anda melihat metrik performa penting untuk model seperti throughput token, latensi jaringan, dan rasio error. Untuk mengetahui informasi, lihat vLLM dalam dokumentasi Monitoring.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus resource

Setelah menyelesaikan tutorial, hapus resource yang tidak Anda perlukan lagi:

Untuk menghapus deployment dan layanan yang ditentukan dalam file vllm-deepseek3-1-base.yaml dan secret Kubernetes dari cluster GKE, jalankan perintah berikut:
```
envsubst < vllm-deepseek3-1-base.yaml | kubectl delete -f -
kubectl delete secret hf-secret
```
Untuk menghapus bucket Cloud Storage, jalankan perintah berikut:
```
gcloud storage rm --recursive gs://$GCS_BUCKET
```

Untuk menghapus cluster GKE Anda, lakukan langkah-langkah berikut:

gcloud container clusters delete $CLUSTER_NAME \
    --region=$REGION \
    --quiet

Menghapus project Anda

Perhatian: Menghapus project akan mengakibatkan:

Semua hal dalam project akan dihapus. Jika Anda menggunakan project yang ada untuk mengerjakan tugas di dokumen ini, saat Anda menghapusnya, pekerjaan lain dalam project tersebut juga akan dihapus.
Project ID kustom akan hilang. Saat membuat project ini, Anda mungkin juga membuat project ID kustom yang masih ingin digunakan pada masa mendatang. Agar tidak kehilangan URL yang menggunakan project ID tersebut, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

Menghapus Google Cloud project:

gcloud projects delete PROJECT_ID

Langkah berikutnya

Mengelola cluster GKE yang dioptimalkan untuk AI