Compila y crea un trabajo de Java en Cloud Run

Compila y crea un trabajo de Java en Cloud Run

Aprende a crear un trabajo simple de Cloud Run, luego a implementar desde la fuente, que empaqueta tu código automáticamente en una imagen de contenedor, sube la imagen del contenedor a Artifact Registry y, luego, se implementa en Cloud Run. Puedes usar otros lenguajes además de los que se muestran.

Antes de comenzar

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. Instala Google Cloud CLI.

5. Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

   gcloud init

   Nota: Si ya instalaste la CLI de gcloud, asegúrate de que tienes la versión más reciente mediante la ejecución de gcloud components update.

6. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

7. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

8. Instala Google Cloud CLI.

9. Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

   gcloud init

   Nota: Si ya instalaste la CLI de gcloud, asegúrate de que tienes la versión más reciente mediante la ejecución de gcloud components update.

Escribe el trabajo de muestra

Para escribir un trabajo en Java, sigue estos pasos:

1. Crea un directorio nuevo llamado jobs y usa el comando de cambio de directorio en él:

   mkdir jobs
   cd jobs
   

2. En un directorio de subdirectorios llamado src/main/java/com/example, crea un archivo JobsExample.java para el código real del trabajo. Copia las siguientes líneas de muestra en él:

   
   package com.example;
   
   abstract class JobsExample {
     // These values are provided automatically by the Cloud Run Jobs runtime.
     private static String CLOUD_RUN_TASK_INDEX =
         System.getenv().getOrDefault("CLOUD_RUN_TASK_INDEX", "0");
     private static String CLOUD_RUN_TASK_ATTEMPT =
         System.getenv().getOrDefault("CLOUD_RUN_TASK_ATTEMPT", "0");
   
     // User-provided environment variables
     private static int SLEEP_MS = Integer.parseInt(System.getenv().getOrDefault("SLEEP_MS", "0"));
     private static float FAIL_RATE =
         Float.parseFloat(System.getenv().getOrDefault("FAIL_RATE", "0.0"));
   
     // Start script
     public static void main(String[] args) {
       System.out.println(
           String.format(
               "Starting Task #%s, Attempt #%s...", CLOUD_RUN_TASK_INDEX, CLOUD_RUN_TASK_ATTEMPT));
       try {
         runTask(SLEEP_MS, FAIL_RATE);
       } catch (RuntimeException | InterruptedException e) {
         System.err.println(
             String.format(
                 "Task #%s, Attempt #%s failed.", CLOUD_RUN_TASK_INDEX, CLOUD_RUN_TASK_ATTEMPT));
         // Catch error and denote process-level failure to retry Task
         System.exit(1);
       }
     }
   
     static void runTask(int sleepTime, float failureRate) throws InterruptedException {
       // Simulate work
       if (sleepTime > 0) {
         Thread.sleep(sleepTime);
       }
   
       // Simulate errors
       if (failureRate < 0 || failureRate > 1) {
         System.err.println(
             String.format(
                 "Invalid FAIL_RATE value: %s. Must be a float between 0 and 1 inclusive.",
                 failureRate));
         return;
       }
       if (Math.random() < failureRate) {
         throw new RuntimeException("Task Failed.");
       }
       System.out.println(String.format("Completed Task #%s", CLOUD_RUN_TASK_INDEX));
     }
   }

   Los trabajos de Cloud Run permiten a los usuarios especificar la cantidad de tareas que se ejecutarán en el trabajo. En este código de muestra, se indica cómo usar la variable de entorno integrada CLOUD_RUN_TASK_INDEX. Cada tarea representa una copia en ejecución del contenedor. Ten en cuenta que las tareas se suelen ejecutar en paralelo. Usar múltiples tareas es útil si cada una puede procesar de forma independiente un subconjunto de tus datos.

   Cada tarea conoce su índice, almacenado en la variable de entorno CLOUD_RUN_TASK_INDEX. La variable de entorno CLOUD_RUN_TASK_COUNT integrada contiene la cantidad de tareas que se proporcionan en el momento de la ejecución del trabajo mediante el parámetro --tasks.

   En el código que se muestra, también aparece cómo reintentar tareas mediante la variable de entorno integrada CLOUD_RUN_TASK_ATTEMPT, que contiene la cantidad de veces que se reintentó esta tarea, a partir del 0 para el primer intento y con incrementos de 1 por cada reintento sucesivo, hasta --max-retries.

   El código también te permite generar fallas como una forma de probar los reintentos y generar registros de errores para que puedas ver cómo se ven.

