SphereX’s Post

Day 2/100: DevOps Challenge - Deep Dive into Git Internals & Branching Today I went deeper into Git internals and advanced workflows as part of my DevOps learning journey with BongoDev courses. This session was all about understanding how Git really works behind the scenes-not just commands, but concepts. Here's what I practiced hands-on today: Git versions & commit history ✓ Viewed commit history using git log, --oneline, and --graph Understood how Git stores multiple versions of files Used git show to inspect changes in old commits HEAD, checkout & time travel ✔ Moved HEAD to previous commits using git checkout <commit-id> ✔ Learned about detached HEAD state and when it's useful Switched back safely to branches Reset & recovery Used git reset --hard to move branch pointers Recovered lost commits using git reflog Clearly understood the difference between reset vs revert Branching & switching ✓ Created branches using git branch and git switch -c Switched between master, dev, and feature branches ✓ Learned why Git doesn't allow deleting the currently checked-out branch Branch workflow & merge Added new files in a dev branch Committed changes separately Merged dev → master using fast-forward merge Verified merge history with commit graphs Safe undo with revert ✓ Used git revert HEAD to safely undo changes ✓ Learned why revert is preferred in shared repositories All Git commands I practiced today (hands-on): # Repository & status git status git log git log --oneline git log --all git log --oneline --all git log --graph git log --all --graph git show <commit-id> # Commit & amend git add. git commit -m "message" git commit --amend #HEAD movement & checkout git checkout <commit-id> git checkout master git switch master git switch dev # Reset & recovery git reset --hard <commit-id> git reflog # Branching git branch git branch dev git branch feature-login git switch -c feature git branch -d <branch-name> git branch -D <branch-name> # Branch workflow git switch dev git merge dev # Safe undo git revert HEAD Lesson learned: Git is not just about saving code. It's about controlling history, navigating timelines, managing branches, and safely fixing mistakes. Understanding HEAD movement, reflog, reset, revert, and merge strategies is essential for real-world DevOps and CI/CD workflows. This session gave me much more confidence in handling Git in production-like scenarios. On to the next challenge-one step closer every day If you're also learning Git or DevOps, let's connect and grow together!

BLOG 12 OF 19 · GIT Git & Version Control: The Skill Every Engineer Uses Every Single Day By Aditya Girish Padhye · ~5 min read Topic: Git & Version Control | Series: Cloud & DevOps Learning Journey I have never had a single day in engineering — learning, building projects, or working in a team — where I didn't use Git. It's the most universally used tool in software and infrastructure development. And yet, most engineers only know git add, git commit, git push. There's a much deeper set of capabilities that separates a git user from a git practitioner. “A well-maintained Git history is a living document of your team's decisions. A messy one is a liability that makes every future change more dangerous.” The Fundamentals Done Properly • Repository & Cloning: A Git repository tracks every change to every file over time. Cloning creates a local copy of the full history — not just the current state. • Staging & Committing: The staging area lets you precisely control what goes into each commit. Atomic, descriptive commits make history meaningful and bisecting bugs possible. • Remote Repositories: GitHub, GitLab, and AWS CodeCommit host remote repos. Push shares your work; pull/fetch syncs changes from the remote. Branching & Merging: Where Real Collaboration Happens Branches let multiple engineers work on different features simultaneously without interfering with each other. A good branching strategy is what makes team development manageable at scale. • Feature Branches: Create a branch per feature or bug fix. Keep main/master always deployable. Merge back when work is reviewed and complete. • Merge vs Rebase: Merging preserves the full branch history. Rebasing rewrites commits for a cleaner linear history. Both have valid use cases. • Merge Conflicts: Occur when two branches modify the same lines. Resolving them requires understanding what both changes intended. Advanced Git Operations • Stashing: Temporarily shelve uncommitted work to switch context, then restore it later. • Interactive Rebase: git rebase -i lets you squash, reorder, and edit commits — keeping history clean before merging. • Reverting & Resetting: git revert creates a new commit undoing a previous one (safe for shared branches). git reset moves the branch pointer (only for local commits). • Git Workflows: Gitflow for release-based projects, GitHub Flow for continuous deployment, trunk-based development for high-frequency CI/CD. Git in a DevOps Context In modern DevOps, every Git push is a potential deployment trigger. CI/CD pipelines watch specific branches — a push to main triggers tests and deployment automatically. Infrastructure code (Terraform, Ansible, CloudFormation) lives in Git alongside application code. The entire state of your system is defined and versioned in Git. #Git #VersionControl #DevOps #GitHub #GitFlow #CICD #CloudEngineer #SoftwareEngineering #LearningInPublic #FortuneCloud Aditya Girish Padhye · AWS Cloud & DevOps Engineer · Pune

