Article

Who actually runs your ingress?

Port gate at night: container trucks drive through an old, rusty gate, while a new gate lit in turquoise stands next to it with an open lane.

On 5 November 2026, a new vulnerability in ingress-nginx was published: CVE-2026-116472, low severity. Anyone allowed to create an Ingress resource may be able to disrupt the controller’s data path or redirect traffic of other Ingresses via the mirror-target annotation. What stands out is not the vulnerability itself but one sentence in the advisory: Kubernetes will not release a fix, because ingress-nginx maintenance ended in March 2026.

This is exactly what the project warned about for months. The component that accepts external traffic in roughly half of all cloud native environments has a known weakness, and the project itself no longer ships a new version. A fix is only available from individual vendors in their own forks. This article explains what happened, which options you have and which question sits behind it.

What happened

  • November 2025: Kubernetes SIG Network and the Security Response Committee announce the retirement of ingress-nginx. Until March 2026 there is only best-effort maintenance.
  • January 2026: The Steering Committee and the Security Response Committee reinforce the announcement in a joint statement and urge all operators to plan their migration.
  • March 2026: The final release 1.15.1 ships, and shortly afterwards the repository is archived. Since then there have been no releases, no bug fixes and no security updates.
  • November 2026: The first new vulnerability after retirement gets an advisory, but no official fix.

To be precise: what was retired is the community controller kubernetes/ingress-nginx. F5’s separately maintained NGINX Ingress Controller and the NGINX web server itself are not affected. The Kubernetes Ingress API also remains in place, it is just no longer being developed further.

The real gap is not in the code

In many environments, the ingress controller was installed with a Helm chart at the start of a project. It worked, so nobody touched it again. That is exactly what makes it a problem, because it often belongs to no one in particular:

  • Not the development team. It writes Ingress resources and annotations, but the controller is not its code.
  • Not the cloud provider. With managed Kubernetes, the provider usually manages the control plane. Whatever you install into the cluster yourself stays with you.
  • Only partly the platform team, if there is one. There, the controller is one of thirty components running on the side.

Someone would have had to read the November 2025 announcement, assess it and turn it into a plan. Where nobody did, the topic only surfaces when the scanner reports a finding that can no longer be closed.

A component without an owner does not age loudly. It ages quietly.

Why leaving is not a version bump

Moving away from ingress-nginx is not a matter of swapping an image. The behaviour lives in the application manifests: annotations for rewrites, authentication, rate limiting or timeouts, and in the extreme case snippets with arbitrary NGINX configuration. Hardly any of this maps one to one onto another controller.

There are two basic paths:

  • Different controller, same Ingress API. The Ingress resources stay, the ingress class points to a different controller. The annotations still need translating. This is the faster path, but more of a stopgap, because the Ingress API is no longer evolving.
  • Gateway API. It is the official successor and separates infrastructure (Gateway) cleanly from application routing (Routes). The effort is higher because routing manifests are rewritten. Tools such as ingress2gateway help with the translation.

Either way: run old and new side by side, start with non-critical applications, move step by step. This is a project involving several teams, not a ticket for an afternoon.

What you can do if ingress-nginx is still running today

  • Harden right away. Block risky annotations with an admission policy, for the current vulnerability for example mirror-target, and lower the permitted annotation risk with the annotations-risk-level parameter. This buys time but fixes nothing.
  • Bridge deliberately. There are forks and commercial extended support offerings that keep shipping security fixes. This moves your dependency to a new vendor. That can be the right call if it is a conscious decision with an end date.
  • Migrate. Take stock of the annotations in use, define the target (preferably Gateway API for anything new) and agree the order with the teams.

What this says about your platform

ingress-nginx is just the best-known example. The same question applies to certificate management, the CNI, storage drivers, operators and Kubernetes itself, whose minor versions are only maintained for about 14 months. Each of these components needs three things:

  • Someone who follows its lifecycle: release notes, deprecations, announcements like the one from November 2025.
  • A clear trigger to act. The right moment is the end-of-life announcement, not the first vulnerability without a fix.
  • Time and budget for migrations. In platform operations they are not the exception but recurring work.

That is why a responsibility matrix needs more than a column for “Who runs the component?”. It also needs a column for “Who replaces it when it ends?”. A quick test for your environment:

  • Do you know which ingress controller runs in which clusters and in which version?
  • Who read the November 2025 announcement, and what happened next?
  • Who decides when a platform component gets replaced?
  • Is the next migration of this kind already in the plan?

How kloudease handles this

On kloudease, the ingress controller and certificate management are part of the platform. Their lifecycle is AOE’s job: updates, security fixes and, when a component reaches its end of life, the migration to a successor. Necessary tool migrations are part of platform operations, not of your backlog.

What stays with your teams is what belongs there: the routing configuration of their applications. If a migration changes the interface itself, for example from Ingress to Gateway API, we plan the switch together so nobody has to rebuild under time pressure.

Conclusion

ingress-nginx did not fail because of bad code but because too few people could maintain it over time. Many platforms have the same problem on a smaller scale: components that run but belong to no one.

So the question in the title is meant seriously. If you can answer it for your ingress, with a name and a plan, you are in good shape. If not, now is a good time to settle it, before the next vulnerability without a fix does it for you. And if you would rather hand this work off than staff it internally: that is exactly what kloudease is for.

More articles

All blog posts