May 29, 2024
May 29, 2024
04-30-2025: We’ve updated this blog post with links to fresh Gateway API resources.
Kubernetes has become the go-to platform for managing containerized applications. It automates the deployment, scaling, and management of containerized workloads, ensuring efficient resource utilization and high availability.
However, managing how these applications communicate with each other and the outside world is crucial. This is where the Kubernetes Gateway API comes in. It provides a standardized way to configure and manage network traffic routing within Kubernetes clusters.
This post will provide an introduction to the Kubernetes Gateway API. We’ll look at its key concepts, its advantages over traditional approaches, and how to use it for effective traffic control in your Kubernetes deployments. By the end of the post, you’ll learn how the Gateway API streamlines network traffic management, giving you more control and flexibility over your containerized applications.
Before discussing the Gateway API, or pointing you to new developments on how ngrok offers the most feature-rich (and struggle-free) implementation of this new spec, it’s important to understand how ingress was handled previously via ingress controllers.
Prior to the Gateway API, ingress controllers were the primary tool for managing inbound traffic in Kubernetes. While ingress controllers served well initially, they faced limitations:
Limited protocol support—Ingress controllers are primarily focused on HTTP traffic, making them unsuitable for routing other protocols.
Static configuration—Changes to ingress configurations often require manual intervention and restarts, hindering dynamic management.
The Gateway API addresses these shortcomings by offering a more comprehensive and flexible approach to traffic management. It provides broader protocol support, facilitates dynamic configuration through the Kubernetes API server, and opens doors for future innovation in network service management within Kubernetes clusters.
The Kubernetes Gateway API is a relatively new addition to the Kubernetes ecosystem, offering a powerful and flexible approach to managing traffic routing within clusters. It is an evolution from ingress controllers, providing greater flexibility, better security, and increased functionality.
The Gateway API is a collection of API components that enable declarative configuration and management of network traffic routing. It functions as an interface, allowing you to control how services in your cluster are exposed and accessible. Consider it a central control panel for managing traffic flow within your Kubernetes system.
One thing to note, the Gateway API is not a feature in and of itself. It’s a standard to define how vendors and projects should create their own implementations. For instance, ngrok has a Gateway API implementation as part of our Kubernetes operator (which also features an ingress controller as well).
The primary purpose of the Gateway API is to simplify and standardize traffic management in Kubernetes. It offers several key benefits:
Unified configuration—The Gateway API consolidates routing configurations for various protocols (HTTP, gRPC, etc.) under one roof, eliminating the need for separate tools for each.
Extensibility—The API is designed to be extensible, allowing integration with future functionalities and third-party plugins.
Role-based access control (RBAC)—The Gateway API supports RBAC, which allows for more detailed control over who can manage specific traffic routes.
While both ingress controllers and the Gateway API handle traffic routing in Kubernetes, they have distinct functionalities. Understanding their strengths and limits will allow you to select the best tool for your deployments.
In essence, ingress controllers offer a simpler solution for basic HTTP traffic management, while the Gateway API provides a more powerful and flexible approach for complex deployments and future-oriented network management within Kubernetes clusters.
The Gateway API provides a comprehensive collection of features that allow you to manage traffic routing in your Kubernetes clusters with greater control and flexibility. Let’s look at some of its important highlights:
The days of using separate tools to manage several protocols are over. The Gateway API offers a single interface for configuring HTTP, gRPC, TCP, TLS, and possibly more in the future, facilitating traffic management across various communication requirements.
The Gateway API includes typed routes and backends. This implies that routes can explicitly describe the protocol they support (HTTP, gRPC, etc.), while backends can represent a variety of targets, such as Kubernetes services, storage buckets, or even serverless tasks. This improved system provides for more precise control and future flexibility.
The Gateway API extends beyond basic path- and host-based routing. It allows you to construct routes based on arbitrary header data from incoming requests. This enables advanced traffic management scenarios such as A/B testing, in which you can direct certain percentages of traffic to different versions of your application based on a header value.
The Gateway API was created with extensibility in mind. It enables the introduction of custom filters and policies at various levels of the API. This enables you to customize the Gateway API to meet your requirements while also leveraging future functionality as it develops.
The Gateway API interacts smoothly with Kubernetes’ RBAC. This allows you to set granular access controls, determining who can manage and modify individual traffic routes inside your cluster. This ensures effective governance and guards against unauthorized changes to crucial network setups.
The Gateway API does more than just handle traffic; it provides several benefits that improve network management and empower developers in your Kubernetes environment, including:
Simplified traffic management—Say goodbye to complicated configurations scattered across different tools. The Gateway API offers a consistent interface for handling all of your traffic routing requirements, reducing complexity and increasing operational efficiency.
Enhanced developer experience—Developers can define sophisticated routing rules directly within the Gateway API, eliminating the need for custom annotations or wrestling with vendor-specific tools. This streamlines development workflows and empowers developers to focus on application logic.
Increased control and flexibility—The Gateway API grants you granular control over traffic flow. Advanced routing capabilities allow for precise targeting based on request headers, enabling A/B testing and other complex routing scenarios. Additionally, the extensible architecture paves the way for future innovations and custom functionalities.
Standardization and future-proofing—The Gateway API is a community-driven standard within the Kubernetes ecosystem. This ensures consistency and reduces vendor lock-in. Moreover, its design promotes future extensibility, allowing you to seamlessly integrate with upcoming functionalities as the Kubernetes landscape evolves.
While the Gateway API offers a significant leap forward in traffic management, it’s important to acknowledge some ongoing challenges:
Relatively new technology—As a relatively new addition to the Kubernetes ecosystem, the Gateway API is still evolving. This means there might be fewer resources and less mature tooling compared with established solutions like ingress controllers.
Adoption rate—Widespread adoption of the Gateway API is still growing. This can lead to compatibility challenges with existing deployments that rely on ingress controllers.
Learning curve—For those accustomed to ingress controllers, the Gateway API introduces a new approach and terminology. A learning curve is involved in understanding and implementing its functionalities effectively.
Despite these challenges, the Gateway API’s advantages and its status as a community-driven standard make it a promising path forward for managing traffic in Kubernetes clusters. As adoption grows and the ecosystem matures, these challenges are likely to diminish over time.
Ingress controllers provide a familiar and simple way for straightforward deployments involving primarily HTTP traffic. In addition, if your team is already familiar with ingress controllers and your needs are covered by their basic functionality, there is no immediate need to transition.
If your applications require A/B testing, header-based routing, or more precise control over traffic splitting, the Gateway API is a more sophisticated alternative. It natively supports a variety of protocols, including HTTP, gRPC, and TCP, making it appropriate for installations with different communication requirements. The Gateway API is an emerging standard that aims to be extensible and integrate with future Kubernetes ecosystem functions.
If you decide you want to migrate from existing ingress controllers to the Gateway API, be sure to check out the Kubernetes documentation for guidance.
The good news is that with ngrok, you can add Traffic Policy custom resources as annotations to your Gateway or Route objects any time Gateway API limits the traffic management rules your network needs.
The Kubernetes Gateway API presents a compelling vision for the future of traffic management within Kubernetes clusters. It offers a unified, standardized, and extensible approach, empowering you to manage network traffic with greater control and flexibility.
By simplifying configurations, enhancing the developer experience, and future-proofing deployments, the Gateway API holds immense potential for streamlining network operations in your Kubernetes environment.
While some challenges exist regarding its relative newness and adoption rate, the Gateway API’s advantages and its position as a community standard make it a worthwhile investment for those looking to elevate their Kubernetes traffic management practices. As the ecosystem matures and adoption grows, the Gateway API is poised to become the go-to solution for managing network traffic in the ever-evolving world of containerized applications.
If you’re interested in trying the Gateway API for yourself, check out our Kubernetes Operator docs and usage guide for Gateway API in particular.
If you have questions or features to request, file issues on the ngrok/ngrok-operator repository or email us directly at support@ngrok.com.
