Introduction

Mastering SQL functions is essential for efficient data manipulation in relational databases. Whether you’re using mathematical functions to calculate totals or date manipulation functions to adjust timestamps, SQL offers powerful tools for data transformation. In this article, we’ll dive into SQL’s most useful functions—like string manipulation functions for text formatting and aggregate functions such as COUNT, MAX, MIN, AVG, and SUM—for summarizing and analyzing large datasets. By learning how to use these functions, you’ll be able to perform complex calculations, transform data, and retrieve exactly what you need from your database. Let’s explore how SQL can help you manage and manipulate data more efficiently.

Connecting to MySQL and Setting up a Sample Database

In this section, you’ll connect to a MySQL server and create a sample database, which will help you practice and follow along with the examples in this guide. Now, if your SQL database system is running on a remote server, the first thing you’ll need to do is SSH into your server from your local machine. Here’s the command for that:

$ ssh samy@your_server_ip

Just replace sammy with your actual server username, and your_server_ip with the IP address of your server.

Once you’re connected, you’ll need to open up the MySQL server prompt. To do that, run the following command, replacing sammy with your MySQL user account name:

$ mysql -u samy -p

After hitting enter, you’ll be asked to enter the MySQL user password. Once that’s done, you’ll be logged into the MySQL shell.

Now, let’s get started by creating a database for testing. We’ll call this database “bookstore.” Run this SQL command to create it:

CREATE DATABASE bookstore;

If everything goes as planned, you’ll see the following confirmation message:

Query OK, 1 row affected (0.01 sec)

Next, to start working with the bookstore database, you’ll need to select it for use. Use this command to switch to the bookstore database:

USE bookstore;

Once that’s done, you should see this confirmation:

Database changed

At this point, the bookstore database is ready to go, and you can start creating tables inside it. For the sake of this guide, let’s pretend we’re setting up a real bookstore that sells books by different authors. We’re going to create a table called inventory to store the data about all the books in the bookstore.

The inventory table will have the following columns:

• book_id: This column will hold a unique identifier for each book. It will use the int data type and will be the primary key for the table, meaning each value here must be unique and will act as the reference for each book.
• author: This column will store the name of the author of each book. It will use the varchar data type with a maximum length of 50 characters.
• title: This will store the book’s title and will allow up to 200 characters, also using the varchar data type.
• introduction_date: This column will store the date the book was added to the bookstore, and it will use the date data type.
• stock: This column will store the number of books currently in stock, using the int data type.
• price: This column will store the price of the book. It will use the decimal data type, which will allow up to five digits before the decimal point and two digits after it.

Now that we have the columns set up, let’s create the inventory table using the following SQL command:

CREATE TABLE inventory (  book_id int,  author varchar(50),  title varchar(200),  introduction_date date,  stock int,  price decimal(5, 2),  PRIMARY KEY (book_id) );

Once this is done, if the table is created successfully, you’ll get this message:

Query OK, 0 rows affected (0.00 sec)

Next up, you’ll need to load the table with some sample data so you can practice working with SQL functions. You can do this by using the following INSERT INTO statement to add a few books to your inventory table:

INSERT INTO inventory VALUES
    (1, ‘Oscar Wilde’, ‘The Picture of Dorian Gray’, ‘2022-10-01’, 4, 20.83),
    (2, ‘Jane Austen’, ‘Pride and Prejudice’, ‘2022-10-04’, 12, 42.13),
    (3, ‘Herbert George Wells’, ‘The Time Machine’, ‘2022-09-23’, 7, 21.99),
    (4, ‘Mary Shelley’, ‘Frankenstein’, ‘2022-07-23’, 9, 17.43),
    (5, ‘Mark Twain’, ‘The Adventures of Huckleberry Finn’, ‘2022-10-01’, 14, 23.15);

This will add five books to your inventory table, each with values for the columns we set up earlier. Once you run the statement, you should see this confirmation:

Query OK, 5 rows affected (0.00 sec)
Records: 5   Duplicates: 0   Warnings: 0

Now that the bookstore database is all set up with some sample data, you’re ready to continue with the guide and start using SQL functions for more advanced data manipulation and analysis!

For a comprehensive guide on how to connect to MySQL and set up a sample database, check out this detailed tutorial on setting up MySQL with sample data and basic queries: MySQL Sample Database Setup and Querying

Understanding SQL Functions

SQL functions are basically named expressions that take in one or more values, perform some calculation or transformation on the data, and then return a new value. You can think of them like the functions in math class, you know? For example, the function log(x) in math takes an input x and gives you the value of the logarithm for that x. In SQL, we use functions to retrieve, process, and transform data that’s stored in a relational database.

When you’re working with a relational database, you typically use a SELECT query to pull out raw data from it, specifying which columns you’re interested in. This query will give you the data exactly as it’s stored, with no changes made to it. So, for instance, let’s say you want to pull out the titles and prices of books from your inventory, ordered from the most expensive to the least expensive. You’d run a query like this:

SELECT title, price, introduction_date FROM inventory ORDER BY price DESC;

Running this would give you a result like this:

title	price	introduction_date
Pride and Prejudice	42.13	2022-10-04
The Adventures of Huckleberry Finn	23.15	2022-10-01
The Time Machine	21.99	2022-09-23
The Picture of Dorian Gray	20.83	2022-10-01
Frankenstein	17.43	2022-07-23

5 rows in set (0.000 sec)

So, in the output above, we have the column names—title, price, and introduction_date—and then the actual data for each book. But, let’s say you want to mess with this data a bit before showing it, right? Like, maybe you want to round the prices to the nearest dollar or convert the titles to uppercase for some reason. This is where SQL functions come in handy. They allow you to manipulate data right as you’re pulling it out of the database.

SQL functions fall into a few different categories depending on what kind of data they’re working with. Here’s a breakdown of the most commonly used ones:

• Mathematical Functions: These are functions that work on numbers, like rounding, calculating logarithms, finding square roots, or raising numbers to a power. They help you do the math directly in your SQL queries.
• String Manipulation Functions: These deal with text, or “strings,” in your database. They let you do things like changing text to uppercase or lowercase, trimming spaces, replacing words, or even pulling out certain parts of a string.
• Date and Time Functions: As the name suggests, these work with dates and times. You can use them to do things like add or subtract days, extract the year, month, or day from a full date, or format dates to fit a specific style.
• Aggregate Functions: These functions are used to perform calculations across multiple rows of data. Things like finding the average (avg), the total sum (sum), the highest (max) or lowest (min) values, or even just counting how many rows match a certain condition (count). These are great for summarizing data.

It’s also worth mentioning that most databases, like MySQL, add extra functions that go beyond the standard SQL functions, which means the functions available to you might differ depending on the database engine you’re using. For example, MySQL has a lot of built-in functions, and if you want to learn more about them, you can always check out the official documentation.

Here’s an example of how you might use an SQL function. Let’s imagine there’s a function called EXAMPLE, and you want to use it to transform the price column in the bookstore inventory table. The query would look like this:

SELECT EXAMPLE(price) AS new_price FROM inventory;

In this query, EXAMPLE(price) is a placeholder for whatever function you’re using. It takes the values in the price column, does its thing with them, and then returns the result. The AS new_price part of the query just gives a temporary name (new_price) to the result of that function, so you can refer to it easily in your query.

Let’s say you want to round the prices instead. You could use the ROUND function like this:

SELECT ROUND(price) AS rounded_price FROM inventory;

This would round the prices to the nearest whole number. And the cool thing is, you can also use WHERE and ORDER BY clauses to filter or sort the results based on those new, transformed values.

In the next section, we’ll dive deeper into how to use mathematical functions for some commonly needed calculations in SQL.

To further explore SQL functions and their practical applications in data manipulation, check out this detailed guide on SQL functions: SQL Functions Tutorial

Using Mathematical Functions

Mathematical functions in SQL are super helpful tools that work with numbers, like the price of a book or how many books are in stock, which are common examples you’d find in a sample database. These functions come in handy for performing all sorts of calculations directly in the database, letting you adjust your data to fit your exact needs. One of the most common uses for these mathematical functions is rounding numbers, especially when you want to simplify or standardize your numerical data.

Let’s say you need to pull up the prices of all the books in your inventory, but you’d like to round those prices to the nearest whole dollar instead of keeping the decimals. In this case, you can use the ROUND function, which will help round those values. It’s especially useful when you don’t need to be precise with decimals and just want the prices to be easier to read or analyze. Here’s how you’d use it in an SQL query:

SELECT title, price, ROUND(price) AS rounded_price
FROM inventory;

Now, when you run that query, you’d get something like this:

+————————————+——-+—————+
| title | price | rounded_price |
+————————————+——-+—————+
| The Picture of Dorian Gray | 20.83 | 21 |
| Pride and Prejudice | 42.13 | 42 |
| The Time Machine | 21.99 | 22 |
| Frankenstein | 17.43 | 17 |
| The Adventures of Huckleberry Finn | 23.15 | 23 |
+————————————+——-+—————+
5 rows in set (0.000 sec)

In the output, the query gets the title and price columns as they are, and then it adds a new temporary column called rounded_price, which shows the result of rounding the prices. The ROUND(price) function rounds the prices to the nearest whole number. If you wanted to adjust how many decimal places you round to, you can simply add another argument to specify the number of decimals you want. For example, if you wanted to round the prices to one decimal place, you’d modify the query like this:

SELECT title, price, ROUND(price, 1) AS rounded_price
FROM inventory;

But wait, it gets better! The ROUND function can also be used with some basic math operations. For example, if you want to calculate the total value of books in stock (you know, multiplying the price by the number of books in stock) and then round that total to one decimal place, you can do this:

SELECT title, price, ROUND(price * stock, 1) AS stock_price
FROM inventory;

Running this query would give you something like this:

+————————————+——-+——-+————-+
| title | stock | price | stock_price |
+————————————+——-+——-+————-+
| The Picture of Dorian Gray | 4 | 20.83 | 83.3 |
| Pride and Prejudice | 12 | 42.13 | 505.6 |
| The Time Machine | 7 | 21.99 | 153.9 |
| Frankenstein | 9 | 17.43 | 156.9 |
| The Adventures of Huckleberry Finn | 14 | 23.15 | 324.1 |
+————————————+——-+——-+————-+
5 rows in set (0.000 sec)

Here, ROUND(price * stock, 1) first multiplies the price of each book by the number of books in stock, and then it rounds the result to one decimal place. This is super helpful if you need to show the total value of the books in stock but want to keep things neat and easy to read. It’s perfect for things like financial reports or just making the numbers look more user-friendly.

There are other mathematical functions in MySQL that do a whole range of operations, like trigonometric functions (sine, cosine, tangent), square roots, powers, logarithms, and exponentials. These are more complex functions that come in handy when you need to do advanced calculations in your SQL queries.

You can dig deeper into these mathematical functions by checking out other tutorials and resources on mathematical expressions and aggregate functions in SQL.

Next, we’ll switch gears and talk about string manipulation functions, which are going to help you work with text data from your database—like formatting book titles, author names, or any other kind of text-based info. These functions are really handy when you need to tweak string values to meet your formatting needs.

To gain a deeper understanding of mathematical functions in SQL and their various applications, check out this comprehensive resource on mathematical operations in SQL: SQL Mathematical Functions Overview

Using String Manipulation Functions

String manipulation functions in SQL are incredibly powerful tools that allow you to modify and transform text data stored in your database. These functions are essential when you need to alter or format values stored in text-based columns, enabling more flexible querying and data processing. They are useful in many different scenarios, like when you want to standardize text, combine multiple columns into one, or replace parts of a string with other values.

One of the most common string manipulation functions is LOWER, which is used to convert all text in a column to lowercase. For instance, if you need to retrieve book titles but want to present them uniformly in lowercase, you can use this function to perform the transformation. Here is an example of how to use it:

SELECT LOWER(title) AS title_lowercase FROM inventory;

When you execute this query, the following output will be generated:

+————————————+
| title_lowercase |
+————————————+
| the picture of dorian gray |
| pride and prejudice |
| the time machine |
| frankenstein |
| the adventures of huckleberry finn |
+————————————+
5 rows in set (0.001 sec)

In this result, the LOWER function has successfully converted all the titles to lowercase. The transformation is displayed in the temporary column labeled title_lowercase, which is specified by the AS alias. By using this approach, you can ensure that the text data is consistently formatted, which is especially useful when you need to perform case-insensitive comparisons or display all data in a standardized case.

Similarly, if you want to ensure that all text data is in uppercase, you can use the UPPER function. For example, to retrieve all authors’ names in uppercase, you can use the following SQL query:

SELECT UPPER(author) AS author_uppercase FROM inventory;

The output of this query will look like this:

+———————-+
| author_uppercase |
+———————-+
| OSCAR WILDE |
| JANE AUSTEN |
| HERBERT GEORGE WELLS |
| MARY SHELLEY |
| MARK TWAIN |
+———————-+
5 rows in set (0.000 sec)

In this case, the UPPER function has transformed the author names into uppercase letters. This is especially helpful if you want to ensure that all text data is consistent in its letter casing, which can be essential for certain kinds of reporting, matching, or sorting operations. Both the LOWER and UPPER functions can be applied when you need uniformity in the presentation of textual data across different parts of your database.

Another useful string manipulation function in SQL is CONCAT, which allows you to combine multiple string values into one. This can be especially helpful when you want to display or retrieve data from multiple columns, like combining the author’s name and the book title into a single output. You can execute the following SQL query to concatenate the author’s name with the book title, separated by a colon and a space:

SELECT CONCAT(author, ‘: ‘, title) AS full_title FROM inventory;

The resulting output will be as follows:

+————————————————+
| full_title |
+————————————————+
| Oscar Wilde: The Picture of Dorian Gray |
| Jane Austen: Pride and Prejudice |
| Herbert George Wells: The Time Machine |
| Mary Shelley: Frankenstein |
| Mark Twain: The Adventures of Huckleberry Finn |
+————————————————+
5 rows in set (0.001 sec)

Here, the CONCAT function takes three arguments: the author column, the string : (a colon and a space), and the title column. The result is a single string combining the author’s name with the book title, presented in a new column called full_title. This type of operation is useful when you need to merge two or more columns into one, such as displaying full names, addresses, or other concatenated data.

In addition to these basic string manipulation functions, MySQL provides several other powerful functions for more advanced operations. These include functions for searching and replacing parts of a string, retrieving substrings, padding or trimming string values to fit a specified length, and even applying regular expressions for pattern matching within strings. These functions expand the range of string manipulation you can perform, enabling you to handle more complex text processing tasks directly within SQL.

You can explore more about using SQL functions for concatenating values and performing other text operations in specialized tutorials, as well as consult the official documentation for string functions and operators provided by MySQL for more advanced use cases.

In the next section, you will learn how to use SQL functions to manipulate date and time data from the database, enabling you to extract, format, and calculate date values as needed.

To dive deeper into the various ways you can manipulate string data in SQL, check out this detailed guide on string operations in SQL: SQL String Functions Overview

Using Date and Time Functions

