DEV Community: Anubhav Singh

Job Scheduling on Google Cloud Platform

Anubhav Singh — Thu, 13 Apr 2023 03:56:52 +0000

Job scheduling is like conducting an orchestra; every task must play its part at the right time to create a harmonious symphony of efficiency.

In the world of software systems, job scheduling plays a critical role in ensuring efficient task execution and harmonious resource management. In this article, we'll explore what job scheduling is, the different types of scheduled jobs and how to implement job scheduling using different available methods. We'll mostly be focusing on the tools and services available for Job Scheduling on Google Cloud Platform. However, these concepts can be extended to any platform with slight modifications.

Scheduling with System Crons: A Classic Approach

For those who prefer a more traditional approach, system crons can be used for job scheduling. This method involves creating a cron job on a Compute Engine instance or Kubernetes cluster. Although system crons lack some of the features provided by GCP's managed services, they can still be a useful tool for basic scheduling tasks.

Example: Database Maintenance with System Cron

In this example, we'll create a simple cron job on a Compute Engine instance to perform periodic database maintenance.

First, SSH into your Compute Engine instance:

gcloud compute ssh my-instance --zone my-instance-zone

Next, open the crontab editor to create a new cron job:

crontab -e

Add the following line to the crontab file to schedule a database maintenance script to run every Sunday at 3 AM:

0 3 * * 7 /path/to/your/db-maintenance-script.sh

Save and exit the editor. The cron job is now scheduled to run the db-maintenance-script.sh script every Sunday at 3 AM.

Remember that system crons depend on the availability and reliability of your Compute Engine instance. If the instance experiences downtime or other issues, your scheduled tasks may not execute as expected. When using system crons, it's essential to implement monitoring and error handling to maintain the reliability of your scheduling solution.

Keep in mind that using system crons may require more manual management compared to GCP's managed services. However, they can still be a viable option for simple scheduling tasks that don't require the advanced features provided by GCP's job scheduling components.

Understanding Cron Job Timing Parameters

Cron job scheduling is based on a series of timing parameters that determine when a task should be executed. A cron job's timing is represented by a string containing five fields separated by spaces: minute, hour, day of the month, month, and day of the week.

Each field can have a specific value, a range of values, or a wildcard (*) to represent all possible values. Here's a brief explanation of each field:

Minute (0-59): Specifies the minute when the task should be executed.
Hour (0-23): Specifies the hour when the task should be executed.
Day of the month (1-31): Specifies the day of the month when the task should be executed.
Month (1-12 or JAN-DEC): Specifies the month when the task should be executed. You can use either numeric values or three-letter month abbreviations.
Day of the week (0-7 or SUN-SAT): Specifies the day of the week when the task should be executed. Both 0 and 7 represent Sunday. You can use either numeric values or three-letter day abbreviations.

Here are some examples of cron job timing parameters and their meanings:

0 3 * * *: This schedule runs the task every day at 3 AM.

0 3 * * 7: This schedule runs the task every Sunday at 3 AM.

0 3 1 * *: This schedule runs the task at 3 AM on the first day of every month.

*/15 * * * *: This schedule runs the task every 15 minutes.

Understanding the cron job timing parameters allows you to create precise schedules for your tasks, ensuring that they run exactly when needed.

GCP Job Scheduling Components

GCP provides several key components for job scheduling:

Cloud Scheduler: A managed cron service for time-based tasks
Cloud Functions: A serverless platform for event-driven functions
Cloud Pub/Sub: A global messaging service for event-driven architectures
Cloud Workflows: A serverless workflow orchestration service

These components are crucial for creating efficient scheduling solutions. For an in-depth understanding of each component, consult the GCP documentation.

Scheduling Strategies: Time-based, Event-based, and Hybrid

GCP offers three primary scheduling strategies, allowing you to select the best fit for your needs:

Time-based scheduling with Cloud Scheduler: Ideal for tasks that need to run at regular intervals or specific times, such as backups or maintenance jobs.
Event-based scheduling with Cloud Functions and Cloud Pub/Sub: Perfect for tasks that need to be executed in response to specific events, such as user actions or data updates.
Hybrid scheduling: A flexible and dynamic job scheduling system that adapts to various scenarios and needs by combining both time-based and event-based approaches.

Best Practices for Job Scheduling in GCP

To ensure optimal performance and reliability, consider the following best practices:

Monitoring and Logging: Utilize tools like Cloud Monitoring and Cloud Logging to keep a close eye on the performance and progress of your scheduled tasks.
Error Handling and Retries: Implement error handling and retries in your job scheduling process to maintain system reliability and minimize the impact of failures.
Resource Allocation: Leverage GCP tools for load balancing and autoscaling to optimize resource usage and maintain system performance.
Security Considerations: Follow best practices and use GCP's security features to protect your scheduled tasks and ensure the overall security of your system.

Enhancing Job Scheduling with Google Cloud Operations Suite

