DEV Community: okunola babatunde

Microsoft-Entra-Management-Tasks: Perform basic Multifactor Authentication tasks

okunola babatunde — Mon, 27 Jul 2026 17:23:37 +0000

Introduction

In today’s cloud‑driven world, passwords alone are no longer enough to protect user identities. Microsoft Entra Multifactor Authentication (MFA) adds an essential layer of security by requiring users to verify their identity through multiple factors — something they know (password), something they have (device or code), or something they are (biometric).

This exercise walks you through enabling and configuring MFA in Microsoft Entra ID. You’ll learn how to manage per‑user MFA settings, review service configurations, and set account lockout thresholds to prevent unauthorized access. These are foundational skills for any cloud engineer responsible for securing identities and access in enterprise environments.

Exercise - Perform basic Multifactor Authentication tasks

In this exercise you will explore the MFA setup process and configure a basic MFA deployment.

Task 1 - Enable / Disable Per-user MFA settings

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, open the Identity submenu
Select Users and then select All users.
Look at the menu on the top of the new screen and find Per-user MFA.
Select Per-user MFA.
Put a mark in the box next to Bhogeswar Kalita.
Select Enable MFA from the top of the list.
Read the message box that pops up. Note - This is a manual URL that you can email to the user, if you want to let them know to set up MFA.
Select Enable button.
Note that after a few seconds enforced shows up next to Bhogeswar’s name.

Task 2 - Review the Service settings for MFA

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, open the Identity submenu.
Select Users and then select All users.
Select Per-user MFA item.
Select Service settings.
Review the settings you can configure:

Setting	What it is for
App passwords	Some legacy applications do not support MFA. This setting allows users to continue using those apps by generating app-specific passwords.
Trusted IPs	Define specific IP address ranges that are always considered safe. Users signing in from these ranges can bypass MFA requirements.
Verification options	Choose which verification methods (e.g., SMS, email, authenticator app, phone call) are available for users as their second factor of authentication.
Remember multifactor authentication on trusted device	Allow users on trusted devices (such as company-managed laptops) to retain their MFA-approved status for a specified number of days, reducing repeated prompts.

Select the Discard button if you made any changes.
This is one method of configuring MFA for your users.

Task 3 - View MFA account lockout settings

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, open the Protection submenu.
Scroll to the bottom of the list and select Show more.
Select Multifactor authentication from the menu.
Select Account lockout from the menu.

Field	Value
Number of MFA denials to trigger account lockout	3
Minutes until account lockout counter is reset	180
Minutes until account is automatically unblocked	15

Select the Save option at the top of your screen.
Review some of the other configuration options you have on MFA like:

Fraud alert

Block / unblock users

Notifications

Summary

Task 1 – Enable/Disable Per-user MFA

Navigate to Microsoft Entra admin center → Identity → Users → All users → Per-user MFA.
Select a user (e.g., Bhogeswar Kalita), enable MFA, and confirm.

The user’s MFA status changes to enforced once enabled.

Task 2 – Review MFA Service Settings

Options include:

App passwords: Allow legacy apps without MFA support.
Trusted IPs: Define safe IP ranges to bypass MFA.
Verification options: Choose allowed second-factor methods.
Remember MFA on trusted devices: Retain MFA approval for a set number of days on managed devices.

Task 3 – Configure MFA Account Lockout

Navigate to Protection → Multifactor authentication → Account lockout.

Suggested values:

3 denials trigger lockout.
Counter resets after 180 minutes.
Account automatically unblocks after 15 minutes.

Additional options: fraud alerts, blocking/unblocking users, notifications.

Conclusion

This exercise demonstrates how I set up and managed basic MFA deployment in Microsoft Entra. It covers enabling MFA for individual users, adjusting service-wide settings to balance usability and security, and configuring account lockout rules to protect against repeated failed attempts.

Takeaway Points

MFA can be enforced per user, giving granular control.
Service settings allow flexibility for legacy apps, trusted networks, and device policies.
Account lockout rules are essential to prevent brute-force attacks while minimizing disruption for legitimate users.
Administrators should regularly review fraud alerts, user blocks, and notifications to maintain a secure environment.

Microsoft-Entra-Management-Tasks: Perform basic Conditional Access policy tasks

okunola babatunde — Thu, 16 Jul 2026 16:14:09 +0000

Introduction

Modern organizations rely on secure access to cloud applications, but not every sign‑in should be treated equally. Microsoft Entra Conditional Access provides administrators with intelligent controls to decide who can access what, when, and under which conditions.
In this exercise, you’ll learn how to create and configure a simple Conditional Access policy that blocks a specific user from accessing a chosen app — in this case, Sway — and then test the policy using the What If analysis tool. This hands‑on lab demonstrates how Conditional Access strengthens identity protection and enforces compliance without disrupting productivity.

Exercise - Perform basic Conditional Access policy tasks

In this exercise you will learn to create and configure a Conditional Access policy and test its results with the What If analysis tool.

Task 1 - Review a Conditional Access policy

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Protection submenu and then select Conditional access.
Review the information provided on the Conditional Access Overview page. Note - You can see how many policies you have enabled, and how many users who have logged in recently that are not covered by a policy; along with other details.
Select the + Create new policy from the top menu.
In the Name box enter Block Bhogeswar from using Sway.
In the Assignments section select 0 users and groups selected text.
In the Include section mark the Select users and groups item.
Put a mark in the Users and groups box.
When the list of users and groups opens, select Bhogeswar Kalita from the list.
Use the Select button to add the user.
Select the word Exclude to switch tabs.
Put a mark in the Users and groups box.
When the list of users ang groups opens, select the admin user you are using from the list.
Use the Select button to exclude this user. *Lab tip *- We have added a user for this policy and we have added an exclude for our admin, to make sure they are not accidentally locked out by a policy change.
Find the section Target resources section.
Select the No target resources selected text from this section.
Make sure Resources (formerly cloud apps) is chosen in the dropdown.
In the section titled Select chose the word None.
When the resource selection dialog opens, enter Sway into the search bar.
Put a check in the box next to Sway then use the Select button to approve the choice.
Open and review the Network section, but we are not going to use that for this lab.
Open and review the Conditions section, but we are not using it for this lab. Lab tip - Network and Conditions are powerful options in the Conditional Access policy, but they are not required for this simple policy to block access to an app. You would use them if you wanted to do things like restrict access for user working from a specific location, or block access if a user has show risky behavior. There are many granular options that you can choose from, or even combine together.
Find the section titled Access controls.
Under the word Grant select the text 0 controls selected.
When the Grant dialog opens, select the Block access item. Use the Select button to accept the change.
Use the Select button to accept the change.

