DEV Community: EMMANUEL

Project on how to build Weather forcast API

EMMANUEL — Sun, 01 Feb 2026 02:46:22 +0000

Architecture Flow

Built locally using .NET 8 >> Tested locally to ensure correctness >> Containerized with Docker >> Stored securely in Azure Container Registry >> Deployed to Azure Kubernetes Service >> Automatically updated via GitHub Actions

Required Software

Visual Studio Code
.NET 8 SDK
Git
Docker Desktop ⚠️ Start Docker Desktop after installation
Azure CLI
kubectl
GitHub CLI (optional but recommended)

✅ Verify Installations
In VS Code, after installation, create a folder for the project and verify these dotnet, git, docker, az , kubectl. Run the following commands:

dotnet --version
git --version
docker --version
az --version
kubectl version --client

Step 1: Create and Test the .NET Application Locally

Never deploy untested code. Testing locally allows you to:

Catch errors early
Validate endpoints
Avoid expensive cloud debugging

1.1 Create Project Structure

mkdir weather-app-demo
cd weather-app-demo
mkdir WeatherApp
cd WeatherApp

1.2 Initialize the .NET Web API

we initialize a .NET Web API to get the application ready to receive, process, and respond to HTTP requests correctly. Initialization wires everything together so the Web API can run reliably, securely, and predictably.

dotnet new webapi -minimal

1.3 Add Required Packages

dotnet add package Microsoft.Extensions.Diagnostics.HealthChecks
dotnet add package Swashbuckle.AspNetCore

This package lets us monitor the health of the Web API and its dependencies.

It check if the API is running
🗄️ Verify dependencies like databases, APIs, caches
🚦 Expose health endpoints (e.g. /health)
☁️ Support cloud platforms (Azure, Kubernetes, load balancers)

We add Swashbuckle to automatically generate interactive API documentation and testing tools.

1.4 Replace Program.cs

1.5 Test Locally

We use dotnet run to build and start a .NET application locally so we can test and run it during development..NET will:

🔨 Compile the code (build the project)
▶️ Start the application
🌐 Launch the Web API / app on a local server (Kestrel)

Test endpoints:

http://localhost:8080/

http://localhost:8080/weather

http://localhost:8080/swagger

http://localhost:8080/health

✅ If this works, your app is ready for containerization

🐳 Step 2: Containerize the Application with Docker

We containerise an application to make it run the same way everywhere — on a laptop, server, or in the cloud.

2.1 Create Dockerfile

Create Dockerfile using the command touch dockerfile, then paste the code below.

2.2 Create .dockerignore

We create a .dockerignore file to tell Docker which files and folders NOT to include when building an image. To do that we do touch .dockerignore to create .dockerfile and the paste the code below.

bin/ obj/ .vs/ .vscode/ .git/ .gitignore Dockerfile README.md *.log

2.3 Build and Test Container Locally

_docker build -t weather-app:local .

docker run -p 8080:8080 weather-app:local_

Test again in browser or with curl. ✅ If it works locally, it will work in AKS.

🔧 Step 3: Create Azure Infrastructure

3.1 Login to Azure

_az login _

3.2 Create Resource Group

az group create --name student-demo --location eastus

3.3 Create Azure Container Registry (ACR)

az acr create \
--resource-group student-demo \
--name studentdemoacr \
--sku Basic

3.4 Build & Push Image Using ACR

We do ACR Build:

To avoids Docker compatibility issues
Runs inside Azure
Faster CI/CD later

_az acr build \
--registry studentdemoacr \
--image weather-app:latest _

3.5 Create AKS Cluster with ACR Attached

We do this so AKS can securely pull Docker images from Azure Container Registry (ACR) without extra credentials or manual setup

az aks create \
--resource-group student-demo \
--name student-aks \
--node-count 1 \
--attach-acr studentdemoacr \
--enable-managed-identity \
--generate-ssh-keys

3.6 Connect kubectl to AKS

We connect kubectl to AKS so our local machine can securely communicate with and manage the AKS cluster. Without this connection, you cannot see, deploy, or control anything in the cluster.

az aks get-credentials \
--resource-group student-demo \
--name student-aks

Verify:

kubectl get nodes

☸️ Step 4: Deploy to Kubernetes

4.1 Create Kubernetes Manifests

We create Kubernetes manifests to tell Kubernetes exactly how we want our application to run.Kubernetes doesn’t guess.
Manifests are the instructions + desired state.

mkdir k8s
cd k8s

deployment.yaml

Use touch deployment.yaml to create our deployment yaml file and paste the code.

service.yaml
Use touch service.yaml and paste the code

4.2 Apply Manifests

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Check status:

kubectl get pods
kubectl get services

🔁 Step 5: CI/CD with GitHub Actions

Why CI/CD? : No manual deployments.Faster releases and. Safer changes

5.1 Initialize Git

git init
git add .
git commit -m "Initial Weather App"

5.2 Create GitHub Repo

Login to your Github

gh auth login

Create a repository

gh repo create weather-app-demo --public --source=. --push

5.3 Create Workflow File

mkdir -p .github/workflows

To create github work flow use
touch .github/workflows/deploy.yml and paste the code below

🌐 Step 6: Access the Application

kubectl get service weather-service

In this project, we successfully built, containerized, and deployed a .NET 8 Web API using modern cloud-native practices on Microsoft Azure. Starting with local development and testing, we ensured application correctness before moving into containerization with Docker for consistency across environments. The container image was securely stored in Azure Container Registry and deployed to Azure Kubernetes Service, enabling scalability, resilience, and production-grade orchestration.

By integrating GitHub Actions, we automated the build and deployment pipeline, ensuring that every code change is safely and consistently delivered to AKS without manual intervention. This end-to-end workflow demonstrates a real-world DevOps lifecycle—combining application development, containerization, infrastructure provisioning, Kubernetes deployment, and CI/CD automation.

Overall, this project highlights best practices for building and deploying cloud-native applications, reinforcing the importance of automation, reliability, and scalability in modern software engineering.

Merging and Branching in DevOps.

EMMANUEL — Sun, 18 Jan 2026 17:17:35 +0000

How to safely work on features using branches and how to merge them using different strategies. In this ;, i'm going to use VS Code for this project.

Step 1
We create a folder for the project.
mkdir git-merge-lab

Step 2
Moves terminal into the folder. So Git works inside the project directory only.

cd git-merge-lab

Step 3
Initialize Git: Starts Git tracking by creating. gitfolder. because Without this, Git cannot save versions of files.

git init

Step 4
Creates README file with project title.A project must have files before committing.

echo "# Team Project" > README.md

Step 5
Move file to staging area. Git only commits files that are staged.

git add README.md

Step 6
Saves snapshot into Git history. Allows recovery if something breaks later.

git commit -m "Initial commit"

Step 7
Renames default branch to main.A Modern standard branch name used by GitHub.

git branch -M main

FAST-FORWARD MERGE

Step 8
Creates and switches to new branch. New features should not be built on main.

git checkout -b feature-login

Step 9
Creates feature file. This Simulates adding new functionality.

echo "Login page created" > login.txt

Step 10
Saves feature changes to branch.Work must be committed before merging.

git add login.txt

git commit -m "Add login feature"

Step 11
Returns to main branch.You merge into the current branch

git checkout main

Step 12
Merge Feature (Fast-Forward):Moves main forward to include feature. Because no other changes existed on main.

git merge feature-login

3-WAY MERGE (PARALLEL WORK)

Step 13
Create Profile Feature : Because another feature is developed independently.

git checkout -b feature-profile
echo "Profile page created" > profile.txt
git add profile.txt
git commit -m "Add profile feature"

Step 14
Create Settings Feature : So two branches now change project separately.

git checkout main
git checkout -b feature-settings
echo "Settings page created" > settings.txt
git add settings.txt
git commit -m "Add settings feature"

Step 15
Merge First Feature: It Adds profile feature to main.

git checkout main
git merge feature-profile

Step 16
Merge Second Feature (3-Way): It Combines two branch histories. Git must compare main, feature, and common base.
Result: Merge commit is created

git merge feature-settings

MERGE CONFLICT
Step 17 : Bugfix edits same file as before.

git checkout -b bugfix-title
echo "# Team Project Version 2" > README.md
git add README.md
git commit -m "Update title in bugfix"

Step 18
Feature Also Changes README

