Executar inferência usando um modelo da Gemma no Cloud Run com GPU RTX 6000 Pro

1. Introdução

Observação:este recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos gerais de serviço" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Visão geral

O que você vai aprender

• Como implantar um modelo do Gemma em uma GPU RTX 6000 Pro do Cloud Run
• Como baixar um modelo simultaneamente do Cloud Storage durante a inicialização do contêiner

2. Configuração e requisitos

Observação:este codelab usa o modelo menor Gemma 3 1B para que você possa concluir as etapas em ambientes de armazenamento limitados, como o Cloud Shell. Este codelab demonstra como carregar o modelo simultaneamente do Cloud Storage durante a inicialização do contêiner. Para mais informações, consulte o guia de práticas recomendadas de GPU. Para usar um modelo maior, substitua gemma3:1b por gemma3:27b em todo este codelab.

Defina as variáveis de ambiente que serão usadas neste codelab:

export PROJECT_ID=<YOUR_PROJECT_ID>

export REGION=europe-west4
export SERVICE_NAME=gemma-rtx-codelab

# set the project
gcloud config set project $PROJECT_ID

Ativar as APIs necessárias para este codelab

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

Criar uma pasta para o codelab

mkdir codelab-rtx
cd codelab-rtx

Ative o Acesso privado do Google à sua sub-rede para otimizar o carregamento de modelos de ML do Cloud Storage. Saiba mais na seção de práticas recomendadas de GPU sobre carregar modelos do Cloud Storage.

gcloud compute networks subnets update default \
  --region=europe-west4 \
  --enable-private-ip-google-access

3. Configurar o Cloud Storage

Primeiro, crie um bucket do Cloud Storage para armazenar os pesos do modelo.

Criar um bucket exclusivo

# Generate a unique bucket name
export MODEL_BUCKET="${PROJECT_ID}-rtx-codelab-$(python3 -c 'import uuid; print(str(uuid.uuid4())[:8])')"
echo "Bucket name: $MODEL_BUCKET"

# Create the regional bucket
gcloud storage buckets create gs://$MODEL_BUCKET \
    --location=$REGION \
    --uniform-bucket-level-access

4. Recuperar pesos do modelo

Em seguida, faça o download do modelo Gemma 3 para um diretório local e envie para seu bucket do Cloud Storage.

Instalar o Ollama

Execute este comando para instalar o Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Baixar o modelo

Crie um diretório para o modelo baixado.

mkdir model-weights

Você vai usar duas guias de terminal para esse processo: uma para executar o servidor Ollama e outra para recuperar o modelo.

Terminal 1 (servidor):

Inicie o servidor transmitindo o local do modelo baixado. Esse comando vai continuar sendo executado.

OLLAMA_MODELS=$(pwd)/model-weights ollama serve

Terminal 2 (cliente): abra uma nova guia do terminal e faça o download do modelo. O cliente se comunica automaticamente com o servidor em execução.

# note if you wish to use a larger model, you can change this to gemma3:27b
ollama pull gemma3:1b

De volta ao terminal 1:quando o download no terminal 2 for concluído, volte para o terminal 1 e pressione Ctrl+C para interromper o servidor.

Fazer upload para o Cloud Storage

Agora faça upload dos pesos para o bucket. O gcloud storage lida automaticamente com uploads paralelos para aumentar a velocidade.