Lab tip - You have not set the values needed to create a simple block access policy to the Sway app for Bhogeswar. In the Access controls section, we could have allowed access with specific conditions like MFA or a domain joined device.

At the bottom of the Conditional Access interface, find the Enable policy item.
Set the value to On.
Select the Create button. *Lab tip *- You have three options to pick from, and you can change value at any time, without having to change the policy.

On = enables the policy to run
Off = turn the policy off in case you need to modify it.
Report-only = use this option to review the outcome of the policy before you fully turn it on.
Note: blocked policy is on and there by the access is granted

Task 2 - Perform a What If analysis for a conditional access policy

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Protection submenu and then select Conditional access.
From the Conditional access screen select the** What if** option from the top menu.
In the section User or Workload identity select the text No user or service principal selected.
Make sure the circle next to User is marked.
Select the text No user selected. Note: steps 5,6 and 7, the user in has been preselected and hence option to seclect "No user selected" is not found in my microsoft entra identity dashboard.
From the Users list, put a mark next to Bhogeswar Kalita, then use the Select button.
In the Cloud apps, actions, or authentication context, select the text Any cloud app.
When the Select target type dialog opens, confirm that Cloud apps is chosen in the dropdown.
+ Select Cloud App
Use the search to find the Sway app, then use the Select botton to finalize.
Scroll down to the bottom of the What If tool.
Select the button What If. *Note *- the results appear off the bottom of the screen, so you will need to scroll down again. 15.You should see the Block Bhogeswar from using Sway policy listed, and it is blocking access.

Subtask 1 - Try a different app in the What If analysis

Scroll back to the top of the What If tool.
In the Cloud apps, actions, or authentication context, select the text 1 app selected.
Select the elipsis ... next to Sway and choose Remove.
Select the text None to pick a new app.
Search for Office 365 and choose it from the list, then use the
Select button.
Scroll down to the bottom again.
Select the What If button.

Note: Steps 3 and 4 are not in my account platform, hence I skipped to step 5 and others to continue with the rest of the assignment.

Summary

During this exercise, you:

Opened the Microsoft Entra admin center and navigated to Protection → Conditional Access.
Created a new policy named “Block Bhogeswar from using Sway.”
Assigned the policy to a specific user (Bhogeswar Kalita) while excluding the admin account to prevent lockout.
Selected Sway as the target resource (cloud app) for the policy.
Configured Access controls → Grant → Block access to deny sign‑in attempts.
Enabled the policy and reviewed the three operational modes: On, Off, and Report‑only.
Used the What If analysis tool to simulate sign‑in scenarios and confirm that the policy correctly blocked access to Sway but not to other apps like Office 365.

This workflow, illustrates how Conditional Access evaluates signals such as user identity, app, and context to enforce real‑time access decisions.

Conclusion

Conditional Access is the cornerstone of Zero Trust security in Microsoft Entra ID. By defining precise conditions and controls, administrators can ensure that only trusted users and devices access corporate resources.
The What If tool provides a safe environment to test policies before deployment, helping prevent accidental lockouts and ensuring that access rules behave as intended.
Through this exercise, you’ve seen how a simple policy can effectively block unauthorized access while maintaining flexibility for legitimate users.

Takeaway Points

Conditional Access policies allow fine‑grained control over user access to cloud apps.
Always exclude admin accounts from restrictive policies to avoid lockouts.
Use Report‑only mode or the What If tool to test policies before enabling them.
Combine Access controls with Conditions (location, device, risk) for advanced protection.
Conditional Access is a key component of a Zero Trust architecture, balancing security and usability.

Microsoft-Entra-Management-Tasks: Perform basic Self-Service Password Rest (SSPR) tasks

okunola babatunde — Wed, 15 Jul 2026 13:50:09 +0000

Introduction

Passwords are the gateway to every digital identity, and managing them securely is critical for any organization. Microsoft Entra ID empowers users with Self‑Service Password Reset (SSPR) — a feature that allows individuals to reset their own passwords without administrative intervention.
This exercise demonstrates how administrators can configure and test SSPR, enabling users to verify their identity through multiple authentication methods such as email, SMS, or security questions. The goal is to reduce help‑desk dependency while maintaining strong security controls.

Exercise - Perform basic Self-Service Password Rest (SSPR) tasks.

In this exercise you will learn where the self-service password reset feature is located in Microsoft Entra and explore the process to configure it.

Task 1 - View the SSPR properties for a specific group.

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, open Protection submenu and then select Password reset.
Find the Self service password enabled bar

Value	What it means
None	No users can use the SSPR feature.
Selected	Only members of the selected group(s) can use SSPR.
All	All users in the tenant can use the SSPR feature.

Set the value to Selected.
Select the text No groups selected.
Mark the Project23 group we created previously.
Use the Select button to complete your choice.
Save your configuration.

Subtask 1 - View SSPR authentication methods

Select Authentication methods from the menu within Password reset.
Select 1 as the value for Number of methods required to reset. Note - this value represents how many different ways the user is required to sign-in to the password reset tool, before they are allowed to reset their password. Note that using a password is not an option. 3, Select Email, Mobile phone, and Mobile app code for Methods available to user. Note - if you use Security Questions you have to specific the number of questions the user is required to create and answer.
Use the button at the top to Save your choices.
You have added an Authentication method to your self-service password reset.

Subtask 2 - View SSPR registration

Select Registration from the menu within Password reset.
Make sure the Required users to register when signing in? value is set to Yes.
Set the Number of days before users are asked to re-confirm… to 90 days. 4.Select Save to save your changes.

Subtask 3 - View SSPR reset notifications

Select Notifications from the menu withing Password reset.
Leave the Notify users on password reset? at the default of Yes.
Change the Notify all admins when other admins reset their password? value to Yes.
Use the Save option to save your changes.

Summary

In this exercise, you learned how to:

Access the Microsoft Entra admin center and navigate to Authentication methods → Password reset.
Configure SSPR settings to allow users to reset their passwords securely.
Set up verification options — including email, SMS, and security questions — to confirm user identity.
Test the password reset workflow, from “Forgot Password?” to successful verification and password creation.
Understand how multi‑factor authentication (MFA) enhances password recovery security.

These steps ensure that users can regain access to their accounts quickly and safely, improving both productivity and security posture.

Conclusion

Implementing Self‑Service Password Reset in Microsoft Entra ID is a simple yet powerful way to strengthen identity management. It reduces administrative overhead, minimizes downtime caused by forgotten passwords, and empowers users to take control of their own credentials.
By combining SSPR with multi‑factor authentication, organizations create a resilient defense against unauthorized access and password‑related attacks.