_git checkout main
git checkout -b feature-title-update
echo "# Awesome Team Project" > README.md
git add README.md
git commit -m "Update title in feature"
_

Step 19
Trigger Conflict: Git cannot auto-merge and stops.It does not know which version to keep.

git checkout main
git merge bugfix-title
git merge feature-title-update

Step 20
Fix Conflict Manually **: Open **README.md, delete conflict markers, and write:

# Awesome Team Project Version 2

Then run:

git add README.md
git commit -m "Resolve merge conflict on title"

This tells Git conflict is fixed and saves final version.

SQUASH MERGE
Create Feature With Many Commits and Squash It.

git checkout -b feature-dashboard

echo "Dashboard layout" > dashboard.txt
git add dashboard.txt
git commit -m "Add dashboard layout"

echo "Add charts" >> dashboard.txt
git add dashboard.txt
git commit -m "Add charts to dashboard"

echo "Fix alignment" >> dashboard.txt
git add dashboard.txt
git commit -m "Fix dashboard alignment"

Now squash:
It Combines many feature commits into one clean commit on main.

git checkout main
git merge --squash feature-dashboard
git commit -m "Add dashboard feature

PUSH PROJECT TO GITHUB

Step 22

Create Repository on GitHub (Website Step):

Open - https://github.com >> Log in >> Click New Repository >> Repository name: 👉 git-merge-lab. N/B❗ DO NOT check: Add README/Add .gitignore. >> Click Create Repository.

Why we do this: Because we need an empty online repo to receive our local project.

What you will see: A page showing commands for pushing existing repo.

Step 23
Connect Local Repo to GitHub:

Copy your repo URL from GitHub, then run: Links your local project to GitHub. So Git knows where to send your code when you push.

_git remote add origin https://github.com/EMMANUELOBINNAONYEMUCHE/git-merge-lab.git
_

Step 24

Push All Branches to GitHub: Uploads all branches (main, feature, bugfix) to GitHub. So Your teacher must see all merge work, not only main branch. It Links your local branches to GitHub so future pushes are easier.

git push -u origin --all

Step 25
Confirm Upload on GitHub: Refresh GitHub page. Click Branches

You must see:

main
feature-login
feature-profile
feature-settings
bugfix-title
feature-title-update
feature-dashboard

Why this is important:
Confirms that your full lab work is visible for marking.

In this project, we explored safe and structured collaboration in Git using branching and merging strategies. Starting from initializing a Git repository, we created multiple feature and bugfix branches to simulate real-world DevOps workflows where developers work in parallel without breaking the main codebase.

We demonstrated:

Fast-forward merges for simple feature integration

3-way merges for parallel development scenarios

Merge conflicts and how to resolve them manually

Squash merges to maintain a clean and readable commit history

Pushing all branches to GitHub to ensure full project visibility and proper review

By using VS Code and Git commands step by step, this lab shows how developers can confidently manage features, fixes, and collaboration in a professional environment. Understanding these merge strategies is essential for working in teams, maintaining clean repositories, and avoiding production issues in DevOps and software development projects.

This workflow mirrors real industry practices and provides a solid foundation for working with Git in collaborative environments.

Full stack DevOps Lab

EMMANUEL — Fri, 02 Jan 2026 21:41:46 +0000

In this article, i am going to dive in ,in detail, on full stack DevOps lab. We have got to have these required Downloads

1.Node.js(v18 or higher)- Current LTS:v20.x

Download from: https://nodejs.org/
Choose the LTS version (20.x as of 2025)
Choose your Operating system,i will be using Mac, using nvm with npm
Verify installation: node --version and npm --version using VS code.

2.Git - Latest stable version

Download from: https://git-scm.com/downloads

Choose your operating system version/install Homebrew

Install git

Verify installation: git --version

3.Docker Desktop - Latest version

Download from: https://www.docker.com/products/docker-desktop/

Install and start Docker Desktop

Verify installation: docker --version and docker-compose --version

4. GitHub Account

5.Code Editor (Optional but recommended)

VS Code: https://code.visualstudio.com/

Or any editor you prefer (Sublime Text, Atom, etc.) but in this lab, I'm going to use VS Code.

Verify Everything is Installed

node --version
npm --version
git --version
docker --version

I have got all our the requirement for this Full stack DevOps lab, now lets go into steps for our Full stack DevOps lab. On the course of this process, I'm going to use VS Code as our Code Editor and the Terminal. I'm going to open my VS Code and create a Folder for this Project.

Step 1: Set Up Git for Version Control

This Configures Git on your machine so it knows who you are when you make commits, and sets up proper project tracking.

A. One-time Git Configuration

git config --global user.name "Emmanuel"
git config --global user.email "emmanuelobinnaonyemuche"
git config --global init.defaultBranch main

B. Create and Initialize Project
I created a folder initially for project, but now I'm going to create a specific folder for the project. Then Cd into it and create a local git for the directory.

mkdir my-devops-project
cd my-devops-project
git init

Step 2: Build a Node.js Web App

What this step does: Creates a web application using Node.js that can serve web pages and API endpoints.

A. Initialize Node.js Project

This Creates a package.json file that describes your project and manages dependencies.

npm init -y

B. Update package.json

What this step does: Customizes the package.json with proper scripts and metadata for your DevOps project. Create/edit package.json. Paste the code.

C. Create Application File

What this code does:

Creates an HTTP server that listens on port 3000
Serves different endpoints (/, /health, /info, /metrics)
Includes security headers and proper error handling
Provides graceful shutdown capability
Exports the server for testing

Create app.js:

To create a text file, I'm going to use this command,touch app.js,then paste the code to create app.js

D. Install Dependencies

We install dependencies so we don’t have to build everything from scratch. Dependencies are pre-written, tested code that your app depends on to work.

What you'll see:
A node_modules/ folder with all installed packages
A package-lock.json file that locks dependency versions

Install testing and development tools
npm install --save-dev jest eslint supertest
Install all dependencies (creates node_modules folder)
npm install

Step 3: Create Proper Tests

What this step does: Sets up automated testing so you can verify your application works correctly every time you make changes.

A. Create tests directory and test file

Create a folder for your tests
mkdir tests

Create the main test file

touch tests/app.test.js

B. Create test file

Copy this code into tests/app.test.js:

C. Create Jest configuration

Create jest.config.js,copy and paste the code

Step 4: GitHub Actions CI/CD Pipeline

What this step does: Creates an automated pipeline that runs tests and builds Docker images every time you push code to GitHub.

A. Create workflow directory

Create the GitHub Actions directory structure
mkdir -p .github/workflows

B. Create CI/CD pipeline file

Create .github/workflows/ci.yml:

In VS Code, use touch command touch .github/workflows/ci.yml. then copy and the code in ci.yml 1,U.

Step 5: Dockerfile

What this step does: Creates instructions for Docker to build a container image of your application that can run anywhere.

What this Dockerfile does:

Uses multi-stage builds for smaller image size
Installs curl for health checks
Creates a non-root user for security
Sets up proper file permissions
Configures health checks

Create Dockerfile:

In your terminal, use this command touch dockerfile,to create a docker file, then copy the code below and paste.

Step 6: Essential Configuration Files

This Creates configuration files that tell various tools what to ignore, how to behave, and what settings to use.

A.Create .dockerignore

Create .dockerignore:

In your Terminal, use touch .dockerignore and paste the code below

B.Create .gitignore

Create .gitignore:

Use touch command to create a text file for gitignore and copy and paste the code .

C.Create environment template

Create .env.example:

Use touch .env.example Command to create this, copy and pasts the code.

D. Create ESLint configuration

Create .eslintrc.js:

Use touch .eslintrc.js Command to create this, copy and pasts the code.

Step 7: Docker Compose for Development

What this step does: Creates a Docker Compose file that makes it easy to run your application and any supporting services with a single command.

Create docker-compose.yml:

Use touch docker-compose.yml Command to create this, copy and pasts the code

Step 8: Test Everything Locally

What this step does: Shows you how to actually run and test your application locally before deploying it.

A. Install and Test Locally

Install all dependencies from package.json

npm install

Run your test suite to make sure everything works

npm test

Start the application server

npm start

What you'll see:

Tests should pass with green checkmarks: ✓ GET / should return welcome page
Server starts and shows: 🚀 Server running at http://localhost:3000/

Test endpoints (in a new terminal window):

curl http://localhost:3000/ # Homepage

curl http://localhost:3000/health # Health check JSON

