100DaysOfDevOps Day 7: Git Staging, Committing, and Branching

🚀 Day 6 of #100DaysOfDevOps Challenge Today I explored one of the most fundamental pillars of modern software development — Version Control Systems (VCS) and Git 🔥 📌 Here’s what I learned today: 🔹 What is Version Control System (VCS)? A system that tracks changes in code over time, enabling collaboration, history tracking, and easy rollback when needed. 🔹 Why is it important? ✔️ Maintains complete history of changes ✔️ Enables team collaboration ✔️ Supports branching & experimentation ✔️ Ensures code safety and integrity 🔹 What is Git & Why Git? Git is a distributed VCS known for its speed, flexibility, and powerful branching capabilities. It’s widely used in DevOps and CI/CD pipelines. 🔹 Git Stages Explained: 📂 Working Directory – Where you create/modify files 📌 Staging Area – Where changes are prepared (git add) 📦 Repository – Where changes are permanently stored (git commit) 🔹 Git Lifecycle: Modify ➝ Stage ➝ Commit ➝ Push ➝ Pull 🔹 Linux Commands to Install Git: sudo apt install git -y sudo yum install git -y sudo dnf install git -y 🔹 Git Logs: Tracking history using commands like: git log git log --oneline git log --graph 💡 Key Takeaway: Mastering Git is not optional — it’s a must-have skill for every DevOps Engineer to manage code efficiently and collaborate seamlessly. 📈 Every commit you make is a step closer to becoming a better engineer! 🔥 What’s next? Diving deeper into branching strategies and Git workflows! #DevOps #100DaysOfDevOps #Git #VersionControl #Linux #CloudComputing #SoftwareDevelopment #DevOpsJourney #LearningInPublic #TechGrowth #CI_CD #Automation #Programming #Developers #flm #Engineering #CareerGrowth #OpenSource #TechCommunity #BuildInPublic 🚀

While learning, I discovered that as a DevOps engineer, Git is not only where code lives. It is where: • Infrastructure configurations are stored • Terraform files are versioned • CI/CD pipelines are managed • Bash and PowerShell scripts are tracked • Teams collaborate without overwriting each other’s work The beauty of Git is that it gives you history. If something breaks, you can trace what changed. If you make a mistake, you can roll back. If multiple people are working together, everyone can contribute without chaos. Concepts that once sounded confusing are now starting to make sense: • git clone → bring a project from the remote repository to your local machine • git add . → prepare your changes • git commit -m "message" → save a snapshot of those changes • git push → send your changes to the remote repository • git pull → get the latest updates from others I now see Git as the memory of a project. Without it, DevOps would feel like trying to build a house with no blueprint and no record of what has changed. What Git command or concept took you the longest to understand? #Git #DevOps #CloudComputing #VersionControl #LearningInPublic #TechJourney #CI_CD

What happens after you push your code to Git? 🤔 Day 16 of my DevOps Journey Today I started learning Jenkins and understood the backbone of DevOps — CI/CD ⚙️🚀 Until now, I was just pushing code… But what happens after that? That’s where CI/CD comes in. CI/CD explained simply: Continuous Integration (CI) → Combination of build + test Whenever a developer commits code to Git: • Code is automatically fetched • Build process starts • Unit tests are executed This helps us quickly know whether new code works with existing code or breaks it Continuous Delivery vs Continuous Deployment: • Continuous Delivery → Code is ready for deployment (manual approval needed) • Continuous Deployment → Code is automatically deployed to production after build & test CI/CD Pipeline stages: Version Control • Code is pushed using tools like Git Build • Code is compiled and prepared for execution Unit Testing • Code is tested to validate functionality Deploy • Application is deployed to environments (Dev/Test/Prod) After deployment, we can see the actual output of the application Tools used for CI/CD pipelines: Jenkins, GitHub Actions, GitLab CI, Azure Pipelines, AWS Pipelines, Travis CI, CircleCI, Harness Day 16 realization💡 Writing code is just the beginning. The real power lies in what happens after the commit. CI/CD makes sure: ✔ Code is tested instantly ✔ Issues are caught early ✔ Deployment becomes fast and reliable Now imagine: The moment code is committed It automatically builds → tests → deploys That’s CI/CD. That’s automation replacing manual effort. This is where DevOps actually begins⚡ Next — I’ll go deeper into Jenkins pipelines🔥 See you on Day 17 with Jenkins Installation and Access🚀 #DevOps #Jenkins #CICD #Automation #LearningInPublic #100DaysOfDevOps #Day16 #Git #Linux

