Monu Alam’s Post

I am glad to share a recent project I co-developed from scratch: j-kube-watch. It is a custom Kubernetes Operator designed to streamline cluster monitoring and eliminate alert fatigue. When monitoring Kubernetes environments, repetitive warnings like a CrashLoopBackOff or a failing probe can easily flood notification channels. To solve this, we built an operator that actively watches Pod lifecycle events and routes them intelligently. Key technical aspects of the project include: ● Built with Java 21 and the Fabric8 client, utilizing Virtual Threads for lightweight, concurrent event processing. ● An intelligent deduplication engine using Caffeine cache to suppress alert storms, sending grouped summaries instead of redundant notifications. ● Fully native configuration using Custom Resource Definitions (CRDs) for routing alerts to external channels like email. ● Packaged completely with Helm to handle deployments, RBAC rules, and network policies. This project was fully co-developed from start to finish in collaboration with Mostafa Mahmoud. You can find the full source code, architecture flow, and Helm charts on GitHub here: https://lnkd.in/dTsukBRK Feedback and code reviews are always welcome. #Kubernetes #DevOps #Java #CloudNative #PlatformEngineering #Helm #Automation #ITI

I am glad to share a recent project I co-developed from scratch: j-kube-watch. It is a custom Kubernetes Operator designed to streamline cluster monitoring and eliminate alert fatigue. When monitoring Kubernetes environments, repetitive warnings like a CrashLoopBackOff or a failing probe can easily flood notification channels. To solve this, we built an operator that actively watches Pod lifecycle events and routes them intelligently. Key technical aspects of the project include: ● Built with Java 21 and the Fabric8 client, utilizing Virtual Threads for lightweight, concurrent event processing. ● An intelligent deduplication engine using Caffeine cache to suppress alert storms, sending grouped summaries instead of redundant notifications. ● Fully native configuration using Custom Resource Definitions (CRDs) for routing alerts to external channels like email. ● Packaged completely with Helm to handle deployments, RBAC rules, and network policies. This project was fully co-developed from start to finish in collaboration with Adham Ayad. You can find the full source code, architecture flow, and Helm charts on GitHub here: https://lnkd.in/dYJzZPZ5 Feedback and code reviews are always welcome. #Kubernetes #DevOps #Java #CloudNative #PlatformEngineering #Helm #Automation #ITI

Spent 2 hours debugging a broken API. Turns out, I forgot to log the request body. I checked the response, traced the code, even asked a colleague. Nothing made sense. The server was throwing an error, but the logs didn’t show the actual payload. I added a log statement. The problem vanished. The request body was malformed. Log everything. Even the 'obvious' parts. A missing log line hides 80% of the problem. What’s the one thing you forgot to log that cost you time? #Debugging #DevOps #SoftwareEngineering

Topic: Avoiding “It Works on My Machine” If it only works on your machine, it doesn’t really work. One common issue in development: Code works locally… but fails in other environments. Reasons include: • Environment differences • Missing dependencies • Configuration mismatches • Data inconsistencies Solutions: • Use containerization (Docker) • Maintain consistent environments • Automate setup with scripts • Use CI pipelines for validation Consistency across environments is key to reliable deployments. Because software should work the same everywhere. How do you ensure consistency across environments? #DevOps #SoftwareEngineering #BackendDevelopment #Java #CICD

Things are getting more interesting on the next stage of my lab project - CI pipeline build workloads are migrated from the Jenkins controller to ephemeral pods running on k3s cluster. In the last update we added a SonarQube integration to our Jenkins CI pipeline for a small C++ service. This time we moved pipeline execution to dynamic agents running in Kubernetes (k3s): • Jenkins controller now orchestrates pipelines only • Build workloads run on ephemeral k3s pods • Custom Docker image prepared for C++ builds (cmake, gcc, python, etc.) • Agents are provisioned on demand per pipeline run • SonarQube integration works from within k8s agents • Full pipeline (build → test → quality → package) now runs outside the controller What this changes: Instead of relying on a single VM, the system can now scale builds dynamically and keep the CI controller lightweight and stateless — which is much closer to how modern CI/CD platforms operate. Also, a lot of “invisible” details showed up during this step: agent startup behavior, Jenkins ↔ Kubernetes connectivity, container entrypoints, authentication flows, and infrastructure reproducibility. Each rebuild made the setup more deterministic and better documented. Repository (current state): 👉 https://lnkd.in/ezKib47U Next step: extend this with multi-node execution and explore autoscaling patterns for Jenkins agents 🚀 #devops #jenkins #kubernetes #cplusplus #cicd