curl http://localhost:3000/info # System info JSON

curl http://localhost:3000/metrics # Prometheus metrics

B.Docker Commands

# Build image

docker build -t my-devops-app:latest .

# Run container

# Check container status

docker ps
docker logs my-devops-container

# Test health check

curl http://localhost:3000/health

# Stop container

docker stop my-devops-container
docker rm my-devops-container

C. Docker Compose Commands

# Start all services defined in docker-compose.yml

docker-compose up -d

# View real-time logs from all services

docker-compose logs -f

# Stop all services and clean up

docker-compose down

Step 9: Deploy to GitHub

What this step does: Commits your code to Git and pushes it to GitHub so the automated CI/CD pipeline can start working.

A. Initial commit

# Add all files to Git staging area

git add .

# Create your first commit with a descriptive message

git commit -m "Initial commit: Complete DevOps setup with working CI/CD"

B. Connect to GitHub

⚠️ IMPORTANT: Before running these commands:

Go to GitHub.com and create a new repository called my-devops-project

DO NOT initialize it with README, .gitignore, or license (we already have these)

Copy the repository URL from GitHub

Replace YOUR_GITHUB_USERNAME below with your actual GitHub username

# Set main as the default branch

git branch -M main

# Connect to your GitHub repository (UPDATE THIS URL!)

git remote add origin https://github.com/EMMANUELOBINNAONYEMUCHE/Day1-Fullstack-devOps-project.git

# Push your code to GitHub for the first time

git push -u origin main

Step 10: Kubernetes Deployment Configurations

What this step does: Creates Kubernetes configuration files that define how your application should run in staging and production environments.

A. Create directories
mkdir -p k8s/staging k8s/production

B. Create Staging Deployment

Create k8s/staging/deployment.yml:
use touch k8s/staging/deployment.yml to create an empty text file and paste the code .

⚠️ IMPORTANT: Update YOUR_GITHUB_USERNAME in the image URL below!

C. Create Production Deployment

Create k8s/production/deployment.yml:

use touch k8s/production/deployment.yml to create an empty text file and paste the code.

⚠️ IMPORTANT: Update YOUR_GITHUB_USERNAME in the image URL below

Step 11: Complete Deployment Workflow

What this step does: Shows you how to use the complete CI/CD pipeline with proper branching strategy for staging and production deployments.

Branch-based Deployment Strategy

develop branch → Automatically deploys to staging environment
main branch → Automatically deploys to production environment
Pull requests → Run tests only (no deployment)

A. Deploy Changes
Deploy to staging:

# Create and switch to develop branch git checkout -b develop_

# Make your changes, then commit and push git add .

git commit -m "Add new feature"

git push origin develop

B. Deploy to production:

Switch to main branch

git checkout main

# Merge changes from develop
git merge develop

# Push to trigger production deployment
git push origin main

This Full Stack DevOps lab provides a comprehensive, hands-on exploration of modern software delivery practices. Beginning with a simple Node.js application, the lab incrementally evolves into a fully automated, production-style system that reflects how DevOps teams operate in real-world environments.

A key strength of the lab is how it demonstrates the interconnected nature of the DevOps lifecycle. Local development, containerization with Docker, automated testing through GitHub Actions, and deployment to staging and production environments using Kubernetes are presented as an integrated workflow rather than isolated steps. This approach clearly illustrates DevOps as a continuous delivery pipeline where each stage depends on the reliability and consistency of the previous one.

The lab strongly emphasizes automation and standardization. By implementing CI/CD pipelines and a branch-based deployment strategy, manual intervention is minimized and the risk of deployment errors is significantly reduced. Automated testing, image builds, and environment-specific deployments ensure predictable and repeatable outcomes, reinforcing core DevOps principles such as reliability, traceability, and trust in the delivery pipeline.

Beyond technical implementation, the lab highlights DevOps as an operational and cultural mindset. It underscores the importance of building systems that are secure, observable, scalable, and maintainable. Overall, this lab establishes a solid foundation for designing and managing real-world DevOps workflows and prepares learners to confidently engage with more complex, production-grade environments.

Getting started with C# as a programming language.

EMMANUEL — Sun, 26 Oct 2025 20:49:47 +0000

Programming languages like C# let you write instructions that you want the computer to carry out. Each programming language has its own syntax, but after learning your first programming language and attempting to learn another one, you'll quickly realize that they all share many similar concepts. A programming language's job is to allow a human to express their intent in a human-readable and understandable way. The instructions you write in a programming language are called "source code" or just "code". Software developers write code

At this point, a developer can update and change the code, but the computer can't understand the code. The code first must be compiled into a format that the computer can understand.

Compilation
A special program called a compiler converts your source code into a different format that the computer's central processing unit (CPU) can execute. When you used the green Run button in the previous unit, the code you wrote was first compiled, then executed.

Why does code need to be compiled? Although most programming languages seem cryptic at first, they can be more easily understood by humans than the computer's preferred language. The CPU understands instructions that are expressed by turning thousands or millions of tiny switches either on or off. Compilers bridge these two worlds by translating your human-readable instructions into a computer-understandable set of instructions.

Syntax
The rules for writing C# code is called syntax. Just like human languages have rules regarding punctuation and sentence structure, computer programming languages also have rules. Those rules define the keywords and operators of C# and how they are put together to form programs.

When you wrote code into the .NET Editor, you may have noticed subtle changes to the color of different words and symbols. Syntax highlighting is a helpful feature that you'll begin to use to easily spot mistakes in your code that don't conform to the syntax rules of C#.

The C# programming language allows you to build many types of applications, like:

Business applications to capture, analyze, and process data
Dynamic web applications that can be accessed from a web browser
Games, both 2D and 3D
Financial and scientific applications
Cloud-based applications
Mobile applications

My first line of code in .NET Editor

There's a long-standing tradition among software developers to print the phrase "Hello World!" to the console output window.

Common mistakes new programmers make:

Entering lower-case letters instead of capitalizing C in Console, or the letters W or L in WriteLine.
Entering a comma instead of a period between Console and WriteLine.
Forgetting to use double-quotation marks, or using single-quotation marks to surround the phrase Hello World!.
Forgetting a semi-colon at the end of the command.

How to Display a new message

1.Modify the code you wrote so that it's prefixed by a code comment using two forward slashes //:

You can create a code comment by prefixing a line of code with two forward slashes //. This prefix instructs the compiler to ignore all the instructions on that line.

Code comments are helpful when you're not ready to delete the code yet, but you want to ignore it for now. You can also use code comments to add messages to yourself or others who may later read the code, reminding you of what the code is doing

2.Add new lines of code to match the following code snippet.

The difference between Console.Write and Console.WriteLine

Console.WriteLine prints a message to the output console. At the end of the line, it adds a line feed similar to pressing Enter or Return to create a new line.

To print to the output console, but without adding a line feed at the end, you use the second technique, Console.Write. So, the next call to Console.Write prints another message to the same line.

How does your code work
Let's focus on the following line of code you wrote:

Console.WriteLine("Hello World!");

When you ran your code, you saw that the message Hello World! was printed to the output console. When the phrase is surrounded by double-quotation marks in your C# code, it's called a literal string. In other words, you literally wanted the characters H, e, l, l, o, and so on, sent to the output.

The Console part is called a class. Classes "own" methods; or you could say that methods live inside of a class. To visit the method, you must know which class it's in. For now, think of a class as a way to represent an object. In this case, all of the methods that operate on your output console are defined inside of the Console class.

There's also a dot (or period) that separates the class name Console and the method name WriteLine(). The period is the member access operator. In other words, the dot is how you "navigate" from the class to one of its methods.

The WriteLine() part is called a method. You can always spot a method because it has a set of parentheses after it. Each method has one job. The WriteLine() method's job is to write a line of data to the output console. The data that's printed is sent in between the opening and closing parenthesis as an input parameter. Some methods need input parameters, while others don't. But if you want to invoke a method, you must always use the parentheses after the method's name. The parentheses are known as the method invocation operator.

Finally, the semicolon is the end of statement operator. A statement is a complete instruction in C#. The semicolon tells the compiler that you've finished entering the command.

Literal value

Many of the applications that you'll build in C# will require you to work with data. Sometimes that data will be hard-coded in your application. Hard-coded values are values that are constant and unchanged throughout the execution of the program. For example, you may need to print a message to the user when some operation succeeds. A "success" message would likely be the same every time the application is executed. This hard-coded value can also be called a constant, or a literal value.

