DEV Community: Anand Ghangoria

Linux : Mastering File System

Anand Ghangoria — Wed, 18 Jun 2025 13:23:14 +0000

What is the Linux File System?

The Linux file system follows a hierarchical directory structure where everything—directories, devices, and even hardware components—is treated as a file. Unlike Windows, which organizes storage using drive letters like C: and D:, Linux operates under a unified structure with a single root directory (/) that encompasses all files and directories.

Linux File System Hierarchy

The Linux file system follows the Filesystem Hierarchy Standard (FHS), which defines a consistent structure for directories and files. Below is an overview of essential directories with examples:

1. / (Root Directory)

The top-level directory from which all other directories branch out. Only the root user has full access to modify critical system files.

Example:

Lists all top-level directories.

2. /bin (Binary Executables)

Contains essential system binaries (commands) like ls, cp, mv, rm, and cat.

Example:

Lists all essential system binaries.

3. /boot (Boot Loader Files)

Stores files needed for booting the system, including the Linux kernel (vmlinuz), bootloader configuration, and initial RAM disk (initrd).

Example:

Displays all boot-related files.

4. /dev (Device Files)

Contains files representing hardware devices (e.g., /dev/sda for the first hard disk, /dev/tty for terminals).

Example:

Lists available storage devices.

5. /etc (Configuration Files)

Stores system-wide configuration files and scripts.

Example:

Displays system user account details.

6. /home (User Home Directories)

Contains personal directories for users (e.g., /home/user1, /home/user2).

Example:

Lists all user directories.

7. /lib & /lib64 (Shared Libraries)

Stores essential shared libraries required by system programs.

Example:

Lists shared C library files.

8. /media & /mnt (Mount Points)

/media: Used for mounting external devices like USB drives and CDs.
/mnt: Temporary mount point for manual mounting of filesystems.

Example:

This mounts an external drive and lists its contents.

9. /opt (Optional Software)

Contains software installed by third-party vendors.

Example:

Lists installed optional software.

10. /proc (Process Information)

Virtual filesystem that provides information about running processes and system resources.

Example:

Displays CPU details.

11. /root (Root User’s Home Directory)

Home directory for the root user.

Example:

Lists files in the root user's home directory.

12. /run (Runtime Data)

Stores volatile runtime information like process IDs.

Example:

Lists runtime data files.

13. /sbin (System Binaries)

Contains essential system administration commands.

Example:

lists of administrative commands.

14. /srv (Service Data)

Stores data related to services like web servers (/srv/www).

Example:

Lists stored service data.

15. /sys (System Information)

Virtual filesystem providing real-time access to kernel and hardware information.

Example:

Lists a Displays system-related files.

16. /tmp (Temporary Files)

Used for storing temporary files.

Example:

Lists temporary files.

17. /usr (User Binaries and Libraries)

Contains user applications, libraries, documentation, and source code.

Example:

Lists user command binaries.

18. /var (Variable Data)

Stores variable files like logs and caches.

Example:

Lists system logs.

File Types in Linux

Regular Files (-************************): Text, binary, and executable files.
Directories (d************************): Containers that hold files.
Symbolic Links (l************************): Pointers to other files.

Special Files:

Character devices (c): /dev/tty

Block devices (b): /dev/sda

Named pipes (p), sockets (s)

Important Linux commands for File Operations with Examples

Viewing Files:

cat filename
less filename

Copying Files:

cp source.txt destination.txt

Moving/Renaming Files:

mv oldname.txt newname.txt

Deleting Files:

rm filename

Changing File Permissions:

chmod 755 script.sh

Changing File Ownership:

chown user:group filename

Creating a Symbolic Link:

ln -s /path/to/file linkname

Finding Files:

find / -name "file.txt"

Checking Disk Usage:

df -h

Terraform Made Easy: A Hands-On Introduction for Beginners