If you aren't using Version Control, you aren't "coding"—you're just gambling with your files. 🎰❌ In 2026, Git and GitHub are the absolute non-negotiables of the tech industry. Whether you are a solo developer or part of a global DevOps team, these tools are the "Time Machine" and "Collaboration Hub" for your source code. The image below is a complete Git & GitHub Fundamentals Cheat Sheet. Here is the breakdown of the workflow that separates the pros from the amateurs: 1️⃣ The "Local" Power (Git): Git is the engine. It lives on your machine and tracks every single line change. 🔹 The Big Three: git add (stage it), git commit (wrap it), and git push (send it). 🔹 Branching: Never work on the main branch. Create a feature branch, experiment, and keep the production code safe. 2️⃣ The "Social" Layer (GitHub): GitHub is the cockpit. It’s where your code meets the world. 🔹 Pull Requests (PRs): This is where the magic happens. Code reviews, discussions, and automated tests (CI/CD) occur here before code is merged. 🔹 Issues & Projects: Managing your roadmap and tracking bugs in the same place where your code lives. 🔹 Actions: Automating your deployments directly from your repository. 3️⃣ The Pro Workflow (The Flow): Fork/Clone: Get the code. Branch: Create your space (git checkout -b feature-name). Commit: Save your progress with meaningful messages. Push: Upload to GitHub. PR: Open a Pull Request and get feedback. Merge: Bring it home to main. Essential Commands to Memorize: ✅ git status — Your best friend. Use it constantly to see what’s happening. ✅ git log — View the history of your project. ✅ git pull — Always grab the latest changes before you start working. Stop saving files as "final_v2_reallyfinal.js." Start using Git. 📌 SAVE THIS POST—this is the foundation of every single DevOps roadmap. What was the most confusing Git command when you first started? For me, it was git rebase. Let’s hear yours! 👇 7000+ Courses = https://lnkd.in/gTvb9Pcp 4000+ Courses = https://lnkd.in/g7fzgZYU Telegram = https://lnkd.in/gvAp5jhQ more - https://lnkd.in/ghpm4xXY Google AI Essentials → https://lnkd.in/gby_5vns AI For Everyone → https://lnkd.in/grgJGawB Google Data Analytics → https://lnkd.in/grBjis42 Google Project Management: → https://lnkd.in/g2JEEkcS Google Cybersecurity → https://lnkd.in/gdQT4hgA Google Digital Marketing & E-commerce → https://lnkd.in/garW8bFk Google UX Design → https://lnkd.in/gnP-FK44 Microsoft Power BI Data Analyst → https://lnkd.in/gCaHF8kT Machine Learning → https://lnkd.in/gFad6pNE Foundations: Data, Data, Everywhere → https://lnkd.in/gw4BwhJ2 IBM Data Analyst → https://lnkd.in/g3PsGrKy IBM Data Science → https://lnkd.in/gHYZ3WKn Deep Learning → https://lnkd.in/gaa5strv Writing in the Sciences → https://lnkd.in/gHewehvu #Git #GitHub #VersionControl #WebDevelopment #DevOps #OpenSource #CodingLife #TechBasics2026