Suppose you want to display a formatted message to the end user containing different types of data. The message would include hard-coded strings combined with information your app collects from the user. To display a formatted message, you'll need to create both hard-coded values and define variables that can store data of a certain type, whether numeric, alphanumeric, and so on.

Different literal data types

1.Character literals
If you only wanted a single alphanumeric character printed to screen, you could create a char literal by surrounding one alphanumeric character in single quotes. The term char is short for character. In C#, this data type is officially named "char", but frequently referred to as a "character"

Notice that the letter b is surrounded with single quotation marks 'b'. Single quotes create a character literal. Recall that using double quotation marks creates a string data type.

2.Integer literals
If you want to display a numeric whole number (no fractions) value in the output console, you can use an int literal. The term int is short for integer, which you may recognize from studying math. In C#, this data type is officially named "int", but frequently referred to as "integer". An int literal requires no other operators like the string or char.

3.Floating-point literals
A floating-point number is a number that contains a decimal, for example 3.14159. C# supports three data types to represent decimal numbers: float, double, and decimal. Each type supports varying degrees of precision.

Float Type Precision

Float ~6-9 digits

To create a float literal, append the letter F after the number. In this context, the F is called a literal suffix. The literal suffix tells the compiler you wish to work with a value of float type. You can use either a lower-case f or **upper-case F **as the literal suffix for a float.

Double ~15-17 digits
To create a double literal, just enter a decimal number. The compiler defaults to a double literal when a decimal number is entered without a literal suffix.

Decimal 28-29 digits
To create a decimal literal, append the letter m after the number. In this context, the m is called a literal suffix. The literal suffix tells the compiler you wish to work with a value of decimal type. You can use either a lower-case m or upper-case M as the literal suffix for a decimal.

4.Boolean literals

If you wanted to print a value representing either true or false, you could use a bool literal. The term bool is short for Boolean. In C#, they're officially referred to as "bool", but often developers use the term "Boolean".

Variable
A variable is a container for storing a type of value. Variables are important because their values can change, or vary, throughout the execution of a program. Variables can be assigned, read, and changed. You use variables to store values that you intend to use in your code. A variable name is a human-friendly label that the compiler assigns to a memory address. When you want to store or change a value in that memory address, or whenever you want to retrieve the stored value, you just use the variable name you created.

Declare a variable
To create a new variable, you must first declare the data type of the variable, and then give it a name.

string firstName;: In this case, you're creating a new variable of type string called firstName. From now on, this variable can only hold string values.

Variable name rules and conventions

Variable names can contain alphanumeric characters and the underscore character. Special characters like the hash symbol # (also known as the number symbol or pound symbol) or dollar symbol $ are not allowed.
Variable names must begin with an alphabetical letter or an underscore, not a number.
Variable names are case-sensitive, meaning that string Value; and string value; are two different variables.
Variable names must not be a C# keyword. For example, you cannot use the following variable declarations: decimal decimal; or string string;

Coding conventions for variables

Variable names should use camel case, which is a style of writing that uses a lower-case letter at the beginning of the first word and an upper-case letter at the beginning of each subsequent word. For example, string thisIsCamelCase;.
Variable names should begin with an alphabetical letter. Developers use the underscore for a special purpose, so try to not use that for now.
Variable names should be descriptive and meaningful in your app. Choose a name for your variable that represents the kind of data it will hold.
Variable names should be one or more entire words appended together. Don't use contractions or abbreviations because the name of the variable (and therefore, its purpose) may be unclear to others who are reading your code.
Variable names shouldn't include the data type of the variable. You might see some advice to use a style like string strValue;. That advice is no longer current.

Variable name examples

char userOption;
int gameScore;
decimal particlesPerMillion;
bool processedCustomer;

Reassign the value of a variable

String concatenation
**String concatenation **is "programmer speak" for simply combining two or more string values into a new string value. Unlike addition, the second value is appended to the end of the first value, and so on. In the following exercise, you'll write code to concatenate string values together.

Concatenate multiple variables and literal strings

String interpolation
String interpolation combines multiple values into a single literal string by using a "template" and one or more interpolation expressions. An interpolation expression is indicated by an opening and closing curly brace symbol { }. You can put any C# expression that returns a value inside the braces. The literal string becomes a template when it's prefixed by the $ character.

In other words, instead of writing the following line of code:

string message = greeting + " " + firstName + "!";

You can write this more concise line of code instead:

string message = $"{greeting} {firstName}!";

Use string interpolation to combine a literal string and a variable value

Use string interpolation with multiple variables and literal strings

Combine verbatim literals and string interpolation
Suppose you need to use a verbatim literal in your template. You can use both the verbatim literal prefix symbol @ and the string interpolation $ symbol together.

Perform addition with implicit data conversion

Often, you'll want to perform mathematical operations on numeric data. You'll start with addition in this unit, and expand to other operations in the next unit because there's an important lesson to learn about how the C# compiler parses and interprets your code

Add two numeric values

To add two numbers together, you'll use the addition operator, which is the plus symbol +. Yes, the same plus symbol + that you use for string concatenation is also used for addition. The reuse of one symbol for multiple purposes is sometimes called "overloading the operator" and happens frequently in C#.

In this instance, the C# compiler understands what you're attempting to do. The compiler parses your code and sees that the + (the operator) is surrounded by two numeric values (the operands). Given the data types of the variables (both are ints), it figures out that you intended to add those two values

Mix data types to force implicit type conversions

What happens if you try to use the + symbol with both string and int values?

Attempt a more advanced case of adding numbers and concatenating strings

Instead of adding the int variable widgetsSold to the literal int 7, the compiler treats everything as a string and concatenates it all together

Add parentheses to clarify your intention to the compiler

The parentheses symbol () becomes another overloaded operator. In this case, the opening and closing parentheses form the order of operations operator, just like you might use in a mathematical formula. You indicate that you want the inner-most parentheses resolved first resulting in the addition of int values widgetsSold and the value 7. Once that is resolved, then it will implicitly convert the result to a string so that it can be concatenated with the rest of the message.

Perform math operations
Perform basic math operations. Write code to perform addition, subtraction, multiplication, and division with integers.

As you can see:

+ is the addition operator
- is the subtraction operator
* is the multiplication operator
/ is the division operator

However, the resulting quotient of the division example may not be what you may have expected. The values after the decimal are truncated from the quotient since it is defined as an int, and int cannot contain values after the decimal.

Code to exercise C#'s order of operations
As you learned in the previous exercise, you can use the () symbols as the order of operations operators. However, this isn't the only way the order of operations is determined.

In math, PEMDAS is an acronym that helps students remember the order of operations. The order is:

Parentheses (whatever is inside the parenthesis is performed first)
Exponents
Multiplication and Division (from left to right)
Addition and Subtraction (from left to right)

C# follows the same order as PEMDAS except for exponents. While there's no exponent operator in C#, you can use the System.Math.Pow method. The module "Call methods from the .NET Class Library using C#" will feature this method and others

Increment and decrement values

The final basic operations you'll learn about in this module is how to increment and decrement values using special operators that are combinations of symbols. You'll need to increment and/or decrement values, especially when you're writing looping logic or code that interacts with a data structure.

The += operator adds and assigns the value on the right of the operator to the value on the left of the operator. So, lines two and three in the following code snippet are the same

int value = 0; // value is now 0.
value = value + 5; // value is now 5.
value += 5; // value is now 10

The ++ operator increments the value of the variable by 1. So, lines two and three in the following code snippet are the same:

int value = 0; // value is now 0.
value = value + 1; // value is now 1.
value++; // value is now 2.

To write code to increment and decrement a value

Position the increment and decrement operators

Both the increment and decrement operators have an interesting quality — depending on their position, they perform their operation before or after they retrieve their value. In other words, if you use the operator before the value as in ++value, then the increment will happen before the value is retrieved. Likewise, value++ will increment the value after the value has been retrieved.

Using .Net Editor to write a letter.

How to work with Text editors in Linux.

EMMANUEL — Sun, 12 Oct 2025 00:33:00 +0000

Text editors are software applications designed to create and modify plain or rich text documents. They range from simple notepad functions for basic text entry to advanced options for programming and coding, featuring tools like syntax highlighting, error detection, and customizable layouts. Text editors can handle various file formats, allowing users to save and share documents in multiple extensions like .txt, .md, or .html.

