DEV Community: Ijas Ahammed

How to Use Terraform to Create an AWS S3 Bucket: A Beginner’s Guide

Ijas Ahammed — Fri, 06 Feb 2026 16:57:36 +0000

What is Terraform?

Terraform is an open-source tool that lets you write code to create and manage cloud infrastructure. Instead of clicking through AWS console to create resources manually, you write configuration files that describe what you want, and Terraform builds it for you.

Think of it like this: Instead of building a LEGO house brick by brick, you write down instructions, and Terraform builds it automatically every time.

What is Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) means managing your servers, databases, networks, and other infrastructure using code files instead of manual configuration.

Benefits:

Repeatable: Create the same infrastructure multiple times without errors
Version Control: Track changes using Git, just like application code
Documentation: Your code becomes living documentation
Collaboration: Teams can review and collaborate on infrastructure changes

Use Cases:

Setting up development, staging, and production environments that are identical
Quickly spinning up infrastructure for new projects
Disaster recovery - rebuild everything from code if something breaks
Sharing infrastructure setups across teams

What is a Terraform Provider?

A provider is a plugin that allows Terraform to interact with a specific cloud platform or service (like AWS, Azure, Google Cloud, etc.).

Think of providers as translators - they translate your Terraform code into API calls that the cloud platform understands.

Setup Guide

1. Create IAM User with S3 Full Access

Before we can create S3 buckets, we need AWS credentials with proper permissions.

Steps:

Log into AWS Console → Go to IAM service
Click "Users" → "Create user"
Username: Enter terraform-demo-user
Click "Next"
Attach policies directly → Search and select AmazonS3FullAccess
Click "Next" → "Create user"
Click on the user → Go to "Security credentials" tab
Click "Create access key"
Select "Command Line Interface (CLI)"
Check the confirmation box → "Next"
"Create access key"
IMPORTANT: Save both:

* Access Key ID

* Secret Access Key (you won't see this again!)

2. Configure AWS CLI

Install AWS CLI (if not already installed):

# For Mac (using Homebrew)
brew install awscli

Configure with your access keys:

aws configure

You'll be prompted to enter:

AWS Access Key ID: [paste your access key]
AWS Secret Access Key: [paste your secret key]
Default region name: ap-south-1
Default output format: json

Verify it works:

aws s3 ls

4. Create Terraform Alias (Optional)

# Add to your shell config file (~/.zshrc for Mac)
echo 'alias tf="terraform"' >> ~/.zshrc

# Reload your shell
source ~/.zshrc

# Test it
tf version

5. Setup VS Code

Open VS Code
Go to Extensions (Cmd+Shift+X)
Search for "HashiCorp Terraform"
Install the official extension

Benefits:

Syntax highlighting
Auto-completion
Format on save
Validation

Understanding the Terraform Configuration

Create a file named main.tf:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"
    }
  }
}

# Configure the AWS Provider
provider "aws" {
  region  = "ap-south-1"
}

# Create S3 Bucket
resource "aws_s3_bucket" "my_first_bucket" {
  bucket = "ijas-tf-test-bucket-12345"

  tags = {
    Name        = "My bucket"
    Environment = "Dev"
  }
}

The terraform {} block is used to configure Terraform itself. Inside it, required_providers tells Terraform which providers are needed for the project. In this case, aws is the name we use to refer to the AWS provider, and source specifies that it should be downloaded from HashiCorp’s official registry.

The line version = "~> 6.0" means Terraform can use any 6.x version of the provider, allowing minor updates but not major ones. The ~> symbol is called a pessimistic constraint, which lets Terraform update safely without breaking changes.

The provider "aws" block is used to set up the AWS provider. Inside it, the region tells Terraform where to create your AWS resources, in this case, Mumbai. Terraform automatically uses the login details you already set up earlier with aws configure, so you don’t need to write your credentials again.

The resource keyword is used to define an infrastructure item in Terraform. "aws_s3_bucket" specifies that you’re creating an S3 bucket using the AWS provider. "my_first_bucket" is just a local name you give this resource inside your Terraform code. The bucket field sets the real S3 bucket name in AWS, which must be globally unique. Finally, tags are optional labels you add to help organize resources and track costs.

Terraform Workflow

Step 1: Initialise Terraform

terraform init
# or using alias
tf init

What happens:

Downloads the AWS provider plugin
Sets up the backend (where state is stored)
Prepares the working directory

