Crear y compilar una tarea de Node.js en Cloud Run

Aprende a crear un trabajo de Cloud Run sencillo y, a continuación, a desplegarlo desde el origen, lo que empaqueta automáticamente tu código en una imagen de contenedor, sube la imagen de contenedor a Artifact Registry y, después, la despliega en Cloud Run. Puedes usar otros idiomas además de los que se muestran.

Antes de empezar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Install the Google Cloud CLI.

  5. Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  6. Para inicializar gcloud CLI, ejecuta el siguiente comando: 

    gcloud init

  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Verify that billing is enabled for your Google Cloud project.

  9. Install the Google Cloud CLI.

  10. Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  11. Para inicializar gcloud CLI, ejecuta el siguiente comando: 

    gcloud init

  12. Habilita las APIs Admin de Cloud Run y Cloud Build:

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

    Una vez que se haya habilitado la API Cloud Run Admin, se creará automáticamente la cuenta de servicio predeterminada de Compute Engine.

  13. Concede a la cuenta de servicio de Cloud Build el siguiente rol de gestión de identidades y accesos.

    Haz clic para ver los roles necesarios de la cuenta de servicio de Cloud Build

    Cloud Build usa automáticamente la cuenta de servicio predeterminada de Compute Engine como cuenta de servicio predeterminada de Cloud Build para compilar tu código fuente y tu recurso de Cloud Run, a menos que anules este comportamiento. Para que Cloud Build compile tus fuentes, pide a tu administrador que conceda el rol Compilador de Cloud Run (roles/run.builder) a la cuenta de servicio predeterminada de Compute Engine de tu proyecto:

      gcloud projects add-iam-policy-binding PROJECT_ID \
      --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
      --role=roles/run.builder

    Sustituye PROJECT_NUMBER por el número de tu proyecto Google Cloud y PROJECT_ID por el ID de tu proyecto Google Cloud. Para obtener instrucciones detalladas sobre cómo encontrar el ID y el número de tu proyecto, consulta el artículo Crear y gestionar proyectos.

    La concesión del rol de compilador de Cloud Run a la cuenta de servicio predeterminada de Compute Engine tarda un par de minutos en propagarse.

    14. Escribir la tarea de ejemplo

    Para escribir un trabajo en Node.js, sigue estos pasos:

    1. Crea un directorio llamado jobs y cambia al directorio:

      mkdir jobs
cd jobs

    2. Crea un archivo package.json con el siguiente contenido:

      {
    "name": "jobs",
    "version": "1.0.0",
    "description": "Node.js sample for Cloud Run jobs",
    "main": "index.js",
    "scripts": {
        "start": "node index.js"
    },
    "engines": {
        "node": ">=16.0.0"
    },
    "author": "Google LLC",
    "license": "Apache-2.0"
}

    3. En el mismo directorio, crea un archivo index.js para el código del trabajo. Copia las siguientes líneas de ejemplo:

      // Retrieve Job-defined env vars
const {CLOUD_RUN_TASK_INDEX = 0, CLOUD_RUN_TASK_ATTEMPT = 0} = process.env;
// Retrieve User-defined env vars
const {SLEEP_MS, FAIL_RATE} = process.env;

// Define main script
const main = async () => {
  console.log(
    `Starting Task #${CLOUD_RUN_TASK_INDEX}, Attempt #${CLOUD_RUN_TASK_ATTEMPT}...`
  );
  // Simulate work
  if (SLEEP_MS) {
    await sleep(SLEEP_MS);
  }
  // Simulate errors
  if (FAIL_RATE) {
    try {
      randomFailure(FAIL_RATE);
    } catch (err) {
      err.message = `Task #${CLOUD_RUN_TASK_INDEX}, Attempt #${CLOUD_RUN_TASK_ATTEMPT} failed.\n\n${err.message}`;
      throw err;
    }
  }
  console.log(`Completed Task #${CLOUD_RUN_TASK_INDEX}.`);
};

// Wait for a specific amount of time
const sleep = ms => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

// Throw an error based on fail rate
const randomFailure = rate => {
  rate = parseFloat(rate);
  if (!rate || rate < 0 || rate > 1) {
    console.warn(
      `Invalid FAIL_RATE env var value: ${rate}. Must be a float between 0 and 1 inclusive.`
    );
    return;
  }

  const randomFailure = Math.random();
  if (randomFailure < rate) {
    throw new Error('Task failed.');
  }
};

// Start script
main().catch(err => {
  console.error(err);
  process.exit(1); // Retry Job Task by exiting the process
});

      Las tareas de Cloud Run permiten a los usuarios especificar el número de tareas que debe ejecutar la tarea. En este código de ejemplo se muestra cómo usar la variable de entorno CLOUD_RUN_TASK_INDEX integrada. Cada tarea representa una copia en ejecución del contenedor. Ten en cuenta que las tareas suelen ejecutarse en paralelo. Usar varias tareas es útil si cada tarea puede procesar de forma independiente un subconjunto de tus datos.

      Cada tarea conoce su índice, que se almacena en la variable de entorno CLOUD_RUN_TASK_INDEX. La variable de entorno CLOUD_RUN_TASK_COUNT integrada contiene el número de tareas proporcionadas en el momento de la ejecución del trabajo a través del parámetro --tasks.

      El código que se muestra también indica cómo reintentar tareas mediante la variable de entorno CLOUD_RUN_TASK_ATTEMPT integrada, que contiene el número de veces que se ha reintentado esta tarea. El primer intento es 0 y se incrementa en 1 en cada reintento sucesivo, hasta --max-retries.

      El código también te permite generar fallos para probar los reintentos y generar registros de errores para que puedas ver cómo son.

    4. Crea un Procfile con el siguiente contenido:

      # Define the application's entrypoint to override default, `npm start`
# https://github.com/GoogleCloudPlatform/buildpacks/issues/160
web: node index.js

    El código está completo y listo para empaquetarse en un contenedor.

    Crear un contenedor de tareas, enviarlo a Artifact Registry y desplegarlo en Cloud Run

    Importante: En esta guía de inicio rápido se da por hecho que tienes el rol de propietario o editor en el proyecto que vas a usar. De lo contrario, consulta los permisos necesarios para implementar un recurso de Cloud Run desde el origen.

    En esta guía de inicio rápido se usa la opción de desplegar desde el código fuente, que crea el contenedor, lo sube a Artifact Registry y despliega el trabajo en Cloud Run:

    gcloud run jobs deploy job-quickstart \
    --source . \
    --tasks 50 \
    --set-env-vars SLEEP_MS=10000 \
    --set-env-vars FAIL_RATE=0.1 \
    --max-retries 5 \
    --region REGION \
    --project=PROJECT_ID

    donde PROJECT_ID es el ID de tu proyecto y REGION es tu región (por ejemplo, europe-west1). Ten en cuenta que puedes cambiar los distintos parámetros por los valores que quieras usar para tus pruebas. SLEEP_MS simula el trabajo y FAIL_RATE provoca que falle el X% de las tareas para que puedas experimentar con el paralelismo y los reintentos de tareas fallidas.

    Ejecutar una tarea en Cloud Run

    Para ejecutar el trabajo que acabas de crear, haz lo siguiente:

    gcloud run jobs execute job-quickstart --region REGION

    Sustituye REGION por la región que usaste al crear y desplegar el trabajo (por ejemplo, europe-west1).

    Siguientes pasos

    Para obtener más información sobre cómo crear un contenedor a partir del código fuente y enviarlo a un repositorio, consulta los siguientes enlaces: