Programmers often need to run some recurring process automatically at fixed intervals or at specific times. A common solution for this problem is to use a cron job. When you have full access to your own server, configuring cron jobs is quite straightforward. However, how hard is it to configure cron jobs when you use an application hosting service? Some services, thankfully, provide a way for you to do this. In this article, we’ll walk through a sample mini-project that shows how to easily set up and deploy a cron job on . Render Core Concepts What Is a Cron Job? A cron job is a Unix command that runs as a background process on a schedule determined by a . Generally, cron determines the jobs to run via crontab configuration files, which consist of pairs of cron expressions and corresponding commands. cron Cron Expression What Is Render? Render is a cloud application hosting service that offers a variety of web service hosting solutions, such as static sites, web servers, databases, and, yes, even cron jobs! Render handles the hassle of hosting and deployment for you so that you can spend all of your time focusing on building out your projects. What Are Render Cron Jobs? Render offers a cron job hosting service that simplifies the process of deploying and maintaining a cron job in the cloud. To set up a Render cron job service, simply link a GitHub repo, choose a runtime, and provide the command to run and the cron expression to determine the schedule. Overview of Our Mini-Project Our project will be a simple service that lets us create and store notes. The service also runs an hourly cron job to email us all the notes created in the last hour. The application consists of three parts: An Express web server that handles requests to create the notes A PostgreSQL database to store the notes A cron job that sends the notes digest email We'll use Render services for each of these components. We'll also use as the service for sending out emails. For our Node.js application, we’ll add the following dependency packages: Mailjet to interact with the database pg as a quality-of-life upgrade that allows us to use async functions as our Express handlers express-async-handler , which is the official client library that interacts with the Mailjet API node-mailjet We’ll assume that you have on your development machine. In our demo code, we’ll use for our package manager. Node.js installed Yarn Setting Up the Project Repo Let's start by setting up our project repo and our web service on Render. We can fork Render's Express Hello World repo for our initial . Express server boilerplate code In Render, we that uses the forked repo. create a web service page We enter a name for our web service, and we proceed with all of the default values. After Render finishes deploying, we see a service URL. We can visit that URL in our browser to verify that everything was set up correctly. Now, we can clone the forked repo to our development machine, and then add our dependencies: ~/project$ yarn add pg express-async-handler node-mailjet With our initial project repo set up, let’s move on to setting up our database. Setting Up the Database Our database is very simple, consisting of just one table called notes. The table will have a column to store the note text and another column to store the timestamp when the note was created. We’ll on Render. create a PostgreSQL database service We provide a name for the database service and then use the default values for all other options. After creating the database, we can connect to it from our local machine and create the table. Copy the connection string from the database dashboard, and then start up a in your local project directory. We'll use a to make the query to our database, so we'll need to import the class and create a object with our external connection string: notes external node REPL connection pool Pool Pool const { Pool } = require('pg');
const pool = new Pool(
  { connectionString: '<External Connection String>?ssl=true'}
); Note that since we are connecting through SSL in the REPL, we need to append to the end of the connection string. With our pool object created, we can execute the query to create the table: node ?ssl=true pool.query(
  'CREATE TABLE notes (text text, created timestamp);',
  console.log
); Voila! Our database is set up with our table! notes Setting Up an Environment Group in Render Before we add the functionality to our web service to start populating the table, let's make sure that our web service has access to our database. In fact, because both our web service and cron job will need to connect to the database, we can take advantage of Render's environment groups to create a shared group of environment variables that we can use for both services. To do this, we'll want the connection string from the database dashboard, since both the web service and cron job will communicate with the database through Render’s internal network. Click on in the main Render navigation. internal Env Groups Next, click on . New Environment Group Choose a name for your environment group. Then, add a new variable with a key of , and paste the internal connection string as the value (no need for this time). CONNECTION_STRING ssl=true Once you've created the group, you can go back to the settings for the web service. In the section, you can select the environment group you just created, and click on . Now, our Node.js code can access any variables we define in this group through the global object. We’ll see an example of this as we start to build out our Express app. Let’s do that now! Environments Linked Environment Groups Link process.env Creating the Express App Our Express app will only have one endpoint, , where we'll handle and requests. /notes POST GET When we receive a request, we create a new note row in the database. We'll expect the of the request to be and the body to be formatted as . We'll also note the time of the request and store that timestamp as the note's value. POST Content-Type application/json {"note": "<note text>"} created When we receive a request, we'll query the database for all the notes and return them as a JSON response. GET Let's start by getting rid of all of the unnecessary code from our boilerplate. We only need to keep the following lines, and we change the callback slightly: app.listen const express = require('express');
const app = express();
const port = process.env.PORT || 3001;

app.listen(port, () => console.log(`Notes server listening on port ${port}!`)); Next, let's add all of the imports we'll need. Again we’ll use a connection to connect to the database: Pool const { Pool } = require('pg'); Additionally, we’ll make use of the package: express-async-handler const asyncHandler = require('express-async-handler'); We instantiate our with the environment variable: Pool CONNECTION_STRING const connectionString = process.env.CONNECTION_STRING;
const pool = new Pool({connectionString}); Since we're expecting a JSON request, let's also use , which will parse the request body into a JavaScript object that we can access at : POST JSON middleware from Express req.body app.use(express.json()); Handling Requests GET /notes Now we can get into the meat of our app: the request handlers. We'll start with our handler since it's a bit simpler. Let’s show the code first, and then we’ll explain what we’ve done. GET app.get('/notes', asyncHandler(async (req, res) => {
  const result = await pool.query('SELECT * FROM notes;');
  res.json({ notes: result.rows });
})); First, we register an async function with at the endpoint using . In the body of the callback, we want to select all the notes in the database using . We return a JSON response with all of the rows we received from the database. asyncHandler /notes app.get pool.query And that's all we need for the handler! GET At this point, we can commit and push these changes. Render automatically builds and redeploys our updated application. We can verify that our handler works, but for now, all we see is a sad, empty notes object. GET Handling Requests POST /notes Let's move on to our handler so that we can start populating our database with some notes! Our code looks like this: POST app.post('/notes', asyncHandler(async (req, res) => {
  const query = {
    text: 'INSERT INTO notes VALUES ($1, $2);',
    values: [req.body.note, new Date()],
  };
  await pool.query(query);
  res.sendStatus(200);
})); First, we insert a new row into our database with our note text and creation timestamp. We get the note text from , and we use to get the current time. The object is converted into a PostgreSQL data type through our use of . We send the insert query, and then we return a response. req.body.note new Date() Date parameterized queries 200 Deploy and Test After pushing our code and having Render redeploy, we can test our server by sending some test requests. At the command line, we use : curl curl -X POST <INSERT WEB SERVICE URL>/notes \
     -H 'Content-Type: application/json' \
     -d '{"note": "<INSERT NOTE TEXT>"}' You can then visit the endpoint in your browser to see all of your newly created notes! /notes Creating the Cron Job The last component that ties our project together is the cron job. This cron job will run at the top of every hour, emailing us with all the notes created in the last hour. Set Up Mailjet We’ll use Mailjet as our email delivery service. You can sign up for a free account . here You’ll need your Mailjet API key and secret key from the API key management page. Let's add these keys to the environment group we created earlier. Add the following environment variables: MAILJET_APIKEY MAILJET_SECRET : the name of the email recipient (your name) USER_NAME : the email address of the recipient (your email address) USER_EMAIL Implement Cron Job Script Now let's write the script we'll run as the cron job, which we can call . Again, we'll use a to query our database, and we'll also want to initialize our Mailjet client with our environment variables: mail_latest_notes.js Pool const { Pool } = require('pg');
const mailjet = require ('node-mailjet')
  .connect(process.env.MAILJET_APIKEY, process.env.MAILJET_SECRET);
