A two-tier application architecture is one of the most common patterns used to build modern web applications. It separates the application into two main layers:

1. Application Layer – Runs the frontend and backend logic, usually on a web server or application server.

2. Database Layer – Stores and manages data using a database server.

This separation makes the application easier to manage, scale, and secure compared to a single-tier setup. In this blog, we’ll walk through how to deploy a two-tier application on AWS.

Objectives

Our goal is to design and deploy a two-tier application on AWS consisting of:

• An application layer running on Amazon EC2.

• A database layer running on Amazon RDS.

We will use AWS networking services to securely connect the two layers.

Prerequisites

Before starting, make sure you have:

• An active AWS account.

• Basic knowledge of Linux commands.

• Understanding of how EC2 and RDS work.

High-Level Architecture

Task 1 — Create a VPC and networking

1. Open AWS Management Console and choose the nearest region (e.g., ap-south-1 (Mumbai)).

2. Create a VPC

   • Services → VPC → Create VPC

   • Name: VPC-EpicReads

   • IPv4 CIDR: 10.0.0.0/16

   • Tenancy: Default

   • Add tags (Name = VPC-EpicReads) → Create

3. Create subnets (across 2 Availability Zones for separation)

   • Create Public Subnet 1: 10.0.1.0/24 (AZ: us‑east‑1a / ap‑south‑1a)

   • Create Public Subnet 2: 10.0.1.0/24 (AZ: us‑east‑1b / ap‑south‑1b)

   • Create Private Subnet 1: 10.0.2.0/24 (AZ: us‑east‑1a / ap‑south‑1a)

   • Create Private Subnet 2: 10.0.3.0/24 (AZ: us‑east‑1b / ap‑south‑1b)

   • Tag the subnets with clear names (e.g., PublicSubnet1-EpicReads, PrivateSubnet1-EpicReads).

4. Create and attach an Internet Gateway (IGW)

   • VPC → Internet Gateways → Create IGW → Name it IGW-EpicReads → Create

   • Actions → Attach to VPC → select VPC-EpicReads

5. Create a Public Route Table and route 0.0.0.0/0 → IGW

   • VPC → Route Tables → Create Route Table (RouteTable-Public-EpicReads) and pick VPC-EpicReads

   • Edit routes: add 0.0.0.0/0 → target = igw-xxxx (your IGW)

   • Subnet Associations → Associate PublicSubnet1 and PublicSubnet2

6. (Optional) Create a NAT Gateway if you need outbound internet from private subnets (e.g., for patching or package downloads). Place NAT in a public subnet and create a private route table that points 0.0.0.0/0 to the NAT.

7. Network ACLs (optional but recommended for subnet‑level controls)

   • VPC → Network ACLs → Create NACL and attach to the VPC

   • Edit inbound/outbound rules as needed (allow HTTP/HTTPS/SSH where applicable).

8. Security Groups (instance‑level firewall)

   • EC2 → Security Groups → Create SG-EpicReads (for application)

     • Inbound: SSH (TCP 22) from your IP, HTTP (TCP 80) from 0.0.0.0/0

     • Outbound: allow all (or limit to RDS SG on TCP 3306)

   • Create EpicReads-DBSG (for RDS)

     • Inbound: MySQL/Aurora (TCP 3306) source: SG-Web-EpicReads (Reference the web SG to allow only app instances to reach DB)

     • Outbound: default (allow all) or restrict to app SG.

Task 2 — Launch EC2 instance (Application server)

1. Launch Instance

   • EC2 → Instances → Launch Instances

   • Name: EpicReads-WebServer

   • Choose AMI: Amazon Linux 2

   • Instance type: t2.micro (free tier) or choose as required

   • Key pair: select or create a key pair (download .pem)

   • Network: select VPC-EpicReads

   • Subnet: PublicSubnet1-EpicReads

   • Auto-assign Public IP: Enable

   • Security group: SG-EpicReads

   • Storage: default is fine for demo

   • Launch instance

2. SSH into the EC2 instance (from your workstation)

   • Ensure .pem has correct permissions: chmod 400 key-pair.pem

   • Example SSH command (Amazon Linux/AMI):

       ssh -i key-pair.pem ec2-user@<public-ip>
     

3. Update and install web server and PHP (Amazon Linux 2 )

sudo yum update -y

It is used to install the Apache web server on a Linux system.

sudo yum install -y httpd

Start and enable the Apache webserver.

sudo systemctl start httpd
sudo systemctl enable httpd

Install PHP and extensions required by WordPress.