3. Crea un archivo pom.xml con el siguiente contenido:

   <?xml version="1.0" encoding="UTF-8"?>
   <!--
   Copyright 2021 Google LLC
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
   -->
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.example.run</groupId>
     <artifactId>jobs-example</artifactId>
     <version>0.0.1</version>
     <packaging>jar</packaging>
   
     <!--  The parent pom defines common style checks and testing strategies for our samples.
   	Removing or replacing it should not affect the execution of the samples in anyway. -->
     <parent>
       <groupId>com.google.cloud.samples</groupId>
       <artifactId>shared-configuration</artifactId>
       <version>1.2.0</version>
     </parent>
   
     <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <maven.compiler.target>17</maven.compiler.target>
       <maven.compiler.source>17</maven.compiler.source>
     </properties>
   
     <dependencyManagement>
       <dependencies>
         <dependency>
           <artifactId>libraries-bom</artifactId>
           <groupId>com.google.cloud</groupId>
           <scope>import</scope>
           <type>pom</type>
           <version>26.32.0</version>
         </dependency>
       </dependencies>
     </dependencyManagement>
   
     <dependencies>
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.13.2</version>
         <scope>test</scope>
       </dependency>
       <dependency>
         <groupId>com.google.truth</groupId>
         <artifactId>truth</artifactId>
         <version>1.4.0</version>
         <scope>test</scope>
       </dependency>
       <dependency>
         <groupId>com.google.cloud</groupId>
         <artifactId>google-cloud-logging</artifactId>
         <scope>test</scope>
       </dependency>
     </dependencies>
   
     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-jar-plugin</artifactId>
           <version>3.3.0</version>
           <configuration>
             <archive>
               <manifest>
                 <addClasspath>true</addClasspath>
                 <mainClass>com.example.JobsExample</mainClass>
               </manifest>
             </archive>
           </configuration>
         </plugin>
       </plugins>
     </build>
   </project>
   

4. Crea un archivo project.toml con el siguiente contenido para compilar con la versión de Java compatible con Buildpack:

   # Default version is Java 11
   #  - See https://cloud.google.com/docs/buildpacks/java#specify_a_java_version
   # Match the version required in pom.xml by setting it here
   #  - See https://cloud.google.com/docs/buildpacks/set-environment-variables#build_the_application_with_environment_variables
   
   [[build.env]]
     name = "GOOGLE_RUNTIME_VERSION"
     value = "17"
   

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

Compila un contenedor de trabajos, envíalo a Artifact Registry y, luego, impleméntalo en Cloud Run

Importante: En esta guía de inicio rápido, se supone que tienes roles de propietario o de editor en el proyecto que usas para la guía de inicio rápido. De lo contrario, consulta los permisos de implementación de Cloud Run, los permisos de Cloud Build y los permisos de Artifact Registry para conocer los permisos necesarios.

En esta guía de inicio rápido, se usa la implementación desde la fuente, que compila el contenedor, lo sube a Artifact Registry y, luego, implementa 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

En el ejemplo anterior, PROJECT_ID es el ID del proyecto y REGION es la región, por ejemplo, us-central1. Ten en cuenta que puedes cambiar los diversos parámetros a cualquier valor que desees usar para fines de prueba. SLEEP_MS simula que el trabajo y FAIL_RATE hacen que el X% de las tareas fallen, por lo que puedes experimentar con el paralelismo y reintentar las tareas con errores.

Ejecuta un trabajo en Cloud Run

Para ejecutar el trabajo que acabas de crear, sigue estos pasos:

gcloud run jobs execute job-quickstart --region REGION

Reemplaza REGION por la región que usaste cuando creaste e implementaste el trabajo, por ejemplo, us-central1.

¿Qué sigue?

Para obtener más información sobre cómo compilar un contenedor a partir de código fuente y enviarlo a un repositorio, consulta los siguientes vínculos:

• Cómo desarrollar servicios de Cloud Run
• Compila contenedores
• Implementa a partir del código fuente