Google Cloud Operations Suite, formerly known as Stackdriver, is a comprehensive suite of tools that helps developers monitor, troubleshoot, and optimize their applications on GCP. While not a job scheduling tool itself, Cloud Operations Suite can significantly enhance job scheduling by providing insights into application performance, resource usage, and potential issues.

Monitoring: With Cloud Monitoring, you can set up custom dashboards to track metrics, logs, and traces from your job scheduling components such as Cloud Functions, Cloud Scheduler, and Cloud Pub/Sub.
Logging: Cloud Logging enables you to store, search, and analyze log data from your scheduled tasks, making it easier to identify and resolve issues.
Error Reporting: Cloud Error Reporting automatically detects and reports errors from your applications, allowing you to quickly identify and resolve issues affecting your scheduled tasks.
Trace: Cloud Trace helps you analyze the performance of your applications by collecting and visualizing latency data from your job scheduling components.

By integrating Google Cloud Operations Suite with your job scheduling components, you can gain valuable insights into your application's performance and optimize your scheduling strategy for better efficiency and reliability.

Streamline Event-driven Job Scheduling with Eventarc

Eventarc is a GCP service that simplifies event-driven job scheduling by allowing you to route events from various sources to Google Cloud services or custom targets. It enables you to create event-driven applications that can react to changes in your environment, such as new files being added to Cloud Storage or updates in a Firestore database.

With Eventarc, you can create event-based job scheduling solutions that trigger Cloud Functions, Cloud Run services, or custom webhooks based on specific events. For example, you could set up a Cloud Function to process new images uploaded to Cloud Storage or trigger a Cloud Run service to handle updates in a Firestore database.

Here's how you can create a trigger using Eventarc:

Enable the Eventarc API:

gcloud services enable eventarc.googleapis.com

Create an Eventarc trigger:

gcloud eventarc triggers create my-trigger --destination-run-service=my-cloud-run-service --destination-run-region=my-region --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished"

This command creates an Eventarc trigger named my-trigger that listens for messages published to a Cloud Pub/Sub topic and sends the event to the specified Cloud Run service in the given region.

By leveraging Eventarc in your job scheduling strategy, you can create more dynamic, event-driven applications that automatically react to changes in your environment, improving efficiency and reducing the need for manual intervention.

Practical Examples of Job Scheduling in GCP

To better understand the practical applications of GCP's scheduling strategies, let's dive into some real-world examples:

Time-based Example: Automated Backups

Automate backups of your system using Cloud Scheduler to ensure data protection and recovery. To create a Cloud Scheduler job that triggers a backup, use the following gcloud command:

gcloud scheduler jobs create http my-backup-job --schedule "0 1 * * *" --http-method POST --uri https://example.com/backup --oidc-service-account-email my-sa@example.iam.gserviceaccount.com

In this example, my-backup-job is a backup job that runs daily at 1 AM, making a POST request to https://example.com/backup.

Event-based Example: Real-time Data Processing

Implement real-time data processing using Cloud Functions and Cloud Pub/Sub. For instance, you can create a Cloud Function that processes incoming data and a Cloud Pub/Sub topic to trigger the function.

First, deploy the Cloud Function:

gcloud functions deploy processData --runtime nodejs14 --trigger-topic my-data-topic --entry-point processDataFunction

In this example, processData is the function that processes incoming data, triggered by the my-data-topic Cloud Pub/Sub topic.

Then, publish a message to the Cloud Pub/Sub topic:

gcloud pubsub topics publish my-data-topic --message '{"data": "your-data-here"}'

This command publishes a message containing data to the my-data-topic topic, which triggers the processData function.

The code for this function has not been included in this blog for sake of focus on the topic. You can check it out in this Github Gist.

Hybrid Example: Inventory Management

Manage inventory with hybrid scheduling, using time-based tasks for restocking and event-based tasks for real-time updates. For instance, you can create a Cloud Scheduler job for periodic restocking and a Cloud Function triggered by Cloud Pub/Sub for processing real-time inventory updates.

First, create the Cloud Scheduler job for restocking:

gcloud scheduler jobs create http restock-job --schedule "0 2 * * 1" --http-method POST --uri https://example.com/restock --oidc-service-account-email my-sa@example.iam.gserviceaccount.com

In this example, restock-job is a restocking job that runs every Monday at 2 AM, making a POST request to https://example.com/restock.

Next, deploy the Cloud Function for real-time inventory updates:

gcloud functions deploy updateInventory --runtime nodejs14 --trigger-topic inventory-updates --entry-point updateInventoryFunction

In this example, updateInventory is the function that processes real-time inventory updates, triggered by the inventory-updates Cloud Pub/Sub topic.

Finally, publish a message to the Cloud Pub/Sub topic for inventory updates:

gcloud pubsub topics publish inventory-updates --message '{"update": "your-update-here"}'

This command publishes a message containing an inventory update to the inventory-updates topic, which triggers the updateInventory function.

Conclusion

GCP offers a robust set of tools for efficient job scheduling, ensuring optimal resource usage, scalability, and fault tolerance. By selecting the appropriate scheduling strategy and following best practices, developers can craft robust and efficient scheduling solutions tailored to their specific needs. With a deeper understanding of GCP job scheduling, you can unlock the full potential of your applications and tackle even the most complex systems.

