Cómo ejecutar la inferencia por lotes en trabajos de Cloud Run

1. Introducción

Descripción general

En este codelab, usarás trabajos de Cloud Run para ejecutar la inferencia por lotes con el LLM Llama 3.2-1b de Meta y el vLLM potenciado por la GPU de trabajos de Cloud Run. Escribirás los resultados directamente en Cloud Storage con las activaciones de volúmenes de Cloud Run.

Qué aprenderás

  • Cómo realizar inferencia por lotes con la GPU de trabajos de Cloud Run
  • Cómo escribir en Cloud Storage con activaciones de volúmenes de Cloud Run

2. Antes de comenzar

Habilita las APIs

Antes de comenzar a usar este codelab, habilita las siguientes APIs ejecutando el siguiente comando:

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

Cuota de GPU

Solicita un aumento de la cuota para una región compatible. La cuota es nvidia_l4_gpu_allocation_no_zonal_redundancy, en la API de Cloud Run Admin.

Nota: Si usas un proyecto nuevo, es posible que debas esperar unos minutos entre la habilitación de la API y la aparición de las cuotas en esta página.

Hugging Face

En este codelab, se usa un modelo alojado en Hugging Face. Para obtener este modelo, solicita el token de acceso de usuario de Hugging Face con el permiso de "Leer". Más adelante, harás referencia a esto como YOUR_HF_TOKEN.

También deberás aceptar las condiciones de uso para usar el modelo: https://huggingface.co/meta-llama/Llama-3.2-1B

3. Configuración y requisitos

En esta sección, se incluyen instrucciones para configurar los siguientes recursos:

  • Cuenta de servicio de IAM y permisos de IAM asociados
  • Secreto de Secret Manager para almacenar tu token de Hugging Face.
  • Bucket de Cloud Storage para almacenar el resultado de la inferencia

Para configurar los recursos necesarios, sigue estos pasos:

  1. Configura las variables de entorno para este codelab:
    export PROJECT_ID=<your_project_id>
export REGION=<your_region>
export HF_TOKEN=<YOUR_HF_TOKEN>