Takeaway Points

SSPR enhances user autonomy while maintaining enterprise‑grade security.
Multiple verification methods (email, SMS, security questions) ensure flexible identity validation.
MFA integration adds an extra layer of protection during password recovery.
Admin configuration in Microsoft Entra ID is straightforward and scalable for any organization.
Empowering users through SSPR reduces help‑desk workload and improves overall security hygiene.

Microsoft-Entra-Management-Tasks: Perform basic Password Protection tasks

okunola babatunde — Wed, 15 Jul 2026 10:05:01 +0000

Introduction
Passwords remain the most common method of authentication, but they are also one of the weakest links in security if not properly managed. Microsoft Entra ID provides built-in password protection features that help administrators enforce strong password policies, prevent common attack vectors, and reduce the risk of compromised accounts.

In this exercise, you’ll explore how to configure smart lockout settings and enforce a custom banned password list. These capabilities allow organizations to automate password strength requirements and defend against brute-force login attempts, ensuring a more secure identity environment.

Exercise - Perform basic Password Protection tasks

In this exercise you will explore the capabilities Microsoft Entra ID offers in protecting your password. You will see how you can automate and enforce a strong password,and use login restrictions to prevent password attacks.

Task 1 - View lock settings, and review duration and threshold values

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Protection submenu and then select Authentication methods. Note - You could also search on Password protection in the search bar at the top.
Select Password protection from the list.
Set the Custom smart lockout with the following values.
Set the Custom smart lockout with the following values.

Field	Value	Description
Lockout threshold	5	Number of failed login attempts allowed before the account is locked.
Lockout duration	30	Duration (in seconds) that the account remains locked once the threshold is reached.

Note - You can also configure a custom banned password list here.

Set Enforce custom list to Yes.
Enter the following values:
Contoso
London
Widget Lab Tip - Your lab is being performed for a company called Contoso, located in London, and it makes Widgets. By enter these three words you block them from being part or a whole of a password.
Set the value for Mode to Enforced.
Select the Save item at the top of the screen.

Summary

This exercise demonstrated how to:
Access the Authentication methods → Password protection settings in Microsoft Entra.
Configure Custom smart lockout with a threshold of 5 failed attempts and a lockout duration of 30 seconds.
Create a custom banned password list (e.g., “Contoso,” “London,” “Widget”) to block weak or predictable passwords.
Set the Mode to “Enforced” so that these rules are actively applied to all users.

By applying these configurations, administrators can strengthen password policies and reduce exposure to password-based attacks.

Conclusion
Strong password protection is a cornerstone of identity security. With Microsoft Entra ID, administrators can go beyond basic complexity rules by implementing smart lockout policies and custom banned password lists. These measures ensure that users cannot rely on weak, predictable passwords and that repeated failed login attempts are automatically mitigated.

This exercise highlights how simple configuration changes can significantly improve organizational security posture, making password attacks far less effective.

Takeaway Points

Smart lockout automatically protects accounts from brute-force attacks.
Custom banned password lists prevent the use of predictable or company-related terms.
Setting the Mode to Enforced ensures policies are applied consistently across the tenant.

Even small adjustments in password policy can have a big impact on security resilience.

Microsoft-Entra-Management-Tasks: Perform basic Group Management tasks

okunola babatunde — Wed, 15 Jul 2026 08:37:20 +0000

Introduction:

In modern cloud environments, Microsoft Entra plays a crucial role in managing identity and access across organizations. Understanding how to perform basic group management tasks is an essential skill for any aspiring cloud engineer. This exercise introduces you to the foundational operations in Microsoft Entra — creating groups, assigning members, managing access, and linking licenses — all of which mirror real-world administrative tasks in enterprise settings.

Exercise - Perform basic Group Management tasks

In this exercise you will explore the beginner level tasks associated with creating and using groups. You make a new group and assign members and set some basic access levels.

Task 1 - Create a Microsoft 365 group

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Groups and then All groups.
Select New group option.
Enter the requested information:

Field	Value
Group type	Microsoft 365
Group name	Project23
Group description	This group consists of members of the new AI Simulation software with codename Project23
Membership type	Assigned

Under the Members heading, select No member selected.
Add Bhogeswar Kalita, by marking the box and choosing the Select button.
Select the Create button.

Task 2 - Create a Security group

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Groups and then All groups.
Select New group option.
Enter the requested information:

Field	Value
Group type	Security
Group name	Guest Users
Group description	This group has all the Guest users currently in the tenant.
Membership type	Dynamic User

Under the Dynamic user members** heading, select Add dynamic query. **
Create a dynamic query with the following values:

Field	Value
Property	userType
Operator	Equals
Value	Guest

Select the Save item from the top of the page.
Select the Create button. Note - It will take up to 2 minutes for the group to be populate.
From the Groups select the Refresh item.
Select the Guest Users group we just created.
Select Members.

Task 3 - Add an existing user to a new group

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Groups and then All groups.
Select the Project23 group we created in Task 1.
Select the Members option from the menu.
Select + Add members from the menu near the top.
Mark the box next to External User and use the Select button.

Subtask 1 - Alternative method to add an existing user to a new group

Open the Users menu, then select All users.
Find and select External User from the list.
Select the Groups item from the menu.
Select the option to + Add memberships.
Mark an existing group and use the Select button to add them.

Task 4 - Add licenses and owners to a group

Open the Microsoft Entra admin center at https://entra.microsoft.com.
Log in using the credentials for your tenant.
From the menu on the left, select Groups and then All groups.
Select the Project23 group we created in Task 1.
Choose the Owners option from the menu. Note - Your tenant administrator will automatically be added as the owner of a group, if no owner is specified.
Select the + Add owners menu item.
Mark the box next to Bhogeswar and use the Select button.
Notice the new owner has been added to the group.

Subtask 1 - Adding a license to a group

Open a new tab in your browser.
Connect to Microsoft 365 admin center at https://admin.microsoft.com.
From the menu on the left, open the Billing section and select Licenses.
Select the Microsoft Power Automate Free license.
Choose the Groups tab from the newly opened screen.
Select the + Assign licenses item.
Use the dropdown on the right side of the screen to select the Project23 group created earlier.
Use the Assign button at the bottom of the screen.
Close the You assigned licenses… notification. # Note: In carrying out the assignment of microsoft power automate free, I used my mentor's microsoft 365 account to assign this license to the Project group 233. The assignment was un-successful due to the pre-assignment done by the account holder.
Use the Refresh button to see the added group licenses.

