Docker DevOps Fundamentals Update: Dockerfile, Node.js, PostgreSQL

🗓️ Day 28/100 — 100 Days of AWS & DevOps Challenge Today's task: a developer has in-progress work on a feature branch but one specific commit is ready and needs to go to master right now, without dragging the rest of the unfinished work along. This is exactly what git cherry-pick is for. # Find the commit hash on the feature branch $ git log feature --oneline # abc5678 Update info.txt ← this one # Switch to master and cherry-pick it $ git checkout master $ git cherry-pick abc5678 # Push $ git push origin master One commit. Surgically applied. Feature branch untouched. 1. Why not just merge the feature branch? - The feature branch has in-progress commits code that isn't tested, isn't ready, and would break things on master. git merge feature brings ALL of it over. Cherry-pick takes only what's ready. 2. When this pattern matters in production: - A critical bug fix lands on a development branch. You can't merge the whole branch, there are half-finished features alongside the fix. You cherry-pick the fix onto master and onto any active release branches. This is how security patches get backported across multiple versions in open source projects. Same concept, same tool. The command to find a commit by message when you don't have the hash handy: $ git log --all --oneline --grep="Update info.txt" Saves time when the branch has many commits and you're looking for one specific one. Full breakdown on GitHub 👇 https://lnkd.in/gVHV9qPc #DevOps #Git #VersionControl #CherryPick #GitOps #100DaysOfDevOps #KodeKloud #LearningInPublic #CloudEngineering #CICD #Hotfix

Beyond the Code: Architecting a Hybrid-Cloud DevSecOps Pipeline I’m thrilled to share that I have successfully deployed my latest project—a professional Python microservice—live on an AWS EC2 instance using a custom, hybrid CI/CD architecture! Most projects stop at "it works on my machine." I wanted to build something that reflects real-world enterprise standards. This project wasn't just about writing Python; it was about orchestrating a secure, automated path from the first line of code to a live production server. The Technical Core Application: A high-performance FastAPI microservice with a modern, responsive dashboard styled via Tailwind CSS. The CI Layer (GitHub): Automated unit testing and linting using GitHub Actions to ensure every Pull Request is production-ready. The "Enterprise" Layer (GitLab): I configured a Self-Hosted GitLab Runner on an AWS EC2 instance to handle deep security analysis and Docker builds. Security & Quality: Integrated SonarQube as a mandatory Quality Gate, ensuring zero vulnerabilities and high code coverage before deployment. The AWS Deployment The final stage of the pipeline uses automated SSH-based deployment to manage a containerized environment on AWS. By using Docker-in-Docker (DinD) and secure secret management, the application is seamlessly updated without manual intervention. Key Lessons Learned: Self-Hosted Infrastructure: Configuring my own GitLab Runner on EC2 provided deep insights into Linux administration, Docker executors, and cloud networking. DevSecOps Integration: Security isn't a final step; it’s a constant. SonarQube taught me how to catch technical debt before it becomes a problem. Hybrid Orchestration: Learning to bridge GitHub and GitLab showed me how to design flexible, tool-agnostic workflows. A huge thank you to the community for the guidance during this build! Check out the live code and the full architecture on GitHub:https://lnkd.in/eGYU99bq #DevOps #CloudEngineering #AWS #Python #FastAPI #GitLab #GitHubActions #SonarQube #Docker #SoftwareEngineering #TechNigeria #DevSecOps #CloudComputing2026 #PythonDevelopment #DevOpsProject

🗓️ Day 35/100 — 100 Days of AWS & DevOps Challenge Containerization chapter begins. Today: installing Docker CE and Docker Compose on the app server. Simple task on the surface — but worth explaining what's actually being installed, because it's not just one thing. Below are the commands to install Docker: $ sudo yum-config-manager --add-repo \  https://lnkd.in/gVPqThME $ sudo yum install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin $ sudo systemctl start docker $ sudo systemctl enable docker $ sudo docker run hello-world #Testing for verification The Docker stack has three layers: docker-ce is the daemon — the background process that manages everything. docker-ce-cli is the command-line client that talks to it. containerd.io is the actual container runtime that creates and manages containers at the OS level. When you run docker run nginx, the CLI talks to the daemon, which talks to containerd, which uses runc to create the container. Three components working together. docker-compose-plugin vs the old docker-compose: The modern Compose is a Docker CLI plugin — invoked as docker compose (no hyphen). The old docker-compose with a hyphen was a separate Python binary and is now deprecated. If you see pipelines or docs using docker-compose, they're using legacy tooling. The modern version is faster, actively maintained, and ships as part of Docker's plugin architecture. Full Docker architecture breakdown + Q&A on GitHub 👇 https://lnkd.in/gKhHi-K6 #DevOps #Docker #Containers #Linux #100DaysOfDevOps #KodeKloud #LearningInPublic #CloudEngineering #Kubernetes #Containerization #CICD

