Terminal Mastery Series

Welcome back DevOps enthusiasts and leaners to my DevOps Journey :) !

In Week 1, we explored how software is developed and deployed, and the role
DevOps engineers plays in this process.
In Week 2, we learned about Linus Torvalds, Linux, Its History and why is it the
backbone of DevOps.

I also wrote an article titled 'Flavors of GNU/Linux', which you can read to better
understand Linux distributions and how Richard Stallman's vision has been
backed and continues to be supported by millions of contributors world wide.

In this article, we will get to know the terminal better. We'll keep it simple as we
dive into the terminal to learn the essential commands. The focus in this week
will be basics to intermediate Linux commands that help you navigate, inspect,
troubleshoot, and manage systems effectively. I will guide you from intermediate
to master in the coming weeks.

So, without further ado, let's SSH into the terminal.

What is the Terminal & Why It Matters in DevOps

The terminal or CLI (Command Line Interface) is where a lot of DevOps magic
happens, from deploying infrastructure to monitoring logs, restarting services,
automating scripts, and much more.

In DevOps, GUI tools are limited. The CLI gives us the speed, control, and
automation that modern infrastructure needs.

In this series, we will use AWS as our cloud platform because it's free and
user-friendly. To work with the terminal on Windows or macOS, we need to
use something called a Virtual Machine, specifically an EC2 instance.

If you are new to cloud computing or AWS services, I will soon write about what
DevOps Engineers need to know about cloud platforms.

In the meantime, you just need to create a free tier account in AWS and launch
an EC2 instance from the search bar. Make sure to use a free tier-enabled AMI
(Amazon Machine Image) and instance type; otherwise, there will be charges.

After opening the Ec2 instance from the search bar it should look like this, you have to
name it first and select the free tire enabled AMI and Instance type and then create a
Key Pair from the section below. Make sure you download the .pem file in a file that
can be accessible and make sure its downloaded successfully.

`.pem` file ?

A .pem (Privacy Enhanced Mail) file is a private key file used to securely authenticate
your identity when connecting to remote servers, like AWS EC2 instances via SSH.

Why It’s Important in AWS:

When you launch an EC2 instance, AWS lets you download a .pem file.
This file is your SSH private key, and it’s used to prove your identity when
accessing the instance securely.
Without this key, you can’t log in to the server.

You have to download Git bash (Click to download) for bashing into the terminal

Git Bash?

Git Bash is a terminal application that bundles Git + Bash shell in one tool.
Windows OS comes with Command Prompt (cmd) and PowerShell, which
are not Unix-like and Most Linux commands, which are essential in DevOps
and scripting, won’t work in cmd or PowerShell. So we use Git Bash It
provides a Unix-like Bash terminal experience, supports Linux/DevOps
commands, and makes Windows compatible with common DevOps workflows.

Steps to Follow After Downloading Git Bash

We have created the EC2 instance. Now, each time we connect to the instance,
we will follow these steps:

Select the instance we to connect and select connect. Most of the times
the instances will be turned off so we have to start that from Instance state
drop down.
Click the Connect selection which will connect the instance. This opens up
another tab which is shown in the image above. It shows different ways which
user can connect to the Ec2 instance.
We will use the SSH client because Git Bash supports it, allowing us to securely
connect to the server just like we would from a Linux or macOS terminal.
Then, copy the SSH command used to connect to the AWS EC2 instance from
your terminal and paste it into the Git Bash terminal. Make sure to open the
Git bash in the same directory where the .pem file is located.

We will use these same steps in the upcoming weeks to connect to an EC2 instance,
which we will work with most of the time as DevOps engineers.

SSH ?

It’s a protocol (set of rules) that lets you securely access a remote computer’s terminal
over an unsafe network (like the internet).

SSH is like teleporting into a secure remote system's terminal with encrypted ID cards,
while the server bouncer (sshd) checks your background, badge, and permissions,
before letting you in to play with the real tools (sudo).

Here’s what using Git Bash with SSH looks like in action:

Linux Commands

Now that we have set up everything, it's time to start using the actual terminal
and get our hands dirty.

As Linus Torvalds always says :),

"Talk is cheap. Show me the code."

Command	Purpose
`pwd`	Print current working directory
`ls` `ls -l` `ls-lr` `ls -lt` `ls -ltr`	List files and directories
`cd </directory name>` `cd ..`	Change directory

There are many type of ls commands which are used to list the files in multiple
ways each have its own purpose. We mostly will be going to use ls and ls -l.

ps: Those who don’t know directory in Linux is like a folder containing files and
other directories.

Here is how the commands look in action:

2. File & Directory Operations

Command	Purpose
`touch <filename.extension>`	Create empty file
`mkdir <directory name>`	Create a directory
`cp`, `mv`, `rm`	Copy, move, delete files
`cat`, `less`, `more`	View file contents
`nano`, `vim`	Edit files directly from terminal

2.1. Cat (ConcentrATe)

Cat can be used for viewing a file and can also be used to append contents to
the files as well.

Command	Purpose
`cat > <filename.txt>`	Creates a new file and lets you type content directly into it
`cat >> <filename.txt>`	Append content at the end of the file without overwriting it
`cat -n <filename.txt>`	Prints the file along with numbers in each line

The first command using > can overwrite the content, so using >> is preferred.
We can also use > to combine multiple files into one file like,
cat <filename1.txt> <filename2.txt> > <combinedfile.txt>

Take a look:

2.2. File Editors

While cat can be called as a file editor, it cant be termed as a proper file editor as
it gives less freedom to edit the file completely. Using file editors like vim and nano
users can edit files with full control over it. Each line can be changed and replaced.

This is what vim and nano looks like:

3. Search & Filter Tools

There are many commands for searching in Linux which serves different purposes.
I will write a detailed article about the difference between those search commands
so stay tuned. :)

Meanwhile, here are some basic Search and Filter commands:

Command	Purpose
`grep`	Search inside files
`find`	Find files or directories
`locate`	Quickly find files (uses a pre-built database)

Applying them:

4. Basic Networking Commands

Command	Purpose
`ping`	Check connectivity
`ifconfig`	Network interface info
`curl` `wget`	Fetch data from web or API

Networking commands:

Conclusion

Here are some of the most basic yet essential Linux commands , Just enough to
get you comfortable in the terminal without overwhelming you (hopefully!). If you
felt stuck at any point or found something unclear, feel free to drop a comment or
reach out I’d love to hear your feedback and help you out.

Even though these commands might seem simple at first glance, they form the
foundation of day-to-day DevOps work, whether you're navigating servers,
managing files, or writing automation scripts.

Next week, we’ll go deeper into the terminal world: covering advanced commands
focusing on User and User Groups, File permissions (chmod, chown) and Sudoers File.
We will cover shell scripting in the later weeks to start automating tasks like a pro.

Till Then.

Happy learning ~ H :)

Hands on the Terminal: DevOps Week 3 Breakdown