sudo yum install -y php php-mysqlnd php-xml php-fpm

sudo systemctl restart httpd

4. Verify Apache is working

   Open browser and navigate to: http://<public-ip> → you should see Apache default page.

Task 3 — Deploy WordPress

These commands assume you are on the EC2 instance and in /var/www/html.

1. Download WordPress:

   Change the directory to /var/www/html/

    cd /var/www/html/
   

   Download latest WordPress package & Extract it

    sudo wget https://wordpress.org/latest.tar.gz
    sudo tar -xzvf latest.tar.gz
   

   Copy the configuration file to wp-config.php file

    sudo cp wp-config-sample.php wp-config.php
   

   Set Permission for Wordpress file.

    sudo chown -R apache:apache /var/www/html/wordpress
    sudo chmod -R 755 /var/www/html/wordpress
   

   

   Task 4 — Create the Database (RDS MySQL)

   1. Create a DB Subnet Group

      • RDS → Subnet groups → Create DB subnet group

      • Name: epicreads-subnetgroup

      • VPC: VPC-EpicReads

      • Add the private subnets (PrivateSubnet1, PrivateSubnet2)

   2. Create RDS instance (MySQL)

      • RDS → Databases → Create database

      • Standard create → Engine: MySQL

      • Template: Free tier (or as required)

      • DB instance identifier: wordpress

      • Master username: choose a username (store it securely)

      • Password: choose a strong password (store it securely)

      • Connectivity: choose VPC-EpicReads and DB subnet group epicReads-subnetgroup

      • Public accessibility: No (keep DB in private subnet)

      • VPC security group: attach EpicReads-DBSG

      • Additional configuration: initial DB name wordpress (optional)

      • Create DB

   3. Edit DB security group inbound rules

      • EC2 Security → Security Groups → select EpicReads-DBSG

      • Inbound rule: MySQL/Aurora (TCP 3306) Source: SG-EpicReads (so only app SG can reach DB)

4. Capture the RDS endpoint from the RDS Console. You will use this in the WordPress config.

   

Task 5 — Connect WordPress to RDS

1. On your EC2 instance, set an environment variable (for testing):

    export MYSQL_HOST=<your-rds-endpoint>
   

2. Connect to the WordPress Database

    mysql --user=<your-username> --password=<your-password> wordpress
   

3. Access the wp-config.php

    sudo vi wp-config.php
   

4. Edit the DB_NAME, DB_USER, DB_PASSWORD, DB_HOST.

   

5. Go to this WordPress Secret Key Generator https://api.wordpress.org/secret-key/1.1/salt/ and Replace the current script.

   

6. Allow 'W3TC' plugin write the configuration data into DB

    define( 'W3TC_CONFIG_DATABASE', true );
   

7. Install the PHP XML extension on your Linux system.

    sudo yum install php-xml -y
   

8. Copy all the files from wordpress folder to html folder & Change Owner.

    cd ..
    sudo cp -r wordpress/* /var/www/html
    sudo chown -R apache:apache /var/www/html
   

   

9. Finally, start hosting the Apache web server

    sudo systemctl start httpd.service
    sudo systemctl enable httpd.service
    sudo systemctl restart php-fpm
   

   

Task 6 — Finalize WordPress setup in browser

1. In your browser, open: http://<ec2-public-ip>/wp-admin/.

2. Choose language → Click continue.

3. Enter site title, admin username, password, and email → Install WordPress.

4. Login with the admin credentials and verify you can create posts and that they are stored in the RDS database.

   

5. Creating a test post.

   

6. Access our site via public Ip address.

    http://<public-ip>
   

   

Conclusion

Deploying a two-tier application architecture on AWS provides a structured way to separate the application layer and the database layer. By setting up VPC, subnets, internet gateway, route tables, security groups, EC2 instances for the app, and RDS (or database server) for data storage, we can create a secure and scalable environment. This separation of concerns ensures better performance, easier management, and a strong foundation for running applications like WordPress on the cloud.

What is Amazon S3?

Amazon S3 (Simple Storage Service) is a cloud-based storage service provided by AWS that allows you to store and retrieve any amount of data at any time. It is highly durable, secure, and scalable, making it ideal for storing files such as images, videos, documents, or entire websites. S3 provides features like access control, versioning, and cost-efficient storage, allowing you to manage your data reliably without worrying about underlying infrastructure or server maintenance.

Hosting a static website on S3 is popular because it’s simple, serverless, and cost-effective. A static website consists of fixed content like HTML, CSS, and JavaScript files, which don’t require a backend server or database. By uploading these files to an S3 bucket and enabling static website hosting, S3 can serve your site directly to visitors. This approach provides high availability, automatic scalability, and a public URL for easy access, making it a perfect solution for portfolios, blogs, landing pages, and other simple web applications.

Objective

The goal is to host a static website by:

• Creating an S3 bucket

• Uploading website files

• Enabling static website hosting

• Setting permissions so anyone can access your site

A static website is one with fixed content like HTML, CSS, and images. There’s no backend or database involved, so it’s fast, secure, and cost-effective.

What You Need

• An AWS account with administrative access

• Basic HTML/CSS/JS files for your website

• AWS CLI (optional, if you want to use commands instead of the AWS console)

Step 1: Log in and Create an S3 Bucket

1. Go to the AWS Management Console and log in using your IAM credentials.

   

2. Choose a region closest to you. This helps your website load faster.

3. In the search bar at the top, type S3 and click the Create bucket button.

   

4. Give your bucket a unique name. (Bucket names are global, so no two buckets anywhere in the world can have the same name.)

   

5. Leave all other settings as default.

6. Click Create bucket.

   

Now your empty S3 bucket is ready to store your website files.

Step 2: Upload Your Website Files

Your bucket is currently empty, so we need to add our website files. One way to upload our project to the bucket is by using the AWS Management Console, and another way is by using the AWS CLI. In this tutorial, we will use the AWS CLI to upload our files.

Steps:

1. Open your terminal or command prompt.

2. Navigate to your project folder:

    cd \Downloads\2117_infinite_loop
   

   List your files to make sure you are in the right folder:

    ls
   

   

3. Upload files to S3 using:

    aws s3 sync . s3://pravinmishrademo01/
   

   

   After uploading, you should see all your files in the S3 bucket.

   

Step 3: Enable Static Website Hosting

1. Click on your bucket → Go to Properties tab.

2. Scroll down to Static website hosting and click Edit.

   

3. Choose Enable.

   

This allows S3 to serve your website files as a real website.

Step 4: Set Index and Error Documents

1. Index document: This is your homepage (usually index.html). When someone visits your website URL, this page will load automatically.

2. Error document: This is shown when someone visits a page that doesn’t exist (like 404.html). It helps guide visitors back to your site.

3. Enter index.html for the index document and leave the error document as default (or add 404.html if you have one).

4. Click Save changes.

   

S3 will now give you a website URL that you can use to visit your site.

When you try to visit the site using the bucket website endpoint, it gives an error because we have not set the bucket policy for website access and have not disabled Block Public Access.

Step 5: Make Your Website Public

By default, S3 blocks public access. Your site won’t be visible until you allow it.

1. Go to the Permissions tab in your bucket.

2. Click Block Public Access → Edit → Disable it → Save changes.

   

3. Add a Bucket Policy to allow everyone to read your files:

   • Go to Permissions → Bucket Policy → Edit.

   • Add this policy (replace your-bucket-name with your actual bucket name):

       {
         "Version": "2012-10-17",
         "Statement": [
           {
             "Sid": "PublicReadGetObject",
             "Effect": "Allow",
             "Principal": "*",
             "Action": "s3:GetObject",
             "Resource": [
                       "arn:aws:s3:::pravinmishrademo01/*"
              ]
           }
         ]
       }
     

4. Save the policy.

   

Now your website is live and publicly accessible using the URL from static website hosting.

Step 6: Test Your Website

• Copy the URL from the Static Website Hosting section in S3.

• Open it in a browser.

• Your static website should load perfectly.

Conclusion

Hosting a static website on AWS S3 is easy and beginner-friendly. You don’t need a server or database. By following these steps, you can make your website live and accessible to anyone. This is perfect for portfolios, blogs, landing pages, or documentation websites.

At that time, it felt straightforward. But as projects grew bigger and more dynamic, I noticed a few challenges:

• Any small change in requirements was difficult to manage.

• Feedback often came late, usually after the product was nearly finished.

• Collaboration between developers, testers, and operations was minimal.

• Delivery cycles were slow, making it harder to respond to fast-changing user needs.

This is where I began exploring modern approaches to SDLC—focusing on Agile methodologies, Scrum frameworks, Jira as a project management tool, and DevOps practices.

From Traditional SDLC to Agile and DevOps

Unlike the traditional model, Agile emphasizes adaptability, customer collaboration, and incremental delivery. Instead of waiting months for a final product, Agile teams deliver working software in short iterations, often called sprints.

This approach made me realize that:

• Software should be delivered in small, valuable increments.

• Continuous feedback ensures we build the right thing.

• Teams should work collaboratively across development, testing, and operations.

And when Agile meets automation and cloud practices, that’s where DevOps comes into the picture.

What is Agile and Why is it Important?

Agile is a mindset and methodology that focuses on delivering value to the customer quickly and effectively. Instead of rigid documentation and long delivery timelines, Agile promotes:

• Iterative development (small releases)

• Continuous feedback from stakeholders

• Flexibility to adapt to changes

• Cross-functional collaboration

Agile is important because modern software projects demand speed + quality. Customers expect rapid updates, bug fixes, and new features—Agile enables teams to meet those expectations without burning out.

What is Scrum?

Within Agile, Scrum is one of the most popular frameworks. It organizes work into sprints (usually 1–2 weeks long), with clearly defined roles and ceremonies.

• Roles: Product Owner, Scrum Master, and Development Team

• Ceremonies: Sprint Planning, Daily Standups, Sprint Review, Sprint Retrospective

• Artifacts: Product Backlog, Sprint Backlog, and Increment

Scrum helps keep teams focused, ensures transparency of progress, and fosters a cycle of continuous improvement.

What is Jira and How Do We Use It?

When I started applying Agile in my projects, I used Jira, a popular project management tool by Atlassian.

Jira allows teams to:

• Create Epics, Stories, and Tasks to structure work.

• Plan and run sprints with defined goals.

• Use Kanban or Scrum boards to visualize progress.

• Track metrics like burndown charts for transparency.

In my own practice projects, I created Epics like “Improve UI discoverability & trust” and then broke them down into stories such as “Hero tagline clarity” or “Primary CTA color.” Using Jira made the entire sprint cycle feel organized and measurable.

How I Used Jira in My Projects

For managing my Agile sprints, I used Jira, which is a powerful tool for planning, tracking, and delivering software efficiently. Here’s a simple way beginners can get started:

Step 1: Create a Project

• Choose Software → Scrum → Team-managed.

• Give it a name (e.g., Gotto Job – Solo Pujan).

Step 2: Add Epics & Stories

• Create Epics for big goals (e.g., Improve UI discoverability).

• Add Stories under Epics with clear titles, descriptions, and acceptance criteria.

• Estimate each story with story points (1, 2, 3…).

Step 3: Plan a Sprint

• Drag 3–4 stories into a sprint.

• Set a Sprint Goal (e.g., Ship 2–3 visible UI improvements).

Step 4: Subtasks & Progress Tracking

• Break stories into subtasks: Build → Verify → Deploy → Screenshot.

• Move tasks across the board as you work: To Do → In Progress → Done.

Step 5: Review & Retro

• Demo the increment.

• Write Retro notes: What went well, what to improve, Scrum pillar observed, Scrum value practiced.

• Check burndown chart for sprint progress.

Using Jira helped me organize my work, visualize progress, and deliver small increments efficiently in my recent projects like Gotto Job and Mini Finance footer deployment on EC2.

The DevOps Life Cycle

While Agile focuses on how we manage work, DevOps focuses on how we build and deliver software efficiently.

The DevOps Life Cycle is usually represented as an infinity loop, covering continuous phases:

1. Plan – Define requirements and track progress (Agile + Jira).

2. Code – Write clean, maintainable code (Git, GitHub, VS Code).

3. Build – Compile and package the software (CI pipelines).

4. Test – Automate testing for quality assurance.

5. Release – Deploy software to staging/production.

6. Deploy – Push updates using tools like Docker, Kubernetes, or AWS EC2.

7. Operate – Monitor system performance and uptime.

8. Monitor – Collect feedback and performance metrics to start the cycle again.

This cycle emphasizes automation, collaboration, and continuous delivery, ensuring faster and more reliable deployments.

What I Did in My Present Projects

In my recent practice projects, I combined Agile, Jira, and DevOps concepts to simulate real-world workflows:

• Used Jira Scrum boards to create Epics and Stories.

• Planned and executed mini-sprints with goals like “Deploy footer with version and date on EC2.”

• Broke down tasks into subtasks (Build, Verify, Deploy, Screenshot).

• Deployed my project on AWS EC2 with Nginx as the web server.

• Practiced retrospectives by reflecting on what went well, what could improve, and Scrum values observed.

This hands-on approach gave me clarity on how modern teams actually build, ship, and improve software continuously.

Final Thoughts

Looking back, moving from traditional SDLC to Agile + DevOps practices has been a huge leap in our learning journey. Agile brought adaptability, Scrum gave structure, Jira made work visible, and DevOps ensured smooth delivery.

Even in small practice projects, applying these frameworks has helped us think like a real-world engineer, preparing us for bigger roles in Cloud, DevOps, and Agile teams.

What is Git?

Git is a distributed version control system that helps developers track changes in their code. It allows multiple people to work on a project simultaneously without overwriting each other’s work. Git stores snapshots of your project at different points in time, making it easy to roll back changes or review history.

What is GitHub?

GitHub is a cloud-based platform that hosts Git repositories. It enables collaboration by allowing developers to share their code, submit pull requests, review changes, and contribute to open-source projects. While Git manages the code locally, GitHub provides a remote backup and collaboration tools.

Difference Between Git and GitHub

Repositories

A repository (repo) is a place where your project files and their history are stored. Git supports different types of repositories:

• Local Repository: Exists on your local machine.

• Remote Repository: Hosted on platforms like GitHub, GitLab, or Bitbucket.

Hands-On Learning: Installing Git & Configuration

1. Installing Git:
   Download Git from git-scm.com and follow the installation steps.

2. Configuring Git:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

This sets your identity for commit history.

Initializing a Repository

To start tracking a project with Git:

git init

This creates a .git folder in your project directory, enabling version control.

Key Git Commands that i Used

1. git status – Checks the current state of files in the working directory.

   

2. git add . – Stages all changes to be committed.

   

3. git commit -m "message" – Saves staged changes with a descriptive message.

   

4. git log – Displays commit history in the repository.

   

5. git push – Sends local commits to a remote repository.

   

6. git checkout - is used to switch between branches or restore files in your working directory to a specific state.

   

7. git merge – Integrates changes from one branch into another.

   

Authentication in GitHub

To interact with GitHub securely, authentication is required:

• HTTPS: Uses your GitHub username and personal access token for authentication.

• SSH: Uses SSH keys to authenticate without entering credentials repeatedly:

ssh-keygen -t rsa -b 4096 -C “pujanbhattarai361@gmail.com”
ls -la ../.ssh/
cat ~/.ssh/id_rsa.pub

SSH is recommended for convenience and security.

Now, Add the SSH key in github, go to Github Settings → SSH and GPG Keys → New SSH keys.

ssh -T git@github.com

.gitignore

The .gitignore file tells Git which files or directories to ignore. For example, sensitive data, log files, or IDE settings should not be tracked:

node_modules/
*.log
.env

Git with VS Code

Visual Studio Code integrates Git natively:

• View changes in the Source Control panel.

• Stage, commit, pull, and push directly from the editor.

• Provides visual diff tools to compare changes.

Using Git with VS Code makes version control more intuitive, especially for beginners.

Importance of Git & GitHub in DevOps

Git and GitHub are fundamental in DevOps for several reasons:

• Collaboration: Teams can work on multiple branches simultaneously.

• Continuous Integration/Deployment (CI/CD): GitHub repositories integrate with pipelines to automate testing and deployment.

• Traceability: Every change is tracked with commits, making debugging easier.

• Backup: Remote repositories serve as a cloud backup for code.

Mastering Git and GitHub is a crucial step toward a career in DevOps or cloud-native development.

Conclusion

Learning Git and GitHub hands-on has been a game-changer for me. From initializing repositories, committing changes, pushing and pulling updates, to creating branches and collaborating via pull requests, I now understand how version control and cloud collaboration work together to streamline software development.

Git and GitHub are more than just tools—they are essential skills for every modern developer and DevOps engineer.

What is Linux?

Linux is an open-source, Unix-like operating system used across desktops, servers, embedded devices, and cloud platforms. Unlike proprietary systems, Linux can be freely modified, distributed, and customized, giving engineers complete control over their environment. Its flexibility, stability, and security make it the preferred OS for production servers, cloud infrastructure, and DevOps automation.

Linux isn’t just an operating system—it’s an ecosystem. From running lightweight web servers to powering containers in Kubernetes clusters, Linux forms the foundation of modern IT operations. Its open-source nature also means there is a vast community, plenty of documentation, and extensive support for developers and engineers worldwide.

Why Linux is Important

Linux is central to DevOps and cloud engineering for several reasons:

1. Stability and Reliability: Linux servers can run for years without rebooting. For critical applications, this reliability is crucial.

2. Security: Its permission and user management systems, combined with open-source transparency, ensure strong security.

3. Flexibility and Customization: You can build minimal systems for containers or fully-featured servers for enterprise workloads.

4. Server and Cloud Dominance: Most of the world’s cloud platforms and over 96% of the top 1 million web servers run Linux.

In short, Linux is not only the operating system of choice but also a skill every DevOps engineer must master to efficiently manage, monitor, and deploy applications at scale.

Essential Linux Commands

File Management

File management is one of the most fundamental skills in Linux. As a DevOps engineer, you will constantly navigate the filesystem, organize scripts, and manage logs.

Some key commands:

ls - Lists files and directories. Options like ls -l show permissions, owners, and sizes, while ls -a shows hidden files.

cd - Changes directories. Navigating efficiently saves time when managing servers.

mkdir - Creates directories. Use mkdir -p to create nested directories in one command.

cat - Displays the entire content of a file

rm - Deletes files and directories. rm -r recursively removes directories; caution is needed to prevent accidental deletion.

Practical Use in DevOps: Organizing scripts for automation, backing up configuration files before deployment, and managing logs for troubleshooting.

Text Editors

Editing configuration files, writing scripts, and debugging are daily tasks for DevOps engineers. Linux provides multiple editors:

Nano – Beginner-friendly terminal-based editor. Easy to learn, ideal for quick edits.

Vim – Advanced editor with powerful features like macros, multi-file editing, and syntax highlighting. Essential for server administration.

Practical Use: Text editors are critical for configuring applications, managing deployment scripts, and debugging automation pipelines.

File Permissions

Linux file permissions control who can read, write, or execute files, maintaining system security and integrity.

ls -l – Shows permissions, ownership, and file size.

chmod – Changes file permissions. Example: chmod 755 script.sh makes it executable for everyone.

chown – Changes file ownership. Example: sudo chown user:group file.txt.

Practical Use in DevOps: Ensuring scripts and configuration files have the correct permissions prevents unauthorized access, accidental modification, and security vulnerabilities on production servers.

Process Monitoring & Control

Processes are programs running on your system. Monitoring and controlling them ensures server stability and efficient resource usage.

ps -e - Lists all running processes on the system along with their process IDs (PIDs). It’s useful for monitoring active processes, checking what’s currently running, and troubleshooting system performance issues.

ps aux | grep nginx – Lists all running nginx with details like PID, CPU, and memory usage.

pstree – Displays running processes in a tree-like structure, showing parent–child relationships between them. It’s useful for understanding how processes are organized, spotting which processes were started by others, and troubleshooting process dependencies.

kill - <PID> – Gracefully stops a process.

kill -9 <PID> – Forcefully terminates an unresponsive process.

Practical Use: Identifying resource-hogging processes, restarting services, and debugging issues during deployment or automation.

Networking Commands

ifconfig - ifconfig (interface configurator) is a command-line tool used in Linux and Unix systems to display and configure network interfaces. It shows details like IP addresses, MAC addresses, and network status, though it has been largely replaced by the ip command in modern systems

ping - This command tests network connectivity between your system and another host (like a server or website) by sending small packets of data and measuring the response time. It’s useful for troubleshooting network issues, checking if a server is reachable, and measuring latency.

dig- The dig (Domain Information Groper) command is used to query DNS servers for information about domain names, such as IP addresses, mail servers, and name servers.

wget - The wget command is used to download files from the internet directly to your Linux system via HTTP, HTTPS, or FTP. In DevOps, it’s useful for fetching scripts, packages, backups, or configuration files from remote servers for automation, deployment, or testing purposes.

Practical Use: Testing network connectivity between servers, monitoring open ports for security, and automating API checks during deployments.

System Information

uname -a - It displays detailed information about your system, including the kernel name, network node hostname, kernel version, machine hardware name, processor type, and operating system. It’s useful for quickly checking system details for troubleshooting, system monitoring, or compatibility purposes.

uptime - It shows how long the system has been running, the current time, the number of logged-in users, and the system load averages for the past 1, 5, and 15 minutes.

who - It displays a list of users currently logged into the system, along with their login terminals, login times, and sometimes their originating IP addresses.

free -h - This command shows the system’s memory usage, including total, used, free, and cached memory, in a human-readable format.

df -h - It shows the disk space usage of all mounted filesystems in a human-readable format (e.g., MB or GB). It’s useful for monitoring storage capacity, identifying full partitions, and managing disk resources effectively.

Practical Use: DevOps engineers rely on these commands to detect bottlenecks, optimize performance, and maintain healthy servers.

Conclusion:

Linux is the foundation of DevOps, cloud computing, and modern IT operations. From file management to process monitoring, networking, and disk management, mastering Linux commands equips engineers to automate tasks, troubleshoot issues, and manage infrastructure efficiently. Practicing these commands regularly will not only improve your confidence but also prepare you to handle real-world DevOps scenarios.

Here’s a detailed breakdown of what I did and what I learned.

Step 1: Launching an EC2 Instance on AWS

The first step was to create a virtual machine on AWS (called an EC2 instance).

1. Logged into our AWS account and go to EC2 → Launch Instance.

2. Selected Ubuntu AMI (Amazon Machine Image) – since Ubuntu is stable and widely used for deployments.

3. Chose a Free Tier eligible instance type (t2.micro). This keeps costs at $0 while still giving us enough power to run small apps.

4. Created a new key pair (.pem file) which is necessary for securely logging in to the instance.

5. Configured the security group to:

   • Allow SSH (port 22) → So we can connect from my local machine.

   • Allow HTTP (port 80) → So users can access our web app in a browser.

6. Finally, We clicked Launch Instance.

At this point, AWS gave us a public IP address for our instance.

To connect, We opened the terminal, navigated to the folder containing .pem key, and ran:

ssh -i "key-pair.pem" ubuntu@<public-ip>

This gave us terminal access to our remote Ubuntu server.

Step 2: Installing Node.js and npm

React apps require Node.js and npm (Node Package Manager).

1. First, we updated the server’s package lists:

sudo apt update

2. Then installed Node.js and npm:

sudo apt install -y nodejs npm

3. Verified installation:

node -v && npm -v

This confirmed that both Node.js and npm were available to build my React project.

Step 3: Installing and Starting Nginx

Nginx is a powerful web server that can serve static files (like React build files) efficiently.

We installed and started it with:

sudo apt install -y nginx

sudo systemctl start nginx

sudo systemctl enable nginx

• start → Starts Nginx immediately.

• enable → Makes sure Nginx starts automatically when the server restarts.

To confirm, I opened my instance’s public IP in a browser, and I saw the default Nginx welcome page.

Step 4: Cloning My React App from GitHub

Next, We needed an application to deploy.

1. I forked a React app on GitHub and cloned it onto my server:

git clone https://github.com/23Pujan/my-react-app.git

cd my-react-app

2. To personalize it, I opened the App.js file in the src folder:

cd src

vi App.js

Inside, I updated the code to display:

<h2>Deployed by: <strong>Pujan Bhattarai</strong></h2>

<p>Date: <strong>21/08/2025</strong></p>

This step made my deployment unique to me.

Step 5: Building the React App for Production

A React app runs on a development server by default, but in production we need optimized static files.

So I ran:

npm install

npm run build

• npm install → Downloads all dependencies listed in package.json.

• npm run build → Creates a production-ready version of the app in the build/ folder.

The build/ folder contains HTML, CSS, and JavaScript files that Nginx can serve directly.

Step 6: Deploying React App with Nginx

Now we needed to replace Nginx’s default files with my React build.

1. Remove the default Nginx files:
   sudo rm -rf /var/www/html/*

2. Copy React build files into Nginx’s web directory:
   sudo cp -r build/* /var/www/html/

3. Set correct ownership and permissions so Nginx can serve them:
   sudo chown -R www-data:www-data /var/www/html

   sudo chmod -R 755 /var/www/html

Step 7: Configuring Nginx for React

React is a Single Page Application (SPA), meaning all routes should point to index.html. Without configuring this, refreshing the page could result in a 404 error.

So I updated Nginx’s default configuration:

echo 'server {

listen 80;

server_name _;

root /var/www/html;

index index.html;

location / {

try_files $uri /index.html;

}

error_page 404 /index.html;

}' | sudo tee /etc/nginx/sites-available/default > /dev/null

Then restarted Nginx to apply changes:

sudo systemctl restart nginx

Now, Nginx was ready to serve my React app properly.

Step 8: Testing My Deployment

Finally, I got my server’s public IP by running:

curl ifconfig.me

When I opened http://<public-ip> in my browser → my React app appeared, with my custom message:

“Deployed by: Pujan Bhattarai – Date: 21/08/2025”

Key Takeaways

This project gave me hands-on DevOps skills:

• How to set up and connect to an EC2 instance.

• Installing Node.js, npm, and Nginx on a Linux server.

• Building and serving a React app in a production-ready environment.

• Configuring Nginx to support single page applications.

Most importantly, I experienced the full process of taking an app from local development → cloud deployment → production hosting.

Credits

This hands-on exercise was guided by the practices shared in Pravin Mishra’s FREE DevOps for Beginners Cohort. For anyone beginning their DevOps journey, it’s an excellent resource to explore and experiment with practical, end-to-end deployments.

The ability to transform raw data into useful insights is critical in today's data-driven world. The secret to unlocking the potential in your data is data visualization. Amazon QuickSight is a cloud-based business intelligence (BI) service provided by Amazon Web Services (AWS) that specializes in data visualization. It enables organizations to create interactive dashboards, analyze data, and generate insights through visualizations. QuickSight is designed to be scalable, user-friendly, and cost-effective, making it suitable for businesses of all sizes.

In this blog, we’ll explore the powerful integration of Amazon QuickSight and Amazon S3, showcasing how this dynamic pair can transform your data into impactful insights and compelling visualizations.

Prerequisites

1. Have an AWS account. If you don’t have one, sign up here free and enjoy the benefit of 12 month free tier account.

2. Download the datasets from Kaggle. In this demo, I use Netflix dataset from Kaggle and other manifest is used to define the data source and data import configuration in Quick sight.

High-Level Architecture

Store the Dataset in S3 Bucket

1. Open AWS management Console and search S3.

2. Click on the Create Bucket.

3. Give the bucket name unique , leave all the default setting as it is and click on the create bucket.

4. Click on the bucket that looks like this:

   

5. Upload the dataset that we downloaded Earlier.

   

6. Now, we have created a bucket which contains our netflix.csv and manifest.json file and copy the netflix_titles.csv URI.

   

7. Open manifest.json file and change the file location URI with your S3 URI which is copied earlier and re-upload the manifest.json file in your s3 bucket.

Create Amazon Quicksight Account

1. Search for Amazon QuickSight in AWS management Console.

2. Select Sign up for QuickSight.

3. Enter the email address, scroll down, and select the Amazon S3 bucket. Then, click on the bucket that was created previously. Lastly, Don’t forgot to untick the Add Pixel-Perfect Reports.

4. Finally, Our Amazon QuickSight account has been created. Let’s play around it.

Connect S3 bucket to Amazon QuickSight

1. From the left hand navigation bar, select Datasets, then New dataset.

2. Select S3.

3. For the first field (data source name), enter netflix-data.

4. Ooo there's also a second field called manifest.json URL - does manifest.json found familiar?

5. Open a new tab to open your AWS Management Console again. Head back to your S3 bucket.

6. Select the checkbox next to manifest.json, then select Copy S3 URI.

7. Enter the S3 URI to our manifest.json file.

8. Select Visualize and Interactive sheet to start creating visualizations.

Create Our First QuickSight Visualisation

Now we get to the creative part! With QuickSight, you can sort, filter, and customize your data to create visualizations. You can also experiment with different types of graphs like bar charts, pie charts, line graphs, etc.

We can see on the left hand panel that the dataset's fields are already imported.

1. There you can see a different types of charts to create a visualization. Drag release_year into the Y-Axis heading. Woo! Now you can see a breakdown on the year that these Netflix-featured TV shows and movies were released.

2. Let's save this in a dashboard. Click on the frame surrounding our lovely donut chart, and click on the white boxes at the edges to resize it.

3. Now let's create a new visual, select + ADD under the Visuals heading on our middle navigation bar, and we'll see another blank frame pop out.

4. Drag the release_year label into the Y Axis heading.

5. Next, drag the type label into the Group/Color heading.

6. Chart that shows the breakdown of TV shows/movies for each release year. Change the graph type to Horizontal stacked 100% bar chart.

Now, Let’s demonstrate the same thing on table format.

Finally, we can see our dashboard looks like this.

Double-click on the titles of all the charts you see in front of you, and the 'Edit Title' panel will pop up. You can give each chart a name which is clear and easy to understand.

Final step, On the top right hand corner, select Publish. This will make your dashboard public so you can share it with your team.

Conclusion

In this project, we explored the powerful capabilities of Amazon QuickSight to transform raw data into actionable insights through intuitive visualizations that enable better decision-making. Through this hands-on exploration of QuickSight, we demonstrated its potential to enhance data-driven decision-making within businesses by providing intuitive, real-time visual analytics. The flexibility, scalability, and cost-effectiveness of QuickSight make it a powerful tool for organizations looking to harness the value of their data.

Resources

Amazon S3: Amazon S3 - Cloud Object Storage - AWS

Amazon QuickSight: Business Intelligence Tools - Amazon QuickSight - AWS