<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Damian Ogedengbe on Medium]]></title>
        <description><![CDATA[Stories by Damian Ogedengbe on Medium]]></description>
        <link>https://medium.com/@tundedamian?source=rss-a3735303df9b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9XL9bqiwgFczpl8j_JRQ_w@2x.jpeg</url>
            <title>Stories by Damian Ogedengbe on Medium</title>
            <link>https://medium.com/@tundedamian?source=rss-a3735303df9b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:54:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tundedamian/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[I Stopped Grepping Logs at 3 A.M.]]></title>
            <link>https://tundedamian.medium.com/i-stopped-grepping-logs-at-3-a-m-81f398d2512f?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/81f398d2512f</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 18:04:06 GMT</pubDate>
            <atom:updated>2026-08-20T18:04:06.190Z</atom:updated>
            <content:encoded><![CDATA[<h3>I Stopped Grepping Logs at 3 A.M. — Here’s How Claude Code + MCP Turned SigNoz Into an SRE That Never Sleeps</h3><h4>From manually chasing trace IDs to prompting your way through root cause analysis, dashboards, alerts, and postmortems</h4><p>Three years ago, a 3 a.m. page looked like this: squint at a Slack alert, tab into SigNoz, copy a trace ID, paste it into a search box, tab into logs, grep for the same request ID, tab into a metrics panel, eyeball a graph, guess, repeat. By the time I had a root cause, I’d opened eleven browser tabs and lost forty-five minutes I was never getting back. The postmortem got written two days later, from memory, missing half the nuance that actually mattered.</p><p>If that paragraph gave you a small physical reaction, you already know why this article exists.</p><p>Observability tooling has spent a decade getting really good at <em>collecting</em> signals — traces, logs, metrics, all beautifully indexed. What it never solved was the <em>investigation</em> step. A human still had to hold the whole incident in their head: correlate three data sources, remember which dashboard shows what, know which query filters actually matter, and translate all of that into prose a stakeholder could read without a computer science degree.</p><p>That step just changed. Not with a smarter dashboard — with an agent that can actually go <em>look</em>.</p><h3>The manual era, honestly assessed</h3><p>Before we talk about what’s new, it’s worth being precise about what was actually broken:</p><ul><li><strong>Trace-ID spelunking.</strong> Root cause analysis meant manually walking a request across services, one trace at a time, hoping you picked the representative one and not an outlier.</li><li><strong>Dashboard-as-YAML-archaeology.</strong> Every new panel meant hand-writing a query, picking the right aggregation window, and often copy-pasting a JSON block from a dashboard that “sort of” did what you needed.</li><li><strong>Alert sprawl.</strong> Rules accumulated over years, half of them tuned to thresholds nobody remembers the reasoning for, most either too noisy to trust or too quiet to matter.</li><li><strong>Incident response by tribal memory.</strong> The fastest responder wasn’t the best engineer — it was whoever had debugged this exact service before and remembered where the bodies were buried.</li><li><strong>Postmortems as homework.</strong> Written under deadline pressure, after the adrenaline wore off, reconstructing a timeline from memory and scattered Slack screenshots.</li></ul><p>None of this was a tooling gap. SigNoz, like most modern observability platforms, already exposes traces, logs, and metrics through a clean query API. The gap was that a <em>human</em> was the only thing capable of reasoning across all three at once — and humans are slow, inconsistent, and need sleep.</p><h3>Enter MCP: giving Claude actual hands</h3><p>The Model Context Protocol (MCP) is the piece that changes the equation. Think of it as a standard socket that lets an LLM call real tools against real systems, instead of just talking about them. Instead of me pasting log excerpts into a chat window and asking Claude to guess, an MCP server exposes SigNoz’s actual query builder, trace explorer, and alerting API as callable tools. Claude doesn’t imagine what the data might say — it queries it, gets structured JSON back, and reasons over that.</p><p>Claude Code is where this becomes a workflow instead of a party trick. It’s an agentic environment that can plan a multi-step investigation, call several MCP tools in sequence, look at what came back, decide it needs one more data point, fetch that too, and only then synthesize an answer — all from a single prompt you typed from your phone on the way to actually looking at your laptop.</p><p>Here’s the shape of the stack:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jU7VAqIB8slGy0WNjWMcOA.png" /></figure><p>Every microservice ships OpenTelemetry data into SigNoz. SigNoz’s MCP server exposes that data as callable tools. Claude Code is the reasoning layer that decides <em>which</em> tools to call and <em>in what order</em>, based on your prompt. You get a prompt in, an evidence-backed answer out.</p><h3>Case study: running this against a real AKS fleet</h3><p>I run this pattern against a distribution and logistics platform built as a set of microservices on Azure Kubernetes Service, fully instrumented with OpenTelemetry into SigNoz. Here’s what each piece of the “manual toil” list above looks like once Claude Code and SigNoz’s MCP server are doing the legwork.</p><h3>1. Building dashboards with a prompt</h3><p>Instead of hand-building a panel, clicking through aggregation dropdowns, and guessing at group-by fields, the prompt does the modeling:</p><pre>Build a SigNoz dashboard for the checkout-service with four panels:<br>p50/p95/p99 latency, error rate %, request volume, and top 5<br>slowest downstream calls — all grouped by pod, last 24h,<br>refresh every 5 minutes. Use our existing color scheme.</pre><p>Claude Code calls the dashboard-creation tool with the right query builder v5 payload — correct aggregation windows, correct group-by keys, correct panel types — and hands back a live link. What used to be twenty minutes of trial-and-error JSON becomes one sentence and a thirty-second wait.</p><h3>2. Doing RCA with a prompt</h3><p>This is where it stops feeling like a demo and starts feeling like a colleague. Say checkout error rates spiked at 14:02. The old way was seven browser tabs. The new way is one message:</p><pre>Why did checkout-service error rate spike at 14:02 today?<br>Pull traces and logs for the 10 minutes around it and tell me<br>what changed.</pre><p>Claude Code doesn’t answer from memory — it plans and executes a small investigation:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UWqAniHMt0E-g7dtZFHcFA.png" /></figure><p>It lists services, scopes a trace search to the exact time window, pulls the error logs for the same window, and only <em>then</em> writes an answer — one that cites the actual trace IDs and log lines it looked at, not a plausible-sounding guess. That evidence trail is the whole game, and I’ll come back to why in the hallucination section below.</p><h3>3. Writing postmortems with a prompt</h3><p>Once the root cause is nailed down, the postmortem practically writes itself:</p><pre>Draft a blameless postmortem for the checkout-service incident<br>we just diagnosed. Use our standard template: summary, timeline,<br>impact, root cause, contributing factors, action items with<br>owners. Pull exact timestamps from the traces we already looked at.</pre><p>Because Claude Code already has the trace and log evidence in context from the RCA step, the postmortem timeline is accurate down to the millisecond — no reconstructing from memory two days later, no “I think it started around 2pm.”</p><h3>4. Creating alerts with a prompt</h3><p>Alert sprawl is a natural byproduct of manual tuning — everyone adds a threshold when they get burned, nobody removes one. A prompt keeps the reasoning explicit and reviewable:</p><pre>Create an alert: checkout-service error rate above 2%, sustained<br>for 5 minutes, notify #sre-oncall on Slack. Base the threshold<br>on the last 30 days of baseline error rate, not a round number.</pre><p>Claude pulls the actual historical baseline through MCP before picking a threshold, instead of hard-coding “5%” because it sounded reasonable. That one change — grounding the threshold in real data — is the difference between an alert that pages you for noise and one you trust.</p><h3>The net effect</h3><p>Stack all four of those together and the shape of an incident changes completely:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jUX30sqITEPQ7RES-MrK4w.png" /></figure><p>The point isn’t that the human disappears. It’s that the human’s job moves from <em>investigator</em> to <em>reviewer</em> — which is a much better use of a senior engineer’s judgment than tab-switching.</p><h3>Minimizing token usage while you prompt</h3><p>None of this is free, and a sloppy agentic workflow can burn through context fast — especially once you’re pulling raw logs. A few habits that make a real difference:</p><ul><li><strong>Scope time windows tightly.</strong> “Last 10 minutes around the spike” costs a fraction of “last 24 hours,” and it’s usually all you need for RCA.</li><li><strong>Ask for aggregates, not raw rows.</strong> Request error <em>counts by type</em> instead of every raw log line — you can always drill into a specific bucket afterward.</li><li><strong>Use the narrowest tool for the job.</strong> A get_trace_error_analysis summary call is far cheaper than pulling the full span hierarchy of every trace in a window.</li><li><strong>Cap result sizes explicitly.</strong> “Top 10 slowest spans” beats an unbounded query every time.</li><li><strong>Let Claude summarize before it continues.</strong> In a multi-step investigation, have intermediate tool results distilled to their conclusion before the next tool call, rather than carrying every raw JSON blob forward in context.</li><li><strong>Reuse session context instead of re-querying.</strong> Service lists, dashboard IDs, and baseline metrics don’t change mid-investigation — ask once, reference afterward.</li><li><strong>Split unrelated tasks into separate sessions.</strong> Use Claude Code’s /clear or /compact between an RCA and an unrelated dashboard request instead of letting the context grow indefinitely.</li><li><strong>Match output length to the task.</strong> A quick “what broke” Slack reply doesn’t need the same verbosity budget as a full postmortem draft — say so in the prompt.</li></ul><p>None of these sacrifice accuracy. They just stop you from paying to re-read data the model already looked at.</p><h3>What about hallucination?</h3><p>This is the question every skeptical engineer should ask, and the honest answer is: hallucination risk doesn’t disappear, but it becomes <em>manageable</em> in a way that free-form chat never allowed. A few concrete mechanisms actually move the needle:</p><ul><li><strong>Tool-grounded answers, not memory-based ones.</strong> Because MCP forces Claude to call real query APIs, every number in the final answer traces back to an actual tool_result block — not a plausible-sounding recollection. If the model can&#39;t point to the data, that&#39;s a visible gap, not a silently invented figure.</li><li><strong>Require citations in the system prompt.</strong> Explicitly instructing Claude to attach trace IDs, log line references, and timestamps to every causal claim turns “the answer sounds right” into “the answer is checkable in thirty seconds.”</li><li><strong>Cross-signal verification.</strong> A root cause that only shows up in traces but isn’t corroborated by logs or a metric shift is a signal to dig further, not to conclude. Prompting for confirmation across at least two of the three telemetry types catches a lot of premature conclusions.</li><li><strong>Human review as a hard gate, not a formality.</strong> Nothing gets posted to an incident channel or filed as a final postmortem without an engineer’s sign-off. The agent proposes; a person still disposes.</li><li><strong>Calibrate against known incidents.</strong> Periodically running the same RCA prompt against a past incident with a known, documented root cause is the cheapest way to catch a workflow that’s drifting toward confident-but-wrong answers before it matters in production.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o5cv-9OVKO4-s2Za8v6XMA.png" /></figure><p>The short version: hallucination is a symptom of a model reasoning without evidence. Give it real evidence to reason over, force it to show its work, and keep a human at the approval gate — and the failure mode shrinks to something you can actually manage.</p><h3>The takeaway</h3><p>Observability didn’t need another dashboard. It needed a reasoning layer that could actually use the telemetry we’d already spent years instrumenting. MCP is the wiring, Claude Code is the hands, and SigNoz’s own data becomes the evidence base for dashboards, RCA, postmortems, and alerts that used to take an entire on-call rotation to produce by hand.</p><p>The engineers who get good at directing this — writing the right prompt, scoping the right time window, knowing when to push back on an agent’s conclusion — are going to look a lot more like AI-native SREs than the traditional ops role most job descriptions still describe. That’s the shift worth paying attention to.</p><p><em>If you’re building something similar with SigNoz, Claude Code, or MCP servers against your own observability stack, I’d genuinely like to compare notes — find me on LinkedIn.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81f398d2512f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 63 of 100 Days of DevOps: Deploying the Iron Gallery App with Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-63-of-100-days-of-devops-deploying-the-iron-gallery-app-with-kubernetes-4f47c2ee7e1d?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f47c2ee7e1d</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Mon, 23 Feb 2026 13:19:48 GMT</pubDate>
            <atom:updated>2026-02-23T13:19:48.759Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most exciting aspects of Kubernetes is how it enables us to deploy complex applications in a structured, repeatable, and scalable way. Today’s task involved deploying a multi-tier application — an Iron Gallery front-end and an Iron DB back-end — on a Kubernetes cluster with proper namespaces, deployments, volumes, and services.</p><p>This exercise really demonstrates how different Kubernetes objects work together to create an environment where applications can run reliably.</p><p><strong>Task Overview:</strong></p><p>The Nautilus DevOps team needed to:</p><ol><li>Create a namespace iron-namespace-nautilus.</li><li>Deploy the Iron Gallery app with:</li></ol><ul><li>Labels for organization (run: iron-gallery).</li><li>A single replica with resource limits.</li><li>Volume mounts for config and images using emptyDir.</li><li>Container based on kodekloud/irongallery:2.0.</li></ul><p><strong>3.</strong> Deploy the Iron DB (MariaDB-based) with:</p><ul><li>Labels (db: mariadb).</li><li>Environment variables to set up database credentials.</li><li>A persistent emptyDir volume for the database files.</li><li>Container based on kodekloud/irondb:2.0.</li></ul><p><strong>4. </strong>Expose services:</p><ul><li>Iron DB with a ClusterIP service on port 3306.</li><li>Iron Gallery with a NodePort service on port 80, accessible externally via NodePort 32678.</li></ul><p><strong>My Solution:</strong></p><p>I created a YAML file with the required details as shown in the attached Images, and applied it</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hlSAbx4ET61Uwwr8lNmTVQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7yrS62actGNSZlXsZEVBqw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vtsqab-7libKPCZONqzwPw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U64yIJLQl-BnlstLRhWj3g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wg5VQjpsi_k6DfCqHnq8Xw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xa8GMVfXLekmFhNFwNESBw.png" /></figure><p><strong>✅ Verification:</strong></p><p>After applying the manifest, both pods, deployments, and services were up and running:</p><pre>kubectl get all - namespace iron-namespace-nautilus</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cu8kTVeQy0eMPlBNB5K8cg.png" /></figure><p>Output:</p><ul><li><strong>Pods</strong>: Iron Gallery and Iron DB both running.</li><li><strong>Services</strong>:</li><li>iron-db-service-nautilus (ClusterIP on port 3306).</li><li>iron-gallery-service-nautilus (NodePort on port 80 → 32678).</li></ul><p>The Iron Gallery installation page was successfully accessible through the NodePort.</p><p><strong>Key Learnings:</strong></p><ul><li><strong>Namespaces</strong> help isolate and organize resources for specific applications or teams.</li><li><strong>Resource limits</strong> ensure containers do not consume excessive cluster resources.</li><li><strong>Volumes (emptyDir)</strong> provide temporary storage tied to pod lifecycle — useful for data caching and runtime storage.</li><li><strong>Services</strong> bridge communication: ClusterIP for internal services like DB, NodePort for exposing apps externally.</li><li>Kubernetes makes deploying multi-tier applications consistent and scalable with declarative YAML.</li></ul><p><strong>Closing Thoughts:</strong></p><p>This task really highlighted the power of Kubernetes abstractions — how deployments, services, and volumes come together to manage a complete application stack.</p><p>Even without connecting the database and front-end fully, this exercise laid the groundwork for production-ready, containerized application deployments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f47c2ee7e1d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 62 of 100 Days of DevOps: Securing License Keys with Kubernetes Secrets]]></title>
            <link>https://tundedamian.medium.com/day-62-of-100-days-of-devops-securing-license-keys-with-kubernetes-secrets-d3cc6930be7b?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3cc6930be7b</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Mon, 23 Feb 2026 12:56:51 GMT</pubDate>
            <atom:updated>2026-02-23T12:56:51.697Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the biggest lessons in DevOps is this: sensitive data should never be hardcoded into configs or images. Whether it’s passwords, API keys, or license numbers, handling them carelessly can lead to severe security breaches.</p><p>Today’s challenge was a hands-on exercise in securely managing such sensitive data using Kubernetes Secrets.</p><p><strong>The Task</strong></p><ul><li>We had a license key file news.txt located under /opt on the jump host.</li><li>Create a generic Kubernetes Secret named news containing the license number from that file.</li><li>Deploy a pod named secret-nautilus with:</li><li>Container name: secret-container-nautilus</li><li>Image: debian:latest</li><li>Command: sleep (to keep the pod running)</li><li>Mount the secret under /opt/demo inside the container.</li><li>Verify that the secret was correctly mounted.</li></ul><p><strong>My Step-by-Step Solution</strong></p><h3>1️⃣ Checked the license file</h3><p>cd /opt</p><p>ls</p><p># news.txt</p><p>cat news.txt</p><p># Output: 5ecur3</p><p><strong>2️⃣ Created the Secret manifest</strong></p><p>I defined a secret.yaml file to store the license key:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nr84QUklcdsLaNLAlxgbVw.png" /></figure><p>Applied it:</p><pre>kubectl create -f secret.yaml</pre><p># secret/news created</p><p>Verification:</p><pre>kubectl get secret</pre><p># NAME TYPE DATA AGE</p><p># news Opaque 1 9m10s</p><p><strong>3️⃣ Created the Pod manifest</strong></p><p>I then defined the pod (pod.yaml):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bud3Ge96MSjweCvCJLulsw.png" /></figure><p>Applied it:</p><pre>kubectl create -f pod.yaml</pre><p># pod/secret-nautilus created</p><p>Confirmed it was running:</p><pre>kubectl get all</pre><p># pod/secret-nautilus 1/1 Running</p><p><strong>4️⃣ Verified the Secret inside the pod</strong></p><p>I exec’d into the container:</p><pre>kubectl exec -it secret-nautilus - bash</pre><p>Checked the mounted directory:</p><pre>ls -la /opt/demo</pre><p># password -&gt; ..data/password</p><p>Read the secret value:</p><pre>cat /opt/demo/password</pre><p># Output: 5ecur3</p><p>✔️ Success — the secret was securely mounted and available to the pod.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CVfdTtfunTyLeBD6LtJVNQ.png" /></figure><p><strong>Key Learnings</strong></p><ul><li>Kubernetes Secrets are the right way to handle sensitive data such as passwords, tokens, and license numbers.</li><li>Storing credentials directly in YAML files is insecure. Mounting them as secrets keeps them safe and manageable.</li><li>Using command: [“sleep”, “infinity”] is a handy trick to keep a pod alive for debugging and verification.</li><li>Security in DevOps isn’t optional — it must be baked into every step of deployment.</li></ul><p><strong>Real-World Relevance</strong></p><p>In production, we’d enhance this setup with:</p><ul><li>Encryption at rest for secrets (enabled via Kubernetes config).</li><li>RBAC controls so only authorized services/users can access secrets.</li><li>Secret rotation policies to prevent stale or compromised credentials.</li></ul><p>This exercise reinforced the importance of DevSecOps principles — integrating security as a first-class citizen in every automation workflow.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3cc6930be7b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 61 of 100 Days of DevOps: Using Init Containers in Kubernetes Deployments]]></title>
            <link>https://tundedamian.medium.com/day-61-of-100-days-of-devops-using-init-containers-in-kubernetes-deployments-1dd4383504d6?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1dd4383504d6</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 12:42:22 GMT</pubDate>
            <atom:updated>2026-02-09T12:42:22.936Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most powerful features of Kubernetes is the ability to extend workloads with init containers. These special containers run <em>before</em> the main container starts and are perfect for performing setup tasks, pre-configuration, or injecting required files that the application needs.</p><p>Today’s task demonstrated how init containers can be used to set up a shared file that the main application container continuously consumes. Let’s break it down.</p><p><strong>The Scenario</strong></p><p>The goal was to:</p><ul><li>Create a Deployment named ic-deploy-datacenter.</li><li>Configure initContainers to run a setup command and write a message into a shared directory.</li><li>Use an emptyDir volume to share data between init and main containers.</li><li>Ensure the main container reads from that file continuously.</li></ul><p><strong>How I Solved It</strong></p><ul><li>I created a Yaml file</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*So4IDldniNF_jsoZbmNCig.png" /></figure><h3>What’s Happening Here</h3><p><strong>Init Container (ic-msg-datacenter)</strong></p><ul><li>Runs once, executes a shell command, and writes a welcome message into /ic/ecommerce.</li><li>Since /ic is mounted from an emptyDir volume, the file is stored in a shared location.</li></ul><p><strong>Main Container (ic-maindatacenter)</strong></p><ul><li>Starts <em>only after</em> the init container finishes.</li><li>Continuously reads and prints the contents of /ic/ecommerce every 5 seconds.</li></ul><p><strong>Volume (ic-volume-datacenter)</strong></p><ul><li>An emptyDir volume ensures data is shared between containers in the same Pod.</li><li>It lives as long as the Pod lives.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XRNtbbirsG7nzkrfVFx-Aw.png" /></figure><p><strong>Verification</strong></p><ul><li>Deployment created successfully:</li></ul><pre>kubectl get deploy</pre><pre>kubectl get pods</pre><ul><li>Logs confirmed the message was being printed repeatedly:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q0PSxa6W670KrETAL_uZ9A.png" /></figure><pre>kubectl logs -f &lt;pod-name&gt;</pre><p>Output:</p><p>Init Done — Welcome to xFusionCorp Industries</p><p>Init Done — Welcome to xFusionCorp Industries</p><ul><li>Double-checked by running:</li></ul><pre>kubectl exec &lt;pod-name&gt; - cat /ic/ecommerce</pre><p>Result:</p><p>Init Done — Welcome to xFusionCorp Industries</p><p><strong>Key Takeaways</strong></p><ul><li>Init containers are extremely useful for pre-deployment tasks that can’t be baked into the main image.</li><li>Shared volumes (like emptyDir) make it possible to pass information between init containers and main containers.</li><li>This pattern is widely used in production environments — for configuration bootstrapping, database migrations, certificate setup, and more.</li></ul><p><strong>Conclusion</strong></p><p>Day 61 showed me how Kubernetes init containers give DevOps engineers fine-grained control over workload initialization. Instead of modifying container images, we can handle pre-setup tasks dynamically at deployment time.</p><p>This is another step forward in building production-ready Kubernetes applications.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1dd4383504d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 60 of 100 Days Of DevOps: Working with Persistent Volumes & Pods in Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-60-of-100-days-of-devops-working-with-persistent-volumes-pods-in-kubernetes-74c3f4c72886?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/74c3f4c72886</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 09:24:30 GMT</pubDate>
            <atom:updated>2026-02-09T09:24:30.593Z</atom:updated>
            <content:encoded><![CDATA[<p>Today’s challenge focused on one of the most important aspects of Kubernetes which is managing persistent storage. Unlike ephemeral pod storage, Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) ensure that application data is durable, consistent, and not lost when pods restart or get rescheduled.</p><p>The Nautilus DevOps team needed a template to deploy a web application backed by persistent storage, and here’s how I approached it:</p><p><strong>Task Requirements</strong></p><p>1️⃣ <strong>PersistentVolume (PV)</strong></p><ul><li>Name: pv-nautilus</li><li>Storage class: manual</li><li>Capacity: 4Gi</li><li>Access mode: ReadWriteOnce</li><li>Volume type: hostPath</li><li>Path: /mnt/data</li></ul><p>2️⃣ <strong>PersistentVolumeClaim (PVC)</strong></p><ul><li>Name: pvc-nautilus</li><li>Storage class: manual</li><li>Request: 2Gi</li><li>Access mode: ReadWriteOnce</li></ul><p>3️⃣ <strong>Pod</strong></p><ul><li>Name: pod-nautilus</li><li>Container: container-nautilus</li><li>Image: httpd:latest</li><li>Mount PVC pvc-nautilus at the document root of the web server</li></ul><p>4️⃣ <strong>Service</strong></p><ul><li>Name: web-nautilus</li><li>Type: NodePort</li><li>Port: 30008 to expose the web server externally</li></ul><p><strong>My Workflow</strong></p><p>🔹 <strong>Created the PV</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pTWVRAb4pVKZNaBQPGXyMA.png" /></figure><pre>kubectl create -f pv.yaml</pre><p>Output:</p><p>persistentvolume/pv-nautilus created</p><p>🔹 <strong>Created the PVC</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ku7KSoqxK-bCCnWAx_djyA.png" /></figure><pre>kubectl create -f pvc.yaml</pre><p>Output:</p><p>persistentvolumeclaim/pvc-nautilus created</p><p>🔹 <strong>Deployed the Pod</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NoaUzwBlwSV19u0jkIaZcw.png" /></figure><pre>kubectl create -f pod.yaml</pre><p>Output:</p><p>pod/pod-nautilus created</p><p>🔹 <strong>Exposed the Pod via Service</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Ia4T_V8xmiMq3VNwE1cxA.png" /></figure><pre>kubectl create -f svc.yaml</pre><p>Output:</p><p>service/web-nautilus created</p><p><strong>Verification</strong></p><p>✔️ <strong>Persistent Volume</strong> bound successfully:</p><p>NAME CAPACITY ACCESS MODES STATUS CLAIM STORAGECLASS</p><p>pv-nautilus 4Gi RWO Bound default/pvc-nautilus manual</p><p>✔️ <strong>PVC</strong> bound to PV:</p><p>pvc-nautilus Bound pv-nautilus 4Gi RWO manual</p><p>✔️ <strong>Pod running and healthy</strong>:</p><p>pod/pod-nautilus 1/1 Running 0 100s 10.244.0.5</p><p>✔️ <strong>Service exposed correctly</strong>:</p><p>service/web-nautilus NodePort 80:30008/TCP</p><p>Finally, I could access the httpd web server externally via NodePort 30008.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ZprtRsURoAYeBbkbI4pFg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8jc_q_DpOhPQ2PkySy52Nw.png" /></figure><p><strong>Key Takeaways</strong></p><ul><li>Persistent Volumes (PV) are cluster-wide storage resources.</li><li>Persistent Volume Claims (PVC) allow pods to request storage in a portable way.</li><li>Binding PVCs to PVs ensures storage durability across pod restarts.</li><li>Exposing the pod via a NodePort service makes it reachable from outside the cluster.</li></ul><p>This exercise was a strong reminder that storage and persistence are just as critical as compute in Kubernetes. Applications aren’t just about running containers, but also need reliable, persistent data too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74c3f4c72886" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 59 of 100 Days Of DevOps: Debugging & Fixing a Redis Deployment on Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-59-of-100-days-of-devops-debugging-fixing-a-redis-deployment-on-kubernetes-106edf0acd6d?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/106edf0acd6d</guid>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 16:12:47 GMT</pubDate>
            <atom:updated>2026-01-29T16:12:47.273Z</atom:updated>
            <content:encoded><![CDATA[<p>Today’s task differed from previous days because, instead of deploying something new, I had to debug and fix a broken application. The Nautilus DevOps team had previously deployed Redis to a Kubernetes cluster; however, due to a configuration typo, the pods failed to start, bringing the app down.</p><p>My role was to quickly identify the issue and restore Redis to a running state.</p><p>Step-by-Step Troubleshooting</p><p>1️⃣ Checked Pod Status</p><pre>kubectl get pods</pre><p>This showed that the pods for redis-deployment were not Running.</p><p>2️⃣ Inspected Pod Events</p><pre>kubectl describe pod redis-deployment-54cdf4f76d-265t5</pre><p>The error logs indicated issues with the image and ConfigMap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VbVo-BQEZaYCu8M557uPTw.png" /></figure><p>3️⃣ Investigated ConfigMaps</p><pre>kubectl get configmap</pre><pre>kubectl get configmap redis-config</pre><p>Here, I noticed a typo in the deployment’s reference to the ConfigMap which was written as redis-cofig instead of redis-config.</p><p>4️⃣ Edited the Deployment</p><pre>kubectl edit deployment redis-deployment</pre><p>Fixed the typo in the image: changed redis:alpin → redis:alpine.</p><p>Fixed the typo in the ConfigMap name: changed redis-cofig → redis-config.</p><p>5️⃣ Verified the Fix</p><pre>kubectl get deployment redis-deployment -o wide</pre><pre>kubectl get pods</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UwJPbEBxUzH3NITfvs7OEA.png" /></figure><p>The pods restarted successfully and entered the Running state andRedis was back online!</p><p>Key Takeaways:</p><p>- Debugging is just as important as deployment: Kubernetes provides powerful tools (describe, get, edit) to investigate and fix issues quickly.</p><p>- Small mistakes like typos in image tags or ConfigMap names can break deployments. Attention to detail matters.</p><p>This exercise reinforced how to:</p><p>- Read pod events to trace the root cause.</p><p>- Edit live Kubernetes deployments to fix misconfigurations.</p><p>- Validate the health of workloads post-fix.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=106edf0acd6d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 58 of 100 Days Of DevOps: Deploying Grafana on Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-58-of-100-days-of-devops-deploying-grafana-on-kubernetes-bdea69f72e96?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/bdea69f72e96</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 16:03:36 GMT</pubDate>
            <atom:updated>2026-01-29T16:03:36.442Z</atom:updated>
            <content:encoded><![CDATA[<p>Today’s task was about deploying Grafana, a powerful monitoring and visualization tool, on a Kubernetes cluster. The Nautilus DevOps team needed a setup to collect and analyze application analytics, and my role was to ensure Grafana was successfully deployed and accessible.</p><h3>What I Did:</h3><p>1️⃣ <strong>Created a Deployment</strong></p><ul><li>Defined a Kubernetes Deployment named grafana-deployment-nautilus using the official Grafana Docker image (grafana/grafana:latest).</li><li>Ensured pod specifications (container name, labels, and selectors) aligned for proper orchestration.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fRGHRMCHAOLefRRMtXc7OA.png" /></figure><p>2️⃣ <strong>Exposed Grafana with a Service</strong></p><ul><li>Configured a NodePort Service named grafana-service.</li><li>Exposed Grafana internally and externally by mapping port 80 inside the cluster to NodePort 32000.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ObDmJFC9FoCbKmQ8D4czlw.png" /></figure><p>3️⃣ <strong>Validated Deployment</strong></p><ul><li>Confirmed the pod was running successfully on the control-plane node.</li><li>Verified the grafana-service was listening on port 32000.</li><li>Accessed the Grafana login page through the NodePort, ensuring the application was available.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NA6DXlQg9MJGMaUwePKbnQ.png" /></figure><h3>Why This Matters:</h3><p>Deploying tools like Grafana in Kubernetes environments is a critical DevOps skill because:</p><ul><li>It demonstrates infrastructure as code (IaC) best practices.</li><li>Provides scalable observability and monitoring for distributed applications.</li><li>Shows how Kubernetes services like NodePort bridge internal apps to external users.</li></ul><p>This exercise reinforced my understanding of workload deployment and service exposure strategies in Kubernetes — skills that are essential when working on production-grade monitoring solutions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bdea69f72e96" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 57 of 100 Days Of DevOps: Working with Environment Variables in Kubernetes Pods]]></title>
            <link>https://tundedamian.medium.com/day-57-of-100-days-of-devops-working-with-environment-variables-in-kubernetes-pods-6e8d2bbc3227?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e8d2bbc3227</guid>
            <category><![CDATA[kodekloud]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 13:58:17 GMT</pubDate>
            <atom:updated>2026-01-28T13:58:17.093Z</atom:updated>
            <content:encoded><![CDATA[<p>Today’s challenge focused on understanding how environment variables can be injected into a Kubernetes Pod and utilized during container execution.</p><p><strong>Scenario:<br></strong> The task was to create a pod that prints a custom greeting message using environment variables. The requirements were:</p><ul><li>Pod name: print-envars-greeting</li><li>Container name: print-env-container</li><li>Image: bash</li><li>Three environment variables:</li><li>GREETING = Welcome to</li><li>COMPANY = Nautilus</li><li>GROUP = Datacenter</li></ul><p>Command:</p><p>[“/bin/sh”, “-c”, ‘echo “$(GREETING) $(COMPANY) $(GROUP)”’]</p><ul><li>Restart policy set to Never to avoid crash loops.</li></ul><p><strong>My Solution:<br>- </strong>I created a Kubernetes manifest (pod.yaml) with the needed configurations</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9MCiWk6XersFba72i-OjCQ.png" /></figure><p>- Applied it with:</p><pre>kubectl apply -f pod.yaml</pre><p>- Then retrieved the output:</p><pre>kubectl logs -f print-envars-greeting</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DEMNH1bO7wsoS2HYWrXbRQ.png" /></figure><p>✅ <strong>Result:<br></strong> The pod executed successfully and printed the message:<br> Welcome to Nautilus Datacenter</p><p><strong>Key Learnings:</strong></p><ul><li>Kubernetes lets you inject environment variables into pods at runtime.</li><li>These variables can be used in commands or passed into applications.</li><li>Setting restartPolicy: Never is a good way to handle one-off jobs or test runs that shouldn’t loop forever.</li></ul><p>This exercise was a solid reminder of how Kubernetes handles configuration injection and process execution inside containers, which are essential skills for real-world DevOps and cloud-native deployments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e8d2bbc3227" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 56 of 100 Days of DevOps: Deploying a Scalable Nginx Application on Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-56-of-100-days-of-devops-deploying-a-scalable-nginx-application-on-kubernetes-931a8d8b5908?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/931a8d8b5908</guid>
            <category><![CDATA[kodekloud]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 13:50:39 GMT</pubDate>
            <atom:updated>2026-01-28T13:50:39.126Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most important aspects of Kubernetes is its ability to scale applications and make them highly available. Today’s task was to put that into practice by deploying a static website on Kubernetes using Nginx and ensuring it was reachable from outside the cluster.</p><h3>The Task</h3><p>The Nautilus team needed:</p><ul><li>An Nginx Deployment with 3 replicas (to ensure availability and scalability).</li><li>Each Pod is running an nginx:latest container named nginx-container.</li><li>A NodePort service to expose the application externally, accessible via nodePort: 30011.</li></ul><h3>The Solution</h3><ul><li>I created a Kubernetes manifest (file.yaml) that defined both the Deployment and the Service</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ijMqCmmDUx1eGh4O3GEuow.png" /></figure><p>- After which I applied the configuration:</p><pre>kubectl apply -f file.yaml</pre><p>I verified that all resources were running:</p><pre>kubectl get all -o wide</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D4POmb1sYU5b7pPurB1RRg.png" /></figure><h3>✅ Outcome</h3><ul><li>The Nginx Deployment spun up 3 replicas across the cluster.</li><li>The application is now accessible externally through NodePort 30011.</li><li>This setup guarantees high availability, fault tolerance, and scalability, which aligns with the principles of cloud-native design.</li></ul><h3>Key Takeaway</h3><p>Today’s exercise reinforced how Deployments and Services work hand-in-hand in Kubernetes.</p><ul><li><strong>Deployment</strong>: manages scaling, rolling updates, and availability of Pods.</li><li><strong>Service (NodePort)</strong>: makes the application reachable from outside the cluster.</li></ul><p>This separation of concerns ensures applications remain resilient while being easy to scale and expose.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=931a8d8b5908" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 55 of 100 Days Of DevOps: Shipping Nginx Logs with the Sidecar Pattern in Kubernetes]]></title>
            <link>https://tundedamian.medium.com/day-55-of-100-days-of-devops-shipping-nginx-logs-with-the-sidecar-pattern-in-kubernetes-a608b95eb96c?source=rss-a3735303df9b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a608b95eb96c</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <dc:creator><![CDATA[Damian Ogedengbe]]></dc:creator>
            <pubDate>Fri, 23 Jan 2026 12:20:17 GMT</pubDate>
            <atom:updated>2026-01-23T12:20:17.888Z</atom:updated>
            <content:encoded><![CDATA[<p>Today’s challenge was all about log management in Kubernetes using the Sidecar pattern, which is a classic approach for separating concerns inside Pods.</p><p>🔹 <strong>The Problem<br></strong> We had a web server container running on the nginx:latest image. By default, Nginx generates access and error logs, but:</p><ul><li>They weren’t critical enough to persist on storage volumes.</li><li>Developers still needed the last 24 hours of logs for debugging.</li></ul><p>Instead of bloating the Nginx container with log-shipping responsibilities, I had to implement the Sidecar container pattern. The idea:</p><ul><li>One container does one thing really well (Nginx serves web pages).</li><li>A second container specializes in shipping logs to a log aggregation service.</li><li>Both containers share an emptyDir volume for logs.</li></ul><p>🔹 <strong>My Solution<br></strong> I created a Kubernetes Pod definition (webserver.yaml) with:</p><p>1️⃣ An emptyDir volume called shared-logs to store Nginx logs.<br>2️⃣ Two containers inside the Pod:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TD7SCP5S5xXKCGqUuNlEaA.png" /></figure><p>nginx-container → Runs nginx:latest and writes logs to /var/log/nginx.</p><p>sidecar-container → Runs ubuntu:latest and continuously reads/shares logs with the command:</p><pre>sh -c &quot;while true; do cat /var/log/nginx/access.log /var/log/nginx/error.log; sleep 30; done&quot;</pre><p>3️⃣ Both containers mount the same shared volume at /var/log/nginx.</p><p>🔹 <strong>Verification<br></strong> I deployed the Pod with:</p><pre>kubectl create -f webserver.yaml</pre><p>Checked the status:</p><pre>kubectl get pods</pre><p>Result:</p><p>NAME READY STATUS RESTARTS AGE</p><p>webserver 2/2 Running 0 38s</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4yxE_U4EDlfKvkxKLyqr2g.png" /></figure><p>✅ Both containers were running smoothly, logs were being captured, and the Sidecar pattern worked as expected.</p><p><strong>Key Takeaway<br></strong> This exercise reinforced how observability and separation of concerns can be achieved in Kubernetes using patterns like Sidecar containers. Instead of coupling responsibilities inside a single container, Kubernetes makes it easy to compose specialized containers that work together efficiently.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a608b95eb96c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>