🛠️ I built a tool that I wish existed when I was learning Git the hard way. The Problem: Most Git tutorials teach you git add, git commit, git push — and stop there. But in real production environments, that's where the easy part ends. I've seen engineers freeze when they accidentally commit AWS credentials to main. I've seen teams spend hours untangling a botched rebase on a release branch. I've seen 2AM hotfixes go wrong because no one had actually practiced that workflow before the incident happened. Reading about git reflog or git cherry-pick is not the same as doing it under pressure. And there was no tool that let you practice the hard stuff in a safe, realistic environment — without setting up a repo, a server, or anything at all. The Solution: I built GitPath — a fully browser-based, interactive Git learning platform designed around real production scenarios. It's built around the situations that actually matter on the job: 🔥 2AM hotfix on a live production system  🔐 AWS credentials accidentally pushed to main — revert, rotate, document  🚢 Full GitFlow release cycle from feature branch to tagged deployment  🧲 Recovering lost commits using git reflog  ⚔️ Resolving a merge conflict between two engineers on the same file Beyond scenarios, it covers 7 structured learning tracks and 28 guided lessons — from absolute basics all the way to Conventional Commits, Monorepo Git strategy, and Branch Protection rules used in enterprise CI/CD pipelines. Every lesson has a real-world story behind it, not just dry command documentation. How Easy Is It to Use: This is the part I'm most proud of. There is nothing to install. No npm. No server. No account. No configuration. You open one HTML file in your browser and you're inside a live Git terminal with a visual branch graph that updates in real time as you type commands. Your progress, XP, and streak are saved automatically in your browser. You can pick it up, put it down, and come back exactly where you left off. If you get stuck, there's a built-in hint system. If you want to explore freely, there's an open sandbox playground with no objectives at all. One file. Any browser. Zero friction. Built this as part of my DevOps portfolio — and it reflects the git workflows I rely on every day working on production AWS environments. 🔗 Try it in 10 seconds — no signup needed: https://lnkd.in/gVWKzBKd 🐙 GitHub: https://lnkd.in/gSD3SY_w If you're a DevOps, Platform, or SRE engineer — I'd genuinely love to hear what scenarios you'd add. Drop a comment or connect. #DevOps #Git #AWS #OpenSource #LearningInPublic #DevSecOps #SRE #PlatformEngineering #CloudEngineering #GitFlow

🚀 Master Git Like a Pro — Save This Cheat Sheet! If you're in DevOps, SRE, or Software Engineering… 👉 Git is your daily weapon. But remembering commands = 😵💫 So here’s a quick breakdown you’ll actually use: 🔹 Basic Commands • git init → Start a new repository • git clone <url> → Copy repo locally • git status → Check changes • git add . → Stage all changes • git commit -m "msg" → Save changes 🌿 Branching • git branch → List branches • git checkout -b feature → Create + switch branch • git merge feature → Merge into main • git branch -d feature → Delete branch 🌍 Remote • git pull → Fetch + merge latest changes • git push → Upload your commits • git remote -v → Show remote repos ⏪ Undo Changes • git checkout -- file → Discard changes • git reset HEAD file → Unstage file • git revert <commit> → Undo commit safely • git reset --hard → Reset everything (⚠️ careful!) 📜 Logs & Debugging • git log → Full history • git log --oneline → Compact view • git diff → See changes • git blame file → Who changed what 📦 Stashing • git stash → Save work temporarily • git stash pop → Restore work • git stash list → View stashes 💡 Pro Tips ✔️ Commit small, commit often ✔️ Use meaningful commit messages ✔️ Always pull before push ✔️ Use branches — never work directly on main 🔥 If this helps you: ✔️ Save it (you’ll need it later) ✔️ Follow for more DevOps/SRE content #Git #DevOps #SRE #SoftwareEngineering #Coding #GitCommands #VersionControl #LearnGit #ProgrammingTips #DevOpsEngineer #Cloud #Kubernetes #Terraform #CareerGrowth #TechCommunity #100DaysOfCode

