<?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 Rushikesh Mane on Medium]]></title>
        <description><![CDATA[Stories by Rushikesh Mane on Medium]]></description>
        <link>https://medium.com/@rushimane2606?source=rss-ed15c742f0cd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*hqAzzXuAcPJ2WJCC</url>
            <title>Stories by Rushikesh Mane on Medium</title>
            <link>https://medium.com/@rushimane2606?source=rss-ed15c742f0cd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 04:37:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rushimane2606/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[Kubernetes 1.37 : HPA Scale-to-Zero Is Now Beta. Do You Still Need KEDA?]]></title>
            <link>https://blog.devops.dev/kubernetes-1-37-hpa-scale-to-zero-is-now-beta-do-you-still-need-keda-1a51d855e492?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a51d855e492</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[autoscaling]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 10:27:12 GMT</pubDate>
            <atom:updated>2026-09-01T12:17:25.872Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l_zoXMfjJhv1DwAU4JP5-g.png" /><figcaption>From Alpha to Beta: Native HPA scale-to-zero in Kubernetes 1.37</figcaption></figure><p>Three months ago, I compared KEDA with the native HPA in Kubernetes 1.36 to see which one handled scale-to-zero better.</p><p>At that time, native HPA scale-to-zero was still an Alpha feature. You had to enable the HPAScaleToZero feature gate on the controller manager, and most managed Kubernetes services didn&#39;t give you access to that setting.</p><p>Kubernetes 1.37 (Garhwal) landed on August 26, 2026, and that changed.</p><p>Scale-to-zero in HPA is now Beta and enabled by default. No feature gate. No custom control plane flags. On 1.37, minReplicas: 0 just works.</p><p>So I ran the test again. This post is the practical follow-up: what changed, a minimal setup, and an answer to the question from the last post: <strong>Do you still need KEDA?</strong></p><blockquote>If you missed the original comparison, start here: <a href="https://blog.devops.dev/keda-vs-kubernetes-1-36-native-hpa-the-ultimate-scale-to-zero-showdown-0a85f79cd7ed"><strong>KEDA vs Kubernetes 1.36 Native HPA: The Ultimate Scale-to-Zero Showdown</strong>.</a></blockquote><h3>What actually changed in 1.37</h3><p>Three things. Only one is obvious.</p><p><strong>1. It’s on by default.</strong> The HPAScaleToZero gate moved to Beta, which means it&#39;s enabled by default. In 1.36, you needed --feature-gates=HPAScaleToZero=true on the kube-controller-manager. In 1.37, you need nothing.</p><p><strong>2. There’s a new status condition: </strong><strong>ScaledToZero.</strong> This is more interesting than the feature graduating to Beta. When the HPA scales a workload to zero, it now sets ScaledToZero: True in its status. When the workload comes back, it changes to False with the reason NotScaledToZero.</p><p>Why does that matter? Zero replicas can be ambiguous. Did the HPA scale it down because the queue was empty, or did someone run kubectl scale --replicas=0? Before 1.37, the HPA couldn&#39;t tell. Now it can, and it only wakes up workloads that it scaled to zero itself. I&#39;ll show that below.</p><p><strong>3. The old limitation is still there.</strong> Scale-to-zero only works with Object and External metrics. CPU and memory still can’t scale you to zero because those metrics come from running pods. At zero replicas, there’s nothing to measure. This hasn’t changed.</p><h3>The setup</h3><p>I wanted to keep the test simple this time. No SQS or real application. Just one BusyBox Deployment, one HPA, and a queue metric that I set manually.</p><ul><li><strong>kind</strong> with the Kubernetes 1.37 node image</li><li><strong>Prometheus</strong> with Pushgateway enabled</li><li><strong>prometheus-adapter</strong> to expose the Pushgateway metric as an external metric</li></ul><p>That’s it. All the files are in the repo linked at the end.</p><pre>kind: Cluster<br>apiVersion: kind.x-k8s.io/v1alpha4<br>nodes:<br>  - role: control-plane<br>    image: kindest/node:v1.37.0</pre><pre>kind create cluster --name k137 --config kind-config.yaml</pre><p>EKS won’t have 1.37 for a while, so I’m using kind to test this.</p><p><strong>Metrics pipeline</strong></p><pre>helm repo add prometheus-community https://prometheus-community.github.io/helm-charts<br><br>helm install prometheus prometheus-community/prometheus -n monitoring --create-namespace \<br>  --set prometheus-pushgateway.enabled=true \<br>  --set alertmanager.enabled=false \<br>  --set prometheus-node-exporter.enabled=false<br><br>helm install adapter prometheus-community/prometheus-adapter -n monitoring \<br>  -f adapter-values.yaml</pre><p>The adapter exposes one external metric:</p><pre># adapter-values.yaml<br>prometheus:<br>  url: http://prometheus-server.monitoring.svc<br>  port: 80<br>rules:<br>  default: false<br>  external:<br>    - seriesQuery: &#39;queue_length{job=&quot;demo&quot;,namespace!=&quot;&quot;}&#39;<br>      resources:<br>        overrides:<br>          namespace:<br>            resource: namespace<br>      metricsQuery: &#39;max(&lt;&lt;.Series&gt;&gt;{&lt;&lt;.LabelMatchers&gt;&gt;})&#39;<br>      name:<br>        as: queue_length</pre><p>One thing that caused an error in my first attempt: the HPA asks the external metrics API for namespaces/default/queue_length. The adapter needs to know that namespace maps to the Kubernetes namespace.</p><p>Without the resources.overrides block, you&#39;ll get a 500 error:no generic resource label form specified for this metric<br>That’s why the metric we push below includes a namespace label.</p><h4>The workload and the HPA</h4><pre># worker.yaml<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: worker<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: worker<br>  template:<br>    metadata:<br>      labels:<br>        app: worker<br>    spec:<br>      containers:<br>        - name: worker<br>          image: busybox:1.36<br>          command: [&quot;sh&quot;, &quot;-c&quot;, &quot;while true; do echo working; sleep 5; done&quot;]<br>---<br>apiVersion: autoscaling/v2<br>kind: HorizontalPodAutoscaler<br>metadata:<br>  name: worker<br>spec:<br>  scaleTargetRef:<br>    apiVersion: apps/v1<br>    kind: Deployment<br>    name: worker<br>  minReplicas: 0<br>  maxReplicas: 5<br>  behavior:<br>    scaleDown:<br>      stabilizationWindowSeconds: 0<br>  metrics:<br>    - type: External<br>      external:<br>        metric:<br>          name: queue_length<br>        target:<br>          type: AverageValue<br>          averageValue: &quot;2&quot;</pre><p>Two things to note here.</p><p>minReplicas: 0 is the feature we&#39;re testing. On 1.36, the API server rejected it unless the feature gate was enabled. On 1.37, it should apply without any extra configuration.</p><p>stabilizationWindowSeconds: 0 is only for this demo, so we don&#39;t have to wait five minutes to see scale-down. Don&#39;t use this setting in production just to make scaling faster.</p><h4>Run 1: empty queue, scale to zero</h4><p>Port-forward Pushgateway and tell it the queue is empty:</p><pre>kubectl -n monitoring port-forward svc/prometheus-prometheus-pushgateway 9091:9091 &amp;<br>echo &quot;queue_length 0&quot; | curl --data-binary @- http://localhost:9091/metrics/job/demo/namespace/default</pre><p>Apply the workload and watch the HPA:</p><pre>kubectl apply -f worker.yaml<br>kubectl get hpa worker -w</pre><p>For the first few seconds, you’ll see &lt;unknown&gt;/2 (avg) while the adapter picks up the metric. That&#39;s normal. If it stays that way for more than a minute, check kubectl describe hpa worker and the adapter logs before blaming the HPA. I&#39;ve added a troubleshooting section at the end with the errors I hit and what they meant.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*681c1KgBNZOYdoxrly29nQ.png" /></figure><p>Three rows, three stages: &lt;unknown&gt; while the adapter warms up, 0/2 once it reads the metric, and then zero pods.</p><p>That last TARGETS value looks broken, but it isn’t. -9223372036854775808m is math.MinInt64 in milli-units. The column shows the <em>average</em> value, and at zero replicas there&#39;s nothing to divide by, so kubectl shows a sentinel value. The actual metric is still fine in .status.currentMetrics.</p><p>Now for the new part. Check the HPA conditions:</p><pre>kubectl get hpa worker -o jsonpath=&#39;{range .status.conditions[*]}{.type}={.status} ({.reason}): {.message}{&quot;\n&quot;}{end}&#39;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvrxHnbVzS0uscsqrHtCfw.png" /></figure><p>Two things stand out.</p><p>ScaledToZero=True is the new condition doing its job.<br>ScalingActive=True is also important. The HPA is at zero replicas, but it&#39;s still checking the metric on every sync and waiting for the workload to scale back up.<br>Keep these conditions in mind. Later, we’ll see what they look like when a human scales the Deployment to zero.</p><p>On my run, it took <strong>about 45 seconds</strong> from applying the workload to reaching zero pods. Most of that time was the adapter picking up the first metric.</p><h4>Run 2: Work arrives, scale back up</h4><p>Now let’s add some work to the queue:</p><pre>echo &quot;queue_length 6&quot; | curl --data-binary @- http://localhost:9091/metrics/job/demo/namespace/default</pre><p>Six items at two per pod means the HPA should land on three replicas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8obdpWRlOB-QrChI-X9wzQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/862/1*p1STT5CqT4cL_ik7DFS0Jw.png" /></figure><p>The ScaledToZero condition also changes:</p><pre>{&quot;lastTransitionTime&quot;:&quot;2026-08-27T10:58:53Z&quot;,&quot;message&quot;:&quot;the HPA controller did not scale the workload to zero&quot;,&quot;reason&quot;:&quot;NotScaledToZero&quot;,&quot;status&quot;:&quot;False&quot;,&quot;type&quot;:&quot;ScaledToZero&quot;}</pre><p>It took <strong>about 30 seconds</strong> from pushing the metric to getting three Ready pods.<br>Most of that time came from the metrics pipeline: Prometheus’s 15-second scrape interval plus the HPA’s 15-second sync period. The pods themselves became Ready almost immediately.<br>For comparison, the KEDA test in my earlier 1.36 post used a different metrics path, so I wouldn’t compare the two timings directly. In both cases, cold-start time is mainly affected by the polling intervals you control, such as the scrape interval and HPA sync period here, and pollingInterval in KEDA, rather than the autoscaler itself.</p><h4>The test that shows why “ScaledToZero” exists</h4><p>Here’s the scenario we want to test.</p><p>Someone manually scales a Deployment to zero. Then a message arrives in the queue. Will the HPA bring the Deployment back up?</p><p>Let’s find out. With the queue is at 6 and three pods are running. Scale the Deployment to zero:</p><pre>kubectl scale deploy worker --replicas=0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y_qS5crMKCv912Zv-ysfyQ.png" /></figure><p>Now increase the queue length:</p><pre>echo &quot;queue_length 10&quot; | curl --data-binary @- http://localhost:9091/metrics/job/demo/namespace/default</pre><p>Wait a minute and check the Deployment:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*qWyg7U3ZSm2rWib0_itYCA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Zm_WgTgnNpJY7JbLarSbA.png" /></figure><p>The queue says 10, the target says 2, and the HPA still shows &lt;unknown&gt;. It isn&#39;t even evaluating the metric. The conditions explain why:</p><pre>kubectl get hpa worker -o jsonpath=&#39;{range .status.conditions[*]}{.type}={.status} ({.reason}): {.message}{&quot;\n&quot;}{end}&#39;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_riUG4Oai6w2g3RaVv8NRQ.png" /></figure><p>The two lines that matter are:</p><p>ScalingActive=False means the HPA isn&#39;t evaluating the metric while the workload is at zero.<br>ScaledToZero=False tells us that the HPA didn&#39;t scale the workload to zero itself.<br>This is the difference we saw earlier. When the HPA scales the workload to zero, ScaledToZero=True and it keeps watching the metric. When someone manually scales it to zero, ScaledToZero=False and the HPA stays out of the way.</p><p>To give control back to the HPA, scale the Deployment to one replica:</p><pre>kubectl scale deploy worker --replicas=1 <br>kubectl get hpa worker -w</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*osMPjIED7LCWIQS95XwSxg.png" /></figure><p>I set it to one replica, and then the HPA scaled it to five because the queue had 10 items and the target was 2 per pod.</p><p>This is similar to the problem KEDA users have dealt with using the autoscaling.keda.sh/paused-replicas annotation. Native HPA now handles this through its status condition, without another annotation.</p><h3>Windows users</h3><p>If you’re running the kubectl get --raw /apis/... commands from Git Bash, use MSYS_NO_PATHCONV=1.</p><p>Otherwise, MINGW can rewrite the leading / as a Windows path, and kubectl may return NotFound even though the metric exists.</p><h4>The gotcha that hasn’t gone away</h4><p>The question I got most under the 1.36 post was: “Can I just set minReplicas: 0 on my existing CPU-based HPA?&quot;</p><p>No. Kubernetes 1.37 doesn’t change that.</p><pre>  metrics:<br>    - type: Resource<br>      resource:<br>        name: cpu<br>        target:<br>          type: Utilization<br>          averageUtilization: 50</pre><p>You can set minReplicas: 0, but the HPA won&#39;t scale from zero based on CPU or memory. The reason is simple: CPU and memory come from running pods. At zero pods, there&#39;s nothing to measure.</p><p>Scale-to-zero needs a metric that exists outside the workload, such as queue depth, request rate, or pending jobs.</p><p>So if you want to move a CPU-based workload to scale-to-zero, the main work isn’t changing the HPA. You need a metric that tells you about demand, not resource usage.</p><h3>So, do you still need KEDA?</h3><p>Short answer: it depends on where your metric comes from, not whether scale-to-zero works.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hIiKjc1ZBc4xLaqeAoS8MQ.png" /></figure><p>If your metrics already flow through Prometheus and you have an adapter, native HPA is enough for many queue-based workloads. You don’t need KEDA just for scale-to-zero.</p><h3>Takeaways</h3><ul><li>On Kubernetes 1.37, minReplicas: 0 works out of the box with Object and External metrics. Nothing to enable.</li><li>The ScaledToZero condition makes it clear whether the HPA or a human scaled the workload to zero.</li><li>CPU and memory still can’t scale a workload from zero. You need a metric that exists even when there are no pods.</li><li>KEDA is still useful. The main difference now is that it’s less about scale-to-zero and more about the built-in scalers it gives you.</li></ul><p>Repo with all the manifests:<a href="https://github.com/rushi2828/k8s-scale-to-zero.git"> <strong>https://github.com/rushi2828/k8s-scale-to-zero.git</strong></a></p><p>If you try this on a different cluster or with a real queue, I’d be interested to see how your cold-start numbers compare.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a51d855e492" width="1" height="1" alt=""><hr><p><a href="https://blog.devops.dev/kubernetes-1-37-hpa-scale-to-zero-is-now-beta-do-you-still-need-keda-1a51d855e492">Kubernetes 1.37 : HPA Scale-to-Zero Is Now Beta. Do You Still Need KEDA?</a> was originally published in <a href="https://blog.devops.dev/">DevOps.dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KEDA vs Kubernetes 1.36 Native HPA: The Ultimate Scale-to-Zero Showdown]]></title>
            <link>https://blog.devops.dev/keda-vs-kubernetes-1-36-native-hpa-the-ultimate-scale-to-zero-showdown-0a85f79cd7ed?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a85f79cd7ed</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Wed, 20 May 2026 16:01:01 GMT</pubDate>
            <atom:updated>2026-05-21T08:41:00.661Z</atom:updated>
            <content:encoded><![CDATA[<p>Kubernetes finally ships native scale-to-zero in 1.36. Is KEDA still worth it?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*4YQBUdKnl1asJ48OYgIpRQ.png" /><figcaption>KEDA vs Kubernetes 1.36 Native HPA</figcaption></figure><h3>The problem with idle pods</h3><p>It’s 3 AM on a Sunday. Your batch job hasn’t run since Friday. Your SQS worker has been sitting at minReplicas: 1 for 48 hours — doing nothing, consuming memory, running up your AWS bill.</p><p><em>Paying for pods that do nothing. Scale-to-zero fixes this.</em></p><p>Multiply that across 20 microservices in staging, and you’re burning hundreds of dollars a month on pods that never process a single request.</p><p>The solution sounds simple: <strong>scale to zero</strong> when there’s no work. In practice, Kubernetes has made this surprisingly hard — until now.</p><p>This article dives into two approaches running on <strong>AWS EKS 1.36</strong>, benchmarks them head-to-head, and tells you exactly when to use each one. All code is at <a href="https://github.com/rushi2828/keda-vs-k8s-scale-to-zero">github.com/rushi2828/keda-vs-k8s-scale-to-zero</a>.</p><h3>What is scale-to-zero?</h3><p>Standard Kubernetes HPA has always required minReplicas: 1. Even at 3 AM with no traffic, at least one pod must be running — still consuming CPU, memory, and node capacity.</p><p>Scale-to-zero means minReplicas: 0 — fully terminating all pods when idle, spinning them back up when demand returns.</p><p>The challenge: <strong>when you have zero pods, you have zero metrics.</strong> No CPU to read. No memory to watch. How does the autoscaler know when to wake up? This is the chicken-and-egg problem both KEDA and the new native HPA have solved — differently.</p><h3>The demo setup</h3><p><em>The demo setup: EKS 1.36 with two parallel scale-to-zero approaches running side by side.</em></p><p>Everything runs on EKS 1.36 provisioned with Terraform. The Terraform creates the VPC, EKS cluster, SQS queue, and all IAM roles. After terraform apply, a single setup.sh script installs KEDA, Prometheus, and deploys both demo apps.</p><h3>Approach 1: KEDA — event-driven autoscaling</h3><p>KEDA was built for exactly this problem. Instead of waiting for pod-level CPU metrics, it watches <strong>external event sources</strong> directly — SQS queue depth, RabbitMQ queue length, Redis list size, Prometheus queries, and 70+ others.</p><h3>How KEDA solves scale-to-zero</h3><pre>Queue empty  → KEDA sees 0 messages → scales Deployment to 0<br>Message arrives → KEDA sees queue depth &gt; 0 → scales to 1+ pods</pre><p>No pods required to make the scaling decision. KEDA reaches outside the cluster to read the SQS queue directly.</p><pre>apiVersion: keda.sh/v1alpha1<br>kind: ScaledObject<br>metadata:<br>  name: sqs-worker-scaler<br>  namespace: keda-demo<br>spec:<br>  scaleTargetRef:<br>    name: sqs-worker<br>  minReplicaCount: 0   # Full scale-to-zero<br>  maxReplicaCount: 20<br>  pollingInterval: 10  # Check SQS every 10 seconds<br>  cooldownPeriod: 60<br>  triggers:<br>    - type: aws-sqs-queue<br>      authenticationRef:<br>        name: aws-sqs-auth<br>      metadata:<br>        queueURL: &quot;https://sqs.us-east-1.amazonaws.com/...&quot;<br>        queueLength: &quot;5&quot;   # 1 pod per 5 messages<br>        awsRegion: &quot;us-east-1&quot;</pre><p>After applying this, KEDA immediately scales the deployment to zero because the SQS queue is empty:</p><p><em>Empty SQS queue = zero pods. KEDA knows this without needing any pods to tell it.</em></p><p>And here’s KEDA confirming it’s healthy and watching the queue — READY=True means connected to SQS, ACTIVE=False means queue is empty so deployment stays at zero:</p><p><em>READY=True means KEDA connected to SQS successfully. ACTIVE=False means queue is empty — deployment stays at zero.</em></p><h3>Approach 2: Native HPA scale-to-zero (K8s 1.36)</h3><p>The HPAScaleToZero feature gate has been in alpha since Kubernetes 1.16 (2019). In <strong>Kubernetes 1.36</strong>, it becomes enabled by default — meaning minReplicas: 0 in a native HPA just works.</p><pre>apiVersion: autoscaling/v2<br>kind: HorizontalPodAutoscaler<br>metadata:<br>  name: http-worker-hpa<br>  namespace: native-hpa-demo<br>spec:<br>  scaleTargetRef:<br>    apiVersion: apps/v1<br>    kind: Deployment<br>    name: http-worker<br>  minReplicas: 0        # Works natively in K8s 1.36+<br>  maxReplicas: 20<br>  metrics:<br>    - type: External<br>      external:<br>        metric:<br>          name: sqs_approximate_number_of_messages_visible<br>        target:<br>          type: AverageValue<br>          averageValue: &quot;5&quot;</pre><p><em>MINPODS=0 and CURRENT=0. In K8s 1.36, this works natively — no KEDA required.</em></p><h3>The critical limitation</h3><p>When a Deployment is at 0 replicas, there are no pods to emit CPU or memory metrics. The HPA is blind at zero — <strong>it cannot scale from 0→1 using CPU metrics alone.</strong></p><p>You must provide an external metric source (like SQS queue depth via CloudWatch) for the HPA to know when to wake up. This requires installing k8s-cloudwatch-adapter — which is nearly as much operational overhead as KEDA itself, but with fewer features.</p><h3>The benchmark: who scales up faster?</h3><p><em>Watch pods go from 0 to Running. KEDA (left) consistently reacts faster than native HPA (right).</em></p><h3>Results (3 runs each, AWS EKS 1.36, us-east-1)</h3><p><em>Grafana showing replica counts during the benchmark. The flat-spike-flat pattern is scale-to-zero working.</em></p><p><em>3 runs each. KEDA wins on speed; native HPA wins on simplicity.</em></p><p>MetricKEDANative HPA (1.36)<strong>0→1 scale-up latency</strong>~18s~32s<strong>N→0 scale-down time</strong>~70s (cooldown)~130s (stabilization)<strong>Trigger granularity</strong>10s poll interval30s (CloudWatch resolution)</p><p><strong>Why KEDA is faster:</strong> KEDA polls SQS directly every 10 seconds. Native HPA uses CloudWatch metrics which have a 30-second minimum resolution. That’s 20 extra seconds before the HPA even knows messages exist.</p><h3>Decision guide: which should you use?</h3><p><strong>Use KEDA when:</strong></p><ul><li>Your trigger is a queue (SQS, RabbitMQ, Redis)</li><li>You need multi-trigger logic or cron-based scaling</li><li>You want production-proven scale-to-zero today</li><li>Your workload is batch, ETL, or ML inference</li></ul><p><strong>Use native HPA (K8s 1.36+) when:</strong></p><ul><li>Simple HTTP workload with CPU-based scaling</li><li>You want minimal cluster components</li><li>Dev/staging cost optimization where latency doesn’t matter</li><li>Your managed K8s provider already runs 1.36+</li></ul><h3>Running the demo yourself</h3><pre>git clone https://rushi2828/YOUR_USERNAME/keda-vs-k8s-scale-to-zero<br>cd keda-vs-k8s-scale-to-zero</pre><pre># 1. Provision AWS infrastructure (~15 min)<br>cd terraform/environments/dev<br>cp terraform.tfvars.example terraform.tfvars<br>terraform init &amp;&amp; terraform apply</pre><pre># 2. Install KEDA, monitoring, deploy apps<br>cd ../../.. &amp;&amp; ./scripts/setup.sh</pre><pre># 3. Trigger the scale-up<br>./scripts/load-generator.sh 50</pre><pre># 4. Benchmark both approaches<br>./scripts/benchmark.sh</pre><pre># 5. Cleanup when done<br>cd terraform/environments/dev &amp;&amp; terraform destroy</pre><h3>Conclusion</h3><p>Scale-to-zero is no longer a “nice to have” — it’s a platform engineering baseline.</p><p><strong>KEDA</strong> is the right choice for event-driven, queue-based workloads. It’s mature, battle-tested, and has a rich ecosystem. It solves the zero-pods-zero-metrics problem natively.</p><p><strong>Native HPA scale-to-zero</strong> (K8s 1.36+) is the right choice for simple HTTP workloads where you want minimal operational overhead. But for queue-based triggers, you still need an external metrics adapter — which narrows the simplicity advantage.</p><p>The good news: they’re not mutually exclusive. Many production clusters run KEDA for queue workers and native HPA for HTTP services. Use the right tool for each job.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a85f79cd7ed" width="1" height="1" alt=""><hr><p><a href="https://blog.devops.dev/keda-vs-kubernetes-1-36-native-hpa-the-ultimate-scale-to-zero-showdown-0a85f79cd7ed">KEDA vs Kubernetes 1.36 Native HPA: The Ultimate Scale-to-Zero Showdown</a> was originally published in <a href="https://blog.devops.dev/">DevOps.dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Ingress to Gateway API: A Hands-On Migration with ingress2gateway 1.0 on kind]]></title>
            <link>https://blog.devops.dev/from-ingress-to-gateway-api-a-hands-on-migration-with-ingress2gateway-1-0-on-kind-eb8db495c8f3?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb8db495c8f3</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[api-gateway]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[nginx-ingress]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Wed, 25 Mar 2026 15:53:25 GMT</pubDate>
            <atom:updated>2026-04-09T13:01:31.432Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>On November 11, 2025, the Kubernetes project announced the retirement of ingress-nginx. On March 20, 2026, the community released ingress2gateway 1.0 — a CLI tool purpose-built to translate your existing Ingress resources and their nginx annotations into Gateway API resources automatically.</blockquote><blockquote>If you are still running ingress-nginx in production, you are running an unmaintained controller. The migration path is Gateway API, and ingress2gateway 1.0 is the fastest way to get there.</blockquote><blockquote>This article walks you through a complete, working local demo: a kind cluster, two sample apps, a classic Ingress with nginx annotations, and the full migration to Gateway + HTTPRoute using the new tool. Every command is exact and tested on Windows with MobaXterm.</blockquote><h3>Why migrate? The old model is broken.</h3><p>The Kubernetes Ingress resource was designed in 2015. It was intentionally minimal — just hostnames and path rules. Any advanced behavior required controller-specific annotations. This coupled your routing config to your controller implementation.</p><p><em>Gateway API separates concerns cleanly:</em></p><p><em>Role : Resource owned ; <br>Platform team: GatewayClass, Gateway;<br>App team: HTTPRoute, GRPCRoute.</em></p><p>Advanced routing — rewrites, CORS, rate limiting, canary splits — are now first-class spec fields, not annotations. Portable across implementations. No lock-in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*N3eDhmE8kU5YUx28I81gLw.png" /><figcaption><em>Before and after: the old model couples app and platform teams in one Ingress object; the new model gives each team their own resource</em></figcaption></figure><h3>What is ingress2gateway 1.0?</h3><p>ingress2gateway is a kubectl-style CLI that reads your existing Ingress resources and outputs equivalent Gateway API YAML. The 1.0 release supports:</p><p><em>• ingress-nginx — 30+ annotations with live integration tests verifying behavioral equivalence<br>• Istio ingress resources<br>• Kong ingress resources</em></p><p>For each annotation it can translate, it generates the correct Gateway API filter or field. For annotations it cannot translate, it prints a WARN so you know exactly what needs manual attention.</p><h3>The demo stack.</h3><p>We will build this on a local kind cluster with two sample apps, an Envoy Gateway implementation, and the full migration flow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Kc73bYavordJl2xeocsM-g.png" /><figcaption><em>Traffic flow through the kind cluster: browser/curl hits NodePort 30080, Envoy proxy matches the HTTPRoute, path prefix is rewritten, and the request reaches the backend pod.</em></figcaption></figure><h3>Prerequisites :</h3><p>Install these tools before starting:</p><p>• Docker : version 24+<br>• Kind : v0.23+<br>• Kubectl : v1.29+<br>• Helm : v3.14+<br>• Go : 1.21+</p><h3>Part 1 — Create the kind cluster.</h3><pre>kind create cluster - config kind-config.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9LbVounJ20ceNm3qK1gocA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*hx62UOJlREi4cF8F1T5wyg.png" /></figure><h3>Part 2 — Install Gateway API CRDs and Envoy Gateway.</h3><p>Install the Gateway API Custom Resource Definitions first — these are schema definitions, not an implementation:</p><pre>kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.1/standard-install.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nXP5yV1g1Be71ojGKimDZw.png" /></figure><p>Then install Envoy Gateway as the Gateway API implementation:</p><pre>helm install eg oci://docker.io/envoyproxy/gateway-helm --version v1.7.1 -n envoy-gateway-system --create-namespace<br><br>kubectl get pods -n envoy-gateway-system</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*RrVoN3WJwvNK7kRCxGNfog.png" /></figure><h3>Part 3 — Deploy two sample apps.</h3><p>Both apps run in a demo namespace. nginx-demo serves the nginx welcome page; echo-demo returns a JSON dump of every request header — useful for verifying routing and Envoy’s injected headers.</p><pre>kubectl create namespace demo<br>kubectl apply -f apps/nginx-demo/deployment.yaml<br>kubectl apply -f apps/echo-demo/deployment.yaml<br>kubectl get pods,svc -n demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*GEHk4taDwwqFzRfjvtbdKg.png" /></figure><p>At this point we have two services but nothing routing traffic to them from outside the cluster.</p><h3>Part 4 — The BEFORE state: a classic Ingress.</h3><p>This is the resource we are migrating away from. Notice the nginx-specific annotations — this is the configuration that couples your routing rules to the ingress-nginx controller:</p><pre>apiVersion: networking.k8s.io/v1<br>kind: Ingress<br>metadata:<br>  name: demo-ingress<br>  namespace: demo<br>  annotations:<br>    kubernetes.io/ingress.class: &quot;nginx&quot;<br>    nginx.ingress.kubernetes.io/rewrite-target: /<br>    nginx.ingress.kubernetes.io/enable-cors: &quot;true&quot;<br>    nginx.ingress.kubernetes.io/cors-allow-origin: &quot;*&quot;<br>    nginx.ingress.kubernetes.io/cors-allow-methods: &quot;GET, POST, OPTIONS&quot;<br>    nginx.ingress.kubernetes.io/backend-protocol: &quot;HTTP&quot;<br>spec:<br>  rules:<br>    - host: demo.localtest.me<br>      http:<br>        paths:<br>          - path: /nginx<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: nginx-demo<br>                port:<br>                  number: 80<br>          - path: /echo<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: echo-demo<br>                port:<br>                  number: 80</pre><pre>kubectl apply -f ingress/demo-ingress.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*selTwhPAbB26MDGEE0RPEg.png" /></figure><h3>Part 5 — Run ingress2gateway.</h3><p>Install the tool. The module path is github.com/kubernetes-sigs/ingress2gateway — not sigs.k8s.io. Using the wrong path gives a module path mismatch error.</p><pre>go install github.com/kubernetes-sigs/ingress2gateway@v1.0.0</pre><p>Windows / MobaXterm users: add the Go bin directory to your PATH:</p><pre>export PATH=&quot;$PATH:$(go env GOPATH | sed &#39;s|\\|/|g&#39; | sed &#39;s|C:|/drives/c|&#39;)/bin&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*PknO7cdnz0L5Bxi6lKz9lQ.png" /></figure><p>Now run the translation:</p><pre>ingress2gateway print --providers=ingress-nginx --namespace=demo --input-file=ingress/demo-ingress.yaml</pre><p>The output is ready-to-apply Gateway API YAML. The rewrite-target: / annotation becomes a URLRewrite filter. You will also see a warning for the CORS annotations — the tool flags anything it cannot translate:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qg6Ln-D7JsMS1WjWsaSfXQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oYdbUhma39_vnILUxcN8SQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*_S8USRFBVlEFQCJZj0UY9g.png" /><figcaption><em>What ingress2gateway translates automatically (green) vs what needs manual attention (amber WARN). CORS annotations have no Gateway API standard equivalent yet.</em></figcaption></figure><h3>Part 6 — The AFTER state: apply Gateway API resources.</h3><h4>GatewayClass and Gateway :</h4><pre>apiVersion: gateway.networking.k8s.io/v1<br>kind: GatewayClass<br>metadata:<br>  name: eg<br>spec:<br>  controllerName: gateway.envoyproxy.io/gatewayclass-controller<br>---<br>apiVersion: gateway.networking.k8s.io/v1<br>kind: Gateway<br>metadata:<br>  name: demo-gateway<br>  namespace: demo<br>spec:<br>  gatewayClassName: eg<br>  listeners:<br>    - name: http<br>      protocol: HTTP<br>      port: 80<br>      allowedRoutes:<br>        namespaces:<br>          from: Same</pre><pre>kubectl apply -f gateway/gateway.yaml</pre><p>kind-specific fix: Envoy Gateway creates a LoadBalancer service, but kind has no cloud load balancer controller. The service stays EXTERNAL-IP: &lt;pending&gt; and the Gateway never becomes Programmed. Patch it to NodePort:</p><pre>kubectl patch svc envoy-demo-demo-gateway-b23f25a6  -n envoy-gateway-system --type=&#39;json&#39; -p=&#39;[ {&quot;op&quot;:&quot;replace&quot;,&quot;path&quot;:&quot;/spec/type&quot;,&quot;value&quot;:&quot;NodePort&quot;}, {&quot;op&quot;:&quot;replace&quot;,&quot;path&quot;:&quot;/spec/ports/0/nodePort&quot;,&quot;value&quot;:30080} ]&#39;<br><br>kubectl wait gateway/demo-gateway -n demo --for=condition=Programmed --timeout=120s</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*PAGm5nfg-SDJkeQHiYwKew.png" /></figure><h4>HTTPRoute :</h4><pre>kubectl apply -f gateway/httproute.yaml<br><br>kubectl get gateway,httproute -n demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*qoYzy0ssm5ZJ-nm1ei-ENw.png" /></figure><h3>Cut over: delete the old Ingress :</h3><pre>kubectl delete ingress demo-ingress -n demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*A_0TTXk0WknegQXDDzFzaw.png" /></figure><p>The migration is complete. The controller-coupled Ingress is gone. Gateway API owns routing now.</p><h3>Part 7 — Verify it works.</h3><h4>Port-forward :</h4><pre>kubectl port-forward pod/envoy-demo-demo-gateway-b23f25a6-55ff89c8bf-t8zcq  8070:10080 -n envoy-gateway-system</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dKo0cCtEIucNLf9oWpTvQQ.png" /></figure><p><strong>Test /nginx route :</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*tjklNyvc8EfjcbLl749ZnQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DL9qo0Rja8TvroaPrPMidg.png" /></figure><h4><strong>Test /echo route :</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xXkKJ9cH4h4Kal53TJDQkg.png" /></figure><p>The presence of <strong>x-envoy-external-address</strong> and <strong>x-request-id</strong> headers confirms that the request was routed through the Envoy proxy. Additionally, the <strong>originalUrl: &quot;/&quot;</strong> in the response verifies that the URLRewrite filter correctly removed the /echo prefix from the request path—effectively mirroring the behavior of the traditional rewrite-target: / annotation used in Ingress.</p><h3>The complete project.</h3><p>All files from this article are in the GitHub repo. Clone it and you can reproduce the entire demo with three commands:</p><p>git clone <a href="https://github.com/rushi2828/ingress2gateway-kind-demo">https://github.com/rushi2828/ingress2gateway-kind-demo</a><br>cd ingress2gateway-kind-demo<br>./scripts/setup.sh<br>./scripts/demo-migration.sh<br>./scripts/test.sh</p><h3>Things to Keep in Mind</h3><h4><strong>ingress2gateway does not migrate everything.</strong></h4><p>Implementation-specific behaviours — custom Lua scripts, configuration-snippet annotations — have no Gateway API equivalent and will appear as warnings. Treat the tool output as a starting point, not a finished migration.</p><h4><strong>The service name contains a hash.</strong></h4><p>The Envoy proxy service name (envoy-demo-demo-gateway-b23f25a6) includes a hash of the Gateway UID. If you delete and recreate the Gateway, the hash changes. Keep this in mind when scripting.</p><h4><strong>LoadBalancer services on kind.</strong></h4><p>Every time Envoy Gateway reconciles the Gateway it may reset the service type to LoadBalancer. The JSON patch with an explicit nodePort: 30080 value is sticky in practice, but for a production-like local setup consider installing MetalLB instead.</p><h4><strong>CORS needs a BackendTrafficPolicy.</strong></h4><p>The enable-cors and cors-allow-* annotations are not translatable. In Envoy Gateway, configure CORS via BackendTrafficPolicy. The ingress2gateway warning tells you exactly which annotations need this follow-up.</p><h3>Conclusion.</h3><p>In under 30 minutes we went from a classic ingress-nginx Ingress with annotations to a fully working Gateway API stack on kind.</p><p>The migration is not just a syntax change — it is a shift in the ownership model. Platform teams own the Gateway infrastructure. Application teams own their HTTPRoutes. The two never need to edit the same object again.</p><p>With ingress-nginx retired, this migration is no longer optional. The tooling is here and the path is clear.</p><h3>Resources.</h3><ul><li><a href="https://kubernetes.io/blog/2026/03/20/ingress2gateway-1-0-release/">Ingress2Gateway 1.0 release announcement</a></li><li><a href="https://github.com/kubernetes-sigs/ingress2gateway">ingress2gateway on GitHub</a></li><li><a href="https://gateway-api.sigs.k8s.io/">Kubernetes Gateway API documentation</a></li><li><a href="https://gateway.envoyproxy.io/">Envoy Gateway</a></li><li><a href="https://kubernetes.io/blog/2025/11/11/ingress-nginx-retirement/">Ingress-NGINX retirement announcement</a></li><li><a href="https://kubernetes.io/blog/2026/01/28/experimenting-gateway-api-with-kind/">Experimenting with Gateway API using kind</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb8db495c8f3" width="1" height="1" alt=""><hr><p><a href="https://blog.devops.dev/from-ingress-to-gateway-api-a-hands-on-migration-with-ingress2gateway-1-0-on-kind-eb8db495c8f3">From Ingress to Gateway API: A Hands-On Migration with ingress2gateway 1.0 on kind</a> was originally published in <a href="https://blog.devops.dev/">DevOps.dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Assisted Observability: Honeycomb + MCP + OpenTelemetry on Kubernetes]]></title>
            <link>https://blog.devops.dev/ai-assisted-observability-honeycomb-mcp-opentelemetry-on-kubernetes-a640036e4b05?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/a640036e4b05</guid>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[ai-observability]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Wed, 03 Dec 2025 12:43:18 GMT</pubDate>
            <atom:updated>2026-05-21T08:39:10.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sL-NoOELIT5MZgEQrXVD1Q.png" /></figure><blockquote>In this article, we will deploy the <strong>OpenTelemetry Demo application</strong> on a <strong>KIND Kubernetes cluster</strong>, export all telemetry data to <strong>Honeycomb.io</strong>, and finally use <strong>MCP (Model Context Protocol)</strong> in VS Code to query Honeycomb interactively.</blockquote><p>This guide is perfect for:</p><ul><li>DevOps/SRE engineers</li><li>Observability practitioners</li><li>Beginners exploring Honeycomb + OpenTelemetry</li><li>Anyone wanting to try MCP integrations in VS Code</li></ul><h3>✅ Overview</h3><p>We will :</p><ol><li>Create a Honeycomb account &amp; ingest key</li><li>Build project folder structure</li><li>Create KIND cluster</li><li>Create namespace</li><li>Create secret with Honeycomb keys</li><li>Deploy OpenTelemetry Demo using custom Helm values</li><li>Verify the deployment</li><li>Validate pods, logs, and dashboards</li><li>Install Honeycomb MCP server in VS Code</li><li>Run real MCP prompts to query Honeycomb data</li></ol><h3>1. Create Honeycomb.io Account and Ingest Key</h3><p>Create a free account → <a href="https://www.honeycomb.io/">https://www.honeycomb.io</a></p><h3>Steps:</h3><ol><li>Login → Go to <em>Access Tokens</em></li><li>Click <strong>Create API Key</strong></li><li>Choose <strong>Ingest</strong> key</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZTE88MHBY8o9GxNbrm_1yA.png" /><figcaption>Creating a new Ingest API key in Honeycomb — required to send traces, logs, and metrics from Kubernetes.</figcaption></figure><p>Copy the key — we’ll use it in Kubernetes.</p><h3>2. Project Structure</h3><p>Here is the structure used in my GitHub repo:</p><pre>.<br>+--- helm<br>|   +--- otel-demo<br>|   |   +--- values-honeycomb.yaml<br>+--- k8s<br>|   +--- namespaces.yaml<br>|   +--- secrets<br>|   |   +--- honeycomb-credentials-example.yaml<br>+--- kind<br>|   +--- create-cluster.sh<br>|   +--- kind-config.yaml<br>+--- README.md</pre><h3>3. Create KIND Cluster</h3><pre>cd kind/<br>chmod +x create-cluster.sh<br>./create-cluster.sh</pre><h3>4. Create Namespace</h3><pre>kubectl create namespace otel-demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*JCZqJAdom1vfVbsjOv1tEg.png" /></figure><h3>5. Create Honeycomb Secret &amp; Dataset</h3><h4>Apply secret directly:</h4><pre>kubectl -n otel-demo create secret generic honeycomb-credential \<br>  --from-literal=HONEYCOMB_API_KEY=&#39;YOUR_API_KEY&#39; \<br>  --from-literal=HONEYCOMB_DATASET=&#39;otel-demo&#39;</pre><h4>You can verify:</h4><pre>kubectl -n otel-demo get secret honeycomb-credential -o yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QirxTGgLNYE-fKp3UhVSAw.png" /><figcaption>Honeycomb API key and dataset stored securely as a Kubernetes Secret.</figcaption></figure><h3>6. Install my-otel-demo Using Helm</h3><pre>helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts<br>helm repo update</pre><p>Now apply the Helm release:</p><pre>helm install my-otel-demo open-telemetry/opentelemetry-demo \<br>  --namespace otel-demo \<br>  --values ./helm/otel-demo/values-honeycomb.yaml</pre><h3>Explanation of values-honeycomb.yaml</h3><p>This file configures:</p><ul><li>Honeycomb exporter endpoint</li><li>API Key from Kubernetes secret</li><li>Dataset name</li><li>Collector processors (batch, memory limiter, tail sampling)</li><li>Service ports</li><li>Tracing + metrics pipeline</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*cG6fOetOsh-rW30cl8gb4Q.png" /><figcaption>Custom Helm values file configuring the OpenTelemetry Collector to export data to Honeycomb.</figcaption></figure><h3>7. Verify the Deployment</h3><h4>Check pods:</h4><pre>kubectl get pods -n otel-demo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*H-k8xiBkqndQekrFOrK0rg.png" /><figcaption>All OpenTelemetry Demo pods running successfully inside the KIND cluster</figcaption></figure><h4>Port-forward UI</h4><pre>kubectl port-forward svc/frontendproxy 8070:8080 -n otel-demo</pre><h4>Visit browser:</h4><pre>http://localhost:8070</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rW656RawL2fp0_l5QbBh_Q.png" /><figcaption>OpenTelemetry Demo frontend UI accessed through local port-forwarding.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8H98ews1dqeWvLE2jQOH0w.png" /></figure><h4>Collector logs</h4><pre>kubectl -n otel-demo logs deploy/otel-collector --tail=50</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3jpFhDvKy5xtbNNhwtLug.png" /><figcaption>Checking OTel Collector logs to confirm successful export to Honeycomb.</figcaption></figure><h3>8. Check Honeycomb.io for Data</h3><p>After a few seconds, visit Honeycomb UI.</p><p>You will see:</p><ul><li>Traces</li><li>Spans</li><li>Metrics</li><li>Service Map</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XYNHRtBK0stCa-RCsciA2Q.png" /><figcaption>Honeycomb showing live traces collected from the OpenTelemetry Demo application.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e6CsXhOfgAWdtzicVcwUmQ.png" /><figcaption>Observed logs flowing into Honeycomb from Kubernetes workloads.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7OrycppesD3WYvFnUHAYKg.png" /><figcaption>Honeycomb’s powerful query and exploration interface used for analyzing telemetry data.</figcaption></figure><h3>9. Install MCP Server in VS Code</h3><p>MCP enables Honeycomb access <strong>directly inside VS Code Chat</strong>.</p><h3>Steps:</h3><ul><li>Open VS Code</li><li>Press Ctrl+Shift+P</li><li>Search: <strong>MCP: Add Server</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*N0_IMJ2VWDZK-zK4znyrsQ.png" /><figcaption>Adding the Honeycomb MCP server in VS Code through the command palette.</figcaption></figure><ul><li>Enter: <a href="https://mcp.honeycomb.io/mcp"><strong>https://mcp.honeycomb.io/mcp</strong></a></li><li>Browser opens → Authorize (read + write)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dR9-y1bVd6qh1SplS2_2dg.png" /><figcaption>Honeycomb MCP server authorization screen requesting read/write access.</figcaption></figure><ul><li>Back in VS Code → Run: <strong>MCP: List Server</strong></li><li>You should see: <strong>mcp-honeycomb (running)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*YzAY7oG98Q-PaLiQ2RG1NA.png" /><figcaption>VS Code showing Honeycomb MCP server successfully connected and running.</figcaption></figure><ul><li>Open Chat → Select Agent → Tools → honeycomb-mcp</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/760/1*Vc2LqmtrxIsOtlFa1qUckw.png" /><figcaption>Selecting Honeycomb MCP as a tool within VS Code’s AI chat interface.</figcaption></figure><h3>10. Test MCP Prompts</h3><p>Now ask anything!</p><h3>Example Prompts:</h3><ul><li><strong>List all datasets</strong></li><li><strong>Run a query for slow traces</strong></li><li><strong>Top 10 slowest operations</strong></li><li><strong>Find checkout service latency</strong></li><li><strong>Show traces for a user flow</strong></li><li><strong>Show high error-rate services</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*DJKfRopvCkc1VMKu1-uyYQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*w6ehI3bpau5JWqc7-bJxEA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/1*fJgqVoBlCiaz_IeRBRRljg.gif" /><figcaption>Using VS Code’s AI Agent with the Honeycomb MCP integration — running a natural-language query (“list all data”) inside the agent chat interface.</figcaption></figure><h3>Conclusion</h3><p>With this setup, you now have:</p><ul><li>FULL observability using Honeycomb</li><li>OpenTelemetry Demo running on KIND</li><li>Secure API key handling in Kubernetes</li><li>VS Code MCP integration for interactive queries</li></ul><p>This is a complete end-to-end <strong>AI + Observability</strong> workflow.</p><h3>🌐 GitHub Repo</h3><p><a href="https://github.com/rushi2828/ai-observability-honeycomb-mcp-kind">https://github.com/rushi2828/ai-observability-honeycomb-mcp-kind</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a640036e4b05" width="1" height="1" alt=""><hr><p><a href="https://blog.devops.dev/ai-assisted-observability-honeycomb-mcp-opentelemetry-on-kubernetes-a640036e4b05">AI-Assisted Observability: Honeycomb + MCP + OpenTelemetry on Kubernetes</a> was originally published in <a href="https://blog.devops.dev/">DevOps.dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Production-Grade Secrets Integration for EKS Using External Secrets Operator]]></title>
            <link>https://blog.devops.dev/production-grade-secrets-integration-for-eks-using-external-secrets-operator-0313f7ae3ed9?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/0313f7ae3ed9</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[aws-eks]]></category>
            <category><![CDATA[external-secrets-operator]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Sat, 16 Aug 2025 16:53:36 GMT</pubDate>
            <atom:updated>2026-05-21T08:39:13.701Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Securely manage Kubernetes secrets at scale with AWS Secrets Manager, ESO, and modular Terraform</blockquote><h3>🧭 Introduction</h3><p>Managing secrets in Kubernetes is notoriously tricky. Kubernetes Secrets are only <strong>base64-encoded</strong> — not encrypted — making them vulnerable by default.</p><p>Enter <strong>External Secrets Operator (ESO)</strong>: a Kubernetes controller that pulls secrets securely from external backends like AWS Secrets Manager, HashiCorp Vault, or Azure Key Vault, and syncs them into native Kubernetes Secrets.</p><p>In this guide, you’ll learn how to <strong>automate the provisioning of an AWS EKS cluster integrated with ESO</strong> using modular Terraform infrastructure. This ensures your secrets are handled securely and your infrastructure remains <strong>scalable, reproducible, and production-ready</strong>.</p><p>👉 Source code available on GitHub: <a href="https://github.com/rushi2828/eso-aws-secret-eks-terraform">eso-aws-secret-eks-terraform</a></p><h3>🔍 Why Use External Secrets Operator on EKS?</h3><ul><li>✅ <strong>No more manual secret syncing</strong> into Kubernetes.</li><li>🔐 <strong>Secure storage and versioning</strong> via AWS Secrets Manager.</li><li>🔁 <strong>Automatic secret sync and rotation</strong>.</li><li>🔒 <strong>IAM Roles for Service Accounts (IRSA)</strong> to follow least privilege.</li><li>📦 <strong>Fully declarative</strong>, version-controlled, infrastructure-as-code setup.</li></ul><h3>📦 Project Overview &amp; Structure</h3><p>To keep the infrastructure modular, maintainable, and production-friendly, the Terraform code is organized like so:</p><pre>eso-aws-secret-eks-terraform/<br>├── main.tf<br>├── providers.tf<br>├── backend.tf<br>├── variables.tf<br>├── outputs.tf<br>├── terraform.tfvars<br>├── modules/<br>│   ├── vpc/<br>│   ├── eks/<br>│   ├── irsa/<br>│   └── eso/<br>├── bootstrap/<br>│   └── s3_backend.tf<br>└── k8s-resources/<br>    ├── secret-store.yaml<br>    └── external-secret.yaml</pre><h3>📁 What Each Module Does<strong>Module responsibilities:</strong></h3><ul><li><strong>VPC</strong> → Networking (subnets, NAT, route tables, IGW)</li><li><strong>EKS</strong> → Cluster + managed node groups</li><li><strong>IRSA</strong> → IAM Role for Service Accounts (ESO access to Secrets Manager)</li><li><strong>ESO</strong> → Helm deployment of ESO with IAM-enabled service account</li><li><strong>k8s-resources</strong> → ESO manifests (SecretStore + ExternalSecret)</li></ul><h3>🚀 Step-by-Step Guide</h3><h4>🔑 Step 1: Bootstrap Terraform Remote State</h4><p>Store Terraform state in an <strong>S3 bucket</strong>, with <strong>DynamoDB </strong>for<strong> state locking</strong> to prevent concurrent updates. This ensures <strong>team-safe state management</strong> in CI/CD pipelines.</p><pre>cd bootstrap<br>terraform init<br>terraform apply -auto-approve</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-OxwD5itmj-ezZQjS7OsGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aHpP-7AXZmMrXbyDeZtL7w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v1PfkpmPh3ZQruI9L2MFog.png" /></figure><h4>🛠️ Step 2: Deploy the EKS Cluster and Infrastructure</h4><p>From the project root, deploy the full stack:</p><pre>cd ..<br>terraform init<br>terrafrom plan<br>terraform apply -auto-apply</pre><blockquote>Terraform provisions (approx. 20–25 min total):<br>- The <strong>VPC</strong>, <strong>subnets</strong>, <strong>NAT</strong>, and <strong>route tables</strong> (~5–7 min)<br>- <strong>EKS</strong> cluster and managed node groups (~10–15 min)<br>-<strong> IRSA</strong> IAM role for ESO (few seconds)<br>- <strong>Helm </strong>release for <strong>External Secrets Operation</strong> (1–2 min)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1YkSC_sNcXFdZjcNfsv2BQ.png" /><figcaption>terraform plan</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AhL7D0Zlra1vTkPEcR7GmA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rxdqqTvmsrLzjCZhVtNG_Q.png" /><figcaption>VPC</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gs-hj5uv0LGCkY8XBc3Qpw.png" /><figcaption>EKS cluster</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*sgoCR-YvC53AtSjjdnvOsw.png" /></figure><h4>📡 Step 3: Access the Cluster via kubectl</h4><p>Update your kubeconfig to talk to the new EKS cluster:</p><pre>aws eks --region ap-south-1 update-kubeconfig --name prod-eks-cluster<br>kubectl get nodes<br>kubectl get pods -A</pre><blockquote>Look for ESO pods under the <strong>external-secrets</strong> namespace.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FW4Gg07NSpPcVXwrpJvWVw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9P9X6z4o5jwQNtPqvoXvg.png" /></figure><h4>🔑 Step 4: Create Secret in AWS Secrets Manager</h4><p>Before applying the ExternalSecret manifest, create a secret in AWS Secrets Manager. This is the secret that will be synced to Kubernetes by External Secrets Operator (ESO).</p><pre>aws secretsmanager create-secret \<br>  --name demo/eks-external-secret \<br>  --secret-string &#39;{&quot;username&quot;:&quot;admin&quot;,&quot;password&quot;:&quot;rushi@123&quot;}&#39; \<br>  --region ap-south-1</pre><blockquote>--name → Path/name of the secret (demo/external-secret).<br>--secret-string → JSON key-value pair that will be synced into K8s.<br>--region → Must match your cluster’s region (e.g., ap-south-1).<br>✅ Now, when you apply the ExternalSecret, it will fetch this secret from AWS Secrets Manager and create a Kubernetes Secret.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CC6VyS56f4m53VARBEaI2A.png" /><figcaption>Secret</figcaption></figure><h4>🔄 Step 5: Apply External Secrets Manifests</h4><p>Two YAML files define the ESO → AWS Secrets Manager connection and which secrets to sync:</p><pre>kubectl apply -f k8s-resources/secret-store.yaml<br>kubectl apply -f k8s-resources/external-secret.yaml</pre><blockquote>secret-store.yaml: Defines <strong>ESO&#39;s</strong> backend (<strong>AWS Secrets Manager</strong>) using <strong>IRSA</strong><br>external-secret.yaml: Specifies which <strong>secret(s)</strong> to pull and map to <strong>Kubernetes.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mWPhwE0moKB-g829F0aiLA.png" /></figure><h3>⚙️ How It Works — In Simple Terms</h3><ol><li><strong>ESO controller runs inside your cluster.</strong></li><li>It uses an <strong>IAM Role via IRSA</strong> to securely authenticate with AWS Secrets Manager.</li><li><strong>ExternalSecret CRDs</strong> define which secrets to fetch and how to map them into Kubernetes.</li><li><strong>Secrets are synced</strong>, automatically and securely, into native K8s Secrets.</li><li><strong>Applications consume Kubernetes Secrets</strong>, unaware of their origin.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wgSi5xt81oVQI6DHrJdZpA.png" /></figure><h3>🔍 Verifying the Secret Sync</h3><p>Once your ExternalSecret is deployed, check the resulting Kubernetes Secret:</p><pre>kubectl get secrets<br>kubectl describe secret synced-secret</pre><blockquote>It should contain the <strong>keys/values</strong> pulled from <strong>AWS Secrets Manager.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*3RHHLTWmC8IfR88To1KGNw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g39Sgf8QQxM6-1HuML0ETA.png" /></figure><h3>🧹 Clean up</h3><p>To remove all resources:</p><pre>terraform destroy -auto-approve</pre><blockquote><strong>This will delete:</strong><br>- <strong>EKS</strong> cluster and worker nodes<br>- <strong>VPC</strong> and networking<br>- <strong>IAM</strong> roles and <strong>Helm </strong>releases<br>- <strong>ESO</strong> resources and <strong>K8s manifests</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0313f7ae3ed9" width="1" height="1" alt=""><hr><p><a href="https://blog.devops.dev/production-grade-secrets-integration-for-eks-using-external-secrets-operator-0313f7ae3ed9">Production-Grade Secrets Integration for EKS Using External Secrets Operator</a> was originally published in <a href="https://blog.devops.dev/">DevOps.dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering GitOps with ArgoCD App of Apps Pattern: Deploying Guestbook & 2048 Game using KIND]]></title>
            <link>https://medium.com/@rushimane2606/mastering-gitops-with-argocd-app-of-apps-pattern-deploying-guestbook-2048-game-using-kind-024ccac95353?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/024ccac95353</guid>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Sun, 03 Aug 2025 07:47:14 GMT</pubDate>
            <atom:updated>2025-08-03T07:47:14.851Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8LxIDs_ZKuKp6woZ2R1cTg.png" /></figure><blockquote>Are you looking to streamline your Kubernetes application deployments using GitOps best practices? The ArgoCD App of Apps pattern is a powerful approach that helps you declaratively manage multiple applications at scale. In this tutorial, we’ll walk through a real-world example: deploying two demo apps — Guestbook and 2048 Game — in a KIND (Kubernetes IN Docker) cluster using the awesome <a href="https://github.com/rushi2828/argocd-app-of-apps">rushi2828/argocd-app-of-apps</a>.</blockquote><h3>🚀 What is the App of Apps Pattern?</h3><p>The App of Apps pattern is an architecture strategy in ArgoCD where a “parent” App manages other “child” App resources. Each child App can represent a complete service or feature, possibly pointing to different Helm charts or Git repositories. This pattern is ideal for multi-app and multi-team Kubernetes environments.</p><h3>🏗️ Project Structure</h3><p>Here’s an overview of the project directory you’ll be working with:</p><p>argocd-app-of-apps/<br>├── charts/<br>│ └── argocd/ # ArgoCD Helm chart (custom overrides)<br>├── apps/<br>│ ├── guestbook-app.yaml # ArgoCD Application for Guestbook (Helm)<br>│ └── 2048-game-app.yaml # ArgoCD Application for 2048 game<br>├── kind-config/<br>│ └── kind-config.yaml # KIND cluster config<br>└── README.md</p><p><em>Notice: Each application (like Guestbook) is deployed into its own dedicated namespace. For example, the Guestbook app uses the </em><em>guestbook namespace, which keeps its resources isolated and organized.</em></p><h3>📦 Prerequisites</h3><ul><li>Docker installed.</li><li>kubectl, kind &amp; helm installed.</li></ul><h3>📋 Step-by-Step Guide</h3><p>1. Create a KIND Cluster</p><p>kind create cluster --name argocd-demo --config ./kind-config/kind-config.yaml</p><p>2. Create the ArgoCD Namespace</p><p>kubectl create namespace argocd</p><p>3. Build and Install ArgoCD via Helm</p><p>helm dependency build charts/argocd</p><p>helm install argocd charts/argocd/ -n argocd</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xj6truEP0WJqSA7YKhYdmQ.png" /></figure><p>4. Deploy the Applications</p><p>kubectl -n argocd apply -f apps/guestbook-app.yaml<br>kubectl -n argocd apply -f apps/2048-game-app.yaml</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y-hro3luuU-7R6JOluZ2Gw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QaqLQFfNZR0N736xFrFSBw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tTHTYjLwaUS5D2pv9y48Ow.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xYAI7e6RAwCFvOfJjbclaw.png" /></figure><h3>🔐 Accessing ArgoCD</h3><p>Get Admin Password:</p><p>kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath=”{.data.password}” | base64 -d &amp;&amp; echo</p><p>Port Forward the ArgoCD UI:</p><p>kubectl port-forward svc/argocd-server -n argocd 8090:443</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UfC6xFew7RyGBYZv34Bg_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1qeTeNbVL03NMaNqfD1rEA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2LX930EgC2SKSb7mu0YDhw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*enT18WJ4HTDRfQFAbkULfw.png" /></figure><h3>🎮 Accessing Your Deployed Apps</h3><h4>Guestbook:</h4><p>kubectl port-forward svc/guestbook 80:80 -n guestbook</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jV48qWY3Uc0o3jGkna09ug.png" /></figure><h4>2048 Game:</h4><p>kubectl port-forward svc/game-2048 85:80 -n 2048-game</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5iKvB2RbS_AQ-T14Bc13Xw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=024ccac95353" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ingress Controller on kind Cluster: Route Multiple Local Services Through One NGINX Ingress]]></title>
            <link>https://medium.com/@rushimane2606/ingress-controller-on-kind-cluster-route-multiple-local-services-through-one-nginx-ingress-607875fef8e9?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/607875fef8e9</guid>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Wed, 23 Jul 2025 12:17:37 GMT</pubDate>
            <atom:updated>2025-07-24T05:46:35.845Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BJpW5BGMi6rhgA0-" /></figure><blockquote><strong>Fast, reproducible local Kubernetes ingress for multi-service apps<br></strong>In this hands-on guide, you’ll stand up a local <a href="https://kind.sigs.k8s.io/"><strong><em>kind </em></strong></a>Kubernetes cluster, install the NGINX Ingress Controller, deploy three sample apps (app1, app2, app3), and route clean host-based URLs like <strong>`http://demo.local/app1`</strong> through a single ingress resource. Along the way you’ll learn the <strong>minimum YAML you need</strong>, common <strong>gotchas</strong>, and <strong>troubleshooting tips </strong>from real-world DevOps work.</blockquote><blockquote><em>✅ GitHub Repo: </em><a href="http://rushi2828/ingress-controller-on-kind-cluster"><em>rushi2828/ingress-controller-on-kind-cluster</em></a></blockquote><p><strong>Why Run an Ingress Controller on kind?</strong></p><p>If you’re building microservices or testing Kubernetes networking locally, you quickly run into the “how do I hit my service?” problem. NodePorts work but are clunky. Port-forwarding doesn’t scale to multiple services. An <strong>Ingress Controller</strong> lets you expose many HTTP(S) services behind a single endpoint — *exactly* how you’d do it in production — right on your laptop.</p><p><strong>With this setup you get:</strong></p><ul><li>A realistic ingress layer that mirrors production patterns.</li><li>One localhost domain (demo.local) mapped to multiple backend services.</li><li><strong>Path-based routing</strong>:<br><a href="https://demo.local/app1">https://demo.local/app1</a><br><a href="https://demo.local/app2">https://demo.local/app2</a><br><a href="https://demo.local/app3">https://demo.local/app3</a></li><li><strong>TLS enabled with mkcert</strong> for local HTTPS testing.</li><li>A great foundation for Helm, GitOps, and CI demos.</li></ul><p><strong>Key pieces:</strong></p><ul><li><strong>kind cluster</strong> with hostPort mappings so traffic on your laptop’s 80/443 reaches the cluster.</li><li><strong>NGINX Ingress Controller</strong> deployed.</li><li><strong>Three sample deployments + services</strong> (ClusterIP) for app1, app2, app3.</li><li><strong>One Ingress resource</strong> with path rules mapping /app1, /app2, /app3.</li><li><strong>/etc/hosts </strong>entry mapping demo.local to 127.0.0.1.</li></ul><h3>Prerequisites</h3><p>Make sure you have these installed <strong>before</strong> starting:</p><p><strong>Docker </strong>: Latest Desktop / Engine docker.com<br><strong>kind</strong>: v0.23+ recommended<br><strong>kubectl </strong>Match your desired Kubernetes minor version</p><p>Confirm they’re on your PATH:<br>docker --version<br>kind --version<br>kubectl version --client</p><h3>Step 1. Create a kind Cluster with Port Mapping</h3><p>We need host-to-cluster port mappings for HTTP (80) and HTTPS (443) so that hitting http://demo.local on your laptop forwards into the cluster.</p><p>Create kind-config.yaml</p><pre>kind: Cluster<br>apiVersion: kind.x-k8s.io/v1alpha4<br>nodes:<br>  - role: control-plane<br>    extraPortMappings:<br>      - containerPort: 80   # for HTTP<br>        hostPort: 80<br>        protocol: TCP<br>      - containerPort: 443  # for HTTPS<br>        hostPort: 443<br>        protocol: TCP</pre><p>Create the cluster:</p><p>kind create cluster --name ingress-demo --config kind-config.yaml</p><p>Verify:</p><p>kind get clusters<br>kubectl get nodes</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4OC9gP_W_b0rfIM9" /></figure><h3>Step 2. Install the NGINX Ingress Controller for kind</h3><p>The NGINX Ingress project publishes a provider-optimized manifest tuned for kind networking. Apply it directly:</p><p>kubectl apply -f <a href="https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.10.1/deploy/static/provider/kind/deploy.yaml">https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.10.1/deploy/static/provider/kind/deploy.yaml</a></p><p>This creates:</p><ul><li>Namespace: ingress-nginx</li><li>Deployment: ingress-nginx-controller</li><li>Service: ingress-nginx-controller (NodePort / internal wiring for kind)</li><li>RBAC, admission webhooks, etc.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FQSTbaa-HvSjBen9" /></figure><h3>Step 3. Build, Tag &amp; Push Your App Images</h3><p>For the demo we’ll deploy three tiny containerized web apps that each return a distinct response so you can see routing working.</p><p>docker build -t app1-img ./app1<br>docker tag app1-img rushi2323/app1-img:latest<br>docker push rushi2323/app1-img:latest</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hqGzAsOI5LCH1JJE" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L61Y2PQHUNRf1a-a" /></figure><h3>Step 4. Map a Local Hostname (/etc/hosts)</h3><p>We’ll reach the ingress via a friendly domain: demo.local.</p><p>Append this to your <strong>host</strong> machine’s /etc/hosts (Linux/macOS) or C:\\Windows\\System32\\drivers\\etc\\hosts (Windows):</p><p>127.0.0.1 demo.local</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/0*_z_z_V2X-K5cObYk" /></figure><p>Test name resolution:</p><p>ping -c1 demo.local || nslookup demo.local</p><p><em>🔐 *Corporate laptop with admin controls?* You may need elevated privileges to edit hosts.</em></p><h3>Step 5. Deploy the Demo Apps (Deployments + Services)</h3><p>Let’s create Kubernetes manifests that spin up one replica per app and expose each internally via a ClusterIP Service.</p><p>Example: app1-deployment.yaml</p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: app1-deployment<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: app1<br>  template:<br>    metadata:<br>      labels:<br>        app: app1<br>    spec:<br>      containers:<br>        - name: app1<br>          image: rushi2323/app1-img:latest<br>          ports:<br>            - containerPort: 80<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: app1-service<br>spec:<br>  selector:<br>    app: app1<br>  ports:<br>    - port: 80<br>      targetPort: 80</pre><p>kubectl apply -f ./k8s/app1-deployment.yaml<br>kubectl get all</p><p>Expected output (sample):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WiLtieJh_F1wm-cV" /></figure><h3>Step 6. Create Ingress Resources</h3><p>Now wire HTTP paths to services using NGINX Ingress. Create k8s/ingress.yaml:</p><pre>apiVersion: networking.k8s.io/v1<br>kind: Ingress<br>metadata:<br>  name: app-ingress<br>  annotations:<br>    nginx.ingress.kubernetes.io/rewrite-target: / <br>spec:<br>  ingressClassName: nginx<br>  rules:<br>    - host: demo.local<br>      http:<br>        paths:<br>          - path: /app1<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: app1-service<br>                port:<br>                  number: 80<br>          - path: /app2<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: app2-service<br>                port:<br>                  number: 80<br>          - path: /app3<br>            pathType: Prefix<br>            backend:<br>              service:<br>                name: app3-service<br>                port:<br>                  number: 80</pre><p>kubectl apply -f k8s/ingress.yaml<br>kubectl get ingress -o wide</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9cMWlQ0gHg-zOIp1" /></figure><p><em>💡 ADDRESS may show an internal cluster IP or `localhost` — that’s OK. Because we mapped host ports in the kind config, traffic will still flow.</em></p><h3>Step 7. Verify Routing</h3><p>Open in browser:</p><ul><li><a href="http://demo.local/app1">http://demo.local/app1</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UK3kMKT1ysKyuQlb" /></figure><ul><li><a href="http://demo.local/app2">http://demo.local/app2</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Mhtdit2VJfqeQ7-K" /></figure><ul><li><a href="http://demo.local/app3">http://demo.local/app3</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Kneim9Dmc45n5xLp" /></figure><h3><strong>Add TLS (Self-Signed)</strong></h3><p>Want to simulate HTTPS locally? Create a self-signed cert and Kubernetes Secret, then update the Ingress.</p><p>Generate cert by <strong>mkcert:</strong></p><p>brew install mkcert # Mac<br>choco install mkcert # Windows (via Chocolatey)</p><p>mkcert -install<br>mkcert demo.local</p><p>Create secret:</p><p>kubectl create secret tls demo-local-tls — cert=demo.local.pem — key=demo.local-key.pem -n default</p><p>Patch ingress (add `tls:`):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/402/1*iWiOUl-1_fsRRd27E1w_QQ.png" /></figure><p><strong>Ingress YAML with TLS Working (Kind + NGINX)</strong></p><pre>apiVersion: networking.k8s.io/v1<br>kind: Ingress<br>metadata:<br>  name: app-ingress<br>  namespace: default<br>  annotations:<br>    nginx.ingress.kubernetes.io/rewrite-target: /$2<br>spec:<br>  ingressClassName: nginx<br>  tls:<br>    - hosts:<br>        - demo.local<br>      secretName: demo-local-tls<br>  rules:<br>    - host: demo.local<br>      http:<br>        paths:<br>          - path: /app1(/|$)(.*)<br>            pathType: ImplementationSpecific<br>            backend:<br>              service:<br>                name: app1-service<br>                port:<br>                  number: 80<br>          - path: /app2(/|$)(.*)<br>            pathType: ImplementationSpecific<br>            backend:<br>              service:<br>                name: app2-service<br>                port:<br>                  number: 80<br>          - path: /app3(/|$)(.*)<br>            pathType: ImplementationSpecific<br>            backend:<br>              service:<br>                name: app3-service<br>                port:<br>                  number: 80</pre><p>Re-apply and test:</p><p><a href="https://demo.local/app1">https://demo.local/app1</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iPPuSYACZT7vazPxJ-erbA.png" /></figure><p>https://demo.local/app2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D78aL-i2CemPF2zphD4vlQ.png" /></figure><p><a href="https://demo.local/app2">https://demo.local/app</a>3</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D6yxbNj_G_eRsh2cWLya6A.png" /></figure><h3><strong>Troubleshooting &amp; Common Errors</strong></h3><p><strong>1. </strong><strong>` — nanme` Typo When Creating Cluster</strong></p><p>If you see <strong><em>unknown flag: — nanme</em></strong>, re-run:</p><p>kind create cluster — name ingress-demo — config kind-config.yaml</p><p>2. <strong>Ingress API Version / Unmarshal Error</strong></p><p><strong>**Error:**</strong></p><p>Error from server (BadRequest): error when creating &quot;./k8s/ingress.yaml&quot;: Ingress in version &quot;v1&quot; cannot be handled as a Ingress: json: cannot unmarshal object into Go struct field IngressSpec.spec.rules of type []v1.IngressRule</p><p><strong>Fix:</strong> Your YAML structure is likely wrong—spec.rules must be a <strong>list</strong>. Make sure you have - host: under rules: and - path: under http.paths:.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/566/1*3hj33YF6AON9pis_MNsNaw.png" /></figure><p><strong>3. Blank Page / 404 from NGINX</strong></p><p>Possible causes:<br>- Hostname mismatch (didn’t set demo.local in Ingress <strong><em>and</em></strong> /etc/hosts).<br>- Path mismatch (curl /app1/ vs /app1). Try both.<br>- Pod image pull issues (check kubectl describe pod`).</p><p><strong>4. Connection Refused on Port 80</strong></p><p>If curl <a href="http://demo.local`/">http://demo.local</a> hangs or fails:</p><ul><li>Did you map hostPort: 80 in kind-config.yaml <strong>before</strong> creating the cluster? (Requires cluster recreate.)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/385/1*06VEkfvogdZ2EuJYCvUrzA.png" /></figure><p>- Is Docker Desktop blocking low ports on macOS/Windows? Try alternate ports (e.g., host 8080→container 80) and update `/etc/hosts` + test URL.</p><p><strong>5. Wrong Container Image Tag</strong></p><p>If Pods stuck in ImagePullBackOff and you’re using local builds, confirm you loaded them:</p><p>kind load docker-image rushi2323/app1-img:latest --name ingress-demo</p><p>Or change the Deployment image to one in a public registry.</p><h3><strong>Clean Up</strong></h3><p>When you’re done experimenting:</p><pre>kind delete cluster --name ingress-demo</pre><p>This removes the kind cluster and all Kubernetes objects.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=607875fef8e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Ansible on Ubuntu EC2 (AWS)]]></title>
            <link>https://medium.com/@rushimane2606/getting-started-with-ansible-on-ubuntu-ec2-aws-c4dd8bf144e4?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4dd8bf144e4</guid>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Fri, 11 Jul 2025 16:09:14 GMT</pubDate>
            <atom:updated>2025-07-11T16:09:14.636Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fbKaipFDrvvpbNFVdbqwPw.png" /></figure><blockquote>Setting up Ansible in a secure and production-ready way is crucial for managing infrastructure at scale. In this guide, you’ll learn how to configure <strong>SSH key-based authentication</strong> on <strong>AWS EC2 instances</strong> and use <strong>Ansible</strong> to automate tasks across multiple servers.</blockquote><h3>Section 1: Launch EC2 Instances on AWS</h3><h4>Step 1.1: Launch 5 Ubuntu EC2 Instances</h4><ul><li>Go to <strong>AWS EC2 → Instances → Launch Instances</strong></li><li>Use the <strong>Ubuntu Server 20.04 LTS</strong> AMI</li><li>Choose <strong>t2.micro</strong> (Free Tier)</li><li>Create the following instances:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8Sjqjjw9OkdNmfrL.png" /></figure><h3>Section 2: Enable Password-Based SSH Access on All EC2 Ubuntu Instances</h3><blockquote>In this section, we’ll configure all 5 EC2 Ubuntu instances (1 Master/Ansible Controller, 4 Slaves) to support password-based SSH login.</blockquote><p><strong>Step 2.1: Connect to Each EC2 Instance</strong></p><p>Use your .pem key file to connect to each EC2 instance using <strong>MobaXterm</strong> or any terminal of your choice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*pm9QWN_AIon5y-GQMG0abw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jtrSK5UaU_H7LY4-.png" /></figure><h4>Step 2.2: Set a Password for the Ubuntu User</h4><p>Run the following command on each instance <strong>after connecting via SSH</strong>:</p><pre>sudo passwd ubuntu</pre><p>You’ll be prompted to enter a new password. Choose a strong one — for example MySecurePass123.This allows the ubuntu user to log in with a password.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*347qQhXkY5mYle9R.png" /></figure><h4>Step 2.3: Enable Password Authentication in SSH Config</h4><p>Edit the SSH configuration file /etc/ssh/sshd_config and uncomment or update the following lines to allow password-based logins.</p><pre>PermistRootLogin yes<br>PasswordAuthentication yes </pre><p>and save the file with :wq</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Tg-heGNsn6wDNyr2.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cnInnidlxCTVZsfR.png" /></figure><p>Also edit the /etc/ssh/sshd_config.d/60-clouding-settings.conf file and uncomment following line</p><pre>PasswordAuthentication yes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ockAK1bqOQvvOUVO.png" /></figure><h4>Step 2.4: Restart SSH Service</h4><p>Apply the configuration:</p><pre>sudo systemctl restart ssh<br>sudo systemctl status ssh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GMWWnyy9Pp7lcFNY.png" /></figure><h3>Section 3: Install Ansible on Ubuntu (Control Node / Master)</h3><blockquote>In this section, we’ll install Ansible on the <strong>Ubuntu-based control node (Ansible Master)</strong>. These steps work on AWS EC2, local VMs, or cloud platforms like GCP, Azure, etc.</blockquote><h4>Step 3.1: Update System Packages</h4><p>Always start by updating your package lists by command :</p><pre>sudo apt update &amp;&amp; sudo apt upgrade -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kX7b-FdeGYL2d0jE.png" /></figure><h4>Step 3.2: Add the Ansible PPA</h4><p>Ansible is not available in Ubuntu’s default repo in the latest version, so add its official PPA:</p><pre>sudo apt-add-repository --yes --update ppa:ansible/ansible</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rCj3t_G2MVTLABCN.png" /></figure><h4>Step 3.3: Install Ansible</h4><p>Now install Ansible:</p><pre>sudo apt install ansible -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vNiPwFLxSBuCNT0W.png" /></figure><h4>Step 3.4: Verify Ansible Installation</h4><p>Check if Ansible is installed correctly:</p><pre>ansible --version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*blG07jaMyDU2Nc1Q.png" /></figure><h3>Step 4: Update Ansible Hosts File on the Master Node</h3><blockquote>Ansible uses a file called the <strong>inventory file</strong> (usually at /etc/ansible/hosts) to define the list of servers it will manage.</blockquote><h4>Step:4.1 Command to Edit Hosts File</h4><pre>sudo vim /etc/ansible/hosts</pre><h4>Step:4.2 Add the private ip address of worker nodes</h4><pre>[test]<br>private-ip-address-of-Test1<br>private-ip-address-of-Test1<br><br>[dev]<br>private-ip-address-of-Dev1<br>private-ip-address-of-Dev2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/0*dJ-_dzw08PyjRJBa.png" /></figure><h3>Step 5: Using ssh-keygen for Passwordless SSH Access (Recommended for Production)</h3><blockquote>While password-based SSH is quick for small demos, production environments require <strong>secure, scalable, and automation-friendly</strong> authentication. Using ssh-keygen to set up <strong>passwordless SSH</strong> is the best practice</blockquote><h4>Step 5.1: Generate SSH Key Pair on Ansible Master</h4><p>On your <strong>Ansible Master EC2 instance</strong>, generate a new SSH key:</p><pre>ssh-keygen</pre><ul><li>Press Enter for all prompts to use default path (/home/ubuntu/.ssh/id_rsa)</li><li>Leave passphrase <strong>empty</strong> (just press Enter)</li></ul><p>This creates:</p><ul><li>Public key: /home/ubuntu/.ssh/id_<a href="http://rsa.pub/">rsa.pub</a></li><li>Private key: /home/ubuntu/.ssh/id_rsa</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/0*I7gkUFf4V2kNVnoC.png" /></figure><h4><strong>Step 5.2: Copy SSH Key to Worker Nodes Using Private IPs</strong></h4><ul><li>Now that your key pair is generated on the Ansible Master, copy the <strong>public SSH key</strong> to each worker node using their <strong>private IP addresses</strong>.</li><li>Run the following commands on your Ansible Master:</li></ul><pre>ssh-copy-id root@&lt;Private-IP-of-Test1&gt;<br>ssh-copy-id root@&lt;Private-IP-of-Test2&gt;<br>ssh-copy-id root@&lt;Private-IP-of-Dev1&gt;<br>ssh-copy-id root@&lt;Private-IP-of-Dev2&gt;</pre><ul><li>When prompted, type yes to accept the host fingerprint.</li><li>Enter the root password you set earlier in <strong>Step 2.2 (</strong>MySecurePass123<strong>)</strong></li><li>This will append your public key to each slave’s ~/.ssh/authorized_keys file, allowing password less SSH from the master.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mDnoWXq2KKHSiOMR.png" /></figure><h4><strong>Step 5.2: Verify SSH Connectivity Using Ansible Ping</strong></h4><ul><li>Once you’ve configured the Ansible inventory and ensured passwordless SSH access to all worker nodes, it’s time to verify that Ansible can connect to all servers using the ping module.</li><li>Run the following command on your <strong>Ansible Master</strong>:</li></ul><pre>ansible all -m ping -u root</pre><blockquote>🔹 all: Refers to all hosts listed in your inventory (/etc/ansible/hosts by default)<br>🔹 -m ping: Uses Ansible&#39;s built-in ping module to test connection<br>🔹 -u root: Specifies that Ansible should use the root user to connect (optional)</blockquote><p><strong>Step 5.3 Expected Output (Success)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v67VkrEtYqPgPMJk.png" /></figure><h3>Step 6: Run a Sample Ansible Playbook</h3><blockquote>This Ansible playbook is designed to test the connection and automation setup by installing two packages — <strong>maven</strong> and <strong>htop</strong> — on all hosts under the [test] group defined in the inventory.</blockquote><p><strong>Step 6.1 Create sample-playbook.yaml</strong></p><pre>---<br>- name: Install maven and htop<br>  hosts: test<br>  become: true<br>  tasks:<br>    - name: Install maven<br>      package:<br>        name: maven<br>        state: present<br><br>    - name: Install htop<br>      package:<br>        name: htop<br>        state: present<br>...</pre><p><strong>Step 6.2 Run sample playbook</strong></p><pre>ansible-playbook sample-playbbok.yaml</pre><p><strong>Step 6.3 Expected output</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pcqyBTFHbEZQZsJr.png" /></figure><p><strong>Step 6.4 Verify on any test worker/server</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/0*PELTF2u6xJDQdqb7.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4dd8bf144e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automate Your Spotify Playlists with Terraform: A Step-by-Step Guide]]></title>
            <link>https://medium.com/@rushimane2606/automate-your-spotify-playlists-with-terraform-a-step-by-step-guide-6b7842f489ea?source=rss-ed15c742f0cd------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b7842f489ea</guid>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Rushikesh Mane]]></dc:creator>
            <pubDate>Mon, 10 Feb 2025 12:53:16 GMT</pubDate>
            <atom:updated>2025-02-10T12:53:16.937Z</atom:updated>
            <content:encoded><![CDATA[<p>This project involves using Terraform to create and manage Spotify playlists automatically. By leveraging Terraform, you can streamline the process of playlist creation and management, making it more efficient and less time-consuming.</p><h3>Prerequisites:</h3><ol><li><a href="https://releases.hashicorp.com/terraform/">Terraform version 1.0+</a></li><li><a href="https://www.docker.com/">Docker</a></li><li><a href="https://developer.spotify.com/dashboard/login">Spotify account with developer access</a></li></ol><h3>Steps:</h3><ul><li>Create a project folder ‘Manage_Spotify_Terraform’ and open it in the VS Code editor.</li><li>Open Terraform and search for Spotify.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*yHQlc7iBlrGv631h" /></figure><ul><li>Create a file named provider.tf and add &#39;required_providers&#39; and &#39;provider&#39;.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/0*eOGmXoQoOBKmlsz4" /></figure><ul><li>Go to <a href="https://developer.spotify.com/dashboard">https://developer.spotify.com/dashboard</a>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*Bt-eryPmDjKnHuF0" /></figure><ul><li>Click Create app and fill in the details like App name and App description.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*mGTv6dNG2dL2fK5b" /></figure><ul><li>Add ‘https://localhost:27228/spotify_callback’ in the ‘Redirect URIs’ field.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*6b_ygSbF3LKLBkVL" /></figure><ul><li>Go to the newly created app settings, where you will get the Client ID and Client secret.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*TWI89wpEyDHwXQsC" /></figure><ul><li>Create a file named .env and add SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*DCynEotXTw8QHN3d" /></figure><ul><li>Execute the following Docker command to obtain the &#39;APIKEY&#39;:<br>$ docker run --rm -it -p 27228:27228 --env-file ./.env ghcr.io/conradludgate/spotify-auth-proxy</li><li>Reference: <a href="https://github.com/conradludgate/terraform-provider-spotify/tree/main/spotify_auth_proxy">https://github.com/conradludgate/terraform-provider-spotify/tree/main/spotify_auth_proxy</a></li></ul><blockquote>Note: For Windows users, please use the Bash terminal.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*pan-RcKLUHAOP0c3" /></figure><ul><li>Create a terraform.tfvars file and add api_key.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*zY4S70jdTmD1Le5k" /></figure><ul><li>Create a &#39;variables.tf&#39; file and define the variable &#39;api_key&#39;.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*9S7GDr1ntXezi3zl" /></figure><ul><li>Put &#39;api_key&#39; in &#39;provider.tf&#39;</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/0*05VKvSH23p-2xFpC" /></figure><ul><li>Run &#39;terraform init&#39;</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*1p-6CLFpp0WS7e97" /></figure><blockquote>Note: Make sure do not close this docker application</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*px_uPlcDbL461ob0" /></figure><ul><li>Add a &#39;playlist.tf&#39; file and include the resource “spotify_playlist”.</li></ul><p>Ref:<a href="https://registry.terraform.io/providers/conradludgate/spotify/latest/docs/resources/playlist">https://registry.terraform.io/providers/conradludgate/spotify/latest/docs/resources/playlist</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/0*wKh49-CFvmZPz3bb" /></figure><p>You can obtain the &#39;track ID&#39; from the Spotify app by searching for a song and locating the ID in the link, as illustrated in the image below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/0*H0AZDJuQNSj__x6h" /></figure><ul><li>Run &#39;terraform plan&#39; (if everything looks correct, it will display the plan)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*mxaVudCzUJOg3T8v" /></figure><ul><li>Run terraform apply -auto-approve to apply the changes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*zhrf8WZ_nO4FJdvJ" /></figure><ul><li>Please verify on <a href="https://open.spotify.com/playlist">https://open.spotify.com/playlist</a> that a playlist with two songs has been created.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*of5NoyRk6zVbLFJc" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b7842f489ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>