👨💻 50-day journey to revisit and strengthen my DevOps engineering skills 📌 Day 2/50 📌 ⚙️ Tools I’ll be working with: Git | GitHub Actions Today, I focused on how local Git operations turn into real CI/CD execution using GitHub Actions. In production environments, every pipeline execution is a result of developer actions performed locally, making it critical to understand the complete flow from code creation to deployment trigger. 🔄 Flow Overview: 💠 Developer writes code locally 💠 Commits and pushes using Git 💠 Code is pushed to GitHub 💠 GitHub Actions workflow is triggered 💠 CI/CD pipeline executes (build, test, deploy) ➡️ Flow attached below 👇 📌 Note: Key CI/CD stability considerations as covered in Day 1 are critical. ➡️ For a more detailed understanding of GitHub Workflows and Actions, I’ve referred to the official documentation—feel free to explore it for deeper insights  🔗 https://lnkd.in/gm77PY7y 🚨 Possible Issue Scenario: A CI pipeline was set to trigger on every push to the main branch. A developer pushed changes without syncing with the latest remote updates, causing merge conflicts and pipeline failure due to inconsistent code. 🛠️ Resolution: Pulled latest changes from the repository Resolved conflicts locally Pushed updated code Pipeline re-triggered and executed successfully 💡 Always sync before pushing. ➡️ The key takeaway is that CI/CD pipelines are only as reliable as the version control practices behind them. Proper use of git pull, disciplined commits, and clean synchronization between local and remote repositories ensures smooth pipeline execution and avoids unnecessary failures. #DevOps #git #cicd #Github #skills #GithubCommands #Branchingstrategy #GithubActions #GithubDocs #Reskill #Workflow #Syntax

🚀 DevOps Day 21 — Git Branching & DevOps Workflow (Part 3) After fixing networking issues, I moved into real Git workflows. This is where Git becomes powerful. SSH vs HTTPS Git Connections I explored both methods: SSH Method git@github.com:nixhal33/DevOps-Mastery.git Advantages: ✔ No repeated authentication ✔ Secure ✔ DevOps-friendly HTTPS Method (Token Based) git clone https://@github.com/repo.git Steps: • Create Classic Token • Clone repo • Push changes But SSH felt more DevOps-aligned. Git Commands I Practiced ✔ git status ✔ git diff ✔ git add ✔ git commit ✔ git push ✔ git restore ✔ git revert HEAD These commands helped me: • Track changes • Revert mistakes • Monitor code differences Git Branching (Most Important Learning) Production branch: main Development branch: git checkout -b dev Workflow: Create dev branch Make changes Push to dev Merge to main Merge Conflict Practice I intentionally: • Edited files in two branches • Created merge conflict • Resolved manually • Merged successfully This was real-world Git learning. Final DevOps Insight My instructor shared something interesting: DevOps Engineers don't use Git as heavily as developers… But Git is critical for: ✔ CI/CD pipelines ✔ Automation workflows ✔ Infrastructure versioning And now I'm ready for: 🚀 Next Topic: Docker From IaC → Version Control → Containers The DevOps journey continues.  you can checkout my github repo using this link: https://lnkd.in/gjw9Fuxe #DevOps #Git #GitHub #Automation #CI_CD #InfrastructureAsCode #DockerJourney #LearningInPublic

30 Days DevOps Revision Challenge – Day 2 Day 2 of my DevOps revision challenge — and today was all about going deeper into Jenkins and organizing everything I’ve learned so far. Yesterday was more about getting started and building a real pipeline. But today, I focused on strengthening almost all important Jenkins concepts in a more structured and practical way. 📌 Day 2 Focus: Advanced Jenkins Concepts Today I worked on multiple key areas to understand how Jenkins is actually used in real-world environments: 🔐 User-Based Authentication Explored how to manage users and roles Understood access control and security basics in Jenkins 📦 Shared Library (Deep Dive) Practiced creating and structuring shared libraries Improved reusability and organization of pipeline code 🔑 Credentials Management Learned how to securely store and use credentials Integrated credentials into pipelines safely 🔄 Build via SCM (GitHub Integration) Created jobs directly connected to GitHub repositories Automated build process using source code changes ⚡ Trigger Builds Without Opening Jenkins UI Configured builds to trigger directly from GitHub Used webhooks effectively for automation 🧑💻 Agent Setup Created and configured Jenkins agents Understood distributed builds and scalability 🔗 Webhook Optimization Used webhooks more efficiently Ensured proper trigger flow and debugging 💡 Key Takeaway Today felt like I connected all the scattered pieces of Jenkins into a complete system. From authentication → credentials → pipelines → agents → automation Everything now feels more organized and production-oriented. 🎯 Progress So Far Day 1: Pipeline + Django App + Shared Library basics Day 2: Advanced Jenkins concepts + full ecosystem understanding Slowly moving from just knowing tools → to actually understanding how everything fits together in production. I’ll continue sharing my journey daily. Consistency is the main goal 💯 If you’re also learning DevOps, let’s connect and grow together #DevOps #30DaysChallenge #Jenkins #CICD #Automation #Webhooks #LearningInPublic #Consistency #TechJourney