🔧 Lab Title: 17 - Dynamically Increment Application version in Jenkins Pipeline - Part 2 🚀 Project Steps PDF Your Easy-to-Follow Guide:https://lnkd.in/gkMhj7Ty 🔗 GitLab Repo Code:https://lnkd.in/gC_svtgv 🔗 DevsecOps Portfolio:https://lnkd.in/g6AP-FNQ 💼 DevOps Portfolio: https://lnkd.in/gT-YQE5U 🔗 Kubernetes Portfolio:https://lnkd.in/gUqZrdYh 🔗 GitLab CI/CD Portfolio:https://lnkd.in/g2jhKsts Summary:  Today, I enhanced the CI/CD pipeline by automating version control with Maven, Jenkins, Docker, and GitLab. The pipeline dynamically bumps app versions, builds and packages the Java app, creates Docker images, pushes them to Docker Hub, and commits updated versions back to GitLab—all in one seamless flow. This ensures every build is uniquely versioned and deployment-ready. 🔄📦🐳 Tools Used: Maven: Parsed & incremented app version using build-helper & versions plugins 🔢 Jenkins: Orchestrated multi-stage CI/CD pipeline 🚦 Docker: Built & pushed container images with dynamic tags 🐳 GitLab: Managed source control with secure commit & push 🔐 Jenkins Ignore Committer Plugin: Prevented redundant builds from automated commits ⚙️ Skills Gained: CI/CD orchestration with Jenkins pipelines 🛠 Secure credential handling for Docker & GitLab integrations 🔐 Automated version bumping and source control updates 🔁 Optimizing pipeline efficiency with ignored committers & .gitignore 📂 Challenges Faced: Configuring Jenkins credentials for GitLab push & Docker login 🔒 Preventing Jenkins-triggered commits from re-triggering builds using Ignore Committer Strategy 🔄 Why It Matters:  This lab demonstrates full automation of the DevOps lifecycle—code changes, versioning, building, containerizing, and deploying—all without manual intervention. These practices are essential for scalable, efficient, and error-free software delivery pipelines. 🌐⚡ 📌 hashtag#DevOps hashtag#Jenkins hashtag#CI_CD hashtag#Maven hashtag#Docker hashtag#GitLab hashtag#Automation hashtag#Versioning hashtag#TechLearning hashtag#DevOpsJourney 🚀 Stay tuned!  The next course 9 - AWS Services is coming soon. 🔥

🌐 DevOps Interview Series — Part 5: 🔧 Git & Version Control Real questions from top tech companies. Save this. Share with a teammate. Follow for Part 6 👇 ❓ Q38: Essential Git Commands • Init/Clone: `git init`, `git clone <url>` • Stage/Commit: `git add .`, `git commit -m "msg"` • Sync: `git push origin main`, `git pull origin main` • Branching: `git branch`, `git checkout -b feature`, `git merge feature`, `git branch -d feature` ❓ Q39: What is the Staging Area? • Definition: The intermediate zone between your working directory and the repository history. • Purpose: Allows you to curate exactly what goes into a commit (atomic commits). • Workflow: `git add` (stage) → `git commit` (save) → `git reset` (unstage). ❓ Q40: Git Flow vs. GitHub Flow 🔹 Git Flow • Complexity: High • Branches: main, develop, feature, release, hotfix • Releases: Via specific `release` branches • Best For: Large teams, scheduled/boxed releases 🔹 GitHub Flow • Complexity: Low/Simple • Branches: main + feature branches • Releases: Directly from `main` (via PRs) • Best For: Agile teams, CI/CD, continuous deployment ❓ Q41: Merge vs. Rebase 🔹 Merge • Action: Creates a merge commit • History: Preserves exact timeline (non-linear) • Safety: Safe for shared/public branches • Command: `git checkout main && git merge feature` 🔹 Rebase • Action: Rewrites history • History: Clean, linear log • Safety: ⚠️ Dangerous for shared branches (don’t do it!) • Command: `git checkout feature && git rebase main` ✅ Rule: Rebase locally to clean up before merging. Never rebase public branches. ❓ Q42: Git Hooks Automation Automate quality checks before code leaves your machine. 📁 `.git/hooks/pre-commit`: ```bash #!/bin/sh eslint src/ if [ $? -ne 0 ]; then  echo "Linting failed. Fix errors."  exit 1 fi ``` 📁 `.git/hooks/pre-push`: ```bash #!/bin/sh npm test # Abort push if tests fail ``` ❓ Q43: Case: How to Undo a Bad Commit in Production? 1️⃣ Not pushed yet? `git reset --hard HEAD~1` (Dangerous: destroys local changes) 2️⃣ Already pushed/shared? `git revert <commit-hash>` ✅ Creates a *new* commit that inverses the changes. Safe for history. 3️⃣ Emergency Reset (Last Resort): `git reset --hard <good-commit>` + `git push --force-with-lease` ⚠️ Only if you know no one else pulled the bad state. ❓ Q44: Branching Strategies for CI/CD • Trunk-Based Development: Everyone merges to `main` frequently. Requires strong automated testing. • Feature Flags: Merge incomplete code but hide it behind flags. Decouples deployment from release. • Release Branches: Freeze code for QA while `main` continues development. • Environment Promotion: Code flows: Dev → Staging → Prod via pipeline, not just branches. 🔔 Follow. You don’t want to miss it. 💬 Merge or Rebase? Team Lead or Solo Dev? Tell me your preference in the comments! #DevOps #Git #VersionControl #CI/CD #SoftwareEngineering #TechInterviews #GitHub #Agile #CareerGrowth #CodingBestPractices

