Cómo programar una tarea de Cloud Run dentro de un perímetro de Controles del servicio de VPC

1. Introducción

Descripción general

Si tu proyecto de GCP está dentro de un perímetro de SC de VPC, deberás seguir pasos adicionales para configurar trabajos programados. Debido a que Cloud Scheduler no puede activar trabajos directamente dentro de los perímetros de SC de VPC, deberás usar un proxy para la solicitud a través de otro componente. Te recomendamos que uses un servicio de Cloud Run como este proxy.

La arquitectura se ve así:

Diagrama de Cloud Scheduler que activa un servicio de Cloud Run que ejecuta un trabajo de Cloud Run

Qué aprenderás

  • Cómo ejecutar un trabajo de Cloud Run según un programa dentro de un perímetro de VPC SC
  • Cómo crear un servicio de Cloud Run que active un trabajo de Cloud Run con las bibliotecas cliente de Cloud Run
  • Cómo configurar Cloud Scheduler para invocar un servicio de Cloud Run según un programa

2. Antes de comenzar

Primero, asegúrate de haber seguido los pasos para configurar Cloud Run para los Controles del servicio de VPC.

A continuación, establece las variables de entorno que se usarán en este codelab.

PROJECT_ID=<YOUR_PROJECT_ID>
REGION=<YOUR_REGION>
AR_REPO=sample-job-repo
CLOUD_RUN_SERVICE=job-runner-service
CLOUD_RUN_JOB=sample-job
CLOUD_SCHEDULER=job-scheduler
SERVICE_ACCOUNT="cloud-run-invoker-sa"
SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
NETWORK=default
SUBNET=default

3. Crea el trabajo de Cloud Run

En este codelab, se usa el contenedor de trabajos de Cloud Run de ejemplo.

Primero, crea un repositorio de Artifact Registry para tu contenedor de trabajo de Cloud Run.

gcloud artifacts repositories create $AR_REPO --repository-format=docker --location=$REGION --description="codelab for Cloud Run jobs on schedule within VPC SC"

A continuación, copia el contenedor de trabajos de Cloud Run de muestra a un Artifact Registry dentro de tu proyecto de VPC configurado con SC. Para ello, puedes usar la herramienta gcrane. Para ello, sigue estas instrucciones de instalación. Puedes obtener más información sobre gcrane en la documentación para copiar imágenes entre repositorios.

gcrane cp us-docker.pkg.dev/cloudrun/container/job:latest $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$CLOUD_RUN_JOB:latest

En segundo lugar, implementa tu trabajo de Cloud Run que cumpla con los Controles del servicio de VPC.

gcloud run jobs create $CLOUD_RUN_JOB --region $REGION \
 --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$CLOUD_RUN_JOB:latest \
 --network=$NETWORK \
 --subnet=$SUBNET \
 --vpc-egress=all-traffic

Para obtener más información sobre cómo crear trabajos, sigue los pasos que se indican en la documentación de trabajos de Cloud Run.

4. Crea una cuenta de servicio

Cloud Run usará esta cuenta de servicio para llamar al trabajo de Cloud Run.

Primero, ejecuta este comando para crear la cuenta de servicio:

gcloud iam service-accounts create $SERVICE_ACCOUNT \
  --display-name="Cloud Run to run a Cloud Run job"

En segundo lugar, otorga a la cuenta de servicio los roles de invocador y de visor de Cloud Run.

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

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

5. Crea el servicio de Cloud Run

En este paso, implementarás un servicio de Cloud Run que actúe como proxy.

mkdir job-runner-service && cd $_

Crea un archivo llamado main.py con el siguiente código.

import os
from flask import Flask
app = Flask(__name__)

# pip install google-cloud-run
from google.cloud import run_v2

@app.route('/')
def hello():

    client = run_v2.JobsClient()

    # UPDATE TO YOUR JOB NAME, REGION, AND PROJECT ID
    job_name = 'projects/YOUR_PROJECT_ID/locations/YOUR_JOB_REGION/jobs/YOUR_JOB_NAME' 

    print("Triggering job...")
    request = run_v2.RunJobRequest(name=job_name)
    operation = client.run_job(request=request)
    response = operation.result()

    print(response)
    return "Done!"

