Build and create a Python job in Cloud Run

Writing the sample job

To write a job in Python:

1. Create a new directory named jobs and change directory into it:

   mkdir jobs
   cd jobs
   

2. Create a main.py file for the actual job code. Copy the following sample lines into it:

   import json
   import os
   import random
   import sys
   import time
   
   # Retrieve Job-defined env vars
   TASK_INDEX = os.getenv("CLOUD_RUN_TASK_INDEX", 0)
   TASK_ATTEMPT = os.getenv("CLOUD_RUN_TASK_ATTEMPT", 0)
   # Retrieve User-defined env vars
   SLEEP_MS = os.getenv("SLEEP_MS", 0)
   FAIL_RATE = os.getenv("FAIL_RATE", 0)
   
   
   # Define main script
   def main(sleep_ms=0, fail_rate=0):
       """Program that simulates work using the sleep method and random failures.
   
       Args:
           sleep_ms: number of milliseconds to sleep
           fail_rate: rate of simulated errors
       """
       print(f"Starting Task #{TASK_INDEX}, Attempt #{TASK_ATTEMPT}...")
       # Simulate work by waiting for a specific amount of time
       time.sleep(float(sleep_ms) / 1000)  # Convert to seconds
   
       # Simulate errors
       random_failure(float(fail_rate))
   
       print(f"Completed Task #{TASK_INDEX}.")
   
   
   def random_failure(rate):
       """Throws an error based on fail rate
   
       Args:
           rate: a float between 0 and 1
       """
       if rate < 0 or rate > 1:
           # Return without retrying the Job Task
           print(
               f"Invalid FAIL_RATE env var value: {rate}. "
               + "Must be a float between 0 and 1 inclusive."
           )
           return
   
       random_failure = random.random()
       if random_failure < rate:
           raise Exception("Task failed.")
   
   
   # Start script
   if __name__ == "__main__":
       try:
           main(SLEEP_MS, FAIL_RATE)
       except Exception as err:
           message = (
               f"Task #{TASK_INDEX}, " + f"Attempt #{TASK_ATTEMPT} failed: {str(err)}"
           )
   
           print(json.dumps({"message": message, "severity": "ERROR"}))
           sys.exit(1)  # Retry Job Task by exiting the process

   Cloud Run jobs allows users to specify the number of tasks the job is to execute. This sample code shows how to use the built-in CLOUD_RUN_TASK_INDEX environment variable. Each task represents one running copy of the container. Note that tasks are usually executed in parallel. Using multiple tasks is useful if each task can independently process a subset of your data.

   Each task is aware of its index, stored in the CLOUD_RUN_TASK_INDEX environment variable. The built-in CLOUD_RUN_TASK_COUNT environment variable contains the number of tasks supplied at job execution time via the --tasks parameter.

   The code shown also shows how to retry tasks, using the built-in CLOUD_RUN_TASK_ATTEMPT environment variable, which contains the number of times this task has been retried, starting at 0 for the first attempt and incrementing by 1 for every successive retry, up to --max-retries.

   The code also lets you generate failures as a way to test retries and to generate error logs so you can see what those look like.

3. Create a text file named Procfile with no file extension, containing the following:

   web: python3 main.py

Your code is complete and ready to be packaged in a container.

Build jobs container, send it to Artifact Registry and deploy to Cloud Run

Important: This quickstart assumes that you have owner or editor roles in the project you are using for the quickstart. Otherwise, refer to the Cloud Run Source Developer role for the required permissions for deploying a Cloud Run resource from source.

This quickstart uses deploy from source, which builds the container, uploads it to Artifact Registry, and deploys the job to 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

where PROJECT_ID is your project ID and REGION is your region, for example, us-central1. Note that you can change the various parameters to whatever values you want to use for your testing purposes. SLEEP_MS simulates work and FAIL_RATE causes X% of tasks to fail so you can experiment with parallelism and retrying failing tasks.

Execute a job in Cloud Run

To execute the job you just created:

gcloud run jobs execute job-quickstart --region REGION

Replace REGION with the region you used when you created and deployed the job, for example us-central1.