🚀 End-to-End DevOps Implementation on a Golang Web Application: Part-2 Step-by-Step (Hands-on Execution) 🟢 Step 1: Create Repo & Code git init git add . git commit -m "Initial commit" git branch -M main git remote add origin <repo-url> git push -u origin main 🟢 Step 2: Docker Build & Push docker build -t <dockerhub>/go-app . docker push <dockerhub>/go-app 🟢 Step 3: Create Kubernetes Cluster Choose one: Local → minikube start Cloud: Google Kubernetes Engine Amazon EKS 🟢 Step 4: Deploy App kubectl apply -f k8s/ kubectl get pods 🟢 Step 5: Setup CI with GitHub Actions Push code → pipeline runs automatically Check in: 👉 GitHub → Actions tab 🟢 Step 6: Install Argo CD kubectl create namespace argocd kubectl apply -n argocd -f https://lnkd.in/gSkmYnCE Expose UI: kubectl port-forward svc/argocd-server -n argocd 8080:443 Use: Argo CD 🟢 Step 7: Connect Git Repo to Argo CD kubectl apply -f argocd/application.yaml Now: ✔ Auto deployment happens 🟢 Step 8: Helm Deployment (Production Way) helm install go-app ./helm/go-app -f values-dev.yaml Switch env: helm upgrade go-app ./helm/go-app -f values-prod.yaml 🟢 Step 9: Setup Ingress Install: NGINX Ingress Controller kubectl apply -f k8s/ingress.yaml 🟢 Step 10: DNS Mapping Buy domain from: GoDaddy Map: A record → LoadBalancer IP Interview Explanation : 💬 “Explain your DevOps project” We implemented an end-to-end DevOps pipeline for a Golang web application. First, we containerized the application using a multi-stage Docker build to reduce image size and improve efficiency. Then we created Kubernetes manifests for deployment and exposed the application using an Ingress controller. For CI, we used GitHub Actions to automate build, test, and Docker image push to Docker Hub. For CD, we implemented GitOps using Argo CD, which automatically syncs the Kubernetes cluster with the Git repository. we also used Helm charts to manage deployments across multiple environments like dev and production. Finally, we configured DNS mapping to expose the application via a custom domain. This setup ensures automated, scalable, and production-ready deployments with minimal manual intervention. 💡 Key Learnings: • Importance of automation in modern DevOps • How GitOps simplifies deployment workflows • Managing multi-environment deployments using Helm • Real-world Kubernetes deployment strategies Would love to hear your feedback and suggestions 🙌

