Como executar a inferência LLM em GPUs do Cloud Run com vLLM e o SDK OpenAI Python

1. Introdução

Visão geral

O Cloud Run é uma plataforma de contêineres no Google Cloud que facilita a execução do código em um contêiner sem exigir o gerenciamento de um cluster. O Cloud Run adicionou recentemente o suporte a GPU.

Atualmente, as GPUs que disponibilizamos são GPUs Nvidia L4 com 24 GB de vRAM. Há uma GPU por instância do Cloud Run, e o escalonamento automático do Cloud Run ainda se aplica. Isso inclui o escalonamento horizontal de até cinco instâncias (com aumento de cota disponível), bem como o escalonamento vertical para zero instâncias quando não há solicitações.

Um caso de uso para GPUs é a execução de modelos de linguagem grandes (LLMs, na sigla em inglês) abertos. Este tutorial orienta você na implantação de um serviço que executa um LLM.

O serviço é um serviço de back-end que executa o vLLM, um mecanismo de inferência para sistemas de produção. Este codelab usa o Gemma 2 do Google com um modelo ajustado por instrução de 2 bilhões de parâmetros.

O que você vai aprender

• Como usar GPUs no Cloud Run.
• Como usar o Hugging Face para recuperar um modelo.
• Como implantar o modelo ajustado por instrução Gemma 2 2b do Google no Cloud Run usando o vLLM como um mecanismo de inferência.
• Como invocar o serviço de back-end para fazer a conclusão de frases.

2. Configuração e requisitos

Pré-requisitos

• Você fez login no console do Cloud.
• Você já implantou um serviço do Cloud Run. Por exemplo, siga o guia de início rápido Implantar um serviço da Web do código-fonte para começar.
• Você tem uma conta do Hugging Face e reconheceu a licença do Gemma 2 2b em https://huggingface.co/google/gemma-2-2b-it. Caso contrário, não será possível fazer o download do modelo.
• Você criou um token de acesso que tem acesso ao modelo google/gemma-2-2b-it.

Ativar o Cloud Shell

1. No console do Cloud, clique em Ativar o Cloud Shell .

Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária será exibida descrevendo o que ele é. Se você recebeu uma tela intermediária, clique em Continuar.

Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.

Essa máquina virtual é carregada com todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório pessoal persistente de 5 GB e é executada no Google Cloud, melhorando muito o desempenho da rede e a autenticação. Neste codelab, quase todo o trabalho pode ser feito com um navegador.

Depois de se conectar ao Cloud Shell, você vai ver que sua conta está autenticada e que o projeto está configurado com o ID do seu projeto.

2. Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:

gcloud auth list

Resposta ao comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Observação: a ferramenta de linha de comando gcloud é a poderosa e unificada do Google Cloud. Ela vem pré-instalado no Cloud Shell. Essa ferramenta aceita preenchimento com tabulação. Talvez seja necessário autenticar na primeira vez que você executar um comando. Para mais informações, consulte a visão geral da ferramenta de linha de comando gcloud.

3. Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

Se o projeto não estiver configurado, faça a configuração usando este comando:

gcloud config set project <PROJECT_ID>

Resposta ao comando

Updated property [core/project].

Observação: se você estiver concluindo este tutorial fora do Cloud Shell, siga as etapas em Configurar as credenciais padrão do aplicativo.

3. Ativar APIs e definir variáveis de ambiente

Ativar APIs

Antes de começar a usar este codelab, é necessário ativar várias APIs. Este codelab exige o uso das seguintes APIs. Para ativar essas APIs, execute o seguinte comando:

gcloud services enable run.googleapis.com \
    cloudbuild.googleapis.com \
    secretmanager.googleapis.com \
    artifactregistry.googleapis.com

Configurar as variáveis de ambiente.

É possível definir variáveis de ambiente que serão usadas neste codelab.

HF_TOKEN=<YOUR_HUGGING_FACE_TOKEN>
PROJECT_ID=<YOUR_PROJECT_ID>

REGION=europe-west1
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. Criar uma conta de serviço

Essa conta de serviço é usada para criar o serviço do Cloud Run e acessar um secret do Secret Manager.

Primeiro, crie a conta de serviço executando este comando:

gcloud iam service-accounts create $SERVICE_ACCOUNT \
  --display-name="Cloud Run vllm SA to access secret manager"

