1. Introduction
Présentation
Cloud Run est récemment devenu compatible avec les GPU. Elle est disponible en version Preview publique sur liste d'attente. Si vous souhaitez essayer cette fonctionnalité, remplissez ce formulaire pour vous inscrire sur la liste d'attente. Cloud Run est une plate-forme de conteneurs sur Google Cloud qui permet d'exécuter facilement votre code dans un conteneur, sans avoir à gérer de cluster.
Aujourd'hui, nous proposons des GPU Nvidia L4 avec 24 Go de VRAM. Il y a un GPU par instance Cloud Run, et l'autoscaling Cloud Run s'applique toujours. Cela inclut le scaling horizontal jusqu'à cinq instances (avec possibilité d'augmentation du quota), ainsi que le scaling à la baisse jusqu'à zéro instance en l'absence de requêtes.
Les GPU peuvent, par exemple, être utilisés pour exécuter vos propres grands modèles de langage (LLM) ouverts. Ce tutoriel vous explique comment déployer un service qui exécute un LLM.
Le service est un service de backend qui exécute vLLM, un moteur d'inférence pour les systèmes de production. Cet atelier de programmation utilise le modèle Gemma 2 de Google, un modèle à 2 milliards de paramètres affinés par instruction.
Points abordés
- Utiliser des GPU sur Cloud Run
- Comment utiliser Hugging Face pour récupérer un modèle.
- Découvrez comment déployer le modèle Gemma 2 2b affiné par instruction de Google sur Cloud Run à l'aide de vLLM comme moteur d'inférence.
- Comment appeler le service de backend pour compléter une phrase.
2. Préparation
Prérequis
- Vous êtes connecté à la console Cloud.
- Vous avez déjà déployé un service Cloud Run. Par exemple, vous pouvez suivre le guide de démarrage rapide pour déployer un service Web à partir du code source pour commencer.
- Vous possédez un compte Hugging Face et vous avez accepté la licence Gemma 2 2b sur https://huggingface.co/google/gemma-2-2b-it. Sinon, vous ne pourrez pas télécharger le modèle.
- Vous avez créé un jeton d'accès qui permet d'accéder au modèle google/gemma-2-2b-it.
Activer Cloud Shell
- Dans Cloud Console, cliquez sur Activer Cloud Shell
.
Si vous démarrez Cloud Shell pour la première fois, un écran intermédiaire s'affiche pour vous le présenter. Si tel est le cas, cliquez sur Continuer.
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier de programmation dans un navigateur.
Une fois connecté à Cloud Shell, vous êtes en principe authentifié, et le projet est défini avec votre ID de projet.
- Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Résultat de la commande
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet :
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
3. Activer les API et définir les variables d'environnement
Activer les API
Avant de pouvoir commencer à utiliser cet atelier de programmation, vous devez activer plusieurs API. Cet atelier de programmation nécessite l'utilisation des API suivantes. Vous pouvez activer ces API en exécutant la commande suivante :
gcloud services enable run.googleapis.com \
cloudbuild.googleapis.com \
secretmanager.googleapis.com \
artifactregistry.googleapis.com
Configurer des variables d'environnement
Vous pouvez définir des variables d'environnement qui seront utilisées tout au long de cet atelier de programmation.
HF_TOKEN=<YOUR_HUGGING_FACE_TOKEN> PROJECT_ID=<YOUR_PROJECT_ID> REGION=us-central1 SERVICE_NAME=vllm-gemma-2-2b-it AR_REPO_NAME=vllm-gemma-2-2b-it-repo SERVICE_ACCOUNT=vllm-gemma-2-2b-it SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
4. Créer un compte de service
Ce compte de service est utilisé pour créer le service Cloud Run et accéder à un secret de Secret Manager.
Commencez par créer le compte de service en exécutant cette commande :
gcloud iam service-accounts create $SERVICE_ACCOUNT \ --display-name="Cloud Run vllm SA to access secret manager"
Ensuite, attribuez le rôle Utilisateur Vertex AI au compte de service.
gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \ --role=roles/secretmanager.secretAccessor
Créez ensuite un secret dans Secret Manager appelé HF_TOKEN pour votre jeton d'accès Hugging Face. Cloud Build utilise le compte de service pour accéder à ce secret au moment de la compilation afin d'extraire le modèle Gemma 2 (2B) de Hugging Face. Pour en savoir plus sur les secrets et Cloud Build, cliquez ici.
printf $HF_TOKEN | gcloud secrets create HF_TOKEN --data-file=-
Accordez au compte de service Compute par défaut l'accès au secret HF_TOKEN dans Secret Manager lors de la création de l'image.
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/secretmanager.secretAccessor"
5. Créer l'image dans Artifact Registry
Commencez par créer un dépôt dans Artifact Registry.
gcloud artifacts repositories create $AR_REPO_NAME \ --repository-format docker \ --location us-central1
Créez ensuite un Dockerfile qui intégrera le secret de Secret Manager. Pour en savoir plus sur l'indicateur Docker buildx –secrets, cliquez ici.
FROM vllm/vllm-openai:latest
ENV HF_HOME=/model-cache
RUN --mount=type=secret,id=HF_TOKEN HF_TOKEN=$(cat /run/secrets/HF_TOKEN) \
huggingface-cli download google/gemma-2-2b-it
ENV HF_HUB_OFFLINE=1
ENTRYPOINT python3 -m vllm.entrypoints.openai.api_server \
--port ${PORT:-8000} \
--model ${MODEL_NAME:-google/gemma-2-2b-it} \
${MAX_MODEL_LEN:+--max-model-len "$MAX_MODEL_LEN"}
Créez maintenant un fichier cloudbuild.yaml.
steps:
- name: 'gcr.io/cloud-builders/docker'
id: build
entrypoint: 'bash'
secretEnv: ['HF_TOKEN']
args:
- -c
- |
SECRET_TOKEN="$$HF_TOKEN" docker buildx build --tag=${_IMAGE} --secret id=HF_TOKEN .
availableSecrets:
secretManager:
- versionName: 'projects/${PROJECT_ID}/secrets/HF_TOKEN/versions/latest'
env: 'HF_TOKEN'
images: ["${_IMAGE}"]
substitutions:
_IMAGE: 'us-central1-docker.pkg.dev/${PROJECT_ID}/vllm-gemma-2-2b-it-repo/vllm-gemma-2-2b-it'
options:
dynamicSubstitutions: true
machineType: "E2_HIGHCPU_32"
Enfin, envoyez une compilation.
gcloud builds submit --config=cloudbuild.yaml
La compilation peut prendre environ huit minutes.
6. Déployer le service
Vous êtes maintenant prêt à déployer l'image dans Cloud Run. Le déploiement prendra environ cinq minutes. Vous devrez augmenter le délai initial de la vérification de l'état de quelques minutes pour donner à l'image plus de temps pour se charger. Sinon, vous recevrez une erreur "Délai dépassé" lors de la vérification de l'état.
gcloud beta run deploy $SERVICE_NAME \ --image=$REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO_NAME/$SERVICE_NAME \ --service-account $SERVICE_ACCOUNT_ADDRESS \ --cpu=8 \ --memory=32Gi \ --gpu=1 \ --port=8000 \ --gpu-type=nvidia-l4 \ --region $REGION \ --no-allow-unauthenticated \ --max-instances 3 \ --no-cpu-throttling \ --no-gpu-zonal-redundancy \ --startup-probe tcpSocket.port=8000,initialDelaySeconds=240,failureThreshold=1,timeoutSeconds=240,periodSeconds=240
7. Tester le service
Une fois déployé, vous pouvez utiliser le service de proxy de développement Cloud Run, qui ajoute automatiquement un jeton d'identité pour vous, ou vous pouvez envoyer une requête cURL directement à l'URL du service.
Utiliser le service de proxy de développement Cloud Run
Pour utiliser le service de proxy de développement Cloud Run, procédez comme suit :
Exécutez d'abord la commande suivante :
gcloud run services proxy $SERVICE_NAME --region us-central1
Ensuite, envoyez une requête curl au service.
curl -X POST http://localhost:8080/v1/completions \
-H "Content-Type: application/json" \
-d '{
"model": "google/gemma-2-2b-it",
"prompt": "Cloud Run is a",
"max_tokens": 128,
"temperature": 0.90
}'
Utiliser directement l'URL du service
Tout d'abord, récupérez l'URL du service déployé.
SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --region $REGION --format 'value(status.url)')
Envoyer une requête Curl au service
curl -X POST $SERVICE_URL/v1/completions \
-H "Authorization: bearer $(gcloud auth print-identity-token)" \
-H "Content-Type: application/json" \
-d '{
"model": "google/gemma-2-2b-it",
"prompt": "Cloud Run is a",
"max_tokens": 128,
"temperature": 0.90
}'
Résultats
Un résultat semblable aux lignes suivantes doit s'afficher :
{"id":"cmpl-e0e6924d4bfd4d918383c87cba5e25ac","object":"text_completion","created":1723853023,"model":"google/gemma-2-2b","choices":[{"index":0,"text":" serverless compute platform that lets you write your backend code in standard languages, such as Java, Go, PHP and Python.\n\nYou can deploy your function as a REST API that scales on demand and allows you to add additional security features such as HTTPS.\n\nTo write code for an Android app with Cloud Run, you need to use the GraalVM. This is because while Node.js is a more commonly known node-based platform, GraalVM is a virtual machine (VM) to run native code in the Cloud Run environment.\n\nNow you need graal.vm/java-11-jre.jar, the","logprobs":null,"finish_reason":"length","stop_reason":null}],"usage":{"prompt_tokens":5,"total_tokens":133,"completion_tokens":128}}
8. Félicitations !
Bravo ! Vous avez terminé cet atelier de programmation.
Nous vous recommandons de consulter la documentation Cloud Run.
Points abordés
- Utiliser des GPU sur Cloud Run
- Comment utiliser Hugging Face pour récupérer un modèle.
- Découvrez comment déployer le modèle Gemma 2 (2B) de Google sur Cloud Run à l'aide de vLLM comme moteur d'inférence.
- Comment appeler le service de backend pour compléter une phrase.
9. Effectuer un nettoyage
Pour éviter des frais involontaires (par exemple, si les services Cloud Run sont invoqués par inadvertance plus de fois que votre quota mensuel d'invocations Cloud Run dans le niveau sans frais), vous pouvez supprimer Cloud Run ou le projet que vous avez créé à l'étape 2.
Pour supprimer le service Cloud Run, accédez à la console Cloud Run à l'adresse https://console.cloud.google.com/run, puis supprimez le service vllm-gemma-2-2b. Vous pouvez également supprimer le compte de service vllm-gemma-2-2b.
Si vous choisissez de supprimer l'intégralité du projet, vous pouvez accéder à https://console.cloud.google.com/cloud-resource-manager, sélectionner le projet que vous avez créé à l'étape 2, puis choisir "Supprimer". Si vous supprimez le projet, vous devrez changer de projet dans votre SDK Cloud. Vous pouvez afficher la liste de tous les projets disponibles en exécutant gcloud projects list.