Date and time functions in SQL are crucial tools for manipulating and working with columns that store date and timestamp values. These functions allow you to extract specific components of dates, perform date arithmetic, and format dates and timestamps into the desired output structure. By using these functions, you can efficiently handle tasks such as retrieving specific parts of a date (like the year, month, or day) or calculating the difference between two dates, among other operations.

For instance, imagine you have a table containing book information, and you need to extract the year, month, and day from each book’s introduction date, instead of displaying the entire date in one column. To accomplish this, you can use the YEAR, MONTH, and DAY functions in SQL. Here’s an example query that demonstrates how to split the introduction date into its individual components:

SELECT introduction_date, YEAR(introduction_date) AS year, MONTH(introduction_date) AS month, DAY(introduction_date) AS day
FROM inventory;

When you run this SQL query, the result will look like this:

+——————-+——+——-+——
| introduction_date | year | month | day |
+——————-+——+——-+——
| 2022-10-01 | 2022 | 10 | 1 |
| 2022-10-04 | 2022 | 10 | 4 |
| 2022-09-23 | 2022 | 9 | 23 |
| 2022-07-23 | 2022 | 7 | 23 |
| 2022-10-01 | 2022 | 10 | 1 |
+——————-+——+——-+——
5 rows in set (0.000 sec)

In this example, each of the date components—year, month, and day—has been extracted using the respective functions. This lets you analyze the individual date elements separately, which can be useful for reporting, filtering data by specific date components, or performing date-based calculations.

Another helpful function when dealing with dates in SQL is DATEDIFF. This function calculates the difference between two dates and returns the result in terms of the number of days. This is especially useful when you need to find the number of days between two events, like how much time has passed since a book was added to the inventory. You can use the following SQL query to calculate how many days have passed since each book was added:

SELECT introduction_date, DATEDIFF(introduction_date, CURRENT_DATE()) AS days_since
FROM inventory;

When you run this query, you’ll see the following output:

+——————-+————+
| introduction_date | days_since |
+——————-+————+
| 2022-10-01 | -30 |
| 2022-10-04 | -27 |
| 2022-09-23 | -38 |
| 2022-07-23 | -100 |
| 2022-10-01 | -30 |
+——————-+————+
5 rows in set (0.000 sec)

Here, the DATEDIFF function calculates the number of days between each book’s introduction date and the current date. If the introduction date is in the past, the result will be negative, meaning that the event happened earlier. If the introduction date is in the future, the result would be positive. The second argument used in the DATEDIFF function is CURRENT_DATE(), which represents today’s date, and the first argument is the column containing the book’s introduction date.

It’s important to note that the DATEDIFF function is not part of the official SQL standard. While many relational databases support this function, its syntax can differ between different database management systems (DBMS). This example uses MySQL’s syntax, so if you’re using a different system, you might want to check the documentation for that specific system.

In addition to DATEDIFF, MySQL provides a bunch of other handy date manipulation functions. For example, you can perform date arithmetic to add or subtract specific time intervals from a given date—days, months, years, you name it. You can also format dates into different styles to suit your location or reporting needs, retrieve day or month names from a date, or even generate new date values based on specific calculations.

For more information on date functions and how to work with dates in SQL, you can dive into the MySQL documentation or check out specialized tutorials on handling dates and times in SQL. These functions are key when you need to manipulate and process date values directly within your database, making SQL a super helpful tool for time-based analysis.

In the next section, we’ll dive into how to use aggregate functions in SQL to summarize and analyze data across multiple rows, letting you perform complex calculations and derive insights from your data.

For more insights on working with date and time functions in SQL, you can explore this detailed guide on date manipulation techniques in SQL: SQL Date Functions Explained

Using Aggregate Functions

In the previous examples, you used SQL functions to apply transformations or calculations to individual column values within a single row, representing a specific record (like a book in a bookstore). But here’s the thing: SQL also has this awesome ability to perform calculations and gather summary data across multiple rows, which allows you to pull aggregate information about your whole dataset. Aggregate functions work with groups of rows to compute a single value that represents that group. These functions give you a way to analyze your data more holistically by calculating things like totals, averages, counts, maximums, minimums, and more.

The main aggregate functions in SQL are:

• AVG: This one calculates the average value of a column.
• COUNT: This counts the number of rows or non-null values in a column.
• MAX: This finds the highest value in a column.
• MIN: This finds the lowest value in a column.
• SUM: This adds up the values in a column.

You can even combine these aggregate functions in a single SQL query to do multiple calculations all at once. For example, imagine you’re working with a bookstore’s inventory database, and you want to find out the total number of books, the maximum price of a book, and the average price of all books. You can use this query to get all that info in one go:

SELECT COUNT(title) AS count, MAX(price) AS max_price, AVG(price) AS avg_price FROM inventory;

And when you run this query, you’ll see an output like this:

+——-+———–+———–+
| count | max_price | avg_price |
+——-+———–+———–+
| 5 | 42.13 | 25.106000 |
+——-+———–+———–+
1 row in set (0.001 sec)

So, here’s how it works:

• COUNT counts the rows in the table. In this case, it’s counting the number of books (which means it counts the non-null values in the title column), and it returns a count of 5.
• MAX finds the highest value in the price column, and in this case, the max price is 42.13.
• AVG calculates the average of the prices in the price column and returns an average of 25.106000 across all the books.

These functions work together to give you a single row with temporary columns that show the results of these aggregate calculations. The source rows are used to perform the math, but they’re not part of the output—just the aggregated values show up.

Another super handy feature of SQL’s aggregate functions is that you can divide the data into groups and calculate the aggregate values for each group separately. This is really helpful when you need to do group-based analysis, like finding averages or totals within specific parts of your data. You can do this by using the GROUP BY clause.

For example, let’s say you want to calculate the average price of books for each author to see which author’s books are the priciest. You’d use a query like this:

SELECT author, AVG(price) AS avg_price FROM inventory GROUP BY author;

This query will give you the average price of books for each author. The GROUP BY clause groups the rows by the author column, and the AVG(price) function is applied to each group individually.

But wait, there’s more! You can combine GROUP BY with other SQL clauses, like ORDER BY, to sort your aggregated results. For example, you could sort the average prices of books by author, from highest to lowest, to find out which authors have the most expensive books on average.

These are some pretty cool techniques to help you analyze your data more deeply and uncover insights you might have missed. You can also explore how to combine GROUP BY and ORDER BY in SQL for more complex aggregation and sorting operations. It’s all about analyzing your data in a structured way, so you can spot trends and patterns that might not be obvious otherwise.

And if you’re feeling adventurous and want to dive deeper into mathematical expressions or working with aggregates in SQL, there are additional tutorials out there that explore these concepts even more.
For a deeper understanding of SQL aggregate functions and their usage, you can refer to this helpful resource: Understanding Aggregate Functions in SQL

Conclusion

In conclusion, mastering SQL functions is essential for effective data manipulation and analysis. Whether you’re working with mathematical functions to compute totals, string manipulation functions to format text, or date manipulation functions to manage time-based data, SQL offers powerful tools to streamline data retrieval. By using aggregate functions like COUNT, MAX, MIN, AVG, and SUM, you can efficiently summarize large datasets and extract valuable insights. As SQL continues to evolve, it’s crucial to stay updated with new functions and techniques to enhance your database management skills. Embrace these SQL functions to unlock the full potential of your data and make more informed decisions.

Master MySQL: Create Tables and Insert Data with SQL Commands

Introduction

Setting up NFS (Network File System) on Rocky Linux 9 allows seamless sharing of directories between a server and client. By configuring NFS, you can efficiently manage networked file access and storage across systems. This step-by-step guide will walk you through installing NFS utilities, configuring shared directories, and ensuring smooth mounting and unmounting of shares. Whether you’re managing a small network or setting up enterprise-level systems, mastering NFS on Rocky Linux 9 can enhance your file management capabilities. Let’s dive into the essential steps for setting up NFS on your system.

Step 1 — Downloading and Installing the Components

Alright, so here’s where the fun begins! You’re about to kick off the setup by getting the essential parts that make nfs work smoothly on both your host and client servers running Rocky Linux. Think of these components like the glue that keeps shared folders connected across your network — they’re what make your systems talk to each other efficiently.

On the Host

Let’s start with your host server, which is basically the “main character” in this setup. This is the machine that’ll share its directories with others — the one that says, “Hey, I’ve got files, come grab them!” To do that, you’ll need to install the nfs-utils package using the dnf package manager. That’s where all the cool NFS tools live. Here’s the command to run:

$ sudo dnf install nfs-utils

This command grabs everything you need, downloads it, and installs all the bits and pieces that help your host share files safely and efficiently. Once it’s done, your host is officially NFS-ready — ready to start exporting shared directories like a pro.

When you’re done with that, you can move over to your client system. This is the machine that’ll reach out and mount those shared folders from the host.

On the Client

Now switch gears to your client server — this is the computer that’s going to connect to the host and use those shared directories. It’s kind of like setting up a receiver for the files you just shared. To keep both systems in sync and ensure they understand each other, you’ll need to install the same nfs-utils package here too.

Run this command on your client:

$ sudo dnf install nfs-utils

By doing this, your client gets all the tools it needs to connect, mount, and manage NFS shares like a champ. You’ll now have commands to mount directories, check connections, and even manage permissions across systems — everything you need for a smooth nfs experience on Rocky Linux.

Once both the host and client have these packages installed, you’re all set with the foundation. Both systems are now on the same page, ready to talk to each other over the network. From here, you can move on to the next exciting part — configuring how they share directories, setting up access permissions, and creating a secure way to let the data flow seamlessly between them.

Read more about installing and configuring NFS on Rocky Linux Install and Configure NFS Server on Rocky Linux

Step 2 — Creating the Share Directories on the Host

Alright, here’s where you start setting things up on your Rocky Linux host to make the nfs magic happen. You’re going to build two separate directories here, and each one shows a different way to deal with those all-powerful superuser privileges when working with shared folders. Think of it as learning how to share files safely without letting anyone accidentally mess things up. The goal is to understand how nfs handles admin-level access across systems that need to share files.

Now, superusers — or as we like to call them, root users — are basically the bosses of the system. They can do anything, anywhere, anytime. But here’s the catch: when you mount directories over nfs, those directories technically belong to another system. For safety reasons, the nfs server says, “Hold on, root, you’re not the boss here!” So, it doesn’t let superuser actions from a client run directly on the host. That means if you’re logged in as root on a client machine, you won’t be able to do things like write files as root, change file ownership, or edit protected directories inside the nfs mount.

But sometimes, you might have trusted admins on client machines who need a bit more control to do their job properly. In those cases, you can tweak your nfs server’s configuration to give them those extra powers. Just keep in mind, this also opens the door a little wider for security risks — like the chance that someone could take advantage of that access and gain root-level control over your host system. So, it’s a bit of a balancing act between convenience and safety.

Example 1: Exporting a General-Purpose Mount

Let’s kick things off with the first example. You’re going to make a general-purpose nfs mount that uses nfs’s default security settings. These defaults keep root users on client systems from pulling any admin-level tricks on your host. This kind of setup works great for shared folders in group projects, where people might upload and edit files together — like team docs, project folders, or even shared directories for web apps such as content management systems.

Start by creating the directory you’ll be sharing. You can use the -p flag with mkdir, which tells it to make the whole path if it doesn’t already exist:

$ sudo mkdir /var/nfs/general -p

Since you’re using sudo, the directory will belong to the root user on your host machine. You can double-check that by listing the details like this:

$ ls -dl /var/nfs/general

Output:

drwxr-xr-x 2 root root 4096 Apr 17 23:51 /var/nfs/general

By default, nfs has a neat safety trick — it changes any root actions from a client into actions by a special “nobody” user. This keeps those powerful client-side root privileges from touching sensitive data on the host. So, before you share this directory, you’ll want to give ownership to that “nobody” user to make sure it’s ready for shared access:

$ sudo chown nobody /var/nfs/general

Once you’ve updated the ownership, your directory is officially ready to be shared. You can now export it as an nfs share, making it safe and accessible for client systems to mount and use without putting your host’s security at risk.

Example 2: Exporting the Home Directory

Now let’s move on to something a little different — exporting the /home directory. This time, you’re setting things up so that the nfs server shares the home directories of your users stored on the host. The idea is to let people log in from different client machines and still have access to their personal files, no matter which system they’re using. It’s super handy in environments where users bounce between multiple servers but want their stuff to follow them.

The /home directory already exists on your Rocky Linux system, so you don’t need to create a new one. And whatever you do, don’t change its permissions. Messing with those could cause all kinds of chaos for users who rely on their current folder setups and file ownership. Keeping those permissions as they are makes sure everyone’s files stay accessible to the right people — and that no one accidentally locks themselves out of their own data.

By setting up these two directories — one general-purpose share and one for home directories — you’re laying down the groundwork to see how nfs manages permissions and superuser behavior between client and host systems. The first example gives you a secure, default setup, while the second one shows you how to make things more flexible when client-side admins need extra control. Both approaches give you valuable insights into how nfs works under Rocky Linux in real-world use cases.

Read more about creating and managing shared directories on a server Network File System — Documentation for Rocky Linux

Step 2 — Creating the Share Directories on the Host

Alright, let’s get things rolling on your Rocky Linux setup with nfs! In this step, you’ll be creating two separate directories on your host machine. Each one is going to show you a different way to handle superuser privileges when working with shared folders. Think of it like testing two security setups to see how permissions play out when files are shared across systems.

Superusers, often called root users, are basically the all-powerful administrators who can do anything on a system. But here’s the twist — when you’re working with nfs, any directory you mount technically belongs to another system. Because of that, the nfs server plays it safe. It doesn’t let superuser actions from a client happen directly on the host. In plain English, if you’re logged in as root on your client machine, you won’t be able to do stuff like write files as root, change who owns files, or mess with protected folders inside your mounted nfs share.

Now, sometimes you’ve got trusted admins on the client side who need that extra access to manage files properly. In those situations, you can configure your nfs server to give them the permissions they need. But fair warning — doing that opens up a little security risk. There’s always a chance that someone sneaky could abuse that access and get root-level control of your host system. So, while it’s powerful, it’s something to use carefully.

Example 1: Exporting a General-Purpose Mount

Let’s start with the first setup. Here, you’ll make a general-purpose nfs mount that sticks to the default nfs security behavior. This setup keeps root users on the client from using their admin powers to change things on your host. It’s perfect for shared spaces where multiple people are working together — maybe uploading files, editing project folders, or running web apps like content management systems that need access to shared storage.

To kick things off, create the directory you want to share. Use the -p flag with mkdir to make sure it builds the whole path if it doesn’t already exist:

$ sudo mkdir /var/nfs/general -p

Since you used sudo, the directory will belong to the root user on your host. You can check the ownership and permissions by running:

$ ls -dl /var/nfs/general

Output

drwxr-xr-x 2 root root 4096 Apr 17 23:51 /var/nfs/general

By default, nfs has a neat security rule — it translates any root actions done on the client into actions performed by the “nobody” user. This prevents root users on the client from doing anything too powerful on your host. To get this directory ready for sharing, you’ll need to switch its ownership to “nobody,” which represents anonymous access in nfs. Here’s how you do it:

$ sudo chown nobody /var/nfs/general