Types of Text Editors

Basic Text Editors: These include simple applications like Notepad (Windows) and TextEdit (Mac), which are suitable for quick edits and basic text manipulation.
Code Editors: Designed for programming, these editors offer features like syntax highlighting, code completion, and debugging tools. Examples include Visual Studio Code, Sublime Text, and Notepad++.
Integrated Development Environments (IDEs): While primarily focused on coding, IDEs also function as text editors. They provide comprehensive tools for software development, including project management and version control integration.

Popular Text Editors

Visual Studio Code: A highly popular code editor known for its extensive features, including a built-in terminal, debugging capabilities, and a rich marketplace for extensions.
Sublime Text: Renowned for its user-friendly interface and powerful features, Sublime Text offers a distraction-free writing mode and split editing.
Notepad++: A free and open-source text editor for Windows that supports multiple programming languages and offers features like tabbed browsing and syntax highlighting.
Atom: An open-source text editor developed by GitHub, known for its hackable nature and community-driven packages.
Emacs and Vim: Classic text editors that are highly customizable and powerful, often preferred by experienced programmers.

In this project I am going to create a textfile in ubuntu environment (Linux) using Vim.

Step 1
In your Multipass, install vim by using this command line apt install vim

Step 2
Create an empty text file, lets use sample for example, so we are going to use this command line touch sample

Step 3
To put something in the empty text file sample that we, created. In the multipass ,type this command line vim sample

Step 4
Change the linux shell from command mode to insert mode after using vim sample command line to put in something in the sample empty file that we created. To be in insert mode, click I on the keyboard and it will change to insert mode.

Step 5
Write anything on the page, when you have change it to insert mode. For example lets write "Linux is Fun" on it.

Step 6
Press esc key on your keyboard to leave the insert mode.

Step 7
Press shift + colon then type wq the w will help you save what you inserted or have written and the q will take you back to your terminal. Like we have written Linux is fun.

In your termial, type cat and "the textfile" you edited to check if what you inserted in it is saved, type the command cat sample

Basic Linux Command Using Ubuntu terminal environment.

EMMANUEL — Sat, 11 Oct 2025 22:40:01 +0000

Ubuntu Terminal Environment
The Ubuntu terminal environment is a powerful tool that allows users to interact with the Ubuntu operating system directly via text-based commands. It is often referred to as the command line interface (CLI) and is built on the Bash shell by default. The terminal is essential for executing programs, managing files, installing packages, monitoring processes, and performing administrative tasks. It is a lightweight and faster alternative to the graphical user interface (GUI) for many tasks, offering more control and automation. However, it also has a steeper learning curve for beginners and can be more error-prone if commands are not executed correctly.

The Linux cogmand line for beginners
Its important to note that, in linux there's always one space rule and its always case sensitive, it should always be in lower case.

sudo su (Administrative command)
This command makes you to be in administrative mode/root for you to able to install or update anything. Some people call it switch user or super user.

apt update
To update the environment.

clear
This command is use to clear the screen when the screen is clogged up.

pwd(print work directory)
This is used to know where exactly you are in your ubuntu terminal shell.

mkdir
It is the command used to make a directory.In your linux terminal type mkdir and the folder directory. Lets create 3 directory; mkdir emmanuel,
mkdir zanmedix,
mkdir tech1

ls
This command is used to list or see what is on your computer.

rmdirthen the name of the directory.
This is used to remove directory that you created.
lets remove tech1 and emmanuel
rmdir tech1
rmdir emmanuel

touch "name of the file"
This is used to create an empty file. Lets create three empty files
touch txt-1
touch txt-2
touch txt-3

then ls to see the created empty files

rm "then the name of the file"
This command is used to delete file.e,g let delete txt-1 and txt-2.

cd
This command is used to enter into a directory. lets do cd dr-1

rm -rf "the directory that is not empty"
this is used to delete a directory you have cd into it. For example lets delete dr-1 thats no longer empty. we going to use this line of command rm -rf dr-1

cd "directory", touch txt-1
This command line is used to open a driectory and create a text file in the directory. E.g cd dr-1. touch txt1

cd ..
This is a command use to leave a particular folder/directory, lets for example we would like to leave dir-1 folder, in our command terminal we write the following command y.

cp
This command is use to copy file to a folder.lets say for example you want to copy text file to a directory you use cp command. lets try it cp txt1 dir-1..Then cd into the directory and do ls to confirm if the txt1 file was copied.

mv
This command is used to move a text file to a folder or directory. if you want to move lets txt2 file to a dir-2. we use this command line mv txt2 dir-2. Then cd into dir-2 folder cd dir-2 then ls to confirm the move.

ls -l (longlisting)
This command is used to list everything in a long format. Lets try in our terminal shell

ls -al
This command is used to list hidden files.

ls -a
This command hide things for you.

Create DNS zones and configure DNS settings

EMMANUEL — Mon, 15 Sep 2025 17:13:26 +0000

The Domain Name System (DNS) is the phonebook of the Internet. Humans access information online through domain names, like nytimes.com or espn.com. Web browsers interact through Internet Protocol (IP) addresses. DNS translates domain names to IP addresses so browsers can load Internet resources.

Each device connected to the Internet has a unique IP address which other machines use to find the device. DNS servers eliminate the need for humans to memorize IP addresses such as 192.168.1.1 (in IPv4), or more complex newer alphanumeric IP addresses such as 2400:cb00:2048:1::c629:d7a2 (in IPv6).

How does DNS work?

The process of DNS resolution involves converting a hostname (such as www.example.com) into a computer-friendly IP address (such as 192.168.1.1). An IP address is given to each device on the Internet, and that address is necessary to find the appropriate Internet device - like a street address is used to find a particular home. When a user wants to load a webpage, a translation must occur between what a user types into their web browser (example.com) and the machine-friendly address necessary to locate the example.com webpage.

In order to understand the process behind the DNS resolution, it’s important to learn about the different hardware components a DNS query must pass between. For the web browser, the DNS lookup occurs "behind the scenes" and requires no interaction from the user’s computer apart from the initial request.

A DNS zone is a specific portion of the Domain Name System (DNS) that is managed by a single authority. It is like a section of a big map, where each section is controlled separately to make management easier. This division allows different organizations or administrators to handle and update their own part of the DNS without affecting the entire system

DNS zones follows a hierarchical concept. Therefore, namespace is subdivided into areas (zones) for this purpose. The purpose of DNS zones is to permit easier control over multiple levels of website.
As the number of resource records increases for single domain, it becomes complex to manage all of them. Network administrations moderate this issue by breaking down their configurations into multiple zones.
Root name servers are responsible for root zone. Each top-level domains
(TLD) name server is responsible for zone covering its specific TLD, and authoritative name servers are responsible for some even smaller zones below that.
The root and TLD name servers are actually just authoritative name servers, but, zones that they're authoritative for are special cases.
DNS zones aren't necessarily physically separated from each other; zones are strictly used for delegating control.

How to Create DNS zones and configure DNS settings

In a scenario where an organization requires workloads to use domain names instead of IP addresses for internal communications. The organization doesn’t want to add a custom DNS solution. You are to identify these requirements.

A private DNS zone is required for contoso.com.
The DNS will use a virtual network link to app-vnet.
A new DNS record is required for the backend subnet.

To identify the above requirements, we need to do the following tasks:

Create and configure a private DNS zone.
Create and configure DNS records.
Configure DNS settings on a virtual network

Create a private DNS zone

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

1.On the Azure portal, search for and select Private dns zones

2.Select + Create

3.Configure the DNS zone

Subscription Select your subscription
Resource group RG1
Name private.contoso.com
Region East US

4.Select Review + create

5.Select Create when the validation is passed.

6.Wait for the DNS zone to deploy, and then select Go to resource

Create a virtual network link to your private DNS zone

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

1.In the portal, continue working on the private.contoso.com DNS zone

2.In the DNS Management blade, select + Virtual network links. Select + Add

3.Configure the virtual network link

Link name app-vnet-link
Virtual network app-vnet
Enable auto registration Enabled

4.Select Create and wait for the deployment to finish. If necessary, Refresh the page

Create a DNS record set
DNS records provide information about the DNS zone.

1.In the portal, continue working on the private.contoso.com DNS zone.

2.In the DNS Management blade, select + Recordsets

3.Notice that two A records have automatically been created for each of the virtual machines.

4.Select + Add and configure a record set. When finished select Add.

