Diffuser Qwen3-8B-Base avec vLLM sur des TPU

Ce tutoriel explique comment mettre en service le modèle Qwen/Qwen3-8B-Base à l'aide du framework de mise en service vLLM TPU sur une VM TPU v6e.

Objectifs

  1. configurer votre environnement ;
  2. exécuter vLLM avec Qwen3-8B-Base ;
  3. envoyer une requête d'inférence ;
  4. exécuter une charge de travail de benchmark ;
  5. effectuer un nettoyage.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

Avant de suivre ce tutoriel, suivez les instructions de la page Configurer l'environnement Cloud TPU. Ces instructions vous guident tout au long des étapes nécessaires pour créer un Google Cloud projet et le configurer afin d'utiliser Cloud TPU. Vous pouvez également utiliser un projet existant Google Cloud projet. Si vous le souhaitez, vous pouvez ignorer l'étape de création d'un Google Cloud projet et commencer par Configurer votre environnement pour utiliser Cloud TPU.

Vous avez besoin d'un jeton d'accès Hugging Face pour suivre ce tutoriel. Vous pouvez vous inscrire pour obtenir un compte sans frais sur Hugging Face. Une fois que vous disposez d'un compte, générez un jeton d'accès :

  1. Sur la page "Welcome to Hugging Face" (Bienvenue sur Hugging Face), cliquez sur l'avatar de votre compte, puis sélectionnez Access tokens (Jetons d'accès).
  2. Sur la page Access Tokens (Jetons d'accès), cliquez sur Create new token (Créer un jeton).
  3. Sélectionnez le type de jeton Read (Lecture), puis saisissez un nom pour votre jeton.
  4. Votre jeton d'accès s'affiche. Enregistrez le jeton dans un endroit sûr.

Configurer votre environnement

Ressources en file d'attente

Créez une VM Cloud TPU v6e à l'aide de l'API de ressources en file d'attente. Pour Qwen3-8B-Base, nous vous recommandons d'utiliser un TPU v6e-1.

export PROJECT_ID=<PROJECT>
export TPU_NAME=<TPU_NAME>
export ZONE=<ZONE>
export QR_ID=<QR_ID>
export TPU_TYPE=<TPU_TYPE>

Définissez les variables :

  • PROJECT : nom de votre projet
  • TPU_NAME : nom de la machine VM TPU que vous allez créer
  • ZONE : zone cloud dans laquelle vous créez la VM
  • TPU_TYPE : type de VM TPU que vous créez Par exemple, v6e-1 ou v6e-4.
  • QR_ID : nom de la ressource en file d'attente que vous créez

Créez la requête de ressource en file d'attente :

gcloud alpha compute tpus queued-resources create $QR_ID \
 --node-id $TPU_NAME \
 --project $PROJECT_ID \
 --zone $ZONE \
 --accelerator-type $TPU_TYPE \
 --runtime-version v2-alpha-tpuv6e

Vérifiez que votre VM TPU est prête.

gcloud compute tpus queued-resources describe $QR_ID \
  --project $PROJECT_ID \
  --zone $ZONE

Par exemple, lorsque l'état est ACTIVE :

name: projects/your-project-id/locations/your-zone/queuedResources/your-queued-resource-id
  state:
  state: ACTIVE
  tpu:
  nodeSpec:
  - node:
      acceleratorType: v6e-1
      bootDisk: {}
      networkConfig:
          enableExternalIps: true
      queuedResource: projects/your-project-number/locations/your-zone/queuedResources/your-queued-resource-id
      runtimeVersion: v2-alpha-tpuv6e
      schedulingConfig: {}
      serviceAccount: {}
      shieldedInstanceConfig: {}
      useTpuVm: true
      nodeId: your-node-id
      parent: projects/your-project-number/locations/your-zone

Réservation

Créez une VM Cloud TPU v6e à l'aide d'une réservation. Pour Qwen3-8B-Base, nous vous recommandons d'utiliser un TPU v6e-1. Commencez par définir les variables d'environnement :

export PROJECT_ID="YOUR_PROJECT_ID"
export TPU_NAME="TPU_MACHINE_NAME"
export ZONE="ZONE_NAME"
export TPU_TYPE=v6e-8
export HF_TOKEN="YOUR_HF_TOKEN"
export RESERVATION="RESERVATION_NAME"

Définissez les variables :

  • PROJECT : nom de votre projet
  • TPU_NAME : nom de la machine VM TPU que vous allez créer
  • ZONE : zone cloud dans laquelle vous créez la VM
  • TPU_TYPE : type de VM TPU que vous créez Par exemple, v6e-1 ou v6e-4.
  • RESERVATION : nom de la réservation avec vos TPU

Créez la VM TPU à l'aide de votre réservation :

gcloud alpha compute tpus tpu-vm create $TPU_NAME \
    --zone=$ZONE \
    --project $PROJECT_ID \
    --accelerator-type=$TPU_TYPE \
    --version=v2-alpha-tpuv6e \
    --provisioning-model=reservation-bound \
    --reservation=$RESERVATION

Connectez-vous à la VM TPU.

gcloud compute tpus tpu-vm ssh $TPU_NAME \
  --project $PROJECT_ID \
  --zone $ZONE

Exécuter vLLM avec Qwen3-8B-Base

  1. Définissez les variables de jeton Hugging Face et de nom de modèle.

      export HF_TOKEN="YOUR_HF_TOKEN"
  export MODEL_NAME="Qwen/Qwen3-8B-Base"

  2. Dans la VM TPU, exécutez le conteneur Docker vLLM en mode détaché et démarrez le serveur vLLM. Cette commande utilise une taille de mémoire partagée de 10 Go.

    export DOCKER_URI="vllm/vllm-tpu:v0.18.0"
export CONTAINER_NAME="${USER}-vllm"
export MAX_MODEL_LEN=4096
export TP=1 # number of chips

sudo docker run -d --name "${CONTAINER_NAME}" \
    --privileged --net=host \
    -v /dev/shm:/dev/shm \
    --shm-size 10gb \
    -e "HF_HOME=/dev/shm" \
    -e "HF_TOKEN=${HF_TOKEN}" \
    -p 8000:8000 "${DOCKER_URI}" \
        vllm serve ${MODEL_NAME} \
            --seed 42 \
            --gpu-memory-utilization 0.98 \
            --max-num-batched-tokens 1024 \
            --max-num-seqs 128 \
            --tensor-parallel-size $TP \
            --max-model-len $MAX_MODEL_LEN

  3. Consultez les journaux du serveur pour vérifier qu'il est en cours d'exécution.

    sudo docker logs -f "${CONTAINER_NAME}"

    Lorsque le serveur vLLM est en cours d'exécution, une sortie semblable à la suivante s'affiche. Une fois la sortie affichée, appuyez sur CTRL+C pour revenir au terminal.

    (APIServer pid=7) INFO:     Started server process [7]
(APIServer pid=7) INFO:     Waiting for application startup.
(APIServer pid=7) INFO:     Application startup complete.

Envoyer une requête d'inférence

Une fois le serveur vLLM en cours d'exécution, vous pouvez envoyer des requêtes à l'API. Pour en savoir plus, consultez la documentation de référence de l'API vLLM.

  1. Envoyez une requête de test au serveur à l'aide de curl.

    sudo docker exec "${CONTAINER_NAME}" \
  curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "prompt": "The future of AI is",
        "max_tokens": 200,
        "temperature": 0
      }'