Summary

This exercise demonstrated how to:

Create a Microsoft 365 group for collaboration.
Create a Security group with a dynamic membership rule.
Add existing users to groups using multiple methods.
Assign owners and licenses to groups. These are the building blocks of group management in Microsoft Entra and Microsoft 365.

Conclusion

Group management is central to identity governance. By mastering these tasks, administrators can ensure that users are properly organized, permissions are consistently applied, and resources are securely managed. This exercise highlights how assigned membership and dynamic rules complement each other in different scenarios.

“From Code to Cloud: Building and Shipping a Simple Node.js App with Docker and GitHub”

okunola babatunde — Mon, 13 Jul 2026 14:01:30 +0000

Introduction

In the world of DevOps, the ability to package applications into containers and manage them with version control is a fundamental skill. This guide walks you through creating a minimal Node.js app, containerizing it with Docker, and pushing it to GitHub for collaboration and backup.

By following these steps, you’ll not only learn how to build and run containers but also understand how version control ties into modern cloud workflows. This exercise emphasizes operational excellence, reliability, and performance efficiency — three pillars of cloud-native engineering.

Create Folder

Implementation Guide 1

Create Folder

Instruction Summary

Creates a dedicated working directory for the lab and moves your shell into it.

Why It's Needed

Keeps the app and Dockerfile isolated from other files on the machine so the build context stays clean.

Pillar Connection

Operational Excellence — Setting up a clean workspace before you start.

To create a folder named "Container-Lab", run this command "mkdir -p ~\container-lab && cd ~\container-lab"

Create app.js

Implementation Guide 1

Create app.js: Create app.js using touch and write the Node.js console log statement

Instruction Summary

Creates the Node.js source file that the container will run.

Why It's Needed

This is the application code your Dockerfile will package into the image.

Pillar Connection

Performance Efficiency — Shipping the smallest possible app for the container.

To create app.js, run this command "touch app.js && echo 'console.log("Hello, DevOps!");' > app.js" Note: The first part of the command, "touch app.js" means to create an app known as app.js While the second part of the command, echo 'console.log("Hello, DevOps!");' > app.js

Implementation Guide 1

Create Dockerfile

Instruction Summary

Writes the build recipe Docker uses to package your app: base image, files to copy in, and the startup command.

Why It's Needed

Without a Dockerfile, Docker has no instructions for turning your source code into a runnable image.

Pillar Connection

Operational Excellence — Reproducible builds defined as code.

The two commands are in existence. The first command is to create a Dockerfile which "touch Dockerfile "

while the second command prints into the dockerfile created "echo -e 'FROM node:18-alpine\nCOPY app.js .\nCMD ["node","app.js"]' > Dockerfile"

Implementation Guide

Build Image

Instruction Summary

Reads the Dockerfile and builds a portable, versioned image containing your app and its runtime.

Why It's Needed

The image is the artifact that actually gets shipped and run anywhere Docker is installed.

Pillar Connection

Reliability — A versioned image guarantees the same app runs identically everywhere.

In other to Build a Docker image from the Dockerfile in the current directory, run this Command "docker build -t simple-container-lab:1.0 ." # Note: Ensure you run your docker engine before running this docker image buiding command "docker build -t simple-container-lab:1.0 ." to avoide error notification on your IDE

Implementation Guide

Run Container

Instruction Summary

Starts a container from the image you just built and removes it automatically when it exits.

Why It's Needed

Confirms the image actually runs your app correctly before you ship it anywhere.

Pillar Connection

Operational Excellence — Verify before you trust a build.

To create and start a new container from the specified image, "docker run --rm simple-container-lab:1.0"

Implementation Guide

1 Initialize Git

Instruction Summary

Creates a local .git directory so version control can start tracking your project.

Why It's Needed

Without a repository, Git has nothing to track changes against.

Pillar Connection

Operational Excellence — Version control is the foundation of every DevOps workflow.
-To nitialize a new Git repository in the current directory, run this command "git init"

Implementation Guide

1 Stage Files

Instruction Summary

Marks the project files as ready to be included in the next commit.

Why It's Needed

Git only commits what has been staged — this moves files from the working directory into the staging area.

Pillar Connection

Operational Excellence — Deliberate, reviewable changesets.

To know the files that are not staged, run this command "git status" -To stage all changed files for the next commit, run this command "git add ." ** **Note: In other to view Staged file, re run this command "git status"

Implementation Guide

Commit Files

Instruction Summary

Saves the staged files as a permanent, named snapshot in your repository's history.

Why It's Needed

Commits are the checkpoints you can always return to, diff against, or roll back.

Pillar Connection

Reliability — A clear history makes recovery and audits possible.

Run *git commit -m 'feat: first container' * to create a new commit with all staged changes and the message after -m.

Implementation Guide

Set GitHub Username

Instruction Summary

Stores your GitHub username in a shell variable.

Why It's Needed

Lets the next command build the correct remote URL without you retyping your username.

Pillar Connection

Operational Excellence — Reusable, less error-prone commands.
-To Set the shell variable GITHUB_USERNAME so later commands can reference it with $GITHUB_USERNAME. Run this command "GITHUB_USERNAME="BAOKONCEPTS"

Implementation Guide

Add Remote

Instruction Summary
Links your local repository to a repository on GitHub named "origin".

Why It's Needed
Without a remote, there is nowhere for your local commits to be pushed to.

Pillar Connection
Operational Excellence — Connecting local work to a shared, backed-up remote.

tO Stage the specified file(s) for the next commit, "git remote add origin https://github.com/${GITHUB_USERNAME}/simple-container-lab.git"

Implementation Guide

Rename Branch

Instruction Summary

Renames the current branch to "main".

Why It's Needed

Matches the default branch name GitHub expects for new repositories, avoiding a push error.

Pillar Connection

Operational Excellence — Consistent naming conventions across your team.

To rename the default branch to main, run this command "git branch -M main"

Implementation Guide

1 Push to GitHub

Instruction Summary

Uploads your commits to the "origin" remote and sets "main" to track it.

Why It's Needed

This is what actually gets your work onto GitHub and sets up future pushes/pulls to sync automatically.

Pillar Connection

Reliability — Your work is now backed up and shareable outside your local machine.

To Upload your local commits to the remote repository, run this command "git push -u origin main"

Summary

This hands-on lab covered the following stages;

Creating a clean project folder.
Writing a minimal Node.js app (app.js).
Defining a Dockerfile for reproducible builds.
Building and running a Docker image.
Initializing Git and staging files.
Linking to GitHub, renaming the branch, and pushing code.