Name ** backend**
Type A
TTL 1
IP address 10.1.1.5

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

Configure network routing.

EMMANUEL — Mon, 15 Sep 2025 14:37:01 +0000

Network routing is the process of determining the best path for data packets to travel from one device to another on a computer network. Routers, the backbone of network infrastructure, are responsible for facilitating this process. When a user sends data to another user or server, the router analyzes the packet's destination address and decides which path to take to reach its destination.

The Role of Routers

Routers act as traffic controllers in a network, directing data packets efficiently to their intended destinations. They maintain routing tables that contain information about various network paths, enabling them to make intelligent decisions about packet forwarding.

How Data Packets Travel

When a data packet is sent from a source device, the router examines the packet's destination IP address. The router consults its routing table to determine the best path for the packet. It then forwards the packet to the next hop, which is another router along the chosen path. This process continues until the packet reaches its final destination.

Types of Network Routing

Network routing can be classified into three main types: static routing, dynamic routing, and default routing.

Static Routing
In static routing, network administrators manually configure the routing tables in routers. This approach is suitable for smaller networks with stable topologies, where the paths between devices remain constant.

Dynamic Routing
Dynamic routing, on the other hand, uses routing protocols to automate the process of updating routing tables. Routers exchange information about the network's status and adapt to changes in real-time, making dynamic routing ideal for larger, more complex networks.

Default Routing
Default routing comes into play when a router does not have a specific entry for the destination IP address in its routing table. In such cases, the router forwards the packet to a pre-defined default gateway, which acts as a central exit point for the network

The Process of Network Routing

The process of network routing is a crucial mechanism that enables data packets to traverse efficiently through a complex web of interconnected devices on a computer network. we will delve deeper into the various steps involved in network routing, shedding light on how routers make intelligent decisions to ensure successful data transmission.

Source and Destination
At the heart of network routing is the concept of source and destination. When a user initiates data transmission, acting as the source, they specify the destination device or server where the data should ultimately arrive. This information is essential as it forms the basis for the routing process.

Building Routing Tables
One of the fundamental tasks of routers is building and maintaining routing tables. These tables contain critical information about various destinations within the network and the paths that can be taken to reach them. In dynamic routing environments, routing tables are continually updated as routers exchange information with each other, adapting to changes in the network's topology.

Determining the Best Path
Once a router receives a data packet from the source, it examines the destination address of the packet. Using the information stored in its routing table, the router evaluates various available paths to determine the best route for the data packet to take. This decision-making process involves considering metrics such as link cost, which assesses the efficiency and reliability of potential paths.

Forwarding Data Packets
With the best path identified, the router proceeds to forward the data packet to the next hop. The next hop refers to the next router along the chosen path that brings the data packet closer to its final destination. This forwarding process occurs iteratively at each router until the data packet reaches its intended endpoint.

In this Articles we are going to look into steps on how to configure network routing.

To ensure the firewall policies are enforced, outbound application traffic must be routed through the firewall. To do that:

A route table is required. This route table will be associated with the frontend and backend subnets.
A route is required to filter all outbound IP traffic from the subnets to the firewall. The firewall’s private IP address will be used.

To configure network routing, we going to perform the following tasks:

Create and configure a route table.
Link a route table to a subnet.

Create a route table

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

Record the private IP address of app-vnet-firewall

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

2.Select app-vnet-firewall

3.Select Overview and record the Private IP address

Add the route table

1.In the search box, enter Route tables. When Route table appears in the search results, select it.

2.In the Route table page, select + Create

3.Create the route table

Subscription Select your subscription
Resource group RG1
Region East US
Name app-vnet-firewall-rt

4.Select Review + create

5.After validation pass. Select Create

6.Wait for the route table to deploy, then select Go to resource

Associate the route table to the subnets

1.In the portal, continue working with the route table, select app-vnet-firewall-rt

2.In the Settings blade, select Subnets and then + Associate

3.Configure an association to the frontend subnet, then select OK.

4.Configure an association to the backend subnet, then select OK

Create a route in the route table

1.In the portal, continue working with the route table, select app-vnet-firewall-rt

2.In the Settings blade, select Routes and then + Add.

3.Configure the route, then select Add.

Route name ** outbound-firewall**
Destination type IP addresses
Destination IP addresses/CIDR range 0.0.0.0/0
Next hop type Virtual appliance
Next hop address private IP address of the firewall

Create a sample resume and Push to GitHub Pages.

EMMANUEL — Fri, 12 Sep 2025 21:55:21 +0000

Git
Git is a distributed version control system, which means that a local clone of the project is a complete version control repository. These fully functional local repositories make it easy to work offline or remotely. Developers commit their work locally, and then sync their copy of the repository with the copy on the server. This paradigm differs from centralized version control where clients must synchronize code with a server before creating new versions of code.

Git's flexibility and popularity make it a great choice for any team. Many developers and college graduates already know how to use Git. Git's user community has created resources to train developers and Git's popularity make it easy to get help when needed. Nearly every development environment has Git support and Git command line tools implemented on every major operating system.

Benefits of Git

Simultaneous development: Everyone has their own local copy of code and can work simultaneously on their own branches. Git works offline since almost every operation is local.

Faster releases: Branches allow for flexible and simultaneous development. The main branch contains stable, high-quality code from which you release. Feature branches contain work in progress, which are merged into the main branch upon completion. By separating the release branch from development in progress, it's easier to manage stable code and ship updates more quickly.

Built-in integration: Due to its popularity, Git integrates into most tools and products. Every major IDE has built-in Git support, and many tools support continuous integration, continuous deployment, automated testing, work item tracking, metrics, and reporting feature integration with Git. This integration simplifies the day-to-day workflow.

Strong community support: Git is open-source and has become the de facto standard for version control. There is no shortage of tools and resources available for teams to leverage. The volume of community support for Git compared to other version control systems makes it easy to get help when needed.

Git works with any team: Using Git with a source code management tool increases a team's productivity by encouraging collaboration, enforcing policies, automating processes, and improving visibility and traceability of work. The team can settle on individual tools for version control, work item tracking, and continuous integration and deployment. Or, they can choose a solution like GitHub or Azure DevOps that supports all of these tasks in one place.

Pull requests: Use pull requests to discuss code changes with the team before merging them into the main branch. The discussions in pull requests are invaluable to ensuring code quality and increase knowledge across your team. Platforms like GitHub and Azure DevOps offer a rich pull request experience where developers can browse file changes, leave comments, inspect commits, view builds, and vote to approve the code.

Branch policies: Teams can configure GitHub and Azure DevOps to enforce consistent workflows and process across the team. They can set up branch policies to ensure that pull requests meet requirements before completion. Branch policies protect important branches by preventing direct pushes, requiring reviewers, and ensuring clean builds.

Github
GitHub is a cloud-based platform for version control and collaboration, primarily used by developers to store, manage, and share code. It is built on Git, an open-source version control system that tracks changes in code and allows multiple people to collaborate on a project efficiently.

Git Bash
Git Bash is an application for Microsoft Windows OS environments that provides Unix based shell utilities and experience for Git command line commands. Git Bash emulates the Git command line experience that Unix environments have, for Windows users. Most Windows users download Git Bash when they first install Git for Windows.

As a version control system, Git was originally delivered within Unix style command line methods. MacOS & Linux Operating Systems have a built-in terminal shell that supports Unix-based command line features whereas Microsoft Windows’ Operating System command line prompt is not a Unix-based terminal. Because the Windows command line does not support Unix-based commands, Git CLI features are mostly delivered with user-friendly GUI applications in the Windows Operating System. These applications provide visual functionalities to the end-user which makes using Git easier.

As Git experience increases, end-users can prefer using Git command line features for specific commands. Git Bash is one tool that provides command line features in the Windows Operating System to end-users.

Essential Git Bash Commands:

1.GIT PUSH: This command is used to upload local repository content to a remote repository. (In Git, a local repository is a version-controlled directory on your local computer where your project files are stored, along with the metadata Git uses to track changes to these files.)

2.GIT COMMIT -M: This takes a snapshot of your repository at one point in time. The -m flag helps u add a message to the commit

3.GIT ADD As the name implies it adds a change in the working directory to the staging area. It tells git that u want to include updates to a particular file.

4.GIT REMOTE ADD ORIGIN: This creates a new empty Git repository on your remote server.

Steps on how to use Git BASH command to create a sample resume and push it to Github pages

