DEV Community: Ezekiel Olaniyan

CONTAINERIZING AND DEPLOYING AN APPLICATION WITH DOCKER, DOCKER HUB AND AZURE CONTAINER INSTANCES

Ezekiel Olaniyan — Thu, 24 Sep 2026 11:49:29 +0000

Step 1: Cloning the Repository
The first step in this project was to clone a GitHub repository containing the application source code. I used the git clone command to download the repository to my local computer and then navigated into the project directory using cd hagitech.

Step 2: Building the Docker Image
I then built a Docker image from the application source code using the docker build command. This process used the instructions in the Dockerfile to package the application and its required dependencies into a Docker image named Container Vibes.

Step 3: Running the Docker Container
After successfully building the image, I created and started a Docker container using the docker run command. I then used the docker ps command to confirm that the container was running successfully.

Step 4: Accessing the Application Through a Web Browser
I accessed the running application through my web browser using localhost:3000. Port 3000 on my computer was mapped to port 3000 inside the container, allowing me to access the application from my local machine. The Container Vibes application loaded successfully, confirming that the container was working as expected.

Step 5: Publishing the Image to Docker Hub
After confirming that the application was working correctly, I published the Docker image to Docker Hub. I logged into Docker Hub from my terminal and used the docker push command to upload the image to my repository. I then verified the uploaded image from my Docker Hub dashboard.

Step 6: Deploying to Azure Container Instances
The next step was to deploy the Docker image to Azure Container Instances (ACI). I logged into my Azure account, created a resource group named wale-container-rg, and then created a container instance using the Docker image stored in my Docker Hub repository. After deployment, I verified the container instance through the Azure Portal and confirmed that the application was publicly accessible.

In this project, I used EXPOSE, -p, and --dns-name-label for different purposes. EXPOSE tells Docker which port my application uses inside the container. -p allows me to connect the container's port to a port on my computer. For example, -p 3000:3000 allowed me to access my application through localhost:3000. --dns-name-label gave my Azure Container Instance a public web address, which made it possible for me to access my application from a browser after deploying it to Azure.

Provisioning a Functional Virtual Machine with Terraform on Azure

Ezekiel Olaniyan — Tue, 22 Sep 2026 09:03:22 +0000

Infrastructure as Code (IaC) has become an important practice in modern cloud engineering because it allows infrastructure to be defined, deployed, and managed using configuration files rather than manually creating resources through a cloud provider's user interface.
As part of my journey into Cloud and DevOps Engineering, I worked on a hands-on project to provision a functional Azure Virtual Machine (VM) using Terraform.
In this project, I created the required Azure infrastructure, deployed a functional Linux virtual machine, installed Nginx, configured a remote Terraform backend, and pushed the configuration to GitHub.
This article documents the process and some of the lessons I learned along the way.

What I Built
The project involved provisioning the following Azure resources using Terraform:
• Resource Group
• Virtual Network
• Subnet
• Public IP Address
• Network Security Group (NSG)
• Network Interface Card (NIC)
• Virtual Machine
• Nginx web server
• Azure Storage Account
• Azure Storage Container for Terraform remote state
The overall objective was to move from manually creating infrastructure to defining and managing it as code.

Step 1: Initializing the Terraform Configuration
The first step was to create a dedicated working directory for the Terraform project.
I created a folder named:
terraform-demo2
inside my Documents directory.
I then created a Terraform configuration file called:
main.tf
The main.tf file contains the Terraform configuration used to define the infrastructure that I wanted Azure to provision.
After creating the configuration, I initialized Terraform using:
terraform init

Step 2: Planning and Applying the Terraform Configuration
After initializing Terraform, I developed the infrastructure configuration in main.tf.
The configuration defined the infrastructure starting from the resource group and networking components through to the virtual machine.
The resources included:
Resource Group
↓
Virtual Network
↓
Subnet
↓
Public IP
↓
Network Security Group
↓
Network Interface
↓
Virtual Machine
I also configured Terraform to output the public IP address of the virtual machine after deployment.
Running Terraform Plan
Before creating the infrastructure, I used:
terraform plan
The terraform plan command allowed me to review the changes Terraform intended to make before actually creating the resources.
This is an important step because it provides an opportunity to identify configuration errors or unexpected changes before they affect the Azure environment.
Applying the Configuration
After reviewing the plan, I deployed the infrastructure using:
terraform apply
Terraform then communicated with Azure and created the resources defined in the configuration.
Once the deployment was completed successfully, the required Azure resources were available for use.

Step 3: Successfully Provisioning a Functional Virtual Machine
One of the most exciting parts of the project was seeing the virtual machine successfully provisioned and become functional.
The VM was created with the networking components required to allow connectivity.
After deployment, I connected to the VM and installed Nginx, which I used to verify that the web server was running successfully.
Nginx can be installed on an Ubuntu-based Linux VM using:
sudo apt update
sudo apt install nginx -y
After installing Nginx, I checked the service:
sudo systemctl status nginx
The service was running successfully.
I then accessed the VM through its public IP address from a web browser.
Seeing the Nginx welcome page confirmed that the VM was not only created successfully but was also functioning as a web server.

Step 4: Reviewing the Provisioned Resources in Azure
After Terraform completed the deployment, I checked the Azure Portal to verify the resources that had been created.
The resources included the components required to support the virtual machine, such as:
• Resource Group
• Virtual Network
• Subnet
• Public IP
• Network Security Group
• Network Interface
• Virtual Machine
This provided a useful visual confirmation that the infrastructure defined in Terraform had been successfully translated into actual Azure resources

Step 5: Creating and Configuring a Remote Backend
After successfully provisioning the VM, I moved to another important Terraform concept: remote state management.
Terraform uses a state file to keep track of the infrastructure it manages.
Instead of keeping the Terraform state only on my local computer, I configured an Azure Storage Account and Blob Container to serve as a remote backend.
The Azure resources required for this included:
Storage Account
↓
Blob Container
↓
Terraform Remote State
I created the storage account and container using Azure CLI commands.
The Terraform backend configuration was then added to the Terraform configuration.

Step 6: Pushing the Terraform Configuration to GitHub
After configuring the remote backend, I created a Git repository for the project.
I initialized Git using:
git init
I then created a .gitignore file.
The purpose of the .gitignore file was to prevent files that should not be committed to the repository from being tracked by Git.
For example, Terraform projects commonly need to exclude files such as:
.terraform/
.tfstate
*.tfstate.
It is important to understand that Terraform state files can contain sensitive infrastructure information, so they should be handled carefully.
I then staged the relevant files:
git add main.tf .gitignore
and committed them:
git commit -m "Add Terraform Azure VM configuration"
Because my GitHub repository used the main branch, I changed the local branch to main before pushing:
git branch -M main
I then connected the local repository to GitHub and pushed the configuration:
git push -u origin main
The Terraform configuration and .gitignore file were successfully pushed to my GitHub repository.

Terraform Configuration in GitHub
The project files were now available in my GitHub repository.
The repository contained the Terraform configuration and supporting files required for the project.
[Insert Screenshot: main.tf and .gitignore in GitHub]
The remote backend configuration was also reflected in the Terraform project.

Conclusion
This project gave me practical experience provisioning a functional Azure Virtual Machine using Terraform.
Starting with a simple main.tf file, I was able to define and provision the required Azure infrastructure, deploy a functional Linux VM, install Nginx, configure a remote Terraform backend, and version-control the project using Git and GitHub.
More importantly, the project helped me understand how different Cloud and DevOps technologies fit together:
Terraform
↓
Azure Infrastructure
↓
Linux Virtual Machine
↓
Nginx
↓
Azure Remote Backend
↓
Git & GitHub
↓
CI/CD Automation
For me, this project represents another practical step toward becoming a well-grounded Cloud and DevOps Engineer.

CloudComputing #DevOps #Terraform #Azure #InfrastructureAsCode #IaC #GitHub #Linux #Nginx #CloudEngineering #DevOpsEngineering

DEPLOYING SECURE VMs THAT CAN BE ACCESSED ONLY THROUGH NSG RULE + AZURE BASTION

Ezekiel Olaniyan — Thu, 27 Aug 2026 14:09:05 +0000

*DEPLOYING SECURE VMs THAT CAN BE ACCESSED ONLY THROUGH NSG RULE + AZURE BASTION WITHOUT EXPOSURE TO THE INTERNET. *

Architectural Drawing of VM Using Bastion and NSG

Step One: Sign in to the Azure Portal and create a new Resource Group as shown below:

Type Resource Group in the search box and select it as indicated in the screenshot.
Click on “Create” in the Resource Group window.
Enter the Resource Group name and select your preferred region.
Finally, click on “review and create” to create the Resource Group .

Step Two: Create Virtual Network.

Search for Virtual Network by typing it in the search box as indicated in the screenshot below, and select Virtual Network.
On the virtual Network page, click on “Create”.
Select your Resource Group and enter your Virtual Network name, then click on next.
Under the Address space, confirm your CIDR range then review and create.
Finally, click on “Create” to create your Virtual Network.

**Step Three (3): Create Subnets.
**For this project, two subnets are required; the main subnet and the Azure Bastion subnet.

To create the main subnet, click on the virtual network you have created, then search for “Subnets” in the search box and select it as shown in the screenshot below
On the “Add Subnets” page, input your subnet name then click on “Add” as shown below.

*Create Azure Bastion-Subnet. *

To create the Azure Bastion subnet, Under the “Add a subnet” page, click on Subnets.
Select Azure Bastion for Subnet purpose as shown in the screenshot.
Finally, click on Add to create your Azure Bastion subnet.

STEP FOUR (4): Create Azure Bastion.

Type Bastions in the search box and select Bastions as indicated in the screenshot.
Click on Create on the Bastions page.
On the Add a Bastion page, select your Resource group, enter your Bastion name and indicate the desired instance count as shown in the screenshot.
Click on Review and create, then “Create” to create your Bastion.

STEP FIVE (5): Create Virtual Machine.

To spin up any virtual machine type “Virtual machines” in the search box as indicated in the screenshot, then select Virtual machines. On the “Compute Infrastructure” page, under virtual machine click on create and select Virtual machine as shown in the screenshot below
On the Create a Virtual machine page, select your Resource group, enter your virtual machine name, select your desired zone, then click on “Next: Disk” as indicated below.
On the next page select your desired availability zone. For windows VM select desired Windows image, architecture and size as shown in the screenshot, then click on Next: Disk
For Windows VM enter the username, password, and confirm password, then click on next: disk
Next, select your virtual network and subnet. For public IP select None, for NIC select Basic and for Public inbound port select None as shown in the screenshot.
Finally, click on review and create, then create.

For Linux VM select desired Ubuntu image, architecture and size as shown in the screenshot, then click on Next: Disk
Select SSH public key, input username, generate keypair, select RSA SSH format, then click on Next: Disk as shown below.
For public inbound port, select None as shown below, then click on Next: Disk
Next, select your virtual network and subnet. For public IP select None, for NIC select Basic and for Public inbound port select None as shown in the screenshot.
Finally, click on review and create, then create

Create a Network Security Group (NSG) for port 3389.

To create NSG, click on the Windows virtual machine, scroll down and click on Networking.
Select Network settings as indicated in the screenshot below.
Click on Create port rule as indicated in the screenshot, then Inbound port rule.
Under “Add security rule” select “Any” for source, select “asterisk” for source port ranges, “Any” for destination, and “RDP” for service and 3389 for destination port ranges as shown below. For Linux VM, select SSH for service and 22 for destination port ranges.
Select TCP for protocol, for Action select “Allow”, for priority select “100”

Connecting to the secure VM via Bastion using SSH Port 22.

Open the virtual machine, then click on connect.
Click on connect via Bastion
Click on Bastion, then select SSH.
Enter your username, keypair (from your download folder) and password. And connect.

Connecting to the secure VM via Bastion using RDP Port 3389.

HOW TO CREATE USER AND ASSIGN ROLES IN AZURE WITH ENTRA ID

Ezekiel Olaniyan — Sat, 23 May 2026 11:02:49 +0000

To create user in Azure using Entra ID, begin by typing Entra ID in the search box and select entra ID from the list of items as shown below

Next, click on "User" as indicated in the image below. This takes you to a new page where you click on "New user".

Select "Create new user", then input the principal name, display name and click on Next: properties. Fill the required information on the properties page, then click on Next: Assignment. On the assignment page, click on "Add Role" and select the desired role from the list of roles on the right hand side of the pane as shown below

Click on Next: Review + Create, then Create. You may need to refresh the new page for the changes made to reflect and for the newly created user to appear in the list of users created.