<?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 Zackky Muhammad on Medium]]></title>
        <description><![CDATA[Stories by Zackky Muhammad on Medium]]></description>
        <link>https://medium.com/@zackijack?source=rss-4a61a1c30b43------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*arEEKOT6R9Z30OTB7qbINA.jpeg</url>
            <title>Stories by Zackky Muhammad on Medium</title>
            <link>https://medium.com/@zackijack?source=rss-4a61a1c30b43------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 00:51:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zackijack/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[From Ingress to Gateway API: Turns Out We Were Still Doing It the Old Way]]></title>
            <link>https://medium.com/inside-kitabisa/from-ingress-to-gateway-api-turns-out-we-were-still-doing-it-the-old-way-ec203f230840?source=rss-4a61a1c30b43------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec203f230840</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[product-and-tech-kitabisa]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Zackky Muhammad]]></dc:creator>
            <pubDate>Mon, 26 May 2025 10:49:22 GMT</pubDate>
            <atom:updated>2025-05-26T10:49:22.505Z</atom:updated>
            <content:encoded><![CDATA[<p>At <a href="https://kitabisa.com/">Kitabisa.com</a>, we’ve been gradually transitioning from Kubernetes Ingress to Gateway API. We made the switch to unlock better flexibility, role separation, and long-term scalability. You can read more about our motivations in this post:</p><p><a href="https://medium.com/inside-kitabisa/migrating-from-kubernetes-ingress-to-gateway-api-at-kitabisa-why-we-made-the-switch-9b68754257b6">Migrating from Kubernetes Ingress to Gateway API at Kitabisa: Why We Made the Switch</a></p><p>But as it turns out — just because we <em>use</em> Gateway API, doesn’t mean we’re actually taking full advantage of it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tQqQUpIRQgc9OL5f0YE7fw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@4dgraphic?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Alexander Dummer</a> on <a href="https://unsplash.com/photos/baby-trying-to-get-out-of-his-crib-x4jRmkuDImo?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Unsplash</a></figcaption></figure><p>Before diving into what went wrong, let’s step back for a moment.</p><p>Gateway API introduces a more flexible and extensible model for handling traffic in Kubernetes. In our setup, we primarily work with three key resources:</p><ul><li><strong>GatewayClass — </strong>defines the controller implementation (e.g., Envoy, Cilium, Traefik)</li><li><strong>Gateway — </strong>configures the entry point for traffic into the cluster</li><li><strong>HTTPRoute — </strong>defines how traffic should be routed to services</li></ul><p>While Gateway API also supports other route types — like GRPCRoute, TCPRoute, and TLSRoute — our current use case only involves HTTPRoute. But the same architectural principles apply across all of them.</p><p>With that in mind, here’s what we realized during our implementation.</p><h3>Realization #1: We Were Still Using It Like Ingress</h3><p>As newcomers to Gateway API, our initial setup looked like this:</p><ul><li>We named our GatewayClass: envoy-gateway</li><li>We also named our Gateway: envoy-gateway</li><li>Developers pointed their HTTPRoute directly to parentRefs.name: envoy-gateway</li></ul><p>This is a very natural starting point — and it works. But it defeats one of the biggest strengths of Gateway API:<strong> clean separation between DevOps and developer roles</strong>.<strong> </strong>In the end, we were still using Gateway API like it was Ingress.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*nmJjuKt1GM3yrAzf.jpg" /></figure><h3>Realization #2: We Need to Decouple Developers from the Controller</h3><p>What happens if the DevOps team wants to migrate from Envoy Gateway to another controller like Cilium or Traefik? In our old setup, that would mean modifying every single HTTPRoute to point to a different Gateway. That’s a major operational burden — and defeats the purpose of role separation.</p><p>So we rethought our architecture.</p><h4>The New Pattern: Controller-Agnostic Gateway Definitions</h4><p>We now use Gateway API as it was truly intended:</p><ul><li>GatewayClass still points to the controller (envoy-gateway, cilium, traefik, etc.)</li><li>We create logical Gateways like stable and canary</li><li>Developers only point to parentRefs.[0].name: stable &amp; parentRefs.[1].name: canary</li><li>If we want to test or migrate controllers, we update the Gateway’s gatewayClassName — no need to touch any HTTPRoute</li></ul><p>This gives us:</p><ul><li>Freedom to switch controllers behind the scenes</li><li>A more maintainable and scalable architecture</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yishAqJmA_x_DSfhnJHunw.png" /></figure><p>With this model, DevOps can experiment confidently, and developers don’t have to worry about the underlying traffic plumbing — they just define their routes.</p><h3>Final Thoughts</h3><p>Gateway API is powerful — but transitioning from Ingress isn’t just about changing resources. It’s about adopting a new mindset. At Kitabisa, we’re still learning, but this shift in how we define Gateways has already paid off in flexibility and team independence.</p><p>If you’re also moving to Gateway API, it might be worth checking — are you still using it like Ingress too? 😅</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec203f230840" width="1" height="1" alt=""><hr><p><a href="https://medium.com/inside-kitabisa/from-ingress-to-gateway-api-turns-out-we-were-still-doing-it-the-old-way-ec203f230840">From Ingress to Gateway API: Turns Out We Were Still Doing It the Old Way</a> was originally published in <a href="https://medium.com/inside-kitabisa">Inside Kitabisa</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrating from Kubernetes Ingress to Gateway API at Kitabisa: Why We Made the Switch]]></title>
            <link>https://medium.com/inside-kitabisa/migrating-from-kubernetes-ingress-to-gateway-api-at-kitabisa-why-we-made-the-switch-9b68754257b6?source=rss-4a61a1c30b43------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b68754257b6</guid>
            <category><![CDATA[product-and-tech-kitabisa]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[Zackky Muhammad]]></dc:creator>
            <pubDate>Fri, 21 Mar 2025 09:11:04 GMT</pubDate>
            <atom:updated>2025-03-21T09:11:04.182Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y73ZENbf6zzKL4UmJUOI9w.png" /><figcaption>Ingress &amp; Gateway API</figcaption></figure><h3>The Limitations of Ingress</h3><p>Kubernetes Ingress has been the standard way to handle host-and-path-based routing in a cluster, allowing external traffic to reach internal services. However, as applications and infrastructure grow in complexity, Ingress starts to show its limitations.</p><p>One of the biggest challenges with Ingress is its reliance on vendor-specific annotations. While the Ingress API itself is minimal, each Ingress controller (e.g., Ingress-NGINX, Kong, Traefik) extends its functionality through annotations, which are unique to each implementation. This means:</p><ul><li><strong>Lack of portability</strong> — Moving from one Ingress controller to another isn’t straightforward since configurations often need to be rewritten.</li><li><strong>Fragmented feature sets </strong>— Features like canary deployments, traffic mirroring, or advanced routing behave differently across controllers, requiring platform teams to maintain multiple configurations.</li><li><strong>Scaling challenges </strong>— Ingress works well for simple use cases but struggles when handling more advanced traffic management scenarios, such as request transformations, rate limiting, and Layer 4 traffic control.</li></ul><p>Given these issues, teams that need more than just basic ingress capabilities often look for alternative solutions — which is exactly where we found ourselves at <a href="https://www.linkedin.com/company/kita-bisa/">Kitabisa</a>.</p><h3>Exploring Istio as an Alternative</h3><p>When we hit the limitations of Ingress, we turned to Istio, a service mesh that provides more advanced traffic management capabilities. Istio is powerful, offering fine-grained control over service-to-service communication, built-in security policies, and observability. However, we quickly realized that for our specific use case, Istio came with too much overhead:</p><ul><li><strong>Every pod runs a sidecar proxy</strong> — This significantly increases resource consumption since each pod needs additional memory and CPU to run the Envoy sidecar</li><li><strong>High operational complexity</strong> — Running Istio isn’t just about traffic management; it introduces new concepts like service mesh policies, mutual TLS, and complex networking configurations</li><li><strong>Overkill for our needs</strong> — While Istio offers powerful service-to-service controls, we primarily needed a way to replace Ingress with a more feature-rich alternative — not a full-fledged service mesh</li></ul><p>At this point, it became clear that we needed something more powerful than Ingress but lighter than Istio.</p><h3>Enter Envoy Gateway and Kubernetes Gateway API</h3><p>As we were evaluating our options, we came across Envoy Gateway — a lightweight, standalone implementation of Envoy designed to work with Kubernetes Gateway API. This was a game-changer for us because:</p><ul><li><strong>Envoy Gateway removes the need for per-pod sidecars</strong>, dramatically lowering resource consumption compared to Istio</li><li><strong>Gateway API standardizes configurations</strong>, meaning no more dealing with vendor-specific annotations</li><li><strong>It supports both Layer 7 (HTTP/HTTPS) and Layer 4 (TCP/UDP) traffic</strong>, making it much more flexible than Ingress, which only works at Layer 7</li></ul><p>By adopting Gateway API with Envoy Gateway, we got the best of both worlds:</p><ul><li><strong>A more advanced solution than basic Ingress</strong></li><li><strong>Lower resource consumption than Istio</strong> — even when compared to Ingress-NGINX or Kong</li><li><strong>A standardized approach without vendor-specific annotations</strong></li></ul><h3>Looking Ahead: Exploring the Potential of Gateway API</h3><p>Currently, we’re using Gateway API primarily as a replacement for Ingress and Istio. However, there’s a lot more to explore with Gateway API, one exciting aspect being the <a href="https://gateway-api.sigs.k8s.io/mesh/">GAMMA Initiative</a>, which aims to expand Gateway API’s role in service mesh management.</p><p>With GAMMA, we can leverage all the key features of Istio without needing to migrate again — simply by extending our existing Gateway API implementation. This means:</p><ul><li><strong>Service-to-service traffic management without sidecars</strong></li><li><strong>Security policies, observability, and traffic routing </strong>— all within the Gateway API framework</li><li><strong>No need for another migration later</strong>, as Gateway API continues to evolve to support more advanced networking needs</li></ul><h3>Key Differences Between Ingress and Gateway API</h3><p>Lastly, here are some differences between Ingress and Gateway API that, beyond the reasons above, also influenced our decision to migrate:</p><h4>1. Traffic Routing</h4><ul><li><strong>Ingress</strong>: Only supports basic HTTP routing. Advanced routing features, such as traffic splitting or header-based matching, require external tools.</li><li><strong>Gateway API</strong>: Natively supports header-based matching, traffic weighting, typed routes, and different backend types.</li></ul><h4>2. Extensibility</h4><ul><li><strong>Ingress</strong>: Requires custom annotations, which vary between different Ingress controllers. This makes migrations between controllers difficult.</li><li><strong>Gateway API</strong>: Uses Kubernetes Custom Resource Definitions (CRDs), allowing for a more standardized and flexible approach.</li></ul><h4>3. Standardization</h4><ul><li><strong>Ingress</strong>: Different Ingress controllers implement the API differently, leading to inconsistencies and compatibility issues.</li><li><strong>Gateway API</strong>: Provides a universal specification that is supported across various implementations, making it more portable.</li></ul><h4><strong>4. Protocol Support</strong></h4><ul><li><strong>Ingress</strong>: Primarily designed for web applications, supporting only Layer 7 (HTTP/HTTPS). Exposing non-HTTP services requires additional Kubernetes resources.</li><li><strong>Gateway API</strong>: Supports multiple protocols, including Layer 4 (TCP/UDP), HTTP, and gRPC, making it more versatile for different workloads.</li></ul><h4>5. Security</h4><ul><li><strong>Ingress</strong>: Provides only basic TLS termination support.</li><li><strong>Gateway API</strong>: Facilitates enhanced security policies, which cluster operators can define, ensuring better security practices.</li></ul><h4>6. Role-Based Access Control</h4><ul><li><strong>Ingress</strong>: Does not have a built-in mechanism for teams to manage different sections of traffic configuration.</li><li><strong>Gateway API</strong>: Allows individual teams to manage their traffic while cluster operators define global policies, enabling better separation of responsibilities.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OFl_KnaPPES0zjv0mDKegw.png" /><figcaption>Ingress vs. Gateway API</figcaption></figure><h3>Final Thoughts: Gateway API Is Not a Silver Bullet</h3><p>While Kubernetes Gateway API offers a more powerful and flexible approach to managing traffic, it’s important to acknowledge that it’s not a silver bullet for every use case.</p><p>Some drawbacks of Gateway API include:</p><ul><li><strong>Installation and Version Compatibility</strong>: Unlike Ingress, which is mostly plug-and-play, Gateway API is still evolving and requires careful setup. Some features may also depend on specific Kubernetes versions.</li><li><strong>Multiple Object Structure</strong>: Gateway API consists of several components (GatewayClass, Gateway, HTTPRoute, etc.), making it more complex than a single Ingress resource. While this modularity adds flexibility, it can be overwhelming for teams new to Kubernetes networking.</li><li><strong>Learning Curve</strong>: Teams must invest time in understanding how Gateway API’s various components interact. This can slow down adoption compared to Ingress, which is simpler to implement.</li><li><strong>Overkill for Simple Use Cases</strong>: If your organization only needs basic HTTP routing, Gateway API may introduce unnecessary complexity. However, if scalability and advanced traffic control are concerns, the Gateway API provides future-proofing benefits.</li></ul><h3>Conclusion</h3><p>For us, the benefits of Gateway API outweigh its drawbacks, especially as we scale our infrastructure and move away from annotation-heavy Ingress configurations. However, it’s essential to evaluate your own use case before migrating. If you’re managing simple applications, sticking with Ingress may be the right choice. But if you need standardized, multi-protocol support and advanced traffic management, Gateway API is a step forward.</p><p>As Kubernetes networking evolves, Gateway API is shaping up to be the future of ingress and traffic management in cloud-native environments. Exciting times ahead! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b68754257b6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/inside-kitabisa/migrating-from-kubernetes-ingress-to-gateway-api-at-kitabisa-why-we-made-the-switch-9b68754257b6">Migrating from Kubernetes Ingress to Gateway API at Kitabisa: Why We Made the Switch</a> was originally published in <a href="https://medium.com/inside-kitabisa">Inside Kitabisa</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>