if __name__ == '__main__':
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

Crea un archivo llamado requirements.txt con el siguiente código.

google-cloud-run
flask

Por último, crea un Dockerfile.

FROM python:3.9-slim-buster
# for logging purposes
ENV PYTHONUNBUFFERED=True

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

CMD ["python3", "main.py"]

A continuación, compila el contenedor con los siguientes comandos de Docker. Ten en cuenta que las implementaciones basadas en fuentes pueden ser difíciles de configurar en un entorno de SC de VPC. Si tienes una canalización de compilación y, también, de implementación existente, úsala para compilar el código fuente en un contenedor y, luego, implementarlo como un servicio de Cloud Run.

docker build -t $CLOUD_RUN_SERVICE .

docker tag $CLOUD_RUN_SERVICE $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$CLOUD_RUN_SERVICE

docker push $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$CLOUD_RUN_SERVICE

Ahora, implementa tu servicio de Cloud Run que cumple con los Controles del servicio de VPC.

gcloud run deploy $CLOUD_RUN_SERVICE --region $REGION \
 --image $REGION-docker.pkg.dev/$PROJECT_ID/$AR_REPO/$CLOUD_RUN_SERVICE \
 --service-account $SERVICE_ACCOUNT_ADDRESS \
 --network=$NETWORK \
 --subnet=$SUBNET \
 --vpc-egress=all-traffic \
 --no-allow-unauthenticated \
 --ingress internal

Ejecuta el siguiente comando para guardar la URL del extremo del servicio:

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

6. Crea un trabajo de Cloud Scheduler para activar el servicio

# create the Cloud Scheduler job
gcloud scheduler jobs create http $CLOUD_SCHEDULER \
  --location=$REGION \
  --schedule="0 0 1 * *" \
  --uri=$SERVICE_URL \
  --http-method=GET \
  --oidc-service-account-email=$SERVICE_ACCOUNT_ADDRESS

Una vez que se crea el trabajo de Cloud Scheduler, puedes ejecutar el siguiente comando para ejecutarlo de inmediato con fines de prueba:

gcloud scheduler jobs run $CLOUD_SCHEDULER --location=$REGION

NOTA:

Es posible que debas esperar unos minutos hasta que se complete la ejecución del trabajo. Puedes hacer un seguimiento de su estado en la página del programador de Cloud Run.

Ejecuta los siguientes comandos para verificar que la tarea de Cloud Run se haya ejecutado correctamente:

EXECUTION_NAME=$(gcloud run jobs describe $CLOUD_RUN_JOB --region $REGION --format 'value(status.latestCreatedExecution.name)')

gcloud run jobs executions describe $EXECUTION_NAME --region $REGION

y deberías ver algo similar a lo siguiente:

✔ Execution sample-job-w6hrj in region us-central1
1 task completed successfully
Elapsed time: 28 seconds

7. ¡Felicitaciones!

¡Felicitaciones por completar el codelab!

Temas abordados

  • Cómo ejecutar un trabajo de Cloud Run según un programa dentro de un perímetro de VPC SC
  • Cómo crear un servicio de Cloud Run que active un trabajo de Cloud Run con las bibliotecas cliente de Cloud Run
  • Cómo configurar Cloud Scheduler para invocar un servicio de Cloud Run según un programa

8. Limpia

Para evitar cargos imprevistos (por ejemplo, si los servicios de Cloud Run se invocan por error más veces que tu asignación mensual de invocaciones de Cloud Run en el nivel gratuito), puedes borrar los servicios de GCP o el proyecto que creaste en el paso 2.

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

Si decides borrar todo el proyecto, puedes ir a https://console.cloud.google.com/cloud-resource-manager, seleccionar el proyecto que creaste en el paso 2 y elegir 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.