Linux for DevOps Beginners: My DevOps Day 1 Journey — Understanding the Internet, Servers, Linux, and Essential Commands

Every Great DevOps Engineer Starts with the Basics

When people think about DevOps, they often imagine technologies like Docker, Kubernetes, AWS, Jenkins, Terraform, or CI/CD pipelines. These are exciting tools, but I realized something important on the first day of my DevOps journey:

You cannot build a strong DevOps career without understanding the fundamentals.

Just like you cannot build a skyscraper without a solid foundation, you cannot become a successful DevOps engineer without first learning how the internet works, what servers are, and why Linux powers most of today’s cloud infrastructure.

Today marked Day 1 of my DevOps learning journey, and instead of jumping directly into containers or cloud platforms, I focused on understanding the technologies that make modern applications possible.

In this article, I’ll share what I learned, explain each concept in simple English, and show how these fundamentals connect to real-world DevOps practices.

Why These Basics Matter Before Learning DevOps

One of the biggest mistakes beginners make is trying to learn Docker, Kubernetes, or AWS without understanding what happens underneath.

Think about driving a car.

You don’t need to know how every engine component works, but you should understand the basics before driving at high speed.

The same principle applies to DevOps.

Before working with cloud platforms, containers, and automation, you should understand:

• How users access websites
• Where applications actually run
• Why Linux is the preferred operating system
• How servers are configured
• How to interact with a Linux system using the command line

These concepts become the foundation for everything you’ll learn later.

1. How Does the Internet Work?

Every time you open a website, send a message, or watch a YouTube video, thousands of systems work together in the background.

Let’s understand it with a simple example.

Imagine you type:

**www.google.com**

into your browser.

Within milliseconds, several things happen:

1. Your browser sends a request.
2. DNS translates the website name into an IP address.
3. The request travels across the internet.
4. Google’s servers receive your request.
5. The server processes it.
6. The server sends the response back.
7. Your browser displays the webpage.

It happens so quickly that we rarely think about it.

A simple representation looks like this:

Your Computer
      │
      ▼
    Internet
      │
      ▼
DNS Server
      │
      ▼
Google Server
      │
      ▼
Web Page Returns

Understanding this flow is essential because every application you deploy as a DevOps engineer follows the same journey.

Whether it’s an AI chatbot, an e-commerce platform, or a banking application, users interact with servers through the internet.

2. What Are Servers?

A server is simply a computer that provides services to other computers.

Your laptop is designed for personal use.

A server is designed to stay online 24 hours a day, handling requests from users around the world.

For example:

• Netflix servers stream movies.
• Amazon servers process online orders.
• WhatsApp servers deliver messages.
• Banking servers process transactions.

Without servers, websites and applications simply wouldn’t exist.

As a DevOps engineer, your responsibility is to deploy, monitor, secure, and maintain these servers.

Different Types of Servers

Different workloads require different server types.

Some common examples include:

Server TypePurposeWeb ServerHosts websites and web applicationsDatabase ServerStores application dataFile ServerShares files across usersMail ServerSends and receives emailsApplication ServerRuns backend business logic

In modern cloud environments, these servers often run as virtual machines or containers rather than physical hardware.

3. What Is Linux?

One of today’s biggest lessons was understanding why Linux is the heart of modern DevOps.

Linux is an open-source operating system used by millions of servers worldwide.

Unlike desktop operating systems that focus on personal use, Linux is built for stability, security, flexibility, and performance.

This is why companies choose Linux to run their production systems.

Almost every major cloud platform — including AWS, Microsoft Azure, and Google Cloud — offers Linux as the preferred operating system.

If you’re serious about becoming a DevOps engineer, learning Linux isn’t optional — it’s essential.

Why Linux Dominates DevOps

Linux offers several advantages:

• Stable under heavy workloads
• Excellent security
• Highly customizable
• Free and open source
• Efficient resource usage
• Powerful command-line tools

These qualities make Linux the ideal choice for cloud computing, container platforms, and automation.

Whether you’re deploying Docker containers, managing Kubernetes clusters, or creating CI/CD pipelines, Linux knowledge will always be valuable.

4. Linux Server Setup

Today I also learned the basic process of preparing a Linux server.

Although production environments include many additional security and networking steps, the general workflow looks like this:

1. Launch a Linux server.
2. Connect using SSH.
3. Update installed packages.
4. Create users.
5. Configure permissions.
6. Install required software.
7. Configure firewall rules.
8. Deploy applications.

For example, on AWS, you might launch an Ubuntu EC2 instance, connect via SSH, update the system, install Docker, and deploy your application.

That entire process begins with understanding Linux.

5. Linux Basic Commands Every DevOps Beginner Should Know

The Linux terminal is where DevOps engineers spend much of their time.

Here are some of the first commands I learned:

CommandPurposepwdShow current directorylsList files and folderscdChange directorymkdirCreate a new foldertouchCreate a new filecpCopy filesmvMove or rename filesrmDelete filescatDisplay file contentsnanoEdit filesclearClear the terminalhistoryView command history

These commands may seem simple, but they form the building blocks of Linux administration and automation.

How These Concepts Connect to DevOps

One thing became very clear during today’s learning.

Everything in DevOps builds on these basics.

For example:

• Docker containers run on Linux.
• Kubernetes manages Linux-based containers.
• AWS EC2 commonly uses Linux.
• Jenkins pipelines often execute Linux commands.
• CI/CD automation relies on Linux scripting.

Without understanding Linux and servers, learning advanced DevOps tools becomes much more difficult.

Real-World Example

Imagine you’re deploying an AI chatbot for a startup.

The journey looks something like this:

1. A customer opens the chatbot in a browser.
2. The request travels over the internet.
3. A Linux server running on AWS receives the request.
4. Docker hosts the chatbot application.
5. Kubernetes manages scaling and availability.
6. The chatbot processes the request and sends a response.

This entire workflow starts with the concepts I learned today.

What I Learned Today

Today’s learning wasn’t about flashy tools or complex automation.

Instead, it was about understanding the foundation of modern infrastructure.

I learned:

• How requests travel across the internet.
• What servers do.
• Why Linux dominates cloud computing.
• The basic process of setting up a Linux server.
• Essential Linux commands every DevOps engineer should know.

These topics may appear simple, but they are the building blocks for everything that comes next.

What I’ll Learn Next

Now that I have a better understanding of Linux fundamentals, my next steps include:

• Linux users and permissions
• File permissions
• Package management
• Shell scripting
• Git and GitHub
• Docker fundamentals
• Containerization
• Kubernetes
• AWS Cloud
• CI/CD pipelines

Each topic builds naturally on today’s foundation.

Final Thoughts

Every expert was once a beginner.

Today’s lessons reminded me that mastering DevOps isn’t about memorizing commands — it’s about understanding how technology works behind the scenes.

Learning the internet, servers, Linux, and basic commands may not seem exciting compared to Kubernetes or cloud-native architectures, but these fundamentals make everything else easier to understand.

I’m excited to continue this journey and share each step along the way.

If you’re just beginning your DevOps journey, my advice is simple:

Don’t rush the basics. Build a strong foundation, stay consistent, and keep practicing every day.

The technologies will change, but strong fundamentals will stay with you throughout your career.

Happy Learning, and see you in DevOps Day 2!