DEV Community: Ayanwole Ayangbade

Azure Architecture And Identity and Access Management.....

Ayanwole Ayangbade — Sun, 20 Sep 2026 17:49:41 +0000

Cloud & DevOps: Azure Architecture ☁️

When you deploy resources in Azure, they fit into a well-defined hierarchy. Grasping this structure is crucial for effectively managing costs, access, and organization as you scale up:

🔹 Azure AD tenant – this is your organization's identity boundary
🔹 Management groups – these help you bundle subscriptions for a unified policy
🔹 Subscriptions – they serve as your billing and access boundary
🔹 Resource groups – think of these as logical containers for related resources
🔹 Resources – these are the actual VMs, storage accounts, apps, and more

Imagine it like a series of folders within folders: everything is neatly organized, allowing you to manage permissions and costs from the top down.

Next up: Identity & Access Management (IAM) 🔐

In Azure, IAM operates on Role-Based Access Control (RBAC). Access isn’t just a simple "on" or "off" switch; it’s made up of three components:

1️⃣ Who – the security principal (this could be a user, group, or app)
2️⃣ What – the role definition (like Owner, Contributor, Reader)
3️⃣ Where – the scope (this could be a management group, subscription, resource group, or resource)

When you combine all three, you create a role assignment — the specific permission that grants access.

💡 Key takeaway: Always assign the least privilege necessary, at the smallest scope possible. This is the golden rule of cloud security.

Hello Tech Community! 👋

Ayanwole Ayangbade — Mon, 14 Sep 2026 11:47:37 +0000

My Journey to Mastering Git: Starting with Git Config

Learning to code is not only about writing code.

It is also about learning the tools that professional developers use to create, manage, track, and collaborate on projects.

One of the tools I have recently started focusing on is Git.

I recently completed the **Git Config exercise on W3Schools, and although it may look like a small step, I see it as an important milestone in my journey toward becoming a more confident developer.

Why I Am Learning Git

As I continue developing my technical skills, I have realized that understanding Git is essential.

Git allows developers to:

Track changes in their projects
Revert to previous versions of their code
Create and manage branches
Experiment without damaging the main project
Collaborate with other developers
Maintain a history of project development
Work effectively with platforms such as GitHub

For me, learning Git is therefore not just about completing exercises. It is about developing a professional development workflow.

My First Step: Git Configuration

One of the foundational concepts I am learning is Git configuration.

Git configuration allows developers to set information that Git uses when working with repositories.

For example, configuring a username and email helps Git identify who made a particular commit.

A basic configuration can look like this:

bash
git config --global user.name "Your Name"
git config --global user.email "your@email.com"

To check the configuration, you can use:

bash
git config --list

These commands may seem simple, but understanding them properly creates a foundation for everything that comes next.

What I Have Learned So Far

My Git learning journey is still at the beginning, but I am gradually becoming familiar with important concepts such as:

Repository – the location where a project's files and Git history are maintained.

Commit – a recorded snapshot of changes made to a project.

Branch – an independent line of development that allows developers to work on features or changes without immediately affecting the main branch.

Merge – combining changes from different branches.

Clone – creating a local copy of a remote repository.

Push – sending local commits to a remote repository.

Pull – retrieving changes from a remote repository.

Understanding these concepts will become increasingly important as I begin working on larger projects.

Git + GitHub

Another major goal of my learning journey is becoming comfortable with GitHub.

Git and GitHub are closely related, but they are not the same thing.

Git is a version control system.

GitHub is a platform that hosts Git repositories and provides collaboration features.

A typical workflow can eventually look something like this:
text
Create Project
↓
Initialize Git
↓
Make Changes
↓
git add
↓
git commit
↓
git push
↓
GitHub Repository

This workflow is something I intend to practise repeatedly until it becomes second nature.

My Learning Philosophy

One thing I am learning about programming is that progress does not always come from trying to learn everything at once.

Sometimes progress looks like completing one small exercise.

Today, it is Git Config.

Tomorrow, it may be branching.

Then merging.

Then pull requests.

Then collaboration on real-world projects.

Eventually, these small steps become a complete skill set.

What Comes Next?

My Git journey does not end with configuration.

My next objectives are to become comfortable with:

Creating Git repositories
Making commits
Working with branches
Merging branches
Resolving merge conflicts
Connecting local repositories to GitHub
Creating and managing remote repositories
Using pull requests
Understanding .gitignore
Collaborating on real-world projects

I also want to apply Git to the other technologies I am currently learning, including HTML, CSS, JavaScript, Python, Excel, Web Development, Cloud and DevOps.

Final Thoughts

I am beginning to understand that becoming a developer is a journey of continuous learning.

Every exercise completed is another brick in the foundation.

The Git Config exercise may be a small achievement, but it represents progress.

I am documenting my journey because I believe that sharing the learning process can also help other beginners who are starting from the same point.

Start small. Learn consistently. Practise repeatedly. Build real projects.

This is only the beginning of my Git journey.

Next stop: becoming comfortable with Git and GitHub. 🚀

https://github.com/Rayg-Dev

Beginners Step into......Cloud and DevOps.....And key Takeaways

Ayanwole Ayangbade — Fri, 11 Sep 2026 17:29:23 +0000

Cloud based Services and their service model.

Infrastructure as a Service (IaaS) - Companies rent virtual servers, storage, and networking, And the owner or providers handle, manage and maintains physical site. And the customer/users handles, manage the OS, application and their own data base E.g - Google Compute Engine (GCE), DigitalOcean Droplets.

Platform as a Service (PaaS) - Unlike IaaS, The provider handles the servers, operating systems, and database management, it delivers a ready made Hardware and software platform for building applications E.g Red Hat OpenShift, Google App Engine.

Software as a Service (SaaS) - The provider manages everything—hardware, code, security, and updates it is a ready-to-use software application over a web browser or mobile app. E.g Netflix, Slack.

Learning DevOps is fun.....

Ayanwole Ayangbade — Sat, 05 Sep 2026 02:28:24 +0000

When the mind is willing under the right guidance and tutor