1.To install Git for windows, click on this link https://git-scm.com/downloads/win

2.Click on windows version to download and install Git for windows.

3.Go to download, choose the downloaded git version for windows, click to install ,choose Next throughout as default to complete the installation.

4.when the installation is complete, open your gitbash to Configure the Gitbash with an Identity, to do that create a name and email with the following commands:

git config --global user.name "name"
git config --global user.email "email"

5.Use this command git config --list to confirm if the configuration is successful. From our gitbash it shows its successful.

6.Prepare your work environment to work with it. To do that, create/make a directory.(Its similiar to what Resource group does in microsoft Azure).To make directory, run this command mkdir emmanuelobinnadirectory in your gitbash.

7.To see things that is in your computer or things you have created use ls command in your gitbash

8.Enter/open the emmanuelobinnadirectory we have created, use cd emmanuelobinnadirectory command

9.Type this command clear your gitbash to clear the screen but its important to note that ,it doesnt mean your previous command have been deleted.

9.In your gitbash type this command git init to convert your directory into a local git repository.

10.To confirm that it has been converted. Type this command ls -al in your gitbash to list the hidden files,.

11.In your gitbash, type this command touch index.html to Create an empty text file/html file.

12.To verify that we have created the touch index.html file use the command ls in your gitbash.

13.Go to chatGPT, upload your resume on your chatGPT, or you can ask chatGPT to create an index.html for cloud engineering resume for Emmanuel obinna Onyemuche.

14.Go to gitbash, use the command vi index.html to open this index.html to start typing.

15.In other to edit vi file ,you have to make it to be on insert mode by typing i

16.Go to chatGPT and copy the code generated on the chatGPT and paste it, in the gitbash.

17.Click escape key on the keyboard to save the vim document.

18.Press shift+colon on your keyboard at the same time, then type wq in front of the colon. Hit enter on the keyboard.
w= is used to save everything.
q= is used to escape the page.

19.Got to github.https://github.com/..sign in to your github or signup if you have not gotten a github account. Go to +create to create a new repository.

20.Give the repository a name,choose the visibility to be public,make sure Add README is on and create the repository.

21.on your Github, after creating the new repository, click on code and copy the https https://github.com/EMMANUELOBINNAONYEMUCHE/Cloud-Engineer-Resume.git