Output you'll see:

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/aws versions matching "~> 6.0"...
- Installing hashicorp/aws v6.x.x...
Terraform has been successfully initialized!

Step 2: Plan the Changes

terraform plan
# or
tf plan

What it does:

Compares your code with the current state
Shows what will be created, modified, or destroyed
Like a "preview" before making actual changes

Output:

Terraform will perform the following actions:

  # aws_s3_bucket.my_first_bucket will be created
  + resource "aws_s3_bucket" "my_first_bucket" {
      + bucket                      = "ijas-tf-test-bucket-12345"
      + tags                        = {
          + "Environment" = "Dev"
          + "Name"        = "My bucket"
        }
      ...
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Symbols:

+ = Will be created
~ = Will be modified
- = Will be destroyed

Optional: Save the Plan

tf plan -out=tfplan

Why use this?

Saves the exact plan to a file
When you run tf apply tfplan, it executes exactly what was planned
Prevents surprises if something changes between plan and apply
Good practice for production environments

Step 3: Apply the Changes

terraform apply
# or
tf apply

Terraform will show the plan again and ask:

Do you want to perform these actions?
  Enter a value:

Type yes and press Enter.

Skip the confirmation:

tf apply -auto-approve

What happens:

Terraform makes API calls to AWS
Creates the S3 bucket
Saves the state to terraform.tfstate file

Step 4: Verify in AWS Console

Go to AWS Console → S3
You'll see your bucket: ijas-tf-test-bucket-12345
Click on it → Properties tab → Tags
You'll see the tags you defined

Step 5: Modify and Reapply

Let's change a tag in main.tf:

resource "aws_s3_bucket" "my_first_bucket" {
  bucket = "ijas-tf-test-bucket-12345"

  tags = {
    Name        = "My bucket"
    Environment = "Development"  # Changed from "Dev"
    Owner       = "Ijas"          # Added new tag
  }
}

Run:

tf plan

You'll see:

  # aws_s3_bucket.my_first_bucket will be updated in-place
  ~ resource "aws_s3_bucket" "my_first_bucket" {
      ~ tags = {
          ~ "Environment" = "Dev" -> "Development"
          + "Owner"       = "Ijas"
            "Name"        = "My bucket"
        }
    }

Plan: 0 to add, 1 to change, 0 to destroy.

Apply the changes:

tf apply -auto-approve

Go back to AWS Console → refresh → see the updated tags!

Step 6: Destroy Resources

When you're done experimenting:

terraform destroy
# or
tf destroy

Terraform shows what will be destroyed:

Plan: 0 to add, 0 to change, 1 to destroy.

Do you really want to destroy all resources?
  Enter a value:

Type yes or use:

tf destroy -auto-approve

What happens:

Terraform deletes the S3 bucket from AWS
Updates the state file (now empty)

Key Concepts Summary

Concept	Simple Explanation
Terraform	Tool to write code that builds cloud infrastructure
IaC	Managing infrastructure through code files instead of clicking
Provider	Plugin that connects Terraform to cloud platforms (AWS, Azure, etc.)
Resource	A piece of infrastructure you want to create (S3 bucket, EC2 instance)
State	Terraform's memory of what exists in the cloud
Plan	Preview of changes before applying them
Apply	Actually create/update/delete resources
Destroy	Delete all resources managed by Terraform

Common Commands Cheat Sheet

# Initialize project (run once)
tf init

# Preview changes
tf plan
tf plan -out=tfplan  # Save plan to file

# Apply changes
tf apply
tf apply -auto-approve  # Skip confirmation
tf apply tfplan  # Apply saved plan

# Show current state
tf show

# List resources
tf state list

# Destroy everything
tf destroy
tf destroy -auto-approve

# Format code (clean up spacing/indentation)
tf fmt

# Validate syntax
tf validate

Understanding HR Domain

Ijas Ahammed — Sat, 17 Jan 2026 15:00:42 +0000

What We'll Cover

Before diving into architecture and code, we need to gain a deep understanding of the HR domain. In this post, I'll break down the six core HR processes that every modern HR Management System must handle:

Recruitment & Hiring
Employee Onboarding
Attendance & Time Tracking
Leave Management
Payroll Processing
Performance Management

By the end, you'll have a clear mental model of how these processes work and their key challenges.

Why Domain Understanding Matters

Before I learned this: I thought I could jump straight into designing microservices. Big mistake! Without understanding the domain, you'll:

Miss critical features
Create wrong service boundaries (Split services wrongly)
Build systems that don't match real-world workflows
Struggle with naming and consistency

The Truth

60% of system design is understanding the problem.

40% is implementing the technical solution.

1️⃣ Recruitment & Hiring

The Workflow

Step	Process
1	📄 Job Requisition
2	📢 Job Posting
3	📥 Applications Received
4	🔍 Screening
5	🗣️ Interviews
6	📑 Offer
7	✅ Acceptance
8	🚀 Onboarding

The process begins with Job Requisition, where a department identifies the need for a new hire and gets approval to fill the position.

Next, the role is shared publicly during Job Posting, allowing potential candidates to learn about the opportunity and apply.

Once applications come in, they are collected under Applications Received, creating a pool of interested candidates.

During Screening, resumes and applications are reviewed to shortlist candidates who best match the job requirements.

Shortlisted candidates move to Interviews, where their skills, experience, and fit for the role are evaluated through discussions.

After interviews, a selected candidate receives an Offer, which includes job details such as role, salary, and joining date.

If the candidate agrees, Acceptance confirms their decision to join the organisation.

Finally, Onboarding helps the new employee settle in through documentation, training, and introductions to the team.

Key Components

Stakeholders

Hiring Manager — Initiates and owns the job requisition.
Recruiter — Manages the end-to-end recruitment process.
Interview Panel — Assesses candidate skills, experience, and suitability.
HR Administrator — Handles final approvals and employment formalities.

Critical Features

Feature	Description	Complexity
Job Posting	Publish job openings across multiple platforms like the company website and job portals	Medium
Application Tracking	Track and manage candidates through different hiring stages	High
Interview Scheduling	Schedule interviews using calendar integration and meeting rooms	Medium
Candidate Scoring	Collect and compare interviewer feedback using standard forms	Medium
Offer Management	Create offers, manage approvals, and collect digital signatures	High

Business Rules

Approval Before Posting

Every job requisition must receive budget and management approval before it can be published.
Minimum Candidate Screening

A defined minimum number of candidates must be screened to ensure fair and competitive selection.
Mandatory Interview Feedback

All interview panel members must submit feedback before a hiring decision can be made.
Offer Validity Period

Job offers are valid only for a fixed time frame (usually 7–15 days) after which they expire automatically.
Background Verification Required

Final hiring confirmation is completed only after successful background and document verification.

Real-World Challenge

Scenario:

A single candidate may apply for multiple job openings using the same or different details, leading to duplicate records.

Solution:

Create a centralised candidate profile using a unique identifier (such as email or phone number). Each candidate has one master profile in the system. Multiple job applications are linked to the same profile.

2️⃣ Employee Onboarding

The Workflow

Step	Stage Name
1	Offered
2	Document Submission
3	Background Check
4	Account Creation
5	Asset Assignment
6	First Day Setup
7	Active

The onboarding begins when the candidate receives and accepts the job offer, officially confirming their entry into the organisation.

Once the offer is accepted, the candidate is asked to submit all required documents for verification and record-keeping purposes.

After the documents are collected, the company performs a background verification to ensure all provided information is accurate.

When verification is completed successfully, official company accounts and system access are created for the new employee.

With digital access ready, necessary work assets such as laptops, ID cards, or other tools are assigned.

On the first working day, basic system setup, orientation, and introductions are completed to help the employee get started smoothly.

Finally, the onboarding process concludes as the employee becomes fully active and begins normal work responsibilities.

Data to Collect

Category	Examples
Personal	Name, DOB, Gender, Address, Emergency contacts
Professional	Previous employment, Education, Certifications
Financial	Bank account, PAN/Tax ID, Salary account
Compliance	Work permits, Right to work documents

Edge Cases

❗ What if the background check fails after offer acceptance?

If the background check fails after the offer is accepted, the company may withdraw the offer based on its internal policy. Legal and compliance teams usually review the case before taking a final decision.

❗ What if the employee doesn't submit documents on time?

If the employee does not submit documents on time, a short grace period is usually given. If delays continue, the issue may be escalated, and the onboarding process can be temporarily paused.

3️⃣ Attendance & Time Tracking

Attendance Methods

No.	Method	Description
1	Biometric (Fingerprint / Face)	Attendance is marked using fingerprint or face scan at the office.
2	RFID Card Swipe	Employees swipe their ID card on a machine to record attendance.
3	Mobile App (GPS-based)	Attendance is marked through a mobile app with location tracking.
4	Web Portal (Manual)	Employees manually log in to a website to mark attendance.
5	Beacon / Bluetooth (Office Entry)	Attendance is automatically captured when entering the office using Bluetooth.

Shift Management:

Fixed shifts (9 AM - 6 PM)
Flexible hours (core hours + flexible)
Rotating shifts (for 24/7 operations)
Night shifts (with allowances)

Attendance Status:

Present (On time)
Late (Grace period: 15-30 mins)
Half Day (Less than X hours)
Absent
Work from Home
On Leave
Holiday

Overtime Calculation:

Regular hours: 8 hours/day
Overtime: > 8 hours
Weekend work: 2x multiplier
Holiday work: 3x multiplier

Business Rules

Employees can be up to 15 minutes late without penalty.
A full day counts only if 8 hours are worked.
Working 4–6 hours is counted as a half day.
Overtime is valid only with manager approval.
Attendance issues must be corrected within 3–5 days.

The Tricky Part: Timezone Handling

Challenge: Global team with employees in multiple time zones.

Example:

HQ in India (IST)
Employee working from the USA (EST)
Check-in at 9 AM EST = 7:30 PM IST (previous day!)

Solution: Store all timestamps in UTC, convert time only for display and reports based on each employee’s assigned time zone.

4️⃣ Leave Management

Leave Types Hierarchy

Annual Leave Quota

Leave Type	Description
Earned Leave	Leave accumulated monthly based on days worked.
Casual Leave	Short-term leave granted annually for personal needs.
Sick Leave	Leave provided annually for illness or medical reasons.
Compensatory Off	Leave earned by working extra hours or on holidays.
Maternity Leave	Leave granted to female employees as per company policy and law.
Paternity Leave	Leave granted to male employees around childbirth, as per policy.
Loss of Pay	Unpaid leave taken when no other leave balance is available.

The Leave Request Workflow

Leave Balance Calculation

Below is an example of how leave balance and accrual logic might be adopted in an HR management system. Accrual means that leave gets added little by little over time. Instead of giving all leave at once, the system adds some every month.

Earned Leave

Every month, you earn 1.5 days
Over a full year: 1.5 × 12 = 18 days
If you don’t use all your earned leave, you can carry it forward:
- You can carry forward only up to 10 days into the next year
- Anything above 10 days is removed or settled
Encashment means converting unused leave into money
- Earned Leave can be converted into salary
- Example: 5 unused days → paid as money

Casual Leave

This is for short, unexpected needs.

You get 12 days per year
All 12 days are given at once on January 1st
Cannot be carried to next year
Cannot be converted to money
If not used → it expires

Leave Type	Days / Year	Carry Forward	Encashment	Expiry
Earned Leave	18	Up to 10 days	Yes	Excess removed
Casual Leave	12	No	No	Expires yearly

Business Rules

Advance notice required
- Some leaves must be applied early
- Example:
  - Casual Leave → 2 days before
  - Earned Leave → 7 days before
Blackout periods
- During important times (year-end, major projects)
- Leave may not be allowed
Maximum continuous leave
- You can’t take too many days in a row
- Example: max 10 consecutive days
Half-day leave
- The company decides whether half-day leave is allowed
Leave cancellation rules
- Leave may need to be cancelled before a certain date
- Late cancellation may still count as leave

5️⃣ Payroll Processing

Salary Structure

CTC (Total yearly pay): $100,000
Fixed Pay (80%)
- Basic Salary: $40,000
- HRA: $20,000
- Special Allowance: $20,000
Variable Pay (15%)
- Bonuses and incentives (performance-based)
Benefits (5%)
- Provident fund, insurance, meal vouchers

Payroll Process (Monthly)

Collect attendance data
Calculate working and leave days
Identify Loss of Pay (LOP)
Calculate gross salary
Add bonuses or overtime
Deduct PF, tax, and other deductions
Calculate net salary
Generate payslip
Transfer salary to the bank

Deductions

Mandatory

Income tax
Provident Fund (12% of basic)
Professional tax
Insurance (if applicable)

Optional

Loan or advance recovery
Meal charges
LOP deductions

Tax Calculation

Tax is calculated using slabs (higher income → higher tax rate)
Allowed deductions reduce taxable income (insurance, loans, donations)

Payroll Cycle

Day 1–25: Attendance tracking
Day 26–30: Data freeze
Next month Day 1–5: Payroll processing & approval
Day 7: Salary paid
Day 10: Payslip shared

Important Edge Cases

Mid-month joining → salary paid proportionally
Mid-month resignation → final settlement
Salary revision → arrears calculation
Recoveries → adjusted in last salary

Payroll ensures employees are paid accurately, on time, and legally compliant.

6️⃣ Performance Management

Performance management is how a company checks how well an employee is doing their job.

At the start, employees are told what they need to work on.
During the year, progress is checked.
Employees and managers both give feedback.
HR reviews everything to keep it fair.
Finally, feedback is shared in a one-on-one meeting.

Based on performance

Good performance leads to a salary increase or promotion.
Average performance gets a normal increment.
Poor performance may need improvement training or further action.

This process helps employees grow and improves overall company performance.

Rating Scale

Employees are rated on a scale of 1 to 5, where 5 is excellent and 1 is poor performance.

5: Exceptional (Top 5%)
4: Exceeds Expectations (25%)
3: Meets Expectations (60%)
2: Needs Improvement (9%)
1: Unsatisfactory (1%)

360-Degree Feedback

The final rating comes from 360-degree feedback:

Manager: 50%
Peers: 20%
Direct reports: 15%
Self-review: 15%

Link to Compensation

This final rating decides salary increment and promotion:

Rating 5 → 15–20% hike + eligible for promotion
Rating 4 → 10–15% hike
Rating 3 → 5–8% hike
Rating 2 → 0–3% hike + improvement plan
Rating 1 → No hike + possible exit discussion

Domain Model Summary

Here's a quick reference of the entities we discovered:

Domain	Key Entities
Recruitment	Job, Candidate, Application, Interview, Offer
Onboarding	Employee, Document, Task, Asset
Attendance	AttendanceRecord, Shift, Timesheet, Overtime
Leave	LeaveRequest, LeaveBalance, LeaveType
Payroll	Payslip, SalaryComponent, Deduction, Tax
Performance	Review, Goal, Feedback, Rating

Designing HR Management System: A Learning Journey

Ijas Ahammed — Sat, 17 Jan 2026 14:58:16 +0000

Hey, welcome to the course. I hope this course provides a great learning experience!

Git Cheatsheet

Ijas Ahammed — Sun, 28 Sep 2025 02:48:24 +0000

A quick reference for the most common and useful Git commands.

🛠 Setup & Initialization

Command	Description
`git init`	Initialize a new Git repository in the current directory.
`git clone [repo-url]`	Clone an existing repository.
`git remote -v`	List remote repositories connected to your project.
`git remote add origin [url]`	Link a local repo to a remote repo.
`git branch -M [new-name]`	Rename the current branch (commonly `main`).

📂 Working with Files

Command	Description
`git add [file/dir]`	Stage a file or directory for commit.
`git add .`	Stage all changes in the current directory.
`git rm [file]`	Remove a file and stage the removal.
`git mv [old] [new]`	Rename or move a file.

💾 Saving Changes

Command	Description
`git commit -m "msg"`	Commit staged changes with a message.
`git commit -am "msg"`	Stage and commit tracked files in one step.
`git reset --soft [hash]`	Undo commits but keep changes staged.
`git reset [hash]`	Undo commits and unstage changes (keep in working dir).
`git reset --hard [hash]`	Reset everything to a specific commit (⚠ destructive).
`git revert [hash]`	Create a new commit that undoes a specific commit.
`git revert --continue`	Continue revert if conflicts occur.
`git revert --abort`	Cancel an in-progress revert.

🌿 Branching & Merging

Command	Description
`git branch`	List all branches, `*` shows current branch.
`git branch [name]`	Create a new branch.
`git branch [new] [existing]`	Create new branch from another.
`git checkout [branch]`	Switch to an existing branch.
`git checkout -b [name]`	Create and switch to a new branch.
`git merge [branch]`	Merge a branch into the current branch.
`git push --set-upstream origin [branch]`	Push new branch and set remote tracking.

🔄 Sync with Remote

Command	Description
`git pull`	Fetch and merge from remote.
`git fetch`	Download changes but don’t merge yet.
`git push`	Push commits to remote.
`git push -u origin main`	Push and set default upstream (first push).

📊 Check Status & History

Command	Description
`git status`	Show staged/unstaged/untracked files.
`git log`	Show commit history.
`git log --oneline --graph --decorate --all`	Pretty, compact commit history.
`git diff [file]`	Show unstaged changes for a file.
`git diff --staged`	Show staged changes (ready to commit).

🗄 Stash & Temporary Work

Command	Description
`git stash`	Save uncommitted changes temporarily.
`git stash list`	Show list of stashed changes.
`git stash apply [id]`	Apply stashed changes (keeps in stash).
`git stash pop`	Apply and remove from stash.

⚔️ Resolving Merge Conflicts

git checkout main
git pull origin main
git checkout your-branch
git merge main
# Resolve conflicts manually in files
git add .
git commit -m "fix merge conflict"
git push

Database Replication

Ijas Ahammed — Sat, 27 Sep 2025 05:24:23 +0000

Database replication can be used in DBMS with a master/slave relationship, where a original master DB syncs and controls the slave DB.

Master DB usually is WRITE intensive, and all the write operations like Create, Update, Delete, Mutate, must be sent only to Master DB.
All the slave DBs are READ intensive.
Most applications have a high read to write ratio, and thus the number of slave databases can be increased to support it.

Advantages

Better Performance

All the write operations will happen on master, and read operations will happen on slaves. It improves performance because more query operations can be done parallely.

Reliability

If any of the DB is destroyed in a natural disaster, the data will be safe, as there are replicas.

High Availability

By deploying the DB replicas in different locations, we ensure that the user always gets the data, even when the DB closer to him is offline.

What if one of the DB goes down?

If the only slave DB goes down, the Master DB will now handle read operation as well. And once the issue is sorted out, a new slave DB will replace the old one.
In case of multiple slave DBs, and one of them fails, all the query requests will be forwarded to healthy slaves.
If the master DB goes down, one of the slave DBs is elected and promoted as the new Master. And immediately a new slave DB is created and replaced.

SSH Key Authentication in Linux

Ijas Ahammed — Tue, 16 Sep 2025 03:44:50 +0000

Introduction
What is SSH Keys?
Working Of SSH Keys
Creation of SSH Keys
Copying Key to Remote Server
Conclusion

Introduction

Normally, when we connect to a server using ssh, we use the password for that user. Do you use simple password which include "123" or your name? Do you think it is safe? Absolutely not!

SecLists, a popular open-source project by Daniel Miessler & others, is a collection of various wordlists and lists used in security testing (penetration testing, red teaming, etc.). The lists include things like common usernames, URLs, known password strings, etc. The goal is to provide testers with ready-made lists that can be used for bruteforce attacks, scanning for vulnerabilities, password cracking, etc.

So the best way to create a secure authenticated connection is using SSH key pairs. You don't have to remember your passwords know, just use the ssh keys instead.

What is SSH Keys?

SSH keys contain two keys, Private key and a Public key. The pirvate key should be super secret and you must know where you are storing it in your machine. The public is key, is public! No matter if you share it with anyone.

Let's say you have two machine, home and a remote machine, which you want to login using ssh keys. First of all, check if any ssh keys exists in the machine using the command: ls -l ~/.ssh. This will list all the existing ssh files. You may choose to backup if any exist.

ijas@debian:~$ ls -l ~/.ssh
ls: cannot access '/home/ijas/.ssh': No such file or directory

ijas@ubuntu:~$ ls -l ~/.ssh
ls: cannot access '/home/ijas/.ssh': No such file or directory

In my debian and ubuntu machines, no ssh keys are present.

Working Of SSH Keys

SSH keys comes with pair (Private and Public). The public key is generated using the private key, in a way, they are linked together (but you can't get the private key from public key). The public key will be sent to the remote machine or server and it stores the key.

Whenever a user try to log in to that remote server from the host machine, the remote server creates a random string of characters (like 8&vw^afdsE...) and encrypt it using the public key. Now, this encrypted text can only be decrypted using the private key. The host now must prove that he can decrypt the encrypted string using the private key. Once decrypted, host sends back the result to the remote server and if they match, then the host is authenticated and can login to the remote server.

Creation of SSH Keys

To create ssh key pair in your machine, use the command ssh-keygen. ssh-keygen generates, manages and converts authentication keys for ssh.

ijas@debian:~$ ssh-keygen -b 4096
Generating public/private rsa key pair.
Enter file in which to save the key (/home/ijas/.ssh/id_rsa): 
Created directory '/home/ijas/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/ijas/.ssh/id_rsa
Your public key has been saved in /home/ijas/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:IVrtM2J36uO57J5vwhI7c4+Bd4pRwAZHngYmDxqnuwc ijas@debian
The key's randomart image is:
+---[RSA 4096]----+
|. + +.o          |
| = = * o         |
|o   . X o        |
| .   = + .       |
|E   . o S .      |
| o   ..= =       |
|. .   o++ .      |
| .    =*=B.      |
|      .O%Bo      |
+----[SHA256]-----+

Use -b flag to specify the bit size. I have used 4096, which is actually much stronger than default.
You can choose a location to store the keys, best to go with default.
Passphrase is for an additional layer of security. You can add a strong passphrase if you want, but remember, if you lost it, there is no way to retrieve it.

Now you can see pair of ssh keys. The .pub is public key.

ijas@debian:~$ ls -l ~/.ssh
total 8
-rw------- 1 ijas ijas 3381 Sep 16 07:49 id_rsa
-rw-r--r-- 1 ijas ijas  737 Sep 16 07:49 id_rsa.pub

You can view the content of public key using cat ~/.ssh/id_rsa.pub.

Copying Key to Remote server

To copy the public to the remote server, use this command: ssh-copy-id username@ip-address

ijas@debian:~$ ssh-copy-id ijas@192.168.139.147
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/ijas/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
ijas@192.168.139.147's password: 

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'ijas@192.168.139.147'"
and check to make sure that only the key(s) you wanted were added.

Once copied, you can see the copied public key (authorized_keys) in the remote server:

ijas@ubuntu:~$ ls -l ~/.ssh
total 4
-rw------- 1 ijas ijas 737 Sep 16 09:07 authorized_keys

Now when you try to ssh into the remote server, it won't ask for password. (Ensure you are SSHing at the directory where the private key is stored)

ijas@debian:~$ ssh ijas@192.168.139.147
Welcome to Ubuntu 25.04 (GNU/Linux 6.15.11-orbstack-00539-g9885ebd8e3f4 aarch64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/pro
Last login: Tue Sep 16 09:06:43 2025 from 192.168.139.177

Conclusion

SSH keys give you better security, faster logins, and peace of mind, making them the best practice for managing Linux systems.

Congrats!🎉 You are now one step ahead in your linux journey. Thanks for reading!

Fetching Data in React

Ijas Ahammed — Sun, 23 Feb 2025 11:11:15 +0000

Fetching data from an API is a fundamental part of web development. In this guide, we’ll explore how to fetch data efficiently using React, handle loading states, manage errors, and prevent race conditions.

📌 Initial Setup

To begin, create a new React application in your code editor. For demonstration purposes, we’ll use the JSONPlaceholder API to fetch posts.

const BASE_URL = "https://jsonplaceholder.typicode.com";

When we hit the /posts endpoint, the API returns data in the following format:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
  "body": "quia et suscipit..."
}

🏗 Creating State and Interface

Since we’re using TypeScript (which is highly recommended 😜), let’s define an interface for our posts:

interface Post {
  id: number;
  title: string;
}

Next, create a state to store the fetched posts:

const [posts, setPosts] = useState<Post[]>([]);

🔄 Fetching Data with `useEffect`

To fetch data, we’ll use the useEffect hook, ensuring the request runs once when the component mounts.

useEffect(() => {
  const fetchData = async () => {
    const response = await fetch(`${BASE_URL}/posts`);
    const posts = (await response.json()) as Post[];
    setPosts(posts);
  };
  fetchData();
}, []);

📝 Key Points:

The fetch API retrieves data from the endpoint.
The response is converted to JSON.
The useEffect dependency array is empty, ensuring the function runs only on mount.
The fetched posts are stored in state.

🎨 Rendering Posts

Using the map function, we’ll display the posts in a list:

return (
  <div className="App">
    <h1>Data Fetching in React</h1>
    <ul>
      {posts.map((post) => (
        <li key={post.id}>{post.id}. {post.title}</li>
      ))}
    </ul>
  </div>
);

🔑 Always provide a unique key when rendering lists in React to avoid rendering issues.

⏳ Adding a Loading State

Fetching data takes time, so we should display a loading indicator while waiting for the response.

const [isLoading, setIsLoading] = useState(false);

useEffect(() => {
  const fetchData = async () => {
    setIsLoading(true);
    const response = await fetch(`${BASE_URL}/posts`);
    const posts = (await response.json()) as Post[];
    setPosts(posts);
    setIsLoading(false);
  };
  fetchData();
}, []);

Now, update the UI to show a loading message:

return (
  <div className="App">
    <h1>Data Fetching in React</h1>
    {isLoading ? <div>Loading...</div> : (
      <ul>
        {posts.map((post) => (
          <li key={post.id}>{post.id}. {post.title}</li>
        ))}
      </ul>
    )}
  </div>
);

⚠ Handling Errors

Errors can occur due to network issues or API failures. Let’s handle errors using a state variable and a try-catch block.

const [error, setError] = useState<string | null>(null);

useEffect(() => {
  const fetchData = async () => {
    setIsLoading(true);
    try {
      const response = await fetch(`${BASE_URL}/posts`);
      if (!response.ok) throw new Error("Failed to fetch data");
      const posts = (await response.json()) as Post[];
      setPosts(posts);
    } catch (error: any) {
      setError(error.message);
    } finally {
      setIsLoading(false);
    }
  };
  fetchData();
}, []);

Modify the UI to display errors:

if (error) {
  return <div>Error: {error}</div>;
}

🏎 Handling Race Conditions

Race conditions occur when multiple API calls return in an unexpected order. To prevent this, we use AbortController to cancel previous requests.

const [page, setPage] = useState(1);
const abortControllerRef = useRef<AbortController | null>(null);

useEffect(() => {
  const fetchData = async () => {
    abortControllerRef.current?.abort(); // Cancel previous request
    abortControllerRef.current = new AbortController();
    setIsLoading(true);
    try {
      const response = await fetch(`${BASE_URL}/posts?page=${page}`, {
        signal: abortControllerRef.current.signal,
      });
      const posts = (await response.json()) as Post[];
      setPosts(posts);
    } catch (error: any) {
      if (error.name !== "AbortError") {
        setError(error.message);
      }
    } finally {
      setIsLoading(false);
    }
  };
  fetchData();
}, [page]);

📌 Adding Pagination

We’ll add a button to update the page number, triggering a new API request:

<button onClick={() => setPage((prev) => prev + 1)}>
  Next Page ({page})
</button>

🎉 Conclusion

And that’s it! 🚀 You’ve learned how to fetch data efficiently in React, manage loading states, handle errors, and prevent race conditions.

You can explore the full working example on CodeSandbox. Happy coding! 😃

DEV Community: Ijas Ahammed

How to Use Terraform to Create an AWS S3 Bucket: A Beginner’s Guide

What is Terraform?

What is Infrastructure as Code (IaC)?

What is a Terraform Provider?

Setup Guide

1. Create IAM User with S3 Full Access

2. Configure AWS CLI

4. Create Terraform Alias (Optional)

5. Setup VS Code

Understanding the Terraform Configuration

Terraform Workflow

Step 1: Initialise Terraform

Step 2: Plan the Changes

Optional: Save the Plan

Step 3: Apply the Changes

Step 4: Verify in AWS Console

Step 5: Modify and Reapply

Step 6: Destroy Resources

Key Concepts Summary

Common Commands Cheat Sheet

Understanding HR Domain

What We'll Cover

Why Domain Understanding Matters

1️⃣ Recruitment & Hiring

The Workflow

Key Components

Business Rules

Real-World Challenge

2️⃣ Employee Onboarding

The Workflow

Data to Collect

Edge Cases

3️⃣ Attendance & Time Tracking

Attendance Methods

Business Rules

The Tricky Part: Timezone Handling

4️⃣ Leave Management

Annual Leave Quota

The Leave Request Workflow

Leave Balance Calculation

Business Rules

5️⃣ Payroll Processing

Salary Structure

Payroll Process (Monthly)

Deductions

Tax Calculation

Payroll Cycle

Important Edge Cases

6️⃣ Performance Management

Rating Scale

360-Degree Feedback

Link to Compensation

Domain Model Summary

Designing HR Management System: A Learning Journey

Git Cheatsheet

🛠 Setup & Initialization

📂 Working with Files

💾 Saving Changes

🌿 Branching & Merging

🔄 Sync with Remote

📊 Check Status & History

🗄 Stash & Temporary Work

⚔️ Resolving Merge Conflicts

Database Replication

Advantages

Better Performance

Reliability

High Availability

What if one of the DB goes down?

SSH Key Authentication in Linux

Table of Contents

Introduction

What is SSH Keys?

Working Of SSH Keys

Creation of SSH Keys

Copying Key to Remote server

Conclusion

Fetching Data in React

📌 Initial Setup

🔄 Fetching Data with `useEffect`