https://www.uchechimodesta.site/

CloudMira, Lagos (2026)

18/12/2025

❤❤❤❤

12/12/2025

🚀 Day 17 of my Cloud Computing & DevOps Rebranding Journey! (User & Group Management in Linux)

Managing users efficiently is more than running commands—it’s critical for real organizations. Imagine a company with 300+ staff across different teams. Assigning users to the right groups ensures permissions can be updated collectively instead of individually. This saves time and prevents mistakes, making group management a cornerstone of secure system administration.

💻 Local Practice:

I started on my WSL Ubuntu environment by creating groups like developers and testers. I added users, assigned them to groups, and verified memberships using id. I also practiced adding and removing users from groups. Each step reinforced how Linux organizes users and groups to keep systems structured and manageable.

☁️ Cloud Practice:

Next, I mirrored the exercises on a cloud-based Ubuntu instance. I explored how the SSH server (sshd) interacts with local SSH clients, like Git Bash on Windows or the macOS terminal, to enable secure remote connections. Enabling password authentication for non-root users allowed me to create a test user, assign it to a group, and log in remotely. This showed me how local commands translate directly to real cloud environments.

🔑 Key Takeaways:
☑️ Clear group structures make user management scalable, consistent, and secure.
☑️ Commands like groupadd and usermod are powerful tools for administering Linux systems.
☑️ Practicing locally before moving to the cloud bridges theory with real-world application.

The exercises made one thing clear: DevOps relies on clean, well-structured user and group management, especially when teams, automation, and cloud resources depend on consistent access controls.

11/12/2025

🚀 Day 16 of my Cloud Computing & DevOps Rebranding Journey! (User Management in Linux)

User management in Linux is more than creating and deleting accounts. It is the foundation of system security and a key skill every Linux administrator, DevOps engineer, or IT professional must master. Today I practiced scenarios that show how proper user control can prevent mistakes and protect systems.

I started with user creation using useradd and noticed that without -m, no home directory is created, which can break applications that expect user directories. Using useradd -m or adduser automatically creates /home directories and sets default permissions. I verified users by checking /etc/passwd and /etc/shadow and confirming home directories. This reinforced the importance of validating every change rather than assuming commands worked.

Next, I focused on security-critical practices. I enforced password policies with chage to require users to change passwords every 90 days. This prevents accounts from being exploited with stale credentials. I also practiced locking a user account when suspicious activity is detected, which immediately restricts access and protects critical system files. After confirming the account was locked, I unlocked it once it was safe and verified that access was restored. This demonstrates how controlled access protects systems while allowing recovery.

A practical lesson came when I switched to a normal user and tried deleting /sbin. Permissions denied me, proving that user privileges and restrictions are not just rules but important protections that prevent serious mistakes.

Mastering user creation, password enforcement, account locking, and unlocking ensures system integrity, enforces security policies, and prevents accidental or malicious damage. These are not basic tasks but the building blocks of secure and well-managed Linux systems.

゚viralfbreelsfypシ゚viral ゚

08/12/2025

✨ Day 15 of My Cloud Computing and DevOps Rebranding Journey

Today I continued deepening my understanding of one of the most important parts of Linux: the File System.

Knowing how Linux organizes system data is essential for DevOps work. It influences automation, troubleshooting, logging, deployments, monitoring, and system behavior. Instead of rushing through everything at once, I approached each directory with clarity and intention.

Here are some of the key directories I worked with today:

/boot

Contains the files the system needs to start up, including the kernel, initrd, and bootloader components.

/opt

Used for optional or third-party applications, keeping them separate from core system packages.

/mnt and /media

Temporary mount points for attaching external storage such as disks and USB devices.

/var

Holds logs, caches, spool files, and data that changes frequently. This directory is important for real-world debugging and monitoring.

/proc and /sys

Virtual filesystems that provide access to kernel and system information. They are not traditional folders, but interfaces that reveal how the system is functioning internally.