Em segundo lugar, conceda o papel de usuário da Vertex AI à conta de serviço.

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/secretmanager.secretAccessor

Agora, crie um secret no Secret Manager chamado HF_TOKEN para seu token de acesso do Hugging Face. O Cloud Build usa a conta de serviço para acessar esse secret no momento da criação para extrair o modelo Gemma 2 (2B) do Hugging Face. Saiba mais sobre secrets e o Cloud Build.

printf $HF_TOKEN | gcloud secrets create HF_TOKEN --data-file=-

E conceda à conta de serviço de computação padrão acesso ao Secret HF_TOKEN no Secret Manager ao criar a imagem.

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$[e-mail]" \
  --role="roles/secretmanager.secretAccessor"

5. Criar a imagem no Artifact Registry

Primeiro, crie um repositório no Artifact Registry.

gcloud artifacts repositories create $AR_REPO_NAME \
  --repository-format docker \
  --location $REGION

Em seguida, crie um Dockerfile que incorpore o secret do Secret Manager. Saiba mais sobre a flag Docker buildx –secrets.

FROM vllm/vllm-openai:v0.11.0

ENV HF_HOME=/model-cache
RUN --mount=type=secret,id=HF_TOKEN HF_TOKEN=$(cat /run/secrets/HF_TOKEN) \
    hf 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} \
    --gpu-memory-utilization 0.85 \
    --max-num-seqs 256 \
    --max-model-len 4096

Agora, crie um arquivo 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: '${_LOCATION}-docker.pkg.dev/${PROJECT_ID}/vllm-gemma-2-2b-it-repo/vllm-gemma-2-2b-it'

options:
  dynamicSubstitutions: true
  machineType: "E2_HIGHCPU_32"

Por fim, envie um build.

gcloud builds submit --config=cloudbuild.yaml --substitutions=_LOCATION=$REGION

O build pode levar aproximadamente 8 minutos.

6. Implantar o serviço

Agora você está pronto para implantar a imagem no Cloud Run. A implantação leva cerca de 5 minutos. É necessário aumentar o atraso inicial da verificação de integridade em alguns minutos para dar mais tempo para a imagem carregar. Caso contrário, você receberá um erro de tempo limite excedido da verificação de integridade.

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. Testar o serviço

Depois de implantado, você pode usar o serviço de proxy de desenvolvimento do Cloud Run, que adiciona automaticamente um token de ID para você, ou usar o URL do serviço diretamente.

Como usar o serviço de proxy de desenvolvimento do Cloud Run

Para usar o serviço de proxy de desenvolvimento do Cloud Run, siga estas etapas:

Primeiro, execute o seguinte comando

gcloud run services proxy $SERVICE_NAME --region $REGION

Em seguida, use o serviço

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
}'

Como usar o URL do serviço diretamente

Primeiro, recupere o URL do serviço implantado.

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --region $REGION --format 'value(status.url)')

Use o serviço

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
}'

Resultados

Os resultados serão semelhantes aos exibidos abaixo:

{"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. Parabéns!

Parabéns por concluir o codelab.

Recomendamos consultar a documentação do Cloud Run.

O que vimos

• Como usar GPUs no Cloud Run.
• Como usar o Hugging Face para recuperar um modelo.
• Como implantar o modelo Gemma 2 (2B) do Google no Cloud Run usando o vLLM como um mecanismo de inferência.
• Como invocar o serviço de back-end para fazer a conclusão de frases.

9. Liberar espaço

Para evitar cobranças acidentais, por exemplo, se os serviços do Cloud Run forem invocados mais vezes do que sua alocação mensal de invocações do Cloud Run na camada sem custo financeiro, exclua o Cloud Run ou o projeto criado na etapa 2.

Para excluir o serviço do Cloud Run, acesse o console do Cloud Run em https://console.cloud.google.com/run e exclua o serviço vllm-gemma-2-2b. Talvez você também queira excluir a conta de serviço vllm-gemma-2-2b.

Se você optar por excluir todo o projeto, acesse https://console.cloud.google.com/cloud-resource-manager, selecione o projeto criado na etapa 2 e escolha "Excluir". Se você excluir o projeto, será necessário mudar os projetos no SDK Cloud. Para conferir a lista de todos os projetos disponíveis, execute gcloud projects list.