🚀 Day 15 – DevOps 100 Days Challenge 🚀 Today's learning dived deep into one of the most critical topics in DevOps — Git, GitHub, and Bitbucket — covering version control concepts, remote repository management, and the difference between these powerful platforms. 🌐🔧 📌 What I learned today: 🔹 Git vs GitHub vs Bitbucket  • Git — a distributed version control system (VCS) for tracking code changes locally  • GitHub — a cloud-based hosting platform for Git repositories with collaboration features  • Bitbucket — Atlassian's Git hosting platform, tightly integrated with Jira & Confluence 🔹 Source Code Management (SCM)  • Understanding SCM and why it's the backbone of every CI/CD pipeline 🔹 GitHub Actions & Webhooks  • Introduction to GitHub Actions for CI/CD automation  • How to configure webhooks to trigger Jenkins pipelines from GitHub Understanding these tools and commands is essential for every DevOps engineer working in collaborative, CI/CD-driven environments. 🔄🌿 Another great step forward — Day 16, let's go! 🚀💪 #DevOps #100DaysOfDevOps #Git #GitHub #Bitbucket #VersionControl #SCM #GitCommands #BranchingStrategy #MergeConflict #GitRebase #GitMerge #GitStash #CherryPick #GitHubActions #Jenkins #Webhooks #LearningJourney #ContinuousLearning

🌿 GitHub Flow vs GitFlow vs Trunk-Based Development After 10 years in DevOps, I've used all three in production. Here's the honest verdict — no fluff. Most teams pick a branching strategy by copying what a bigger company does. That's the wrong way to choose. The right strategy depends on your team size, release cadence, and risk tolerance. GitHub Flow works when: → You deploy continuously (multiple times a day) → Your team is small and moves fast → You trust your CI/CD pipeline completely → You don't need to support multiple live versions GitFlow works when: → You ship on a fixed release schedule (weekly, monthly) → You maintain multiple versions simultaneously → You have a QA stage before every release → Your team is large with clear role separation Trunk-Based Development works when: → You have a mature engineering culture → Feature flags are part of your workflow → You want the fastest possible feedback loop → You're serious about CI/CD at scale My honest take after a decade? Most teams start with GitFlow because it feels safe. They move to GitHub Flow as they mature. The best teams end up on Trunk-Based — but only when they've built the culture for it. There's no wrong answer. There's only the wrong answer for your team right now. Which one is your team using — and are you happy with it? 👇 #DevOps #SRE #GitHub #GitFlow #TrunkBasedDevelopment #CICD #SiteReliabilityEngineering #PlatformEngineering #CloudNative #SoftwareEngineering #EngineeringCulture #TechLeadership #Kubernetes #CloudOps #Automation #GitOps #BackendEngineering #Infrastructure #VersionControl #DevSecOps #ContinuousDelivery #Reliability #OpenSource #TechCommunity #Programming

🚀 From Zero to Version Control: My Journey into Git & GitHub  In my journey toward becoming a DevOps Engineer, one of the most fundamental (yet powerful) skills I’ve been focusing on is Version Control using Git and GitHub.  At first, it felt like just “commands" but soon I realized it’s the backbone of modern software development and DevOps workflows. --> What I’ve Learned So Far:   - Understanding Version Control – tracking changes, collaboration, and code history.   - Git Basics – initializing repositories, staging, committing changes.   - Branching & Merging – working on features without breaking main code.   - GitHub – remote repositories, pushing code, pull requests, collaboration.  --> Key Commands I Practiced Daily:   - git init # Start a repository   - git clone # Copy a remote repo   - git add / git commit # Track and save changes   - git push / git pull # Sync with remote repositories   - git branch / git checkout # Work with branches   - git merge # Combine code changes  --> Why This Matters for DevOps & Cloud:   Version control is not just about code - it’s about collaboration, automation, and CI/CD pipelines. Every deployment, every infrastructure change, and every release starts here.  Learning Git has helped me understand how teams manage code at scale and how DevOps ensures smooth integration and delivery.  This is just the beginning - next step: integrating Git workflows with CI/CD tools and cloud platforms.   #DevOps #Git #GitHub #VersionControl #CloudComputing #LearningJourney #CI_CD #TechSkills

🚀 Day 3 Small Steps, Big Learning! Today I focused on improving my workflow and understanding how professionals manage code and projects. 🔧 What I worked on today: Set up my development environment and ensured tools like Git and VS Code are working properly. Practiced important Git commands to track and manage code changes. Organized my project repository with a proper folder structure (scripts, configs, docs). Created a detailed Day 3 report documenting my work and debugging process. 💡 One thing I learned today: Using clear and meaningful commit messages makes it much easier to track changes and collaborate with others in a project. 🎯 My goal for this week: To strengthen my DevOps fundamentals and build better habits for writing clean code, documentation, and version control. Learning in public and enjoying the journey! 📈 #IndustryImmersion #DevOps #Git #LearningInPublic #TechLearning