Anand Ghangoria — Sat, 24 May 2025 11:09:54 +0000

This article provides a professional introduction to Terraform, outlining its core features, workflow, and significance in modern DevOps practices. We’ll explore common use cases relevant to various environments and highlight initial challenges to help streamline your adoption of Terraform. Let’s get started.

History of Terraform

The inventor of terraform is Mitchell Hashimoto, the co-founder of Hashicrop.

It was designed as an infrastructure as code (IaC) tool to help automate cloud infrastructure provisioning.
2014: Initial release by Hashicrop.
2017: Introduction of HCL(Hashicrop Configuration Language)
2021: Terraform 1.0 released, as stable for production use.
2023: Opensource ---> Bussiness Source License (BSL).

What is Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) is a method of managing and setting up IT infrastructure using code, instead of manually configuring hardware or using point-and-click tools. With IaC, you write configuration files that tell the system what resources to create, making the process faster, repeatable, and more reliable.

The image above illustrates how traditional infrastructure operates.

Why Terraform?

Terraform helps organizations reduce manual work, improve efficiency, and maintain infra-structure consistency across different environment.

What is Terraform?

Terraform is an open-source Infrastructure as Code (IaC) tool developed by HashiCorp. It allows you to define, provision, and manage cloud infrastructure using simple, human-readable configuration files written in HashiCorp Configuration Language (HCL).

Seamlessly integrating with CI/CD pipelines, Terraform automates infrastructure provisioning and changes, streamlining development workflows and ensuring repeatability across environments.

Key Terraform components

Terraform is stateful, tracking the state of the infrastructure by comparing the current defined IaC configuration and a state file it generates after a Terraform run. This introduces a layer of complexity because you need to manage this state file.

Providers

Define which platform or service you're interacting with (e.g., AWS, Azure, GCP, Kubernetes).

Example:

provider "aws" { region = "us-east-1" }

Resources

Represent the infrastructure objects you want to create or manage (e.g., EC2 instances, S3 buckets).

Example:

resource "aws_instance" "web" { ... }

Modules

Group multiple resources together for reuse and organization.
Help you follow DRY (Don't Repeat Yourself) principles.
Example: A reusable VPC module used across environments.

Variables

Allow you to customize configurations without changing the code.

Example:

variable "instance_type" { default = "t2.micro" }

Outputs

Show useful information after a Terraform run (e.g., IP address of a created instance).

Example:

output "instance_ip" { value = aws_instance.web.public_ip }

State

Tracks the current state of your infrastructure.
State stored in a .tfstate file, either locally or remotely (e.g., in S3).

Terraform Workflow

Terraform follows a simple yet powerful workflow to manage infrastructure as code:

Init – Run terraform init to initialize the working directory and download providers.
Plan – Preview changes with terraform plan before making any updates.
Apply – Execute changes with terraform apply to provision or update resources.
Destroy – Use terraform destroy, to Destroys all resources defined in your Terraform configuration.

🔍 File Overview

main.tf – The heart of your infrastructure.
variables.tf – Defines inputs for flexibility.
terraform.tfvars – Assigns real values to your variables.
outputs.tf – Makes key info accessible after deployment.
provider.tf – Sets up your cloud provider (e.g., AWS).
backend.tf – Configures remote state storage (optional but recommended).
versions.tf – Locks Terraform & provider versions.
modules/ – Reusable infrastructure components.
env/ – Isolated configurations for environments like dev/staging/prod.

📦 Pro Tip: Keep sensitive values (like secrets) out of version control. Use terraform.tfvars locally or manage secrets with tools like Vault or SSM.

Hashicrop Configuration Language (HCL)

What is HCL?

HCL (HashiCorp Configuration Language) is a declarative language designed by HashiCorp.

It is mainly used in tools like Terraform to define Infrastructure as Code (IaC).

Human-readable: Easy for people to write and understand.
Declarative: You describe what you want, not how to do it.
Optimized for machines: Easy for software to parse and process.

HCL allows you to manage and provision cloud resources (like AWS, Azure, GCP) in a clear and structured way.

HCL Syntax: Blocks, Parameters, and Arguments

1. Blocks

Blocks are the fundamental building units in HCL. They group configuration settings together.

A block starts with a block type (like resource, provider, variable).
It can have one or more labels (names or identifiers).
Inside the curly braces {}, you write the block’s body — parameters and arguments.

Example:

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

resource is the block type
"aws_instance" and "web_server" are labels (resource type and resource name)
Inside {}, you define arguments (parameters to configure the resource)

2. Arguments

Arguments are key-value pairs inside a block that configure the block’s behavior.
The key is the argument name.
The value can be a string, number, boolean, list, map, or an expression.
Arguments define how a resource, provider, or variable is set up.

Example:

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"  # Argument
  instance_type = "t2.micro"                 # Argument
}