In the previous step I set up CI for the C++ service, the next stage — introducing a quality gate into the pipeline. The idea was to go beyond “build & test succeeded” and make code quality a part of the delivery flow. By now I’ve introduced: - SonarQube server provisioned on AWS (separate VM, Terraform-managed) - Integration between Jenkins and SonarQube - Static code analysis for the C++ project using real build context - Pipeline stages for:   - SonarQube analysis   - Quality Gate check (pipeline can fail based on it) - CMake configured to generate compile_commands.json for proper C++ analysis - Centralized quality reports with history in SonarQube The main focused was on: - treating quality checks as part of CI, not optional reporting - keeping the setup fully reproducible (infra + CI + analysis) - understanding C++-specific constraints (analysis requires build context) - making the pipeline decision-driven (quality gate can block further steps) The project became one step closer to a real-world CI pipeline — where not only build and tests matter, but also whether the code meets defined quality standards. Link to the repository: 👉 https://lnkd.in/d937Mztr Next step: moving from CI + quality gate to actual CD — deploying artifacts to Linux nodes and simulating remote updates 🚀 #devops #jenkins #sonarqube #cplusplus #terraform

In 2016, I mass-produced microservices like a factory. By 2017, I was debugging them at 2 AM on a Saturday. Here's what 14 years taught me about microservices the hard way: We had a monolith that "needed" to be broken up. So I split it into 23 microservices in 4 months. Result? - Deployment time went from 30 min to 3 hours - Debugging a single request meant checking 7 services - Team velocity dropped 40% - Every "simple" feature needed changes in 5+ repos The problem? I created a "distributed monolith." All the pain of microservices. None of the benefits. What I learned after fixing it: 1. Start with a well-structured monolith. Split only when you MUST. 2. Each service must own its data. Shared databases = shared pain. 3. If 2 services always deploy together, they should be 1 service. 4. Invest in observability BEFORE splitting. Tracing, logging, monitoring. 5. Domain boundaries matter more than tech stack choices. We consolidated 23 services down to 8. Deployment time dropped to 15 minutes. Team happiness went through the roof. The best architecture is the one your team can actually maintain. Have you ever over-engineered a system? What happened? #systemdesign #microservices #softwarearchitecture #java #programming

The diagram illustrates a common Maven pitfall: Snapshot artifacts are mutable, so the same 1.2.1-SNAPSHOT coordinate can resolve to different binaries over time depending on which commit was published last. That makes builds non-deterministic, weakens reproducibility, and complicates debugging because a downstream service may compile or test against one snapshot today and a different one tomorrow without any version change. For that reason, snapshots should be treated as short-lived development artifacts, while shared dependencies should be promoted to immutable release versions tied to a specific commit, build, and artifact lineage. This is especially important in CI/CD environments where traceability, repeatability, and supply-chain integrity matter. #Maven #Java #SoftwareEngineering #BuildSystems #DevOps #CICD #ReproducibleBuilds #SoftwareSupplyChain #ArtifactImmutability #SnapshotBestPractices #C2C #ContinuousDelivery #JavaDevelopment #BuildReliability

🐳 🐙 Docker Compose Tip #52: Setting up a CI test environment Your dev Compose file isn't your CI Compose file! ```bash docker compose -f compose.yml -f compose.ci.yml up \ --build --exit-code-from tests docker compose down --volumes ``` The CI override adds: • Database seeded with test fixtures via init scripts • Test runner service with depends_on healthchecks • No persistent volumes — fresh state every run • Frontend disabled via profiles when not needed Real example using dockersamples/sbx-quickstart! Full setup: https://lnkd.in/ebAQc85k #Docker #DockerCompose #CICD #Testing #DevOps

It's impressive when tools can recognize complexity and offer relevant solutions, like suggesting a GitLab CI runner setup. Imagine going from simply building an app to managing a full CI/CD pipeline, including deployment, dependencies like Python and Postgres, and even choosing a web server. This goes beyond basic development, touching on maintainability and automated processes. The next step involves integrating security testing (SAST/DAST) into the pipeline to proactively catch issues. Check out more insights at https://lnkd.in/gjXm7xzG #CI/CD #DevOps #SoftwareDevelopment #CloudComputing #Automation