🚀 From Code to Production — A Real-World DevOps Story Ever wondered what actually happens after a developer pushes code? Here’s a simple story from my daily work 👇 👨💻 A developer pushes code to GitHub ⬇️ ⚙️ GitHub Actions kicks off automatically Maven builds the application Tests run (quality checks ✅) Docker image gets created ⬇️ 📦 The image is pushed to AWS ECR (our secure registry) ⬇️ ☸️ Deployment begins in EKS (Kubernetes) Kubernetes detects new image version Scheduler decides where to run pods EC2 worker nodes pull the image from ECR Kubelet starts containers ⬇️ 🔄 Rolling update happens New pods come up Old pods are gradually removed Zero downtime 🚀 ⬇️ 🌐 Traffic is shifted to new version seamlessly 💡 The beauty of this flow? No manual intervention Fully automated Scalable & resilient Production-ready deployments in minutes This is what modern backend + DevOps looks like — not just writing code, but owning the full lifecycle. #DevOps #Java #SpringBoot #Kubernetes #AWS #EKS #Docker #GitHubActions #Microservices

🚀 DevOps Hands-on Project Series Excited to share two practical projects I recently built to strengthen my hands-on understanding of application deployment, CI/CD, containerization, and Kubernetes. Project 1: Job Application Tracker Web App 🔹 Built using Python Flask and SQLite 🔹 Containerized using Docker 🔹 Implemented CI/CD using GitHub Actions 🔹 Pushed images to Docker Hub 🔹 Configured GitHub repository secrets for secure Docker Hub authentication Project 2: Server Health Monitoring Dashboard 🔹 Built a monitoring dashboard for CPU, memory, disk, uptime, and system health 🔹 Containerized using Docker 🔹 Automated Docker image build and push using GitHub Actions 🔹 Deployed on Kubernetes using Deployment and Service manifests 🔹 Implemented High Availability using multiple pod replicas Key Learnings ✅ CI/CD automation using GitHub Actions ✅ Secure secrets management ✅ Containerized deployments using Docker ✅ Kubernetes Deployment, Service and High Availability concepts ✅ Troubleshooting real workflow failures and improving hands-on DevOps skills Tech Stack Python | Flask | SQLite | Docker | GitHub | Docker Hub | GitHub Actions | Kubernetes | AWS EC2 | Linux 🔗 GitHub Repositories: https://lnkd.in/dhgaUXqc 🐳 Docker Hub Images: https://lnkd.in/di3E39n3 Always learning by building and improving through hands-on practice. Shubham Londhe 😎 #DevOps #Docker #Kubernetes #HighAvailability #GitHubActions #CICD #Python #AWS #Linux #Automation #CloudComputing

Writing a Dockerfile for the first time feels easy. Until you realize every line you write actually matters. 🐳 Looks simple. But there's a reason the order is the way it is. 👇 Docker builds images in layers and it caches each one. So if nothing changed in that layer, Docker skips rebuilding it. That's why I copy pom.xml and pull dependencies BEFORE copying the source code. → Dependencies change rarely → Source code changes constantly If I flipped the order, Docker would re-download all dependencies every single time I changed even one line of code. That's slow and wasteful. By separating them, only the layers that actually changed get rebuilt. ⚡ One small ordering decision = way faster builds. This is the kind of thing that seems obvious in hindsight but took me actually writing it to understand. What Docker tricks have you picked up? 👇 #Docker #DevOps #Microservices #SpringBoot #CSUN #LearningInPublic

GitOps changed how I think about deployments. Here's the mental model: Before GitOps: ❌ SSH into server → pull code → restart service → pray ❌ Jenkins pipeline pushes directly to cluster ❌ "Who deployed what?" — nobody knows After GitOps: ✅ Git is the single source of truth ✅ ArgoCD watches the repo and syncs automatically ✅ Every deployment is a Git commit — auditable, reversible ✅ Multi-cluster? Just point ArgoCD at different directories Key decisions I made: 1. Mono-repo for manifests (simpler than multi-repo for our scale) 2. ArgoCD for app deployments, FluxCD for infra components 3. Automated image tag updates via CI → Git commit → ArgoCD sync If you're starting with GitOps, start with ArgoCD + a single cluster. Don't over-engineer day one. Save this for later ♻️ #GitOps #ArgoCD #FluxCD #Kubernetes #DevOps #EKS #Kubernetes #AWS #CICD #PlatformEngineering #GitOps #Terraform #ArgoCD #CloudEngineering #SRE #DevSecOps #BackstageIO #InfrastructureAsCode #GitHub #Docker #DevOpsCommunity #TechCareers #LearningInPublic #BuildInPublic