Once you’ve updated the ownership, this directory is ready to be shared safely as an nfs export. That means client systems can mount it and use it without compromising the host’s security.

Example 2: Exporting the Home Directory

Next up, let’s talk about exporting the /home directory. This time, the goal is to make user home directories stored on your host available to your client machines. The cool part? Admins on the clients will have just enough power to manage user files effectively without going overboard. This is super handy in multi-server environments where users log in from different systems but still need to access their personal files, no matter which machine they’re on.

The /home directory already exists on your Rocky Linux system, so no need to make a new one. Don’t touch its permissions. Changing them could cause serious headaches for users who rely on their home folders being set up in a specific way. Keeping the permissions as-is ensures that everyone can still access their files while keeping the system secure and stable.

By setting up both directories — the general-purpose one and the /home one — you’re building a solid foundation for understanding how nfs manages permissions and superuser behavior. The first setup shows you how to keep things locked down, while the second gives a bit more flexibility for trusted admins. Together, they show how nfs balances security and convenience on Rocky Linux systems that need to share files across networks.

Learn more about configuring NFS exports in Linux environments 10 Practical Examples to Export NFS Shares in Linux

Step 2 — Creating the Share Directories on the Host

Okay, so here’s the fun part of setting up your nfs environment on Rocky Linux. You’re going to make two different directories on your host machine, and each one shows a unique way to handle superuser permissions. Think of it as a little experiment to see how nfs deals with admin powers when files are being shared between systems.

Now, let’s talk about superusers — you know, the root users who basically have the keys to the entire system. They can do anything they want, whenever they want. But when you mount directories through nfs, there’s a twist. Those directories technically belong to another computer, so the nfs server gets a bit protective. For safety, it won’t let superuser commands from a client directly affect the host. That means even if you’re root on your client machine, you won’t be able to pull off root-level actions like creating files as root, changing who owns them, or tinkering with protected directories inside the mounted share.

But here’s the thing — sometimes you trust the admin on the client side. Maybe they’re responsible and just need a bit more access to do their job right. In that case, you can tweak your nfs server setup to allow those higher privileges. Just keep in mind that you’re opening a door that could, in theory, let a bad actor sneak in and get root access to your host system. So it’s a tradeoff between convenience and safety.

Example 1: Exporting a General-Purpose Mount

Alright, let’s start simple. In this first example, you’ll make a general-purpose nfs mount that sticks to the default nfs security rules. This setup keeps root users on the client from pulling any admin stunts on the host. It’s a great choice for shared spaces where lots of people are working together — like folders where teams upload project files or web apps dump their content, such as content management systems.

Start by creating the directory you want to share. Use the -p flag with mkdir just in case some parts of the path don’t exist yet — it’ll build them for you:

$ sudo mkdir /var/nfs/general -p

Since you ran this with sudo, the directory now belongs to the root user on your host system. You can double-check that by listing its details:

$ ls -dl /var/nfs/general

Output:

drwxr-xr-x 2 root root 4096 Apr 17 23:51 /var/nfs/general

Here’s what’s happening next. By default, nfs is smart — it automatically changes any root actions on the client into actions by a special “nobody” user. This stops anyone with root access on the client from messing with sensitive stuff on your host. To get this directory ready for sharing, you’ll just need to hand over ownership to that “nobody” user, which represents anonymous access in nfs.

$ sudo chown nobody /var/nfs/general

And that’s it! The directory is now ready to be shared safely. Once it’s exported, client machines can mount it and start using it without putting your host system at risk.

Example 2: Exporting the Home Directory

Next up, let’s take it up a notch. In this example, you’re going to configure your nfs server to share the /home directory. The idea here is to let users on client machines access their home folders stored on the host — pretty handy when users log into different servers but still need the same files everywhere they go. This setup also gives admins on client systems enough freedom to manage user files easily.

Since /home already exists on your Rocky Linux host, you don’t need to make a new one.

Don’t touch the permissions on this folder. Changing them could create serious issues for users who rely on their home directories working correctly.

Keeping the permissions as they are ensures that everyone can still access their own files without breaking anything.

So now you’ve got two directories — a general-purpose share and a home directory share. Together, they’ll help you see how nfs handles permissions and superuser behavior between client and host machines. The first example shows you the standard, safe setup, while the second one gives you a look at a more flexible configuration that allows client-side admin access when it’s needed. Both setups are super useful depending on your environment and trust level between systems.

Read more about configuring firewall settings for NFS on Rocky Linux Configuring firewalld for NFS Connections on Linux

Step 5 — Creating Mount Points and Mounting Directories on the Client

Now that your host server is all set up and sharing its nfs directories, it’s time to prepare the client machine. This step is where your Rocky Linux client learns how to reach out and actually use those shared folders. Think of it like connecting your computer to a shared drive so you can read, write, and manage files as if they were sitting right there on your own system.

To make the shared folders accessible, you’ll need to mount them from the host onto the client machine. Basically, you’re attaching remote directories to local ones so they appear as part of your file system. But here’s a key detail — always make sure you’re mounting onto empty directories. Otherwise, anything already inside those folders gets hidden once the nfs mount takes over.

If there are already files or folders inside your mount point, those items will seem to disappear after the mount operation because the shared nfs directory will sit right on top of it. Don’t panic — they’re not deleted, just hidden. To avoid confusion or unintentional data loss, double-check that your mount directories are empty before you start.

Let’s create the mount points. You’ll need two directories on your client machine — one for each share you created earlier on the host. The -p flag makes sure the entire folder path is created if it doesn’t already exist:

$ sudo mkdir -p /nfs/general
$ sudo mkdir -p /nfs/home

These two directories will act as the landing spots for your nfs shares. The /nfs/general directory connects to your general-purpose share, and /nfs/home links to the shared home directories from the host.

Once those directories are in place, and you’ve verified your firewall rules are allowing traffic between the host and the client, it’s time to mount the shared folders. To do that, use your host server’s IP address along with the paths of the exported directories:

$ sudo mount host_ip:/var/nfs/general /nfs/general
$ sudo mount host_ip:/home /nfs/home

What these commands do is pretty cool — they form a bridge between your client and host systems, so the host’s shared directories are now available right inside your client’s file system.

Now, let’s make sure everything worked. You can check your mounted file systems using mount or findmnt, but a friendlier way to see what’s going on is by using df -h. It shows disk usage in a nice, easy-to-read format:

$ df -h

Output:

Filesystem Size Used Avail Use% Mounted on
devtmpfs 370M 0 370M 0% /dev
tmpfs 405M 0 405M 0% /dev/shm
tmpfs 405M 11M 394M 3% /run
tmpfs 405M 0 405M 0% /sys/fs/cgroup
/dev/vda1 25G 1.5G 24G 6% /
tmpfs 81M 0 81M 0% /run/user/0
host_ip:/var/nfs/general 25G 1.6G 24G 7% /nfs/general
host_ip:/home 25G 1.6G 24G 7% /nfs/home

If you look toward the bottom, you’ll see both of your nfs shares successfully mounted under /nfs/general and /nfs/home. You’ll also notice that their sizes and usage are the same — that’s because they both come from the same file system on the host.

And just like that, your Rocky Linux client is now fully connected to the nfs server’s shared directories. You can browse, read, or write to those folders as if they were on your local machine. It’s seamless file sharing made simple, all powered by nfs.

Read more about mounting NFS shares on Linux clients How to Mount an NFS Share in Linux

Step 6 — Testing NFS Access

Alright, now that your nfs shares are up and running, it’s time to make sure everything is working the way it should. This step is all about testing your setup on Rocky Linux to confirm that file permissions, ownership, and access behave correctly between your host and client machines. Basically, we’re going to play around a bit to see if the permissions are doing what we expect.

Example 1: The General Purpose Share

Let’s start by checking out the general-purpose nfs share. This one uses the default nfs behavior, which doesn’t let root users on the client do admin-level stuff on the host’s file system. So, here’s what you’ll do: create a new test file in the /nfs/general directory using sudo.

$ sudo touch /nfs/general/general.test

Now, take a look at who owns that file by running:

$ ls -l /nfs/general/general.test

Output

-rw-r–r–. 1 nobody nobody 0 Aug 8 18:24 /nfs/general/general.test

See what happened? The file belongs to the user and group “nobody.” That’s nfs doing its thing — whenever a root user on the client tries to act on the share, nfs automatically switches that to the “nobody” user for safety. This cool feature is called root squashing. It’s basically nfs’s way of saying, “Sorry, root, not today!”

Because of this, even if you’re the superuser on the client, you can’t pull off your usual admin tricks like changing file owners, making protected folders, or editing system-level stuff inside the share. This setup is perfect for shared spaces where multiple users work together, and you don’t want anyone with local admin powers to accidentally break things or mess with the host’s data.

Example 2: The Home Directory Share

Now let’s move on to the second one — the shared home directory. This one’s a bit different because it was set up with the no_root_squash option. What that means is that root users on the client actually keep their root powers when working inside this share.

Go ahead and try it by making another test file, this time in the /nfs/home directory.

$ sudo touch /nfs/home/home.test

Once that’s done, check who owns it:

$ ls -l /nfs/home/home.test

Output

-rw-r–r–. 1 root root 0 Aug 8 18:26 /nfs/home/home.test

Now that’s interesting, right? You used the same command as before, but this time, the file is owned by “root.” That’s because the no_root_squash setting lets the client’s root account act like root on the host file system too. It’s super handy for admins who need full control — like when you’re managing user files, fixing permissions, or moving home directories around between servers.

Be cautious when using no_root_squash since it grants full root privileges to the client machine — only enable it in trusted environments.

Just keep in mind, while this setup makes life easier for system administrators, it also comes with a bit of risk. Giving root-level access to clients means there’s more power — and as we all know, with great power comes great responsibility. So, use it wisely!

After you’ve run both tests, you’ll see that everything’s working exactly as intended. The general-purpose share
Read more about verifying NFS share accessibility and permissions How to Test if an NFS Server is Accessible (LinuxIntro)

Step 7 — Mounting the Remote NFS Directories at Boot

Sometimes it’s just nice when things take care of themselves, right? In this case, you can make your nfs shares on Rocky Linux mount automatically every time the client system boots. That way, you don’t have to manually remount them after every restart. It’s a simple tweak that saves time and keeps everything running smoothly for users or services that rely on those shared folders.

Here’s the plan — you’ll set things up so that your nfs mounts load automatically at startup. All you need to do is add them to the /etc/fstab configuration file on your client machine.

First, open the file with root privileges using your favorite text editor. I’ll use nano here because it’s simple and gets the job done:

$ sudo nano /etc/fstab

Once the file is open, scroll to the bottom and add a line for each of your nfs shares. Each line tells your system which remote directory to mount, where to mount it locally, and what options to use. Here’s what those entries should look like:

/etc/fstab
. . .
host_ip:/var/nfs/general    /nfs/general    nfs    auto,nofail,noatime,nolock,intr,tcp,actimeo=1800    0    0
host_ip:/home    /nfs/home    nfs    auto,nofail,noatime,nolock,intr,tcp,actimeo=1800    0    0

Each of these options plays a specific role, and together they make sure your mounts are both reliable and fast. Let’s break them down a bit:

• auto — Automatically mounts the nfs share when your system boots up.
• nofail — Keeps the boot process going even if the nfs share isn’t available yet, which is super handy for network setups.
• noatime — Speeds things up by skipping file access time updates.
• nolock — Turns off file locking when you don’t need it, which helps reduce possible delays.
• intr — Lets you interrupt nfs operations if the server ever becomes unresponsive.
• tcp — Makes sure nfs uses TCP for more stable data transfers.
• actimeo=1800 — Sets the cache timeout to 30 minutes (that’s 1800 seconds), giving you a nice balance between speed and keeping your data fresh.

Once you’ve added those lines, save the file and close it. From now on, every time your client starts, it’ll automatically mount the nfs shares for you.

When your system boots, it might take a few seconds before the NFS server connects. Don’t worry if things don’t appear instantly — your client just needs a moment to establish a network connection before mounting the shares.

And there you have it! You’ve now automated your nfs setup on Rocky Linux, so everything connects on its own. No more manual mounting after every reboot — just a seamless, hands-free experience every time your system starts up.

Read more about setting up automatic NFS mounts at boot on Linux Configuring a File System to Automatically Mount (Linux Instances)

Step 8 — Unmounting an NFS Remote Share

So, let’s say you’re done working with your nfs shares on Rocky Linux, and you don’t need those remote directories connected anymore. No problem — you can safely disconnect them, but first, make sure you’re not currently inside one of those mounted folders. It’s like trying to take out a USB drive while still browsing its files — it won’t end well.

So, switch to your home directory first and then use the umount command like this:

$ cd ~
$ sudo umount /nfs/home
$ sudo umount /nfs/general

Oh, and here’s a small but classic Linux quirk — the command is umount, not unmount. Yeah, it’s missing that “n.” Don’t worry, you’re not typing it wrong — that’s just how Linux rolls. The umount command disconnects your nfs shares from the client, cutting off access to those remote folders.

After unmounting, only your local drives will show up. To double-check that the nfs directories are really gone, use the df -h command to see your current mounted filesystems:

$ df -h

Output

Filesystem Size Used Avail Use% Mounted on
devtmpfs 370M 0 370M 0% /dev
tmpfs 405M 0 405M 0% /dev/shm
tmpfs 405M 11M 394M 3% /run
tmpfs 405M 0 405M 0% /sys/fs/cgroup
/dev/vda1 25G 1.5G 24G 6% /
tmpfs 81M 0 81M 0% /run/user/0

See? No /nfs/home or /nfs/general listed anymore — that means your nfs shares have been completely disconnected, leaving only your local storage visible.

Now, if you’d like to stop these directories from automatically remounting the next time you reboot, you can tweak the /etc/fstab file. Open it with elevated permissions using your favorite editor — here’s an example with nano:

$ sudo nano /etc/fstab

Inside the file, find the lines that reference your nfs shares and comment them out by adding a # at the start of each one, like this:

# host_ip:/var/nfs/general /nfs/general nfs auto,nofail,noatime,nolock,intr,tcp,actimeo=1800 0 0
# host_ip:/home /nfs/home nfs auto,nofail,noatime,nolock,intr,tcp,actimeo=1800 0 0

If you don’t want to disable them completely but would rather mount them manually later, you can just remove the auto option instead. That way, the configuration stays, but nothing mounts automatically when you reboot — handy if you only need these connections occasionally.

By managing your nfs mounts this way, you stay in full control of when and how your remote directories are connected. It’s a great way to keep your Rocky Linux system clean, fast, and flexible while still being ready to reattach your shares whenever you need them.

Read more about safely disconnecting NFS shares from client systems Unmounting NFS Shares in Linux: A Comprehensive Guide

Conclusion

In conclusion, setting up NFS on Rocky Linux 9 is a straightforward yet powerful way to share directories between a server and client. By following this step-by-step guide, you can efficiently configure NFS, ensure secure access, and automate the mounting of directories, providing seamless network storage. From installing NFS utilities to testing access and managing firewall settings, this process ensures smooth and reliable file sharing across systems. As NFS continues to evolve, staying updated with the latest best practices for security and performance will further enhance your system’s file-sharing capabilities on Rocky Linux.

