DEV Community: RB Punna

Introduction to Shell Scripting: A Beginner’s Guide

RB Punna — Wed, 09 Oct 2024 12:54:01 +0000

Shell scripting is a powerful way to automate tasks in Linux environments. If you find yourself typing the same commands repeatedly, shell scripts allow you to bundle these commands into a single executable file. This is particularly useful in DevOps, system administration, and development, where automation is key.

In this guide, we’ll cover the basics of shell scripting, from creating your first script to executing and managing file permissions.

Getting Started with Shell Scripting

1. Creating a Shell Script
To create a shell script, you need to start by creating an empty file. You can use the touch command to create a new file:

touch test.sh

The .sh extension is optional but recommended to denote that this file is a shell script.

2. Listing Files and Understanding Manual Pages
After creating your script, you can list the files in the current directory using the ls command:

ls

To understand the various options for a command, use the man (manual) command. For example, to see the options for ls:

man ls

3. Opening and Editing Shell Scripts
To start writing in your shell script, open the file using a text editor like vi or vim:

Open an existing file or create a new one:

vi test.sh

vim test2.sh

Once inside the editor, press i to switch to insert mode and start typing.

The First Line of Every Shell Script: Shebang (#!/bin/bash)
Every shell script should begin with a shebang. This is a special line that tells the system which interpreter to use to execute the script. The most common shebang for Bash scripts is:

#!/bin/bash

This tells the system to use the Bash shell to run the script. Note that #!/bin/sh was commonly used, but as some systems have changed the default shell to dash, it’s safer to explicitly use /bin/bash for compatibility.

Writing Your First Shell Script

Let’s start with something simple: printing text to the screen. Use the echo command in your script to display a message:

#!/bin/bash
echo "My first shell script"

After saving this file (:wq in vi/vim), you need to make the script executable.

Making a Shell Script Executable

By default, newly created scripts aren’t executable. You can grant execute permissions using the chmod command:

chmod +x test.sh

Now, you can run your script:

./test.sh

Alternatively, you can also execute the script using sh:

sh test.sh

Working with File Permissions

Linux uses a permission model that includes read (r), write (w), and execute (x) permissions for the file owner, group, and others. Here’s how to modify permissions for your shell scripts:

-
Give all permissions** (read, write, and execute) to everyone:

chmod 777 firstfile.sh

This grants full control to the user, group, and others.

Read-only permissions:

chmod 444 firstfile.sh
This allows users to read the file but not modify or execute it.

Understanding Numeric Permissions

The numeric permissions in chmod correspond to:

4 = Read
2 = Write
1 = Execute

So, chmod 777 gives read, write, and execute permissions to everyone, while chmod 444 gives only read permissions.

Writing a More Complex Shell Script

Let’s create a slightly more complex shell script that creates a directory and two files inside it:

#!/bin/bash

# Create a directory
mkdir myfolder

# Move into the new directory
cd myfolder

# Create two files
touch file1.txt file2.txt

Save and exit the file, then give it execute permissions:

chmod +x firstbash.sh

Run the script, and you’ll see that it creates the folder and files:

./firstbash.sh

Essential Commands in Shell Scripting

Here are some other important commands you can use in shell scripting:

Disk Space Information: Use df to check disk space usage.

df -h

CPU Information: Use nproc to display the number of processing units available.

nproc

Memory Information: Use free to check memory usage.

free -g

System Monitoring: Use top to display active processes and resource usage.

top

Stopping a Script: Press Ctrl + C to stop a running script or process.

The Role of Shell Scripts in DevOps

In DevOps, shell scripting plays a critical role in automating repetitive tasks such as:

Deploying applications
Managing infrastructure
Monitoring system resources
Performing backups

Automating these tasks reduces human error and ensures consistency in deployments, making shell scripts an essential tool for DevOps professionals.

Using Comments in Shell Scripts

When writing longer scripts, it’s essential to add comments to explain different sections of your script. In Bash, comments begin with the # symbol:

#!/bin/bash

# This is a comment
echo "This script demonstrates shell scripting"

Comments are ignored during execution but help others (or future you) understand your code better.

Conclusion

Shell scripting is a powerful way to automate and streamline tasks in a Linux environment. By learning the basics of scripting, from creating files to managing permissions, you’ll be able to simplify complex processes and boost your productivity.

With commands like chmod, echo, and basic script structures, you're well on your way to mastering shell scripting. And as you grow in your Linux journey, you’ll find countless opportunities to use scripts to solve real-world problems in system administration, development, and DevOps.

Now, it’s your turn: write your first shell script, experiment with the commands, and start automating your tasks today!

Unlocking Linux: A Beginner’s Guide to Essential Commands and Shell Scripting

RB Punna — Thu, 03 Oct 2024 07:16:22 +0000

Why Linux? Understanding the Power Behind the OS

Linux has steadily gained popularity over the years, especially in server environments, software development, and IT operations. What makes it so special? Here’s why Linux stands out:

1. Free
Linux is completely free! You don’t need to purchase expensive licenses or subscriptions to use it. It’s accessible to everyone.

2. Open Source
Linux’s open-source nature allows users to inspect, modify, and distribute the code. This fosters a global community of developers working to improve the system.

3. Secure
With frequent updates and its permission-based architecture, Linux is one of the most secure operating systems available. It’s far less susceptible to viruses and malware than its competitors.

4. Versatile Flavors
Linux comes in many distributions (distros) such as Ubuntu, CentOS, Debian, and Fedora, catering to different needs, from enterprise solutions to personal computing.

5. Fast Performance
Linux’s lightweight structure makes it fast and resource-efficient. It’s especially suited for older hardware or systems requiring high performance, like servers.

Linux Shell: Where the Magic Happens

The shell is the interface between the user and the Linux operating system. It’s where you enter commands and where most of your interaction with the system happens. Let’s dive into the essential Linux commands that every user should know.

Basic Navigation and Directory Management

Linux treats everything as a file, even directories (folders), making navigation a core skill to master.

1. Understanding Your Current Location:
pwd – Print Working Directory. Displays the path of your current directory.

pwd

2. Listing Files and Directories:
ls – List the contents of a directory.

ls

ls -ltr – List files and directories in long format, showing file properties and sorted by time.

ls -ltr

3. Changing Directories:
cd – Change directory. You can move between directories using this command.

cd /path/to/directory     # Move to specific directory
cd ..                     # Move to parent directory
cd ../..                  # Move two directories up

cd directory1/directory2 – Navigate through multiple directories in one go.

4. Creating Directories:
mkdir– This command is used to create a new directory.

mkdir my_new_directory

You can also create multiple directories at once:

mkdir dir1 dir2 dir3

mkdir -p – This option creates parent directories if they don’t already exist. For example, if you want to create a directory inside another directory that doesn't exist yet, use -p:

mkdir -p parent_directory/child_directory

5. Removing Directories:
rmdir – Removes an empty directory.

rmdir empty_directory

rm -r – Removes a directory and its contents recursively.

rm -r directory_to_remove

File Management
Working with files is a daily task for every Linux user, and there are several commands that make this easy.

1. Creating and Editing Files:
touch– Create a new, empty file.

touch newfile.txt

vi – Open or create a file and start editing with the vi text editor.

vi test.txt

Press i to switch to insert mode and start typing.
Press Esc to exit insert mode.
Type :wq! to save and exit.

2. Viewing File Contents:
cat – Display the contents of a file.

cat test.txt

System Monitoring
Monitoring system resources and performance is crucial, especially in server environments or during heavy computation tasks.

1. Checking Memory Usage:
free -g – Display memory usage in gigabytes.

free -g

2. Checking CPU Information:
nproc – Display the number of CPU cores available.

nproc

3. Checking Disk Space:
df -h – Display available disk space in a human-readable format.

df -h

4. Real-Time System Monitoring:
top – Display real-time system information, including CPU and memory usage and running processes.

top

Shell Scripting: Automating Tasks in Linux

Linux is not just about running commands manually. Shell scripting allows you to automate repetitive tasks, making your life easier, especially in DevOps environments.

1. Creating a Simple Shell Script:
Step 1: Create the script
Use the touchcommand to create a script file:

touch myscript.sh

Step 2: Edit the script
Open the script using vior vimand add your commands:

vi myscript.sh

Step 3: Add a Shebang
The shebang (#!/bin/bash) at the top tells the system that this is a bash script:

#!/bin/bash

Step 4: Add Commands
Write your commands under the shebang, like printing a message:

echo "Hello, Linux!"

Step 5: Save and exit
Press Esc and type :wq! to save and exit.

2. Running the Shell Script:
Before running the script, give it execute permission:

chmod +x myscript.sh

Now run the script:

./myscript.sh

3. Managing File Permissions with chmod
In Linux, every file has three types of permissions: read, write, and execute. Using the chmod command, you can modify these permissions for the owner, group, and others. Let’s look at how you can manage file permissions using chmod with some practical examples:

Each group has three types of access:

Read (4) (r)
Write (2) (w)
Execute (1) (x)

4. Granting Read Permission:
To allow a user to read a file, you can use the +r option:

chmod +r myscript.sh

This command gives read permission to the file myscript.sh.

5. Granting Write Permission:
To give write permission (allowing modification of the file), use the +w option:

chmod +w myscript.sh

This allows you or other users to edit the file myscript.sh.

6. Granting Execute Permission:
To make a script or program executable, use the +x option:

chmod +x myscript.sh

This command allows the file myscript.sh to be run as an executable program.

Combining Permissions:
You can also combine multiple permissions in a single command. For example, to give read, write, and execute permissions to a file, use

chmod +rwx myscript.sh

Or, using numeric notation:

chmod 777 myscript.sh

This would grant read, write, and execute permissions to everyone.

DevOps and Shell Scripting: Why It’s Essential

Shell scripting is the backbone of many DevOps operations. Here’s why:

Automating Repetitive Tasks: From deploying applications to managing configurations, shell scripts reduce manual effort.

Efficiency: By scripting routine tasks, you can improve the overall efficiency of the system.

Monitoring and Maintenance: Automate tasks like system monitoring, log rotation, backups, and more using shell scripts.

Bonus: Additional Useful Linux Commands

1. Getting Command Options:
man – The manual for any command. For example, man ls will show all the options for the ls command.

man ls

2. History of Commands:
history – Display the list of commands you've previously entered.

history

3. Canceling a Running Command:
Ctrl+C – Stop a running program in the terminal.

Conclusion

Linux is a powerful and flexible operating system that rewards users who take the time to master its command-line interface. By learning and practicing the commands outlined in this post, you’ll unlock a world of potential — whether you’re navigating the file system, managing resources, or automating tasks through shell scripting.

The key to becoming proficient in Linux is practice. So fire up your terminal, run these commands, and start exploring the endless possibilities that Linux offers!

Thank you for reading..!! If you like the post, Clap and comment..!!

If you feel any other important Linux command to be added, please mention in comment, I will try to add.

I will also post another article on Shell Scripting soon here.