Why shell scripting is essential for DevOps

Automating Deployments with Jenkins CI Today, I took a big step forward in my DevOps journey by setting up Jenkins for continuous integration and automated deployments. Here’s what I worked on 👇🏽 🔹 Set up a Jenkins server on an EC2 instance 🔹 Installed essential plugins (Git & Publish over SSH) 🔹 Connected Jenkins to GitHub for automatic builds via webhooks 🔹 Configured “Publish over SSH” to transfer files to the NFS server 🔹 Troubleshot the tricky “invalid privatekey” SSH error and fixed it by properly formatting my .pem file (lesson learned!) 🔹 Successfully triggered my first automated build from GitHub 💥 It was amazing to see everything come together; from installation to watching Jenkins automatically fetch and deploy updates from my repo. This hands-on project really helped me understand how Continuous Integration brings speed, consistency, and automation into real-world deployments. You can check out the project files and setup details on my GitHub here: 👉🏽 https://lnkd.in/dM8aCAmB Next up: expanding this into a full CI/CD pipeline that deploys straight to web servers 👩🏽💻 #DevOps #Jenkins #Automation #ContinuousIntegration #LearningInPublic #AWS #StegHub

CI/CD Pipeline with Jenkins and GitHub Webhooks I recently worked on setting up a complete CI/CD pipeline using Jenkins and GitHub Webhooks — automating the entire software delivery process from code commit to deployment! 🔹 Overview: This project demonstrates how Jenkins can automatically: Clone source code from GitHub Run tests and quality checks Build deployable artifacts Deploy the application to the target environment 🔹 Key Highlights: ✅ Continuous Integration through Jenkins pipelines ✅ Automated builds triggered by GitHub Webhooks ✅ Seamless testing and deployment process ✅ Faster feedback loop for developers https://lnkd.in/g3KGGsPK #Jenkins #CICD #DevOps #Automation #GitHub #Webhooks #SoftwareEngineering #ContinuousIntegration #ContinuousDelivery

I thought mastering coding and data science was enough — until I discovered the missing link holding everything together: DevOps. That realization changed the way I think about engineering reliability and automation. When I first started learning software development and data science, I was focused on writing better code, building smarter models, and analyzing data more efficiently. But something was missing. I realized I didn’t fully understand what happens after the code runs — how to keep systems healthy, automate tasks, or ensure reliability at scale. That’s when I discovered the missing link: DevOps. ⚙️ Now, I’m beginning my DevOps journey by learning bash scripting — the language behind system automation. 🖥️ Project 1: System Health Checker For my first script, I built a System Health Checker that automatically monitors: 🧠 CPU load 💾 Memory usage 📂 Disk space 🌐 Network status It logs everything into /var/log/system_health.log and even triggers alerts when thresholds are exceeded — the kind of proactive monitoring DevOps engineers rely on to prevent downtime and improve reliability. 🔗 Explore the script here: https://lnkd.in/djJ2rZut This project taught me that DevOps isn’t just about tools — it’s about thinking like an engineer who builds for reliability, scalability, and automation. More bash projects coming soon! 🚀 #DevOps #Bash #Linux #Automation #SystemMonitoring #SoftwareEngineering #DataScience

🔥 Day 79 of #100DaysOfDevOps Jenkins Deployment Job Today’s focus was on designing a fully automated deployment workflow using Jenkins integrated with a Git-based source control system. The goal: ensure that every code push triggers a clean, consistent, and reliable deployment without manual intervention. 🚀 What I accomplished today 🔹 Configured a web server environment for application hosting 🔹 Prepared the source code repository and validated connectivity 🔹 Set up Jenkins with required plugins, credentials, and node restrictions 🔹 Built a deployment job triggered automatically on new commits 🔹 Validated the deployment by confirming the updated application served correctly This exercise strengthened my understanding of continuous delivery and the importance of seamless integration between CI tools, version control, and application servers. 📘 Key Learnings & Best Practices 🔐 Secure Access Control - grant only the minimum permissions needed 🔁 Full Deployment Strategy - deploy the entire package for consistency 🧱 Node Isolation - execute builds on dedicated and controlled environments 🧩 Reliable Triggers - ensure deployments happen predictably on each commit 📊 Log-Based Verification - pipeline logs remain the most accurate success indicator 📎 Full write-up available in my 100DaysOfDevOps repository: https://lnkd.in/giKBTd6B 🏆 Final Thoughts 🔹Day 79 brings together CI, CD, Git workflows, node-based deployments, security best practices, and automated web server updates. 🔹This task reflects real-world DevOps responsibilities - especially in distributed environments with shared storage and multi-server deployments. #DevOps #Jenkins #CI_CD #Automation #100DaysOfDevOps #KodeKloud