These two lines are arguments specifying which Amazon Machine Image (AMI) to use and the instance size.

3. Parameters

Parameters are inputs that allow you to customize and reuse your Terraform configurations, especially within variables and modules.

Parameters define what values a block (like variable or module) expects from the user.
They make your configurations flexible by accepting dynamic input.
Parameters are declared inside blocks like variable or passed into module blocks.

Example:

variable "region" {
  description = "The AWS region where resources will be created"
  type        = string
  default     = "us-east-1"
}

In this example, description, type, and default are parameters (arguments) that define the variable’s behavior.

Hands-On: Provisioning an S3 Bucket with Terraform

In this hands-on guide, we'll walk through the steps to create an Amazon S3 bucket using Terraform. This is perfect for beginners who want to get practical experience with Infrastructure as Code (IaC) on AWS.

Step 1: Verify Terraform and AWS CLI Versions

Before starting, make sure both Terraform and AWS CLI are installed and accessible in your terminal.

terraform -version
aws --version

Step 2: Define the AWS Provider Configuration

Create a file named provider.tf and configure the AWS provider. This tells Terraform which cloud and region to use.

#provider.tf
provider "aws" {
  region = "us-east-1"
}

Make sure you’ve configured AWS CLI with your credentials using aws configure.

Step 3: Configure `main.tf` for S3 Bucket

Now create the main Terraform configuration to define the S3 bucket resource.

# main.tf
resource "aws_s3_bucket" "my_bucket" {
  bucket = "anand-ghangoria-bucket"  # Replace with a unique name

  tags = {
    Name        = "MyBucket"
    Environment = "Dev"
  }
}

Bucket names must be globally unique across all AWS accounts. Modify bucket accordingly.

Step 4: Initialize, Plan, and Apply

Run the following Terraform commands in the terminal:

# Initialize the project (downloads provider plugins)
terraform init

# Preview the changes that will be made
terraform plan

# Apply the configuration to create the S3 bucket
terraform apply

When prompted, type yes to confirm the apply step.
If everything was configured correctly, you should see an output like:

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

You’ve now successfully created an S3 bucket using Terraform!

STEP:5 Clean Up Resources

To delete the S3 bucket and avoid unwanted charges:

terraform destroy

Hands-On: create an EC2 instance on AWS using Terraform

In this hands-on guide, we'll walk through the steps to create an Amazon EC2 instance using Terraform. This is perfect for beginners who want to get practical experience with Infrastructure as Code (IaC) on AWS.

Step 1: Verify Terraform and AWS CLI Versions

Before starting, make sure both Terraform and AWS CLI are installed and accessible in your terminal.

terraform -version
aws --version

Step 2: Define the AWS Provider Configuration

Create a file named provider.tf and configure the AWS provider. This tells Terraform which cloud and region to use.


# Configure the AWS Provider
provider "aws" {
  region = "us-east-1"
}

Make sure you’ve configured AWS CLI with your credentials using aws configure.