22.Go to back to your gitbash and type this command git remote add origin "url" (https://github.com/EMMANUELOBINNAONYEMUCHE/Cloud-Engineer-Resume.git)

23.Use git status to verify there is a file.

24.Take the file to the staging area by using a command git add .

25.Type git status command on your gitbash to verify it has been added to the staging area.

26.Type the command git commit -m "a commit message" to take a snapshot of the entire file in the staging area and save it.

27.In the gitbash, type the command git push origin master to push it to the github. It will prompt a page, asking you to sign in to github. Choose sign in through the browser

28.Login to your github, while its pushing it to your github, after you have logged in, check your gitbash for confirmation that the push to the github is successful.

29.In your github, switch to master from main because we pushed it to master in our gitbash.

30.In your github, click on the index.html that you created.

31.When you open it, you will notice that everything that you did in you local environment was brought up to github.

32.Select settings.

33.On the left hand side look for Pages and click on it. On the branch, select master and save.

34.Refresh the page to see a link or visit site copy the link and paste on new browser or click on visit site to the Resume

The Resume

Create and configure Azure Firewall.

EMMANUEL — Wed, 10 Sep 2025 14:57:46 +0000

Azure Firewall is a fully managed, cloud-native network security service from Microsoft designed to protect Azure Virtual Network resources by filtering both inbound and outbound traffic with high availability and unlimited scalability.

Azure Firewall operates as a stateful firewall-as-a-service within the Azure cloud, meaning it tracks the state of network connections and makes intelligent security decisions based on that context. It inspects both east-west traffic (within the same network) and north-south traffic (between networks or to/from the internet), providing comprehensive network protection. Azure Firewall is integrated tightly with Azure’s infrastructure, allowing centralized, policy-driven security management across multiple subscriptions and virtual networks.

Key Features

Stateful Inspection: Tracks connection states to allow or block traffic intelligently.
Built-in High Availability: Automatically available with no need to deploy additional infrastructure.
Cloud Scalability: Dynamically scales to handle fluctuating workloads and traffic volumes without manual intervention.
Application and Network Filtering: Supports filtering based on fully qualified domain names (FQDNs), IP addresses, protocols, and ports.
Threat Intelligence Integration: Constantly updated with Microsoft’s threat intelligence to block traffic from known malicious IPs and domains.
Advanced Capabilities with Premium SKU: Includes features like TLS inspection (decrypting and inspecting encrypted traffic), Intrusion Detection and Prevention System (IDPS) for signature-based malware detection, URL filtering, and web category filtering.
Logging and Monitoring: Seamlessly integrates with Azure Monitor for logging, diagnostics, and security analytics.

Comparison with Other Azure Security Tools

Azure Firewall complements Network Security Groups (NSGs) by providing a higher level of network and application-layer protection centrally across networks, while NSGs offer more distributed, subnet-level control. It also differs from Azure Web Application Firewall (WAF), which focuses specifically on protecting web applications from Layer 7 attacks.

In a scenario where an organization requires centralized network security for the application virtual network. As the application usage increases, more granular application-level filtering and advanced threat protection will be needed. Also, it is expected the application will need continuous updates from Azure DevOps pipelines. So to protect the inbound and outbound virtual networks, the following requirement is needed:

Azure Firewall is required for additional security in the app-vnet.
A firewall policy should be configured to help manage access to the application.
A firewall policy application rule is required. This rule will allow the application access to Azure DevOps so the application code can be updated.
A firewall policy network rule is required. This rule will allow DNS resolution.

To achieve this we have got to perform the following Tasks:

Create an Azure Firewall.
Create and configure a firewall policy
Create an application rule collection.
Create a network rule collection

Create Azure Firewall subnet in our existing virtual network

1.In the search box at the top of the portal, enter Virtual networks. Select Virtual networks in the search results.

2.Select app-vnet

3.Select Subnet

4.Select + Subnet

5.Enter the following information and select Save.

Name AzureFirewallSubnet
Address range 10.1.63.0/26

Note: Leave all other settings as default

Create an Azure Firewall

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

2.Select + Create

3.Create a firewall by using the values in the following table. For any property that is not specified, use the default value

Resource group RG1
Name app-vnet-firewall
Firewall SKU Standard
Firewall management Use a Firewall Policy to manage this firewall
Firewall policy select Add new
Policy name fw-policy
Region East US
Policy Tier Standard
Choose a virtual network Use existing
Virtual network app-vnet (RG1)
Public IP address Add new: fwpip
Enable Firewall Management NIC uncheck the box

4.Select Review + Create

5.Select Create

Update the Firewall Policy

1.In the portal, search for and select Firewall Policies

2.Select fw-policy

Add an application rule

1.In the Rule blade, select Application rules and then Add a rule collection.

3.Create a firewall by using the values in the following table. For any property that is not specified, use the default value. Add

Name app-vnet-fw-rule-collection
Rule collection type Application
Priority 200
Rule collection action Allow
Rule collection group DefaultApplicationRuleCollectionGroup
Name AllowAzurePipelines
Source type IP address
Source 10.1.0.0/23
Protocol https
Destination type FQDN
Destination dev.azure.com, azure.microsoft.com

Note: The AllowAzurePipelines rule allows the web application to access Azure Pipelines. The rule allows the web application to access the Azure DevOps service and the Azure website.

Add a network rule

1.In the Settings blade, select Network rules and then Add a network collection.

2.Configure the network rule and then select Add

Name app-vnet-fw-nrc-dns
Rule collection type Network
Priority 200
Rule collection action Allow
Rule collection group DefaultNetworkRuleCollectionGroup
Rule AllowDns
Source 10.1.0.0/23
Protocol UDP
Destination ports 53
Destination addresses 1.1.1.1, 1.0.0.1

Verify the firewall and firewall policy status

1.In the portal search for and select Firewall.

2.View the app-vnet-firewall and ensure the Provisioning state is Succeeded. This may take a few minutes.

3.In the portal serach for and select Firewall policies

4.View the fw-policy and ensure the Provisioning state is Succeeded. This may take a few minute

Create and Configure network security groups.

EMMANUEL — Wed, 10 Sep 2025 11:17:53 +0000

A network security group (NSG) is a virtual firewall that controls network traffic to and from resources within a cloud environment, such as a virtual network. It uses a set of access control rules to allow or deny network traffic based on criteria like source/destination IP address, port, and protocol.

NSGs are a fundamental part of cloud security and can be applied to either entire network subnets or individual virtual machine network interfaces. By applying them at the subnet level, all resources within that subnet are protected, offering a simple way to manage access for groups of resources.

How network security groups work

NSGs operate based on a set of security rules that define what traffic is permitted. These rules are processed in order of priority, with the lowest number having the highest priority. Once a rule matches a traffic packet, processing stops.

A rule contains the following elements:

Direction: Whether the rule applies to inbound (incoming) or outbound (outgoing) traffic.
Source/Destination: Can be a specific IP address, an IP address range (using CIDR notation), or a Service Tag that represents a group of IP prefixes for an Azure service.
Port range: A specific port (e.g., 80) or a range of ports (e.g., 1000-2000).
Protocol: Specifies the protocol to match, such as TCP, UDP, or ICMP.
Action: What to do with the traffic if it matches the rule, either "Allow" or "Deny".

Key NSG concepts

Default rules: NSGs come with a set of default rules that cannot be removed but can be overridden by user-created rules with higher priority.
Stateful filtering: NSGs are "stateful," meaning that if an outbound connection is allowed, the firewall automatically permits the return inbound traffic for that connection. You do not need a separate inbound rule for it.
Application security groups (ASGs): A related feature that allows you to group virtual machines by application or role, rather than by IP address. You can then use the ASG in your NSG rules, which simplifies management and helps ensure consistent security policies.
Flow logs: A feature that logs information about IP traffic passing through an NSG, including source/destination details and whether traffic was allowed or denied. This data is useful for monitoring and troubleshooting network traffic.

In this article, we are going to create and configure a network security group based on a scenario of an organization that requires the network traffic in the app-vnet to be tightly controlled. To do that we have to meet this requirements.

The frontend subnet has web servers that can be accessed from the internet. An application security group (ASG) is required for those servers. The ASG should be associated with any virtual machine interface that is part of the group. This will allow the web servers to be easily managed.
The backend subnet has database servers used by the frontend web servers. A network security group (NSG) is required to control this traffic. The NSG should be associated with any virtual machine interface that will be accessed by the web servers.
For testing, a virtual machine should be installed in the frontend subnet (VM1) and the backend subnet (VM2).Then complete the following task:
Create a network security group.
Create network security group rules.
Associate a network security group to a subnet.
Create and use application security groups in network security group rules.

Create VM1 with Ubuntu server, and associate frontend as the subnet and app-vnet as the virtual network.

1.In your Azure portal, in the search resource, search for virtual machine and select the grayed virtual machine.

2.Select +Create and select Virtual machine.

3.Under Basics, fill the project detail by choosing your Resource group, Virtual machine name, Region,Availability option, Availability zone, Image, Size.

4.Under Administrator account, choose password then fill in the Username and Password.

5.On the Inbound port rules, select None

6.On Networking, choose your virtual network app-vnet and your frontend subnet. And leave the rest as default

7.Select Review + Create

8.After Validation, select Create and wait for deployment.

Create another virtual machine VM2 with Ubuntu server, and associate backend as the subnet and app-vnet as the virtual network.

1.In your Azure portal, search for virtual machine and select.

2.Select +Create

3.Under Basics, fill the project detail by choosing your Resource group, Virtual machine name, Region,Availability option, Availability zone, Image, Size.

4.Under Administrator account, choose password then fill in the Username and Password.

5.On the Inbound port rules, select None

6.On Networking, choose your virtual network app-vnet and your backend subnet. Leave the rest as default.

7.Select Review + Create

8.After Validation, select Create and wait for deployment.

Verify both vm1 and vm2 are Running. Then create an Application security group.Application security groups (ASGs) let you group together servers with similar functions. For example, all the web servers hosting your application.

Create Application Security Group

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

2.Select + Create

3.Configure the application security group.

Subscription Subscription 1
Resource group RG1
Name app-frontend-asg
Region East US

4.Select Review + create

5.Select Create

Note: You are creating the application security group in the same region as the existing virtual network.

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

1.In the Azure portal, search for and select VM1

2.In the Networking blade, select Application security groups and then select Add application security groups

3.Select the app-frontend-asg and then select Add.

Create and Associate the Network Security Group

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

1.In the portal search for and select Network security group.

2.Select + Create

3.Configure the network security group

Subscription Subscription 1
Resource group RG1
Name app-vnet-nsg
Region East US

4.Select Review + create

5.Select Create after the validation is passed.Then wait for deployment to complete.

Associate the NSG with the app-vnet backend subnet.

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

1.Select Go to resource or navigate to the app-vnet-nsg resource. In the Settings blade select Subnets.

2.Select + Associate.

3.Select app-vnet (RG1) and then the Backend subnet. Select OK

Create Network Security Group rules

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

1.In the search box at the top of the portal, enter Network security groups. Select Network security groups in the search results.

2.Select app-vnet-nsg from the list of network security groups.

3.In the Settings blade, select Inbound security rules

4.Select + Add

5.Configure an inbound security rule and Add

How to Create a virtual network in Azure.

EMMANUEL — Fri, 05 Sep 2025 01:39:29 +0000

A Virtual Network (VNet) is a logically isolated network(a network segment intentionally separated from other networks, including the public internet, to improve security and performance by containing threats and controlling traffic flow)in the cloud that lets you securely connect and manage your resources, just like a traditional on-premises network.

Azure Virtual Network provides the fundamental building block for your private network in Azure. This service enables Azure resources like virtual machines (VMs) to securely communicate with each other, the internet, and on-premises networks. Virtual networks deliver the scale, availability, and isolation benefits of Azure infrastructure while maintaining the familiar networking concepts you use in traditional datacenters.

In this article, lets create two virtual networks app-vnet and hub-vnet that simulates a hub and spoke network architecture. The app-vnet will host the application. This virtual network requires two subnets. The frontend subnet will host the web servers. The backend subnet will host the database servers. The hub-vnet only requires a subnet for the firewall. The two virtual networks must be able to communicate with each other securely and privately through virtual network peering. Both virtual networks should be in the same region.

The Microsoft provides multiple ways to create Azure Virtual Networks.

Using the Azure Portal
Using Azure PowerShell
Using the Azure CLI

This tutorial covers using the Azure portal.

Create hub and spoke virtual networks and subnets

1.Login to your Azure portal. https://portal.azure.com

2.In the search Resources, search for virtual network,click enter and select the grayed out virtual machine.

3.Select + Create

4.Complete the configuration of the app-vnet.

Resource group RG1
Virtual network name app-vnet
Region East US

5.Still on the configuration of the app vnet, This virtual network requires two subnets, frontend and backend.

IPv4 address space(vnet IP address) 10.1.0.0/16

Subnet name frontend
Subnet address range 10.1.0.0/24

Subnet name backend
Subnet address range 10.1.1.0/24

6.Leave all other settings as their defaults. When finished select “Review + create and wait for the validation to pass

Select Create

Create the Hub-vnet virtual network configuration. This virtual network has the firewall subnet

1.In your Azure portal, , search for virtual network and select the grayed virtual nerwork.

2.Select + Create

3.Configure the Hub-vnet virtual network. This virtual network has firewall subnet .

Resource group RG1
Name hub-vnet
Region East US

IPv4 address space 10.0.0.0/16

Subnet name AzureFirewallSubnet
Subnet address range 10.0.0.0/26

4.Select Review + Create.After validation is passed select Create

Deployment

5.Once the deployments are complete, search for and select your ‘virtual networks`

6.Verify your virtual networks and subnets were deployed.

App-vnet Subnets

Hub-vnet firewall subnet

Configure a peer relationship between the virtual networks
Virtual network peering enables you to seamlessly connect two or more Virtual Networks in Azure.

1.Search for and select the app-vnet virtual network.

2.In the Settings blade, select Peerings.

3.Select + Add a peering between the two virtual networks.

4.Configure a peer relationship between the virtual networks

Remote peering link name app-vnet-to-hub
Virtual network hub-vnet

Local virtual network peering link name hub-to-app-vnet

5.Leave all other settings as their defaults. Select “Add” to create the virtual network peering.

6.Once the deployment completes, verify the Peering status is Connected