/dev

Contains device files that represent hardware components like disks, terminals, and USB devices.

/run

Stores runtime information for processes and services after boot.

/root

The home directory for the system’s superuser.

Throughout the session, I inspected the contents of each directory, observed their structure, and used practical commands to understand their role in system operations. Step by step, these fundamentals are strengthening my approach to engineering work.

Linux rewards anyone who studies it with patience and curiosity. This phase of my journey is helping me understand what truly happens beneath the surface.

More learning continues tomorrow.

29/11/2025

💫Day 14 of My Cloud Computing / DevOps Rebranding Journey (Understanding the Linux Filesystem Structure)

Understanding the Linux filesystem is a core skill for any DevOps engineer. The terminal prompt itself carries meaningful information about the current session:

cloudmira@DESKTOP-KRL2771:~$

This structure represents:

☑️ The active user (cloudmira)
☑️ The system hostname (DESKTOP-KRL2771)
☑️ The current working directory (~, which points to the user’s home directory)
☑️ The session type ($ indicates a standard user, while # indicates root)

Administrative tasks require elevated privileges, which are obtained by switching to the root user:

sudo su -
cd /

After this, the prompt changes to:

root@DESKTOP-KRL2771:/ #

☑️ root indicates full administrative privileges
☑️ / is the root of the Linux filesystem hierarchy
☑️ # shows that the system is operating in a root session

To inspect the top-level filesystem structure, the following command is used:

ls -lrt

This displays files and directories in long format, ordered by modification time.

Key directories at the root level include:

☑️ /bin – essential binaries required for basic operations
☑️ /sbin – system binaries used for administrative tasks
☑️ /lib – shared libraries used by binaries in /bin and /sbin
☑️ /usr – user-facing applications, libraries, and utilities
☑️ /home – directories where user data and configurations are stored

A solid understanding of these directories strengthens system navigation, troubleshooting, and deployment workflows. The filesystem tells the story of how Linux organizes its core components, and knowing where everything lives is foundational for effective DevOps work.

25/11/2025

✨ Day 13 of My Cloud Computing & DevOps Rebranding Journey (Linux Fundamentals)

Today I started a new chapter of my journey, shifting from version control into the core engine that powers DevOps: Linux.

I focused on understanding how the operating system actually works beneath the surface. Not theory for theory’s sake, but the fundamentals that make real engineering possible.

I explored how Linux:
✔ Identifies the hardware it runs on
✔ Manages CPU and memory
✔ Controls processes
✔ Loads device drivers
✔ Handles networking

Seeing this in action is a reminder that DevOps is not just automation and pipelines. It is understanding the foundation that every container, server, workload, and deployment stands on.

I used simple commands like uname, lscpu, free, ps, and ip a to observe the system live. Just watching the OS manage hardware, processes, and resources gave me a clearer view of what happens under every tool we use in the DevOps world.

This phase will be practical. I will build, test, break, fix, and share everything as I grow deeper into Linux.
To everyone following this journey, thank you. Your support makes the process even more meaningful.

゚viralfbreelsfypシ゚viral ゚

20/11/2025

✨ Wrapping Up My Git and GitHub Phase | DevOps Rebranding Journey

The past weeks have been focused, challenging, and rewarding. I have strengthened my Git and GitHub skills not as a beginner, but as someone refining the habits and precision that real DevOps work demands.

I tackled real projects with real challenges: cherry-picking, rebasing, resolving conflicts, managing branches, keeping commits clean, and debugging with bisect. Each task improved my workflow, discipline, and understanding of code history and collaboration.

Git is more than a tool. It is a system for organizing work, improving processes, and solving problems intentionally. It reveals patterns, highlights mistakes, and shapes the way engineers think.

Now it’s time for the next phase: Operating Systems, starting with Linux. This is where DevOps comes alive, permissions, processes, networking, scripting, automation, and debugging, all the skills that make an engineer effective in real environments.

This journey will be hands-on, practical, and public. Every build, break, fix, and lesson will be documented and shared.

Step by step, project by project, the foundation grows stronger. To everyone who has been following this journey so far, thank you for the support. The next chapter begins with focus, learning, and meaningful growth.

19/11/2025

🚀 Day 12 of my Cloud Computing & DevOps Rebranding Journey!

Understanding your project’s history is one of the most powerful skills a DevOps engineer can have. Git logs provide visibility into who changed what, when, and why—keeping your infrastructure and deployments reliable.

Mastering Git log commands allows you to:

☑️ Audit full commit history with git log
☑️ Quickly scan commits using git log --oneline
☑️ Visualize branches and merges with git log --graph --decorate --oneline --all
☑️ Track detailed code changes using git log -p
☑️ Filter by author or keyword with git log --author and git log --grep
☑️ Summarize file changes with git log --stat
☑️ Prepare formatted commit lists for release notes with git log --pretty=format
☑️ Compare commit points using git log ..

A clean Git workflow goes beyond just committing code. It brings clarity, accountability, and confidence to every deployment. Each commit is a clue in the story of your project, and knowing how to read it prevents mistakes before they reach production.

With every commit I review and every command I practice, I am strengthening my foundation in practical DevOps skills.

17/11/2025

🚀 Day 11 of my Cloud Computing & DevOps Rebranding Journey!

In every real-world DevOps project, not all files are meant to be tracked. Sensitive information, logs, caches, and temporary files can accidentally leak into your repositories if you are not careful.

This is where .gitignore comes in, a simple file with massive impact. It allows you to:

▪️Protect sensitive files like .env containing API keys or passwords.

▪️Keep your repository clean by ignoring logs, cache, or system-generated files.

▪️Focus on tracking only the code and configuration that matters.

A clean Git workflow is not just about committing code. It is about security, organization, and professionalism. Using commands like git check-ignore ensures your ignored files are actually safe from accidental commits.

Mastering .gitignore today reinforced a key DevOps principle: small habits in version control prevent big mistakes in production.

Step by step, day by day, I am building a strong foundation in secure DevOps practices.

15/11/2025

Feeling Grateful

14/11/2025

🚀 Day 10 of my Cloud Computing & DevOps Rebranding Journey!

Today I focused on mastering Git Diff, a powerful tool in version control that helps me see exactly what has changed in my code and configuration files. Understanding these changes is critical in DevOps because even small differences can affect deployments, break scripts, or introduce bugs.

git diff is especially useful for:

▪️Tracking unstaged changes before committing.

▪️Comparing staged changes to ensure only the intended updates go into the repository.

▪️Ignoring insignificant differences like whitespace to keep focus on real edits.

▪️Comparing specific commits or files, helping to review history or troubleshoot issues.

To put this into practice, I worked on a real-world project updating deployment configs and Terraform variables. I ran these commands:

▪️git diff – shows unstaged changes, letting me catch edits early.

▪️git diff --staged – reviews staged changes, ensuring only correct updates are committed.

▪️git diff -w – ignores whitespace differences, keeping diffs clean.

▪️git diff – compares specific commits to track changes over time.

▪️git diff --no-index – compares files outside Git, useful for external checks.

▪️git diff --word-diff – highlights word-level changes, great for small edits.

▪️git diff --stat – gives a summary of changes, showing a quick overview.

💡 Takeaway: Mastering git diff helps you track, review, and trust every line of code. In DevOps, precise control over changes is what keeps deployments smooth and infrastructure reliable.

CloudMira

18/12/2025

12/12/2025

11/12/2025

08/12/2025

29/11/2025

25/11/2025

20/11/2025

19/11/2025

17/11/2025

15/11/2025

14/11/2025

Address

Telephone

Website

Alerts

Shortcuts

Share