🚀 DevOps Journey – Day 35 / 100 👉 Today I learned Dockerfile (How we build our own images) 🐳🔥 🔹 🧠 Real-Time Scenario 👉 Developer pushes code to GitHub 👉 As DevOps Engineer: ✔ Clone code ✔ Write Dockerfile ✔ Build image ✔ Run container 💡 This is how applications are containerized in real projects 🚀 🔹 🔁 Flow 👉 Code → Dockerfile → Image → Container ✔ Dockerfile → Instructions ✔ Image → Application package ✔ Container → Running app 🔹 📘 What is Dockerfile? 👉 Dockerfile is a script with instructions to build an image 💡 It defines how application should run 🔹 🧩 Dockerfile Components ✔ FROM → Base image 👉 Example: nginx / openjdk ✔ MAINTAINER (⚠️ deprecated) 👉 Use LABEL instead ✔ LABEL → Metadata ✔ WORKDIR → Working directory inside container ✔ COPY → Copy files from local to container ✔ ADD → Copy + supports URL & extraction ✔ RUN → Execute commands while building image ✔ ENV → Environment variables ✔ ARG → Build-time variables ✔ EXPOSE → Define port ✔ CMD → Default command when container starts 🔹 📜 Sample Dockerfile (Java App) FROM openjdk:11 WORKDIR /app COPY target/myapp.war /app/myapp.war EXPOSE 8080 CMD ["java", "-jar", "myapp.war"] 🔹 ⚙️ Build Image docker build -t myapp:v1 . 🔹 🚀 Run Container docker run -d -p 8080:8080 myapp:v1 👉 Access: http://:8080 🔹 🔄 Important Concept 👉 If Dockerfile changes: ✔ Need to rebuild image ✔ Old image won’t update automatically 💡 Image is immutable 🔥 🔥 🔹 Real-Time Understanding 👉 Dockerfile = Recipe 🍲 👉 Image = Prepared food 👉 Container = Serving plate 🎯 Pro Insight 👉 Dockerfile optimization (layers, caching) is very important in real projects 🔥 Now building our own containers 😎 #DevOps #Docker #Dockerfile #Containers #AWS #Linux #100DaysOfDevOps #MultiCloud #DevSecOps

Episode 10 of my journey to becoming a DevOps Engineer 🚀 In this episode, I’m diving into Docker and containerization. Before containerization, we relied heavily on virtual machines (VMs) to run multiple applications or services on a single server or PC. However, each VM requires its own operating system, which makes them heavy, slower to boot, and resource-intensive. To solve these challenges, containerization emerged. 1. In 2006, Cgroups were introduced 2. In 2008, LXC (Linux Containers) came along 3. In 2013, Docker was released — and it quickly became the most popular containerization platform Containers are lightweight because they share the host OS kernel. This means: 1. Faster startup times ⚡ 2. Better resource efficiency 💻 3. Reduced costs (time, infrastructure, and maintenance) 💰 🔧 Docker Runtime The runtime responsible for creating and managing containers is called containerd. The core server-side engine of Docker is known as dockerd (Docker daemon). 📦 Key Docker Components 1. Dockerfile – A script used to build Docker images 2. Image – A blueprint or snapshot of a container 3. Container – A running instance of an image 4. Volume – Persistent storage for containers 5. Network – Enables communication between containers Command for installing docker: sudo apt update sudo apt install docker.io sudo usermod -aG docker $USER sudo reboot For downloading an image: docker pull <image_name>:latest For running a container: docker run <image_name>:latest To execute something inside a running container docker exec -it <container_id> <what you want to execute> #AWS #Python #DevOps #Debugging #Learning #Programming #PDB #VSCode #CloudEngineering #CICD #Linux #GitHub #Git #bongoDev #Networking #InfrastructureAsCode #DevOpsJourney #CloudComputing #LearningInPublic

Excited to kick off my next major DevOps project: 𝐄𝐩𝐡𝐞𝐦𝐞𝐫𝐚𝐥 𝐏𝐑 𝐄𝐧𝐯𝐢𝐫𝐨𝐧𝐦𝐞𝐧𝐭𝐬! As I continue to dive deeper into Platform Engineering and infrastructure automation, I wanted to tackle a very real bottleneck: developers stepping on each other's toes when testing code on a single, shared staging server. The goal? Build a fully automated CI/CD pipeline that spins up a temporary, isolated environment every time a developer creates a Pull Request, and cleanly destroys it when the PR is closed. ♻️ Here is the architecture I’m building out: ✅ The App: A lightweight Python/FastAPI service, containerized with Docker. ✅ The Automation: GitHub Actions to trigger builds and deployments strictly on 𝒑𝒖𝒍𝒍_𝒓𝒆𝒒𝒖𝒆𝒔𝒕 events. ✅ The Infrastructure: AWS EKS (Elastic Kubernetes Service) to host the cluster. ✅ The Magic: Dynamically creating a brand new K8s Namespace named after the PR (e.g., 𝒏𝒂𝒎𝒆𝒔𝒑𝒂𝒄𝒆: 𝒑𝒓-42), deploying the app, exposing it via a Kubernetes Service, and writing a janitor workflow to tear it all down on 𝒑𝒖𝒍𝒍_𝒓𝒆𝒒𝒖𝒆𝒔𝒕_𝒄𝒍𝒐𝒔𝒆𝒅. This project is essentially a miniature version of Platform Engineering. It’s a fantastic way to master Git workflows, advanced CI/CD logic, and Kubernetes resource isolation in a highly practical, production-like scenario. I'll be sharing my learnings and code snippets as I build this out. If you've implemented something similar or have favorite tips for managing EKS and GitHub Actions, I’d love to hear them in the comments! 👇 #DevOps #Kubernetes #AWS #CICD #GitHubActions #PlatformEngineering #Docker #ContinuousIntegration