• Private EC2 instances have no public IP

• They can still access the internet via NAT Gateway

• SSH access is only possible through a Bastion Host

• I automated configuration using Ansible

• I exposed the application securely using an Application Load Balancer

This setup follows real-world DevOps and cloud security best practices.

🏗 Final Architecture Overview

Architecture Components

• Custom VPC

• Public Subnet (Bastion Host, NAT Gateway, ALB)

• Private Subnet (2 Ubuntu EC2 Instances)

• Internet Gateway

• NAT Gateway

• Public & Private Route Tables

• Ansible Automation

• Application Load Balancer

  

✅ STEP 1: Create a Custom VPC

Instead of using the default VPC, I created a new one for full control.

Configuration:

• Name: Custom-Bastion-VPC

• IPv4 CIDR Block: 10.0.0.0/16

• Enable DNS Hostnames: Yes

• Enable DNS Resolution: Yes

✅ STEP 2: Create Public and Private Subnets

Inside the VPC, I created two subnets.

🔓 Public Subnet

• Name: Public-Subnet

• CIDR: 10.0.1.0/24

• Used for:

  • Bastion Host

  • NAT Gateway

  • Application Load Balancer

🔒 Private Subnet

• Name: Private-Subnet

• CIDR: 10.0.2.0/24

• Used for:

  • 2 Private EC2 Instances

✅ STEP 3: Create and Attach Internet Gateway

To allow internet access:

1. Create Internet Gateway

2. Attach it to Custom-Bastion-VPC

This enables internet connectivity for public subnet resources.

✅ STEP 4: Create a NAT Gateway (For Private Internet Access)

Since private instances should not have public IPs, I created a NAT Gateway.

Steps:

1. Allocate an Elastic IP

   

2. Create NAT Gateway

3. Place it inside the Public Subnet

4. Attach the Elastic IP

Why?

This allows:

• Private instances → Outbound internet access

• Internet → Cannot directly access private instances

✅ STEP 5: Configure Route Tables

🌍 Public Route Table

• Route: 0.0.0.0/0 → Internet Gateway

  

• Associate with Public Subnet

  

🔐 Private Route Table

• Route: 0.0.0.0/0 → NAT Gateway

  

• Associate with Private Subnet

  

Now:

• Public subnet → Internet via IGW

• Private subnet → Internet via NAT

  

✅ STEP 6: Launch the Bastion Host

Now I launched an Ubuntu EC2 instance in the Public Subnet.

Configuration:

• AMI: Ubuntu Server

• Subnet: Public Subnet

• Auto-assign Public IP: Enabled

• Security Group:

  • Allow SSH (Port 22)

  • Source: My Public IP only

This ensures only I can SSH into the Bastion.

✅ STEP 7: Launch Two Private EC2 Instances

Next, I launched 2 Ubuntu EC2 instances inside the Private Subnet.

Configuration:

• Subnet: Private Subnet

• Auto-assign Public IP: Disabled

• Security Group:

  • Allow SSH (Port 22)

  • Source: Bastion Host Security Group

  • Allow HTTP (Port 80) from ALB Security Group

This ensures:

• Only Bastion can SSH into them

• Only Load Balancer can access port 80

✅ STEP 8: SSH into Bastion and Access Private Servers

First, SSH into Bastion:

ssh -i key.pem ubuntu@<Bastion-Public-IP>

Then SSH into private server from Bastion:

ssh -i key.pem ubuntu@10.0.2.10

This confirms secure internal-only access.

Second private instance

✅ STEP 9: Install Ansible on Bastion Host

Inside Bastion:

sudo apt update
sudo apt install ansible -y

Verify:

ansible --version

✅ STEP 10: Configure Ansible to Install Nginx

Create Inventory File

nano inventory.ini

[webservers]
web1 ansible_host=10.0.2.199
web2 ansible_host=10.0.2.153

[all:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/home/ubuntu/Server-key.pem
ansible_python_interpreter=/usr/bin/python3

Create Playbook

nano install-nginx.yml

- name: Install and configure web servers
  hosts: webservers
  become: yes

  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes

    - name: Install Nginx
      apt:
        name: nginx
        state: present

    - name: Start and enable Nginx
      service:
        name: nginx
        state: started
        enabled: yes

Run Playbook

ansible-playbook -i inventory.ini install-nginx.yml

✅ STEP 11: Modify Nginx Default Page

On each private server:

sudo nano /var/www/html/index.nginx-debian.html

Change content:

Server 1:

<!DOCTYPE html>
<html>
<head>
    <title>My Cloud Web Page</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background: #f4f6f8;
            text-align: center;
            padding: 50px;
        }
        .card {
            background: white;
            padding: 30px;
            border-radius: 10px;
            width: 60%;
            margin: auto;
            box-shadow: 0 0 15px rgba(0,0,0,0.1);
        }
        h1 { color: #2c3e50; }
        p { font-size: 18px; }
    </style>
</head>
<body>

<div class="card">
    <h1>Hello 👋 I'm NAME</h1>

    <p><strong>Instance Hostname:</strong> HOSTNAME</p>

    <p><strong>Private IP:</strong> HOST_IP</p>

    <h2>About Me</h2>
    <p>
        I am a Cloud Computing student and aspiring DevOps Engineer.
        I enjoy building secure AWS infrastructure, automating deployments,
        and learning modern cloud technologies.
    </p>
</div>

</body>
</html>

Server 2:

This is Private Server 2

✅ STEP 12: Create Target Group

Now I configured a Target Group:

• Target type: Instances

• Protocol: HTTP

• Port: 80

• Registered both private instances

  

✅ STEP 13: Create Application Load Balancer

Configuration:

• Type: Application Load Balancer

• Scheme: Internet-facing

• Subnets: Public Subnet

• Security Group:

  • Allow HTTP (Port 80)

Attach:

• Previously created Target Group

✅ STEP 14: Access the Application

Copy the ALB DNS name:

http://<ALB-DNS-Name>

Result:

• Traffic distributed between both servers

• No public IP exposed on private instances

• Fully secure architecture

  

🔐 Why I Used a Bastion Host

The Bastion Host acts as a secure jump server into the private network.

Instead of exposing my private EC2 instances directly to the internet, I:

• Placed them in a private subnet

• Disabled public IP assignment

• Allowed SSH access only from the Bastion Host

The Bastion Host:

• Allows SSH only from my personal IP

• Acts as the single controlled entry point

• Reduces attack surface

This follows the principle of least privilege and improves overall security posture.

🤖 How Ansible Simplified Deployment

To avoid manually configuring each server, I used Ansible for automation.

Using:

• An inventory file

• A playbook

• A single execution command

I was able to install and configure Nginx on both private servers simultaneously.

Benefits:

• Consistency across servers

• Reduced human error

• Faster deployment

• Easy scalability

This demonstrates infrastructure automation, a core DevOps principle.

🌍 Direct EC2 Access vs Load Balancer Access

There are two ways users can access applications:

🔴 Direct EC2 Access

Users connect directly to a server’s public IP.

Disadvantages:

• Single point of failure

• No traffic distribution

• Reduced scalability

• Increased security risk

🟢 Load Balancer Access

Users connect through a single DNS endpoint provided by the Application Load Balancer.

Advantages:

• High availability

• Automatic traffic distribution

• Fault tolerance

• Backend servers remain private

Using a Load Balancer makes the architecture production-ready and scalable.

🔐 Security Achieved

✔ Private instances have no public IP
✔ SSH only through Bastion
✔ Bastion restricted to my IP
✔ Internet access via NAT only
✔ Load Balancer securely exposes app
✔ Infrastructure automated using Ansible

🏁 Conclusion

In this project, I successfully built a secure, scalable, and production-style AWS infrastructure using:

• VPC segmentation

• Bastion Host access control

• NAT Gateway for private internet access

• Ansible automation

• Application Load Balancer for high availability

This architecture mirrors what is used in real-world enterprise cloud environments and demonstrates strong understanding of networking, security, and DevOps automation.

In this project, I deployed two Amazon EC2 instances running Amazon Linux, installed Apache on one instance and Nginx on the other, and placed both behind an AWS Application Load Balancer.

To make the setup more production-ready, I also configured:

• Monitoring and alerting using Amazon CloudWatch

• Automated backups using EC2 snapshots

This project demonstrates core AWS skills such as compute provisioning, traffic distribution, monitoring, and disaster recovery.

Architecture Overview

Architecture Components

• 2 EC2 Instances (Amazon Linux)

• Apache Web Server (Instance 1)

• Nginx Web Server (Instance 2)

• 1 Application Load Balancer

• 1 Target Group

• Amazon CloudWatch for monitoring

• Automated EC2 snapshots for backups

Step 1: Launch Two EC2 Instances

I logged into the AWS Management Console and navigated to Amazon EC2.

Configuration Steps

1. Click Launch Instance

   

2. Select Amazon Linux

3. Choose instance type (e.g., t2.micro)

   

4. Create or select a key pair

5. Configure a Security Group:

   • SSH (22) — My IP

   • HTTP (80) — Anywhere

6. Launch two separate EC2 instances

   

Step 2: SSH into Both Instances

Using the public IPs, I connected to each instance via SSH.

ssh -i mykey.pem ec2-user@<EC2_PUBLIC_IP>

I confirmed successful access on both instances.

Step 3: Install Apache on the First Instance

On the first EC2 instance, I installed Apache HTTP Server.

sudo yum update -y
sudo yum install httpd -y
sudo systemctl start httpd
sudo systemctl enable httpd
sudo systemctl status httpd

I customized the web page:

sudo nano /var/www/html/index.html

<h1>Apache Server - EC2 Instance 1</h1>

Step 4: Install Nginx on the Second Instance

On the second EC2 instance, I installed Nginx.

sudo yum update -y
sudo yum install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

I edited the default Nginx page:

sudo nano /usr/share/nginx/html/index.html

<h1>Nginx Server - EC2 Instance 2</h1>

Step 5: Create a Target Group

I created a Target Group to route traffic to the instances.

Target Group Configuration

• Target type: Instance

• Protocol: HTTP

• Port: 80

• Health check path: /

Both EC2 instances were registered and marked healthy.

Step 6: Create an Application Load Balancer

Next, I created an Application Load Balancer.

Load Balancer Settings

• Scheme: Internet-facing

• Listener: HTTP (80)

• Availability Zones: Same as EC2 instances

• Forward traffic to the created Target Group

Step 7: Access the Load Balancer DNS

Once the load balancer became active, I accessed its DNS name in a browser.

http://<load-balancer-dns-name>

Refreshing the page alternated between:

• Apache server response

• Nginx server response

Step 8: Enable Monitoring with Amazon CloudWatch

To monitor performance and availability, I used Amazon CloudWatch.

What I Monitored

• EC2 CPU Utilization

• Network In / Network Out

• Load Balancer request count

• Target group health status

Alarm Configuration

• Created a CloudWatch alarm to trigger when CPU utilization exceeds a threshold

• Notifications configured using SNS

Step 9: Configure Automated Backups Using EC2 Snapshots

To ensure disaster recovery, I enabled automated backups by creating EC2 snapshots.

Backup Strategy

• Created AMIs or EBS snapshots for both instances

• Configured lifecycle rules to:

  • Run backups automatically

  • Retain snapshots for a defined period

This ensures the instances can be restored quickly in case of failure or data loss.

Key Takeaways

• Load balancers distribute traffic efficiently across multiple instances

• CloudWatch provides visibility into system performance and health

• Automated backups are essential for fault tolerance and recovery

• This setup reflects real-world AWS production practices

Conclusion

This project showcases how to deploy multiple EC2 instances with different web servers, expose them through an Application Load Balancer, and enhance the setup with monitoring and automated backups. It demonstrates foundational AWS skills required for Cloud and DevOps roles, including scalability, observability, and resilience.

Modern cloud infrastructure must be designed with scalability, fault tolerance, and observability in mind. In this project, I built a highly available setup by deploying multiple virtual servers (Droplets), configuring a Load Balancer to manage incoming traffic, and ensuring monitoring and automated backups were properly enabled.

This blog documents the end-to-end process I followed, demonstrating real-world cloud and DevOps best practices using DigitalOcean.

Project Objectives

The main goals of this deployment were to:

• Provision multiple Linux-based Droplets

• Deploy the same application across all servers

• Configure a Load Balancer to distribute traffic evenly

• Enable monitoring and health checks

• Configure automatic backups for data protection and disaster recovery

• Test failover and traffic distribution

This architecture closely resembles what is used in production environments to guarantee uptime and performance.

Architecture Overview

The infrastructure consists of:

• Multiple Ubuntu Droplets running the same application

• A DigitalOcean Load Balancer placed in front of the Droplets

• Monitoring and alerting enabled at the Droplet level

• Automated backups configured for recovery

All incoming requests pass through the Load Balancer, which forwards traffic only to healthy Droplets.

Step 1: Creating Multiple Droplets

The first step was to provision the Droplets that would host the application.

Process:

1. Logged into the DigitalOcean dashboard

   

2. Navigated to Create → Droplets

   

3. Selected Ubuntu Linux as the operating system

   

4. Chose an appropriate Droplet size based on expected workload

   

5. Selected a region closest to users to reduce latency

   

6. Enabled SSH key authentication for secure access

   

7. Created multiple Droplets with identical configurations

   

Using identical Droplets ensures consistency and simplifies scaling and maintenance.

Step 2: Accessing and Preparing the Droplets

Once the Droplets were created, I connected to each one using SSH.

Tasks Performed:

• Updated system packages to the latest versions

• Installed required dependencies and a web server

• Configured firewall rules where necessary

• Ensured all Droplets had the same environment setup

apt update && apt install -y apache2 && echo "Hello world,Welcome to server 1" > /var/www/html/index.html

This step is critical because load-balanced systems require uniform server behavior.

Step 3: Deploying the Application Across All Droplets

After preparing the servers, I deployed the same application to each Droplet.

Key Actions:

• Copied application files to each Droplet

• Configured the web server to serve the application

• Ensured the application was reachable via each Droplet’s public IP

• Verified application responses were consistent across servers

At this stage, each Droplet could independently serve user requests.

Step 4: Creating and Configuring the Load Balancer

To manage incoming traffic efficiently, I created a DigitalOcean Load Balancer.

Load Balancer Configuration:

• Selected the same region as the Droplets

  

• Attached all application Droplets to the Load Balancer

• Configured forwarding rules:

  • HTTP (Port 80)

  • HTTPS (Port 443, if SSL is enabled)

• Enabled health checks to continuously monitor Droplet availability

The Load Balancer automatically routes traffic to healthy Droplets and removes unhealthy ones from rotation.

Step 5: Enabling Monitoring and Health Metrics

Monitoring is essential for understanding system performance and detecting problems early.

Monitoring Features Enabled:

• CPU usage tracking

• Memory utilization

• Disk and network I/O

• Load Balancer health checks

• Droplet uptime monitoring

These metrics allow proactive troubleshooting and performance optimization.

Step 6: Configuring Automated Backups

To ensure data protection and fast recovery, I enabled automatic backups for each Droplet.

Benefits of Automated Backups:

• Daily snapshots without manual intervention

• Ability to restore a Droplet to a previous working state

• Protection against accidental deletion, corruption, or system failure

This adds an important layer of resilience to the infrastructure.

Step 7: Testing Load Balancing and Failover

To validate the setup, I tested how traffic was distributed and how the system handled failures.

Testing Steps:

• Accessed the Load Balancer’s IP address or DNS name

  

• Reloaded the application multiple times

  

  

  

• Confirmed traffic was served by different Droplets

• Stopped one Droplet to simulate failure

• Observed the Load Balancer automatically rerouting traffic

The application remained available even when a Droplet went offline.

Key Outcomes and Benefits

This deployment achieved:

• High Availability – No single point of failure

• Scalability – Easy addition or removal of Droplets

• Reliability – Health checks and failover handling

• Observability – Real-time monitoring and metrics

• Data Safety – Automated backups and recovery options

Conclusion

This project demonstrates how to build a scalable, fault-tolerant cloud infrastructure using DigitalOcean. By combining multiple Droplets, a Load Balancer, monitoring, and automated backups, I implemented an architecture that aligns with real-world DevOps and cloud engineering standards.

This setup is suitable for production workloads and serves as a strong addition to my cloud and DevOps portfolio.

Amazon Elastic Compute Cloud (EC2) is a core AWS service that allows users to run virtual servers in the cloud. These servers can be used to host websites, applications, and other services.

In this blog, I will give a detailed step-by-step explanation of how I:

• Launched an EC2 instance on AWS

• Configured security groups to allow SSH and HTTP traffic

• Connected to the instance from my local machine using SSH

• Installed and configured the Apache web server

• Edited the default Apache web page to display my name

• Accessed the web page using the EC2 public IP address

• Safely terminated the EC2 instance after completion

Step 1: Logging into AWS and Navigating to EC2

I started by logging into the AWS Management Console using my AWS account. From the AWS services menu, I searched for EC2 and clicked on it to open the EC2 Dashboard.

Step 2: Launching a New EC2 Instance

From the EC2 Dashboard, I clicked Launch Instance.

Instance Configuration

• Name: I assigned a name to the instance for easy identification.

• Amazon Machine Image (AMI): I selected an Ubuntu Server / Amazon Linux AMI.

• Instance Type: I chose t3.micro, which is eligible for the AWS Free Tier.

Step 3: Creating or Selecting a Key Pair

To securely connect to the EC2 instance, AWS requires a key pair.

• I created a new key pair (or selected an existing one).

• I downloaded the private key file (.pem) and stored it safely on my local machine.

This key is required for SSH access to the instance.

Step 4: Configuring the Security Group

A security group acts as a virtual firewall for the EC2 instance.

I configured the inbound rules to allow:

• SSH (Port 22) – for remote access from my local machine

• HTTP (Port 80) – to allow web traffic to the Apache server

These rules ensure that I can connect to the instance and that the web page can be accessed from a browser.

Step 5: Launching the Instance

After reviewing all configurations, I clicked Launch Instance. Within a few minutes, the instance entered the running state.

I then copied the public IP address, which would be used to connect to the server and access the website.

Step 6: Connecting to the EC2 Instance Using SSH

On my local machine, I opened the terminal and navigated to the directory containing the private key file.

I used SSH to connect to the instance using the public IP address. Once connected, I gained command-line access to the remote server.

Step 7: Updating the Server and Installing Apache

After connecting to the instance, I updated the system packages to ensure everything was up to date.

Next, I installed Apache2, which is a widely used open-source web server.

Once installation was complete, I started the Apache service and verified that it was running correctly.

Step 8: Editing the Default Apache Web Page

Apache stores its default web page in the /var/www/html directory.

• I navigated to this directory

• I opened the index.html file

• I replaced the default content with a simple message displaying my name

This customization helped confirm that the server was correctly serving my own content.

Step 9: Accessing the Web Page via Browser

After configuring Apache, I opened my web browser and entered the public IP address of the EC2 instance.

The page loaded successfully and displayed my name, confirming that:

• Apache was running

  

• HTTP traffic was allowed in the security group

• The EC2 instance was accessible from the internet

Step 10: Terminating the EC2 Instance

After completing the project, I returned to the EC2 Dashboard and selected the instance.

To avoid unnecessary charges, I clicked Terminate Instance. This permanently deleted the EC2 instance and released its resources.

Conclusion

This step-by-step project demonstrated how to deploy a basic web server using AWS EC2 and Apache. It provided hands-on experience with cloud infrastructure, Linux server management, security groups, and web hosting.

This foundational knowledge is essential for more advanced cloud and DevOps projects such as deploying applications, configuring load balancers, and automating infrastructure.

Introduction

Amazon Simple Storage Service (Amazon S3) is one of the most popular services provided by Amazon Web Services (AWS). It allows users to store and retrieve files (objects) securely and at any time from anywhere on the internet.

In this blog, I will walk through the steps I followed to:

• Create an S3 bucket on AWS

• Upload an image into the bucket

• Configure the bucket to allow public access to the image

This project helped me understand how cloud storage works and how permissions are managed in AWS.

What is Amazon S3?

Amazon S3 (Simple Storage Service) is an object storage service that offers scalability, security, and high availability. It is commonly used for:

• Storing images and videos

• Hosting static websites

• Backups and data archiving

Each file stored in S3 is called an object, and objects are stored inside containers called buckets.

Step 1: Logging into the AWS Management Console

To begin, I logged into my AWS account using the AWS Management Console.

Steps:

1. Opened my browser and visited https://aws.amazon.com

   

2. Signed in using my AWS credentials

3. From the AWS Management Console, searched for S3 and selected it

Step 2: Creating an S3 Bucket

After opening the S3 dashboard, I created a new bucket.

Steps:

1. Clicked on Create bucket

   

2. Entered a unique bucket name

3. Selected a preferred AWS region

4. Left other settings as default

5. Clicked Create bucket

Step 3: Uploading an Image to the Bucket

Once the bucket was successfully created, I uploaded an image file into it.

Steps:

1. Opened the newly created bucket

2. Clicked Upload

3. Selected an image file from my local system

4. Clicked Upload to complete the process

After uploading, the image appeared inside the bucket as an object.

Step 4: Disabling Block Public Access

By default, S3 buckets block public access for security reasons. To make my image publicly accessible, I adjusted the bucket’s public access settings.

Steps:

1. Opened the bucket

   1. Navigated to the Permissions tab

      

      

2. Clicked Edit under Block public access

   

3. Unchecked Block all public access

   

4. Saved the changes and confirmed

   

Step 5: Making the Image Public Using Bucket Policy

To allow public access to the image, I applied a bucket policy.

Steps:

1. Went to the Permissions tab

2. Selected Bucket policy

3. Added a policy that allows public read access to objects

4. Saved the policy

   

This policy allows anyone on the internet to view the image.

Step 6: Accessing the Image Publicly

After configuring the permissions, I copied the Object URL of the image and opened it in a browser.

The image loaded successfully, confirming that it was publicly accessible.

Conclusion

Through this project, I learned how to:

• Create and manage an S3 bucket

• Upload objects to cloud storage

• Configure permissions to allow public access

This exercise gave me practical experience with AWS S3 and helped me understand how cloud storage and access control work in real-world scenarios. Amazon S3 is a powerful service, and mastering it is an important step in becoming a cloud engineer.

A Beginner-Friendly Linux Automation Project (AltSchool Cloud Engineering)

Introduction

As a beginner in Linux system administration, Cloud computing, or DevOps, learning how to automate routine tasks is a very important skill. Instead of manually checking system status every time, Linux allows us to write Bash scripts and schedule them to run automatically using cron jobs.

In this blog, I’ll walk you through a simple but practical project where we:

• Check disk usage on the /home directory

• Identify the top 5 processes consuming memory

• Save the results to a log file

• Automate the script to run every 5 minutes using cron

This project was completed as part of my AltSchool Cloud Engineering Program (Second Semester – Month Two Assignment).

Prerequisites

Before starting, you should have:

• A Linux-based system (Ubuntu, Debian, CentOS, etc.)

• Basic familiarity with the Linux terminal

• Permission to create and execute scripts

• Access to cron on your system

Project Objective

The goal of this project is to automate system monitoring tasks that system administrators and cloud engineers frequently perform, such as:

• Monitoring disk usage

• Identifying memory-heavy processes

• Logging system information for future review

Automation helps reduce human error and ensures consistent system visibility.

Step 1: Writing the Bash Script

What the Script Does

The Bash script performs the following actions:

1. Checks the disk usage of the /home directory

2. Displays the top 5 processes consuming memory

3. Saves all output into a single log file

4. Prints a meaningful completion message

Bash Script Code

#!/bin/bash

LOGFILE="/var/log/system_monitor.log"

echo "===== System Monitoring Log =====" >> $LOGFILE
echo "Date: $(date)" >> $LOGFILE

echo "" >> $LOGFILE
echo "Disk usage of /home:" >> $LOGFILE
du -sh /home >> $LOGFILE

echo "" >> $LOGFILE
echo "Top 5 memory-consuming processes:" >> $LOGFILE
ps aux --sort=-%mem | head -n 6 >> $LOGFILE

echo "" >> $LOGFILE
echo "Logging done successfully." >> $LOGFILE
echo "=================================" >> $LOGFILE

📸 Bash Script Screenshot

Step 2: Making the Script Executable

After saving the script, make it executable using:

chmod +x system_monitor.sh

This allows the script to be executed like a program.

Step 3: Running the Script Manually

Before automation, it is good practice to test the script manually:

./system_monitor.sh

If successful, the log file will be created and updated with system information.

📸 Manual Script Execution

Step 4: Automating the Script Using Cron

What Is a Cron Job?

A cron job is a Linux scheduler that allows tasks to run automatically at specified time intervals. It is widely used for backups, monitoring, and maintenance tasks.

Editing the Crontab File

Open your crontab file with:

crontab -e

Cron Job Configuration (Every 5 Minutes)

Add the following line:

*/5 * * * * /path/to/system_monitor.sh

This configuration ensures the script runs every 5 minutes, meeting the assignment requirement of running at least three times in 15 minutes.

📸 Cron Job Configuration

Step 5: Verifying Cron Job Output

After waiting at least 15 minutes, check the log file to confirm multiple executions:

cat /var/log/system_monitor.log

You should see multiple timestamps indicating that the cron job executed successfully.

📸 Cron Job Log File Output

Common Issues and Troubleshooting

• Ensure absolute paths are used in cron jobs

• Confirm the script has execute permission

• Check cron service status if the job does not run

Key Learnings from This Project

Through this project, I gained hands-on experience with:

• Bash scripting fundamentals

• Linux process and disk monitoring

• Task automation using cron jobs

• Log file management

These skills are essential for anyone pursuing a career in Cloud Engineering or DevOps.

Conclusion

This beginner-friendly project demonstrates how powerful Linux automation can be when Bash scripting and cron jobs are combined. By automating system monitoring, we save time, improve reliability, and gain deeper insight into system behavior.

This assignment significantly strengthened my confidence in Linux administration and automation as part of my AltSchool Cloud Engineering journey.

✍️ Author

Silias Odion Adodo
Cloud Engineering Student | Linux & DevOps Enthusiast
AltSchool Africa

Introduction

As part of my Altschool Africa one-year Diploma in Cloud Engineering Program, I recently completed a second-semester practical assignment focused on strengthening my foundational skills in Cloud Computing, Linux system administration, and command-line tools.
This assignment was not just theoretical — it required hands-on exploration, testing real commands, managing users, working with permissions, and applying core concepts that every cloud and DevOps engineer must master.

This blog is a comprehensive, upgraded version of that assignment. I expanded the original scope by diving deeper into the Linux environment, documenting 15 essential and lesser-known commands, and breaking everything down into clear, structured sections for easier understanding.
Whether you're a beginner in cloud engineering or someone looking to sharpen your Linux skills, this write-up provides a practical and beginner-friendly walkthrough of the key concepts I studied.

1. My Understanding of the Cloud

Cloud Computing refers to a globally distributed network of remote servers and data centers that deliver computing services over the internet. These include:

• Servers

• Storage

• Databases

• Networking

• Security

• Virtual machines

• Software platforms

Instead of owning physical infrastructure, cloud users rent resources on demand, enabling scalability, cost efficiency, reliability, and global accessibility.

2. My Understanding of Linux as an Operating System

Linux is a free and open-source operating system created by Linus Torvalds in 1991. It manages hardware resources (memory, CPU, storage, networking) and provides a platform where applications run.
Linux is particularly popular among engineers because of its:

• Security

• Flexibility

• Lightweight architecture

• Open-source community support

• Strong presence in cloud, DevOps, and server environments

3. Fifteen Linux Terminal Commands I Researched and Practiced

As part of the assignment, I initially explored 5 uncommon Linux commands — but I have now added 10 more to make a total of 15 powerful commands useful for any beginner cloud or DevOps engineer.

You’ll also find an image beneath each command that displays the output you should expect to see when you run it.

3.1 lsblk — List Block Devices

Used to list all storage devices and partitions.

lsblk

3.2 grep — Search Patterns in Text

grep "keyword" filename

3.3 top — Real-Time Process Viewer

top

3.4 htop — Advanced Process Manager

htop

3.5 ps aux — View All Running Processes

ps aux

Additional 10 Linux Commands (Expanded List)

Below are 10 more commands to broaden your Linux CLI experience.

3.6 df — Check Disk Usage

Shows available and used disk space on mounted filesystems.

df -h

3.7 du — Check Directory Size

Shows size of files and folders.

du -sh *

3.8 free — View RAM Usage

Displays memory usage in real-time.

free -h

3.9 uname — Display System Information

Shows OS name, kernel version, hardware architecture.

uname -a

3.10 whoami — Show Current Logged-In User

whoami

3.11 chmod — Change File Permissions

chmod 755 file.txt

3.12 chown — Change File/Directory Ownership

sudo chown user:user file.txt

3.13 systemctl — Manage System Services

Used to start, stop, enable, or disable services.

sudo systemctl status ssh

3.14 ping — Test Network Connectivity

ping google.com

3.15 history — View Previously Run Commands

history

4. User Management and File Permissions

4.1 Creating Users (Anna, Beatrice, Conrad)

sudo adduser Anna
sudo adduser Beatrice
sudo adduser Conrad

4.2 Creating the File (index.html)

echo "Welcome to my webpage" > index.html

4.3 Assigning Different Permissions Using ACLs

• Anna → Read

• Beatrice → Write

• Conrad → Execute

sudo setfacl -m u:Anna:r index.html
sudo setfacl -m u:Beatrice:w index.html
sudo setfacl -m u:Conrad:x index.html

Conclusion

This expanded assignment gave me deeper insight into:

• Cloud Computing basics

• Linux OS fundamentals

• Essential command-line operations

• User and permission management

• Practical DevOps-related tasks

With 15 Linux commands explored and hands-on practice in managing users and filesystem permissions, this experience strengthened my foundation for advanced cloud computing and DevOps engineering.

🧭 Introduction

In this post, I’ll walk you through how I successfully downloaded the Ubuntu 24.04 image, hosted it using UTM on my MacBook, and then connected to it using SSH from my Mac Terminal.

This guide is perfect for anyone who wants to set up an Ubuntu environment on macOS for learning Linux, testing server configurations, or practicing DevOps commands.

By the end of this article, you’ll be able to:

• Download and install Ubuntu 24.04 using UTM on a Mac.

• Locate your VM’s IP address.

• Configure SSH access and connect seamlessly from your Mac Terminal.

🧩 Step 1: Downloading the Ubuntu 24.04 Image

1. Open your web browser and go to the official Ubuntu Downloads page.

2. Select Ubuntu 24.04 LTS (Noble Numbat).

   • For most modern Macs, choose ARM (Apple Silicon) if you have an M1, M2, or M3 chip.

   • If you’re on an Intel Mac, download the AMD64 (x86_64) version.

3. Once downloaded, you’ll get an .iso or .img file (depending on your choice).

   

⚙️ Step 2: Installing and Setting Up UTM on macOS

UTM is a lightweight virtualization app for macOS that allows you to run virtual machines easily.

1. Visit https://mac.getutm.app/ and download UTM for macOS.

2. Drag the UTM app into your Applications folder and open it.

3. Click Create a New Virtual Machine.

4. Choose Virtualize (since we’re using a standard OS image).

5. Select Linux as the operating system.

6. Under Boot ISO Image, click Browse and select the Ubuntu 24.04 image you downloaded.

7. Allocate:

   • Memory (RAM): At least 2 GB (4 GB recommended)

   • CPU Cores: 2 or more for smoother performance

8. Proceed through the setup, then click Save to finish.

🚀 Step 3: Installing Ubuntu Inside the VM

1. Start the VM by clicking Play ▶️ in UTM.

2. The Ubuntu installer will load — follow the on-screen setup:

   • Choose Try or Install Ubuntu

   • Select your language and keyboard layout

   • Choose Install Ubuntu

   • Create a username (e.g. user01) and password

3. Wait for installation to finish, then reboot the VM when prompted.

🌐 Step 4: Verifying Your Network and Checking the VM IP Address

To connect via SSH later, you’ll need your Ubuntu VM’s IP address.

1. Once logged into your Ubuntu VM, open the Terminal.

2. Run the following command:

    ip a
   

   Look for the network interface (often enp0s1, eth0, or similar) — you’ll see something like:

    inet 192.168.64.12/24
   

   The number before /24 is your VM’s IP address.

🔑 Step 5: Enabling SSH Server on Ubuntu

Ubuntu Desktop doesn’t come with SSH enabled by default, so let’s install it:

1. Run:

    sudo apt update
    sudo apt install openssh-server -y
   

2. Start and enable SSH:

    sudo systemctl enable ssh
    sudo systemctl start ssh
   

3. Check the SSH service status:

    sudo systemctl status ssh
   

   You should see active (running) highlighted in green.

💻 Step 6: SSH into the VM from Your Mac Terminal

Now that your VM is running and SSH is enabled, it’s time to connect from your Mac.

1. Open Terminal on your Mac.

2. Use the following command:

    ssh user01@192.168.64.12
   

   Replace:

   • user01 → your Ubuntu username

   • 192.168.64.12 → your VM’s IP address

3. When prompted, type yes to trust the connection, then enter your Ubuntu password.

✅ You’re now inside your Ubuntu VM terminal remotely!

🧠 Step 7: (Optional) Fix SSH Permission Errors

If you see something like:

Permission denied (publickey,password)

That usually means:

• The SSH service isn’t running (sudo systemctl restart ssh)

• Your username or IP is wrong

• The VM isn’t connected to the network (check ip a again)

Try reconnecting after confirming those fixes.

🧱 Step 8: Make Your SSH Login Easier (Optional Shortcut)

You can save your connection details in a config file so you don’t have to type the full command every time.

On your Mac, run:

nano ~/.ssh/config

Add:

Host ubuntu-vm
    HostName 192.168.64.12
    User user01

Now, connect with:

ssh ubuntu-vm

✅ Step 9: Summary

Here’s everything we accomplished:

• Downloaded Ubuntu 24.04 LTS from the official site

• Installed and configured it inside UTM

• Verified networking and found the VM’s IP

• Installed and started the SSH service

• Connected to the VM securely from macOS Terminal

With this setup, you now have a fully functional Linux environment for coding, DevOps experiments, or cloud practice — right from your MacBook.

🚀 Next Steps

Now that SSH works, you can:

• Configure SSH key authentication for passwordless login

• Set a static IP in Ubuntu using Netplan

• Install Docker or Kubernetes (minikube) inside your VM

• Start building DevOps pipelines locally

✍🏽 Conclusion

Hosting Ubuntu 24.04 on UTM gave me a solid, isolated Linux workspace right on my Mac — no need for dual booting or external servers.
The process taught me how virtualization, SSH, and networking fit together, and it’s an excellent foundation for anyone learning Linux, Cloud Computing, or DevOps.

Step 1: Setting Up an Azure IoT Hub

Prerequisites

Before you begin, ensure you have:

• An active Azure account.

• Azure CLI installed locally (optional but recommended).

Create an IoT Hub

1. Sign in to Azure Portal

   • Log in to the Azure Portal.

     

2. Create an IoT Hub

   • Navigate to Create a resource > Internet of Things > IoT Hub.

     

     

     

     

     

     

   • Fill in the required fields:

     • Subscription: Select your Azure subscription.

     • Resource Group: Create a new one or use an existing one.

     • Region: Select a location close to your devices.

     • Pricing and Scale Tier: Choose a tier suitable for your needs (e.g., F1 for free tier).

   • Click Review + Create and then Create.

3. Access IoT Hub Settings

   • Once the IoT Hub is created, navigate to it in the Azure Portal.

Step 2: Registering a Device

Create a Device Identity

1. In the IoT Hub, go to IoT devices under the Device Management section.

2. Click + New to add a new device.

3. Fill in the required fields:

   • Device ID: Give your device a unique identifier.

   • Authentication type: Use Symmetric key for simplicity.

4. Click Save.

Retrieve Connection String

• After saving, select the device and copy its Primary Connection String. This will be used by the simulated device to authenticate.

Step 3: Simulating a Device

Install Required Tools

1. Ensure you have Python installed.

2. Install the Azure IoT Device SDK for Python:

    pip install azure-iot-device
   

Create a Simulation Script

Create a Python script to simulate telemetry data. Below is a basic example:

import time
from azure.iot.device import IoTHubDeviceClient, Message

CONNECTION_STRING = "<Your_Device_Connection_String>"

# Define the telemetry data
TEMPERATURE = 20
HUMIDITY = 60

# Create IoT Hub client
client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

def send_telemetry():
    try:
        print("Sending telemetry to IoT Hub...")
        while True:
            telemetry = {
                "temperature": TEMPERATURE + (2 * time.time() % 1),
                "humidity": HUMIDITY + (1.5 * time.time() % 1)
            }
            message = Message(str(telemetry))
            client.send_message(message)
            print(f"Telemetry sent: {telemetry}")
            time.sleep(5)  # Send every 5 seconds
    except KeyboardInterrupt:
        print("Simulation stopped.")
    finally:
        client.disconnect()

send_telemetry()

Replace <Your_Device_Connection_String> with the connection string you retrieved earlier.

Run the script:

python simulate_device.py

Step 4: Storing Data in Azure Blob Storage

Set Up Blob Storage

1. In the Azure Portal, create a Storage Account.

2. Inside the storage account, create a Container to hold the data.

Link IoT Hub to Blob Storage

1. Navigate to your IoT Hub and go to Routes under the Message Routing section.

2. Click + Add:

   • Data Source: Select "Device Telemetry".

   • Endpoint Type: Select "Storage" and configure it with your blob storage account.

   • Route Name: Provide a meaningful name.

3. Save the route.

Verify Data Storage

• Ensure your device simulation is running.

• Check the Azure Blob Storage container for incoming telemetry data.

Conclusion

By following these steps, you have successfully set up an IoT solution using Azure IoT Hub. You’ve registered a device, simulated telemetry data, and routed that data to Azure Blob Storage. This framework can be extended to include advanced features like real-time monitoring, alerting, or integration with analytics services like Azure Stream Analytics and Power BI.

This blog will walk you through the process step by step.

Step 1: Log in to the Azure Portal

1. Open your web browser and navigate to Azure Portal.

2. Enter your Azure account credentials to log in.

Step 2: Navigate to Virtual Networks

1. In the search bar at the top of the Azure Portal, type "Virtual Networks" and select the Virtual Networks service from the results.

2. Click on the + Create button to start configuring your virtual network.

Step 3: Configure the Basics

1. In the Basics tab of the Virtual Network creation wizard:

   • Subscription: Select the appropriate subscription.

   • Resource Group: Choose an existing resource group or create a new one (e.g., VN-rg).

   • Name: Provide a name for your virtual network, such as VN-instance.

   • Region: Select the Azure region where the VN-instance will be deployed.

2. Click Next: IP Addresses.

Step 4: Configure the Address Space

1. Under the IP Addresses tab:

   • Add the address space 192.148.30.0/26. This address space provides 64 IP addresses, which we’ll divide into four subnets.

     

     

2. Scroll down to the Subnets section.

Step 5: Create Four Subnets

We’ll divide the address space into four equal subnets, each with 16 IP addresses:

• finance-department: 192.148.30.0/28

• marketing-department: 192.148.30.64/28

• purchasing-department: 192.148.30.128/28

• IT-department: 192.148.30.192/28

Steps to Add Subnets:

1. Click + Add subnet under the Subnets section.

2. For Subnet Name, enter finance-department.

3. For Subnet Address Range, enter 192.148.30.0/28.

4. Click Add.

   

   

   

5. Repeat the process to add marketing-department, purchasing-department, and IT-department, using their respective address ranges.

   

Step 6: Review and Create

1. Click Next: Security, then Next: Tags, and finally, Review + Create.

2. Review the summary of your configuration, ensuring all details are correct.

3. Click Create to deploy your virtual network.

   

Step 7: Verify Your Virtual Network

1. Once the deployment is complete, navigate to the Virtual Networks service in the Azure Portal.

2. Select the virtual network you just created (e.g., VN-instance).

3. Go to the Subnets tab and verify that all four subnets are listed:

   • finance-department: 192.148.30.0/28

   • marketing-department: 192.148.30.64/28

   • purchasing-department: 192.148.30.128/28

   • IT-department: 192.148.30.192/28

     

     

     

Step 8: Next Steps

You’ve now successfully created a virtual network with four subnets using the address space 192.148.30.0/26. To take your setup further:

• Associate Network Security Groups (NSGs): Protect each subnet with security rules.

• Integrate with Services: Attach virtual machines, app services, or other Azure resources to these subnets.

• Set Up Routing: Define custom routes if needed for advanced traffic control.

Conclusion

Creating a well-structured Azure Virtual Network with subnets helps optimize resource segmentation, security, and traffic management. Following this guide ensures you can design and deploy a scalable network foundation tailored to your needs.

If you have any questions or feedback, feel free to drop a comment below. Happy networking!

Pro Tip: Always plan your address spaces and subnet sizes carefully to avoid conflicts and ensure scalability.

What is Azure Blob Storage?

Azure Blob Storage is a cloud-based service for storing large amounts of unstructured data. It supports hosting static content like HTML, CSS, JavaScript, and images, making it a great option for static websites.

Step-by-Step Guide to Hosting a Static Website on Azure Blob Storage

Creating and hosting a portfolio website has never been easier! With platforms like ThemeWagon providing stunning free and premium templates, and Azure Blob Storage offering cost-effective hosting, you can get your site online in no time.

In this guide, we’ll walk you through:

1. Downloading a portfolio template from ThemeWagon.

2. Hosting your static website on Azure Blob Storage

Step 1: Download a Portfolio Template from ThemeWagon

Step 1.1: Visit the ThemeWagon Website

1. Open your web browser and go to the ThemeWagon website.

2. Use the search bar or navigate to the Portfolio Templates section.

   

   

Step 1.2: Choose Your Template

1. Browse through the portfolio templates.

2. Click on a template to view its details. Check out the demo to ensure it meets your requirements.

Step 1.3: Download the Template

1. If the template is free:

   • Click the Download button and save the .zip file to your computer.

2. For premium templates:

   • Purchase the template, then download the .zip file.

Step 1.4: Extract the Template Files

1. Locate the downloaded .zip file.

   

2. Extract the contents to a folder using tools like WinRAR or 7-Zip.

   

3. Inside the extracted folder, you'll find:

   • index.html

   • Folders for CSS, JavaScript, images, etc.

     

   • Go to your code editor and Open the unzipped Folder using any code Editor of your choice e.g Visual studio code(VS code)

     

     

Create a new file 404.html and paste the codes below

• And then Save using Control S for Windows or Command S for Mac

Step 2: Host the Static Website on Azure Blob Storage

Azure Blob Storage is ideal for hosting static websites. Follow these steps to deploy your downloaded template.

Step 2.1: Create an Azure Storage Account

1. Log in to the Azure Portal.

   

2. Click Create a resource > Storage > Storage account.

   

   

   

3. Fill in the required fields:

   • Resource group: Select an existing one or create a new one.

   • Storage account name: Enter a globally unique name.

   • Region: Choose a region close to your audience.

   • Performance: Choose Standard.

   • Redundancy: Select LRS (Locally Redundant Storage).

4. Click Review + Create, and then click Create.

   

   

   

   

Step 2.2: Enable Static Website Hosting

1. Open your storage account in the Azure Portal.

2. In the left-hand menu, select Static website under Data management.

   

3. Toggle Static website to Enabled.

   • Index document name: Enter index.html.

   • Error document path: (Optional) Enter 404.html.

     

4. Click Save. Azure will provide a Primary Endpoint URL—this is your website’s public address.

   

Step 2.3: Upload Your Template Files

1. Navigate to the Containers section of your storage account.

   

   

2. Open the $web container (automatically created when static website hosting is enabled).

   

3. Click Upload and select all files from your extracted folder (HTML, CSS, JavaScript, images, etc.).

   • Maintain the folder structure as it is.

     

     

     

Step 2.4: Test Your Website

1. Copy the Primary Endpoint URL from the Static Website settings.

2. Paste it into your browser. Your portfolio website should now be live!

   

Step 3: (Optional) Add a Custom Domain

To make your website more professional, you can add a custom domain.

1. Update your domain’s DNS settings to include a CNAME record pointing to the Azure website endpoint.

2. In the Azure Portal, navigate to the Custom domain section of your storage account.

3. Enter your custom domain name and validate it.

Step 4: (Optional) Enable HTTPS

Azure Blob Storage provides HTTPS for the default domain. To enable HTTPS for a custom domain:

1. Use Azure Front Door or Azure CDN.

2. Follow the configuration steps to secure your site.

Conclusion

By following these steps, you can easily create and host a stunning portfolio website:

1. Download a professional template from ThemeWagon.

2. Host it on Azure Blob Storage for reliable and scalable access.

Now, go ahead and showcase your work with your new portfolio site!

Happy Hosting! 🎉

In this blog, we’ll dive deep into the essential building blocks of Azure’s architecture, exploring how they work together to deliver seamless cloud services.

Core Architectural Components of Azure

1. Azure Regions

Azure operates data centers worldwide, grouped into regions to provide localized and reliable cloud services.

• Definition: A region is a geographical area that contains one or more Azure data centers.

• Purpose: Regions allow users to deploy resources close to their target audience to minimize latency and meet data residency requirements.

• Examples: Azure regions include East US, West Europe, and Southeast Asia.

• Paired Regions: Every Azure region is paired with another to ensure business continuity. For example, East US is paired with West US for disaster recovery and data redundancy.

2. Azure Resource Groups

Resource groups are logical containers used to organize Azure resources.

• Definition: A resource group is a container for related resources that share the same lifecycle and permissions.

• Purpose: They simplify management by grouping related resources, making it easier to monitor, deploy, and delete them as a unit.

• Key Features:

  • Role-Based Access Control (RBAC): Set permissions at the resource group level.

  • Tagging: Add metadata to resources for easy categorization.

3. Azure Resource Manager (ARM)

Azure Resource Manager is the backbone of Azure's resource deployment and management.

• Definition: ARM is a management layer that allows users to create, update, and delete Azure resources.

• Key Benefits:

  • Consistent Management: Use templates, APIs, and tools for consistent resource deployment.

  • Dependency Mapping: Define dependencies between resources to ensure proper deployment order.

  • Role-Based Access Control (RBAC): Securely manage who can perform actions on specific resources.

4. Azure Compute Services

Azure provides scalable compute options to run applications and services.

• Components:

  • Virtual Machines (VMs): Fully customizable virtual servers for hosting applications.

  • Azure Kubernetes Service (AKS): Managed Kubernetes for containerized applications.

  • App Services: PaaS for hosting web apps, RESTful APIs, and mobile backends.

  • Azure Functions: Serverless compute for event-driven tasks.

• Scalability: Automatically scale compute resources to handle increased workloads.

5. Azure Networking

Azure's networking services connect and secure resources globally.

• Key Components:

  • Virtual Network (VNet): Enables secure communication between Azure resources.

  • Azure Load Balancer: Distributes incoming network traffic for high availability.

  • Azure Traffic Manager: Routes user traffic to optimal endpoints based on routing rules.

  • ExpressRoute: Provides private connections between on-premises infrastructure and Azure.

  • Azure Firewall: Offers network security to protect resources from threats.

6. Azure Storage

Azure provides scalable, secure, and redundant storage solutions for various data needs.

• Types of Storage:

  • Blob Storage: Unstructured data storage for documents, images, videos, etc.

  • File Storage: Managed file shares accessible via SMB protocol.

  • Queue Storage: Messaging services for communication between application components.

  • Table Storage: NoSQL data store for structured data.

• Redundancy Options:

  • Locally Redundant Storage (LRS)

  • Geo-Redundant Storage (GRS)

  • Zone-Redundant Storage (ZRS)

7. Azure Identity and Access Management

Azure provides robust tools to secure access to resources.

• Azure Active Directory (Azure AD):

  • Cloud-based identity and access management service.

  • Enables single sign-on (SSO) and multi-factor authentication (MFA).

• Role-Based Access Control (RBAC):

  • Granular permissions management for resources.

• Azure Key Vault:

  • Securely stores secrets, certificates, and encryption keys.

8. Azure Monitoring and Management Tools

Azure offers tools to monitor and manage resources effectively.

• Azure Monitor:

  • Collects metrics and logs to provide insights into resource performance.

• Azure Advisor:

  • Personalized recommendations to improve resource performance and cost efficiency.

• Azure Service Health:

  • Provides alerts and updates about service issues or outages.

• Azure Automation:

  • Automates repetitive tasks like patch management and configuration updates.

9. Azure Databases

Azure supports a variety of database solutions for diverse application needs.

• SQL Database: Fully managed relational database.

• Cosmos DB: Globally distributed, multi-model NoSQL database.

• Azure Database for MySQL/PostgreSQL: Managed open-source database solutions.

• Azure Synapse Analytics: Integrates big data and data warehousing for advanced analytics.

10. Azure AI and Machine Learning

Azure simplifies the development of AI and ML models.

• Azure Cognitive Services: Pre-built APIs for vision, speech, language, and decision-making.

• Azure Machine Learning: End-to-end service for building, training, and deploying machine learning models.

11. Azure Security

Azure incorporates security at every layer of its architecture.

• Azure Security Center:

  • Unified security management and threat protection.

• Azure Sentinel:

  • Cloud-native SIEM for intelligent threat detection and response.

• DDoS Protection:

  • Protects applications from distributed denial-of-service attacks.

12. Azure DevOps

Azure DevOps provides development tools to streamline CI/CD processes.

• Key Features:

  • Repositories for version control.

  • Pipelines for continuous integration and deployment.

  • Boards for agile project management.

  • Artifacts for package management.

Conclusion

Microsoft Azure’s core architectural components offer a robust and flexible foundation for businesses of all sizes. By understanding these components, organizations can effectively design, deploy, and manage cloud-based solutions to meet their needs. Whether it's compute power, storage, networking, or AI capabilities, Azure provides the tools to innovate and scale in a secure and cost-effective way.

Understanding these building blocks not only empowers businesses to maximize Azure’s potential but also prepares them for the future of cloud computing.

Cloud computing is a technology that allows users to access and store data, applications, and computing resources over the internet instead of on a local computer or server. Essentially, it means that instead of managing physical servers and storage hardware, users can utilize virtual resources provided by remote servers hosted in data centers by cloud providers like Amazon Web Services (AWS), Microsoft Azure, and Google Cloud.

Key Concepts of Cloud Computing

1. On-Demand Availability: Users can access computing resources whenever they need them, without requiring prior setup or large infrastructure.

2. Scalability: Cloud computing allows users to scale resources up or down based on demand. This is ideal for businesses with fluctuating workloads or growing needs.

3. Cost Efficiency: Users pay only for the resources they use, avoiding large upfront costs for hardware and maintenance, and potentially reducing overall IT costs.

4. Remote Access: Since cloud services are accessed via the internet, they can be used from anywhere, supporting remote work and collaboration.

5. Resource Sharing: Cloud computing uses shared resources to serve multiple users, allowing for efficient use of resources and lowering costs.

Types of Cloud Computing

• Public Cloud: Services provided over the public internet and shared among multiple organizations.

• Private Cloud: A dedicated environment accessible only to a single organization, offering greater control and security.

• Hybrid Cloud: A combination of both public and private cloud resources, allowing data and applications to be shared between them.

• Multi-Cloud: Utilizing multiple cloud services from different providers to meet specific needs or avoid dependency on a single provider.

Types of Cloud Services (Cloud Computing Models)

1. Infrastructure as a Service (IaaS): Provides fundamental resources like virtual machines, storage, and networking. (Example: AWS EC2)

2. Platform as a Service (PaaS): Offers development tools and platforms to build and deploy applications without managing underlying infrastructure. (Example: Google App Engine)

3. Software as a Service (SaaS): Delivers fully managed applications to users via the internet. (Example: Microsoft 365, Salesforce)

Real-World Applications of Cloud Computing

• Data Storage and Backup: Storing files, databases, and backups on the cloud to reduce physical storage needs.

• Web Hosting and Application Hosting: Hosting websites, applications, and databases on scalable cloud servers.

• Data Analytics and Machine Learning: Using powerful cloud-based computing resources to analyze data and build machine learning models.

• Remote Collaboration: Allowing teams to work together using shared, cloud-hosted applications and storage (e.g., Google Workspace, Microsoft Teams).

Cloud computing has become fundamental in modern technology, enabling innovation and efficiency for businesses, developers, and everyday users alike.

The Advantages and Disadvantages of Cloud Computing

Cloud computing has transformed how we work, play, and connect. By offering on-demand access to vast computing resources, cloud computing enables businesses and individuals to scale their operations with ease, reduce costs, and access data from anywhere. However, it's essential to weigh both the advantages and disadvantages before fully committing to a cloud solution. Here’s a closer look at the pros and cons of cloud computing.

Advantages of Cloud Computing

1. Cost Savings

• One of the main benefits of cloud computing is cost efficiency. Traditional on-premises infrastructure requires significant upfront investments in hardware, software, and IT maintenance. With cloud computing, companies only pay for the services they use, similar to a utility model.

• Savings on Infrastructure: Cloud providers handle the maintenance, so companies don’t need to invest in data centers or the personnel to manage them.

• Flexible Pricing Models: Many providers offer pay-as-you-go and subscription-based pricing, allowing businesses to scale costs in line with their actual usage and budget.

2. Scalability and Flexibility

• Cloud computing provides nearly unlimited scalability. Organizations can increase or decrease their resources to meet demand without needing to procure additional hardware or suffer from idle resources.

• Elasticity: Companies can quickly scale up their computing power during peak times and scale back down as needed, avoiding unnecessary costs.

• Global Reach: Many cloud providers offer data centers worldwide, allowing users to deploy resources closer to their customers, which reduces latency and improves performance.

3. Accessibility and Collaboration

• Cloud services can be accessed from anywhere with an internet connection, making it easier for teams to collaborate across different locations and time zones.

• Remote Access: With cloud computing, employees can work from virtually any device, making remote work easier and more flexible.

• Real-Time Collaboration: Many cloud-based tools allow multiple people to work on the same document or project in real time, enhancing productivity and team collaboration.

4. Automatic Updates and Patches

• Cloud providers manage all updates, security patches, and maintenance, freeing up internal IT teams from these tasks.

• Improved Security: Providers keep the systems updated with the latest security measures, which is essential for keeping data safe.

• Reduced Downtime: Scheduled updates and maintenance are often managed seamlessly in the background, minimizing downtime and ensuring continuous availability.

5. Data Backup and Disaster Recovery

• Cloud computing includes built-in data redundancy and backup capabilities, which can simplify disaster recovery.

• Resilience: Cloud providers replicate data across multiple locations, ensuring that even if one data center goes offline, the data remains accessible.

• Business Continuity: In the case of a disaster, businesses can recover their data faster, helping them resume operations more quickly.

Disadvantages of Cloud Computing

1. Security and Privacy Concerns

• Moving data and applications to the cloud introduces potential security risks, as companies must trust the cloud provider with sensitive information.

• Data Breaches: Cloud providers are high-value targets for cybercriminals, and a breach could expose sensitive customer or business data.

• Compliance: Certain industries have strict regulatory requirements (e.g., HIPAA for healthcare), and compliance can be challenging when data is hosted off-site.

2. Limited Control and Flexibility

• With cloud computing, companies must rely on their provider’s infrastructure, which means less control over hardware and performance parameters.

• Dependency on the Provider: If a provider experiences downtime, the customer’s data or applications might be inaccessible. Also, changes made by the provider (like service updates) might not always align with a company’s specific requirements.

• Customization Constraints: Some cloud solutions might not be as customizable as on-premises alternatives, which could be a limitation for companies with unique technical needs.

3. Potential Downtime

• Although cloud providers aim to ensure high availability, downtime can still occur due to maintenance, updates, or unforeseen issues.

• Network Reliability: If an internet connection is lost, users won’t have access to cloud services, impacting productivity.

• Service Outages: Even the largest providers can experience outages. In such cases, businesses relying heavily on cloud infrastructure may face costly downtime.

4. Data Transfer and Bandwidth Costs

• While storing data in the cloud is relatively inexpensive, transferring large amounts of data in and out of the cloud can incur significant bandwidth costs.

• Data Egress Fees: Most providers charge fees for moving data out of their systems, which can add up if a business frequently transfers data.

• Performance Latency: For applications requiring rapid data access, latency might be an issue if the data center is far from the user, affecting real-time processing.

5. Risk of Vendor Lock-In

• Transitioning from one cloud provider to another can be complex and costly, leading to vendor lock-in, where businesses are tied to a particular provider.

• Difficulty in Migration: Migrating large data sets or applications from one cloud environment to another can be technically challenging and require significant downtime.

• Loss of Flexibility: Businesses may feel constrained by a provider’s specific offerings, pricing models, and proprietary technologies.

Final Thoughts: Finding the Right Balance

Cloud computing offers a range of benefits, including cost savings, scalability, and accessibility, making it an excellent choice for many businesses. However, it also introduces potential drawbacks, such as security risks, limited control, and potential downtime, which companies need to consider carefully.

The best approach is to assess your business’s specific needs and challenges, consult with your cloud provider about the best practices for security and reliability, and possibly implement a hybrid solution that combines cloud resources with on-premises systems. By doing so, you can maximize the advantages of cloud computing while minimizing its potential disadvantages.

Prerequisites

Before we start, ensure you have:

1. An active Azure account. Sign up for free if you don’t have one.

2. Basic knowledge of Azure portal and virtual machine concepts.

Step 1: Navigate to the Azure Portal

1. Go to portal.azure.com.

   

Step 2: Create a Virtual Machine Scale Set

1. In the Azure portal, search for "Virtual Machine Scale Sets" in the search bar at the top.

   

2. Select Virtual Machine Scale Sets from the dropdown, and click + Create to start the setup process.

   

Step 3: Configure Basic Settings

1. In the Basics tab, enter the following informatioSubscription: Select your Azure subscription.

   • Resource group: Either create a new resource group or select an existing one.

   • Region: Choose the region where you want to deploy the VM scale set.

   • Scale set name: Provide a name for your scale set.

     

   • Orchestration mode: Choose Uniform (default) for identical VMs, or Flexible if you need more control.

• Scaling Configuration

  1. Set the Initial instance count (e.g., 2 instances).

  2. Enable Autoscale if you want the VMSS to automatically adjust the number of VMs based on demand.

  3. Configure scale-out and scale-in rules if autoscaling is enabled (e.g., increase by 1 instance when CPU usage is above 75%).

     

     

     

     

• Operating System: Select Linux.

• Image: Choose a Linux image, like Ubuntu Server 18.04 or 24.04 LTS.

• Size: Pick a VM size suitable for your workload (e.g., Standard_D2s_v3).

  

  

2. Click Next: Disks > to proceed.

   

Step 4: Configure Disk Options

1. On the Disks tab, select Standard SSD for cost-effective storage, or choose Premium SSD if performance is critical.

2. Configure any additional disks if necessary.

3. Click Next: Networking >.

   

Step 5: Set Up Networking

1. In the Networking tab, select the Virtual network you wish to use or create a new one.

2. Choose a Subnet for the VMs in the scale set.

3. Enable Load Balancing if you want to distribute traffic across VMs.

4. Enable Public IP for individual instances if necessary for direct connections, though it’s generally recommended to connect via Load Balancer for security.

   

   

   

   

   

   

   

5. Click Next: Management >.

   

Step 6: Configure Management Options

1. Set the Diagnostics options to enable monitoring.

2. Choose Identity and Access Management settings if needed for security policies.

3. Enable Auto-shutdown if you want to reduce costs by automatically turning off VMs during off-hours.

4. Click Review + create to finalize the configuration.

   

Step 7: Review and Create the Scale Set

1. Azure will validate your configuration. If all settings are correct, click Create to start deploying the scale set.

   

   

2. Wait for the deployment to complete, which may take a few minutes.

   

Step 8: Connect to a VM in the Scale Set

1. Once deployment is complete, go to the Scale Set overview page.

2. Select Instances from the left menu to view the list of VMs in the scale set.

   

   

3. Click on one of the instance names to access its details.

   

   

4. Under Settings, go to Networking and locate the Public IP address (if assigned).

   

   

5. Open a terminal and connect using SSH:

    ssh -i <The path to your downloaded Pem Key file> azureuser@<PublicIP>
   

   Replace <PublicIP> with the actual IP address of the instance.

   

Step 9: Verify Connectivity

1. Run a few commands on the connected VM to verify everything is set up as expected.

Consider setting up monitoring tools to observe the performance and scalability of the VMSS.

Conclusion

You have successfully set up a Linux Virtual Machine Scale Set, configured autoscaling, and connected to an individual instance. By following this guide, you can scale your application’s backend to handle different levels of demand seamlessly.

Creating a virtual machine (VM) in Microsoft Azure is a key skill for anyone looking to leverage cloud computing, whether for personal projects, application development, or enterprise solutions. Azure virtual machines offer flexibility, scalability, and access to a variety of resources, making them ideal for running everything from simple applications to complex infrastructure setups. In this guide, we’ll walk through the steps to create a virtual machine in Azure, from setting up essential configurations to accessing your VM. By the end, you’ll have a functional virtual machine ready for development, testing, or deployment. Let’s get started!

Step 1: Log into the Azure Portal

• Description: Begin by logging into your Azure account via the Azure Portal

Step 2: Access the “Create a Resource” Option

• Description: Once logged in, you’ll be on the Azure dashboard. On the left-hand side menu, click on Create a resource. This opens a new window where you can choose from a list of resources.

• 

Step 3: Search and Select “Virtual Machine”

• Description: In the “Create a resource” window, use the search bar at the top to type Virtual Machine. Select Virtual Machine from the options that appear.

Step 4: Configure the Basics of Your Virtual Machine

• Description: The first tab you’ll see is the Basics tab. Here, you’ll enter essential details for your VM:

  • Subscription: Choose the subscription you’re using.

  • Resource Group: Select an existing resource group or create a new one.

  • 

  • Virtual Machine Name: Enter a name for your VM, like "MyFirstVM."

  • Region: Select the Azure region where your VM will be hosted.

  • Availability Options: Choose Availability zone or Availability set if you need redundancy.

  • 

Step 5: Choose the Virtual Machine Image and Size

• Description: Scroll down to select the Image (operating system) for your VM, such as Windows Server 2019 or Ubuntu Server 20.04 LTS. Then, choose the Size based on your CPU and memory requirements.

Step 6: Configure Administrator Account

• Description: In the same Basics tab, set up the admin account details to manage your VM:

  • Authentication Type: Choose between Password or SSH Public Key.

  • Username and Password/SSH Key: Provide a username and either a password or SSH key.

  • 

Step 7: Configure Disk Options

• Description: In the Disks tab, select the OS disk type (Standard SSD, Premium SSD, or HDD) based on performance and cost needs. You can also add data disks if required

• 

Step 8: Set Up Networking

• Description: Switch to the Networking tab to configure network settings for the VM, including the Virtual Network (VNet), Subnet, and Public IP. You can accept the defaults or customize these settings.

Step 9: Set Up Monitoring (Optional)

• Description: On the Monitoring tab, you can enable monitoring options such as Boot diagnostics, Guest OS diagnostics, and Auto-shutdown if needed.Step 10: Review and Create the Virtual Machine

Step 10: Review and Create the Virtual Machine

• Description: After completing all necessary tabs, go to the Review + Create tab. Azure will validate the settings, and if everything is correct, you’ll see a green checkmark. Click Create to start the VM deployment.

• 

Step 11: Access and Manage Your Virtual Machine

• Description: Once the VM is created, go to your Virtual Machines page, select your VM, and use the Connect button to log in via RDP (for Windows) or SSH (for Linux).

Step 12: Connect to Your Windows VM

• Description: Once deployment is complete, go to the Virtual Machines section in your Azure portal. Select your VM and click Connect. Follow the instructions for connecting via Remote Desktop Protocol (RDP), using the username and password you set up in Step 6.

Step 13 : Double click on the RDP File to Launch VM

Description: Double-click on the downloaded RDP file to initiate a remote desktop session with your virtual machine. This action will open the Remote Desktop Protocol (RDP) client, allowing you to securely connect and manage your VM directly from your local device.

Conclusion

Creating a virtual machine in Microsoft Azure is a simple yet powerful way to get started with cloud computing. Whether you’re testing an app, running isolated development environments, or hosting scalable services, Azure VMs offer the flexibility and power you need.