export SERVICE_ACCOUNT=inference-service-account
export SERVICE_ACCOUNT_EMAIL=${SERVICE_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com
export SECRET_ID=hugging-face-token
export BUCKET_NAME=inference-codelab-${PROJECT_ID}
  2. Para crear la cuenta de servicio, ejecuta el siguiente comando:
    gcloud iam service-accounts create ${SERVICE_ACCOUNT} \
  --display-name="Service account for batch inference codelab"
  3. Usa Secret Manager para almacenar el token de acceso de Hugging Face:
    gcloud secrets create $SECRET_ID \
      --replication-policy="automatic"

printf $HF_TOKEN | gcloud secrets versions add $SECRET_ID --data-file=-
  4. Otorga a tu cuenta de servicio el rol de descriptor de acceso a secretos de Secret Manager:
    gcloud secrets add-iam-policy-binding $SECRET_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role='roles/secretmanager.secretAccessor'
  5. Crea un bucket para alojar tu modelo ajustado:
    gcloud storage buckets create -l us-central1 gs://${BUCKET_NAME}
  6. Otorga a tu cuenta de servicio acceso al bucket:
    gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
  --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
  --role=roles/storage.objectAdmin
  7. Crea un repositorio de Artifact Registry para almacenar la imagen del contenedor. Si ya usaste implementaciones de origen de Cloud Run en tu proyecto, omite este paso.
    gcloud artifacts repositories create cloud-run-source-deploy \
    --repository-format=docker \
    --location=$REGION \
    --project=$PROJECT_ID

4. Crea el trabajo de Cloud Run

En esta sección, crearás el código que hará lo siguiente:

  • Importa el modelo Llama de Hugging Face
  • Realiza la inferencia por lotes en el modelo. La tarea usa una sola GPU L4 en este proceso.
  • Escribe los resultados en el disco local. Esto se escribe en Cloud Storage a través de activaciones de volúmenes.

Para crear el trabajo de Cloud Run y un Dockerfile, sigue estos pasos:

  1. Crea un directorio para alojar el código de tu trabajo de ajuste fino:
    mkdir codelab-inference-job
cd codelab-inference-job
  2. Crea un archivo llamado main.py.
    # SPDX-License-Identifier: Apache-2.0
from vllm import LLM, SamplingParams

# Sample prompts.
prompts = [
    "Cloud Run is",
    "The future of AI is",
    "The capital of Germany is",
    "python as a programming language is",
]
# Create a sampling params object.
sampling_params = SamplingParams(temperature=0.8, top_p=0.95)

# Create an LLM.
llm = LLM(model="meta-llama/Llama-3.2-1B")
# Generate texts from the prompts. The output is a list of RequestOutput objects
# that contain the prompt, generated text, and other information.
outputs = llm.generate(prompts, sampling_params)

# Save the outputs to disk
with open("/results/output.txt", "w") as f:
    for output in outputs:
        prompt = output.prompt
        generated_text = output.outputs[0].text
        f.write(f"Prompt: {prompt!r}, Generated text: {generated_text!r}\n")

print(f"Wrote {len(outputs)} to disk.")
  3. Crear un Dockerfile:
    FROM python:3.12
ADD main.py .
RUN python -m pip install --upgrade pip setuptools
RUN pip install vllm
CMD ["python", "./main.py"]

5. Implementa y ejecuta el trabajo

En este paso, crearás la tarea de Cloud Run con la implementación de código fuente de Cloud Run y, luego, la ejecutarás. Este paso también incluye las marcas de activación de volumen de Cloud Run para almacenar los resultados.

  1. Crea el trabajo de Cloud Run:
    gcloud beta run jobs deploy inference-job \
  --region $REGION \
  --source . \
  --gpu=1 \
  --set-secrets HF_TOKEN=${SECRET_ID}:latest \
  --add-volume name=results,type=cloud-storage,bucket=${BUCKET_NAME} \
  --add-volume-mount volume=results,mount-path=/results \
  --service-account $SERVICE_ACCOUNT_EMAIL
    Este comando compila la imagen desde la fuente y, luego, implementa el trabajo. Este proceso tardará un tiempo en completarse.
  2. Ejecuta el trabajo:
    gcloud run jobs execute inference-job --region $REGION --async
    La tarea tarda unos minutos en completarse. Puedes verificar el estado con el vínculo que se proporciona en el resultado del último comando.

Confirmación de que la implementación se ejecutó correctamente

Para confirmar que la tarea se ejecutó correctamente, consulta los registros de la tarea como en el resultado del último comando.

Verifica los resultados en el bucket de Cloud Storage:

En la consola:

  1. Ve a Cloud Storage.
  2. Selecciona el bucket que comienza con inference-codelab.
  3. Selecciona output.txt.
  4. Haz clic en URL autenticada para ver el contenido en el navegador.

El contenido del archivo debe ser las cuatro instrucciones y sus resultados.

6. ¡Felicitaciones!

¡Felicitaciones por completar el codelab!

Te recomendamos que revises la documentación de Cloud Run.

Temas abordados

  • Cómo realizar inferencia por lotes con la GPU de trabajos de Cloud Run
  • Cómo escribir en Cloud Storage con activaciones de volúmenes de Cloud Run

7. Limpia

Para borrar el trabajo de Cloud Run, ve a la consola de Cloud Run en https://console.cloud.google.com/run y borra el trabajo de inference-job.

Para borrar todo el proyecto, ve a Administrar recursos, selecciona el proyecto que creaste en el paso 2 y elige Borrar. Si borras el proyecto, deberás cambiar los proyectos en tu SDK de Cloud. Para ver la lista de todos los proyectos disponibles, ejecuta gcloud projects list.