Tired of complex templating tools for simple Kubernetes YAML changes? Sometimes you don't need a full-blown Helm chart or Kustomize overlay. You just need to substitute a couple of values—like an image tag or a namespace—before applying a manifest. Enter `envsubst`. It's a powerful command-line utility (part of gettext and available on most Linux distros and CI runners) that substitutes environment variables in shell format strings. It's the perfect tool for lightweight templating. Here's how it works: 1. Create a template YAML file with shell-style variables (e.g., `${IMAGE_TAG}`). 2. Export the variable in your shell. 3. Pipe the template through `envsubst` and directly into `kubectl`. For example, your `deployment.template.yaml` might have: `image: my-app:${IMAGE_TAG}` Then, in your CI/CD script, you can run this beautiful one-liner: `export IMAGE_TAG=v1.2.3 && envsubst < deployment.template.yaml | kubectl apply -f -` Why is this useful? - No Dependencies: You don't need to install extra tools for simple cases. - Simplicity: It keeps your CI/CD steps clean and easy to understand. - Readability: The templates are just YAML files with clear placeholders. While tools like Helm and Kustomize are essential for managing complex applications, for simple substitutions, `envsubst` is an elegant and efficient solution. It's a great reminder to use the right tool for the job. What are your favorite lightweight CI/CD tricks? #kubernetes #devops #cicd #automation #yaml #opensource #bash #cncf

As part of enhancing my DevOps and CI/CD automation skills, I’ve been exploring GitHub Actions — a powerful platform for automating build, test, and deployment workflows directly within GitHub. Through this hands-on learning project, I’ve gained a strong understanding of how GitHub Actions integrates seamlessly with modern DevOps pipelines. My repository documents practical examples and exercises covering: 🔹 Workflow and job orchestration 🔹 Trigger events (push, pull_request, workflow_dispatch) 🔹 Environment variables and secrets management 🔹 Passing outputs and data between jobs 🔹 Working with GitHub-hosted and self-hosted runners 🔹 Using environments for staging and production Each topic includes working YAML files and real-world scenarios that demonstrate how automation pipelines can be built efficiently and securely. 📂 Check out the repository: https://lnkd.in/ganGfzEP This project helped me gain a deeper, practical understanding of Continuous Integration and Continuous Delivery (CI/CD) using GitHub’s native automation capabilities. #GitHubActions #DevOps #CICD #Automation #GitHub #ContinuousIntegration #ContinuousDelivery #Learning

I built a tiny backend with two routes — /health and /data — no database, no frameworks. Then I pushed it through a complete DevOps pipeline: Docker → GitHub Actions → CI/CD → Kubernetes (no Helm). It looked simple on paper. It wasn’t. Here’s what I actually learned: 1. Docker: Multi-stage builds matter. Image bloat happens fast. latest tags break reproducibility, and running as root is just asking for pain. Small, clean images build trust in your environment. 2. CI/CD: GitHub Actions taught me how to fail fast. Caching dependencies, splitting jobs, and scanning images (Trivy/Cosign) made me see how fragile pipelines get without structure. Automation isn’t magic — it’s versioned logic. 3. Kubernetes: Writing manifests manually (Deployment, Service, Ingress) forced me to understand each layer. Getting probes, resource limits, and image pull secrets right took more time than the app itself. When the pod finally stabilized, it wasn’t luck — it was configuration discipline. 4. Observability & Hardening: Added liveness/readiness probes → instant feedback on bad rollouts. Used resource limits to prevent cluster hogging. Logged in JSON → easy to parse in Prometheus/Loki later. What looked like a “toy backend” ended up being a full beginner production simulation. If you’re experimenting with DevOps end-to-end — Docker to K8s without Helm — connect with me. Let’s trade notes on what’s breaking (and why). Github: https://lnkd.in/e3vjz7Cm

