ExternalDNS End of Life (EOL) Dates and End of Support (EOS) Dates
ExternalDNS 0.24.0 is the current supported release. Track ExternalDNS end of life dates — EOL, EOS and EOSL dates — across all 1 release. Also see cert-manager end of support life for related end-of-life information.
Currently Supported ExternalDNS Releases - Active EOS/EOSL Support (1)
| Release | Released | Support | Latest |
|---|---|---|---|
| 0 | (1 month and 3 weeks ago) | Active | 0.24.0 (2 weeks and 6 days ago) |
Planning a cluster upgrade and wondering about ExternalDNS end of life? ExternalDNS synchronizes exposed Kubernetes Services and Ingresses with DNS providers, and this CNCF-adjacent effort from a Kubernetes SIG publishes no end date for any build. This guide shows what the project does say, how to read its status page, and how to protect your DNS records.
ExternalDNS End of Life: What the Project Says Today
The software describes itself as a controller that watches the Kubernetes API and writes matching DNS records to your provider. Its GitHub repository shows the newest tag, and the endoflife.date tracker mirrors that data through a JSON endpoint and an RSS feed, so you can automate checks. On the tracker, the newest build is 0.24.0, released on 23 October 2026, and the previous minor line sits roughly a month and a week behind it. Both the repository and the tracker live on GitHub and in public view, which makes audits simple.
Because the tool is still labelled experimental in several areas, treat every status page as a snapshot rather than a promise.
Supported Release and Latest Version
Only the newest minor line counts as a supported release. A column on the tracker says "Yes" for that line and nothing more, so the practical rule is simple: if your pinned tag is behind it, you are running code nobody will patch.
Why No Published Support Dates Exist
The maintainers have not reached 1.0, and the owners do not commit to a calendar. Dates would imply a promise of security patches, and a volunteer-driven effort cannot make one honestly. Routine maintenance happens in the open instead.
ExternalDNS Release Schedule and Minor Releases
There is no fixed release schedule. A new release ships when the maintainers decide the accumulated work is ready, so gaps between tags vary. Minor releases can carry behaviour changes, and the tracker is the only reliable source of what is current.
Breaking Changes Before Stable Versions
Pre-stable software may ship breaking changes in any minor bump. Older minor versions are not patched in parallel: once newer ones are released, the lines behind them stop receiving fixes. Read the changelog before each upgrade and test flags that were renamed.
Release Cycle and Dependency Updates
Security and API changes in the libraries the binary links also drive tags. Frequent dependency updates are one reason owners want providers separated from the core, a topic covered below.
Comparing ExternalDNS Releases With Kubernetes Releases
Kubernetes ships three minor versions per year and supports each for about a year. ExternalDNS makes no such pairing, so you must match your controller to your Kubernetes build yourself. Kubernetes upgrades can break old controller builds, and the reverse is rare.
Support Policy for Kubernetes Clusters and Version Compatibility
The repository documents a Kubernetes version compatibility table. No formal support policy sits behind it, so the table reflects what was tested rather than a commitment. Check it before upgrading a cluster, then confirm the controller still starts and logs a clean sync loop in your own namespace.
Ingress and Service Sources
ExternalDNS reads Kubernetes sources: Services of type LoadBalancer, NodePort and ExternalName, plus Ingress objects. For each Ingress, it builds records from hostnames or from an annotation. Common ingress controller choices include nginx, Traefik and Emissary. An nginx ingress behind an AWS load balancer yields a CNAME in your zone, while the same nginx setup on bare metal yields an address record. The compatibility table covers these sources, so an ingress that the project does not list gets no support promise and may need a manual target annotation, and a CNAME created that way requires an existing hostname. A TTL annotation lets each Ingress override the default, and each Service can carry its own annotation too. An ingress class that serves only private traffic needs the internal hostname annotation instead, and a nginx ingress on a private network is a typical case. Anything outside that list is yours to maintain once a release stops receiving attention.
Permissions and Version Skew on Your Cluster
A ServiceAccount, a ClusterRole and a ClusterRoleBinding give the controller read access to Services, Ingresses and nodes. When a Kubernetes release removes an old API group, a stale ClusterRole silently stops the controller from seeing an Ingress. Review RBAC at every upgrade.
Namespace Scope and Support Boundaries
By default one deployment watches every namespace. Overlapping controllers fall outside what the project tests, so run one per cluster, not one per team, and keep any domain-filter from overlapping another's. An unsupported layout is one more reason an upgrade can fail.
Provider Lifecycle: In-Tree Providers and New Providers
The lifecycle of each provider matters more than the core tag, because most outages start in provider code. The repository separates in-tree providers, compiled into the binary, from new providers that integrate externally. Major clouds such as AWS, Route 53, Google Cloud DNS and Azure sit in tree today. Your DNS provider decides how quickly bugs get fixed, and each DNS provider ships its own limits on API calls. AWS accounts also face request limits on hosted zones.
Moving Providers Out of Tree
A long-running GitHub issue proposes moving providers out of tree, starting with the unmaintained ones and ending with the large cloud providers. Contributors argue that every in-tree provider creates an expectation nobody can meet. Migration is therefore likely to reach you as a deprecation, so watch the issue.
Webhook Providers
The webhook mechanism lets a DNS vendor ship its own provider as a separate service, decoupled from the core release cycle. A webhook provider runs as a sidecar container beside the controller, and every webhook call crosses localhost. The maintainers still call the webhook interface experimental, although adoption has been good. A stable interface is a prerequisite before anything else moves, and the webhook route is now the only way to add a provider. Webhook support in the Helm chart makes the sidecar easy to deploy.
| Provider type | Where the code lives | Release cycle |
|---|---|---|
| In-tree provider | The main GitHub repository | Follows the core release |
| Webhook provider | The vendor's own GitHub project | Independent of ExternalDNS |
| Orphaned provider | Main repository, candidate to leave | No guaranteed fixes |
Stable Providers and Unmaintained Code
The README marks which providers are stable and which are not. Before you adopt one in production, read its tutorial, its section of the documentation, and the FAQ, then check the date of the last merged fix. Unmaintained code with no commits for a year is end-of-life in all but name.
End-of-Life Checklist: Staying on a Supported Release
Use this checklist every quarter, because no official notice will warn you:
- Compare your running tag with the newest on the tracker.
- Subscribe to the RSS feed or the GitHub releases page.
- Confirm where your provider sits: in tree, webhook, or abandoned.
- Check the upsert-only setting so an upgrade cannot delete records unexpectedly.
Run a Dry Run Before Every Upgrade
With no end-of-life notice to warn you, a forced move off an unpatched release should never surprise production. Run one sync loop in dry-run mode so bug fixes and renamed flags show up as planned changes, not live edits, then apply the manifest with kubectl.
external-dns --txt-owner-id prod-eu-1 --provider aws --source ingress --once --dry-run
Keep TXT Registry Ownership Stable
The TXT registry records which entries a cluster owns. Changing the txt-owner-id after an upgrade orphans every record you created earlier, so choose a value once and carry it across every move onto a newer, supported release. Questions on GitHub about vanished records usually trace back to this one setting.
Pin the Image Version for Production
Never deploy a floating tag. Pin the current supported minor line in your Helm chart values, bump it deliberately, and an automatic pull cannot replace a working controller with a surprise. The official Docker images are published per tag, which makes pinning easy.
Plan a Migration Before Support Ends
When your provider becomes a candidate to leave the tree, schedule the move to a webhook provider early. Test it first against a throwaway hosted zone with one record, confirm the metrics endpoint still reports successful syncs, and keep the old deployment ready for rollback.