diff --git a/content/en/blog/gateway-api-v1-6/cover.png b/content/en/blog/gateway-api-v1-6/cover.png new file mode 100644 index 0000000..1a5d913 Binary files /dev/null and b/content/en/blog/gateway-api-v1-6/cover.png differ diff --git a/content/en/blog/gateway-api-v1-6/index.md b/content/en/blog/gateway-api-v1-6/index.md new file mode 100644 index 0000000..db18fb0 --- /dev/null +++ b/content/en/blog/gateway-api-v1-6/index.md @@ -0,0 +1,106 @@ +--- +title: "Gateway API v1.6 — TCPRoute and UDPRoute Graduate to Standard" +description: "Kubernetes Gateway API v1.6.0 brings TCPRoute and UDPRoute to Standard (GA) for portable raw L4 TCP/UDP routing, introduces the experimental XBackend resource, and moves experimental APIs to their own group, gateway.networking.x-k8s.io." +summary: "Gateway API v1.6.0 is out. TCPRoute and UDPRoute graduate from Experimental to Standard in v1, giving workloads like databases, DNS, VoIP, gaming and IoT a portable way to route raw L4 traffic. The release also adds the new experimental XBackend resource and splits experimental APIs into the gateway.networking.x-k8s.io group." +date: 2026-08-03 +draft: false +tags: ["kubernetes", "gateway-api", "networking", "service-mesh", "cncf"] +categories: ["infrastructure"] +featureimage: "cover.png" +featureimagecaption: "Gateway API v1.6 cover — TCPRoute and UDPRoute graduate to Standard" +--- + +The Kubernetes SIG Network community released **Gateway API v1.6.0** on June 30, 2026, and it is a milestone release: **TCPRoute and UDPRoute graduate from Experimental to Standard (GA)** in the `v1` API version. For the first time, you can route raw TCP and UDP traffic through Gateway API with a portable, vendor-neutral API — no more falling back to a plain `Service` or to implementation-specific CRDs. + +![Gateway API v1.6](cover.png) + +## What's New in Gateway API v1.6 + +- **TCPRoute and UDPRoute are now Standard** (`v1`), enabling portable raw L4 traffic routing. +- **A new experimental resource, XBackend**, arrives in the `gateway.networking.x-k8s.io/v1alpha1` group as a general-purpose decorator for backends. +- **Experimental APIs get their own group**: new experimental resources live under `gateway.networking.x-k8s.io` with an `X` prefix, instead of the old version-string scheme. +- **Six implementations are conformant with v1.6** on the day of the announcement. + +## TCPRoute and UDPRoute Graduate to Standard + +Raw Layer 4 routing has been the most requested feature in Gateway API's history. Before v1.6, workloads that need protocol-level TCP or UDP traffic — databases, DNS, VoIP, gaming, IoT telemetry — had to rely on plain Kubernetes `Service` objects or on CRDs tied to a specific implementation. + +With `TCPRoute` and `UDPRoute` in the `v1` API version, that changes. A `Gateway` declares a listener with `protocol: TCP` (or `UDP`) and an `allowedRoutes.kinds` list that includes the route type. The route attaches to the listener through `parentRefs` — with an optional `sectionName` and `port` — and forwards to a backend via `rules[].backendRefs`. + +Here is what a TCP setup looks like: + +```yaml +apiVersion: gateway.networking.k8s.io/v1 +kind: Gateway +metadata: + name: tcp-gateway +spec: + gatewayClassName: example + listeners: + - name: tcp + protocol: TCP + port: 3306 + allowedRoutes: + kinds: + - group: gateway.networking.k8s.io + kind: TCPRoute +--- +apiVersion: gateway.networking.k8s.io/v1 +kind: TCPRoute +metadata: + name: database +spec: + parentRefs: + - name: tcp-gateway + sectionName: tcp + port: 3306 + rules: + - backendRefs: + - name: database + port: 3306 +``` + +`UDPRoute` follows exactly the same pattern — just swap `protocol: TCP` for `protocol: UDP` on the listener and use `kind: UDPRoute` (with a matching `allowedRoutes.kinds` entry) on the route. + +**Deprecation note:** the `v1alpha2` versions of `TCPRoute` and `UDPRoute` are deprecated as of v1.6 and will be removed in a future release. Existing `v1alpha2` users should plan to migrate to `v1`. + +## XBackend: A New Experimental Resource (GEP-4894) + +Alongside the GA graduation, v1.6 introduces a new experimental API called **XBackend**, a general-purpose decorator for `Service` and other backend types. It lives in the new API group `gateway.networking.x-k8s.io/v1alpha1`. + +The first version of `XBackend` supports `ExternalHostname` destinations — an Extended/Optional feature that is useful for egress scenarios and agentic AI workloads. Because an `ExternalHostname` resolves to an address outside the cluster, keep the *confused deputy* security consideration in mind: any controller that proxies to external hostnames should be explicit about which hostnames it is allowed to reach. + +The community is also working on moving Session Persistence configuration from `XBackendTrafficPolicy` into `XBackend`, as well as adding support for retries and TLS origination. + +## Experimental APIs Move to Their Own Group + +v1.6 also changes *how* experimental APIs are versioned. New experimental resources now live in a separate API group, `gateway.networking.x-k8s.io`, and their type names carry an `X` prefix — for example `XBackend` and `XMesh`. When a resource graduates to Standard, it is renamed into `gateway.networking.k8s.io` and the `X` prefix is dropped (for example, `XMesh` becomes `Mesh`). + +`TCPRoute` and `UDPRoute` were the last resources to graduate under the old version-string scheme (`v1alpha2` → `v1`). Going forward, the `X`-prefixed group makes it clear at a glance which resources are still experimental. + +## Conformance: Six Implementations + +Gateway API conformance is enforced through a formal test suite, and the following six implementations were conformant with v1.6 on publication day: + +- Agentgateway +- Airlock Microgateway +- GKE Gateway +- kgateway +- NGINX Gateway Fabric +- Traefik Proxy + +## Try It Yourself + +If you want to try TCP or UDP routing today, any of the conformant implementations above is a good starting point. The project maintains user guides for [TCP](https://gateway-api.sigs.k8s.io/guides/user-guides/tcp/) and [UDP](https://gateway-api.sigs.k8s.io/guides/user-guides/udp/) routing, plus full [documentation](https://gateway-api.sigs.k8s.io/) and the [v1.6.0 release notes](https://github.com/kubernetes-sigs/gateway-api/releases/tag/v1.6.0). + +## Get Involved + +Gateway API is the role-oriented, expressive service networking standard for Kubernetes, built under SIG Network. To get involved: + +- Join **#sig-network-gateway-api** on the [Kubernetes Slack](https://slack.k8s.io/) +- Check the SIG Network calendar for community meetings +- Browse and contribute to the [gateway-api repository](https://github.com/kubernetes-sigs/gateway-api) + +--- + +At **EF-TECH**, we specialize in Kubernetes, cloud computing, and infrastructure automation. We help teams design and operate modern service networking — Gateway API included. [Contact us](/en/contato/) to learn how we can help your team. For more articles like this, visit our [blog](/en/blog/). diff --git a/content/pt-br/blog/gateway-api-v1-6/cover.png b/content/pt-br/blog/gateway-api-v1-6/cover.png new file mode 100644 index 0000000..1a5d913 Binary files /dev/null and b/content/pt-br/blog/gateway-api-v1-6/cover.png differ diff --git a/content/pt-br/blog/gateway-api-v1-6/index.md b/content/pt-br/blog/gateway-api-v1-6/index.md new file mode 100644 index 0000000..127e505 --- /dev/null +++ b/content/pt-br/blog/gateway-api-v1-6/index.md @@ -0,0 +1,106 @@ +--- +title: "Gateway API v1.6 — TCPRoute e UDPRoute tornam-se Standard" +description: "O Gateway API v1.6.0 do Kubernetes traz TCPRoute e UDPRoute para Standard (GA) com roteamento L4 TCP/UDP portável, apresenta o novo recurso experimental XBackend e separa as APIs experimentais no grupo gateway.networking.x-k8s.io." +summary: "O Gateway API v1.6.0 chegou. TCPRoute e UDPRoute deixam o estágio Experimental e passam a Standard na versão v1, oferecendo a workloads como bancos de dados, DNS, VoIP, jogos e IoT uma forma portátil de rotear tráfego L4 puro. A release também adiciona o novo recurso experimental XBackend e separa as APIs experimentais no grupo gateway.networking.x-k8s.io." +date: 2026-08-03 +draft: false +tags: ["kubernetes", "gateway-api", "redes", "service-mesh", "cncf"] +categories: ["infraestrutura"] +featureimage: "cover.png" +featureimagecaption: "Capa do Gateway API v1.6 — TCPRoute e UDPRoute promovidos a Standard" +--- + +A comunidade Kubernetes SIG Network lançou o **Gateway API v1.6.0** em 30 de junho de 2026, e esta é uma release marcante: **TCPRoute e UDPRoute deixam o estágio Experimental e passam a Standard (GA)** na versão de API `v1`. Pela primeira vez, você consegue rotear tráfego TCP e UDP puro com o Gateway API usando uma API portátil e neutra de fornecedor — sem precisar recorrer a um `Service` comum ou a CRDs específicos de cada implementação. + +![Gateway API v1.6](cover.png) + +## O Que Há de Novo no Gateway API v1.6 + +- **TCPRoute e UDPRoute agora são Standard** (`v1`), habilitando roteamento portátil de tráfego L4 puro. +- **Um novo recurso experimental, XBackend**, chega no grupo `gateway.networking.x-k8s.io/v1alpha1` como um decorator de uso geral para backends. +- **APIs experimentais ganham grupo próprio**: novos recursos experimentais passam a viver em `gateway.networking.x-k8s.io` com o prefixo `X`, em vez do antigo esquema de versões. +- **Seis implementações são conformes com o v1.6** no dia do anúncio. + +## TCPRoute e UDPRoute tornam-se Standard + +O roteamento puro na camada 4 (L4) é um dos recursos mais pedidos na história do Gateway API. Antes do v1.6, workloads que precisam de tráfego TCP ou UDP em nível de protocolo — bancos de dados, DNS, VoIP, jogos, telemetria de IoT — dependiam do `Service` comum do Kubernetes ou de CRDs atrelados a uma implementação específica. + +Com `TCPRoute` e `UDPRoute` na versão de API `v1`, isso muda. Um `Gateway` declara um listener com `protocol: TCP` (ou `UDP`) e uma lista `allowedRoutes.kinds` que inclui o tipo de rota. A rota se conecta ao listener por meio de `parentRefs` — com `sectionName` e `port` opcionais — e encaminha o tráfego para um backend via `rules[].backendRefs`. + +Veja como fica uma configuração TCP: + +```yaml +apiVersion: gateway.networking.k8s.io/v1 +kind: Gateway +metadata: + name: tcp-gateway +spec: + gatewayClassName: example + listeners: + - name: tcp + protocol: TCP + port: 3306 + allowedRoutes: + kinds: + - group: gateway.networking.k8s.io + kind: TCPRoute +--- +apiVersion: gateway.networking.k8s.io/v1 +kind: TCPRoute +metadata: + name: database +spec: + parentRefs: + - name: tcp-gateway + sectionName: tcp + port: 3306 + rules: + - backendRefs: + - name: database + port: 3306 +``` + +A `UDPRoute` segue exatamente o mesmo padrão — basta trocar `protocol: TCP` por `protocol: UDP` no listener e usar `kind: UDPRoute` (com a entrada correspondente em `allowedRoutes.kinds`) na rota. + +**Nota sobre depreciação:** as versões `v1alpha2` de `TCPRoute` e `UDPRoute` estão deprecadas a partir do v1.6 e serão removidas em uma release futura. Quem ainda usa `v1alpha2` deve planejar a migração para `v1`. + +## XBackend: um novo recurso experimental (GEP-4894) + +Junto com a promoção a GA, o v1.6 introduz uma nova API experimental chamada **XBackend**, um decorator de uso geral para `Service` e outros tipos de backend. Ela vive no novo grupo de API `gateway.networking.x-k8s.io/v1alpha1`. + +A primeira versão do `XBackend` suporta destinos `ExternalHostname` — um recurso Extended/Opcional útil para cenários de egress e workloads de IA agêntica. Como um `ExternalHostname` resolve para um endereço fora do cluster, vale lembrar da consideração de segurança conhecida como *confused deputy*: qualquer controlador que faça proxy para hostnames externos deve ser explícito sobre quais hostnames ele pode acessar. + +A comunidade também está trabalhando para mover a configuração de Session Persistence do `XBackendTrafficPolicy` para dentro do `XBackend`, além de adicionar suporte a retries e TLS origination. + +## APIs experimentais ganham grupo próprio + +O v1.6 também muda *como* as APIs experimentais são versionadas. Novos recursos experimentais agora vivem em um grupo de API separado, `gateway.networking.x-k8s.io`, e os nomes de seus tipos recebem o prefixo `X` — por exemplo, `XBackend` e `XMesh`. Quando um recurso passa a Standard, ele é renomeado para `gateway.networking.k8s.io` e o prefixo `X` é removido (por exemplo, `XMesh` vira `Mesh`). + +`TCPRoute` e `UDPRoute` foram os últimos recursos a serem promovidos sob o antigo esquema de versões (`v1alpha2` → `v1`). Daqui para frente, o grupo com prefixo `X` deixa claro de imediato quais recursos ainda são experimentais. + +## Conformidade: seis implementações + +A conformidade do Gateway API é garantida por uma suíte de testes formal, e as seis implementações a seguir eram conformes com o v1.6 no dia da publicação: + +- Agentgateway +- Airlock Microgateway +- GKE Gateway +- kgateway +- NGINX Gateway Fabric +- Traefik Proxy + +## Experimente Você Mesmo + +Se quiser testar roteamento TCP ou UDP hoje, qualquer uma das implementações conformes acima é um bom ponto de partida. O projeto mantém guias de usuário para roteamento [TCP](https://gateway-api.sigs.k8s.io/guides/user-guides/tcp/) e [UDP](https://gateway-api.sigs.k8s.io/guides/user-guides/udp/), além da [documentação completa](https://gateway-api.sigs.k8s.io/) e das [notas da release v1.6.0](https://github.com/kubernetes-sigs/gateway-api/releases/tag/v1.6.0). + +## Participe + +O Gateway API é o padrão de service networking do Kubernetes: orientado a papéis, expressivo e construído sob o SIG Network. Para participar: + +- Entre no canal **#sig-network-gateway-api** no [Slack do Kubernetes](https://slack.k8s.io/) +- Acompanhe o calendário do SIG Network para as reuniões da comunidade +- Explore e contribua com o [repositório do gateway-api](https://github.com/kubernetes-sigs/gateway-api) + +--- + +Na **EF-TECH**, somos especialistas em Kubernetes, cloud computing e automação de infraestrutura. Ajudamos equipes a projetar e operar service networking moderno — incluindo o Gateway API. [Entre em contato](/pt-br/contato/) para saber como podemos ajudar sua equipe. Para mais artigos como este, visite nosso [blog](/pt-br/blog/). diff --git a/static/img/blog/gateway-api-v1-6/cover.png b/static/img/blog/gateway-api-v1-6/cover.png new file mode 100644 index 0000000..1a5d913 Binary files /dev/null and b/static/img/blog/gateway-api-v1-6/cover.png differ diff --git a/static/img/blog/gateway-api-v1-6/generate_cover.py b/static/img/blog/gateway-api-v1-6/generate_cover.py new file mode 100644 index 0000000..fdc137e --- /dev/null +++ b/static/img/blog/gateway-api-v1-6/generate_cover.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python3 +""" +Generate the featured image (1200x630px PNG) for the Gateway API v1.6 blog post. + +Design (same dark-terminal style as the Ansible CLI GitHub Action cover): + - Dark navy gradient background (#0e1120 -> #1e2a4a) with a grid of dots + - A terminal window showing `kubectl apply -f gateway.yaml` plus a + Gateway / TCPRoute YAML snippet + - Big title "Gateway API v1.6", subtitle "TCPRoute & UDPRoute Graduate + to Standard", and EF-TECH branding at the bottom right + +Requires: pip install pillow +""" + +import os +import sys + +try: + from PIL import Image, ImageDraw, ImageFont +except ImportError: + print("Pillow is required. Install it with: pip install pillow") + sys.exit(1) + +WIDTH, HEIGHT = 1200, 630 + + +def find_font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont | ImageFont.ImageFont: + """Try to find a suitable monospace font on the system.""" + candidates = [] + if bold: + candidates = [ + "/System/Library/Fonts/Supplemental/SFNSMono-Bold.otf", + "/usr/share/fonts/truetype/dejavu/DejaVuSansMono-Bold.ttf", + "/usr/share/fonts/truetype/ubuntu/UbuntuMono-B.ttf", + "/usr/share/fonts/truetype/liberation/LiberationMono-Bold.ttf", + ] + candidates += [ + "/System/Library/Fonts/Supplemental/SFNSMono-Regular.otf", + "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", + "/usr/share/fonts/truetype/ubuntu/UbuntuMono-R.ttf", + "/usr/share/fonts/truetype/liberation/LiberationMono.ttf", + ] + for path in candidates: + if os.path.exists(path): + return ImageFont.truetype(path, size) + return ImageFont.load_default() + + +def draw_terminal_window(draw: ImageDraw, x: int, y: int, w: int, h: int) -> None: + """Draw a terminal window with a title bar.""" + # Window shadow + shadow_offset = 4 + draw.rounded_rectangle( + [x + shadow_offset, y + shadow_offset, x + w + shadow_offset, y + h + shadow_offset], + radius=12, fill=(0, 0, 0, 60) + ) + # Window body (dark terminal bg) + draw.rounded_rectangle( + [x, y, x + w, y + h], radius=10, fill=(22, 26, 46) + ) + # Title bar area + draw.rounded_rectangle( + [x, y, x + w, y + 42], radius=10, fill=(32, 38, 64) + ) + # Flatten bottom corners of title bar + draw.rectangle([x, y + 32, x + w, y + 42], fill=(32, 38, 64)) + # Traffic light buttons + for cx, color in [(x + 20, (255, 95, 87)), (x + 46, (255, 189, 46)), (x + 72, (39, 201, 63))]: + draw.ellipse([cx, y + 14, cx + 14, y + 28], fill=color) + # Title text in title bar + font_title = find_font(15) + draw.text((x + w // 2, y + 21), "gateway-api-v1-6 — bash", fill=(170, 180, 210), + font=font_title, anchor="mm") + + +def create_featured_image(output_path: str) -> None: + """Create the 1200x630 OG image for the Gateway API v1.6 post.""" + img = Image.new("RGBA", (WIDTH, HEIGHT), (14, 17, 32, 255)) + draw = ImageDraw.Draw(img) + + # Background: subtle gradient #0e1120 (top) -> #1e2a4a (bottom) + top = (14, 17, 32) + bottom = (30, 42, 74) + for i in range(HEIGHT): + t = i / HEIGHT + r = int(top[0] + (bottom[0] - top[0]) * t) + g = int(top[1] + (bottom[1] - top[1]) * t) + b = int(top[2] + (bottom[2] - top[2]) * t) + draw.line([(0, i), (WIDTH, i)], fill=(r, g, b, 255)) + + # Decorative grid dots + for x in range(0, WIDTH, 30): + for y in range(0, HEIGHT, 30): + draw.point((x, y), fill=(70, 84, 130, 60)) + + # Terminal window (central element) + tw, th = 960, 360 + tx, ty = (WIDTH - tw) // 2, 30 + draw_terminal_window(draw, tx, ty, tw, th) + + # Terminal content + font_cmd = find_font(15, bold=True) + font_out = find_font(14) + font_yaml = find_font(14) + + prompt_x = tx + 30 + line_y = ty + 56 + + # Command + output lines + draw.text((prompt_x, line_y), "$", fill=(82, 188, 74), font=font_cmd) + draw.text((prompt_x + 20, line_y), " kubectl apply -f gateway.yaml", fill=(240, 242, 250), font=font_cmd) + line_y += 22 + + for out_line in [ + "gateway.gateway.networking.k8s.io/tcp-gateway created", + "tcproute.gateway.networking.k8s.io/database created", + ]: + draw.text((prompt_x, line_y), out_line, fill=(120, 170, 255), font=font_out) + line_y += 22 + + # Blank spacer + line_y += 6 + + # YAML snippet — Gateway listener (TCP) + yaml_lines = [ + ("", "apiVersion: gateway.networking.k8s.io/v1", (225, 230, 245)), + ("", "kind: Gateway", (225, 230, 245)), + ("", "spec:", (225, 230, 245)), + ("", " listeners:", (225, 230, 245)), + ("", " - name: tcp", (225, 230, 245)), + ("key", " protocol: TCP", (82, 188, 74)), + ("", " port: 3306", (225, 230, 245)), + ("", " allowedRoutes:", (225, 230, 245)), + ("", " kinds: [TCPRoute]", (225, 230, 245)), + ("sep", "---", (120, 130, 170)), + ("", "kind: TCPRoute # attaches via parentRefs", (225, 230, 245)), + ("", "spec:", (225, 230, 245)), + ("", " parentRefs:", (225, 230, 245)), + ("", " - name: tcp-gateway", (225, 230, 245)), + ("", " rules:", (225, 230, 245)), + ("", " - backendRefs:", (225, 230, 245)), + ("", " - name: database, port: 3306", (225, 230, 245)), + ] + + for kind, text, color in yaml_lines: + if kind == "sep": + draw.text((prompt_x, line_y), text, fill=color, font=font_yaml) + elif kind == "key": + # Highlight the protocol keyword + draw.text((prompt_x, line_y), text, fill=color, font=font_yaml, stroke_width=0) + else: + draw.text((prompt_x, line_y), text, fill=color, font=font_yaml) + line_y += 19 + + # Title overlay below the terminal + title_font = find_font(46, bold=True) + draw.text((WIDTH // 2, ty + th + 66), "Gateway API v1.6", + fill=(255, 255, 255), font=title_font, anchor="mm") + + subtitle_font = find_font(24, bold=True) + draw.text((WIDTH // 2, ty + th + 118), "TCPRoute & UDPRoute Graduate to Standard", + fill=(94, 170, 255), font=subtitle_font, anchor="mm") + + info_font = find_font(15) + draw.text((WIDTH // 2, ty + th + 156), "v1.6.0 · Released June 30, 2026 · Kubernetes SIG Network", + fill=(140, 150, 185), font=info_font, anchor="mm") + + # EF-TECH branding + brand_font = find_font(14, bold=True) + draw.text((WIDTH - 30, HEIGHT - 20), "EF-TECH", fill=(100, 110, 145), font=brand_font, anchor="rs") + + # Convert to RGB and save as PNG + final = Image.new("RGB", (WIDTH, HEIGHT), (14, 17, 32)) + final.paste(img, mask=img.split()[3]) + final.save(output_path, "PNG") + print(f"Image saved to {output_path} ({WIDTH}x{HEIGHT})") + + +if __name__ == "__main__": + output = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cover.png") + create_featured_image(output)