🚀 Day 77 of #100DaysOfDevOps - Jenkins Deploy Pipeline “Automation in DevOps isn’t just about speed - it’s about confidence, consistency, and control.” ⚙️ Today’s challenge was all about building a Jenkins Pipeline to deploy a static website to Nautilus App Servers - automating what used to be a manual, repetitive task. 🧩 Here’s what went into it: 🔹 Installed and configured the Jenkins Pipeline plugin 🔹 Prepared the Storage Server (installed Java, verified Git repo) 🔹 Added a Jenkins agent (slave node) with a labele 🔹 Connected the agent to the Jenkins controller via agent.jar & secret file 🔹 Created a Pipeline job with a single Deploy stage ✅ Outcome: A fully automated, reproducible deployment pipeline ensuring Nautilus App Servers always serve the latest version - without human touch. 💡 Key Learnings: ⚙️ Pipeline as Code: Groovy makes deployments version-controlled and repeatable. 🧠 Agent Connectivity: always ensure nodes are online before triggering builds. 📜 Console Validation: your logs tell the real story of success. 📘 Full Write-Up 📄 https://lnkd.in/gd_AyAAK 💬 Final Thoughts: 🔹Every build teaches us something new - not just about tools, but about trusting the process. 🔹Because in DevOps, a pipeline isn’t just automation - it’s the rhythm of continuous delivery. ❤️🔥 #DevOps #Jenkins #CICD #Automation #100DaysOfDevOps #LearningInPublic #Cloud #KodeKloud #ContinuousDelivery

🚢 End-to-End DevOps Delivery Using GitHub Actions & Argo CD I recently built a complete DevOps pipeline for a Go-based web application, demonstrating my ability to design, automate, and deploy applications using industry-standard tools and practices. 1️⃣ Containerization & Security 🔹Designed a multi-stage Dockerfile for efficient builds 🔹Used Distroless images to improve security and reduce attack surface 2️⃣ Kubernetes Deployment 🔹Deployed workload using Deployment, Service, and Ingress 🔹Implemented an Ingress Controller for routing and load balancing 3️⃣ CI Automation – GitHub Actions 🔹Built and tested the application on every push 🔹Automated Docker image creation and registry updates 🔹Pipeline automatically updated Helm chart image tags 4️⃣ CD Automation – Argo CD (GitOps) 🔹Implemented GitOps for continuous delivery 🔹Argo CD monitored Helm chart repo and auto-synced changes to Kubernetes 🔹Achieved consistent, version-controlled, and fully automated deployments This project demonstrates my hands-on experience in cloud-native deployments, CI/CD automation, containerization, Kubernetes operations, and GitOps workflows. repo -> https://lnkd.in/eTgavJWg

🚀 Day 78 of #100DaysOfDevOps Smarter Jenkins Deployments 💡 “A great DevOps engineer doesn’t just automate - they automate wisely.” Today’s challenge pushed me to make Jenkins a bit smarter! I built a conditional pipeline that automatically deploys different branches (master or feature) of a web application - depending on the parameter chosen at build time. 🔧 What I built: ✅ Created a Jenkins Pipeline job. ✅ Added a parameterized input (BRANCH) for flexible deployments ✅ Configured a Jenkins slave node, with its document root mounted across app servers ✅ Implemented a single Deploy stage that: • Validates branch input • Checks out and pulls the selected branch from repo • Updates instantly visible on all app servers ✅ Fixed the classic Git issue: “fatal: detected dubious ownership in repository” 🧠 What I learned: 💬 Git 2.35+ introduces safe-directory checks - critical for multi-user Jenkins setups. 🔐 Always run Jenkins agents as a non-root user (jenkins), and secure credentials using the Jenkins Credentials Store. ⚙️ Parameterized pipelines make deployments both reusable and controlled - no need for multiple jobs per branch. 🧩 Mounting shared document roots across app servers simplifies static deployments and eliminates manual sync. 🚦 Adding simple conditionals can prevent accidental production deployments - tiny guardrails, massive impact. 💭 Final Thoughts 🔹 This exercise reinforced how automation and governance must go hand-in-hand. 🔹 DevOps isn’t just about writing scripts - it’s about designing pipelines that are secure, maintainable, and predictable. 🔹 Small refinements, like parameter validation or least-privilege agents, compound into big reliability wins in CI/CD. 📘 Full Guide: https://lnkd.in/gCvbVxkn #100DaysOfDevOps #DevOps #Jenkins #CICD #Automation #Git #LearningInPublic #KodeKloud