For further details on the process, explore more about setting up NFS on Rocky Linux 9 for optimized performance.

Set Up NFS Mount on Debian 11: Step-by-Step Guide

Introduction

Handling asynchronous tasks efficiently is a key aspect of modern web development, and with Node.js and BullMQ, developers can streamline this process. Node.js, known for its non-blocking I/O operations, combined with BullMQ’s advanced job and queue management capabilities, creates a powerful solution for handling background tasks. This article delves into how Node.js, along with BullMQ, can improve the performance and scalability of your applications by managing heavy workloads, retrying failed jobs, and processing tasks asynchronously with minimal overhead. Let’s explore how this combination is revolutionizing asynchronous task handling in web development.

Prerequisites

To follow this tutorial, you’ll need to have the following:

• A Node.js development environment set up on your system. If you’re using Ubuntu 22.04, just check out our detailed guide on how to install Node.js on Ubuntu 22.04 to get everything ready. For other systems, you can follow our How to Install Node.js and Create a Local Development Environment guide, which has steps for different operating systems.
• Redis installed on your machine. If you’re on Ubuntu 22.04, follow Steps 1 through 3 in our tutorial on installing and securing Redis on Ubuntu 22.04. For other systems, don’t worry—we’ve got you covered in our guide on how to install and secure Redis, which walks you through the steps for different platforms.
• You should be comfortable with promises and async/await functions to follow along with this tutorial. If you’re still wrapping your head around these, check out our tutorial on understanding the Event Loop, Callbacks, Promises, and Async/Await in JavaScript. This will help you get a solid understanding of these core JavaScript concepts.
• A basic knowledge of using Express.js for building web apps is also needed. If you’re new to Express.js, no worries—take a look at our tutorial on getting started with Node.js and Express. It will guide you through creating and running a simple web app using Express.
• Familiarity with Embedded JavaScript (EJS) is required for this tutorial. If you haven’t worked with EJS templating before, we recommend checking out our tutorial on how to use EJS to template your Node.js app. It covers the basics of using EJS to render dynamic views in your Node.js app.
• A basic understanding of how to process images using the Sharp library is important too. Sharp is a super-efficient image processing library for Node.js, and you’ll need to be comfortable using it to follow along. If you’re not yet familiar with Sharp, take a look at our tutorial on processing images in Node.js with Sharp. It’ll help you get up to speed with resizing, cropping, and optimizing images in your Node.js applications.

Once you’ve got these prerequisites set up, you’ll be all set to dive into this tutorial and start implementing the concepts we’re going to cover.

Read more about setting up Node.js and Redis for web applications Installing Node.js and Redis for Web Applications.

Step 1 — Setting Up the Project Directory

So, here’s the deal: we’re going to create a directory and get everything ready for your app. In this tutorial, you’ll be building something that lets users upload an image, which will then get processed with the sharp package. Image processing can be a bit slow and resource-heavy, which is why we’re going to use bullmq to move that task to the background. That way, it doesn’t slow down the rest of the app. This method isn’t just for images; it can be used for any heavy-duty tasks that you’d rather not have hanging up the main process.

Alright, let’s start by creating a directory called image_processor and then jumping into it. To do that, just run:

$ mkdir image_processor && cd image_processor

Once you’re inside the directory, the next step is to initialize the project. This will set everything up like a basic package, and it’ll create a package.json file for you. To do this, simply run:

$ npm init -y

The -y flag means npm will automatically accept all the default options. Once you do that, your terminal should show something like this:

Wrote to /home/sammy/image_processor/package.json: {
    “name”: “image_processor”, 
    “version”: “1.0.0”, 
    “description”: “”,
    “main”: “index.js”, 
    “scripts”: {
        “test”: “echo "Error: no test specified" & exit 1”
        }
    “keywords”: [],
    “author”: “”,
    “license”: “ISC”
}

That’s npm confirming it’s created the package.json file for you. Here’s what you should keep an eye on:

• name: This is the name of your app (in this case, image_processor).
• version: The current version of your app (starting at 1.0.0).
• main: This is the entry point to your app (usually index.js).

If you want to dive deeper into the other properties in the file, you can check out the npm package.json docs.

Next up, we’re going to install all the dependencies you’ll need. These are the packages that’ll help you handle image uploads, process images, and manage background tasks. Here’s the list of packages to install:

• express: This is the framework we’ll use to build our web app. It makes things like routing and handling requests super easy.
• express-fileupload: This is a handy middleware that makes handling file uploads a breeze.
• sharp: This is the magic sauce for resizing, manipulating, and optimizing images.
• ejs: A templating engine that helps us generate HTML dynamically on the server side with Node.js.
• bullmq: This is a distributed task queue that we’ll use to send tasks (like image processing) to the background so the app stays responsive.
• bull-board: This gives us a nice UI dashboard on top of bullmq to monitor the status of all our jobs and tasks.

To install everything, just run:

$ npm install express express-fileupload sharp ejs bullmq @bull-board/express

Now, you’ll need an image to play around with for the tutorial. You can use the following curl command to grab one:

$ curl -O https://deved-images.nyc3.cdn.caasifyspaces.com/

At this point, you’ve got everything installed and the image you need. You’re all set to start building your Node.js app that integrates with bullmq to handle background tasks.

Read more about creating and setting up project directories for web applications Setting Up Project Directories for Web Applications.

Step 2 — Implementing a Time-Intensive Task Without bullmq

In this step, you’ll create an app using Express where users can upload images. Once an image is uploaded, the app will kick off a time-consuming task that uses the sharp module to resize the image into multiple sizes. After the app finishes processing, the resized images will be shown to the user. This will give you a solid understanding of how long-running tasks can affect the request/response cycle in a web app.

Setting Up the Project

To get started, open up your terminal and create a new file called index.js using nano or your favorite text editor:

$ nano index.js

In your index.js file, add the following code to import the necessary dependencies:

const path = require(“path”);
const fs = require(“fs”);
const express = require(“express”);
const bodyParser = require(“body-parser”);
const sharp = require(“sharp”);
const fileUpload = require(“express-fileupload”);

Here’s what each module does:

• The path module helps you handle file paths in Node.js.
• The fs module lets you interact with the file system, like reading and writing files.
• The express module is the web framework that powers the app and its routes.
• The body-parser module helps parse incoming request bodies, like JSON or URL-encoded data.
• The sharp module makes image processing easy, including resizing and converting images.
• The express-fileupload module makes it simple to upload files from an HTML form to the server.

Configuring Middleware

Now, let’s set up middleware for your app. This middleware will handle incoming requests and manage file uploads. Add the following code in your index.js file:

const app = express();
app.set(“view engine”, “ejs”);
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(fileUpload());
app.use(express.static(“public”));

Here’s what each part does:

• const app = express(); – This creates an Express application instance.
• app.set("view engine", "ejs"); – This configures Express to use the EJS templating engine for dynamic HTML rendering.
• app.use(bodyParser.json()); – This middleware parses incoming requests with JSON payloads.
• app.use(bodyParser.urlencoded({ extended: true })); – This middleware parses URL-encoded data, which is what forms usually send.
• app.use(fileUpload()); – This middleware handles file uploads.
• app.use(express.static("public")); – This serves static files like images or CSS from the “public” folder.

Setting Up Routes for Image Upload

Next, you’ll set up a route to show an HTML form for uploading images. Add the following code in your index.js:

app.get(“/”, function (req, res) {
res.render(“form”);
});

This renders the form.ejs file when users visit the home page. The form will be used to upload the image. Now, create the views folder and go into it via the terminal:

$ mkdir views
$ cd views

Create the form.ejs file:

$ nano form.ejs

In your form.ejs file, add the following HTML code:

This form allows users to choose an image file from their computer and upload it to the server. The form uses multipart/form-data encoding to handle file uploads.

Setting Up the Image Upload Handling

Now, you’ll need to handle the file upload. Modify the index.js file and add the following code to handle the POST request to the /upload route:

app.post(“/upload”, async function (req, res) {
const { image } = req.files;
if (!image) return res.sendStatus(400); // Send a 400 error if no image is uploaded
const imageName = path.parse(image.name).name;
const processImage = (size) => sharp(image.data)
.resize(size, size)
.webp({ lossless: true })
.toFile(`./public/images/${imageName}-${size}.webp`);
const sizes = [90, 96, 120, 144, 160, 180, 240, 288, 360, 480, 720, 1440];
Promise.all(sizes.map(processImage));
let counter = 0;
for (let i = 0; i < 10_000_000_000; i++) {
counter++;
}
res.redirect("/result");
});

Here’s how it works:

• req.files contains the uploaded file. You extract the image from this object.
• If no image is uploaded, the code sends a 400 status code back to the user.
• imageName is the name of the file without its extension.
• processImage() processes the image with sharp, resizing it, converting it to WebP format, and saving it in the public/images/ directory.
• The sizes array defines all the sizes you want to resize the image into.
• Promise.all() makes sure all images are processed asynchronously.
• A CPU-intensive loop is added just to simulate a delay, allowing you to see how long the image processing takes.

Displaying the Processed Images

Now, you need a route to show the resized images after processing. Add this code in your index.js:

app.get(“/result”, (req, res) => {
const imgDirPath = path.join(__dirname, “./public/images”);
let imgFiles = fs.readdirSync(imgDirPath).map((image) => {
return `images/${image}`;
});
res.render(“result”, { imgFiles });
});

This code defines the /result route. It reads the image files from the public/images folder, creates an array of their paths, and sends that array to the result.ejs template.

Creating the Result Page

Next, create the result.ejs file to display the processed images. Open the views folder:

$ cd views
$ nano result.ejs

In your result.ejs file, add the following HTML code to show the resized images:

This code checks if there are any images in the imgFiles array. If there are, it displays each image in a list. If not, it asks the user to refresh the page in a few seconds to see the resized images.

Styling the Application

To style your app, create the necessary directories and a main.css file. In the terminal, create the public and css directories:

$ mkdir -p public/css
$ cd public/css
$ nano main.css

In main.css, add the following styles:

body {
background: #f8f8f8;
}
h1 {
text-align: center;
}
p {
margin-bottom: 20px;
}
a:link, a:visited {
color: #00bcd4;
}
button[type=”submit”] {
background: none;
border: 1px solid orange;
padding: 10px 30px;
border-radius: 30px;
transition: all 1s;
}
button[type=”submit”]:hover {
background: orange;
}
input[type=”file”]::file-selector-button {
border: 2px solid #2196f3;
padding: 10px 20px;
border-radius: 0.2em;
background-color: #2196f3;
}
ul {
list-style: none;
padding: 0;
display: flex;
flex-wrap: wrap;
gap: 20px;
}
.home-wrapper {
max-width: 500px;
margin: 0 auto;
padding-top: 100px;
}
.gallery-wrapper {
max-width: 1200px;
margin: 0 auto;
}

These styles make the page look organized and visually appealing. After adding the CSS, save the file and close it.

Starting the Server

Now that everything is set up, start the Express server. Open the terminal and run:

$ node index.js

The terminal will show that the server is running:

Server running on port 3000

Visit http://localhost:3000/ in your browser. You’ll see the image upload form. Once an image is uploaded, the app will process the image, and you’ll be redirected to the /result route to see the resized images.

Stopping the Server

To stop the server, press CTRL+C in the terminal. Remember, Node.js doesn’t automatically reload the server when files change, so you’ll need to stop and restart it whenever you update the code.

That’s all for handling time-intensive tasks and observing how they impact your app’s request/response cycle.

Read more about handling time-intensive tasks in web applications Handling Time-Intensive Tasks in Web Applications.

Step 3 — Executing Time-Intensive Tasks Asynchronously with bullmq

In this step, you will offload a time-intensive task to the background using bullmq. This adjustment will free the request/response cycle and allow your app to respond to users immediately while the image is being processed. To do that, you need to create a succinct description of the job and add it to a queue with bullmq. A queue is a data structure that works similarly to how a queue works in real life. When people line up to enter a space, the first person on the line will be the first person to enter the space. Anyone who comes later will line up at the end of the line and will enter the space after everyone who precedes them in line until the last person enters the space. With the queue data structure’s First-In, First-Out (FIFO) process, the first item added to the queue is the first item to be removed (dequeue). With bullmq, a producer will add a job in a queue, and a consumer (or worker) will remove a job from the queue and execute it. The queue in bullmq is stored in Redis.

When you describe a job and add it to the queue, an entry for the job is created in a Redis queue. A job description can be a string or an object with properties that contain minimal data or references to the data that will allow bullmq to execute the job later. Once you define the functionality to add jobs to the queue, you move the time-intensive code into a separate function. Later, bullmq will call this function with the data you stored in the queue when the job is dequeued. Once the task has finished, bullmq will mark it completed, pull another job from the queue, and execute it.

Open index.js in your editor:

nano index.js

In your index.js file, add the highlighted lines to create a queue in Redis with bullmq:

const fileUpload = require(“express-fileupload”);
const { Queue } = require(“bullmq”);

const redisOptions = {
host: “localhost”,
port: 6379
};

const imageJobQueue = new Queue(“imageJobQueue”, {
connection: redisOptions,
});

async function addJob(job) {
await imageJobQueue.add(job.type, job);
}

You start by extracting the Queue class from bullmq, which is used to create a queue in Redis. You then set the redisOptions variable to an object with properties that the Queue class instance will use to establish a connection with Redis. You set the host property value to localhost because Redis is running on your local machine.

Note: If Redis were running on a remote server separate from your app, you would update the host property value to the IP address of the remote server.

You also set the port property value to 6379, the default port that Redis uses to listen for connections. If you have set up port forwarding to a remote server running Redis and the app together, you do not need to update the host property, but you will need to use the port forwarding connection every time you log in to your server to run the app.

Next, you set the imageJobQueue variable to an instance of the Queue class, taking the queue’s name as its first argument and an object as a second argument. The object has a connection property with the value set to an object in the redisOptions variable. After instantiating the Queue class, a queue called imageJobQueue will be created in Redis. Finally, you define the addJob() function that you will use to add a job in the imageJobQueue. The function takes a parameter of job containing the information about the job (you will call the addJob() function with the data you want to save in a queue). In the function, you invoke the add() method of the imageJobQueue, taking the name of the job as the first argument and the job data as the second argument.

Add the highlighted code to call the addJob() function to add a job in the queue:

app.post(“/upload”, async function (req, res) {
const { image } = req.files;

if (!image) return res.sendStatus(400);
const imageName = path.parse(image.name).name;

await addJob({
type: “processUploadedImages”,
image: {
data: image.data.toString(“base64”),
name: image.name
},
});

res.redirect(“/result”);
});

Here, you call the addJob() function with an object that describes the job. The object has the type attribute with a value of the name of the job. The second property, image, is set to an object containing the image data the user has uploaded. Because the image data in image.data is in a buffer (binary form), you invoke JavaScript’s toString() method to convert it to a string that can be stored in Redis, which will set the data property as a result. The image property is set to the name of the uploaded image (including the image extension). You have now defined the information needed for bullmq to execute this job later. Depending on your job, you may add more job information or less.

