Forem: Oluwanifesimi

Steps to Containerize a Software Application

Oluwanifesimi — Mon, 10 Nov 2025 18:56:52 +0000

Introduction
Containerization has revolutionized modern software development by streamlining how applications are built, deployed, and maintained. In this guide, you'll learn how to containerize a simple Node.js Todo List Manager using Docker. By encapsulating the app and its dependencies into a container, you’ll gain consistency across environments, simplify deployment workflows, and enhance scalability.
Whether you're exploring Docker for the first time or brushing up on containerization fundamentals, this hands-on project will walk you through transitioning an app from a local setup to a fully containerized solution.

What You’ll Need
Before diving in, make sure your system is equipped with the following tools:

Docker Desktop (latest version): For building, running, and managing containers.
Git client: To clone the project repository and handle version control.
Code editor or IDE: Preferably Visual Studio Code for editing project files.
(Optional but helpful) Basic familiarity with terminal or command-line usage.

Step 1 : Get the app

Steps to Get the App and Run it in Visual Studio Code
Open Visual Studio Code
Launch VS Code on your computer.
Open the Terminal
Click on Terminal at the top menu and select new terminal
Clone the Application Repository
In the terminal, type the following command and press Enter:
git clone https://github.com/docker/getting-started-app.git
Navigate into the App Folder cd getting-started-app
Open the Folder in VS Code (Optional) code .
View the contents of the cloned repository. You should see the following files and sub-directories.

Step 2 : Build image

To build the image, you'll need to use a Dockerfile. A Dockerfile is simply a text-based file with no file extension that contains a script of instructions. Docker uses this script to build a container image.

In the getting-started-app directory, the same location as the package.json file, create a file named Dockerfile with the following contents:
This Dockerfile starts off with a node:lts-alpine base image, a light-weight Linux image that comes with Node.js and the Yarn package manager pre-installed. It copies all of the source code into the image, installs the necessary dependencies, and starts the application.
Build the image using the following commands:
docker build -t getting-started-app .

Step 3: Start an app container

Now that you have an image, you can run the application in a container using the docker run command.
Run your container using the docker run command and specify the name of the image you just created:
docker run -d -p 127.0.0.1:3000:3000 getting-started

After a few seconds, open your web browser to http://127.0.0.1:3000. You should see your app.

Conclusion
Upon completing this project, you’ll have elevated a basic Node.js Todo List Manager into a fully containerized application. Along the way, you’ll build practical expertise in Docker — mastering commands, crafting images, and managing containers. These are essential capabilities for today’s DevOps practices and cloud-native development. More than just a technical exercise, this project empowers you to confidently deploy applications that are scalable, portable, and production-ready in diverse environments.

Advanced Linux Administration: User and Permission Control in a Simulated Business Environment

Oluwanifesimi — Thu, 06 Nov 2025 15:52:22 +0000

Introduction

Effective user, group, and permission management is a cornerstone of Linux system administration. It safeguards sensitive data by controlling access, while enabling seamless collaboration across shared environments. In this project, you'll engage in a realistic simulation—creating users, organizing them into groups, and configuring access to shared directories and project files. Through this hands-on experience, you'll gain proficiency with key commands such as adduser, groupadd, usermod, chmod, chown, and id.

Tasks to be Completed

Create Groups
Set up 2 groups (e.g., devs and staff) using groupadd.
Create Users
Add 5 new users with adduser or useradd.
Assign Users to Groups
Use usermod -aG to assign users to the correct group.
Set Up a Shared Project Directory
Create a directory (/home/company_projects) and configure it with the SGID bit so all files inherit the group ownership.
Manage Permissions
Use chmod to enforce rules (e.g., only group members can read/write, others are denied).
Test Group Collaboration
Have one user (e.g., alice) create a file and another group member (e.g., bob) edit it.
Confirm that non-members (e.g., carol) cannot access the directory.
Change File Ownership
Practice with chown and chgrp to assign ownership of files to specific users or groups.
Verify and Troubleshoot
Use commands like id, groups, ls -l, and stat to confirm changes.

Prerequisites

Most commands require root privileges. Prefix with sudo when needed, or run as root:
sudo -i **or **sudo su - if you want a root shell

Step 1: Create two groups

Choose meaningful group names. Example: devs and staff.

sudo groupadd devs
sudo groupadd staff

Verify groups exist:

getent group devs
getent group staff

Step 2 : Create five users
Create five user using the command adduser, adduser will prompt for a password and optional info.

sudo adduser alice
sudo adduser john
sudo adduser Isabella
sudo adduser dave
sudo adduser stefan
To view all the users created
awk -F: '$3 >= 1000 {print $1}' /etc/passwd

To delete a user
To verify a user was deleted , If nothing is returned, that user is fully removed.

grep username /etc/passwd

Step 3 :Assign users to groups

Decide group membership. Example mapping:
devs: alice, bob
staff: isabella, dave, stefan

Add users to groups (use -aG user to each group)

sudo usermod -aG devs alice
sudo usermod -aG devs john
sudo usermod -aG staff Isabella
sudo usermod -aG staff dave
sudo usermod -aG staff stefan

Verify membership:
verify membership by using the command sudo getent group devs and sudo getent group staff

Step 4 : Create a shared project directory

Create a directory that group members can read/write. We'll create a company_projects folder in the home directory:

mkdir -p /home/company_projects (create a parent directory in the home directory)
sudo chmod g+s /home/company_projects The g+s (setgid on directory) is what makes a shared project folder behave like a real team workspace.

sudo chown root:devs /home/company_projects

chown → change owner of a file or directory.
root:devs
root = new owner of the directory
devs = new group of the directory
/home/company_projects → the target directory.

sudo chmod u+rwx /home/company_projects

chmod → change file/directory permissions.
u → refers to the owner of the directory.
+rwx → add read (r), write (w), and execute (x) permissions.
Effect: The owner of ~/company_projects can list contents, create/delete files, and enter the directory

sudo chmod g+rwx /home/company_projects

chmod: change permissions.
g: refers to the group of the file/directory (in your case, the group might be devs because of sudo chown root:devs).
+rwx: add three permissions:
r (read): group members can list the files inside.
w (write): group members can create new files, delete files, and make changes.
x (execute): group members can enter the directory and access its contents.

Step 5 : Test the shared directory behavior

switched to the alice account and tried to enter /home/company_projects

su - alice
cd /home/company_projects
touch testfile_from_alice.txt
ls
shows: file_from_alice.txt
ls -l
shows a line similar to:
-rw-rw-r-- 1 alice devs 0 Sep 27 08:40 file_from_alice.txt
What this shows:
The file owner is alice.
The file group is devs — it inherited the directory group (devs) because the parent directory had the setgid bit.
File permissions are -rw-rw-r-- (owner read/write, group read/write, others read).
exit to logout from alice

5.1 As another devs member (john), confirm you can edit/delete:

su - john
cd /home/company_projects
echo "hello user" >> testfile_from_alice.txt
cat testfile_from_alice.txt allowed because group has write permission

*5.2 A non-member (e.g., Isabella, in staff) should be denied because they are not a member of the group devs, they belong to the staff group:
*

su - Isabella
cd /home/company_projects
touch file_from_Isabella.html this should fail with "Permission denied" touch should_fail.txt

Step 6 : Manage file ownership and group on existing files

Set owner and group for a file or directory using the command

sudo chown alice:devs /home/company_projects/somefile.txt
The owner of the directory is alice and now belong to the devs team.

6.1 change only group:

sudo chgrp staff ~/company_projects/some_other_file.txt

Before the command

The directory /home/company_projects had:

Owner: alice
Group: devs
Shown by:
drwxrwsr-x 2 alice devs 4096 Sep 27 09:15 /home/company_projects
Step: sudo chgrp staff /home/company_projects
chgrp = change group ownership
staff = new group
So, this command changed the group of the directory from devs ➝ staff.
Now the directory looks like:
drwxrwsr-x 2 alice staff 4096 Sep 27 09:15 /home/company_projects

Meaning:

Owner is still alice
Group is now staff
Next: su - carol
switched to user carol.
Carol goes into /home/company_projects and creates a file:
touch man.txt
Now when you list:
-rw-rw-r-- 1 carol staff 0 Sep 27 09:53 man.txt
-rw-rw-r-- 1 alice devs 16 Sep 27 09:23 testfile_from_alice.txt

Why this happened:

man.txt
Owner = carol (because she created it).
Group = staff (because the directory /home/company_projects now belongs to group staff AND it has the setgid bit s set → that s in drwxrwsr-x).
The setgid bit ensures new files created inside inherit the directory’s group.
testfile_from_alice.txt
This was created earlier by Alice when the group was still devs.
So it keeps alice:devs.

Conclusion

This project provided a hands-on exploration of Linux file ownership, group management, and permission control. Through practical exercises using commands like chown, chgrp, and chmod, we illustrated how to assign resources to users and groups while regulating access levels. A standout feature was the use of the setgid permission, which ensures consistent group ownership for new files in shared directories—streamlining collaboration across teams. We also examined how changes in group membership (e.g., alice:devs to alice:staff) influence access rights and user interactions within shared environments. Ultimately, this project underscores the critical role of permission management in maintaining secure, efficient multi-user systems.

Linux Essentials: Managing Files and Folders in a Simulated Company Setup

Oluwanifesimi — Tue, 04 Nov 2025 17:17:07 +0000

Introduction
Linux is a powerful operating system used in everything from servers and cloud platforms to smart devices and supercomputers. One of the first things to learn when working with Linux is how to manage files and folders. This skill is essential for anyone interested in system administration, DevOps, or automation.

In this project, “File & Directory Management for a Mock Company using Linux”, you’ll set up and organize a sample company’s folder structure. It’s a hands-on way to learn how to move through the Linux filesystem, work with files, and use key commands like mkdir, cd, ls, and more. You’ll also practice using both absolute and relative paths to navigate and manage data.

What You’ll Do
Here are the practical tasks you’ll complete step by step:

Set Up the Company Structure

Create directories for different departments (HR, Finance, Dev, Marketing).

Create and Manage Files

Add employee records, policy documents, budgets, and project files.
Use commands like touch, ls, cat.

Copy, Move, and Rename Files

Share policies across departments.
Move misplaced project files.
Rename files correctly.

Search and Find Files

Use find to locate files.
Search content inside files with grep.

Compress and Backup Data

Archive the company directory with tar and gzip.
Extract the archive to test backup recovery.

Check Storage Usage

Monitor directory size with du.
Check disk space with df.

Work with Paths

Practice using absolute paths (/home/user/company/...).
Practice using relative paths (../finance/budget.txt).

Step 1 Create the Company Folder Structure

We will first create a parent directory named company, and inside this directory, we will create four subdirectories representing different departments of the organization:

Commands Used and Their Meanings

mkdir -p ~/company
mkdir: Make Directory (creates a new folder)
-p: Parents flag (creates parent directories if they don't exist)
~/company: Path to the new directory (in the user's home folder)
Meaning: Create a directory called "company" in the home directory
mkdir -p ~/company/hr (and similar commands)
Meaning: Create subdirectories (hr, finance, marketing, dev) inside the company directory
ls
Meaning: List contents of the current directory
cd company
cd: Change Directory
Meaning: Move into the company directory

1.1 Create the main company directory:

mkdir -p ~/company

1.2 Create department subdirectories:

mkdir -p ~/company/hr
mkdir -p ~/company/finance
mkdir -p ~/company/marketing
mkdir -p ~/company/dev

1.3 Verify the directory structure:

ls
This shows all files and directories in your current location, including the new "company" directory.

1.4 Navigate into the company directory:
Navigate into the parent directory (company) using the cd command.
*cd * company

ls
This confirms that all four department directories (dev, finance, hr, marketing) were created successfully.

Step 2: Create Some Sample Files

touch → creates empty files.

Here we simulate real company documents: HR gets employee records and policies, Finance gets budgets, Dev has project files, and Marketing has strategies.

You can confirm they were created with: ls ~/company/hr ls ~/company/finance ls ~/company/dev ls ~/company/marketing

Step 3: Copy & Rename Files

Copy HR policies to Marketing:

cp copy files from one directory to another directory
ls comfirm the policies.txt file is copied to marketing directory

cp ~/company/hr/policies.txt ~/company/marketing

mv → use for renaming files.

The file in the dev folder (projectA.txt) is spelt wrongly, rename the file to project2025.txt
cd into the dev directory
ls to list the files in the directory
use mv to rename the directory from projectA.txt to project2025.txt
use ls to verify your change.

Step 4: Search for Files

find → locates files and directories matching a pattern.
grep -r → searches inside files for specific words recursively.
This is useful for quickly tracking down documents.
find ~/company -name "*.txt" locates files and directories that has the .txt files.
find ~/company -name "*.txt" locates files and directories that has the .png files.
Search for the word “policy” inside files:
grep -r "policies" ~/company

Step 5: Organize with Compression

At some point, every company needs to back up its files to protect against accidental deletion, corruption, or system failure. In Linux, one of the most common tools for this is tar (short for tape archive). It allows you to bundle multiple files and directories into a single archive, and with the right options, compress it to save space.

5.1 Compress the company folder

Command:

tar -czvf company_backup.tar.gz ~/company

tar → archives multiple files and directories into one.
-c → create a new archive.
-z → compress the archive using gzip (makes it smaller in size).
-v → verbose mode, shows the progress in the terminal as files are being archived.
-f → specifies the filename of the archive (company_backup.tar.gz).
~/company → the folder you want to back up.
This command creates a compressed backup file named:
company_backup.tar.gz
in your current working directory. Extract the backup to test

Command:

tar -xzvf company_backup.tar.gz -C ~/

-x → extract files from an archive.
-z → tells tar the archive is compressed with gzip.
-v → verbose mode, shows files being extracted.
-f → specifies the filename of the archive.
-C ~/ → tells tar where to extract the files (in this case, your home directory). This simulates restoring the backup. After extraction, you should see the company folder again in your home directory.

5.2 Compress the company folder:

tar -czvf company_backup.tar.gz ~/company

5.3 Extract it to test:

tar -xzvf company_backup.tar.gz -C ~/

5.4 View whats inside the compressed folder

Check what’s inside your archive before extracting:
This lists all files and directories stored in the archive. tar -tzvf company_backup.tar.gz

5.5 Extract into a new folder
Create a new folder (Restorefiles) in the company directory which is the parent directory.

5.5.1 Preparation Setup

mkdir -p ~/company/Restorefiles
cd company
ls
cd ..

Created a safe restoration area (Restorefiles) to extract backup files
Verified your existing company structure before restoration
Positioned yourself in the home directory ready for extraction 5.1.2: Backup Extraction

tar xzvf company_backup.tar.gz -C ~/company/Restorefiles

Extracted a compressed backup archive (company_backup.tar.gz)
Used safe extraction to an isolated location instead of overwriting original files
Preserved the complete directory structure and file permissions 5.1.3 Verification & Inspection

cd ~/company/Restorefiles
ls
cd home
ls
cd ubuntu
ls
cd company
ls

Navigated through the extracted backup structure to verify contents
Confirmed all data was intact: departments, files, and hierarchy
Checked that the backup matched your expected company structure
What Your Backup Contained

Step 6: Check Storage & File Sizes

Commands:
6.1 Check company folder size:
du -sh ~/company

the size is 60kilobytes.

6.2 Check overall disk usage

df -h
du -sh → displays size of a directory in human-readable format.
df -h → shows free/used space on mounted filesystems.

Conclusion
This project showed how Linux can be used to build and manage a realistic company file system. By setting up department folders, organizing files, renaming and moving them, and securing everything with backups and compression, you’ve practiced essential skills that are key for system administrators and DevOps professionals.

Throughout the exercises, you learned how to:

Create and move through directories using mkdir and cd
Work with files using touch, ls, cp, and mv
Search for files and content using find and grep
Back up and restore data with tar and gzip
Check storage usage using du and df

Applying these commands in a mock company setup helped you see how Linux is used in real-world tasks like organizing data, managing backups, and keeping systems efficient. These foundational skills prepare you for more advanced topics like scripting, user permissions, automation, and cloud deployment. You’re now one step closer to becoming confident in Linux system administration.

How to Create DNS zones and configure DNS settings

Oluwanifesimi — Sat, 11 Oct 2025 03:27:40 +0000

Introduction

In today’s cloud infrastructure, the Domain Name System (DNS) is a cornerstone for managing communication between applications and services. Rather than depending on complex IP addresses, DNS enables the use of intuitive and human-readable names, simplifying both access and management. This project focuses on implementing and configuring DNS zones and settings within Microsoft Azure. By creating private DNS zones, defining DNS records, and linking DNS configurations with a virtual network, we establish secure and efficient name resolution, enhance network reliability, and streamline resource management.

Tasks to Cover

Create and configure a private DNS zone – to manage DNS records in a secure and isolated Azure environment.
Create and configure DNS records – to associate domain names with IP addresses or other Azure resources.
Configure DNS settings on a virtual network – to enable seamless and efficient name resolution for virtual machines and services within the VNet.

Step 1 Create a private DNS zone

Azure Private DNS provides a reliable, secure DNS service to manage and resolve domain names in a virtual network without the need to add a custom DNS solution. By using private DNS zones, you can use your own custom domain names rather than the Azure-provided names.

On the Azure portal, search for and select Private dns zones.
Select + Create and configure the DNS zone.
Subscription: Select your subscription
Resource group: RG1
Name: private.contoso.com
Region: East US
Select Review + create
Select Create.
Wait for the DNS zone to deploy, and then select Go to resource.

Step 2 Create a virtual network link to your private DNS zone

To resolve DNS records in a private DNS zone, resources must be linked to the private zone. A virtual network link associates the virtual network to the private zone.

In the portal, continue working on the private.contoso.com DNS zone.
In the DNS Management blade, select + Virtual network links.
Select + Add” and configure the virtual network link.
Link name: app-vnet-link
Virtual network: app-vnet
Enable auto registration: Enabled
Select Create and wait for the deployment to finish. If necessary, Refresh the page.
The virtual ntework as been link to the private DNS zone

Step 3 Create a DNS record set

DNS records provide information about the DNS zone.

In the portal, continue working on the private.contoso.com DNS zone.
In the DNS Management blade, select + Recordsets.
Notice that two A records have automatically been created for each of the virtual machines.
Select + Add and configure a record set. When finished select Add.
Name: backend
Type: A
TTL: 1
IP address: 10.1.1.5
DNS recordset has been created

Note: This record set implies there is a virtual machine in app-vnet with a private IP address of 10.1.1.5.

Conclusion
Completing this project results in a robust DNS infrastructure within Azure, tailored for efficiency and scalability. By leveraging private DNS zones and records, domain name management becomes centralized and streamlined. Integrating DNS configurations with the virtual network ensures consistent and reliable name resolution across all connected services and applications.

Beyond improved connectivity, this setup strengthens security by keeping DNS resolution internal—minimizing exposure and reducing risk. Ultimately, this project showcases how Azure DNS can simplify network administration while laying a scalable groundwork for future cloud-based workloads.

How to Configure Network routing in Azure

Oluwanifesimi — Sat, 11 Oct 2025 02:53:00 +0000

Introduction

In cloud networking, routing is essential for directing traffic efficiently and securely between subnets, virtual networks, and external networks. In Microsoft Azure, custom route tables provide administrators with greater control over how traffic flows within a virtual network—offering flexibility beyond the platform’s default system routes.

This project demonstrates how to configure and manage routing in Azure by creating a custom route table, associating it with specific subnets, and defining custom routes to manage traffic paths. By completing this project, you will develop hands-on experience in Azure routing configuration and learn how to tailor routing behavior to meet application and organizational needs.

Tasks to Complete

Create a Route Table – Build a custom route table to define and manage routing rules within your virtual network.
Add the Route Table – Integrate the newly created route table into the Azure environment for active use.
Associate the Route Table with Subnets – Attach the route table to one or more subnets so that its routing rules apply to the network traffic within those subnets.
Create a Custom Route – Define specific routes that control how traffic is directed, ensuring efficient and secure communication across the network.

Step 1 Create a Route Table

Azure automatically creates a route table for each subnet within an Azure virtual network. The route table includes the default system routes. You can create route tables and routes to override Azure’s default system routes.

Record the private IP address of app-vnet-firewall

In the search box at the top of the portal, enter Firewall. Select Firewall in the search results.
Select app-vnet-firewall.
Select Overview and record the Private IP address.

Step 2 Add the route table

In the search box, enter Route tables. When Route table appears in the search results, select it.
In the Route table page, select + Create and create the route table.

Complete the following configuration

Subscription: Select your subscription
Resource group: RG1
Region: East US
Name: app-vnet-firewall-rt
Select Review + create
Select Create.
Wait for the route table to deploy, then select Go to resource.

Step 3 Associate the route table to the subnets

In the portal, continue working with the route table, select app-vnet-firewall-rt.
In the Settings blade, select Subnets and then + Associate.
Configure an association to the frontend subnet, then select OK.
Virtual network: app-vnet (RG1)
Subnet: frontend
Configure an association to the backend subnet, then select OK.
Virtual network: app-vnet (RG1)
Subnet: backend
The Frontend and the Backend subnets as been associated to the route table.

Step 4 Create a route in the route table

In the portal, continue working with the route table, select app-vnet-firewall-rt.
In the Settings blade, select Routes and then + Add.
Configure the route, then select Add.
Route name outbound-firewall
Destination type IP addresses
Destination IP addresses/CIDR range 0.0.0.0/0
Next hop type Virtual appliance
Next hop address: private IP address of the firewall (10.0.2.4)
Route was created successfully in the route table

Conclusion
With this project complete, you've successfully created, configured, and linked a custom route table within Azure—giving you precise control over how traffic flows through your virtual network. These steps empower administrators to fine-tune performance, strengthen security, and tailor network behavior to meet specific application needs.

This hands-on exercise showcases the flexibility of Azure’s routing architecture and lays the groundwork for more advanced designs, such as integrating virtual appliances, enforcing traffic inspection, or building hybrid connectivity solutions. You're now equipped to shape network paths with confidence in any cloud scenario.

How to Create and Configure Azure Firewall

Oluwanifesimi — Sat, 11 Oct 2025 02:12:35 +0000

Introduction
This project focuses on designing and implementing centralized network security for an application virtual network (app-vnet) using Azure Firewall. As application demands scale, ensuring secure traffic flow, granular access control, and protected CI/CD operations via Azure DevOps becomes essential. To address these needs, you'll deploy Azure Firewall and configure it with a tailored firewall policy.

What You'll Accomplish
Throughout this project, you'll gain hands-on experience with key security tasks:

Deploy Azure Firewall to serve as a centralized security gateway.
Create and Configure a Firewall Policy to define traffic filtering rules.
Set Up an Application Rule Collection to allow secure access from app-vnet to Azure DevOps services.
Create a Network Rule Collection to enable DNS resolution for resources within the virtual network.
Prepare the AzureFirewallSubnet, deploy the firewall, apply the necessary rules, and validate the configuration.

By the end, you'll have a working firewall solution that enforces robust security policies and supports secure application development workflows in Azure.

Step 1 Create Azure Firewall subnet in our existing virtual network

In the search box at the top of the portal, enter Virtual networks. Select Virtual networks in the search results.
Select app-vnet.
Select Subnets.
Select + Subnet.
Enter the following information and select Save.
Name: AzureFirewallSubnet
Address range: 10.1.63.0/26
Note: Leave all other settings as default.

Step 2 Create an Azure Firewall

In the search box at the top of the portal, enter Firewall. Select Firewall in the search results.
Select + Create.

Create a firewall by using the values in the following table. For any property that is not specified, use the default value.
Note: Azure Firewall can take a few minutes to deploy.

Resource group: RG1
Name: app-vnet-firewall
Firewall SKU: Standard
Firewall management: Use a Firewall Policy to manage this firewall
Firewall policy: select Add new
Policy name: fw-policy
Region: East US
Policy Tier: Standard
Choose a virtual network: Use existing
Virtual network: app-vnet (RG1)
Public IP address Add new: fwpip
Enable Firewall Management NIC uncheck the box
Select Review + create
Then select Create.
Azure Firewall as been created succesfully, Click on go to resources to see the firewall.

Step 3 Update the Firewall Policy

In the portal, search for and select Firewall Policies.
Select fw-policy.

Add an application rule

In the rule blade, select Application rules and then Add a rule collection.
Configure the application rule collection and then select Add.
Name: app-vnet-fw-rule-collection
Rule collection type: Application
Priority: 200
Rule collection action: Allow
Rule collection group DefaultApplicationRuleCollectionGroup
Name: AllowAzurePipelines
Source type: IP address
Source: 10.1.0.0/23
Protocol: https
Destination type: FQDN
Destination dev.azure.com, azure.microsoft.com
Note: The AllowAzurePipelines rule allows the web application to access Azure Pipelines. The rule allows the web application to access the Azure DevOps service and the Azure website.
Application rule as been added to the firewall policy

Add a network rule

In the rule blade, select Network rules and then Add a network collection.
Configure the network rule and then select Add.
Name: app-vnet-fw-nrc-dns
Rule collection type: Network
Priority: 200
Rule collection action: Allow
Rule collection group: DefaultNetworkRuleCollectionGroup
Rule: AllowDns
Source: 10.1.0.0/23
Protocol: UDP
Destination ports: 53
Destination addresses: 1.1.1.1, 1.0.0.1
Network collection rule as been added to the firewall policy
Verify the firewall and firewall policy status
In the portal search for and select Firewall.
View the app-vnet-firewall and ensure the Provisioning state is Succeeded. This may take a few minutes.
In the portal search for and select Firewall policies.
View the fw-policy and ensure the Provisioning state is Succeeded. This may take a few minutes

Conclusion
This project successfully delivered a fully operational Azure Firewall within the application’s virtual network, establishing a centralized and resilient security architecture. Key milestones included:

Deploying Azure Firewall to serve as the core security layer.
Configuring and managing a custom firewall policy.
Creating an application rule collection to enable secure access to Azure DevOps services.
Implementing a network rule collection to support DNS resolution.

Together, these components strengthen the application's security posture by precisely controlling traffic flow while maintaining essential connectivity. The solution also lays the groundwork for a scalable and maintainable security framework that can adapt to future growth and evolving requirements. Ultimately, this project highlights the strategic role of Azure Firewall in delivering advanced threat protection and centralized network governance in modern cloud environments.

How to Create and Configure Network Security Groups in Azure

Oluwanifesimi — Fri, 10 Oct 2025 19:17:12 +0000

Introduction
In today’s cloud-first environments, securing and managing network traffic is essential for protecting workloads and maintaining optimal application performance. Azure Network Security Groups (NSGs) serve as virtual firewalls, enabling administrators to control inbound and outbound traffic to Azure resources. When paired with Application Security Groups (ASGs), access policies become easier to manage by grouping similar resources and applying consistent rules across them.

Objectives

Create a network security group.
Create network security group rules.
Associate a network security group to a subnet.
Create and use application security groups in network security group rules.
Create a Network Security Group (NSG)
Provision an NSG that can be associated with the backend subnet of the app-vnet.
Create Network Security Group Rules
Define inbound and outbound rules to control traffic flow between the frontend and backend resources.
Associate a Network Security Group to a Subnet
Link the NSG to the backend subnet in the app-vnet to secure database server access.
Create and Use Application Security Groups (ASGs)
Create an ASG (app-frontend-asg) for web servers in the frontend subnet.
Associate the ASG with VM1’s network interface.
Use the ASG in NSG rules to simplify traffic management.
Deploy and Test Virtual Machines
Deploy VM1 in the frontend subnet and VM2 in the backend subnet using the provided ARM template.
Verify traffic control using the configured NSG and ASG rules.

Step 1 Create the network infrastructure for the exercise

Use the icon (top right) to launch a Cloud Shell session.
Use these commands to deploy the virtual machines required for this exercise. copy and paste the command on the cloudshell.

New-AzResourceGroupDeployment -ResourceGroupName RG1 -TemplateUri
https://raw.githubusercontent.com/MicrosoftLearning/Configure-secure-access-to-workloads-with-Azure-virtual-networking-services/main/Instructions/Labs/azuredeploy.json

In the portal search for and select virtual machines.

Verify both vm1 and vm2 are Running.

Step 2 Create Application Security Group

Application security groups (ASGs) let you group together servers with similar functions. For example, all the web servers hosting your application.

In the portal, search for and select Application security groups.

Select + Create
Configure the application security group.
Property Value
Subscription Select your subscription
Resource group RG1
Name app-frontend-asg
Region East US 2
Select Review + create
Then select Create.
The application security group as been created successfully

Step 3 Associate the application security group to the network interface of the VM

In the Azure portal, search and select Virtual Machine.
Select LinuxVM1.
In the Networking blade, select Application security groups and then select Add application security groups.
Select the app-frontend-asg and then select Add.
Application security group as been added to VM1

Step 4 Create and Associate the Network Security Group

Network security groups (NSGs) secure network traffic in a virtual network.

In the portal search for and select Network security group.
Select + Create.
Configure the network security group.
Property Value
Subscription Select your subscription
Resource group RG1
Name app-vnet-nsg
Region East US 2
Select Review + create
Then select Create.
The network security group as been created successfully

Step 5 Associate the NSG with the app-vnet backend subnet.

NSGs can be associated with subnets and/or individual network interfaces attached to Azure virtual machines.

Select Go to resource or navigate to the app-vnet-nsg resource.
In the Settings blade select Subnets.
Select + Associate
Select app-vnet (RG1) and then the Backend subnet. Select OK.
Backend submit as been associated to the network security group

Step 6 Create Network Security Group rules

An NSG use security rules to filter inbound and outbound network traffic.

In the search box at the top of the portal, enter Network security groups. Select Network security groups in the search results.
Select app-vnet-nsg from the list of network security groups
In the Settings blade, select Inbound security rules.
Select + Add and configure an inbound security rule.
Source: Any
Source port ranges: *
Destination: Application Security group
Destination application security group app-frontend-asg
Service SSH
Action: Allow
Priority: 100
Name: AllowSSH

Network security group rule as been created

Conclusion
Through this exercise, you've gained practical experience in implementing network security within Azure. You’ve successfully:

Configured a Network Security Group (NSG) to manage and filter traffic.

Created and linked an Application Security Group (ASG) to frontend virtual machines for streamlined policy control.

Deployed virtual machines across segmented subnets to validate secure communication.

Applied custom NSG rules to enable secure SSH access from frontend to backend resources.

This project highlights the power of NSGs and ASGs working in tandem to deliver fine-grained control over network traffic. With these skills, you're now equipped to design secure, scalable, and well-managed cloud environments that protect workloads and simplify access across Azure infrastructure.

How to Create and Configure Virtual Networks in Azure

Oluwanifesimi — Fri, 10 Oct 2025 10:46:14 +0000

Introduction
Azure Virtual Network (VNet) provides a secure and scalable environment for Azure resources to communicate—whether it's with each other, external networks, or on-premises infrastructure. Within a VNet, resources are organized into subnets, allowing for structured and efficient network segmentation.

In this project, you'll gain hands-on experience with key networking tasks, including:

*Creating a Resource Group *– The foundational container for managing related Azure resources.
Setting Up a Virtual Network and Subnets – Establishing the core network structure to host your services.
Configuring a Secondary VNet with a Firewall Subnet – Enhancing security through network isolation and traffic control.
Establishing VNet Peering – Enabling seamless communication between two virtual networks.

By the end, you'll have a solid grasp of how to architect secure and interconnected environments in Azure.

Step 1: Create a Resource Group

Sign in to the Azure Portal
In the search bar, search for Resource groups
Select + Create.
Enter the following properties:
Property Value
Resource group RG1
Region East US
Click Review + create and then Create.
Then Create.

Step 2 Create hub and spoke virtual networks and subnets

An Azure virtual network enables many types of Azure resources to securely communicate with each other, the internet, and on-premises networks. All Azure resources in a virtual network are deployed into subnets within the virtual network.

In the Azure portal, Search for and select Virtual Networks.
Create and complete the configuration of the app-vnet. This virtual network requires two subnets, frontend and backend.
Select + Create
In the Basics tab, enter the following information:
Select “Review + create"
Property Value
Subscription Select your subscription
Resource group RG1
Name app-vnet
Region East US
Then Create.
Click on go to resources button

Step 3: Configure IP Address Space

Under settings, Select Address Space
In the IP Addresses tab, set the following:
IPv4 address space: 10.1.0.0/16 and Click on save button. This address space will allow multiple subnets within the virtual network.

Step 4: Create Subnets

Still in the IP Addresses tab, add two subnets:
Subnet name Address range
frontend 10.1.0.0/24
backend 10.1.1.0/24
Leave other settings as defaults.

For Frontend subnet

Under settings, Select Subnet
Select + Subnet
Give subnet a name frontend, enter starting address 10.1.0.0, enter size /24 and Click on Add.

For backend subnet

Under settings, Select Subnet
Select + Subnet
Give subnet a name backend, enter starting address 10.1.1.0, enter size /24 and Click on Add.
Frontend and the Backend Subnet as been created successfully

Step 5: Create the Hub-VNet Virtual Network

Create another virtual network called hub-vnet.
In the Azure portal, Search for and select Virtual Networks.
Select + Create
Enter the following properties:
Property Value
Resource group RG1
Virtual network name hub-vnet
Region East US
Select Review + create

Then Create.
Click on go to resources button

Step 6 Configure IP Address Space for the firewall subnet

Under settings, Select Address Space
In the IP Addresses tab, set the following:
IPv4 address space: 10.0.0.0/16 and Click on save button. This address space will allow multiple subnets within the virtual network.

Step 7 Create firewall subnet

Under settings, Select Subnet
Select + Subnet
Select subnet purpose azure, enter starting address 10.0.0.0, enter size /26 and Click on Add.
The Firewall subnet as been created successfully

Step 8 Configure a peer relationship between the virtual networks

Search for and select the app-vnet virtual network.
In the Settings blade, select Peerings.
- Add a peering between the two virtual networks.
Complete the following Configurations.
Remote peering link name: app-vnet-to-hub
Virtual network: hub-vnet
Local virtual network peering link name: hub-to-app-vnet
Note: Leave all other settings as their defaults. Select “Add” to create the virtual network peering.
Once the deployment completes, verify the Peering status is Connected.

Conclusion
By completing this project, you've built a solid foundation in cloud networking—gaining practical skills in designing and configuring Azure Virtual Networks. From creating VNets and organizing them into subnets to enabling seamless communication through VNet peering, you've tackled essential components of cloud infrastructure. These capabilities not only strengthen your technical proficiency but also pave the way for more advanced scenarios, such as implementing network security groups, deploying VPN gateways, and integrating hybrid connectivity solutions. Mastering virtual networking is a key milestone on the path to becoming a confident and capable cloud architect.

How to Configure monitoring for compute services

Oluwanifesimi — Fri, 10 Oct 2025 07:25:29 +0000

Introduction
In today’s cloud-driven world, monitoring compute services is essential for maintaining performance, availability, and reliability. As businesses increasingly depend on virtual machines and cloud-native applications, having a proactive monitoring strategy becomes non-negotiable. It’s not just about collecting data—it’s about gaining real-time insights, spotting anomalies early, and minimizing downtime before it impacts users or operations.

This project focuses on building a robust monitoring framework for Azure compute services. By configuring data collection and analysis tools, we aim to improve visibility, streamline troubleshooting, and empower smarter decision-making.

Objectives
To achieve this, we’ll walk through the following key tasks:

Set up a Data Collection Endpoint
Create a Data Collection Rule
Add IIS Log Collection to an existing rule
Configure Network Connection Monitor for a Linux IaaS VM

Together, these steps lay the foundation for a scalable and intelligent monitoring system.

Step 1: Create a Data Collection Endpoint
Think of this as installing a mailbox for your telemetry. Without it, logs and performance data stay locked inside individual VMs. With it, everything gets routed to a central hub—like Azure Monitor or Log Analytics—where you can actually analyze and act on the information.

Real-World Scenario
Imagine you’re running several virtual machines. One of them crashes unexpectedly. If you haven’t set up a data collection endpoint, you might not even know it happened until users complain. But with the endpoint in place, the crash logs are automatically sent to your monitoring dashboard—giving you the visibility to respond quickly.

Example: A Windows VM restarts due to a system failure. Thanks to the data collection endpoint, the event is logged and surfaced in Azure Monitor, allowing your team to investigate and resolve the issue before it escalates.

In the Azure Portal Search Bar, enter Monitor and select Monitor from the list of results.
In the Monitor page, under Settings, choose Data Collection Endpoints.
On the Data Collection Endpoints page, choose Create.
On the Create Data Collection Endpoint page, provide the following settings and then choose Review + Create.
Property Value
Endpoint name IaaSVMCollectionEndpoint
Subscription Your subscription
Resource Group NK_RG
Region Canada Central
Review the settings and choose Create.

** Step 2 Create a data collection rule**

What it does:
The rule decides what kind of data should be collected and where it should go.

Real-life example:
You configure a rule to collect Windows Event Logs from your VMs. These logs capture:

Failed login attempts (security threats )
Service crashes (like SQL Server suddenly stopping)
System warnings (like low memory alerts)

Example: If someone tries to brute-force passwords on your VM, the Windows Security log will show repeated failed login attempts. With a collection rule in place, you’ll spot this early and block the attacker.

In the Azure Portal Search Bar, enter Monitor and select Monitor from the list of results.
In the Monitor page, under Settings, choose Data Collection Rules.
On the Data Collection Rules page, choose Create.
On the Create Data Collection Rule page, configure the following settings and choose Next.
Property Value
Rule name WinVMDCR
Subscription Your subscription
Resource Group NK_RG
Region Canada Central
Platform type Windows
Data collection endpoint IaaSVMCollectionEndpoint
On the Resources page, choose Add Resources.
On the Select a scope page, enable the DynamicVM checkbox and choose Apply.
On the Create Data Collection Rule page, choose Next.
On the Collect and Deliver page, choose Add data source.
On the Add data source page, select Windows Event Logs.
In the Application category enable the Critical and Error categories.
In the Security category, choose the Audit Failure category.
In the System category, enable the Critical and Error categories.
Choose Next.
On the Destination page, configure the following settings:

Property Value
Destination type Azure Monitor Logs
Subscription Your subscription
Account or namespace NKlogAnalytic
Choose Add data source.
Choose Review + Create and then choose Create.

Data Collection rules is created successfully

step 3 Add an IIS log collection to an existing data collection rule

What it does:
Captures web server activity logs (IIS).
Real-life example:
Your web app hosted on IIS starts running slow. By looking at IIS logs, you can see:

Which pages are taking too long to load
If users are getting “500 Internal Server Error"
If there’s unusual traffic (like a sudden spike that might be a DDoS attack)
Example: IIS logs reveal that a particular API endpoint /login is throwing 500 errors frequently. This helps developers fix the bug quickly.

In the Azure Portal Search Bar, enter Monitor and select Monitor from the list of results.

In the Monitor page, under Settings, choose Data Collection Rules.
Choose the WinVMDRC rule in NK_RG.
Under Configuration, choose Data Sources.
On the Data Sources page, choose Add.
On the Add Data Source page, select IIS Logs.
Choose Next.

On the Destination page, configure the following settings:

Property Value
Destination type Azure Monitor Logs
Subscription Your subscription
Account or namespace NKLogworkspaceanalytic
Choose Add data source.
IIS log as been added to the data collection rule.

Step 4 Configure Network Connection Monitor for a windows/linux IaaS virtual machine

What it does:
Checks if your VM’s network connections are healthy and reliable.

Real-life example:
If your VM hosts a database, applications must always reach it quickly. The monitor will alert you if:

The connection is dropping packets
Latency (delay) is too high
The VM is unreachable from certain regions
Example: A user in Europe complains your app is slow. Network Connection Monitor shows high latency between your Windows/Linux VM (in West US) and Europe, confirming it’s a network issue, not the app itself.

In the Azure Portal Search Bar, enter Network Watcher and select Network Watcher from the list of results.

Under Monitoring, choose Connection Monitor.
On the Connection Monitor page, choose Create.

On the Basics page of the Create Connection Monitor wizard, provide the following information and choose Next.

Property Value
Connection Monitor name DynamicNetMonitor
Subscription Your subscription
Region Canada Central
Workspace NKLogworkspaceanalytic
On the Add test group details page, enter the name LinuxIPTest and choose Add sources.

On the Add Sources page, select Azure Endpoints and set the type to Virtual machines. Select Subnet and then enable the DynamicLinuxVm checkbox. Choose Add Endpoints.

Choose Add Test Configuration.
On the Add Test Configuration page, enter the name DefaultHTTP and then choose Add Test Configuration.
Choose Add Destinations.
Select Azure Endpoints and set the type to Virtual machines. Select Subnet and then enable the DynamicLinuxVm checkbox. Select Add Endpoints.
Choose Add Test Group.
Choose Review and Create then choose Create.
Then choose Create.
Connection Monitor is created successfully

Conclusion
This project showcases a comprehensive approach to monitoring compute services through structured data collection and analysis. By establishing a robust data collection endpoint, defining monitoring rules, incorporating IIS log tracking, and deploying a Network Connection Monitor for Linux-based IaaS, we have developed a dependable solution that enhances operational transparency. These capabilities empower administrators with real-time visibility into system performance and security, enabling swift issue detection and resolution. Ultimately, the project underscores the critical role of proactive monitoring in maintaining stability, optimizing performance, and ensuring user satisfaction within modern cloud infrastructures.

How to Configure Alert in Azure

Oluwanifesimi — Thu, 09 Oct 2025 12:45:10 +0000

Introduction
In cloud-based systems, keeping resources healthy and responsive is essential. Azure Alerts offer a smart way to stay ahead of performance issues by continuously monitoring workloads and notifying you when something needs attention. With the right alert configuration, your team can react swiftly to potential disruptions—minimizing downtime and maximizing efficiency.

This guide walks you through configuring alerts for Azure compute services, with a focus on tracking virtual machine (VM) performance and ensuring notifications reach the right people at the right time.

Project Goals
Here’s what we aim to achieve:

Set up an action group that sends email notifications when alerts are triggered.
Create a performance alert for VM CPU usage to monitor system health in real time.

Step 1: Create an Action Group for Email Notifications
Think of this as assigning your cloud emergency contacts. When Azure detects a problem, it automatically sends an email to the designated recipients—so they can jump in and fix things fast.

Setting up an action group ensures that alerts don’t just sit in a dashboard—they reach the people who can act on them.

In the Azure Portal Search Bar, enter Monitor and select Monitor from the list of results.
Select Alerts in the navigation menu.
Choose Action Groups.
On the Action Groups page, choose Create.
On the Basics page of the Create Action Group wizard, configure the following settings and choose Next.
Property Value
Subscription Your subscription
Resource Group NK_RG
Region Global
Action group name NotifyCPU
Display Name NotifyCPU
On the Notifications page, set the notification type to Email/SMS message/Push/Voice and the Name to NotificationEmail. Choose the Edit (pencil) icon.
On the Email/SMS message/Push/Voice enable the email checkbox and enter the address koladeadeyemo99@gmail.com. Choose OK.
Choose Review and Create. Choose Create.
Choose Create.
Action group as been successfully created
Notification email sent to the person added under the action group

Step 2 Create an alert for virtual machine CPU utilization

This means: “Tell Azure to watch the computer’s brain (CPU).”
If the CPU is working too hard (too much usage), Azure will raise a flag and send the alert to the action group (the people you set up in Task 1). This helps you know early when your virtual machine is struggling, so you can fix it before it crashes or slows down.

In the Azure Portal Search Bar, enter Resource Group select NK_RG from the list of results.
Select NK_RG from the list of results.
From the list of items in the resource group, choose DynamicVm.
On the DynamicVm properties page, choose Alerts under Monitoring.
On the Alerts page, choose Create and then choose Alert rule.

On the Condition page of the Create an Alert Rule wizard, set the Signal name to Percentage CPU. Use the default settings and choose Next.
On the Actions page, choose Select Action Group.
On the Select Action Groups page, choose NotifyCPU and choose Select.
On the Details page enter the Alert rule name HighCPU. Choose Review and Create. choose Create.
Choose Create
Alert rule as been created successfully

Conclusion
This project showcased how to effectively set up alerts in Microsoft Azure to strengthen your system’s monitoring and response strategy. By creating an action group, we ensured that key team members are promptly notified when issues arise. Configuring a CPU utilization alert provided real-time visibility into virtual machine performance, helping to detect and address bottlenecks before they escalate.

Ultimately, this approach reinforces the value of proactive monitoring—keeping systems reliable, minimizing downtime, and supporting seamless business operations.

How to create a Web app using Azure App service.

Oluwanifesimi — Wed, 03 Sep 2025 14:10:22 +0000

In today’s rapidly evolving digital world, developers and businesses need agile, scalable, and cost-efficient ways to bring their applications to life. Enter Microsoft Azure App Service—a fully managed platform that streamlines the entire web app lifecycle. From building and deploying to scaling and maintaining, Azure App Service takes the complexity out of infrastructure so you can focus on writing great code.

Supporting a wide range of programming languages, integrating effortlessly with popular development tools, and offering built-in DevOps workflows, Azure App Service empowers developers to go from local development to global deployment with ease. In this guide, we’ll walk through the step-by-step process of creating a web app using Azure App Service, giving you both practical insights and hands-on experience in modern cloud development.

Step 1: Sign in to Azure Portal

Step 2: Create the a resource group

In the Azure Portal, search resource group and select resource group.
Click + Create.
Select subscription, Give your resource group a name WebAppRG, and select a region, click review + create
Click create to create your resource group

Step 3: Create the Web App

In the Azure Portal, search App Services and select it.
Click + Create, under the drop-down select Web App
Under the basic tab, select the resource group created in step 2 (WebAppRG).
Give your Web App a name RentalWebApp
Under publish select code
Choose your runtime stack .NET 9 STS
Select Operating System (Windows)
select your desired region.
Create your own App service plan by clicking (create new) and name it Rentalwebplan, Click Ok. and Review + create.
Click Create
After Deployment Click on go to resources to see the Web App
Under Development tools select Advance tools and click on go
You will be asked to sign in again into your azure account, select your azure account to sign in or it might go directly to the web page
Once sign in, you will be redicted to the advance tool web page.
Select Debug Console and Click on CMD
Click on sites
Click on wwwroot.
Click on the Edit pencil to edit the default template code or clear the default template code.
Clear the default code.
Copy and Paste your RentalWebApp code and save

-Navigate back to your App service and Select your Web App

Copy the Default domain
paste default domain in a web browser to see your RentalwebApp running.

Conclusion
Building a web app with Azure App Service isn’t just a technical task—it’s a gateway to delivering fast, secure, and scalable experiences to users across the globe. From initial setup to live deployment, Azure strips away the infrastructure hassle and lets developers zero in on what matters most: creating impactful solutions.
By walking through this guide, you’ve laid the groundwork for confidently launching, managing, and growing cloud-based applications. Whether you're just dipping your toes into cloud development or refining your workflow as a seasoned pro, Azure App Service equips you with the flexibility and power to bring your ideas to life—quickly and reliably.
Keep exploring, keep building, and let the cloud work for you.

Custom VM Image Creation and Deployment Using Azure Compute Gallery and Virtual Machine Scale Sets

Oluwanifesimi — Fri, 22 Aug 2025 16:59:29 +0000

Introduction

This will guide you through the steps to build a reusable image from an Azure Virtual Machine (VM) and save it in an Azure Compute Gallery (previously called Shared Image Gallery). By doing this, you can replicate VM setups and launch multiple identical VMs quickly and consistently.

Here's what we'll cover:

Setting up an Azure Compute Gallery
Capturing a VM image from an existing virtual machine
Uploading and storing the image in the gallery
Using the custom image to deploy a Virtual Machine Scale Set (VMSS)

Step 1:Setting up an Azure Compute Gallery
An Azure Compute Gallery (formerly Shared Image Gallery) image is a managed resource that stores and organizes custom VM images in Azure

In the search bar, type "Azure Compute Galleries" and select it
Click + Create
Fill in the details:
Subscription: Select your subscription
Resource group: Select existing or create new
Name: Enter a name (e.g., "AlphaGallery")
Region: Select a region (e.g., West US)
Click Review + create,
Then Create
Click on go to resources to see the created gallery.
Compute Gallery is created successfully (AlphaGallery)

Step 2: Create a VM Image from an Existing VM
Creating a vm image means you want to create a replica of the original image with the same configuration and settings.

In the search bar, type "Virtual Machine" and select it
Select the existing Virtual Machine
click Capture drop down and select image.
In the "Create image" blade:
Select resource group (AlphaRG)
Choose Operating system state (I picked specialised because i dont want the users of the image to login into the vm with any credentials) Generalised requires Login Access.
Create new Target Vm image definition
Give the target vm image definition a name (AlphaImageDefinition)
Click OK
set version number to 0.0.1
Click Create + review
Click create
Click go to resources to see your image

Step 3: Deploy a VM Scale Set from the Custom Image
A Virtual Machine Scale Set (VMSS) is an Azure service that allows the automatic deployment and scaling of identical VMs based on demand.

In the search bar, type "Azure Compute Galleries" and select it
Select your gallery (AlphaGallery)
Select your image (AlphaImageDefinition)
Click on + Create VMSS to create a virtual machine scale set.
Select resource group (NK_RG)
Give your Virtual Machine scale set a name (Alphascaleset)
Select availability zone (zone 1)
Ocherstration mode is set to uniform
Scaling mode is set to manual
Instant count is set to 3 (set based on your preference
Select AlphaImageDefinition for the image
The administration account is grade-out because we select specialised mode when creating the image.
Click review + create
Click Create
Click on go to resources to view your deployed virtual machine scale set
Three instance of Virtual machine scale set as been created succesfully
Click on status to view the Three vmss

Conclusion
This project successfully demonstrated the creation of a reusable image from an Azure Virtual Machine and its integration into an Azure Compute Gallery. The image was then deployed through a Virtual Machine Scale Set, enabling consistent replication of VM configurations across multiple instances. This approach enhances scalability, simplifies infrastructure management, and ensures uniformity in deployment environments. The outcome validates the effectiveness of Azure Compute Gallery in streamlining VM provisioning for enterprise-grade solutions.