Day 2 Fundamentals of Linux: A DevOps Engineer's Perspective

Being familiar with Linux is crucial for DevOps engineers as it forms the basis of many of the systems you will oversee. We'll go over the foundations of Linux in this blog and offer practical examples to highlight its significance in the DevOps domain.

What is Linux?

Linux is an open-source operating system that is widely used in various environments, from personal computers to servers and cloud infrastructures. It is known for its robustness, security, and flexibility, making it a preferred choice for developers and system administrators.

History of Linux

Linux was created by Linus Torvalds in 1991 while he was a student at the University of Helsinki. Inspired by the MINIX operating system and the GNU Project, Torvalds developed Linux as a free and open-source Unix-like operating system kernel. He released the first version, 0.01, in September 1991. Over time, contributions from developers worldwide led to its rapid evolution and widespread adoption. Linux became popular in various domains, from servers and supercomputers to embedded systems and personal computers, thanks to its flexibility, security, and community-driven development model.

Benefits of Using Linux

Open Source and Free: Linux is open-source, which means its source code is freely available. This fosters a community-driven approach to software development, encouraging innovation and collaboration.
Security: Linux is renowned for its security features, including user permissions and various security modules.
Stability and Performance: Linux systems are known for their stability and performance, making them ideal for running critical applications and services.
Flexibility: With various distributions (distros) like Ubuntu, CentOS, and Fedora, Linux can be tailored to meet specific needs.
Support and Community: The Linux community is vast and active, providing extensive documentation, forums, and support channels for users of all skill levels.

Architecture of Linux

Linux architecture consists of several layers, each playing a crucial role in the OS's functionality:

Kernel: The core of the operating system, managing hardware resources and providing essential services to the system's software.
System Libraries: Libraries that provide essential functions for applications and system utilities.
System Utilities: Basic programs that perform individual, specialized management tasks.
Shell: The command-line interface that allows users to interact with the system.
Applications: User-level programs that provide various functionalities, from text editors to web browsers.

Linux File System Hierarchy

/ (Root Directory): The top-level directory.
- /bin: Essential command binaries like ls, cp, and mv.
- /boot: Boot loader files, including the kernel.
- /dev: Device files representing hardware components.
- /etc: Configuration files for the system and applications.
- /home: User home directories.
- /lib: Essential shared libraries and kernel modules.
- /media: Mount points for removable media like USB drives.
- /mnt: Temporary mount point for filesystems.
- /opt: Optional software and add-on packages.
- /proc: Virtual filesystem providing process and system information.
- /root: Home directory for the root user.
- /sbin: System binaries for administration.
- /srv: Data for services provided by the system.
- /tmp: Temporary files.
- /usr: User programs and utilities.
- /var: Variable files like logs and databases.

Real-life Example: Imagine you're managing a web server. Knowing that configuration files are in /etc, you can quickly locate and edit the Apache configuration file at /etc/httpd/conf/httpd.conf to update server settings.

Basic Linux Commands

Listing Commands

ls: Lists files and directories.
```
  ls
```
ls -l: Lists files with detailed information.
```
  ls -l
```
ls -a: Includes hidden files in the listing.
```
  ls -a
```
*ls .sh: Lists files with a .sh extension.
```
  ls *.sh
```
ls -lhirt: Lists files with inode numbers and human-readable sizes.
```
  ls -lhirt
```

Directory Commands

pwd: Prints the current working directory.
```
  pwd
```
cd: Changes the directory.
- To a specific directory:
```
  cd path_to_directory
```
- To the home directory:
```
  cd ~
  cd
```
- One level up:
```
  cd ..
```
- Two levels up:
```
  cd ../..
```
  mkdir: Creates a new directory.
- Create a single directory:
```
  mkdir newFolder
```
- Create a hidden directory:
```
  mkdir .NewFolder
```
- Create multiple directories:
```
  mkdir A B C D
```
- Create a nested directory:
```
  mkdir -p A/B/C/D
```

Additional Commands

touch: Creates a new file or updates the timestamp of an existing file.
```
  touch file{1..10}.txt
```
sudo su: Switches to the root user.
```
  sudo su
```
df: Reports file system disk space usage.
```
  df
```
ping: Checks the network connection to a server.
```
  ping example.com
```
rm -r: Removes directories and their contents recursively.
```
  rm -r directory_name
```
echo: Displays a line of text.
```
  echo "Hello, World!"
```
whoami: Displays the current username.
```
  whoami
```
clear: Clears the terminal screen.
```
  clear
```
lsb_release -a: Provides information about the Linux distribution.
```
  lsb_release -a
```

Conclusion

Linux is more than just an operating system; it’s a versatile and powerful tool that forms the foundation of modern DevOps practices. By delving into its history, understanding its architecture, and mastering its file system hierarchy and commands, you equip yourself with the essential skills needed to thrive as a DevOps engineer.

The journey to proficiency in Linux involves continuous learning and hands-on experience. Each command you learn and each configuration you master brings you one step closer to becoming adept at managing complex systems efficiently. Whether you’re automating tasks with scripts, managing servers, or ensuring the security of your infrastructure, Linux provides the flexibility and control necessary for success.

As you advance in your DevOps career, remember that the Linux community is a valuable resource. Engaging with other Linux enthusiasts, contributing to open-source projects, and staying updated with the latest developments will enhance your skills and broaden your knowledge.

Embrace the power of Linux, and you’ll unlock new levels of productivity and capability in your DevOps journey. Keep exploring, keep experimenting, and most importantly, keep learning.