📝 Blog: Day 5 Tasks for DevOps Engineers 🚀

Introduction

Hello fellow DevOps enthusiasts! 👋 Today, let's dive into some advanced Linux shell scripting and user management tasks to further enhance our skills. Let's get started! 💻🔧

1. Automating Directory Creation with

createDirectories.sh

The objective of the createDirectories.sh script is to create a specified number of directories with a dynamic name. The script takes three arguments:

1. Directory name: The base name for the directories to be created.

2. Start number of directories: The number from which the directory names should start.

3. End number of directories: The number at which the directory names should end.

The script will use loops to iteratively create the directories based on the input provided.

2. Automating Backups with a Backup Script

Backups are an integral part of a DevOps Engineer's daily activities. They ensure data security and disaster recovery. To automate the backup process, we can create a shell script that takes regular backups of important files and directories.

The backup script will:

1. Obtain the current timestamp as a unique identifier for the backup.

2. Compress and archive the specified files and directories using the tar command.

3. Move the backup archive to a destination directory for storage.

   

3.Understanding Cron and Crontab: Automating Tasks in Linux

In the world of Linux and system administration, automating repetitive tasks is a crucial aspect of maintaining an efficient and well-organized environment. One of the most powerful tools for task automation is Cron, and it is managed through the Crontab command. In this blog, we'll delve into the concepts of Cron and Crontab and explore how they work together to streamline task scheduling in Linux.

What is Cron?

Cron is a time-based job scheduler in Unix-like operating systems, including Linux. It allows users to schedule and automate the execution of specific commands or scripts at predetermined intervals. These scheduled tasks, known as "cron jobs," can run on a daily, weekly, monthly, or even minute-to-minute basis.

Crontab: The Cron Table

The Crontab (short for "cron table") is a configuration file that holds the list of cron jobs scheduled on a system. Each user can have their Crontab, which defines the tasks they are authorized to schedule and automate.

The Anatomy of a Cron Job

A cron job is defined using a specific syntax in the Crontab file. Each line in the Crontab represents one cron job and follows this format:

* * * * * command_to_be_executed

The five asterisks represent time values that determine the schedule of the job. Each asterisk corresponds to a time unit:

• Minute (0-59)

• Hour (0-23)

• Day of the month (1-31)

• Month (1-12)

• Day of the week (0-6, with Sunday as 0 or 7)

A single asterisk (*) means "every" for the corresponding time unit. For example, * * * * * indicates that the command should be executed every minute.

Examples of Cron Jobs

Here are some examples of cron jobs:

1. To run a script every day at 2:30 AM:

30 2 * * * /path/to/script.sh

1. To run a cleanup script every Sunday at 10 PM:

0 22 * * 0 /path/to/cleanup_script.sh

1. To take a backup of a directory every first day of the month at midnight:

0 0 1 * * /path/to/backup_script.sh

Managing Crontab

To edit your Crontab, use the crontab -e command. This will open the Crontab in the default text editor. To list the existing cron jobs, use crontab -l.

Important Notes

• Be cautious while scheduling cron jobs, as they can affect the system's performance.

• Always specify absolute paths for commands and scripts within cron jobs to avoid issues with environment variables.

Use logging and output redirection (>> and 2>>) to capture the output of cron jobs for debugging and error monitoring.

4.User Management in Linux: Empowering System Administration

In Linux operating systems, user management plays a pivotal role in maintaining a secure and organized environment. As a fundamental aspect of system administration, user management enables administrators to control access to resources, ensure data security, and effectively manage user privileges. In this blog, we'll explore the key concepts of user management in Linux and the essential commands used to interact with users.

Understanding Users in Linux

In Linux, a user is an entity with specific privileges and permissions that determine their access to files, directories, and system resources. Each user is assigned a unique identifier known as the User ID (UID). Additionally, users belong to one or more user groups, which help in organizing users with similar access rights.

User Management Commands

Linux provides several user management commands to interact with users. Here are some of the essential ones:

1. Adding a New User (useradd): To add a new user to the system, the useradd command is used. For example:

sudo useradd username

1. Setting User Password (passwd): The passwd command allows you to set or change a user's password:

sudo passwd username

1. Modifying User Information (usermod): To modify user account properties, such as username, user ID, or primary group, use the usermod command.

2. Deleting a User (userdel): To remove a user account from the system, the userdel command is used:

sudo userdel username

1. Creating User Groups (groupadd) and Adding Users to Groups (usermod): Groups are essential for managing user access and privileges. Use the groupadd command to create a new group and usermod to add users to an existing group.

Viewing User Information

To display user account information, use the id command, which shows details such as UID, GID (Group ID), and group memberships for a specified user:

id username

The Root User

The root user (User ID 0) is a special administrative account with full control over the system. It is crucial to exercise caution while using the root account, as it has the power to modify system files and settings.

Conclusion

Throughout this blog, we've covered various aspects of shell scripting and its significance in automating repetitive tasks in DevOps. We started by creating a powerful script for automating directory creation, followed by backup automation with a backup script and cron jobs. We then explored user management in Linux, understanding user entities and user IDs.

Happy scripting and automation on our DevOps journey! 🚀🐧💻

Happy Learning!!!

Reference

To develop deeper into the world of DevOps I highly recommend following Shubham Londhe on TrainWithShubham and Bhupinder Rajput on Technical Guftgu.