Warning: Since Redis is an in-memory database, avoid storing large amounts of data for jobs in the queue. If you have a large file that a job needs to process, save the file on the disk or the cloud, then save the link to the file as a string in the queue. When bullmq executes the job, it will fetch the file from the link saved in Redis.

Save and close your file.

Next, create and open the utils.js file that will contain the image processing code:

nano utils.js

In your utils.js file, add the following code to define the function for processing an image:

const path = require(“path”);
const sharp = require(“sharp”);

function processUploadedImages(job) {}

module.exports = { processUploadedImages };

You import the modules necessary to process images and compute paths in the first two lines. Then you define the processUploadedImages() function, which will contain the time-intensive image processing task. This function takes a job parameter that will be populated when the worker fetches the job data from the queue and then invokes the processUploadedImages() function with the queue data. You also export the processUploadedImages() function so that you can reference it in other files.

Save and close your file.

Return to the index.js file:

nano index.js

Copy the highlighted lines from the index.js file, then delete them from this file. You will need the copied code momentarily, so save it to a clipboard. If you are using nano, you can highlight these lines and right-click with your mouse to copy the lines:

app.post(“/upload”, async function (req, res) {
const { image } = req.files;

if (!image) return res.sendStatus(400);
const imageName = path.parse(image.name).name;
const processImage = (size) => sharp(image.data)
.resize(size, size)
.webp({ lossless: true })
.toFile(`./public/images/${imageName}-${size}.webp`);

sizes = [90, 96, 120, 144, 160, 180, 240, 288, 360, 480, 720, 1440];
Promise.all(sizes.map(processImage))

let counter = 0;
for (let i = 0; i < 10_000_000_000; i++) {
counter++;
};

res.redirect("/result");
});

The post method for the upload route will now match the following:

app.post(“/upload”, async function (req, res) {
const { image } = req.files;

if (!image) return res.sendStatus(400);

await addJob({
type: “processUploadedImages”,
image: {
data: image.data.toString(“base64”),
name: image.name
},
});

res.redirect(“/result”);
});

Save and close your file, then open the utils.js file:

nano utils.js

In your utils.js file, paste the lines you just copied for the /upload route callback into the processUploadedImages function:

function processUploadedImages(job) {
const imageName = path.parse(image.name).name;
const processImage = (size) => sharp(image.data)
.resize(size, size)
.webp({ lossless: true })
.toFile(`./public/images/${imageName}-${size}.webp`);

sizes = [90, 96, 120, 144, 160, 180, 240, 288, 360, 480, 720, 1440];

Promise.all(sizes.map(processImage))
let counter = 0;
for (let i = 0; i < 10_000_000_000; i++) {
counter++;
};
}

Now that you have moved the code for processing an image, you need to update it to use the image data from the job parameter of the processUploadedImages() function you defined earlier. To do that, add and update the highlighted lines below:

function processUploadedImages(job) {
const imageFileData = Buffer.from(job.image.data, “base64”);
const imageName = path.parse(job.image.name).name;

const processImage = (size) => sharp(imageFileData)
.resize(size, size)
.webp({ lossless: true })
.toFile(`./public/images/${imageName}-${size}.webp`);

sizes = [90, 96, 120, 144, 160, 180, 240, 288, 360, 480, 720, 1440];

Promise.all(sizes.map(processImage))
let counter = 0;
for (let i = 0; i < 10_000_000_000; i++) {
counter++;
};
}

You convert the stringified version of the image data back to binary with the Buffer.from() method. Then you update path.parse() with a reference to the image name saved in the queue. After that, you update the sharp() method to take the image binary data stored in the imageFileData variable. The complete utils.js file will now match the following:

const path = require(“path”);
const sharp = require(“sharp”);

function processUploadedImages(job) {
const imageFileData = Buffer.from(job.image.data, “base64”);
const imageName = path.parse(job.image.name).name;

const processImage = (size) => sharp(imageFileData)
.resize(size, size)
.webp({ lossless: true })
.toFile(`./public/images/${imageName}-${size}.webp`);

sizes = [90, 96, 120, 144, 160, 180, 240, 288, 360, 480, 720, 1440];

Promise.all(sizes.map(processImage))
let counter = 0;
for (let i = 0; i < 10_000_000_000; i++) {
counter++;
};
}

module.exports = { processUploadedImages };

Save and close your file, then return to the index.js file:

nano index.js

The sharp variable is no longer needed as a dependency since the image is now processed in the utils.js file. Delete the highlighted line from the file:

const bodyParser = require(“body-parser”);
const sharp = require(“sharp”);
const fileUpload = require(“express-fileupload”);
const { Queue } = require(“bullmq”);

Save and close your file.

You have now defined the functionality to create a queue in Redis and add a job. You also defined the processUploadedImages() function to process uploaded images. The remaining task is to create a consumer (or worker) that will pull a job from the queue and call the processUploadedImages() function with the job data.

Create a worker.js file in your editor:

nano worker.js

In your worker.js file, add the following code:

const { Worker } = require(“bullmq”);
const { processUploadedImages } = require(“./utils”);

const workerHandler = (job) => {
console.log(“Starting job:”, job.name);
processUploadedImages(job.data);
console.log(“Finished job:”, job.name);
return;
};

In the first line, you import the Worker class from bullmq; when instantiated, this will start a worker that dequeues jobs from the queue in Redis and executes them. Next, you reference the processUploadedImages() function from the utils.js file so that the worker can call the function with the data in the queue. You define a workerHandler() function that takes a job parameter containing the job data in the queue. In the function, you log that the job has started, then invoke processUploadedImages() with the job data. After that, you log a success message and return null.

To allow the worker to connect to Redis, dequeue a job from the queue, and call the workerHandler() with the job data, add the following lines to the file:

const workerOptions = {
connection: {
host: “localhost”,
port: 6379,
},
};

const worker = new Worker(“imageJobQueue”, workerHandler, workerOptions);
console.log(“Worker !”);

Here, you set the workerOptions variable to an object containing Redis’s connection settings. You set the worker variable to an instance of the Worker class that takes the following parameters: imageJobQueue: the name of the job queue, workerHandler: the function that will run after a job has been dequeued from the Redis queue, and workerOptions: the Redis config settings that the worker uses to establish a connection with Redis.

Finally, you log a success message. After adding the lines, save and close your file.

You have now defined the bullmq worker functionality to dequeue jobs from the queue and execute them.

In your terminal, remove the images in the public/images directory so that you can start fresh for testing your app:

rm public/images/*

Next, run the index.js file:

node index.js

The app will start:

Server running on port 3000

You’ll now start the worker. Open a second terminal session and navigate to the project directory:

cd image_processor/

Start the worker with the following command:

node worker.js

The worker will start:

Worker !

Visit http://localhost:3000/ in your browser. Press the “Choose File” button and select the underwater.png from your computer, then press the “Upload Image” button. You may receive an instant response that tells you to refresh the page after a few seconds. Alternatively, you might receive an instant response with some processed images on the page while others are still being processed. You can refresh the page a few times to load all the resized images.

Return to the terminal where your worker is running. That terminal will have a message that matches the following:

Worker ! Starting job: processUploadedImages Finished job: processUploadedImages

The output confirms that bullmq ran the job successfully.

Your app can still offload time-intensive tasks even if the worker is not running. To demonstrate this, stop the worker in the second terminal with CTRL+C. In your initial terminal session, stop the Express server and remove the images in public/images:

rm public/images/*

After that, start the server again:

node index.js

In your browser, visit http://localhost:3000/ and upload the underwater.png image again. When you are redirected to the /result path, the images will not show on the page because the worker is not running:

Return to the terminal where you ran the worker and start the worker again:

node worker.js

The output will match the following, which lets you know that the job has started:

Worker ! Starting job: processUploadedImages

After the job has been completed and the output includes a line that reads “Finished job: processUploadedImages,” refresh the browser. The images will now load.

Stop the server and the worker.

You now can offload a time-intensive task to the background and execute it asynchronously using bullmq. In the next step, you will set up a dashboard to monitor the status of the queue.

Read more about executing tasks asynchronously in Node.js applications Executing Tasks Asynchronously in Node.js Applications.

Step 4 — Adding a Dashboard to Monitor bullmq Queues

In this step, you’ll use the bull-board package to keep an eye on your jobs in the Redis queue with a visual dashboard. The bull-board package gives you a user-friendly interface (UI) that automatically sets up a dashboard. This dashboard will organize and show detailed info about the bullmq jobs stored in the Redis queue. You can then check out the jobs in various states—whether they’re completed, still waiting, or have failed—right from your browser, without needing to mess with the Redis CLI in the terminal.

Start by opening your index.js file in your text editor so you can modify your app:

$ nano index.js

Now, add this code to import the bull-board and related packages. These imports are necessary to make the dashboard work in your app:

const { Queue } = require(“bullmq”);
const { createBullBoard } = require(“@bull-board/api”);
const { BullMQAdapter } = require(“@bull-board/api/bullMQAdapter”);
const { ExpressAdapter } = require(“@bull-board/express”);

In the code above, you’re importing the createBullBoard() function from the bull-board package. You’re also bringing in the BullMQAdapter, which lets the bull-board access and manage your bullmq queues, and the ExpressAdapter, which connects the dashboard to an Express.js server to show the UI.

The next step is to link up bull-board with bullmq. You’ll do this by setting up the dashboard with the right queues and server adapter for your Express app.

async function addJob(job) {
await imageJobQueue.add(job.type, job);
}

const serverAdapter = new ExpressAdapter();
const bullBoard = createBullBoard({
queues: [new BullMQAdapter(imageJobQueue)],
serverAdapter: serverAdapter,
});
serverAdapter.setBasePath(“/admin”);

Here, the serverAdapter is set up as an instance of the ExpressAdapter, which you need to integrate with Express. Then, the createBullBoard() function is called, with an object that has two properties: queues and serverAdapter. The queues property is an array that includes the bullmq queues you’ve set up—like the imageJobQueue here. The serverAdapter property holds the ExpressAdapter instance that will handle the routes for the dashboard.

Once the dashboard is set up, the next step is to define the /admin route where the dashboard will be available. You can do that by adding this middleware:

app.use(express.static(“public”));
app.use(“/admin”, serverAdapter.getRouter());

This code tells your Express server to serve static files from the public folder and sets up the /admin route to show the dashboard. Now, any traffic to http://localhost:3000/admin will open the dashboard interface.

Here’s what the complete index.js file will look like once you’ve added everything you need:

const path = require(“path”);
const fs = require(“fs”);
const express = require(“express”);
const bodyParser = require(“body-parser”);
const fileUpload = require(“express-fileupload”);
const { Queue } = require(“bullmq”);
const { createBullBoard } = require(“@bull-board/api”);
const { BullMQAdapter } = require(“@bull-board/api/bullMQAdapter”);
const { ExpressAdapter } = require(“@bull-board/express”);

const redisOptions = { host: “localhost”, port: 6379 };

const imageJobQueue = new Queue(“imageJobQueue”, { connection: redisOptions });

async function addJob(job) {
await imageJobQueue.add(job.type, job);
}

const serverAdapter = new ExpressAdapter();
const bullBoard = createBullBoard({
queues: [new BullMQAdapter(imageJobQueue)],
serverAdapter: serverAdapter,
});
serverAdapter.setBasePath(“/admin”);

const app = express();
app.set(“view engine”, “ejs”);
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(fileUpload());

app.use(express.static(“public”));
app.use(“/admin”, serverAdapter.getRouter());

app.get(“/”, function (req, res) {
res.render(“form”);
});

app.get(“/result”, (req, res) => {
const imgDirPath = path.join(__dirname, “./public/images”);
let imgFiles = fs.readdirSync(imgDirPath).map((image) => {
return `images/${image}`;
});
res.render(“result”, { imgFiles });
});

app.post(“/upload”, async function (req, res) {
const { image } = req.files;
if (!image) return res.sendStatus(400);
await addJob({
type: “processUploadedImages”,
image: {
data: Buffer.from(image.data).toString(“base64”),
name: image.name,
},
});
res.redirect(“/result”);
});

app.listen(3000, function () {
console.log(“Server running on port 3000”);
});

After saving and closing the file, run your app by executing:

$ node index.js

Once the server is up and running, open your browser and go to http://localhost:3000/admin to see the dashboard. Now you can keep track of your jobs and interact with the UI to check out jobs that are done, have failed, or are paused.

In the dashboard, you’ll find detailed info about each job, such as its type, data, and status. You can also check out different tabs, like the Completed tab for jobs that finished successfully, the Failed tab for jobs that ran into issues, and the Paused tab for jobs that are currently on hold.

With this setup, you’ll be able to easily monitor and manage your Redis queue jobs with the bull-board dashboard.

Read more about setting up dashboards to monitor background jobs in web applications Setting Up Dashboards to Monitor Background Jobs in Web Applications.

Conclusion

Conclusion

In this article, we explored how to handle asynchronous tasks efficiently using Node.js and BullMQ. By integrating BullMQ with Node.js, you can manage background jobs and queues, ensuring that your applications scale and perform effectively. We discussed setting up queues, handling job retries, and optimizing performance for long-running tasks. With BullMQ, you gain a robust solution for managing async tasks with advanced features like rate-limiting and delayed jobs.

Node.js and BullMQ together provide a seamless way to handle asynchronous operations in large-scale applications. Whether you’re working on microservices or complex backend systems, leveraging these tools can significantly improve your workflow and application performance.

As you continue to build with Node.js, stay tuned for new developments in job queue management, as both Node.js and BullMQ are evolving with new features that further enhance scalability and ease of use.

Snippet for Search Results: Learn how to manage asynchronous tasks effectively with Node.js and BullMQ, ensuring optimal performance for your applications.

This approach will help ensure your Node.js applications can scale and handle tasks more efficiently in the future.

Introduction

Automating the installation and setup of Docker on remote Ubuntu servers can save time and reduce errors. With Ansible, a powerful automation tool, you can easily create playbooks to streamline the process of configuring Docker containers on Ubuntu 18.04 systems. This guide walks you through creating a playbook that installs necessary packages, sets up Docker, and deploys containers across multiple servers, ensuring consistency and efficiency. Whether you’re managing a single server or many, using Ansible for this task will help eliminate manual configuration and improve your workflow.

Step 1 — Preparing your Playbook

The playbook.yml file is where you define all your tasks. A task is the smallest thing you can automate using an Ansible playbook, and it helps you carry out different operations on your target systems. Each task usually does one job, like installing a package, copying files, or configuring system services.

To start making your playbook, just open your favorite text editor and create the playbook.yml file with this command:

$ nano playbook.yml

This will open a blank YAML file. YAML, which stands for “YAML Ain’t Markup Language,” is a format that’s easy for humans to read and is often used for writing configuration files. One thing to keep in mind is that YAML is super picky about indentation, so a small mistake can cause errors.

Before you get into adding tasks to your playbook, begin by adding this basic setup to your file:

hosts: all
become: true
vars:
  container_count: 4
  default_container_name: docker
  default_container_image: ubuntu
  default_container_command: sleep 1

Let’s break this down:

• hosts: all: This part tells Ansible which servers to target with the playbook. The all part means the playbook will run on all the servers listed in your inventory file.
• become: true: This tells Ansible to run all tasks with elevated root privileges (basically like using sudo). You’ll need this for tasks that require admin access, like installing software or changing system settings.
• vars: The vars section is where you define variables that will be used throughout the playbook. This makes your playbook super flexible because you can adjust things without digging through the whole file.

Here’s what the variables mean:

• container_count: This is how many containers you want to create. Adjust this number based on how many you need.
• default_container_name: This sets the default name for your containers. It helps keep things organized, especially if you’re creating multiple containers.
• default_container_image: This defines which Docker image you’ll use when creating containers. In this case, it’s set to use the ubuntu image. You can swap this out for any other Docker image you prefer.
• default_container_command: This is the command that will run in each container when it’s created. By default, it’s set to make the container run sleep 1, which just keeps the container running for a second. You can change this to any other command you need.

If you want to see the playbook once it’s finished, check out Step 5. YAML file
You can find more information on automating server setups with Ansible in this detailed guide on Ansible automation for server configuration.

Step 2 — Adding Packages Installation Tasks to your Playbook

By default, tasks in an Ansible playbook are executed one after the other, meaning they run sequentially in the order you’ve written them. This setup ensures that each task is finished before the next one starts. It’s important to know that the order of tasks really matters; the result of one task can affect the next, so you need to think carefully about the flow of your tasks. This feature is super helpful because it lets you manage dependencies—one task won’t kick off until the previous one is done.

Also, every task in Ansible can work on its own, which is really nice. It makes tasks reusable in different playbooks. This means you don’t have to rewrite the same code over and over again. Once you set up something like installing packages in one playbook, you can reuse it anywhere else, saving you time and keeping things consistent across your setup.

Now, let’s go ahead and add the first tasks to your playbook for installing some essential packages. First up, we’ll install aptitude, a tool that interacts with the Linux package manager. Then, we’ll install the required system packages. These packages are important for setting up Docker and all the dependencies you’ll need for managing containers. The configuration below will make sure that Ansible installs these packages on your server, checks for any updates, and ensures you’re always working with the latest versions.

Here’s how you can write this part of the playbook:

tasks:
– name: Install aptitude
apt:
name: aptitude
state: latest
update_cache: true
– name: Install required system packages
apt:
pkg:
– apt-transport-https
– ca-certificates
– curl
– software-properties-common
– python3-pip
– virtualenv
– python3-setuptools
state: latest
update_cache: true

Let’s break down what’s happening here:

• Install aptitude: This task installs aptitude, which is Ansible’s preferred tool over the default apt package manager. Aptitude makes managing packages easier, especially when dealing with dependencies.
• Install required system packages: This task installs the necessary packages that your server will need for Docker and other configuration tasks. The list of packages includes:

• apt-transport-https: This allows the server to securely download packages over HTTPS.
• ca-certificates: This makes sure the system has the right certificates for secure communication.
• curl: This tool helps transfer data with URLs and is often needed for downloading files or communicating with remote servers.
• software-properties-common: This package provides helpful utilities for managing repositories on Ubuntu.
• python3-pip: This is a package installer for Python, which is needed to manage Python dependencies.
• virtualenv: A tool to create isolated Python environments, which can be really useful in different setups.
• python3-setuptools: This helps with packaging and distributing Python software.

By using the apt module in Ansible, you’re telling it to install these packages on your system. The apt module works with the apt package manager, which is perfect for managing packages on Ubuntu and other Debian-based systems. The state: latest directive ensures that you’re always installing the most up-to-date versions, and update_cache: true makes sure the apt cache is updated before it starts installing the packages.

This setup will guarantee that the right packages are always installed and up-to-date each time the playbook runs. You’ll automate the setup process for Docker containerization, so you don’t have to worry about doing it manually each time. Ansible takes care of all the installation, ensuring everything is configured the right way.

For a deeper dive into automating server setups and package management, check out this helpful resource on Ansible Package Management Automation.

Step 3 — Adding Docker Installation Tasks to your Playbook

In this step, you’re going to tweak your playbook to install the latest version of Docker directly from the official Docker repository. Docker, as you probably know, is one of the most widely used container platforms. It’s great for running applications in isolated environments, or containers, which are super useful when you’re looking to keep things organized. Getting Docker up and running on your servers is key to making sure everything is fresh and running smoothly.

First, we’re going to add the Docker GPG key to your server. Think of the GPG key like a security check that makes sure the Docker packages you’re installing are legitimate and haven’t been messed with. So, what we’re doing here is fetching this key from a secure URL and adding it to the server’s keyring. This ensures that when Docker packages are downloaded in the future, they’re coming from the official source and haven’t been tampered with.

Next up, we add the Docker repository to your server’s list of package sources. This is how your server knows where to pull the latest Docker packages from. You’ll specify the repository URL for Ubuntu systems, and, in this case, we’re going with “bionic,” which refers to Ubuntu 18.04. By using Ansible’s apt_repository module, we make sure the Docker repository is added correctly to your system, so you don’t have to manually handle this.

Once the repository is added, the next task is to update the local apt package list. We’re basically telling the system, “Hey, go check for any updates from the new Docker repository.” The command apt update runs in the background to make sure the package manager knows about the new Docker packages available.

After that, Ansible is instructed to install the docker-ce (Community Edition) package. By adding state: latest, we ensure that we’re getting the newest version of Docker. The update_cache: true part makes sure that any changes to the package list are taken into account during the installation process.

Finally, the last task in this part of the playbook installs the Docker module for Python using pip. This Python module helps your Python scripts interact with Docker. If you plan to automate Docker container management within Python, this is going to be your best friend.

Here’s what this part of the playbook would look like:

tasks:
– name: Add Docker GPG apt Key
apt_key:
url: https://download.docker.com/linux/ubuntu/gpg
state: present
– name: Add Docker Repository
apt_repository:
repo: deb https://download.docker.com/linux/ubuntu bionic stable
state: present
– name: Update apt and install docker-ce
apt:
name: docker-ce
state: latest
update_cache: true
– name: Install Docker Module for Python
pip:
name: docker

Here’s a breakdown of each task:

• Add Docker GPG apt Key: This ensures your server can verify Docker packages, so you know they’re the real deal.
• Add Docker Repository: This task adds Docker’s repository, which allows you to install Docker from the official source, keeping everything legit.
• Update apt and install docker-ce: This task installs Docker Community Edition and ensures that your server is using the most recent stable version.
• Install Docker Module for Python: This installs the Python module that lets you control Docker through Python scripts.

When all of these tasks are executed, Docker will be installed smoothly on your system. And the best part? You won’t have to manually handle any of it—thanks to Ansible automating the whole process. This makes Docker installation repeatable and hassle-free for all your future setups!

For more details on automating Docker installation tasks and playbook configurations, check out this comprehensive guide on Ansible Docker Setup Automation.

Step 4 — Adding Docker Image and Container Tasks to your Playbook

In this step, you’re going to roll up your sleeves and start creating your Docker containers. The first task is to pull the Docker image you want to use as the base for your containers. By default, Docker gets its images from Docker Hub, which is basically a giant online library of container images for all kinds of applications and services. You can think of it as a ready-to-go inventory of Docker environments, all set up for you to use. The image you choose will determine the environment inside your containers, including all the necessary dependencies and settings.

Once you have the image, the next step is to create the Docker containers using that image. These containers will be set up according to the variables you’ve already defined in your playbook. Here’s a breakdown of the tasks:

Pull Docker Image

This part of the task uses the docker_image Ansible module to pull the image from Docker Hub. In the playbook, the name parameter specifies which image to grab, and source: pull makes sure the image is pulled from the Docker registry.

name: Pull default Docker image
docker_image:
name: “{{ default_container_image }}”
source: pull

In this case, the default_container_image variable holds the name of the image you want to use, and it could be something like Ubuntu or CentOS, depending on what you’re working with. You can change default_container_image to any image name that fits your project.

Create Docker Containers

Once the image is pulled, the next task is to create one or more containers based on the image you’ve just downloaded. The docker_container Ansible module is used for this, and it’s where you define the configuration for each container. The variables from earlier in your playbook, like default_container_name, default_container_image, and default_container_command, will control how each container is set up.

name: Create default containers
docker_container:
name: “{{ default_container_name }}{{ item }}”
image: “{{ default_container_image }}”
command: “{{ default_container_command }}”
state: present
with_sequence:
count={{ container_count }}

Here’s how each part works:

• name: This dynamically generates the name for each container. It combines the default_container_name with the item variable, which represents the current iteration in the loop. So each container gets a unique name based on its position in the sequence.
• image: This tells Docker which image to use when creating the container. The image is pulled from Docker Hub as defined in the previous task.
• command: This is the command that runs when the container starts. By default, it’s set to sleep 1, which keeps the container running for just one second. You can change this to run whatever command you need inside the container.
• state: The state is set to present, which means the container will be created if it doesn’t already exist.
• with_sequence: This part is crucial because it creates a loop that runs the task container_count times, which is the number of containers you want. The item variable ensures that each container in the sequence gets a unique name.

The with_sequence loop is super helpful because it lets you automate the creation of multiple containers without having to repeat the task for each one. Instead, you define how many containers you want at the top of your playbook, and Ansible handles the rest, ensuring each container gets its own name based on the loop iteration.

This method of container creation is not only efficient but also really flexible. You can easily scale up the number of containers you need without manually tweaking the playbook every time. It’s all automated, and you don’t have to worry about a thing!

For a deeper dive into automating container tasks with Ansible, check out this detailed guide on Ansible Docker Image and Container Automation.

Step 5 — Reviewing your Complete Playbook

Once you’ve added all your tasks, it’s time to take a step back and review everything in your playbook to make sure it’s all set up correctly. This is the moment to double-check everything, especially the little details you might’ve customized, like the number of containers you want to create or the Docker image you’re using.

Here’s an example of how your playbook should look when you’re all done:

hosts: all
become: true
vars:
container_count: 4
default_container_name: docker
default_container_image: ubuntu
default_container_command: sleep 1d
tasks:
– name: Install aptitude
apt:
name: aptitude
state: latest
update_cache: true
– name: Install required system packages
apt:
pkg:
– apt-transport-https
– ca-certificates
– curl
– software-properties-common
– python3-pip
– virtualenv
– python3-setuptools
state: latest
update_cache: true
– name: Add Docker GPG apt Key
apt_key:
url: https://download.docker.com/linux/ubuntu/gpg
state: present
– name: Add Docker Repository
apt_repository:
repo: deb https://download.docker.com/linux/ubuntu bionic stable
state: present
– name: Update apt and install docker-ce
apt:
name: docker-ce
state: latest
update_cache: true
– name: Install Docker Module for Python
pip:
name: docker
– name: Pull default Docker image
docker_image:
name: “{{ default_container_image }}”
source: pull
– name: Create default containers
docker_container:
name: “{{ default_container_name }}{{ item }}”
image: “{{ default_container_image }}”
command: “{{ default_container_command }}”
state: present
with_sequence:
count: {{ container_count }}

This is the full playbook, and as you can see, it includes everything you need to get Docker up and running on your target servers. Let’s break it down a little bit more:

Hosts: The hosts section specifies which machines this playbook will be applied to. In this case, it’s set to “all,” which means it’ll apply to all of the servers in your Ansible inventory.

Become: The become: true line is important because it tells Ansible to run everything with root (admin) privileges, which you’ll need to install packages and do other Docker-related tasks.

Vars: Here, we define variables to make things more flexible. You can easily change the number of containers you want to create, or pick a different Docker image or startup command for your containers. It’s all in one place!

The Tasks:

• Aptitude and System Packages: The first part installs some necessary tools and packages, like curl and python3-pip, to make sure your system is ready for Docker.
• Docker Setup: Next up, we add the Docker GPG key (to verify Docker packages) and the Docker repository (so we can download Docker), and finally, install Docker and the Python Docker module.
• Docker Containers: After Docker is installed, we pull the Docker image you’ve chosen and then create your containers based on that image. Each container gets set up with the specific configuration you’ve defined.

Customization:

• You could use the docker_image module to push your custom Docker images to Docker Hub.
• You could also update the docker_container task to set up more complex container networks or tweak other settings.

Just a heads-up, YAML files are picky about indentation. If something goes wrong, it might be due to incorrect spacing, so make sure your indentations are consistent. For YAML, the standard is to use two spaces for each indent level. If you run into any errors, check your spacing first, and you’ll likely spot the issue.

Once everything looks good, save your playbook, exit your text editor, and you’re ready to roll! You’re all set to run your playbook and automate your Docker setup.

For a comprehensive guide on configuring and reviewing Ansible playbooks, take a look at this helpful article on Reviewing Your Complete Playbook.

Step 6 — Running your Playbook

Now that you’ve reviewed and fine-tuned your playbook, it’s time to run it on your server or servers. Typically, most playbooks are set up to run on all servers in your Ansible inventory by default, but if you want to run it on a specific server, you can easily specify that. For example, if you want to run your playbook on server1 and connect using the sammy user, you can use the following command:

$ ansible-playbook playbook.yml -l server1 -u sammy

Let’s break down this command a bit so you can see how it works:

• -l flag: This specifies the server (or group of servers) where the playbook will run. In this case, it’s limiting the execution to server1.
• -u flag: This flag tells Ansible which user to log in as. So, in this case, sammy is the user Ansible will use to log into the remote server and run the commands.

Once the command runs, you should see something like this:

changed: [server1]
TASK [Create default containers] *****************************************************************************************************************
changed: [server1] => (item=1)
changed: [server1] => (item=2)
changed: [server1] => (item=3)
changed: [server1] => (item=4)

PLAY RECAP ***************************************************************************************************************************************
server1 : ok=9 changed=8 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

Output Explanation

• changed: [server1]: This tells you that changes were made on server1. The number of changes corresponds to the tasks executed, meaning tasks that modified the server’s configuration.
• TASK [Create default containers]: This is the task that’s being executed. In this case, it’s the creation of your Docker containers.
• changed: [server1] => (item=1), etc.: This shows the creation of each individual container. The item refers to the number of the container in the loop defined in your playbook (like container 1, container 2, and so on).
• PLAY RECAP: This section gives you a summary of your playbook’s run. Here’s what each part means:

• ok=9: Nine tasks were successfully executed.
• changed=8: Eight tasks made changes to the server.
• unreachable=0: No servers were unreachable.
• failed=0: No tasks failed.
• skipped=0: No tasks were skipped.
• rescued=0: No tasks needed to be rescued.
• ignored=0: No tasks were ignored.

Verifying the Container Creation

Once your playbook finishes running, you’ll want to verify that the containers were actually created. Here’s how to check:

SSH into your server using the sammy user:

$ ssh sammy@your_remote_server_ip

Then, list the Docker containers to see if they were created successfully:

$ sudo docker ps -a

You should see output similar to this:

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a3fe9bfb89cf ubuntu “sleep 1d” 5 minutes ago Created docker4
8799c16cde1e ubuntu “sleep 1d” 5 minutes ago Created docker3
ad0c2123b183 ubuntu “sleep 1d” 5 minutes ago Created docker2
b9350916ffd8 ubuntu “sleep 1d” 5 minutes ago Created docker1

Each line represents a container, and the names (like docker1, docker2, etc.) are assigned based on the loop in your playbook. The status being “Created” tells you the containers were successfully created but may not be running just yet, since you set the command to sleep 1d (which makes them sleep for 1 day).

Confirmation of Successful Execution

If you see the containers listed like above and there are no failures in your playbook output, that’s your confirmation that everything worked just as expected. The tasks were executed correctly, and your containers are good to go!

For further details on running Ansible playbooks effectively, check out this in-depth guide on Running Your Playbook.

Conclusion

In conclusion, automating the installation and setup of Docker on remote Ubuntu 18.04 servers using Ansible offers significant advantages in terms of efficiency and consistency. By creating an Ansible playbook, you can streamline the process of installing Docker, setting up necessary packages, and managing containers across multiple servers. This not only reduces human errors but also ensures that your server configurations remain uniform and easily repeatable. As automation tools like Ansible continue to evolve, mastering these skills will remain essential for IT professionals seeking to enhance operational workflows. In the future, expect even more advanced features from Ansible to make container management even more seamless.

Automate Docker Setup with Ansible on Ubuntu 22.04

Introduction

Building an SEO-friendly blog requires the right tools and technologies, and using Ghost, Next.js, and Tailwind CSS can streamline the process. Ghost serves as an efficient content management system (CMS) while Next.js helps create a fast, static frontend, ensuring optimal SEO performance. With Tailwind CSS for design flexibility and ease, you can create a clean, modern interface for your blog. In this article, we’ll guide you through setting up Ghost on a server, integrating it with Next.js, and styling your blog using Tailwind CSS to create a seamless, high-performance website.

Step 1 — Publishing Posts on Ghost

Alright, here’s the deal. In this step, you’re going to set up an account on Ghost and publish a few sample posts so you’ve got content ready for the next steps. After you’ve got Ghost up and running, the first thing you need to do is create an admin account to manage your blog’s content.

So, to kick things off, just open your browser and type in the URL you set when you installed Ghost. It’s going to be something like YOUR_DOMAIN/ghost. Once you’re there, you’ll be greeted by the “Welcome to Ghost” page, where it’ll ask you to create an admin account.

All you need to do now is fill out the form with your site title, your name, email, and password. When you’re done with that, hit the “Create account & start publishing” button. And boom, you’re in. This will take you straight to your blog’s admin dashboard.

Now that you’re logged in, you’ll be on the Ghost dashboard. On the left side, you’ll see a section that says “What do you want to do first?” and right under it, there’s a button that says “Write your first post.” Go ahead and click on that to start writing.

Once you’re in the editor, type up a catchy title and add your content in the body section. After you’re done, click the “Publish” button at the top right of the screen. You’ll then see a little confirmation asking if you want to “Continue, final review.” Once you’re all set, click “Publish post, right now” to make it go live.

To check out your blog live, go back to YOUR_DOMAIN/ghost and navigate to the dashboard. There, on the left sidebar, you’ll find a “View site” option. Click it, and voila, your blog is now live!

At this point, you’ve created your first post, and your Ghost site is officially up and running. Next, you’ll want to add more content. From the dashboard, select “Posts” on the left, and add two more blog posts. Make sure to give each post a unique title so you can easily spot them later.

Right now, your blog is using the default Ghost template. While it works, it doesn’t give you much room to play around with design. But don’t worry, in the next step, you’re going to set up a Next.js project that will let you create a much more personalized and flexible frontend for your blog, combining Next.js’s power with Ghost’s content management features.

For more details on managing and publishing content effectively with Ghost, check out this guide on publishing and managing posts on Ghost.

Step 2 — Creating a Next.js Project

Now that you’ve got Ghost all set up and ready for your blog, the next step is to create the frontend for your blog using Next.js, and of course, spice things up with Tailwind CSS for styling.

First things first, open up the Next.js project you created earlier in your favorite code editor. Then, go ahead and open the pages/index.js file by running this command:

$ nano pages/index.js

Once the index.js file is open, go ahead and clear out whatever content is already in there. Then, add this code to import the Head component from next/head and set up a basic React component:

import Head from ‘next/head’;

export default function Home() {
    return (
        // Code to be added in the next steps
    );
}

So, here’s the thing. The Head component from Next.js is your go-to for adding stuff like the <title> and <meta> tags that you usually find in the <head> section of an HTML document. These are super important because they help define the metadata for your page—things like the title that shows up in the search results and the description that social media platforms use to generate previews.

Next, to make the Head component work for your blog, we’ll add a return statement that includes a <div> element. Inside this <div>, we’ll nest a <Head> tag, and inside that, we’ll place a <title> and <meta> tag like this:

return (
    <div>
        <Head>
            <title>My First Blog</title>
            <meta name=”description” content=”My personal blog created with Next.js and Ghost” />
        </Head>
    </div>
);

Here’s how it breaks down:

• The <title> tag sets the name of your webpage, which is what appears on the browser tab when someone visits your site. In this case, it’s “My First Blog.”
• The <meta> tag defines the “description” of your site, which is a brief blurb about what your website is about. In this case, “My personal blog created with Next.js and Ghost,” which will show up in search engine results and give people a preview of what your site offers.

Now that you’ve set the title and description, it’s time to add a list of blog articles. For now, we’ll use some mock data as placeholders—don’t worry, we’ll fetch the real blog posts from Ghost in the next section. Below the <Head> tag, you can add a list of articles using <li> tags, just like this:

<div>
    <Head>
        <title>My First Blog</title>
        <meta name=”description” content=”My personal blog created with Next.js and Ghost” />
    </Head>
    <main className=”container mx-auto py-10″>
        <h1 className=”text-center text-3xl”>My Personal Blog</h1>
        <div className=”flex justify-center mt-10″>
            <ul className=”text-xl”>
            <li>How to build and deploy your blog on Caasify</li>
            <li>How to style a Next.js website</li>
            <li>How to cross-post your articles automatically</li>
        </ul>
    </div>
    </main>
</div>

Let’s break that down:

• We’ve added a <main> tag with a header (<h1>) for the blog title, and we’re using a <div> that centers the content.
• Inside this <div>, we use the flex utility class from Tailwind CSS to center the list of articles horizontally.
• The articles themselves are wrapped in an unordered list (<ul>) with each item inside a <li> tag. We’ve also applied the text-xl Tailwind CSS class to make the list items a bit bigger.

Your index.js file should now look like this:

import Head from ‘next/head’;

export default function Home() {
    return (
        <div>
            <Head>
            <title>My First Blog</title>
            <meta name=”description” content=”My personal blog created with Next.js and Ghost” />
            </Head>
        </div>
        <main className=”container mx-auto py-10″>
            <h1 className=”text-center text-3xl”>My Personal Blog</h1>
            <div className=”flex justify-center mt-10″>
            <ul className=”text-xl”>
            <li>How to build and deploy your blog on Caasify</li>
            <li>How to style a Next.js website</li>
            <li>How to cross-post your articles automatically</li>
        </ul>
        </div>
        </main>
        </div>
}

Once you’ve saved that, it’s time to fire up the web server locally. Whether you’re using Yarn or npm, just run the appropriate command:

• For Yarn: $ yarn dev
• For npm: $ npm run dev

Now, when the server is running, open your browser and go to https://localhost:3000. You should see your homepage with the list of mock blog articles we just added. Of course, this is just placeholder content for now. In the next step, we’ll replace it with the actual blog posts pulled from Ghost.

And just like that, your blog’s Home page is all set up, and it’s ready to show dynamic content fetched from Ghost!

To dive deeper into creating and customizing projects with Next.js, you can explore this comprehensive guide on Next.js documentation and project setup.

Step 3 — Fetching All Blog Posts from Ghost

In this step, you will fetch the blog posts you created in Ghost and display them in your browser. To fetch your articles from Ghost, you will first need to install the JavaScript library for the Ghost Content API. Start by stopping the server using the keyboard shortcut CTRL+C. Then, run the following command in your terminal to install the library:

If you are using Yarn, run:

$ yarn add @tryghost/content-api

If you are using npm, run:

$ npm i @tryghost/content-api

With the library successfully installed, the next step is to create a file that will store the logic required to fetch your blog posts. Inside the pages directory, create a new folder named utils:

$ mkdir utils

Now, create a new file within the utils folder named ghost.js:

$ nano pages/utils/ghost.js

In the ghost.js file, you will import the GhostContentAPI module from the Ghost Content API library. Then, initialize a new instance of the GhostContentAPI and store the resulting value in a constant variable called api. You will need to provide values for the host URL, API key, and API version. The code should look like this:

import GhostContentAPI from “@tryghost/content-api”;

const api = new GhostContentAPI({

   url: YOUR_URL,

   key: YOUR_API_KEY,

   version: ‘v5.0’

});

In this code, YOUR_URL refers to the domain name you configured when installing Ghost, including the protocol (i.e., https://). To obtain your Ghost API key, follow these steps:

• Navigate to YOUR_DOMAIN/ghost (where YOUR_DOMAIN is the URL you set up during Ghost installation) and log in with your admin credentials.
• Click the gear icon at the bottom of the left sidebar to access the settings page.
• In the “Advanced” category, click “Integrations” from the left sidebar.
• On the Integrations page, scroll down to the “Custom Integrations” section and click “+ Add custom integration.”
• A pop-up will appear asking you to name your integration. Enter a name for your integration in the “Name” field and click “Create.”
• This will take you to a page to configure your custom integration. Copy the Content API Key (note: use the Content API Key, not the Admin API key).
• Press “Save” to store the integration settings.

In the ghost.js file, replace YOUR_API_KEY with the copied API key. Once you have initialized the GhostContentAPI, you will write an asynchronous function to fetch all the articles from your Ghost installation. This function will retrieve the blog posts regardless of their tags. Here is the code to add to your ghost.js file:

export async function getPosts() {
   return await api.posts
      .browse({
         include: “tags”,
         limit: “all”
      })
      .catch(err => {
         console.error(err);
      });
}

The getPosts() function calls api.posts.browse() to fetch posts from your Ghost installation. The include parameter is set to “tags”, meaning that it will fetch the tags associated with each post along with the content itself. The limit parameter is set to “all” to retrieve all available posts. If an error occurs while fetching the posts, it will be logged to the browser console.

At this point, your ghost.js file will look like this:

import GhostContentAPI from ‘@tryghost/content-api’;

const api = new GhostContentAPI({

   url: YOUR_URL,

   key: YOUR_API_KEY,

   version: ‘v5.0’,

});

export async function getPosts() {
   return await api.posts
      .browse({
         include: ‘tags’,
         limit: ‘all’,
      })
      .catch((err) > {
         console.error(err);
      });
}

Save and close the file. The next step is to update your index.js file to display the list of posts. Open index.js and add the following line to import the getPosts function above the Head import:

import { getPosts } from ‘./utils/ghost’;

import Head from ‘next/head’;

You will now create an async function called getStaticProps(). This function allows Next.js to pre-render the page at build time, which is beneficial for static generation. In getStaticProps(), call the getPosts() method and return the posts as props. The code should look like this:

export async function getStaticProps() {
   const posts = await getPosts();
   return {
      props: { posts },
   };
}

Save the file. Now that you’ve defined the getStaticProps() method, restart the server by running one of the following commands, depending on your package manager:

If you’re using Yarn, run:

$ yarn dev

If you’re using npm, run:

$ npm run dev

In your browser, the page will initially show the static data. However, because you are fetching the posts asynchronously but not rendering them yet, you need to make some changes to the index.js file. Press CTRL+C to stop the server, then open index.js for editing:

$ nano pages/index.js

Make the following highlighted changes to index.js to render the posts:

export default function Home({ posts }) {
   return (
      <div>
         <Head>
           <title>My First Blog</title>
           <meta name=”description” content=”My personal blog created with Next.js and Ghost”>
         </Head>
         <main className=”container mx-auto py-10″>
           <h1 className=”text-center text-3xl”>My Personal Blog</h1>
         <div className=”flex justify-center mt-10″>
           <ul className=”text-xl”>
           {posts.map((post) > 
               <li key={post.title}>{post.title}</li>
           )}
         </ul>
         </div>
         </main>
         </div>
   );
}

Save and close the file. Restart the server again using either npm run dev or yarn dev, and navigate to localhost:3000 in your browser. Your homepage should now display a list of blog articles fetched from Ghost.

At this stage, the blog has successfully retrieved and displayed the post titles from your Ghost CMS. However, it still doesn’t render individual posts. In the next section, you will create dynamic routes to display the content of each post.

For more details on integrating APIs with static sites, check out this useful guide on Using the Fetch API in JavaScript.

Step 4 — Rendering Each Individual Post

In this step, you will write code to fetch the content of each blog post from Ghost, create dynamic routes, and add the post title as a link on the homepage. Next.js allows you to create dynamic routes, which makes it easier to render pages with the same layout. By using dynamic routes, you can reduce redundancy in your code, as you won’t need to create a separate page for each post. Instead, all of your posts will use the same template file to render.

To create dynamic routes and render individual posts, you will need to:

• Write a function to fetch the content of a specific blog post.
• Create dynamic routes to display each post.
• Add blog post links to the list of articles on the homepage.

In the ghost.js file, you already wrote the getPosts() function to fetch a list of all your blog posts. Now, you will add another function called getSinglePost() that fetches the content of a specific post based on its slug. Ghost automatically generates a slug for each article using its title. For example, if your article is titled “My First Post,” Ghost will generate a slug like my-first-post. This slug will be used to identify the post and can be appended to your domain URL to display the content.

The getSinglePost() function will take the postSlug as a parameter and return the content of the corresponding blog post. Follow the steps below to add and configure this function.

Step-by-step implementation:

1. Stop the server if it’s still running.
2. Open the pages/utils/ghost.js file for editing.
3. Below the getPosts() function in the ghost.js file, add and export the getSinglePost() function like this:

export async function getSinglePost(postSlug) {
return await api.posts
.read({ slug: postSlug })
.catch((err) => {
console.error(err);
});
}

The getSinglePost() function uses the posts.read() method from the GhostContentAPI to fetch a single post by its slug. If an error occurs during the API call, it will be logged to the browser’s console.

Now, your updated ghost.js file should look like this:

import GhostContentAPI from ‘@tryghost/content-api’;

const api = new GhostContentAPI({
url: YOUR_URL,
key: YOUR_API_KEY,
version: ‘v5.0’,
});

export async function getPosts() {
return await api.posts
.browse({
include: ‘tags’,
limit: ‘all’,
})
.catch((err) => {
console.error(err);
});
}

export async function getSinglePost(postSlug) {
return await api.posts
.read({ slug: postSlug })
.catch((err) => {
console.error(err);
});
}

Save and close the ghost.js file.

Next, to render individual blog posts dynamically in Next.js, you will use a dynamic route. In Next.js, dynamic routes are created by adding brackets ([ ]) to a filename. For example, creating a file named [slug].js in the pages/post/ directory will match any slug passed in the URL after /post/ and display the corresponding post.

Create the dynamic route file /post/[slug].js:

nano pages/post/[slug].js

Note: The backslashes () in the filename are necessary for escaping the brackets in the terminal when using the nano editor.

Inside the [slug].js file, import the getPosts() and getSinglePost() functions from the ../utils/ghost.js file. Then, create the template for rendering the post:

import { getPosts, getSinglePost } from ‘../utils/ghost’;

export default function PostTemplate(props) {
const { post } = props;
const { title, html, feature_image } = post;
return (

{title}

);
}

export const getStaticProps = async ({ params }) => {
const post = await getSinglePost(params.slug);
return {
props: { post },
};
};

In this code, the PostTemplate() function receives the post object as a prop, and it destructures the title, html, and feature_image properties from it. The post content (HTML) is injected into the <article> tag using React’s dangerouslySetInnerHTML attribute. Note: This is a React feature that allows you to insert raw HTML, but you should sanitize the content if it’s coming from an untrusted source to prevent security risks.

The getStaticProps() function fetches the content of the blog post corresponding to the slug parameter in the URL. This ensures that each post is pre-rendered at build time.

Next, you need to create another function, getStaticPaths(), to tell Next.js which URLs need to be generated during build time. The function will return a list of slugs to generate paths for all posts.

Add the getStaticPaths() function to the [slug].js file:

export const getStaticPaths = async () => {
const allPosts = await getPosts();
return {
paths: allPosts.map(({ slug }) => {
return {
params: { slug },
};
}),
fallback: false,
};
};

Here, getStaticPaths() fetches all the posts using the getPosts() function and returns a list of slugs as the paths. By setting fallback: false, any paths that do not match the list will result in a 404 page.

The final version of the /post/[slug].js file should now look like this:

import { getPosts, getSinglePost } from ‘../utils/ghost’;

export default function PostTemplate(props) {
const { post } = props;
const { title, html, feature_image } = post;
return (

{title}

);
}

export const getStaticProps = async ({ params }) => {
const post = await getSinglePost(params.slug);
return {
props: { post },
};
};

export const getStaticPaths = async () => {
const allPosts = await getPosts();
return {
paths: allPosts.map(({ slug }) => {
return {
params: { slug },
};
}),
fallback: false,
};
};

Save and close the file.

Next Step: To navigate between the homepage and individual posts, you will add links on the homepage that point to each post. For this, stop the server if it’s still running, then open pages/index.js for editing.

Add an import statement for Link from next/link and create links to the individual posts:

import { getPosts } from ‘./utils/ghost’;
import Head from ‘next/head’;
import Link from ‘next/link’;

export default function Home(props) {
return (

);
}

export async function getStaticProps() {
const posts = await getPosts();
return {
props: { posts },
};
}

In this updated code, the Link component from next/link is used to create clickable links to each individual post. The href attribute uses the post’s slug to navigate to the corresponding post page.

Save the file, restart the server using npm run dev or yarn dev, and navigate to localhost:3000. Now, when you click on any post title, you will be redirected to the corresponding post page where its content is displayed.

Your homepage will now show the list of blog titles, and clicking on a title will take you to the individual blog post page. This marks the completion of rendering individual posts using dynamic routes.

To learn more about building dynamic web pages with Next.js, check out this detailed guide on Dynamic Routing in Next.js.

Conclusion

In conclusion, building an SEO-friendly blog with Ghost, Next.js, and Tailwind CSS is a powerful combination that ensures a fast, flexible, and visually appealing website. By using Ghost as your CMS, you can efficiently manage and publish content, while Next.js provides the performance and SEO benefits of static site generation. Tailwind CSS offers seamless design customization, making your blog stand out with a modern, responsive layout. With this tutorial, you now have the knowledge to set up a scalable, SEO-optimized blog that delivers exceptional performance. As web development continues to evolve, adopting these tools will keep your blog ahead of the curve, providing improved functionality and user experience.

Install Ghost CMS Easily: Setup and Configure via SSH

Introduction

Setting up a Ruby programming environment on macOS with Homebrew is a straightforward process that equips you with the tools needed for Ruby development. By installing essential components like Xcode’s Command Line Tools and Homebrew, you can easily manage your Ruby installation and ensure you have the latest version. Whether you’re a beginner or experienced developer, this step-by-step guide will help you get your environment up and running quickly. In this article, we’ll walk through the entire process—from prerequisites to verifying your setup and running a “Hello, World!” program. Get ready to start writing Ruby code on your macOS system with Homebrew and Xcode!

Step 1 — Using the macOS Terminal

Alright, in this step, you’re going to use the command line interface (CLI) to install Ruby and run a bunch of commands that you’ll need for your Ruby projects. Now, the command line is kind of like a non-graphical way to interact with your computer. Instead of clicking around on buttons with your mouse, you’ll type commands, and your computer will respond with text. It’s a pretty powerful tool, especially for developers like us, since it allows you to automate repetitive tasks and make things a lot easier.

To get to the CLI on macOS, you’ll use the Terminal app, which is already installed on your system. If you’re not sure where it is, you can find it by opening Finder, going into the Applications folder, and then heading into the Utilities folder. Inside, you’ll spot the Terminal app. Double-click it to open it up. If you’re more of a shortcut person, press and hold the COMMAND key, tap the SPACE bar, type "Terminal", and hit RETURN to launch it straight from Spotlight.

Once Terminal is up and running, you’re all set to start executing those important commands. If you’re not that familiar with the command line and want to get more comfortable, you might want to check out some tutorials, like “An Introduction to the Linux Terminal”, since the command line on macOS is pretty similar. With Terminal ready to go, you’ll be all set to move on to installing Ruby and setting up your environment.

For more detailed instructions on using the macOS Terminal for development, check out this guide on Using the macOS Terminal.

Step 2 — Installing Xcode’s Command Line Tools

Alright, so here’s the deal with Xcode: It’s this powerful development environment (IDE) that comes with a bunch of tools for macOS. Now, here’s the thing—while you don’t need the full Xcode IDE to write Ruby programs, you’ll still need some parts of it. Specifically, Ruby and a few related tools rely on Xcode’s Command Line Tools package to work properly. These tools include stuff like compilers, libraries, and other essential resources that make it possible to build and manage software on macOS.

To install Xcode’s Command Line Tools, all you’ve got to do is enter one simple command in the Terminal. Just open your Terminal and type in:

$ xcode-select –install

Once you hit Enter, the system will prompt you to start the installation. You’ll then be asked to accept a software license agreement—nothing too wild, just the usual click-to-accept deal. After that, macOS will automatically download and install everything you need.

Boom, you’re done! You now have Xcode’s Command Line Tools installed, and these tools are the key to compiling and managing Ruby and pretty much any other programming language on macOS. With that all set up, you’re ready to mov
For further instructions on installing Xcode’s Command Line Tools, refer to this detailed guide on Installing Xcode’s Command Line Tools.

Step 3 — Installing and Setting Up Homebrew

So, here’s the thing—macOS does have a command line interface (CLI), but unlike Linux or other Unix systems, macOS doesn’t come with a super robust package manager out of the box. Now, a package manager is this awesome tool that helps you install, configure, and update software automatically. It keeps everything organized in one spot and makes sure things are compatible across different systems. Basically, it makes life way easier when you need to manage all that software stuff.

That’s where Homebrew comes in. Homebrew is a super popular, free, and open-source package manager designed specifically for macOS. It takes the pain out of installing software, including Ruby, on your Mac. And with Homebrew, you can easily install the latest version of Ruby and swap out the default version that macOS gives you with whatever version you want. Pretty handy, right?

To get Homebrew installed, just open up your Terminal and type this command:

/usr/bin/ruby -e $(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)

This little command runs a Ruby script that grabs Homebrew and installs it for you. And since the script itself is written in Ruby, macOS will use the default Ruby interpreter to run it. The command uses curl (that’s a tool for transferring data) to pull the installation script from Homebrew’s GitHub page.

Now, let’s break down that curl command, because it’s got some nifty flags you should know about:

• -f or --fail: Makes sure curl doesn’t show an HTML error page if something goes wrong. So, no messy error messages for you.
• -s or --silent: Mutes the progress meter, which is kind of like getting rid of the loading bar. It just keeps things cleaner.
• -S or --show-error: Makes sure that if there’s an error, you’ll actually see it, even when the -s flag is used.
• -L or --location: Handles redirects, so if the server has moved the script, curl will follow it to the new spot.

Once the script is downloaded, Ruby will run it, and you’ll start the Homebrew installation process. During the installation, you’ll get a prompt that shows you exactly what the script is about to do. This is to make sure you’re fully aware of any changes it’s going to make to your system.

Then, it’s password time! You’ll be prompted to enter your system password. Don’t freak out if you don’t see your password as you type—it’s a security thing. Just know that the system is still recording your input. Once you’ve typed it in, press RETURN. After that, you’ll get another prompt asking if you want to confirm the installation—just type “y” and hit RETURN to proceed.

Once Homebrew is installed, you’ll need to make sure that your system prioritizes Homebrew’s directory for executables over macOS’s default system tools. Basically, you want to make sure that Homebrew’s version of Ruby gets used instead of the older version macOS might have. To do this, you’ll need to edit your ~/.bash_profile file using a text editor like nano. Run this command to open the file:

nano ~/.bash_profile

Once the file is open, add this line to the very end:

# Add Homebrew’s executable directory to the front of the PATH
export PATH=/usr/local/bin:$PATH

This line adds the directory where Homebrew stores its executables to the beginning of your PATH variable. When you’re done, save your changes by pressing CTRL+O and then RETURN. To exit nano, press CTRL+X.

To make sure the changes take effect right away, run this command in your Terminal:

source ~/.bash_profile

Now, your system is all set to use Homebrew’s tools. These changes will stick around even if you close and reopen Terminal since ~/.bash_profile is automatically executed whenever you open a new Terminal window.

To double-check that Homebrew is installed correctly, run:

brew doctor

If everything’s good, you’ll see the message “Your system is ready to brew.” If there’s anything off, brew doctor will let you know what to do to fix it. Once it’s all set, you’re ready to use Homebrew to install Ruby (and anything else you might need) with ease!

For additional details on installing and setting up Homebrew, check out the comprehensive guide on Homebrew Installation and Setup.

Step 4 — Installing Ruby

Alright, now that Homebrew is all set up, it’s time to put it to good use! Homebrew is like a magical little helper that makes it super easy to install all kinds of software and development tools on your macOS system. It takes care of managing software packages and their dependencies, which basically means it handles all the hard stuff for you. So in this step, we’re going to use Homebrew to install Ruby along with everything it needs to run smoothly. That way, you’ll have the latest and greatest version of Ruby at your fingertips.

To search for software you want to install, you’ll use the brew search command. And to get Ruby (along with all the things that go with it), you can search for Ruby-related packages by typing this:

brew search ruby

Once you run that command, you’ll see a list of all available Ruby versions and some handy tools that come with it, like:

• chruby
• chruby-fish
• imessage-ruby
• jruby
• mruby
• rbenv-bundler-ruby-version
• ruby
• ruby-build
• ruby-completion
• ruby-install
• [email protected]
• [email protected]
• [email protected]
• [email protected]
• [email protected]
• [email protected]
• homebrew/portable/portable-ruby
• homebrew/portable/[email protected]

Among all of these options, you’ll spot the latest stable version of Ruby. To install it, you just need to type:

brew install ruby

Homebrew will go ahead and download Ruby along with any necessary dependencies, like readline, libyaml, and openssl. Now, keep in mind that this might take a little time, since Homebrew will also handle the download and setup of those dependencies. Once it’s done, you’ll see something like this in your Terminal:

==> Installing dependencies for ruby: readline, libyaml, openssl …
==> Summary ? /usr/local/Cellar/ruby/2.4.1_1: 1,191 files, 15.5MB

But wait, there’s more! Homebrew doesn’t just install Ruby. It also sets you up with some super helpful tools like irb (that’s the interactive Ruby console), rake (a tool that runs automation scripts called Rake tasks), and gem (which is a life-saver for installing and managing Ruby libraries).

To make sure Ruby installed properly, check the version by running:

ruby -v

This will show you the version of Ruby you just installed. By default, Homebrew installs the most up-to-date stable version, so you might see something like this:

ruby 2.4.1p111 (2017-03-22 revision 58053) [x86_64-darwin15]

If you ever find yourself wanting to upgrade Ruby to a newer version, it’s a breeze. First, you’ll want to update Homebrew to get the latest package info, and then upgrade Ruby. Just run these two commands:

brew update
brew upgrade ruby

Now that Ruby’s all set up, it’s time to test it out! Let’s write a simple Ruby program to make sure everything is working smoothly.

For more detailed instructions on installing Ruby, visit the comprehensive guide on Ruby Installation Documentation.

Step 5 — Creating a Program

Alright, let’s get hands-on and create a simple “Hello, World” program to make sure everything is working properly with your Ruby setup. This isn’t just a fun little program—it’ll confirm that Ruby is running as it should, and it’ll also give you a chance to get comfortable writing and running Ruby code.

Here’s what you do: First, open up your Terminal and create a new file called hello.rb using the nano text editor. Don’t worry, it’s easy. Just type this command:

$ nano hello.rb

When the file opens up, type this line of Ruby code into the editor:

puts “Hello, World!”

This might look super simple, but trust me, it’s a classic! It’s a basic Ruby script that prints “Hello, World!” to your screen when you run it. After typing it out, you’re going to exit the editor. To do that, press CTRL + X. You’ll be asked if you want to save your file. Hit Y to say yes, then press RETURN to finalize everything.

Now that you’re back at the Terminal prompt, it’s time to run the program! Type the following command:

$ ruby hello.rb

Hit RETURN, and voilà! Your program should run, and you should see this message pop up on your screen:

Hello, World!

Boom! This confirms that Ruby is installed and working like a charm on your macOS machine. The “Hello, World” program is just a little test to make sure all is good, but now you’re ready to dive into more advanced Ruby programming.

Plus, this exercise is great for getting the hang of creating, saving, and running Ruby scripts, which will come in handy as you take on bigger projects in the future. You got this!

To learn more about creating programs in Ruby, check out the official Ruby Quickstart Guide for more tips and examples.

Conclusion

In conclusion, setting up a Ruby programming environment on macOS with Homebrew is an essential step for anyone looking to develop with Ruby. By following this guide, you’ve learned how to install key components like Xcode’s Command Line Tools and Homebrew, as well as how to install and verify Ruby. Whether you’re a beginner or an experienced developer, the process is straightforward and ensures that your macOS system is ready for Ruby development. With this setup, you can now dive into creating Ruby applications, running simple programs like “Hello, World!”, and exploring more complex projects.

Looking ahead, as Ruby continues to evolve, staying updated with the latest versions and tools will be crucial for optimizing your development environment. Keep an eye on new releases of Homebrew and Xcode to ensure you’re always working with the best tools available for macOS Ruby development.

Snippet: “Learn how to set up a Ruby programming environment on macOS using Homebrew and Xcode with this easy-to-follow guide, ensuring your system is ready for Ruby development.”

Master Ruby Programming: Write Your First Interactive Ruby Program (2023)