gcloud storage cp -r ./model-weights/* gs://$MODEL_BUCKET/

(Opcional) Limpar pesos locais

Como o modelo agora está no Cloud Storage, remova a cópia local.

rm -rf model-weights

5. Criar o serviço

Primeiro, crie uma pasta para o serviço.

mkdir rtx-service
cd rtx-service

Crie um Dockerfile com o seguinte conteúdo:

FROM ollama/ollama:latest

# Install Google Cloud CLI
RUN apt-get update && apt-get install -y curl gnupg && \
    echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] http://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 | apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - && \
    apt-get update && apt-get install -y google-cloud-cli && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

# Listen on all interfaces, port 11434
ENV OLLAMA_HOST 0.0.0.0:11434

# Store model weight files in /models
ENV OLLAMA_MODELS /models

# Reduce logging verbosity
ENV OLLAMA_DEBUG false

# Never unload model weights from the GPU
ENV OLLAMA_KEEP_ALIVE -1

# Copy and set up the startup script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

# Start using the entrypoint script
ENTRYPOINT ["/entrypoint.sh"]

Crie um arquivo chamado entrypoint.sh com o conteúdo a seguir.

#!/bin/bash
set -e

# Ensure OLLAMA_MODELS directory exists
mkdir -p $OLLAMA_MODELS

# Download model weights from GCS if MODEL_BUCKET is set
if [ -n "$MODEL_BUCKET" ]; then
  echo "Downloading model weights from gs://$MODEL_BUCKET..."
  # gcloud storage handles concurrent downloads automatically
  gcloud storage cp -r "gs://$MODEL_BUCKET/*" "$OLLAMA_MODELS/"
else
  echo "MODEL_BUCKET not set. Skipping download."
fi

# Start Ollama
exec ollama serve

6. Implantar no Cloud Run

Nesta seção, você vai implantar o serviço usando gcloud run deploy. Esse comando vai criar seu contêiner da origem e implantá-lo no Cloud Run com as configurações de rede e GPU necessárias.

Criar a conta de serviço

Crie uma conta de serviço dedicada para esse aplicativo e conceda apenas as permissões necessárias.

# Create a dedicated service account
gcloud iam service-accounts create rtx-codelab-identity \
    --display-name="RTX Codelab Identity"

# Grant permission to read from the model bucket
gcloud storage buckets add-iam-policy-binding gs://$MODEL_BUCKET \
    --member="serviceAccount:rtx-codelab-identity@$PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/storage.objectViewer"

# Grant access to the Compute Engine network for the Cloud Run service identity
gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:rtx-codelab-identity@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/compute.networkUser"

# Grant access to the Compute Engine network for the default service account
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')@serverless-robot-prod.iam.gserviceaccount.com" \
 --role="roles/compute.networkUser"

Configuração de rede

Para ter uma performance ideal ao fazer o download de modelos grandes, use a saída de VPC direta. Isso permite que o contêiner acesse o Cloud Storage pela rede particular do Google, ignorando a Internet pública e os gateways NAT. As seguintes flags são usadas no comando gcloud run deploy:

• --network: conecta-se à VPC default. Verifique se essa rede existe e tem uma sub-rede na sua região com o Acesso privado do Google ativado.
• --subnet: a sub-rede específica na sua região (geralmente default se você estiver usando a rede padrão).
• --vpc-egress: defina como all-traffic para forçar todo o tráfego de saída pela VPC.

Comando de implantação

gcloud beta run deploy $SERVICE_NAME \
    --source . \
    --region $REGION \
    --project $PROJECT_ID \
    --no-allow-unauthenticated \
    --port 11434 \
    --service-account rtx-codelab-identity@$PROJECT_ID.iam.gserviceaccount.com \
    --cpu 20 --memory 80Gi \
    --gpu 1 \
    --gpu-type nvidia-rtx-pro-6000 \
    --set-env-vars MODEL_BUCKET=$MODEL_BUCKET \
    --network default \
    --subnet default \
    --vpc-egress all-traffic \
    --no-gpu-zonal-redundancy

7. Testar o serviço

Depois da implantação, é possível interagir com o modelo Gemma 3 usando a API Ollama.

Receber URL do serviço

Recupere o URL do serviço implantado do Cloud Run.

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --region $REGION --format 'value(status.url)')
echo "Service URL: $SERVICE_URL"

Executar inferência

Envie um comando para o modelo usando curl. Você pode definir "stream": false para receber a resposta completa em um único objeto JSON e usar jq para extrair apenas o texto.

Observação: se você estiver usando um modelo maior, como gemma3:27b, mude o nome do modelo no JSON abaixo.

curl -s "$SERVICE_URL/api/generate" \
  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gemma3:1b",
  "prompt": "Why is the sky blue?",
  "stream": false
}' | jq -r '.response'

8. Parabéns!

Parabéns por concluir o codelab!

Recomendamos que você consulte a documentação do Cloud Run.

O que aprendemos

• Como implantar um modelo do Gemma em uma GPU RTX 6000 Pro do Cloud Run
• Como baixar um modelo simultaneamente do Cloud Storage durante a inicialização do contêiner

9. Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste tutorial, exclua o projeto ou os recursos individuais.

Opção 1: excluir recursos

Excluir o serviço do Cloud Run

gcloud run services delete $SERVICE_NAME \
      --region $REGION \
      --quiet

Excluir a conta de serviço

gcloud iam service-accounts delete \
      rtx-codelab-identity@$PROJECT_ID.iam.gserviceaccount.com \
      --quiet

Excluir o bucket do Cloud Storage

gcloud storage rm --recursive gs://$MODEL_BUCKET

Exclua a imagem do contêiner

Esse build criou uma imagem de contêiner no Artifact Registry. Você pode encontrar e excluir o nome da imagem.

Liste as imagens para encontrar o nome exato (geralmente gcr.io/PROJECT_ID/SERVICE_NAME).

gcloud container images list --filter="name:$SERVICE_NAME"

Exclua a imagem (substitua IMAGE_NAME pelo resultado acima)

gcloud container images delete <IMAGE_NAME> --force-delete-tags

Opção 2: excluir o projeto

Para excluir todo o projeto, acesse Gerenciar recursos, selecione o projeto criado na etapa 2 e escolha "Excluir". Se você excluir o projeto, vai precisar mudar de projeto no SDK Cloud. Para conferir a lista de todos os projetos disponíveis, execute gcloud projects list.