Step 3: Configure `main.tf` for EC2 instance

Now create the main Terraform configuration to define the EC2 instance resource .

# main.tf
resource "aws_key_pair" "my_key" {
  key_name   = "delight"
  public_key = file("delight.pub")
}

data "aws_ami" "ubuntu" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"] # Canonical
}

resource "aws_instance" "web" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "t2.micro"
  key_name = aws_key_pair.my_key.key_name

  tags = {
    Name = "delight"
  }
}

Step 4:Generate an SSH key pair named `delight`

ssh-keygen -t rsa -b 2048 -f delight
chmod 400 delight

When prompted for a passphrase, you can just press Enter to skip it (or set one if you want).

Step 5: Initialize, Plan, and Apply

Run the following Terraform commands in the terminal:

# Initialize the project (downloads provider plugins)
terraform init

# Preview the changes that will be made
terraform plan

# Apply the configuration to create the S3 bucket
terraform apply

When prompted, type yes to confirm the apply step.
If everything was configured correctly, you should see an output like:

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

You’ve now successfully created an ec2 instance using Terraform!

Step:6 Clean Up Resources

To delete the ec2 instace and avoid unwanted charges:

terraform destroy

Terraform #IaC #FileStructure #DevOps #BestPractices #HashiCorp #CloudInfrastructure

DEV Community: Anand Ghangoria

Linux : Mastering File System

What is the Linux File System?

Linux File System Hierarchy

1. / (Root Directory)

Example:

2. /bin (Binary Executables)

Example:

3. /boot (Boot Loader Files)

Example:

4. /dev (Device Files)

Example:

5. /etc (Configuration Files)

Example:

6. /home (User Home Directories)

Example:

7. /lib & /lib64 (Shared Libraries)

Example:

8. /media & /mnt (Mount Points)

Example:

9. /opt (Optional Software)

Example:

10. /proc (Process Information)

Example:

11. /root (Root User’s Home Directory)

Example:

12. /run (Runtime Data)

Example:

13. /sbin (System Binaries)

Example:

14. /srv (Service Data)

Example:

15. /sys (System Information)

Example:

16. /tmp (Temporary Files)

Example:

17. /usr (User Binaries and Libraries)

Example:

18. /var (Variable Data)

Example:

File Types in Linux

Important Linux commands for File Operations with Examples

Viewing Files:

Copying Files:

Moving/Renaming Files:

Deleting Files:

Changing File Permissions:

Changing File Ownership:

Creating a Symbolic Link:

Finding Files:

Checking Disk Usage:

Terraform Made Easy: A Hands-On Introduction for Beginners

History of Terraform

What is Infrastructure as Code (IaC)?

Why Terraform?

What is Terraform?

Key Terraform components

Terraform Workflow

🔍 File Overview

Hashicrop Configuration Language (HCL)

What is HCL?

HCL Syntax: Blocks, Parameters, and Arguments

1. Blocks

2. Arguments

3. Parameters

Hands-On: Provisioning an S3 Bucket with Terraform

Step 1: Verify Terraform and AWS CLI Versions

Step 2: Define the AWS Provider Configuration

Step 3: Configure main.tf for S3 Bucket

Step 4: Initialize, Plan, and Apply

STEP:5 Clean Up Resources

Hands-On: create an EC2 instance on AWS using Terraform

Step 1: Verify Terraform and AWS CLI Versions

Step 2: Define the AWS Provider Configuration

Step 3: Configure main.tf for EC2 instance

Step 4:Generate an SSH key pair named delight

Step 5: Initialize, Plan, and Apply

Step:6 Clean Up Resources

Terraform #IaC #FileStructure #DevOps #BestPractices #HashiCorp #CloudInfrastructure

Step 3: Configure `main.tf` for S3 Bucket

Step 3: Configure `main.tf` for EC2 instance

Step 4:Generate an SSH key pair named `delight`