Jenkins isn’t just a CI tool… it’s your team’s silent productivity engine. While developers sleep 😴 Jenkins is still working… building, testing, validating ⸻ 💡 The real problem Jenkins solves: Before CI/CD… ❌ Developers work in isolation ❌ Big code merges = big bugs ❌ Manual testing slows everything down As explained in the guide, fragmented workflows and manual testing create inefficiencies that slow down production and increase debugging time ⸻ 🔥 Enter Jenkins — the automation powerhouse Think of it like a tireless factory robot 🤖 👉 Every code commit triggers: • Build • Test • Validation No excuses. No delays. ⸻ 🧠 What makes Jenkins powerful? 🔹 Open-source CI/CD server 🔹 Works with any language & platform 🔹 Plugin ecosystem (GitHub, Docker, Slack, etc.) 🔹 Automates build → test → deploy pipeline 📖 According to the guide, Jenkins uses a plugin-based architecture and is one of the most widely adopted automation servers ⸻ ⚡ CI vs CD (simple breakdown): 🔹 CI → Code is built + tested automatically 🔹 CD → Code is delivered/deployed automatically 📊 The diagram on page 7 shows how CI validates code, while CD pushes it toward production environments for testing and deployment ⸻ 🚀 Why teams swear by Jenkins: ✅ Faster development cycles ✅ Early bug detection ✅ Automated testing ✅ Reliable deployments ✅ Consistent builds 💰 Fun fact: CI/CD can save hundreds of hours per developer annually by reducing manual effort ⸻ ⚠️ Reality check (most ignore this): Jenkins is not “set and forget” It needs: 🔧 Maintenance 🔧 Proper configuration 🔧 Testing discipline As mentioned in the guide, CI systems require ongoing updates and can break if not maintained properly ⸻ 💬 Final thought: Don’t just write code… Automate trust in your code Because in modern DevOps: 👉 If it’s not automated… it’s a risk ⸻ #Jenkins #DevOps #CICD #Automation #SoftwareEngineering #CloudComputing #Docker #Kubernetes #AWS #Azure #GCP #Git #GitHub #GitLab #CI #CD #ContinuousIntegration #ContinuousDelivery #ContinuousDeployment #SRE #SiteReliabilityEngineering #InfrastructureAsCode #IaC #CloudNative #Microservices #BackendDevelopment #FrontendDevelopment #FullStack #Programming #Developers #Tech #Coding #100DaysOfCode #BuildInPublic #Engineering #TechCommunity #Learning #CareerGrowth #OpenSource #AutomationTesting #SoftwareDevelopment #SystemDesign #Scalability #Performance #Cloud #TechTrends

Question 51: Explain Jenkins pipeline stages? Answer: A Jenkins pipeline is a scripted CI/CD workflow that defines how your code moves from commit → build → test → deploy. Think of it as a production line where each stage has a clear responsibility. Here’s the breakdown your audience will instantly understand. 🔹 1. Checkout / Source Stage Pulls the latest code from GitHub/GitLab/Bitbucket. stage('Checkout') {    checkout scm } Purpose: Ensures Jenkins always works with the latest commit Triggers the pipeline on every push/PR 🔹 2. Build Stage Compiles the code or packages the application. stage('Build') {    sh 'mvn clean install' } Purpose: Converts source code → executable artifact Validates that the code compiles 🔹 3. Test Stage Runs unit tests, API tests, UI tests, or automation suites. stage('Test') { sh 'mvn test' } Purpose: Ensures code quality Prevents broken builds from moving forward 🔹 4. Code Quality / Static Analysis Stage Tools like SonarQube, Checkstyle, PMD. stage('Code Quality') { sh 'sonar-scanner' } Purpose: Detects vulnerabilities Enforces coding standards 🔹 5. Package / Artifact Stage Creates deployable artifacts (JAR, WAR, Docker image). stage('Package') { sh 'docker build -t app:latest .' } Purpose:  Prepares the final build for deployment 🔹 6. Deploy to QA / Staging Deploys to a test environment. stage('Deploy to QA') { sh './deploy.sh qa' } Purpose: Enables functional, regression, and integration testing 🔹 7. Approval / Manual Gate (Optional) Human approval before production deployment. stage('Approval') { input 'Deploy to Production?' } Purpose: Adds governance and safety 🔹 8. Deploy to Production Final deployment to live environment. stage('Deploy to Prod') { sh './deploy.sh prod' } Purpose: Makes the new version available to end users 🔥 Quick Summary Checkout → Get latest code Build → Compile Test → Validate Code Quality → Analyze Package → Create artifact Deploy QA → Test environment Approval → Manual gate Deploy Prod → Release   👉 Final Thoughts A Jenkins pipeline is not just automation — it’s discipline. Each stage ensures that only stable, tested, high‑quality code reaches production. 💬 Which stage do you think is the most critical for preventing production issues — Testing, Code Quality, or Approval Gates?