Together, these steps demonstrate the end-to-end DevOps lifecycle starting from writing code to shipping it in a container and backing it up in a shared repository.

Conclusion

By completing this workflow, you’ve learned how to;

Create and run a Node.js app inside a Docker container.
Use Dockerfiles to define reproducible builds.
Apply Git version control to track and manage changes.
Push your project to GitHub for collaboration and reliability.

This exercise demonstrates the core practices of DevOps: automation, reproducibility, and collaboration.

Key takeaways from this hands-on lab;

Containers make applications portable and consistent across environments.
-Dockerfiles are the blueprint for reproducible builds.
Git ensures deliberate, reviewable changes and collaboration.
GitHub integration connects local work to a shared, backed-up remote.

Practicing all steps as detailed in this article, builds confidence in cloud-native workflows and prepares you for real-world DevOps tasks.

Microsoft-Entra-Management-Task: Perform basic User Management tasks

okunola babatunde — Sat, 11 Jul 2026 06:38:59 +0000

Introduction:

Welcome to your first step into cloud identity management! In modern IT architecture, an organization's security boundary begins with identity. This hands-on lab introduces you to the core responsibilities of an Identity and Access Administrator. Over the next 10 minutes, you will gain practical experience in Microsoft Entra ID by executing five essential user management workflows—ranging from provisioning single and bulk user accounts to assigning operational roles, licenses, and collaborating with external partners.

Exercise - Perform basic User Management tasks

In this exercise you will explore the beginner tasks of an Identity and Access administrator by creating and managing a user in Microsoft Entra ID. There are five common activities you will perform in your lab from creating a new user to assigning them roles and licenses.

Task 1 - Create a new user

Open the Microsoft Entra admin center at https://entra.microsoft.com
Log in using the credentials for your tenant.
From the menu on the left, select User and then All users.
Select + New user and then pick the Create new user option
Enter the requested information:

| Field | Value |

| :--- | :--- |

| User principal name | BhogeswarK |

| Display name | Bhogeswar Kalita |

Leave the Mail nickname as is.
Make a copy of the Password (auto-generated) and store it in Notepad. You will need it later.
Leave Accounted enabled checked.
Select the Properties tab.
Set the values for first and last name:

Field	Value
First name	Bhogeswar
Last name	Kalita

Note that you can set the User type to Member. If you pick Guest, it will restrict the users capabilities.
Scroll down to the bottom of the page.
Set the Usage location to United States or to whatever region you are in.
Select the Review + create button.
Select Create.

Subtask 1 - Log in to confirm user

Open an InPrivate browsing window.
Connect to the Microsoft Entra admin center at the link https://entra.microsoft.com Voya457374
Enter the username and password you just created. | Field | Value | | :--- | :--- | | Username | BhogeswarK@your tenant name.onmicrosoft.com | | Password | Auto generated password you saved |
If prompted follow the on-screen instructions to complete MFA setup.
Feel free to explore the Microsoft Entra admin center for a minute
Close the InPrivate browsing window.

Task 2 - Add a license to the user

Open a new tab in your browser.
Connect to the Microsoft 365 admin center at https//:admin.microsoft.com.
If prompted, log in using the credentials for your tenant.
Find the menu on the left side of the screen.
Open the Billing item in the menu.
Select Licenses from the list.
When the list of licenses appears, select Microsoft Power Automate Free
Select the + Assign licenses item.
Choose Brogeswar from the list (user created in previous task).
Select the Assign button at the bottom of the page.

Task 3 - Invite an external user to your tenant

If not already open - Open a browser and connect to the Microsoft Entra admin center at https://entra.microsoft.com.
From the menu on the left, open the Identity menu.
From the menu on the left, open the Identity menu.
At the top of the page select + New User.
Choose the option to Invite external user from the dropdown.
Enter the information for your new external user:

Field	Value
Email	ExtUser@testemail.com
Display Name	External User
Message	Thank you for joining the company for this short work project. We look forward to building this project together.

Select the** Review + Create** button.
Select Create.

Task 4 - Assign a role to a user

If not already open - Open a browser and connect to the Microsoft Entra admin center at https://entra.microsoft.com.
If prompted, log in using the credentials for your tenant.
In the left menu find the Identity section. Open it if not already opened.
Select Users then select All users.
Choose the user Bhogeswar Kalita create in the earlier task.
From the newly opened menu select Assigned roles.
At the top of the screen select + Add assignment.
From the Select role dropdown menu chose the role Attribute Definition Reader.
Select the Next button when it becomes available
Choose the option Eligible for Assignment type.
Select Assign.

Subtask 1 - Alternate method to assign a role to a user

Look at the Identity menu section on the left side of the screen.
Select the Show more option to see the full Identity menu.
From the list of items in the Identity menu, expand the Roles & admins section.
Select Roles & admins.
Select Attribute Log Reader from the list of roles.
From the top of the screen select + Add assignment.
From the Select member(s) select the No member selected text.
From the list of user choose Bhogeswar Kalita.
Choose the Select button at the bottom.
Select the Next button.
On the Add assignments page choose Active for the Assignment type.
Note that you have to enter a justification for this role / user assignment.
Enter the justification User will be working as an Attribute log reader as their primary job. into the box.
Select Assign.

Task 5 - Bulk import users

If not already open - Open a browser and connect to the Microsoft Entra admin center at https://entra.microsoft.com.
If prompted, log in using the credentials for your tenant
From the Identity menu, select Users and then select All users.
From the top of the page, select the Bulk operations drop-down arrow and then select Bulk create. Note - Selecting Bulk create will open a new tile. This tile provides a Download link to a template file that you will edit to populate with your user information and upload to add the bulk creation of users.
Select Download to see a sample bulk user CSV file Note **- The .csv template provides you with the fields included with the user profile. This includes the required username, display name, and initial password. You can also complete optional fields, such as Department and Usage location, at this time. You do not need to fill out all the fields. **Lab Tip - A sample CSV has been provided in the Allfiles/Lab1 folder – APL0501-BulkUser.csv.
Open Notepad.
Open the SC300BulkUser.csv file.
Search and replace the existing value «>> with Your actual domain name.
Save the file.
On the Bulk create users dialog, select the file folder icon on step 3.
Path to the Allfiles/Lab1 folder and select APL0501-BulkUser.csv file.
Select Open.
Wait for the notification that the file uploaded successfully. Select the Submit button to add the users. *Note *- After the users have been created, you will be prompted that the creation has succeeded.
Close the Bulk create users dialog.
Check the list of users to see your bulk created users. Modern Cloud Engineering relies heavily on the principle of Least Privilege and secure identity management. This hands-on technical exercise demonstrated the foundational lifecycle of identity and access management (IAM) within Microsoft Entra ID and the Microsoft 365 Admin Center.