const connectionString = process.env.CONNECTION_STRING;
const pool = new Pool({connectionString}); Next, let's query the database for all notes created in the last hour. Since this will be an asynchronous operation, we can wrap the rest of the script in an , which will allow us to use the keyword to make it easier to work with: async IIFE await (async () => {
  // all remaining code will go here
})(); We use another parameterized query with to capture the current time and use it to filter the notes. This time, however, we'll want to get the time an hour before the current time, which we can do using the and Date methods, so that we can filter for all the notes after that timestamp: new Date() setHours getHours const timestamp = new Date();
timestamp.setHours(timestamp.getHours() - 1);
const query = {
  text: 'SELECT * FROM notes WHERE created >= $1;',
  values: [timestamp],
};
const result = await pool.query(query); We check how many rows were returned, and we won’t send the email if there aren’t any notes to send. if (result.rows.length === 0) {
  console.log('No latest notes');
  process.exit();
} If there are rows, then we create the email message with the retrieved notes. We pull out the text from each note row with a and use HTML for some easy formatting, joining all the note texts with tags: map <br> const emailMessage = result.rows.map(note => note.text).join('<br>'); Finally, we use the Mailjet client to with the message we just created and the environment variables we set up earlier. We can also log the response we get back from Mailjet, just to make sure that our email was sent: send an email const mailjetResponse = mailjet
  .post('send', {'version': 'v3.1'})
  .request({
    'Messages':[{
      'From': {
        'Email': process.env.USER_EMAIL,
        'Name': process.env.USER_NAME
      },
      'To': [{
        'Email': process.env.USER_EMAIL,
        'Name': process.env.USER_NAME
      }],
      'Subject': 'Latest Notes',
      'HTMLPart': `<p>${emailMessage}</p>`
    }]
  });

console.log(mailjetResponse); That's all we need for our script! Set Up Render Cron Job Service Lastly, let's create the cron job service on Render. We give our cron job service a name and set the environment to . Then, we set the command field to . To run the script every hour, we set the schedule field to the cron expression . Render has a nifty label under the input which shows what the cron expression translates to in plain English. We create the cron job. Node node mail_latest_notes.js 0 * * * * Next, we go to the tab for the cron job service, and we link the environment group that we created earlier. All that's left to do is wait for Render to finish building our cron job service. Then, we can test it! Before the build finishes, you can create more notes to make sure the script sends an email. Finally, you can click on the button on the cron dashboard to manually run the script, and check your inbox to make sure you receive that email. Environment Trigger Run And with that, we've finished our notes project! Conclusion Job schedulers like are powerful tools that provide a simple interface to run automated processes on strict schedules. Some application hosting services — like Render — make it easy for you to set up cron job services alongside your web and database services. In this article, we walked through how to do just that, by building a mini-project that saves notes and then sends an email digest triggered hourly by a cron job. With Render, coordinating communication between our various components and setting up the cron job was straightforward and simple. cron Happy coding! Also Published Here

Alongside

Mozilla

Deploying Apache Kafka With Kubernetes

What is a Data Reliability Engineer?

Nominated for 2022 - HackerNoon Contributor of the Year - Heroku

Nominated for 2022 - No No No Nodejs

Nominated for 2022 - HackerNoon Contributor of the Year - Jobs

Nominated for 2022 - HackerNoon Contributor of the Year - Npm

Nominated for 2022 - HackerNoon Contributor of the Year - Kubernetes

Nominated for 2022 - HackerNoon Contributor of the Year - Engineering

Too Long; Didn't Read

Scheduled Cron Jobs with Render

Scheduled Cron Jobs with Render

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Breaking Free From Going Solo: Learning to Collaborate on API Development with Postman

5 Tips for Evaluating Your Cloud Service Provider's Security

7 Critical Challenges Caused by SaaS

Are AWS and GCP Actually 'Secure'?

Cloud Computing Systems 101: An Overview

Breaking Free From Going Solo: Learning to Collaborate on API Development with Postman

5 Tips for Evaluating Your Cloud Service Provider's Security

7 Critical Challenges Caused by SaaS

Are AWS and GCP Actually 'Secure'?

Cloud Computing Systems 101: An Overview

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps