DEV Community: olakunle makanjuola

From Terraform Code to a Real Azure VM: Building a Secure Azure Infrastructure with Terraform

olakunle makanjuola — Thu, 24 Sep 2026 13:28:53 +0000

Introduction

Infrastructure as Code (IaC) has changed the way modern cloud infrastructure is designed, deployed, and managed.

Instead of manually logging into the Azure Portal, clicking through multiple screens, creating a virtual network, configuring a subnet, creating a public IP, setting up a Network Security Group, creating a network interface, and finally deploying a virtual machine, Terraform allows us to describe the infrastructure in code and provision it automatically.

In this project, I wanted to move beyond simply learning Terraform commands and actually use Terraform to build a real Azure infrastructure.

The goal was to provision an Azure environment containing:

An Azure Resource Group
A Virtual Network (VNet)
A Subnet
A Public IP address
A Network Security Group (NSG)
A Network Interface Card (NIC)
An NSG-to-NIC association
An Ubuntu Linux Virtual Machine
SSH key-based authentication

At the end of the project, I successfully deployed a real Ubuntu 22.04 virtual machine inside an Azure Virtual Network, protected it with an NSG, assigned it a public IP address, and successfully connected to it remotely using SSH.

This article documents the entire process, including the errors I encountered along the way, what caused them, and how I resolved them.

Project Objectives

The main objectives of this project were to:

Learn how to provision Azure infrastructure using Terraform.
Understand how Terraform resources depend on one another.
Create an Azure Virtual Network and subnet.
Configure a Network Security Group to control inbound traffic.
Create a public IP address for the virtual machine.
Create and configure a Network Interface.
Associate the NSG with the NIC.
Provision an Ubuntu Linux VM using Terraform.
Configure SSH key-based authentication.
Connect to the provisioned VM remotely through SSH.
Understand the relationship between Azure networking components.
Troubleshoot real Terraform, Azure, and SSH errors.

Tools Used And Deployed

The project was built using:

Microsoft Azure
Terraform
AzureRM Terraform Provider
Ubuntu 22.04 LTS
Git Bash
SSH
Azure Virtual Network
Network Security Group
Azure Public IP
Azure Network Interface

My Terraform environment was running on Windows using Git Bash.

Terraform was used as the Infrastructure as Code tool, while Azure provided the actual cloud infrastructure.

Understanding the Architecture
Before writing the Terraform configuration, it was important to understand how the Azure resources would connect to each other.

The architecture was:

                     INTERNET
                        │
                        │
                 Public IP Address
                  4.221.66.140
                        │
                        ▼
                ┌───────────────┐
                │      NIC      │
                │ flackern-nic  │
                └───────┬───────┘
                        │
                 NSG Association
                        │
                        ▼
                ┌───────────────┐
                │      NSG      │
                │ flackern-nsg  │
                │               │
                │ TCP/22 Allow  │
                └───────────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │     Azure VM        │
             │    flackern-vm      │
             │                     │
             │    Ubuntu 22.04     │
             │    azureuser        │
             └──────────┬──────────┘
                        │
                        │
                 Inside Subnet
                        │
                        ▼
              ┌───────────────────┐
              │ flackern-subnet   │
              │   10.0.1.0/24     │
              └─────────┬─────────┘
                        │
                        ▼
              ┌───────────────────┐
              │  flackern-vnet    │
              │   10.0.0.0/16     │
              └───────────────────┘

The important traffic flow is:

Internet
↓
Public IP
↓
Network Interface
↓
Network Security Group
↓
Virtual Machine
The NSG controls whether network traffic is allowed to reach the VM.

In this project, TCP port 22 was opened for SSH access.

Step 1 — Creating the Terraform Configuration

I started by defining the Terraform and AzureRM provider configuration.

terraform {
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 5.5.0"
}
}
}

provider "azurerm" {
features {}

subscription_id = "YOUR-SUBSCRIPTION-ID"
}

For security reasons, I have replaced my actual subscription ID in this article.

The AzureRM provider allows Terraform to communicate with Microsoft Azure and create Azure resources.

Step 2 — Creating the Resource Group

The first Azure resource I created was the Resource Group.

resource "azurerm_resource_group" "flackern-rg" {
name = "flackern-rg"
location = "south Africa North"
}

The Resource Group provides a logical container for the Azure resources used in the project.

Step 3 — Creating the Virtual Network
Next, I created the Virtual Network.

resource "azurerm_virtual_network" "flackern-vnet" {
name = "flackern-vnet"
location = azurerm_resource_group.flackern-rg.location
resource_group_name = azurerm_resource_group.flackern-rg.name
address_space = ["10.0.0.0/16"]
}
The VNet uses:

10.0.0.0/16
This provides the private network address space for the infrastructure.

Step 4 — Creating the Subnet

Inside the Virtual Network, I created a subnet.

resource "azurerm_subnet" "flackern-subnet" {
name = "flackern-subnet"
resource_group_name = azurerm_resource_group.flackern-rg.name
virtual_network_name = azurerm_virtual_network.flackern-vnet.name
address_prefixes = ["10.0.1.0/24"]
}

The subnet uses:

10.0.1.0/24

Step 5 — Creating the Public IP

The VM needed a public IP so that I could connect to it remotely from my computer.

resource "azurerm_public_ip" "flackern-ip" {
name = "flackern-ip"
resource_group_name = azurerm_resource_group.flackern-rg.name
location = azurerm_resource_group.flackern-rg.location
allocation_method = "Static"
sku = "Standard"
}

Azure eventually assigned:

4.221.66.140

to the VM.

Step 6 — Creating the Network Security Group

Next, I created the Network Security Group.

resource "azurerm_network_security_group" "flackern-nsg" {
name = "flackern-nsg"
location = azurerm_resource_group.flackern-rg.location
resource_group_name = azurerm_resource_group.flackern-rg.name

security_rule {
name = "Allow-SSH"
priority = 100
direction = "Inbound"
access = "Allow"
protocol = "Tcp"
source_port_range = ""
destination_port_range = "22"
source_address_prefix = ""
destination_address_prefix = "*"
}
}

The important part is:

destination_port_range = "22"

Port 22 is the standard SSH port.

This rule allows inbound TCP traffic on port 22.

Step 7 — Creating the Network Interface

The VM needs a network interface to communicate with the Azure network.

I created the NIC with:

resource "azurerm_network_interface" "flackern-nic" {
name = "flackern-nic"
location = azurerm_resource_group.flackern-rg.location
resource_group_name = azurerm_resource_group.flackern-rg.name

ip_configuration {
name = "flackern-ipconfig"
subnet_id = azurerm_subnet.flackern-subnet.id
private_ip_address_allocation = "Dynamic"
public_ip_address_id = azurerm_public_ip.flackern-ip.id
}
}

The NIC connects the VM to the subnet.

The relationship is:

VNet
↓
Subnet
↓
NIC
↓
VM

The NIC also connects the VM to the public IP.

Step 8 — Associating the NSG with the NIC

Creating an NSG does not automatically mean that the VM's NIC is associated with it.

I explicitly created the association:

resource "azurerm_network_interface_security_group_association" "flackern-nic-nsg" {
network_interface_id = azurerm_network_interface.flackern-nic.id
network_security_group_id = azurerm_network_security_group.flackern-nsg.id
}

This connects:

NSG
↓
NIC
↓
VM

Therefore, the SSH rule in the NSG can control traffic reaching the VM through its network interface.

Step 9 — Creating the SSH Key Pair

For secure access to the Linux VM, I generated an SSH key pair.

From Git Bash:

ssh-keygen -t ed25519 -C "terraform-azure-vm"

This produced two files:

terraform-azure
terraform-azure.pub

The difference is important.

Private key
terraform-azure

This stays on my computer and must be kept secret.

Public key
terraform-azure.pub

This can be installed on the Azure VM.

I verified the files with:

ls -la ~/.ssh

The result included:

terraform-azure
terraform-azure.pub

Step 10 — Configuring the Linux VM

I then created the Ubuntu VM.

resource "azurerm_linux_virtual_machine" "flackern-vm" {
name = "flackern-vm"
resource_group_name = azurerm_resource_group.flackern-rg.name
location = azurerm_resource_group.flackern-rg.location
size = "Standard_B2ats_v2"
admin_username = "azureuser"

network_interface_ids = [
azurerm_network_interface.flackern-nic.id,
]

admin_ssh_key {
username = "azureuser"
public_key = file("~/.ssh/terraform-azure.pub")
}

os_disk {
caching = "ReadWrite"
storage_account_type = "Standard_LRS"
}

source_image_reference {
publisher = "Canonical"
offer = "0001-com-ubuntu-server-jammy"
sku = "22_04-lts"
version = "latest"
}
}

The VM uses Ubuntu 22.04 LTS.

The administrator username is:

azureuser

The VM receives the public SSH key generated earlier.

Step 11 — Creating the VM Public IP Output

To make it easy to retrieve the public IP after deployment, I added an output:

output "vm_public_ip" {
value = azurerm_public_ip.flackern-ip.ip_address
}

After running Terraform, the output was:

vm_public_ip = "4.221.66.140"

This made it easy to connect to the VM.

*Step 12 — Running Terraform
*
Once the configuration was ready, I initialized Terraform:

terraform init

Then I formatted the configuration:

terraform fmt

Then I validated it:

terraform validate

Terraform returned:

Success! The configuration is valid.

I then generated the execution plan:

terraform plan

After reviewing the planned resources, I applied the configuration:

terraform apply

Terraform eventually returned:

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

This was the moment the infrastructure was actually provisioned in Azure.

Pictorial Diagram of Successful Resource Provision On Azure Portal Using Terraform

Log into https://portal.azure.com/ to confirm the successful creation of these resource

Step 13 — First SSH Connection Attempt

After Terraform successfully created the infrastructure, I attempted to connect to the VM:

ssh azureuser@4.221.66.140

I was prompted to verify the host:

The authenticity of host '4.221.66.140' can't be established.

Are you sure you want to continue connecting
(yes/no/[fingerprint])?

I entered:

yes

The server was then added to my local SSH known_hosts file.

However, the connection failed:

azureuser@4.221.66.140: Permission denied (publickey).

Step 14 — Successful SSH Connection

This time the connection succeeded.

I received the Ubuntu welcome message:

Welcome to Ubuntu 22.04.5 LTS

and eventually reached:

azureuser@flackern-vm:~$

This confirmed that I was now inside my Azure VM.

The VM reported its private IP as:

10.0.1.4

while the public IP was:

4.221.66.140

This demonstrated the difference between a VM's private network address and its public Internet-facing address.

SOME OF THE ERROR ENCOUNTERED IN THE COURSE OF CARRYING OUT THIS PROJECT

Error 1 — security_rule Unsupported Block Type

This was one of my first Terraform errors.

Initially, I accidentally placed the security_rule block outside the Network Security Group resource.

Terraform returned an error similar to:

Error: Unsupported block type

Blocks of type "security_rule" are not expected here.
What caused the problem?

The structure was effectively:

resource "azurerm_network_security_group" "flackern-nsg" {
...
}

security_rule {
...
}

Terraform interpreted security_rule as a standalone block.

But security_rule belongs inside the azurerm_network_security_group resource.

How I fixed it

I moved the entire block inside the NSG:

resource "azurerm_network_security_group" "flackern-nsg" {

...

This taught me an important Terraform lesson:

Terraform configuration is hierarchical. A block must be placed inside the resource that supports it.

Error 2 — Resource Name Mismatch

I also encountered errors caused by inconsistent Terraform resource labels.

At different points I had references such as:

flakern-rg

and:

flackern-rg

I had made a similar mistake with the NSG:

flakern-nsg

versus:

flackern-nsg

Terraform resource references must match the declared resource label exactly.

For example:

resource "azurerm_resource_group" "flackern-rg" {

must be referenced as:

azurerm_resource_group.flackern-rg.name

not:

azurerm_resource_group.flakern-rg.name
How I fixed it

I standardized the naming convention throughout the Terraform configuration:

flackern-rg
flackern-vnet
flackern-subnet
flackern-ip
flackern-nsg
flackern-nic
flackern-vm

After correcting the references, I ran:

terraform fmt

followed by:

terraform validate

Terraform eventually returned:

Success! The configuration is valid.

*Error 3 — Public IP Resource Reference Was Treated as a String
*
During terraform plan, I encountered another important error.

I initially wrote:

public_ip_address_id = "azurerm_public_ip.flackern-ip.id"

Terraform interpreted this as a literal string rather than a Terraform resource reference.

This caused an error involving the parsing of the Public IP resource ID.

Why?

Terraform distinguishes between strings and expressions.

This:

"azurerm_public_ip.flackern-ip.id"

means:

Treat this entire thing as text.

Whereas this:

azurerm_public_ip.flackern-ip.id

means:

Retrieve the ID of this Terraform resource.

The correction

I removed the quotation marks:

public_ip_address_id = azurerm_public_ip.flackern-ip.id

I then ran:

terraform fmt
terraform validate
terraform plan

The plan proceeded successfully.

This was an important lesson for me:

Terraform resource references should not be placed inside quotation marks.

Error 4 — SSH Permission Denied (publickey)

This was not a Terraform deployment failure.

The VM was running and reachable, but SSH authentication was failing.

The important distinction was:

Network connection: SUCCESS
SSH authentication: FAILED

The solution was to explicitly tell SSH which private key to use.

Instead of:

ssh azureuser@4.221.66.140

I used:

ssh -i ~/.ssh/terraform-azure azureuser@4.221.66.140

The difference is the:

-i

option.

It tells SSH which private identity file to use.

What I Learned From This Project

This project taught me much more than simply how to write Terraform syntax.

Infrastructure as Code

I learned that infrastructure can be described in code and deployed consistently rather than manually created through the Azure Portal.

For example:

resource "azurerm_virtual_network" "flackern-vnet" {
...
}

is not just configuration.

It represents an actual Azure resource that Terraform manages.

Terraform Dependencies

I also learned how Terraform understands relationships between resources.

For example:

Resource Group
↓
Virtual Network
↓
Subnet
↓
NIC
↓
VM

Terraform can determine the dependency relationships because resources reference one another.

Azure Networking

The project helped me understand the relationship between:

VNet
Subnet
NIC
Public IP
NSG
VM

Before building this project, these components could seem like separate Azure services.

Building the infrastructure made their relationship much clearer.

Network Security Groups

I learned that an NSG acts as a traffic filtering mechanism.

In this project, the NSG allowed:

Inbound TCP
Port 22

which enabled SSH access to the VM.

SSH Authentication

I also learned the practical difference between an SSH public key and private key.

Public key
↓
Azure VM

Private key
↓
My computer

The private key is used to prove that I am authorized to access the VM.

Troubleshooting Is Part of Engineering

Perhaps one of the most valuable lessons was that real-world infrastructure work does not always work on the first attempt.

I encountered:

Unsupported block type

then:

Resource reference/name mismatch

then:

Public IP ID parsing error

and finally:

Permission denied (publickey)

Each error provided an opportunity to understand what was actually happening rather than simply copying commands.

The Final Terraform Workflow

The workflow I followed can be summarized as:

Write Terraform Configuration
↓
terraform init
↓
terraform fmt
↓
terraform validate
↓
terraform plan
↓
terraform apply
↓
Azure Infrastructure Created
↓
Retrieve Public IP
↓
SSH into Ubuntu VM
↓
SUCCESS

This is a workflow I can now reuse for future Azure projects.

Conclusion

This project was an important step in my journey into Cloud and DevOps engineering.

I started with Terraform configuration and ended with a real Ubuntu server running inside Microsoft Azure.

More importantly, I learned that Infrastructure as Code is not simply about memorizing Terraform commands. It is about understanding infrastructure, dependencies, networking, security, authentication, automation, and troubleshooting.

The project also reinforced an important engineering principle:

When something fails, understand the error before trying to fix it.

Every error I encountered helped me understand Terraform and Azure more deeply.

This project started as a Terraform learning exercise, but it became something much more valuable: a practical demonstration of how Infrastructure as Code can turn source code into real cloud infrastructure.

One VM. One Virtual Network. One NSG. One public IP. All provisioned from code.

And this is only the beginning of my DevOps journey.

DevOps #Terraform #Azure #InfrastructureAsCode #CloudComputing #Linux #SSH #AzureVM #DevOpsJourney

From Local Files to GitHub: My First Git Push, the Error I Encountered, and How I Fixed It

olakunle makanjuola — Thu, 10 Sep 2026 18:41:39 +0000

As part of my journey into Cloud Computing and DevOps, I have been spending more time learning and practicing Git and GitHub.

In this practical exercise, I created several files locally using Git Bash, initialized a Git repository, committed the files, connected the local repository to GitHub, and pushed my work to a GitHub repository.

However, the process did not go completely smoothly. I encountered a non-fast-forward / fetch-first error when I tried to push my local repository to GitHub.

This article documents the complete process, including the error, why it happened, and how I resolved it.

What I Intend to Achieve

Objectives:

Create files in a local project folder.

Initialize Git.

Track the files with Git.

Commit the files.

Create a connection between the local repository and GitHub.

Push the local repository to GitHub.

Make additional changes.

Commit and push the changes again.

My working directory was:

C:/Users/HP/Documents/hagital-demo

My GitHub repository was:

https://github.com/Makansgreat/hagital-demo

Step 1: Navigate to the Project Directory

I started from my Git Bash terminal inside my project directory.

pwd

The result showed:

This confirmed that I was working inside the correct project folder.

Step 2: Create the Files

I created several files using the touch command:

touch devop.txt aps.pdf notes.txt name.docx admin.pdf mccons.py secrets.txt

This created the following files:
devop.txt
aps.pdf
notes.txt
name.docx
admin.pdf
mccons.py
secrets.txt

Step 3: Initialize the Git Repository

I ran:

git init

Git responded:

Initialized empty Git repository in C:/Users/HP/Documents/hagital-demo/.git/

Git created a hidden .git directory inside my project folder.

I then checked the status again:

git status

This time Git reported:

On branch master

No commits yet

Untracked files:
admin.pdf
aps.pdf
devop.txt
mccons.py
name.docx
notes.txt
secrets.txt

This meant Git could now see the files, but they were still untracked.

Step 4: Add the Files to the Staging Area

I used:

git add .

The . means "add all changes in the current directory."

I then checked the status:

git status

Git showed:

Changes to be committed:

    new file:   admin.pdf
    new file:   aps.pdf
    new file:   devop.txt
    new file:   mccons.py
    new file:   name.docx
    new file:   notes.txt
    new file:   secrets.txt

The files had now moved from untracked to staged.

Step 5: Create the First Commit

I committed the staged files with:

git commit -m "added couple of files"

Git returned:

[master (root-commit) 02e2324] added couple of files
7 files changed, 2 insertions(+)

I had now created my first local Git commit.

Step 6: Rename the Branch from master to main

Modern GitHub repositories commonly use main as the default branch.

My local branch was still called master, so I renamed it:

git branch -m main

My terminal prompt now showed:

(main)

This confirmed that I was working on the main branch.

Step 7: Connect the Local Repository to GitHub

I connected my local repository to my GitHub repository using:

git remote add origin https://github.com/Makansgreat/hagital-demo.git

I then verified the remote connection:

git remote -v

Git returned:

origin https://github.com/Makansgreat/hagital-demo.git (fetch)
origin https://github.com/Makansgreat/hagital-demo.git (push)

This confirmed that origin was pointing to my GitHub repository.

Step 8: Attempt to Push to GitHub
I tried to push my local main branch:

git push -u origin main
But Git rejected the push.

I received:

! [rejected] main -> main (fetch first)

error: failed to push some refs to
'https://github.com/Makansgreat/hagital-demo.git'

hint: Updates were rejected because the remote contains work
that I d0 not have locally.

The Problem
At first, this error was confusing.

I had already created my local commit, so why couldn't Git push it?

The reason was that the GitHub repository already contained a commit that my local repository did not have.

In my case, the GitHub repository already had an Initial commit.

Therefore, the histories looked roughly like this:

GitHub:

Initial commit
|
main
While my local repository had:

Local:

added couple of files
|
main
The two repositories had different histories.

Git did not want me to simply overwrite the history that already existed on GitHub.

Step 9: Pull the GitHub Changes Using Rebase
I then used:

git pull origin main --rebase
Git successfully downloaded the remote changes:

From https://github.com/Makansgreat/hagital-demo

branch main -> FETCH_HEAD

Successfully rebased and updated refs/heads/main.

What did --rebase do?
The --rebase option allowed Git to take my local commit and place it on top of the existing GitHub history.

Conceptually, the history changed from something like:

GitHub:
Initial commit

Local:
added couple of files
to:

Initial commit
|
added couple of files
Now the histories were properly connected.

Step 10: Push Again

After the successful rebase, I ran:

git push -u origin main

This time the push was successful:

To https://github.com/Makansgreat/hagital-demo.git
900f6a7..0ce22f5 main -> main

branch 'main' set up to track 'origin/main'.

The important part was:

branch 'main' set up to track 'origin/main'

This meant my local main branch was now tracking the GitHub main branch.

Step 13: Verify the Repository Status
I ran:

git status
Git responded:

On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
This was exactly what I wanted to see.

It meant:

My local branch was main.

My local branch was synchronized with GitHub.

There were no uncommitted changes.

The working tree was clean.

Step 11: Check the Commit History
I also checked the commit history:

git log --oneline --all --decorate -5
The result was:

0ce22f5 (HEAD -> main, origin/main, origin/HEAD) added couple of files
900f6a7 Initial commit

This confirmed that both commits were now part of the repository history.

The first commit was:

900f6a7 Initial commit
and my second commit was:

0ce22f5 added couple of files

Step 12: Make Additional Changes

After successfully pushing the files to GitHub, I made additional changes to some of the files.

Git then showed:

Changes not staged for commit:

    modified:   devop.txt
    modified:   mccons.py
    modified:   name.docx
    modified:   notes.txt

This meant Git detected that four previously tracked files had been modified.

Step 13: Stage the New Changes

I added the modified files to the staging area:

git add .

Then I checked the status:

git status

Git showed:

Changes to be committed:

    modified:   devop.txt
    modified:   mccons.py
    modified:   name.docx
    modified:   notes.txt

The changes were now staged and ready to commit.

Step 14: Commit the New Changes

I created another commit:

git commit -m "I added to some files"

Git responded:

[main afa7b13] I added to some files
4 files changed, 5 insertions(+), 2 deletions(-)

This created another commit in my Git history.

Step 15: Push the New Commit to GitHub

Finally, I pushed the new commit:

git push origin main

Git successfully uploaded the changes:

Enumerating objects: 9, done.
Counting objects: 100% (8/8), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (5/5), 536 bytes | 12.00 KiB/s, done.
Total 5 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)

To https://github.com/Makansgreat/hagital-demo.git
0ce22f5..afa7b13 main -> main

The push was successful.

The Complete Git Workflow
Looking back, the complete workflow I followed was:

1. Create files

touch devop.txt aps.pdf notes.txt name.docx admin.pdf mccons.py secrets.txt

2. Initialize Git

git init

3. Check status

git status

4. Stage files

git add .

5. Commit

git commit -m "added couple of files"

6. Rename branch

git branch -m main

7. Add GitHub remote

git remote add origin https://github.com/Makansgreat/hagital-demo.git

8. Verify remote

git remote -v

9. Push

git push -u origin main

10. Because the remote already had a commit,

pull and rebase

git pull origin main --rebase

11. Push again

git push -u origin main

12. Verify

git status

13. View commit history

git log --oneline --all --decorate -5

14. After making more changes

git add .

15. Commit the changes

git commit -m "I added to some files"

16. Push the changes

git push origin main

What I Learned From This Exercise

This exercise taught me several important Git concepts.

git init

Initializes a normal folder as a Git repository.

git init

git status

Shows the current state of the working directory.

git status

It helps identify:

Untracked files
Modified files
Staged changes
Uncommitted changes

git add

Moves changes into the staging area.

git add .

git commit

Creates a snapshot of the staged changes.

git commit -m "commit message"

git remote

Connects the local repository to a remote repository such as GitHub.

git remote add origin

git push

Uploads local commits to the remote repository.

git push origin main

git pull

Downloads changes from the remote repository and integrates them into the local repository.

git pull origin main

git pull --rebase

In my case, this was the command that solved the problem:

git pull origin main --rebase

It allowed me to integrate the existing GitHub history with my local commit history without creating an unnecessary merge commit.

The Important Lesson From My Error

The most important lesson I learned was that a GitHub repository and a local Git repository can have different histories.

When I received:

! [rejected] main -> main (fetch first)

I initially thought there was something wrong with my Git configuration.

There wasn't.

Git was protecting the existing history on GitHub.

The solution was to first retrieve the remote history:

git pull origin main --rebase

and then push my changes:

git push -u origin main

After that, future pushes became much simpler because my local main branch was tracking origin/main.

A Better Workflow for Future Projects

Going forward, when I create a local project and want to push it to GitHub, I need to be aware of whether the GitHub repository is completely empty.

If the GitHub repository already contains files such as a README or an initial commit, I should synchronize the repositories before pushing.

Final Thought
This may look like a small Git exercise, but it was valuable because I didn't just learn how to push files to GitHub—I encountered and resolved an actual Git version-control problem.

As I continue my Cloud and DevOps engineering journey, understanding Git is essential because Git is used extensively for source-code management, collaboration, CI/CD pipelines, infrastructure-as-code projects, and DevOps automation.

One error message such as:

rejected (non-fast-forward)
can initially be frustrating, but understanding why Git rejected the push makes the solution much easier to understand.

My key takeaway is:

Before pushing, make sure your local repository and remote repository are synchronized.

And when the remote has commits that the local repository doesn't have, one possible solution is:

git pull origin main --rebase
git push origin main
This exercise is another step forward in my journey from learning Git to applying Git as part of my Cloud and DevOps workflow.

Enterprise-Grade Static Website Hosting on Azure: Deploy, Secure with SSL, and Connect a Custom Domain

olakunle makanjuola — Wed, 12 Aug 2026 07:55:15 +0000

Project Overview

Introduction

Today more and more organizations are using serverless static website hosting in order to provide fast, secure and cost-efficient web experiences. Instead of having to maintain virtual machines or web servers, companies can store their HTML, CSS, JavaScript and media files directly in Azure Blob Storage, which in turn reduces their operational burden and at the same time improves scalability and reliability.

In order to offer users a professional experience, organizations generally set up a custom domain name (for example www.flackern.com) and secure their websites by using HTTPS together with an SSL/TLS certificate; this guarantees that communication between users and the website is encrypted and thus protects sensitive information while also enhancing trust.

For this end-to-end project we will create a fully production-ready solution by deploying a static website to Azure Storage, setting up Azure DNS, mapping a custom domain, enabling HTTPS using either Azure CDN or Azure Front Door, and then verifying secure access via a web browser.

When you are done going through this step by step guide, you will own a fully functional, secure, serverless website that is running on Microsoft Azure in accordance with enterprise best practices.

Project Objectives

By completing this project, you will learn how to:

Create an Azure Storage Account
Enable Static Website Hosting
Upload website files
Configure Azure DNS
Purchase or use an existing domain
Map a custom domain
Enable HTTPS (SSL/TLS)
Validate website accessibility
Understand enterprise serverless architecture

Prerequisites

_Before starting, ensure you have:
_
An active Azure subscription
Owner or Contributor permissions
A registered domain name
A static website (HTML, CSS, JavaScript)
Azure Portal access
Visual Studio Code (optional for editing files)
Basic knowledge of DNS and web hosting

                Deployment Workflow

                Create Resource Group
                       │
                       ▼
             Create Storage Account
                       │
                       ▼
           Enable Static Website Hosting
                       │
                       ▼
            Upload Website Files
                       │
                       ▼
            Test Azure Web Endpoint
                       │
                       ▼
             Create Azure DNS Zone
                       │
                       ▼
               Map Custom Domain
                       │
                       ▼
         Configure Azure CDN / Front Door
                       │
                       ▼
              Enable HTTPS (SSL)
                      │
                      ▼
            Verify Secure Website

Step 1: Download a Free Website Template
Procedure
Visit Tooplate (https://www.tooplate.com/)

.Browse available templates.

.Select a template of your choice and Download it

.Download the ZIP package and from your download extract all files locally

_Step 2: Login to your Microsoft Azure Portal by going to https://portal.azure.com.

Step 3: Create a Resources Group
We need to create our Resources Group first before we go ahead to create our storage account

. Search for Resource Group in the search bar at the top of your portal
page and Select/Click on Resource Group.

.Click on Create to create Resource Group

.Type the Resource group name, select the region and click Next

. Apply tags to your resources to logically organize them by categories and click Next

.Review the resources group and click on Create

. _ Click on Resource Group on the left to bring out the resource group you created_

Step 4: Create an Azure Storage Account

.Search for Storage in the search bar at the top of your portal page and Select/Click on Storage account.

_Click on Create _

In the Basics tab, under Project details, make sure the correct subscription is selected and for the Storage Resource Group click on the list arrow and select resource group you have already created above.

.Storage account name - flakern2026 (Choose a unique name)
.Region -Select a region
.Preferred Storage Type: Azure Blob Storage
.Performance - Select Standard
.Redundancy - Select Local Redundant Storage (LRS)
.Click the next button

Click the next button or configure the other sections if required, otherwise leave as default.

Under the security, toggle the Allow enabling anonymous access on individual containers.(This is to give access to our static website)

Under Encryption, tags leave as default and click Next

Click on Review + Create

Validation
Check if storage account has configured properly or not, if properly configured it will show the create option otherwise you need to check all the configurations again. Then click on the Create Button.

After Deployment, if the deployment is successful it will show your deployment is complete, then click on Go to Resource and you will see our storage account is been created.

Step 5: Enable Static Website Hosting

.On the left pane search bar type static website and click on static website.

Enable Static Website and configure:
.Index Document Name:index.html
.Error Document Path: 404.html
.And click Save

Enabling static websites on the blob service allows you to host static content.
In the Index document name field, provide the name for your default index page, for instance index.html. This is the page that displays when a user navigates to the root of your static website.
In the Error document path field, specify the path to a default error page of your site(404.html). This is the default error page that is displayed when a user attempts to navigate to a page that does not exist in your static website.

Azure created a storage container to host the static website $WEB, Click on it or Navigate to Containers

Step 6: Upload Website Files
click on Upload
Navigate to where the website folder is located on the computer.
Drag and Drop the files from the location to the provided box.

Upload:
index.html/css/images/js/font/news-detail.html/about this template.txt

Step 7 — Verify the Deployment By Testing the Azure Website Endpoint
Open the endpoint: go back to static web site and copy the endpoint
Confirm the website loads successfully

You can open this URL in your browser to view your static website.
https://flackern2026.z1.web.core.windows.net/

Step 8: Create an Azure DNS Zone

Navigate to: Azure DNS Zones → Create
Configuration:
Name: flackernagentic.com
Resource Group: Flackern-RG

Step 8: Configure DNS Records

Create the appropriate DNS records.
Click on Recordsets -> +Add
Root Domain (Apex)
If using Azure Front Door or Azure CDN, configure an ALIAS or A record according to the service documentation.
Subdomain
Create a CNAME,@,_dnsauth record:
Name Type Points To
www CNAME Azure CDN or Front Door endpoint
@ A YES (Azure Resources)
_dnsauth TXT _3brw0rg1m1a2xpj0b0d67juoch804vg
If your domain is managed by another registrar, update the nameservers or create the required records there.

Step 9: Configure Azure Front Door or Azure CDN

Type Front Door on the search box and click on Front Door icon

Click on create

Scroll Down and ensure that Azure Front Door and Quick Create is selected
Then click on continue to create front Door

Create A Front Door Profile
Subscription :Azure Subscription
*Resource Group: Select the Resource group created
*Profile Name: Give your front door a profile name
*Tier: Standard
*Endpoint Name: Give it a unique name
*Endpoint hostname: Comes by default
*Origin Type: Toggle down and select storage(static website)
*Origin hostname: Toggle down and select static website created
**Click on Next->Review + Create*
After Validation have been passed click on CREATE

Wait until all your resource is been deploy successfully.
When your resource deployment is complete, click on Go to Resource

*Step 10: Update Default Route *
*To your left click on settings(Toggle Down) and click on Front Door Manager

*Click on Default-route(Toggle down)

*On Default-Route: Update Route->Click on "Add a new domain"

Step 11: Configure Domain Name
On this project we are not using domain name gotten from Azure but we are using domain name gotten from Domain name provider
*Domain type: Highlight Non-azure validated Domain
*DNS Management: Highlight all other DNS services
*Custom Domain: We will be using domain name gotten from domain name providers

Note: Register with a domain name with domain name providers like Qservers, Godaddy, Namecheap, Hostgator

*Click on Domain on the left side *

Under the Validation state for our website you can see pending

In order to solve the pending issue we click on pending and Validate custom domain ownership by copying the record name

Step 12: Configure DNS Records on Domain Provider Platform
Create the appropriate DNS records.
Copy the following from Azure under Validate custom Domain Ownership and go ahead and paste it under "Add a new DNS record" in your domain name provider
COPY(AZURE) PASTE(DN PROVIDER)
Record Type: TXT TYPE: TXT
Record Name: dnsauth Host Name:_dnsauth
Record Value: _3brw0rg1m1a2xpj0b0d67juoch804vg Add/value:_3brw0rg1
_Click on SAVE CHANGE

This show we have addded DNS Record successfully

Step 13: Verify the Secure Website
Open: https://www.flackernagentic.com
Verify that:
*The website loads correctly.
*The browser shows a secure padlock.
*The certificate is valid.

Conclusion
Hosting a static website on Azure Blob Storage is a smart, serverless way to put your site online — perfect for things like portfolios, landing pages, business sites, or marketing campaigns. When you hook up Azure Storage with services like Azure DNS and Azure CDN or Azure Front Door, you end up with a web setup that’s safe, can handle traffic spikes, and doesn’t break the bank.

For this project, you set up Azure resources, turned on static website hosting, uploaded your site files, attached a custom domain, added HTTPS for security, and double-checked everything worked. The whole process hits all the marks for modern cloud architecture. It’s a great example to show off your skills in Azure admin, networking, DNS management, and web deployment skills for any Cloud or DevOps engineering portfolio.

Secure VM Access Without Public IPs: A Beginner's Guide to Azure Bastion Service for Secure And Efficient VM Access

olakunle makanjuola — Mon, 06 Jul 2026 18:47:46 +0000

Introduction
Securely managing virtual machines is one of the major challenges of cloud engineering. Generally, administrators use SSH (for Linux VM) and RDP (for Windows) for accessing Azure VMs via public IP addresses. This is a good approach but exposing SSH (port 22) and RDP (port 3389) to the Internet increases the attack surface of your environment hence making it susceptible to brute force and other forms of attacks.

To overcome this problem, Azure Bastion is a Platform as a Service (PaaS) solution which provides secure SSH and RDP connection from Azure portal using HTTPS (Port 443). The use of Azure Bastion eliminates the need of assigning public IP addresses to virtual machines thus making them safer and easy to manage.

In this tutorial, you will be able to know how to implement Azure Bastion, set up the required networking configuration, connect to an Ubuntu virtual machine using SSH and understand Azure Bastion security benefits.

What is Azure Bastion?

Azure Bastion is a managed Azure service that provides secure browser-based SSH and RDP connectivity to Azure Virtual Machines without exposing them to the public internet.

Instead of connecting directly to your VM's public IP, you connect through the Azure Portal, and Azure Bastion establishes a secure session over Microsoft's private network.

Benefits of Azure Bastion
No Public IP required for Virtual Machines
Secure browser-based SSH and RDP access
No need to expose ports 22 or 3389
Reduced attack surface
Fully managed Platform as a Service (PaaS)
Uses HTTPS (Port 443)
Integrates seamlessly with Azure Virtual Networks

Project Objectives
In this project, you will:
Create an Azure Virtual Network
Create the AzureBastionSubnet
Deploy Azure Bastion
Create an Ubuntu Virtual Machine
Connect to the VM using Azure Bastion
Verify secure SSH connectivity
Understand Azure Bastion architecture and best practices

Prerequisites
Before beginning, ensure you have:
An active Microsoft Azure subscription
Access to the Azure Portal
Basic knowledge of Azure Virtual Machines
A web browser
Permissions to create Azure resources

Azure Bastion Architecture

Step 1: Sign in to Azure Portal
On your web browser, head over to https://portal.azure.com and log in with your Microsoft account. If you don't have an account, create or sign up and provide the required information so your Microsoft account can be activated.

A successful login bring you to this page below,

Step 2: Create a Resource Group
Search for Resource Groups on search bar and click on Resource group from the dropdown

-Click on Create

-Type the Resource group name, select the region and click Next

Apply tags to your resources to logically organize them by categories and click Next

Review the resources group and click on Create

-Click on Resource Group on the left to bring out the resource group you created

Step 3: Create a Virtual Network
1. .Click on Resource group created and right on the Resource Group page Search for Virtual Network on search bar and click on Virtual Network from the dropdown__

-Click on +Create(With a plus sign)

2. Define Basic Settings
Subscription: Select your subscription
Resource group: Choose an existing resource group or create a new one.
Region: Select the same region as your resource group
Virtual Network Name: Provide a name for the VNet.
Click on Next and Next under the Security

3. Define IP Address Space
Enter the IPV4 address 10.0.0.0/16 space for your virtual network. The image below shows that we can have 65,536 IP addresses within this network.

NOTE:Whenever you create your VNet there is a subnet that comes with it defaultly. We delete the subnet and create our own Subnet

-Click Next -> Review + Create -> Create

4.Click on Create, the deployment will be submitted, and the VNet will be created
Click on Go To Resources and you will see the the Created VNet

_Step 4: Configure Subnets _
Now, let's Create two subnets within the virtual network:
_1 AzureBastionSubnet
2 Default Subnet( Create another subnet)
_

Type Subnet on the search bar and click on Subnet
Click +Subnet to define each subnet

Subnet Creation- Add a Subnet
_AzureBastionSubnet
Azure Bastion requires a dedicated subnet named exactly:
_

Configure each subnet as follows:
_Subnet purpose: Azure Bastion
Subnet Name: AzureBastionSubnet
Subnet Address range: Specify the subnet range within the virtual network address space (10.0.0.0/26). _

Create another subnet(Default VM Subnet)

Step 5: Create an Ubuntu Virtual Machine
1.Type "Virtual Machines" in the search bar at the top. Once you see virtual machine display click on the virtual machine

When you click on "Create" button, it will display a drop down as shown below. You will then click on the Azure virtual machine highlighted in red arrow. This will take you to the project details where you will begin to fill the basic configuration for you to start creating your virtual machine.

2.Create virtual Machine under the BASIC CONFIGURATIONS by filling the following tabs as follows:

Subscription: Select your subscription(Azure Subscription 1)
Resource Group: Use an existing or create a resource group (FlackernProj-rg)
Virtual machine name: flackern-VM or use your desired username
Region: Select a nearby or preferred location ((Africa) South Africa North)
Availability options: Leave it as default (Availability Zone)
Availability Zone: Zone 1 (For this demo we select only one zone)
Security type: Standard
Image: Ubuntu Server 24.04 LTS - x64 Gen2
VM architecture: x64
Size: Standard_B2as_v2 - 2 vcpus, 8 GiB memory ($71.32)
Authentication type: SSH public key
Username: Use your desired username
SSH public key source: Generate new key pair
SSH Key Type: RSA SSH Format
Key pair name: flackern-vm_key or use your desired username
Public inbound ports: NONE
Select inbound ports: All traffic from the internet will be blocked by default.

3.Configure Disks

Click on Next : Disks >, this leads you to on the next page, you can use the default OS disk size, use the Image default (30 GiB) and for the OS disk type, use the default settings Premium SSD (locally-redundant storage) unless you have unique configuration requirements.

4.Networking Configuration
On the bottom of the last page in Step 3, Click on Next : Networking >, this leads you to the Network interface page below:
Create your virtual network and subnet or make use of the one you have created before
Virtual Network: flackernproj-Vnet (Vnet created before)
Subnet : Default Subnet (flackern-subnet)
Public IP: None
Public Inbound Port: None
Note: We are creating a private VM,so you select None for Public IP and Public Inbound Port.
***Remember: Public VM, Public IP*
Private VM, No Public IP

5.Management, monitoring, Advanced, Tags: These pages usually displayed as default. Find their default screenshots below. However, you may wish to skip them and proceed to “Review+Create”

Step 5. Generate SSH private Key
After a successful Linux VM deployment process, Azure will validate the configuration

Then Click "Review + create". This will show validation passed as highlighted below.

Then click “Create” . This will take you to the next page to generate new key pair. Then, you will click on “Download private key and create resource” as shown below. The new key pair will then be downloaded on your PC, while Azure will also provision your VM.

Download private key and create resource, afterwards, the deployment will start.

Wait for Deployment: Azure will now provision your virtual machine. This process may take a few minutes. Then the next page will show that your deployment is complete as shown below, then you will click on “Go to Resource”

Step 6: Deploy Azure Bastion
Type "Bastion" in the search bar at the top. Once you see Bastion display click on the Bastion

When you click on "Create" button,this will take you to the project details where you will begin to fill the basic configuration for you to start creating your Bastion

Advanced, Tags: These pages usually displayed as default. Find their default screenshots below. However, you may wish to skip them and proceed to “Review+Create”

Click on Create after validation is passed

Connect to VM using Bastion:
Once the VM is deployed, go to the VM in the Azure portal.
Click on the Connect button.
Select Bastion as the type of connection.
Enter the credentials (username and password or SSH key) and click Connect.

Provide your credentials to securely connect to the virtual machine using Bastion
Connection Settings:
Protocol: SSH
Port : 22
Authentication Type: SSH Private Key from Local File
Username: Use the username you created
Local File: Pick up the Key-pem you downloaded on your download,open the file on your azure portal and click on connect

Immediately you Click Connect, within a few seconds, Azure opens an SSH session directly in your browser.(We are connecting to our VM Securely)

Congratulations we have successfully SSH into our Virtual Machine securely using Bastion

Conclusion
Azure Bastion is one of the most effective ways to securely manage Azure Virtual Machines without exposing them to the public internet. By providing browser-based SSH and RDP access over HTTPS, it eliminates the need for public IP addresses and open management ports, significantly improving the security posture of your cloud environment.

In this step by step guide you created a Virtual Network, configured the required AzureBastionSubnet, deployed an Azure Bastion host, created an Ubuntu virtual machine, and successfully connected to it using a secure browser-based SSH session.

Deploying My First Ubuntu Virtual Machine on Microsoft Azure: SSH Access, Apache2 Installation, and Web Server Configuration"

olakunle makanjuola — Tue, 23 Jun 2026 22:21:55 +0000

Introduction

Microsoft Azure Virtual Machines (VMs) provide scalable cloud computing resources that allow users to deploy and manage operating systems in the cloud. In this project, I created an Ubuntu 22.04 Virtual Machine in Azure, connected to it using SSH from both Git Bash through the Visual Studio Code, updated the server, installed Apache2, configured network security settings, and deployed a custom web page accessible through a public IP address.

This hands-on lab helped me gain practical experience with Azure Infrastructure as a Service (IaaS), Linux administration, SSH connectivity, and web server deployment.

Project Objectives
Create an Ubuntu 22.04 Azure VM
Download and secure a .pem private key
Connect to the VM using Git Bash
Update and upgrade Ubuntu packages
Install and verify Apache2
Create a custom web page
Access the website through a browser

Prerequisites
Active Azure Subscription
Azure Portal access
Git Bash installed
Internet connection

Step 1. Log In to Azure Portal

On your web browser, head over to https://portal.azure.com and log in with your Microsoft account. If you don't have an account, create or sign up and provide the required information so your Microsoft account can be activated.

A successful login bring you to this page below,

**_Step 2: Create a Resources Group
_**
We need to create our Resources Group first before we go ahead to create our virtual machine
. Search for Resource Group in the search bar at the top of your portal

page and Select/Click on Resource Group.

Click on Create to create Resource Group

Type the Resource group name, select the region and click Next
Apply tags to your resources to logically organize them by categories and click Next

Review the resources group and click on Create

_ Click on Resource Group on the left to bring out the resource group you created_

Step 2. Create a New Virtual Machine
Type "Virtual Machines" in the search bar at the top. Once you see virtual machine display click on the virtual machine

Once you click on the virtual machine, your screen will be displayed as shown below. Click on CREATE

Create virtual Machine under the BASIC CONFIGURATIONS by filling the following tabs as follows:

Subscription: Select your subscription(Azure Subscription 1)
Resource Group: Use an existing or create a resource group (FlackernProj-rg)
Virtual machine name: flackern-vm or use your desired username
Region: Select a nearby or preferred location ((Africa) South Africa North)
Availability options: Leave it as default (Availability Zone)
Availability Zone: Zone 1 (For this demo we select only one zone)
Security type: Standard
Image: Ubuntu Server 24.04 LTS - x64 Gen2
VM architecture: x64
Size: Standard_B2as_v2 - 2 vcpus, 8 GiB memory ($71.32)
Authentication type: SSH public key
Username: Use your desired username
SSH public key source: Generate new key pair
SSH Key Type: RSA SSH Format
Key pair name: flackern-vm_key or use your desired username
Public inbound ports: Allow selected ports
Select inbound ports: HTTP (80) and SSH (22)

Step 3. Configure Disks

Step 4. Networking Configuration

On the bottom of the last page in Step 3, Click on Next : Networking >, this leads you to the Network interface page below:

Create your virtual network and subnet or make use of the one you have created before

Management, monitoring, Advanced, Tags: These pages usually displayed as default. Find their default screenshots below. However, you may wish to skip them and proceed to “Review+Create”.

Step 5. Generate SSH private Key
After a successful Linux VM deployment process, Azure will validate the configuration

_Then Click "Review + create". This will show validation passed as highlighted below.

Download private key and create resource, afterwards, the deployment will start.

_Wait for Deployment: Azure will now provision your virtual machine. This process may take a few minutes. Then the next page will show that your deployment is complete as shown below, then you will click on “Go to Resource”
_

Next, click on “Connect” and then “Connect”. This will take you to a page with other options to connect your VM.

Retrieve Public IP Address: Once the virtual machine is deployed, note down the Public IP address on Azure portal overview page.

Note: Also go to your download and save the downloaded key pair into a file for later use when connecting via SSH.

Step 6: SSH into VM Using Git Bash -Connect via SSH Key Authentication*:*
Open your Command Line Interface on Windows or Terminal on your Visual studio code using gitbash or power shell
Move the .pem file into a secure folder.
Set permissions:
chmod 600 flackern-vm_key.pem

Step 7: SSH into VM Using Azure Cloud Shell
Connect:
ssh -i flackern-vm_key.pem flackern-vm@102.37.144.183

Step 8: Update Ubuntu Packages
Using sudo apt update and click enter.This will update our virtual machine

Step 9: Install Apache2
Instal apache2 on our VM and click enter
Install:
sudo apt install apache2 -y

Now let us confirm if apache2! Was actually installed on the virtual machine, we can do this by going to your Azure site and copy the ip address and paste it on the web page and see the result.

Copy ip address

Test Your Web Server
Open a web browser and enter the public IP address you obtained earlier. If apache2 is running correctly, you should see a default welcome page.
Congratulations! You have successfully created a Linux virtual machine on Microsoft Azure and installed the Apache2 web server. This is a foundational step for hosting web applications or deploying other web services.

Creating An Azure Virtual Network(VNET) And Multiple Subnets: A Step-By-Step Beginner's Guide

olakunle makanjuola — Mon, 08 Jun 2026 10:58:44 +0000

Introduction:
A virtual Network (VNet) is a logically isolated private network you create inside Azure. Virtual Network (VNET) is one of the essential building blocks of Microsoft Azure networking architecture and also the foundation of your networking setup.

Virtual Network allows resources running in Microsoft Azure, like Virtual Machines, Storage Accounts, Applications, to communicate with each other, internet, and even on-premises network environments.

A Subnet is a subdivision of your VNet. It allows you to divide your network into smaller, logical sections and assign different resources to different sections based on their purpose.

Subnets are logical segments of a Virtual Network which assist in organizing and securing network resources. In this project, I have designed an Azure Virtual Network with three separate Subnets.

Objectives

The objectives of this project are to:

Create an Azure Virtual Network (VNet)
Configure an address space for the VNet
Create three separate subnets
Understand Azure networking fundamentals
Document the deployment process

Prerequisites

Before starting, ensure you have:
.An active Azure Subscription
.Access to Azure Portal
.Internet Connection
.Appropriate permissions to create Azure resources

Azure Portal:

https://portal.azure.com

Architecture Overview
Azure Virtual Network (10.0.0.0/16)
│
├── Subnet-1 (10.0.1.0/24)
│
├── Subnet-2 (10.0.2.0/24)
│
└── Subnet-3 (10.0.3.0/24)

Step 1: Sign in to Azure Portal
Open Azure Portal.
https://portal.azure.com.

Step 2: Create a Resource Group

Search for Resource Groups on search bar and click on Resource group from the dropdown
Click on Create
Type the Resource group name, select the region and click Next
Apply tags to your resources to logically organize them by categories and click Next
Review the resources group and click on Create
Click on Resource Group on the left to bring out the resource group you created

Step 3: Create a Virtual Network
1.Click on Resource group created and right on the Resource Group page Search for Virtual Network on search bar and click on Virtual Network from the dropdown

Click on +Create(With a plus sign)

2. Define Basic Settings
Subscription: Select your subscription
Resource group: Choose an existing resource group or create a new one.
Region: Select the same region as your resource group
Virtual Network Name: Provide a name for the VNet.
Click on Next and Next under the Security

3. Define IP Address Space
Enter the IPV4 address 10.0.0.0/16 space for your virtual network. The image below shows that we can have 65,536 IP addresses within this network.

_NOTE: Whenever you create your VNet there is a subnet that comes with it defaultly. We delete the subnet and create our own Subnet
_

- Click Next -> Review + Create

-4. Click on Create, the deployment will be submitted, and the VNet will be created
_Click on Go To Resources and you will see the the Created VNet
_

_Step 4: Configure Subnets _
Now, let's configure the Three subnets within the virtual network:

Type Subnet on the search bar and click on Subnet

- Click + Add subnet to define each subnet

Configure each subnet as follows:
Subnet Name: Enter a name for the subnet (e.g., Subnet1, Subnet2,Subnet3, etc.).
Subnet Address range: Specify the subnet range within the virtual network address space (10.0.0.0/24). Ensure each subnet range is within the /24 address space 10.0.0.0 - 10.0.0.255)

- Creation of Subnet 1

- Creation of Subnet 2

- Creation of Subnet 3

To have a view of the subnets created, click on Settings on the left pane and then on Subnets

Congratulations! You have successfully created an Azure virtual network with Three subnets using the address space (10.0.0.0/24)

From Template to Cloud: Hosting a Free Static Website on Azure Blob Storage Step-by-Step

olakunle makanjuola — Fri, 05 Jun 2026 12:34:49 +0000

Introduction
Website hosting has been greatly improved through the use of cloud computing. This has made it easier for individuals as well as businesses to access, scale, and use hosting services at a reasonable price. One of the easiest and most efficient methods that developers may use to host a static site on Microsoft Azure is the Static Website Hosting option offered by Azure Blob Storage, which allows developers to upload their static files without the need for a traditional web or virtual server (i.e., HTML, CSS, JavaScript, and media files).

In this project, I will download a free static website template from Tooplate, customize the downloaded version using Visual Studio Code (VS Code), and then deploy the new version to Azure Blob Storage for public viewing. This will involve editing all content, images, styles, and branding so that the template reflects how I want it to look when it is completed.

To develop my own static website using Azure Blob Storage, I will first navigate to Tooplate and browse the templates available for modification (or further development). After deciding which template is most suitable, I will download the ZIP package of the template and extract it onto my local computer's disk drive. Then, I will open the ZIP file's contents using VS Code to customize all aspects of the website prior to publishing.

After customizing the template, we will create an Azure storage account, enable Static Website Hosting, upload the customized/static website files to the Azure Blob Storage $web container, and then publish the created static website into the cloud.

Project Objectives

.Download a free static website template from Tooplate.
.Go to VS code and edit the downloaded template from there
.Create a Resources Group
.Create an Azure Storage Account.
.Enable Azure Static Website Hosting.
.Upload website files to Azure Blob Storage.
.Deploy and access the website through Azure's public endpoint.
.Document the deployment process.

Prerequisites

Before we begin, ensure you have the following installed on your machine:
Active Azure Subscription
Microsoft Azure Account(portal.azure.com)
VS Code download and install (https://code.visualstudio.com/Download)
Internet Connection
ZIP Extraction Tool

Step 1: Download a Free Website Template
Procedure
Visit Tooplate (https://www.tooplate.com/)

.Browse available templates.

.Select a template of your choice and Download it

.Download the ZIP package and from your download extract all files locally

Step 2: Download the latest version of vs code and install it.
.Open the vs code

.Click on file -> Select Open Folder-> Select the unzip folder and the folder containing the /index.html,css ,js,images ,fonts ,news-detail.html will be upload on the Vs code template

.Click index.html which has the code as seen
.You can edit some elements especially those on white characters
.You can edit elements as they appear in the lines 48
.Be careful not to change the code, so the browser will not be scattered

The new edited index.html page will look like this after what you edited on the template is save.

Storage Hierarchy:
Azure Subscription → Resource Group → Storage Account → Container → Blob Files

_Step 3:First thing login to your Microsoft Azure Portal by going to https://portal.azure.com.
_

_Step 4: Create a Resources Group
_
We need to create our Resources Group first before we go ahead to create our storage account
. Search for Resource Group in the search bar at the top of your portal

page and Select/Click on Resource Group.

. Click on Create to create Resource Group

. Type the Resource group name, select the region and click Next

. Apply tags to your resources to logically organize them by categories and click Next

. Review the resources group and click on Create

. _ Click on Resource Group on the left to bring out the resource group you created_

Step 5: Create an Azure Storage Account
.Search for Storage in the search bar at the top of your portal page and Select/Click on Storage account.

_Click on Create _

.Storage account name - flakernpro (Choose a unique name)
.Region -Select a region
.Preferred Storage Type: Azure Blob Storage
.Performance - Select Standard
.Redundancy - Select Local Redundant Storage (LRS)
.Click the next button

Click the next button or configure the other sections if required, otherwise leave as default.

Under the security, toggle the Allow enabling anonymous access on individual containers.(This is to give access to our static website)

Under Encryption, tags leave as default and click Next

Click on Review + Create

After Deployment, if the deployment is successful it will show your deployment is complete, then click on Go to Resource and you will see our storage account is been created.

_Step 6: Enable Static Website Hosting
_
.On the left pane search bar type static website and click on static website.

Enable Static Website and configure:
.Index Document Name:index.html
.Error Document Path: 404.html
.And click Save

Azure created a storage container to host the static website $WEB, Click on it or Navigate to Containers

.On Data storage dropdown
.Click container
.Click $WEB

Step 7: Upload Website Files
click on Upload.
Navigate to where the website folder is located on the computer.
Drag and Drop the files from the location to the provided box.

Upload:
index.html/css/images/js/font/news-detail.html/about this template.txt

Step 8 — Verify the Deployment
Open the endpoint: go back to static web site and copy the endpoint

You can open this URL in your browser to view your static website.
https://flackernprod.z19.web.core.windows.net/

Conclusion

In this project, I successfully deployed a free static website template downloaded from Tooplate to Azure Blob Storage using Azure Static Website Hosting. This approach actually provides a simple, secure, scalable, and cost-effective solution for hosting static websites without the difficulty of managing web servers.

The project reinforced key Azure concepts such as Resource Group, Storage Accounts, Blob Containers, Static Website Hosting, and cloud-based web deployment. For beginners entering cloud computing, DevOps, or Azure administration, this is an excellent hands-on project that demonstrates practical cloud hosting skills while building confidence in Azure services.

Azure Entra ID User & Role Management — Step-by-Step Practical Guide With A Simple Excercise

olakunle makanjuola — Mon, 25 May 2026 17:50:55 +0000

Before going into the step by step practical guide on Creating User Via Azure Active Directory (Microsoft Entra ID) and Assigning Roles with RBAC,I will like to define key concepts to learn:

Microsoft Entra ID: Azure's Identity Management System Microsoft Entra ID(previously called Azure Active Directory or Azure AD) is the service that manages all identities in Azure. Every user account, every application identity, every group, all of them are stored and managed here. When you log into the Azure Portal, Entra ID is checking your credentials behind the scene.

2. Identity And Access Management(IAM)
Identity and Access Management(IAM) Is the system that answers three very important questions about every person or application that tries to use cloud: WHO are you? Are you really who you say you are? And what are you ALLOWED to do here? Which talks about IDENTITY! AUTHENTICATION! AUTHORISATION!

3. Role Based Access Control(RBAC)
RBAC is how Azure controls what a logged-in user is allowed to DO. Instead of giving everyone full admin access. RBAC lets you assign specific roles to specific people. RBAC allows administrators to assign permissions based on roles instead of assigning permissions individually.
Examples:
Global Administrator
User Administrator
Security Administrator

4.Principle of Least Privilege (PoLP)
Users should only have the minimum access required to perform their duties.

Azure Entra ID User & Role Management Practice Exercise

Create a new user in Azure Entra ID.

Grant the user Global Administrator access.

Using the newly promoted account, create another new user in Azure Entra ID.

After creating the second user, revoke the Global Administrator access from the first user account.

Document the entire process with screenshots and explanations

The Practice Exercise involved:
In this exercise, I carried out administrative tasks in Microsoft Azure using Microsoft Entra ID.
Creating users in Azure Entra ID
Assigning Global Administrator privileges
Testing administrative access
Revoking elevated permissions
Demonstrating Identity and Access Management (IAM) best practices

Introduction

This step by step guide will helped us gain practical experience in Azure identity administration and role-based access control (RBAC).

Prerequisites

Before starting, ensure you have:
An active Azure subscription
Access to Azure Portal
First thing login to your Microsoft Azure Portal by going to https://portal.azure.com.

If you do not have an azure account sign up and create an account for free with this link https://azure.microsoft.com/en-us/free/. Registration will require a phone number and a debit or credit card details to validate your account even for the free account. You have a choice between the free or pay as you go account.

Official Portal:
Microsoft Azure Portal

Step 1 — Create a New User in Azure Entra ID

1.First thing login to your Microsoft Azure Portal by going to https://portal.azure.com.

2.Search for Microsoft Entra ID in the search bar at the top of your portal page and Select Microsoft Entra ID.

You are now in the Default Directory| Overview page.

3.Navigate to Users → + New user → Create new user.
Type Users on the search box and click on Users then click on + New User with a drop down arrow and click on create a new user

4.Fill in the details:

User principal name: Shalom1503
Display name: Shalom Ife
Password:***************
First name: Shalom
Last name: Ife
Usage location: Nigeria
And click on Next(Property)-> Next(Assignment)-> Review + create -> Create

Step 2 — Sign In with the Newly Created User Account

Open a new browser/incognito window
Go to: Microsoft Sign In Page
Sign in using: . Newly created username . Username: Shalom1503@makansgreatolakunleoutlook.onmicrosoft.com . Password: saved password . Change password when prompted . Complete MFA setup when prompted by scanning the QRCODE

Step 3: Assign a Role to a User(Grant Global Administrator Access)

Come to Default Directory through the Entra ID

2.Type USER on the search box and Click on the USER → SHALOM IFE(New User Created)

3.Select Assigned roles → + Add assignment.

4.Choose admin roles that you want to assign to user and add it

Step 4 — Use the Newly Promoted Account to Create Another User

# Sign in with the promoted user account to create another new user in Azure Entra ID

1.login to your Microsoft Azure Portal by going to
(https://portal.azure.com)
2.From the Default Directory page of the User created
'Shalom1503@makansgreatolakunleoutlook.onmicrosoft.com".
Click on +ADD → User → Create new user.

3 Fill in the details:
User principal name: Favour1403
Display name: Favour Timi
Password:***************
First Name:************
Last Name:*************

And click on Next(Properties)-> Next(Assignment)->

Review + create -> Create

Step 5 — Revoke Global Administrator Access from the First User

1.Sign in using the original administrator account
login to your Microsoft Azure Portal by going to

https://portal.azure.com/auth/login/

2.Navigate to and click on Microsoft Entra ID

3.Click on Manage button under the overview to bring down the arrow

which brings out the Roles and administrator button.
OVERVIEW -> MANAGE -> ROLES AND ADMINISTRATOR

4.On the search bar under the Administrator Roles, type the Global Administrator Roles given to the User and click on it

5.Click on the User given the Global administrator Roles(Shalom Ife)

6.Click the button in front of Global Administrator to make the X Remove Assignments button active and click on it and it will ask whether to Remove selected assignment. Click on YES

7.This successfully removed assignment "Global Administrator" from the
USER (Shalom Ife)

Removing/Revoking privileged access follows the concept called the Principle of Least Privilege (PoLP), ensuring users only retain permissions necessary for their tasks or give people only the minimum access needed to do their job

Conclusion

This assignment provided hands-on experience with Azure identity and access management using Microsoft Entra ID. This allow us to learn how to create users, assign administrative privileges, manage RBAC roles, and apply security best practices in a cloud environment.

The exercise also reinforced the importance of privilege management and secure administrative operations in enterprise cloud environments.