SUMMARY

The lab successfully walked through the five core pillars of user administration:

Identity Provisioning: Creating a standard internal user cloud identity (Bhogeswar Kalita) and verifying authentication pipelines via isolated active sessions (InPrivate browsing).
Resource & License Lifecycle: Assigning SaaS capabilities (Microsoft Power Automate Free) to a user entity via central billing allocation frameworks.
B2B Collaboration: Operationalizing business-to-business workflows by safely inviting external guest identities (ExtUser@testemail.com) into a secure tenant space.
Role-Based Access Control (RBAC): Implementing sophisticated authorization boundaries by assigning targeted roles (Attribute Definition Reader and Attribute Log Reader) using both Eligible and Active assignment types—complete with strict auditing justification.
Automation & Scalability: Utilizing standardized structural templates (.csv) to execute bulk identity provisioning operations efficiently.

Key Takeaways for Aspiring Cloud Engineers

If you are charting your path toward becoming a successful Cloud or DevOps Engineer, this exercise holds crucial architectural lessons that stretch far beyond just clicking buttons in a portal:

Identity is the New Perimeter: In the cloud, traditional network perimeters (like firewalls) are no longer enough. Identity is your first and strongest line of defense. Mastering Microsoft Entra ID (or AWS IAM / Google Cloud IAM) is an absolute non-negotiable skill for any modern cloud professional.
Embrace Just-In-Time (JIT) & PIM Mentality: Task 4 highlighted the difference between Eligible and Active assignments. As a cloud engineer, you should rarely give someone permanent global access. Understanding how to configure temporary, auditable, and justifiable access is what separates junior admins from elite cloud architects.
Think in Scale (Automate Everything): While creating a single user manually (Task 1) teaches you the fundamentals, Task 5 (Bulk Import) teaches you how production environments actually work. Always look for ways to abstract manual workflows into CSVs, scripts (PowerShell/CLI), or Infrastructure as Code (Terraform/Bicep).
Secure Multi-Tenant Boundaries: Cloud ecosystems are interconnected. Learning how to properly invite, restrict, and manage B2B guest accounts ensures that external collaboration does not accidentally open backdoors into your organization's sensitive data.

Conclusion

Mastering the cloud begins with mastering the user. This exercise seamlessly bridges the gap between theoretical identity governance and the practical realities of infrastructure management.

By understanding how identities are provisioned, licensed, restricted via RBAC, and scaled through bulk automation, you have successfully practiced the foundational mechanics of a secure cloud infrastructure. As you progress on your cloud engineering journey, carry the mindset demonstrated here: secure by design, automated at scale, and governed by strict access controls.

Mission 5: Tag the Production Release

okunola babatunde — Wed, 08 Jul 2026 19:44:33 +0000

Introduction:

Whether you are building a solo project or working inside a massive enterprise, code that only lives on your local machine isn't true DevOps. To achieve automated, scalable software delivery, you must learn to checkpoint your progress, push it to a shared remote, and signal to your automation pipelines that your software is ready for prime time.

In this final mission of the DevOps Lab, you will learn how to officially stamp your code with a version number using Git tags, push your architecture to GitHub, and lay the crucial groundwork for automated CI/CD pipelines.

Implementation Guide

1. Create a Release Tag

Instruction Summary
Commits any remaining work and creates a shiny 'v1.0.0' sticker on your latest commit.

Why It's Needed

Tags mark stable points in time. When a CI/CD pipeline sees a new tag, it knows it's time to automatically deploy to production!

Pillar Connection
Reliability — Rock-solid, easy-to-find rollback points.

To Stage all changed files for the next commit, run this command** "git add ."**
Staging the specified file(s) for the next commit, you will need to run this command "git commit -m 'feat: add Makefile automation'"
To create a tag (label) on a commit — typically used for release versions (v1.0, v2.0), run this command "git tag -a v1.0.0 -m 'First epic DevOps lab release!'"
In other to Show the commit history. run this command "git log --oneline". This command condenses each commit to one line,
"git log --graph" shows branches visually.
In order to show the commit history of your Git repository, but with additional information showing which branches, tags, or references point to each commit, run this command "git log --decorate"

Push Everything to GitHub

Instruction Summary
Uploads all your local commits and the v1.0.0 tag to your GitHub repository so the world can see your work.

Why It's Needed
Code that only lives on your laptop isn't real DevOps! Pushing to GitHub backs up your work, enables team collaboration, and is the trigger point for CI/CD pipelines in the real world.

Pillar Connection
Collaboration & Delivery — Shipping code to the remote so pipelines can pick it up.

To upload your local commits to the remote repository, run this command "git push -u origin main"
To push your release tag too, run this command "git push origin v1.0.0"

Conclusion
Successfully tagging a production release is more than just an administrative step; it is the bridge between writing code and shipping software at an enterprise level. By moving away from local, unversioned development and adopting Git tags, you establish absolute certainty over what code is currently running in your production environment.

In modern engineering, this predictable structure removes the guesswork from deployment. If an unforeseen critical bug emerges, your team doesn’t have to parse through hundreds of chaotic commits to find a stable version—they can simply point the infrastructure back to v1.0.0. Implementing this workflow effectively transforms a developer's local experiment into a secure, collaborative, and deployment-ready architecture.

Summary
In this final mission of the DevOps Lab, you successfully completed the critical cycle of code finalization and remote delivery:

Milestone Creation: By executing git tag, you attached a permanent, immutable metadata marker (v1.0.0) to your latest commit, establishing an explicit rollback point that safeguards system reliability.
Upstream Delivery: By troubleshooting and running git push, you securely transferred your local repository's history to a centralized cloud host on GitHub, making your code accessible to your wider team.
The Automation Trigger: In professional environments, pushing an annotated version tag acts as the definitive trigger event that commands automated systems to build, test, and deploy software directly to users.

Mission 4: Automate with a Robot Butler (Make)

okunola babatunde — Wed, 08 Jul 2026 15:19:12 +0000

Introduction:

Introduction
In the fast-paced world of DevOps, efficiency is everything. Engineering teams frequently handle complex, multi-step commands to build, test, and deploy applications. Relying on memory or manual typing for these tasks introduces human error and slows down momentum.

To achieve Operational Excellence, teams rely on automation tools like Make. This guide provides a step-by-step walkthrough for setting up Make on a Windows environment, creating an automation script (Makefile), and testing it locally to streamline your development workflow.
However, the implementation process follows three logical phases to move you from a manual setup to an automated, reliable system:

Implementation Guide

Install Make (if you don't have it) Instruction Summary: Installs the 'make' command-line tool so your system can read and run Makefile instructions. Why It's Needed: Make is not installed by default on Windows. Without it, the 'make build' shortcut won't work. Pillar Connection: Operational Excellence — Setting up the right tools before you start. To install "Make" follow the processes below,
To install "Make", utilize winget by running this command *"winget install GnuWin32.Make" *
To verify the installation of "Make", run this command "make --version"

2. Write the Automation Script (Makefile)

Instruction Summary: Creates a 'Makefile' that defines simple shortcuts (build, run, clean) for our long Docker commands. The tab character before each docker command is critical — Make requires TABS, not spaces.

Why It's Needed

DevOps engineers hate doing the same thing twice. Automation saves time and prevents typos!
Pillar Connection:
Operational Excellence — Automating the boring stuff so you can focus on fun stuff.
To create the Makefile with proper tab characters, run this command "$tab = "`t"" and **""build:n${tab}docker build -t devops-hello .nrun:n${tab}docker run --rm devops-hellonclean:`n${tab}docker rmi devops-hello" | Out-File -FilePath Makefile -Encoding ascii"

To verify the file is correctly created,, run this command "Get-Content Makefile"

2. Test Your New Butler

Instruction Summary:
Executes your newly created shortcuts to build the image, run it, and clean up the mess.

Why It's Needed
Always test your automation locally before letting it loose on real servers.

Pillar Connection
Reliability — Verifying automation works perfectly.

Conclusion:
Automation isn't just about saving seconds; it's about eliminating cognitive load and preventing typos that break systems. By transitioning tedious Docker commands into a single Makefile, you establish a standardized workflow that works the same way every time. Adopting these automation habits ensures that your local environment remains aligned with the same rigorous engineering pillars found in elite, large-scale production infrastructures.

Summary:
• The Goal: Turn repetitive, error-prone terminal commands into simple, reliable one-word shortcuts using Make.
• The Process:

Install the tool using standard Windows package managers (winget)
Write a strict, tab-formatted configuration file (Makefile) containing your command definitions.
Run and verify the shortcuts (make build, make run, make clean) locally.
• The Value: Enhances Operational Excellence and Reliability by substituting human error with automated execution.

Mission 3: Measure DORA Metrics.

okunola babatunde — Wed, 08 Jul 2026 09:32:28 +0000

Introduction:

Every elite sports team relies on stats to win games, and software development teams are no different. In the world of technology, top-performing software teams don't guess how good they are—they measure it. The secret to their success lies in four key numbers known as DORA metrics. These metrics act as a high-tech scoreboard, helping teams track exactly how fast they can deliver software and how reliable their systems are.
However, DORA stands for DevOps Research and Assessment, which is the team that spent years figuring out what makes a software team successful. They discovered that elite teams excel in four specific areas:

Deployment Frequency: How often does the team successfully push new code or updates live to users? (Speed)
Lead Time for Changes: How long does it take for a line of code to go from being written to actually running in production? (Velocity)
Change Failure Rate: What percentage of deployments cause a problem or outage that requires an immediate fix? (Quality)
Failed Component Recovery Time: When things do break or crash, how long does it take the team to restore service to normal? (Stability)

By tracking these four numbers, teams no longer have to rely on guesswork. They can easily spot bottlenecks, reduce errors, and continuously improve how they work.

Implementation Guide
1. Simulate a Super-Fast Deployment
Instruction Summary: Adds a second save point (commit) to simulate shipping a new feature quickly.
Why It's Needed:
Deployment Frequency is a key metric. Elite teams deploy multiple times a day instead of once a month!

Pillar Connection:
Speed & Agility — Measuring and supercharging your delivery speed. The core activity here, is the procedure to make a change to app.js containerized by docker.

To make a quick change and add it to app.js, run this command "Add-Content app.js 'v2'"
To Stage all changed files for the next commit, run this command "git add ."
To create a new commit with all staged changes and the message after -m run this command "git commit -m 'feat: bump to v2'"
To show the commit history, run this command "git log --oneline" condenses each commit to one line.
To visually show the branch, run this command "git log --graph"

Conclusion
Measuring success isn't about working harder; it’s about working smarter. By adopting DORA metrics, any engineering team can look at the data, see exactly where they are struggling, and make targeted improvements. Ultimately, these secret numbers give teams a clear, data-driven roadmap to transform themselves from average performers into elite, high-speed innovators.

Summary
What it is: DORA metrics are four specific data points used to measure the success of software engineering teams.

Why it matters: They help teams balance speed (how fast they deliver software) with stability (how rarely things break).

The Goal: By tracking these numbers, teams can eliminate guesswork and adopt the exact habits used by the world's most elite DevOps organizations.

Mission 2: Containerise the App

okunola babatunde — Tue, 07 Jul 2026 22:50:39 +0000

Introduction:

Welcome back to Mission 2! In the https://dev.to/okunola_babatunde_dff5cbd/mission-1-arm-your-workstation-438i, we laid the groundwork by setting up our project folder, building a tiny Node.js application, saving it to Git, and linking everything up to GitHub.

Now that we have a solid, version-controlled codebase, it's time to take the next critical step in modern development: containerization.

In this guide, I am going to take that exact Node.js app from our GitHub repository and package it into a lightweight, portable, and isolated container using Docker. By the end of this mission, you will ensure that your app runs consistently, regardless of where it is deployed. Let's get started!

Implementation Guide

1. Create Your First App

Instruction Summary: Creates a folder, makes a tiny Node.js app, saves it into Git history, and links it to your GitHub repository.
Why It's Needed:
Every epic journey starts with a single line of code. We connect to GitHub early so your work is always backed up and ready for CI/CD!

Pillar Connection
Operational Excellence — Versioning controls everything from minute one.
terminal
In order to create a folder and switch into the folder, run the command "mkdir devops-lab; cd devops-lab"

To create the app.js file using PowerShell, run this command "Set-Content app.js 'console.log("Hello, DevOps!");'"

The next step is to initialize a new Git repository in the current directory by running this command "git init"

To list, creat or manage branches, run this commmand "git branch -M main"

To stage all the changed files, run these command at a go "git add . && git commit -m 'Initial commit'"

In order to connect the local repo on the machine with the Github repo created in mission 1, run the following command "git remote add origin plus url of the github repo created in the mission 1". However, this command stages the specified file(s) for the next commit.

To manage remote repository connections (origin, upstream, etc.). Run this command "git remote -v"

Note: If this command "git remote -v" is run and there is no evidence of fetch and push, it means there is an error or errors somewhere.

2. Build the Docker Container
Instruction Summary: Writes a recipe (Dockerfile) to package your app, builds it into an image, and runs it! The Dockerfile tells Docker which base image to use, which files to copy in, and which command to run.
Why It's Needed: Containers ensure that if it works on your laptop, it'll work on the production servers without those pesky 'it works on my machine' excuses.
Pillar Connection:
Reliability — Eliminating environment drift with magical immutable boxes.
From the power shell, create a docker file running the following command;
@'

FROM node:18-alpine

COPY app.js .

CMD ["node","app.js"]

'@ | Out-File -FilePath Dockerfile -Encoding ascii

To successfully know if the docker file has been created, run this command "Get-Content Dockerfile"

Run this command "docker build -t devops-hello ." to build a Docker image from the Dockerfile in the current directory. The -t flag tags it with a name.
To creates and start a new container from the specified image, run this command "docker run --rm devops-hello"

Summary

In this mission, you broke your application free from the unique quirks of your personal computer. You wrote a tiny JavaScript program, saved a snapshot of it using a tracking tool called Git, and then created a precise recipe file called a Dockerfile. This recipe tells Docker exactly how to wrap your program inside its own self-contained, portable digital box called an image.

Conclusion

By putting your app inside this digital box, you guaranteed that it will run flawlessly anywhere. Whether it is running on your laptop, a colleague's computer, or a massive cloud server, it will behave exactly the same way every single time. This completely solves the classic developer headache: "Well, it worked perfectly on my machine!" This predictable, hassle-free packaging is the foundation of how modern software is built and delivered to millions of users today.

Key Takeaways

The "Frozen" Blueprint: Think of a Docker image as a frozen, unchangeable blueprint. It contains everything your program needs to survive and run, so you never have to worry about missing files or wrong software versions.
Packing Light: By using a tiny, stripped-down version of Node.js (alpine), your digital box stays incredibly small and lightweight. This means it downloads in seconds and uses almost none of your computer's memory.
No Leftover Mess: By using a special cleanup command (--rm), the digital box instantly vanishes the moment it finishes running. This keeps your computer completely clean, with no digital clutter left behind.
Future-Proofing: By connecting your project to GitHub right from the start, you ensure your work is always backed up safely in the cloud and ready to be automatically updated whenever you write new code.

Mission 1: Arm Your Workstation

okunola babatunde — Sun, 28 Jun 2026 17:15:16 +0000

Introduction:
Before anything else, your workstation is either your launchpad or your bottleneck. That’s what “Mission 1: Arm Your Workstation” is about.

It’s the foundation of every serious developer journey. Not the language, not the framework, but the environment where everything happens. You can’t build fast or think clearly in a setup that constantly slows you down.

Arming your workstation means turning your tools into a system. Your laptop becomes a command center, VS Code your cockpit, and the terminal your control room. Git, GitHub, Node.js, Docker, Postman, and Chrome DevTools stop being random tools and start working like a unified arsenal.

But it’s not just software, it’s flow. The goal is to remove friction so ideas move smoothly from thought to execution. A clean, structured setup means less confusion and more building.

Most beginners skip this. They jump into tutorials with messy environments and scattered tools, then wonder why progress feels slow. Professionals do the opposite, they build the environment first.

So the mission is simple: set up your system like someone building at scale, not experimenting casually.

Once your workstation is armed, everything changes. You don’t just learn faster, you execute better, think sharper, and build with momentum.

Implementation Guide

Upgrade Local Arsenal

Instruction Summary:
Refreshes your computer's package list and upgrades installed software to their latest, shiniest versions.
Why It's Needed:

A fully patched system keeps the gremlins away and prevents annoying errors when installing new tools.

Pillar Connection:
Operational Excellence — Keeping your digital house clean and ready for action.
In order to refresh the package list so you can get the latest versions when installing. Run this Command on your system terminal*"winget upgrade --all"*

. The applications highlighted above were successfully upgraded

2. Install Git, Curl, and Docker
Instruction Summary:
Installs** Git** (your code time-machine), Curl (for downloading stuff), and Docker (for running apps in isolated boxes).
Why It's Needed:
These three tools are the absolute foundation of modern tech. You'll use them every single day!
Pillar Connection:
Operational Excellence — Equipping yourself with industry-standard tools.
. The above applications have to be run individually to have them installed.

Prints the installed Docker version to verify it's set up.

3.** Introduce Yourself to Git**
Instruction Summary:
Tells Git who you are so it can slap your name on every awesome piece of code you write.
Why It's Needed:
Since we just installed Git, it needs to know who's driving! Without this, you can't save (commit) your work.
Pillar Connection:
Security & Auditing: Knowing exactly who made what change.
Run the following commands;

Sets Git configuration (user name).

Sets Git configuration (email).

Sets Git configuration (user name, email, aliases, etc.)

Create a GitHub Repository Instruction Summary: Creates a remote home for your code on GitHub — think of it as your project's cloud backup and portfolio piece. Why It's Needed: In real DevOps, code lives in a remote repository so the whole team can collaborate, CI/CD pipelines can trigger, and nothing is lost if your laptop catches fire! Pillar Connection: Collaboration & Sharing — Every professional project needs a central remote repository.
1. Go to https://github.com and sign in (or create an account if you don't have one)
Click the '+' icon in the top-right corner → 'New repository'
Name it: devops-lab
Leave it PUBLIC, do NOT add a README (we'll push our own code)
Click 'Create repository'
Copy the HTTPS URL — it will look like: https://github.com/YOUR-USERNAME/devops-lab.git https://github.com/BAOKONCEPTS/devops-lab1.git ## Summary Mission 1: Arm Your Workstation focuses on setting up a strong development environment before writing code. A well-prepared workstation gives you structure, speed, focus, and confidence. Tools like VS Code, Terminal, Git, GitHub, Curl, Docker,and Chrome DevTools become part of your daily workflow, helping you build, test, debug, and deploy more efficiently.

## Conclusion
A strong setup creates a stronger developer. When your workstation is organized and properly equipped, you reduce frustration, avoid setup problems, and build with more confidence. Before building great projects, you must first build the environment that supports your growth.

## Key Takeaways

Your workstation is the foundation of your developer journey.
The right tools help you work faster and smarter.
A clean setup reduces confusion and wastes time.
Your laptop or PC should function like a command center.
Good preparation helps you focus on building, not fixing setup issues.
Professionals prepare before they build.
strong workstation gives you confidence and momentum.