La réponse est renvoyée au format JSON.

Exécuter une charge de travail de benchmark

Vous pouvez exécuter des benchmarks sur le serveur en cours d'exécution à partir de votre deuxième terminal.

  1. Dans le conteneur, installez la bibliothèque datasets.

    sudo docker exec "${CONTAINER_NAME}" pip install datasets

  2. Dans le conteneur, exécutez la commande vllm bench serve.

    sudo docker exec "${CONTAINER_NAME}" \
    vllm bench serve \
        --backend vllm \
        --dataset-name random \
        --num-prompts 1000 \
        --seed 100

Les résultats du benchmark s'affichent comme suit :

============ Serving Benchmark Result ============
Successful requests:                     1000
Failed requests:                         0
Benchmark duration (s):                  73.97
Total input tokens:                      1024000
Total generated tokens:                  128000
Request throughput (req/s):              13.52
Output token throughput (tok/s):         1730.38
Peak output token throughput (tok/s):    2522.00
Peak concurrent requests:                1000.00
Total Token throughput (tok/s):          15573.42
---------------Time to First Token----------------
Mean TTFT (ms):                          34834.97
Median TTFT (ms):                        34486.19
P99 TTFT (ms):                           70234.40
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          47.30
Median TPOT (ms):                        48.57
P99 TPOT (ms):                           48.60
---------------Inter-token Latency----------------
Mean ITL (ms):                           47.31
Median ITL (ms):                         53.49
P99 ITL (ms):                            54.58
==================================================

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

  1. Dans votre terminal, saisissez exit pour vous déconnecter de la VM TPU.

Supprimer vos ressources

Vous pouvez supprimer le projet, ce qui supprimera toutes les ressources, ou conserver le projet et supprimer les ressources.

Supprimer votre projet

Pour supprimer votre Google Cloud projet et toutes les ressources associées, exécutez :

    gcloud projects delete $PROJECT_ID

Supprimer les ressources TPU

Ressources en file d'attente

Supprimez vos ressources Cloud TPU. La commande suivante supprime à la fois la requête de ressource en file d'attente et la VM TPU à l'aide du paramètre --force.

gcloud alpha compute tpus queued-resources delete $QR_ID \
  --project=$PROJECT_ID \
  --zone=$ZONE \
  --force

Réservation

Supprimez votre VM Cloud TPU. Utilisez la commande suivante pour arrêter la VM et libérer les TPU dans votre réservation.

gcloud compute tpus tpu-vm delete $TPU_NAME --zone $ZONE --project $PROJECT_ID --quiet

Étape suivante