Happy scheduling!

Python Websockets SSL with Let's Encrypt

Anubhav Singh — Thu, 05 Jan 2023 16:35:35 +0000

This tutorial is an explanation of my gist Python Websockets SSL with Let's Encrypt
.

With the launch of HTML5 in 2008, a technology that immediately took off in popularity was WebSockets. According to W3C, the basic definition of a Websocket is - an interface that enables web applications to maintain bidirectional communications with server-side processes.

In this short tutorial, I'll be showing you how you can host a WebSocket server with SSL enabled on it. This allows your socket server to run on an HTTPS address.

Setup

We'll be working with asyncio library and for WebSocket server implementation will be using the websockets library.

The asyncio library comes pre-packaged with Python distributions since Python 3.4. To install websockets library, you can use the following command:

pip install websockets

Next, we'll be looking to how to generate the SSL certificate files.

Generate certificate and keyfile using Let's Encrypt

Before you can enable SSL on your WebSocket being run by a Python script, you'll have to generate certificate files for your domain.

The basic gist of this step is to fetch Let's Encrypt signed certficiates for your domain and store them on your server where the Python WebSocket script is running.

Here's a great quick tutorial on How To Use Certbot Standalone Mode to Retrieve Let's Encrypt SSL Certificates on Ubuntu 20.04.

Make certificate files accessible

After generating the files correctly, you need to make them accessible to the current user who runs the Python WebSocket script.

In the previous step, if certbot stored your certificate files at /etc/letsencrypt/live/your_domain location, you should be able to see 4 files when you perform an ls on the folder -

~$ ls /etc/letsencrypt/live/your_domain
cert.pem  chain.pem  fullchain.pem  privkey.pem  README

To change the owner of the certificate files, use the following command:

~$ sudo chown -R $(id -u):$(id -g) /etc/letsencrypt/live/your_domain

Next, ensure that the right permissions are applied to the folder:

~$ sudo chmod -R 400 /etc/letsencrypt/live/your_domain

We're now good to read these files from the Python WebSocket script.

Create server script

While your WebSocket server script will differ from the most barebones implementation, here's one for you -

Create a file named socket_server.py. Then, make all the necessary imports.

#!/usr/bin/env python

# WS server example that synchronizes state across clients

import asyncio
import json
import logging
import websockets
import ssl

logging.basicConfig()

Next, let us configure the SSL for this script, as shown below -

ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)

# Generate with Lets Encrypt, chown to current user and 400 permissions
ssl_cert = "/etc/letsencrypt/live/your_domain/fullchain.pem"
ssl_key = "/etc/letsencrypt/live/your_domain/privkey.pem"

ssl_context.load_cert_chain(ssl_cert, keyfile=ssl_key)

The above code configures the script to run a TLS server with the certificates available in the folder generated by certbot.

Next, we define the functions that shall be used to notify clients of the socket server and to get information from them.

STATE = {"value": 0}

USERS = set()


def state_event():
    return json.dumps({"type": "state", **STATE})


def users_event():
    return json.dumps({"type": "users", "count": len(USERS)})


async def notify_state():
    if USERS:  # asyncio.wait doesn't accept an empty list
        message = state_event()
        await asyncio.wait([user.send(message) for user in USERS])


async def notify_users():
    if USERS:  # asyncio.wait doesn't accept an empty list
        message = users_event()
        await asyncio.wait([user.send(message) for user in USERS])

After that, we need to add functions that register and unregister clients from the WebSocket.

async def register(websocket):
    USERS.add(websocket)
    await notify_users()


async def unregister(websocket):
    USERS.remove(websocket)
    await notify_users()

This done, let us implement a function that gets state update requests from clients and performs it.

async def counter(websocket, path):
    # register(websocket) sends user_event() to websocket
    await register(websocket)
    try:
        await websocket.send(state_event())
        async for message in websocket:
            data = json.loads(message)
            if data["action"] == "minus":
                STATE["value"] -= 1
                await notify_state()
            elif data["action"] == "plus":
                STATE["value"] += 1
                await notify_state()
            else:
                logging.error("unsupported event: {}", data)
    finally:
        await unregister(websocket)

Finally, we run the server.

start_server = websockets.serve(counter, "0.0.0.0", 6789, ssl=ssl_context)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

How you expose the server to the internet, I shall leave that on your use case. However, you can explore this tutorial on Websockets - Deploy behind nginx.

Implement a client page

To test the above WebSocket script, you can spin up your own client script or feel free to use the socket_client.html file I've provided.

Make sure to update the following line in the client file to point to your live server -

websocket = new WebSocket("wss://localhost:6789/");

Note that we're using the wss:// protocol here instead of ws:// protocol which is popularly found on other tutorials on the internet.

Conclusion

This was my attempt at explaining the gist I put out more than an year back. Hope it helps you go through the process easier than how I had first written it.

Make sure to leave me feedback on how this blog went!