DEV Community: Chinonso Ukadike

Securing Azure Networks: Creating and Configuring Network Security Groups (NSGs) and Application Security Groups (ASGs)

Chinonso Ukadike — Wed, 07 May 2025 16:15:46 +0000

This article is a continuation of Building Strong Connections: A Beginner’s Guide to Setting Up Virtual Networks and Peering in Azure. In that guide, we set up a virtual network (app-vnet) with two subnets: frontend and backend.

In this article, we’ll focus on securing those subnets by implementing network security groups (NSGs) and application security groups (ASGs) to control inbound and outbound traffic between VMs and from the internet.

Step 1: Deploy Virtual Machines to Existing Subnets

We will deploy two Ubuntu virtual machines using an Azure Resource Manager (ARM) template provided by Microsoft. VM1 will reside in the frontend subnet, and VM2 will be placed in the backend subnet.

Open Azure Cloud Shell (select PowerShell) and run the following command:

   $RGName = "RG1"

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

Step 2: Create an Application Security Group (ASG)

ASGs allow you to group virtual machine network interfaces by application roles, making it easier to manage NSG rules.

In the Azure portal, search for Application security groups.
Click + Create.
Use the following configuration:
- Subscription: Your subscription
- Resource Group: RG1
- Name: app-frontend-asg
- Region: East US
Click Review + create, then click Create.

Step 3: Associate VM1 with the Application Security Group

To apply NSG rules based on ASG membership, associate VM1 with the app-frontend-asg.

Go to Virtual Machines, select VM1.
Under Settings, select Networking.
Click Application security groups, then select Add application security groups.
Choose app-frontend-asg and click Add.

Step 4: Create a Network Security Group (NSG)

Now create a network security group to control traffic to the backend subnet.

Search for Network security groups in the portal.
Click + Create.
Use the following configuration:
- Subscription: Your subscription
- Resource Group: RG1
- Name: app-vnet-nsg
- Region: East US
Click Review + create, then click Create.

Step 5: Associate the NSG with the Backend Subnet

Open the app-vnet-nsg NSG from the list in your resource group.

In the left pane, click Subnets.
Click + Associate.
Select:
- Virtual Network: app-vnet
- Subnet: backend
Click OK to complete the association.

Step 6: Add an Inbound Security Rule to Allow SSH from Frontend ASG

Now configure an NSG rule to allow secure SSH access from the frontend web server (VM1, in app-frontend-asg) to the backend VM (VM2).

Open the app-vnet-nsg NSG.
Click Inbound security rules under Settings.
Click + Add.
Use the following settings:
- Source: Any
- Source port ranges: *
- Destination: Application Security Group
- Destination application security group: app-frontend-asg
- Service: SSH
- Action: Allow
- Priority: 100
- Name: AllowSSH
Click Add to create the rule.

Conclusion

At this point, you’ve:

Deployed VMs into existing subnets
Created and applied an ASG to organize frontend VMs
Created an NSG and associated it with the backend subnet
Added a rule allowing SSH traffic from frontend ASG members to backend resources

This security configuration enables precise control over internal communication within your Azure virtual network. By leveraging Application Security Groups (ASGs) and Network Security Groups (NSGs), you can implement scalable, role-based access policies that are easier to manage and adapt as your infrastructure grows. This layered approach enhances both security and flexibility, laying the groundwork for a robust cloud governance strategy.

Building Strong Connections: A Beginner's Guide to Setting Up Virtual Networks and Peering in Azure

Chinonso Ukadike — Thu, 01 May 2025 10:42:47 +0000

In today's digital world, every app or service relies on computers communicating with each other over a network.

Networking is like building roads that allow data to move safely and quickly between different locations. Without a good network, applications cannot function properly, and users may experience delays, security issues, or even complete failures.

When moving a web-based application to Microsoft Azure, setting up the right network structure is one of the first and most important steps. A strong network ensures different parts of your application can communicate securely, privately, and efficiently.

This guide walks you through how to create virtual networks (VNets), configure subnets, and set up peering between networks in Azure.

Step 1: Create the Virtual Networks

Sign in to the Azure Portal.
In the search bar, type Virtual Networks and select it.
Click on + Create.

Configure the first virtual network (app-vnet):

Resource Group: RG1
Name: app-vnet
Region: East US
IP Address Space: 10.1.0.0/16

Click Review + Create, then Create.

Repeat the steps to create the second virtual network (hub-vnet):

Resource Group: RG1
Name: hub-vnet
Region: East US
IP Address Space: 10.0.0.0/16

Click Review + Create, then Create.

Step 2: Create the Subnets

For app-vnet:

Go to Virtual Networks and select app-vnet.
Under Settings, click Subnets.
Click + Subnet and enter the following:
- Name: frontend
- Subnet Address Range: 10.1.0.0/24
- Click Add.
Click + Subnet again and enter:
- Name: backend
- Subnet Address Range: 10.1.1.0/24
- Click Add.

It should look like the image below after creation

For hub-vnet:

Go to Virtual Networks and select hub-vnet.
Under Settings, click Subnets.
Click + Subnet and enter:
- Subnet purpose: Azure Firewall
- Name: AzureFirewallSubnet
- Subnet Address Range: 10.0.0.0/26
- Click Add.

Step 3: Configure Virtual Network Peering

From app-vnet to hub-vnet:

Go to Virtual Networks and select app-vnet.
Under Settings, click Peerings.
Click + Add and enter:
- Peering Link Name: app-vnet-to-hub
- Virtual Network Deployment Model: Resource Manager
- Virtual Network: hub-vnet
- Peering Link Name (on remote network): hub-to-app-vnet
- Leave all other settings at their default.
Click Add.

Step 4: Verify the Setup

Go to Virtual Networks in the Azure Portal.
Select both app-vnet and hub-vnet.
Confirm:
- Correct subnets are created inside each VNet.
- Peering connection status is Connected.

Conclusion

Setting up Azure virtual networks with subnets and peering is a critical first step for creating secure and scalable cloud applications. By following these steps, you build a strong foundation where different parts of your application can communicate securely, leading to better performance, better management, and better protection against external threats.

Understanding how networking works in the cloud is essential for anyone involved in cloud deployment and infrastructure management.

Thanks for reading! If this helped you, leave a comment or share your tips on Azure networking! 💬✨

Mastering the Linux Terminal: A Practical Guide from Basics to Power Commands

Chinonso Ukadike — Tue, 01 Apr 2025 21:38:04 +0000

Introduction

The Linux terminal is not just for the elite few — it’s a skill every developer, admin, and tech-savvy user should understand. The command line provides precision, speed, and control. It can automate tasks, fix issues, and manage systems — all with a few keystrokes.

In this article, we’ll explore Linux commands in a practical, easy-to-understand way — starting with the basics and gradually diving into more powerful system commands.

1. Navigating the Linux Filesystem

One of the first things you’ll do in a Linux terminal is move around the filesystem.

Command	Description	Example	Output
`pwd`	Shows your current directory path	`pwd`	`/home/user/Documents`
`ls`	Lists files and folders in a directory	`ls -l`	Shows file sizes, owners, dates
`cd`	Changes the current directory	`cd /etc`	Moves into the `/etc` folder

Example

This sequence from the image above further shows the basic Linux terminal navigation. It begins with listing the contents of the current directory using ls, then navigates into the dir1 directory with cd dir1. Inside dir1, the ls command is used again to view its contents. The pwd command prints the full path of the current directory, confirming the location as /home/ubuntu/dir1. To move up one level, cd .. is used. Finally, cd ~ takes the user back to the home directory.

2. Managing Files and Directories

Linux provides powerful tools for creating, renaming, copying, and deleting files and folders.

Command	Description	Example	Result
`mkdir`	Create a new directory	`mkdir Projects`	Creates a folder named Projects
`touch`	Create a new empty file	`touch file.txt`	Creates file.txt
`cp`	Copy files or folders	`cp file.txt backup.txt`	Copies the file
`mv`	Move or rename files	`mv file.txt archive.txt`	Renames file.txt
`rm`	Remove files or folders	`rm file.txt` `rm -r folder/`	Deletes a file or folder

Be Careful with rm -rf — This will force delete folders without confirmation.

Example

From the image above, this terminal session demonstrates how to manage files and directories in Linux, including how to delete non-empty folders.

The session begins by creating a new directory named folder using the mkdir folder command.
The ls command is then used to confirm the presence of the new directory.
An empty file named file is created with touch file, and ls confirms it exists in the current directory.
The file file is then moved into the folder directory using mv file folder.
The user navigates into the folder directory using cd folder, and ls confirms that the file has been moved successfully.
The file is deleted using the rm file command.
ls is run again to confirm that the folder is now empty.
The user returns to the parent directory using cd .. and verifies the current contents with ls.

At this point, the user tries to delete the folder directory using rm folder, but this results in an error message:

rm: cannot remove 'folder': Is a directory

This happens because rm by itself can only delete files, not directories.

To resolve this, the user runs rm -r folder, which recursively deletes the directory and any contents it may contain (even though it's already empty in this case).
A final ls confirms that folder has been successfully deleted, leaving only the original directories and files.

This sequence highlights important distinctions between deleting files (rm) and directories (rm -r), along with standard file and folder management in the Linux command line.

3. Viewing and Editing Files

Before editing files, you’ll often want to view them, especially log files or configuration settings.

Command	Description	Example
`cat`	Shows file content	`cat notes.txt`
`less` / `more`	Opens files one screen at a time	`less syslog`
`head` / `tail`	Shows the start or end of a file	`tail -n 20 error.log`
`vim`	Opens a simple file editor	`vim file.txt`

Use Case:

When you're troubleshooting, tail -f /var/log/syslog helps you watch system logs in real-time.

4. Searching and Finding

Linux makes it easy to search for files and content using find and grep.

Command	Description	Example
`find`	Locates files/folders	`find /home -name "*.pdf"`
`grep`	Searches inside files	`grep "error" server.log`
`grep -r`	Recursively search in folders	`grep -r "port" /etc/nginx`

Use Case:

You’re checking a config folder to find which file contains a specific keyword.

Example

The image above illustrates a typical Linux terminal workflow for working with text files. It starts with the creation of a file using vim sample.txt. Inside the Vim editor, you enter the Insert mode by pressing i, which enables you to type in your text, and then saves and exits by pressing Esc, followed by Shift + esc + ;, typing wq, and hitting Enter. This process is useful when working directly in the terminal without relying on a graphical text editor.

To quickly check the file’s structure, the user runs head -n 1 sample.txt and tail -n 1 sample.txt to view the first and last lines of the file. These commands are helpful when dealing with large files where scrolling through the entire content isn’t practical—head and tail let you verify file formatting, headers, or summary lines at a glance.

The user then uses find *.txt to identify all .txt files in the current directory and runs grep error sample.txt to search for a specific keyword inside the file. After locating the file and confirming its contents, it is deleted with rm sample.txt, and ls is used to confirm the removal. Finally, cat text.txt displays the contents of another text file. Altogether, this flow demonstrates essential file creation, inspection, search, and cleanup techniques in a Linux environment.

5. User Permissions and Access Control

Every file and command has rules about who can read, write, or execute it. Linux uses permissions and ownership to manage this.

Command	Description	Example	What it Does
`chmod`	Change permissions	`chmod 755 script.sh`	Owner can read/write/execute; others can read/execute
`chown`	Change ownership	`chown user:group file.txt`	Assigns a file to a different user
`ls -l`	View permissions	`ls -l`	Displays permission strings like `-rw-r--r--`

6. Running Commands as Administrator (`sudo`)

Some actions — like installing software or editing system configs — require elevated privileges.

Command	Description	Example
`sudo`	Run a command as the superuser	`sudo apt update`
`sudo su`	Switch to root (superuser)	`sudo su`
`whoami`	See your current user	`whoami`

Explanation:

sudo stands for “superuser do”.
You'll be prompted for your password before the command executes.

Use Case:

Installing or updating software:

sudo apt install nginx

7. System Monitoring and Process Management

To keep your system healthy, you need to check memory, CPU, disk, and processes.

Command	Description	Example
`top`	Live view of CPU/memory usage	`top`
`htop`	A better visual version of top	`htop`
`ps aux`	List all running processes	`ps aux`
`kill` / `pkill`	End a process by PID or name	`kill 1234`, `pkill firefox`
`df -h`	Disk space usage	`df -h`
`du -sh`	Folder size summary	`du -sh Downloads`

🔧 Use Case

A process is frozen. Find its PID (Process ID) with ps aux, then end it:

kill 5423

8. Working with Networks

Linux makes it easy to test connectivity and manage network settings.

Command	Description	Example
`ping`	Test network connectivity	`ping google.com`
`curl`	Check a website or API	`curl -I https://example.com`
`wget`	Download files from the internet	`wget https://example.com/file.zip`
`ss`	Check open ports and services	`ss -tuln`

🔧 Use Case:

If you can’t access your web app. Use ping, curl, and ss to check if the server is up, the site is reachable, and the port is open.

9. Command Variations and Enhancements

Even familiar commands have powerful variations that can significantly improve productivity:

Command	Variation	Purpose
`ls -lh`	Human-readable sizes	Makes file sizes easier to read (e.g., MB/GB)
`rm -rf`	Force recursive delete	Deletes folders and contents without prompts
`cp -u`	Update-only copy	Copies files only if the source is newer
`grep -i`	Case-insensitive search	Finds matches regardless of case
`find -mtime +30`	Find old files	Locates files modified more than 30 days ago

🔧 Use Case:

Task: Find and delete all .log files older than 7 days.

find /var/log -type f -name "*.log" -mtime +7 -exec rm -f {} \;

Explanation:

find /var/log: Starts searching in the /var/log directory
-type f: Restricts the search to files only
-name "*.log": Matches files ending in .log
-mtime +7: Filters files modified more than 7 days ago
-exec rm -f {} \;: For each matching file, runs the rm -f command to delete it
- {} is replaced with the current file name
- -f forces deletion without prompting
- \; ends the -exec command (the backslash escapes the semicolon for the shell)

Caution:

This command permanently deletes files. Always double-check what will be affected with a dry run like this:

find /var/log -type f -name "*.log" -mtime +7

Mastering the Linux command line is not just about typing instructions — it's about understanding how your system works. From navigating and organizing files to managing permissions and automating tasks, each command is a tool in your toolbox.

The key is practice. Use these commands often, explore their options, and experiment safely. Over time, the terminal becomes not just powerful, but second nature.

Building C# Web and Console Applications: A Hands-On Guide with a Guessing Game

Chinonso Ukadike — Thu, 20 Mar 2025 19:45:13 +0000

Introduction

C# is a versatile programming language widely used for developing various types of applications, including web and console applications. The .NET framework and .NET Core provide robust environments for building scalable, high-performance applications.

This guide outlines the steps for creating a C# web application using ASP.NET Core and a C# console application using .NET.

As part of this tutorial, we will build a simple Guessing Game for both console and web environments. This will demonstrate how to implement user interaction, logic processing, and UI handling in different application types.

1. Creating a C# Console Application

A console application is a simple, lightweight program that runs in a command-line interface. It is typically used for utilities, automation scripts, or testing.

Prerequisites

Install .NET SDK from Microsoft
Use an IDE such as Visual Studio, Visual Studio Code, or JetBrains Rider

Steps to Create a Console Application

Step 1: Open Command Prompt or Terminal

Run the following command to create a new console application:

dotnet new console -n MyConsoleApp

Step 2: Navigate to the Project Directory

cd MyConsoleApp

Step 3: Open and Modify `Program.cs`

We will implement a simple guessing game where the user must guess a randomly generated number.

using System;

class GuessingGame
{
    static void Main()
    {
        Random random = new Random();
        int numberToGuess = random.Next(1, 101);
        int userGuess = 0;
        int attempts = 0;

        Console.WriteLine("Welcome to the Guessing Game!");
        Console.WriteLine("Try to guess the number between 1 and 100.");

        while (userGuess != numberToGuess)
        {
            Console.Write("Enter your guess: ");
            string input = Console.ReadLine();

            // Validate input
            if (!int.TryParse(input, out userGuess) || userGuess < 1 || userGuess > 100)
            {
                Console.WriteLine("Invalid input. Please enter a number between 1 and 100.");
                continue;
            }

            attempts++;

            if (userGuess < numberToGuess)
                Console.WriteLine("Too low! Try again.");
            else if (userGuess > numberToGuess)
                Console.WriteLine("Too high! Try again.");
            else
                Console.WriteLine($"Congratulations! You guessed it right in {attempts} attempts.");
        }
    }
}

Step 4: Build and Run the Application

Before running the modified code, build the application using:

dotnet build

Then run the application:

dotnet run

2 Creating a C# Web Application using ASP.NET Core

A web application is a more complex system that runs on a web server and interacts with users through a web browser.

Prerequisites

Install the latest .NET SDK
Install Visual Studio (with ASP.NET and Web Development workload)
Basic knowledge of HTML, CSS, and JavaScript

Steps to Create a Web Application

Step 1: Open Visual Studio and create a new project.

dotnet new webapp -n MyWebApp

Step 2: Navigate to the Project Directory

cd MyWebApp

Step 3: Open `Program.cs` and Modify It

We will implement a simple web-based guessing game using ASP.NET Core Razor Pages.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;
using System;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseHttpsRedirection();

// Generate a random number to guess
int numberToGuess = new Random().Next(1, 101);
int attempts = 0;

// Serve the game page and process guesses
app.Map("/", async context =>
{
    string resultMessage = ""; // This will hold feedback messages

    // Only process form data if it's a POST request
    if (context.Request.Method == "POST")
    {
        var form = await context.Request.ReadFormAsync();
        string guessInput = form["userGuess"];

        if (!string.IsNullOrEmpty(guessInput) && int.TryParse(guessInput, out int userGuess))
        {
            attempts++;

            if (userGuess < 1 || userGuess > 100)
                resultMessage = "<p style='color: red;'> Invalid input! Please enter a number between 1 and 100.</p>";
            else if (userGuess < numberToGuess)
                resultMessage = "<p style='color: blue;'> Too low! Try again.</p>";
            else if (userGuess > numberToGuess)
                resultMessage = "<p style='color: blue;'> Too high! Try again.</p>";
            else
            {
                resultMessage = $"<p style='color: green;'> Congratulations! You guessed it right in {attempts} attempts.</p>";
                numberToGuess = new Random().Next(1, 101); // Reset the game
                attempts = 0;
            }
        }
    }

    // HTML structure
    string html = $@"
    <html>
    <head>
        <title>Guessing Game</title>
    </head>
    <body style='font-family: Arial, sans-serif; text-align: center;'>
        <h2>Welcome to the Web Guessing Game!</h2>
        <p><strong>Guess a number between 1 and 100.</strong></p>

        <form method='post'>
            <input type='number' name='userGuess' min='1' max='100' required>
            <button type='submit'>Guess</button>
        </form>

        {resultMessage} <!-- This ensures the result is displayed below the input field -->
    </body>
    </html>";

    context.Response.ContentType = "text/html"; // Ensure correct content type
    await context.Response.WriteAsync(html);
});

app.Run();

Step 4: Build and Run the Application

Before running the modified code, build the application using:

dotnet build

Then run the application:

dotnet run

After running, the application will be accessible at https://localhost:5001 (or as indicated in the console output).

3 Differences Between Console and Web Applications

Feature	Console Application	Web Application
UI	Command-line	Web-based
User Interaction	Text input/output	Browser-based interface
Use Case	Automation, testing, scripts	Web services, websites
Framework	.NET Console	ASP.NET Core

4 Explanation of Commands Used

Command	Description
`dotnet new console -n MyConsoleApp`	Creates a new console application project named `MyConsoleApp`.
`dotnet new webapp -n MyWebApp`	Creates a new web application project named `MyWebApp`.
`cd MyConsoleApp` / `cd MyWebApp`	Changes the directory to the specified project folder.
`dotnet build`	Compiles the project, checking for errors and generating necessary binaries.
`dotnet run`	Runs the application after it has been built.

This guide has provided a comprehensive, hands-on approach to building both C# console and web applications, highlighting their unique strengths and use cases.

Through the Guessing Game project, we explored how applications handle user interaction, logic processing, and UI design across different environments.

Console applications are lightweight, efficient, and ideal for automation, scripting, and quick prototyping.
Web applications offer a more interactive, browser-based experience, making them suitable for dynamic and scalable solutions.

By harnessing the robust capabilities of .NET, developers can create high-performance applications that cater to a wide range of business and technical needs. Whether building simple command-line tools or full-fledged web applications, mastering these concepts will provide a strong foundation for future development endeavors.

Keep learning, keep building!

Secure and Scalable File Sharing with Azure Files: A Step-by-Step Guide

Chinonso Ukadike — Sun, 16 Mar 2025 16:59:31 +0000

Secure and Scalable File Sharing with Azure Files: A Step-by-Step Guide

Introduction

In today's fast-paced digital world, businesses rely heavily on secure and efficient file-sharing solutions to collaborate effectively. Whether it's storing project documents, sharing reports with teams, or ensuring critical files are backed up, having a reliable, cloud-based file system is crucial.

Azure File Storage provides a fully managed, highly available, and scalable solution that allows organizations to store and access files from multiple locations. With features like snapshots for file recovery and network security restrictions, Azure Files is an excellent choice for organizations that need enterprise-grade file storage without the complexity of managing physical servers.

This guide will walk you through creating an Azure File Share, configuring snapshots for data protection, and securing access to enhance security and compliance.

Use Case: Cloud-Based Document Management for Remote Teams

Imagine a consulting firm with employees working remotely across different locations. The firm needs a centralized document storage system where consultants can access project files, upload reports, and collaborate in real-time with the following requirements:

Files should be easily accessible from different devices and locations.
Snapshots should be enabled to prevent data loss due to accidental deletion.
Access should be restricted so only authorized users from the corporate network can retrieve sensitive documents.

With Azure Files, the company can set up a secure and scalable document repository that ensures smooth collaboration, high availability, and data protection.

Getting Started

Now that we understand the importance of Azure File Storage and its benefits for remote teams, let's dive into the step-by-step implementation process. We will cover:

Creating an Azure File Share for centralized document storage.
Configuring snapshots for file protection and recovery.
Restricting access to ensure only authorized users can retrieve sensitive files.

Let’s get started!

Step 1: Create and Configure an Azure Storage Account

To use Azure File Storage, we first need to create a Storage Account optimized for file shares.

1.1 Create a Storage Account for File Sharing

Search for "Storage Accounts" in the Azure Portal and select it.
Click + Create on the storage account screen.
Under Resource group, select Create new, provide a name, and click OK.
Enter a Storage account name (must be globally unique).
Set Performance to Premium for fast and reliable access.
Set Premium account type to File shares.
Set Redundancy to Zone-redundant storage (ZRS) for better data protection.
Click Review + Create and then Create.
Once deployed, click Go to Resource.

Step 2: Create and Configure an Azure File Share

Now that the storage account is ready, we can create an Azure File Share to store project documents.

2.1 Create a File Share

In the Storage Account, go to the File shares section.
Click + File Share.
Provide a Name (e.g., project-documents).
Keep the default settings and click Create.

2.2 Organize Files with Directories

To keep the file share structured, we will create a directory for different types of documents.

Open the File Share.
Click + Add Directory and name it reports.
Click Browse, select the reports directory, and click Upload to add a sample file for testing.

Step 3: Enable Snapshots for Data Protection

Snapshots help protect files from accidental deletion or corruption by allowing users to restore previous file versions.

3.1 Creating a Snapshot

In the File Share, go to the Snapshots section.
Click + Add Snapshot (optional: add a comment for reference).
Click OK to create the snapshot.

3.2 Restore a Deleted File from a Snapshot

Open the File Share and navigate to the reports directory.
Locate the uploaded file, open its Properties, and click Delete.
Confirm the deletion.
Go to the Snapshots section and select the latest snapshot.
Find the deleted file, right-click, and select Restore.
You have two options when restoring the file:
- Restore as a copy: Provide a new name for the file, creating a duplicate while keeping the snapshot intact.
- Restore to overwrite the original file: If the file still exists in the directory, this option will replace it with the version from the snapshot. However, since the file was deleted, it will be restored as a new file without overwriting anything.
Verify that the file has been successfully restored by going to the reports directory.

Step 4: Restrict Access to a Corporate Virtual Network

To enhance security, we will restrict access so that only users within a specific corporate network can access the file share.

4.1 Create a Virtual Network

Search for "Virtual Networks" in the Azure Portal and select it.
Click Create, select the resource group, and name the VNet (e.g., corporate-network).
Click Review + Create, then Create.
Once deployed, click Go to Resource.
In Settings, go to Subnets.
Select the default subnet.
Under Service Endpoints, select Microsoft.Storage.
Click Save.

Why are we selecting Microsoft.Storage?

Service Endpoints improve security by allowing Azure services to communicate privately within Azure’s network instead of going through the public internet. By selecting Microsoft.Storage, we ensure that our Azure Storage Account (which holds the file share) is only accessible from this virtual network. This helps keep the connection secure and private, reducing the chance of unauthorized access while also improving speed.

4.2 Restrict File Storage Access to the Virtual Network

Go back to the Storage Account.
Under Security + Networking, select Networking.
Change Public network access to Enabled from selected virtual networks and IP addresses.
Click Add existing virtual network and select corporate-network and its subnet.
Click Save.

4.3 Verify Restricted Access

Try to access the file share from a different network.
You should see an unauthorized access message, confirming the restriction.

Conclusion

Through this guide, you've learned how to:

Set up an Azure Storage Account and File Share to store and organize files efficiently.
Create directories and upload files for structured data management.
Enable snapshots for data protection, ensuring quick recovery from accidental deletions.
Restrict access using Virtual Networks to enhance security and prevent unauthorized users from accessing sensitive information.

With Azure File Storage, organizations can eliminate the challenges of traditional file servers, improve data availability, and ensure business continuity. Whether handling project documentation, financial records, or sensitive reports, Azure Files provides the flexibility, security, and reliability needed for modern file management.

By implementing these best practices, your business can streamline operations, safeguard critical data, and enable seamless collaboration—all while leveraging the power of the cloud.

Secure and Scalable Storage in Azure: Replication, Object Replication, Lifecycle Management, and Access Control

Chinonso Ukadike — Mon, 10 Mar 2025 20:25:23 +0000

1.0 Introduction to Azure Storage
Azure Storage is a cloud-based solution offered by Microsoft, providing scalable, durable, and highly available storage services for a wide range of business applications. It eliminates the need for on-premises storage infrastructure and offers built-in security, redundancy, and access control to ensure seamless data management.
Organisations use Azure Storage to:

Store and retrieve unstructured data such as images, videos, and logs.
Host static websites with built-in web access capabilities.
Replicate data across regions for disaster recovery and high availability.
Manage data lifecycle through tiered storage options to optimize costs and performance.

1.1 Key Benefits of Azure Storage
Scalability – Easily handles data volumes from gigabytes to petabytes, supporting business growth.
High Availability – Ensures 99.9% uptime with geo-replication for business continuity.
Cost Efficiency – Supports tiered storage, reducing costs for infrequently accessed data.
Security – Provides encryption, private endpoints, and fine-grained access control for robust data protection.

1.2 Azure Storage Types
Azure Storage is categorized into different services, each designed for specific use cases:

This report focuses on Azure Blob Storage, which is widely used for storing and managing unstructured data.

2.0 Creating an Azure Storage Account

2.1 What is a Storage Account?
A Storage Account acts as a container for storing Azure Storage services, including blobs, files, queues, and tables. It provides:

A globally unique namespace for data storage.
Security configurations such as RBAC, SAS, and encryption.
Options for replication and lifecycle policies.

2.2 Steps to Create an Azure Storage Account

Step 1: Log in to Azure Portal

Navigate to Azure Portal (https://portal.azure.com).
Log in to the portal with your credentials
Search for Storage Accounts and click + Create.

Step 2: Configure the Storage Account

Subscription: Select an active subscription.
Resource Group: Choose an existing group or create a new one.
Storage Account Name: Enter a globally unique name (e.g., mystorage123).
Region: Choose a preferred Azure region.
Performance:
- Standard (for general-purpose storage).
- Premium (for low-latency, high-performance storage).
Replication: Choose a replication strategy (covered in Section 3).
Click Review + Create → Create.

3.0 Configuring Replication in Azure Storage

3.1 Why is Replication Important?
Replication ensures data durability and availability by creating multiple copies of your data. This helps protect against hardware failures, cyberattacks, or regional outages, ensuring that your information remains accessible even if something goes wrong.

Imagine you have an important document stored on your laptop. If your laptop crashes or gets stolen, you might lose that document forever. But if you’ve saved copies of it in multiple places like on an external hard drive, in the cloud, and on a USB drive, you can still access it even if one copy is lost.

Similarly, Azure Storage automatically creates multiple copies of your data, so even if one server or data centre goes down, your information remains safe and available.

Azure provides multiple replication options:

3.2 Enabling Replication

Open the Storage Account → Data Management.
Under Redundancy, select LRS, ZRS, GRS, or RA-GRS.
Click Save.

4.0 Implementing Object Replication in Blob Storage

4.1 What is Object Replication?
Object Replication enables automatic synchronization of blobs between containers, improving disaster recovery and geo-distribution.

4.2 Steps to Set Up Object Replication

Step 1: Create Source and Destination Containers

Open the Source Storage Account → Data Storage → Container → + Container (source-container).
Set Public Access Level to Private.

Repeat for the Destination Storage Account (destination-container).

Note:
To successfully configure the Object Replication policy, you must follow the process from Session 1 to Session 4 to:

Create a second storage account – This serves as the replication target, where data will be copied.
Set up a destination container – This container will receive the replicated objects from the source storage account. Without these prerequisites, Object Replication cannot be properly configured, as the system needs both a source and a destination to replicate data effectively.

Step 2: Configure Object Replication Policy

Open Source Storage Account → Data Management → Object Replication.
Click + Create Replication Rule.

Select the Destination Storage Account and authenticate access.
Choose the Source Container and Destination Container.
Click Add Rule.

Note:
You can click on the "Change" link under "Copy Over" to modify the replication rule based on your needs. The available options include:

Copy all contents – This option replicates everything in the source container to the destination container, ensuring a complete copy.
*Copy only new objects *– Only newly added files in the source container will be replicated to the destination container, while existing data remains unchanged.
Add a custom rule – You can define specific conditions for replication, such as filtering by blob name, prefix, or metadata, to control which objects are copied.

This flexibility allows you to tailor Object Replication to your organization's storage and data synchronization needs.

*Steps to Verify Object Replication Configuration in Azure Storage *

Upload a Test File to the Source Container
- In the source storage account, go to the source container.
- Upload a test file.
Verify the File in the Destination Container
- Navigate to the destination storage account and open the destination container.
- Check if the test file has been replicated successfully. If the file does not appear in the destination container, check for policy misconfiguration, delays, or insufficient permissions, then reattempt the setup.

5.0 Securing Access with Shared Access Signatures (SAS)

5.1 Why Use SAS?
Shared Access Signatures (SAS) provide a secure and flexible way to grant temporary, controlled access to Azure Storage resources without exposing sensitive account keys. Instead of sharing full administrative access, organizations can generate time-limited and permission-specific SAS tokens, allowing external users or applications to interact with storage resources based on predefined rules.

Imagine you own a warehouse and have a master key that opens all doors. Instead of giving visitors full access, you provide a temporary key that only allows entry to a specific storage room for a limited time. This way, they can only access what they need without compromising overall security.

Similarly, SAS in Azure Storage allows organizations to grant restricted access to data while keeping the master account key secure.

Key Benefits of Using SAS:

Enhanced Security – SAS Prevents unauthorized access by restricting permissions, ensuring users only perform allowed actions (e.g., read, write, delete).
Temporary Access – SAS tokens have an expiration time, reducing the risk of long-term security vulnerabilities.
Granular Control – You can define access levels, limiting actions to specific files, containers, or storage services.
No Exposure of Account Keys – Instead of sharing the storage account key (which grants full access), SAS provides a safer alternative with limited access scope.

5.2 Generating a SAS Token

Open Azure Portal → Storage Accounts.
Navigate to Security + Networking → Shared Access Signature (SAS).
Select Permissions (Read, Write, Delete, etc.).
Set an Expiration Date for token validity.
Click Generate SAS and connection string.

6.0 Implementing Lifecycle Management

Lifecycle Management in Azure Storage helps organizations automatically manage their data by moving, retaining, or deleting files based on predefined rules. This ensures cost efficiency, compliance, and optimal performance without manual intervention.

Imagine your phone storage is running out because of thousands of old photos and videos. Instead of deleting them manually, you set up a rule: "Move photos older than 1 year to cloud storage and delete anything older than 5 years."

Similarly, Azure Lifecycle Management helps businesses automatically move or remove old data, keeping storage costs low and systems running smoothly.

6.1 Why is Lifecycle Management Important?

Cost Savings – Not all data is accessed frequently. Lifecycle policies automatically move infrequently used files (e.g., old logs, backups) to cheaper storage tiers (such as Cool or Archive storage), reducing costs without deleting valuable data.
Data Retention Compliance – Some industries require data to be stored for a specific period (e.g., financial records must be kept for 7 years). Lifecycle policies can automatically delete expired data, ensuring compliance with legal and regulatory requirements.
Performance Optimization – Unused or redundant files can clutter storage and slow down operations. By freeing up space through automatic deletion or archiving, lifecycle management keeps storage lean and efficient, improving overall system performance.

6.2 Configuring Lifecycle Management
Step 1: Open Lifecycle Management

Navigate to your Storage Account → Data Management → Lifecycle Management.
Click + Add Rule.

Step 2: Define a New Lifecycle Rule

Move to Cold Tier after 30 days.

Step 3: Save and Enable the Rule

Click Review + Add.
Click Save.

7.0 Conclusion
Azure Storage provides secure, scalable, and highly available solutions for modern data management. By implementing replication, object replication, lifecycle management, and Shared Access Signatures (SAS), organizations can enhance data durability, optimize costs, and improve security. These features ensure business continuity, efficient storage management, and controlled data access. Leveraging Azure Storage effectively enables businesses to protect, manage, and optimize their data with confidence.

Mastering the Essentials of IT Infrastructure and Cloud Computing

Chinonso Ukadike — Sat, 22 Feb 2025 20:25:54 +0000

As businesses continue to embrace digital transformation, the demand for efficient and reliable IT infrastructure has never been higher. Understanding key concepts like virtualization, scalability, and fault tolerance is crucial for optimizing performance and ensuring seamless service delivery. Let’s dive into these essential terms and explore their impact on modern technology.

Virtualization: The Foundation of Modern IT

Virtualization allows multiple virtual environments to run on a single physical machine, maximizing resource utilization and efficiency. Instead of using separate physical servers for different applications, businesses can create virtual machines (VMs) that operate independently on the same hardware.

This is made possible by a hypervisor, software that manages virtual machines and allocates resources efficiently. Virtualization reduces hardware costs, improves flexibility, and enhances disaster recovery by enabling quick system backups and restorations.

Scalability: Preparing for Growth

Scalability is all about handling growth effectively. A scalable system can expand to accommodate increased demand without performance degradation. There are two main types:

Vertical Scalability (Scaling Up): Enhancing an existing system by adding more power, like CPU or memory.
Horizontal Scalability (Scaling Out): Expanding capacity by adding more machines to share the workload. A well-designed scalable system ensures businesses can grow seamlessly without major infrastructure overhauls.

Agility: Adapting to Change Effortlessly

Agility in IT refers to how quickly an organization can adjust to evolving demands, whether it’s new market trends or customer expectations. Cloud computing plays a vital role in agility by offering on-demand resources, fast deployment, and minimal downtime. Businesses that prioritize agility can innovate faster and stay ahead of the competition.

High Availability: Keeping Systems Up and Running

Nobody likes downtime, and that’s where high availability (HA) comes in. HA ensures that services remain operational, even in the face of hardware failures or network disruptions. By implementing redundancy, failover mechanisms, and load balancing, businesses can minimize downtime and maintain customer trust.

Fault Tolerance: Ensuring Continuous Operations

While high availability minimizes downtime, fault tolerance takes it a step further. It enables systems to keep running even when critical components fail. With built-in redundancies and automated recovery mechanisms, fault-tolerant systems eliminate single points of failure, ensuring uninterrupted service.

Global Reach: Connecting the World Seamlessly

In today’s interconnected world, businesses need to serve customers globally without performance issues. Thanks to cloud computing and distributed data centers, organizations can achieve global reach by reducing latency and delivering content efficiently to users worldwide. This not only enhances user experience but also strengthens a company’s competitive edge.

Elasticity vs. Scalability: Understanding the Difference

Though often confused, scalability and elasticity have distinct meanings:

Scalability refers to the ability to expand capacity over time to handle increasing workloads.
Elasticity allows resources to automatically adjust in real time based on demand fluctuations.

For instance, an online store preparing for a holiday sale may scale up its servers in advance. Meanwhile, a video streaming service benefits from elasticity, as its infrastructure automatically adjusts to spikes in viewership during a major event.

Final Thoughts

Mastering these key concepts is essential for businesses looking to optimize their IT infrastructure. Whether it’s virtualization for efficiency, scalability for growth, or fault tolerance for reliability, leveraging these principles ensures a smooth and resilient digital experience. As technology continues to evolve, staying informed and adaptable is the key to success.

DEV Community: Chinonso Ukadike

Securing Azure Networks: Creating and Configuring Network Security Groups (NSGs) and Application Security Groups (ASGs)

Step 1: Deploy Virtual Machines to Existing Subnets

Step 2: Create an Application Security Group (ASG)

Step 3: Associate VM1 with the Application Security Group

Step 4: Create a Network Security Group (NSG)

Step 5: Associate the NSG with the Backend Subnet

Step 6: Add an Inbound Security Rule to Allow SSH from Frontend ASG

Conclusion

Building Strong Connections: A Beginner's Guide to Setting Up Virtual Networks and Peering in Azure

Step 1: Create the Virtual Networks

Step 2: Create the Subnets

Step 3: Configure Virtual Network Peering

Step 4: Verify the Setup

Conclusion

Mastering the Linux Terminal: A Practical Guide from Basics to Power Commands

Introduction

1. Navigating the Linux Filesystem

2. Managing Files and Directories

3. Viewing and Editing Files

4. Searching and Finding

5. User Permissions and Access Control

6. Running Commands as Administrator (sudo)

7. System Monitoring and Process Management

8. Working with Networks

9. Command Variations and Enhancements

🔧 Use Case:

Explanation:

Caution:

Building C# Web and Console Applications: A Hands-On Guide with a Guessing Game

Introduction

1. Creating a C# Console Application

Prerequisites

Steps to Create a Console Application

Step 1: Open Command Prompt or Terminal

Step 2: Navigate to the Project Directory

Step 3: Open and Modify Program.cs

Step 4: Build and Run the Application

2 Creating a C# Web Application using ASP.NET Core

Prerequisites

Steps to Create a Web Application

Step 1: Open Visual Studio and create a new project.

Step 2: Navigate to the Project Directory

Step 3: Open Program.cs and Modify It

Step 4: Build and Run the Application

3 Differences Between Console and Web Applications

4 Explanation of Commands Used

Secure and Scalable File Sharing with Azure Files: A Step-by-Step Guide

Secure and Scalable File Sharing with Azure Files: A Step-by-Step Guide

Introduction

Use Case: Cloud-Based Document Management for Remote Teams

Getting Started

Step 1: Create and Configure an Azure Storage Account

1.1 Create a Storage Account for File Sharing

Step 2: Create and Configure an Azure File Share

2.1 Create a File Share

2.2 Organize Files with Directories

Step 3: Enable Snapshots for Data Protection

3.1 Creating a Snapshot

3.2 Restore a Deleted File from a Snapshot

Step 4: Restrict Access to a Corporate Virtual Network

4.1 Create a Virtual Network

Why are we selecting Microsoft.Storage?

4.2 Restrict File Storage Access to the Virtual Network

4.3 Verify Restricted Access

Conclusion

Secure and Scalable Storage in Azure: Replication, Object Replication, Lifecycle Management, and Access Control

Mastering the Essentials of IT Infrastructure and Cloud Computing

Virtualization: The Foundation of Modern IT

Scalability: Preparing for Growth

Agility: Adapting to Change Effortlessly

High Availability: Keeping Systems Up and Running

Fault Tolerance: Ensuring Continuous Operations

Global Reach: Connecting the World Seamlessly

Elasticity vs. Scalability: Understanding the Difference

Final Thoughts

6. Running Commands as Administrator (`sudo`)

Step 3: Open and Modify `Program.cs`

Step 3: Open `Program.cs` and Modify It