The Kubernetes Python Client Roadmap Moves Toward OpenAPI Generator v7 and Native asyncio
"Google Cloud engineers are rebuilding the official Kubernetes Python client on OpenAPI Generator v7.20, adding native asyncio and SharedInformer, after a decade of clusters growing to 50,00
TL;DR
- The Kubernetes Python client is the official library that lets Python code talk to a Kubernetes cluster's API server, and Google Cloud engineers are working with open source contributors to modernize it for AI workloads.
- The client is being migrated from OpenAPI Generator v4.3.0, a generator deprecated in 2020 and removed from upstream in May 2022, toward OpenAPI Generator v7.20.0 and continuous tracking of later releases.
- Native asyncio support is being introduced inside the client so that an async orchestrator or a FastAPI control plane will be able to issue non-blocking API calls through the official library.
- The SharedInformer pattern comes to Python with list-watch caching, automatic reconnection and
on_add,on_updateandon_deletehandlers, which changes the load a controller puts on kube-apiserver. - Deserialisation is the performance item: listing pods or nodes in a large cluster could take 30+ seconds, recorded in issue #1921, and model initialisation is being reworked.
- A platform team should read this as a dependency decision: 73 million monthly PyPI downloads make the client part of the platform surface, and a generator frozen since 2020 is a maintenance fact worth planning around.
- The work runs in the open under SIG API Machinery, and the post describes the client up through Kubernetes 1.35, so a platform team meets the new toolchain in the next upgrade it evaluates.

What the official client carries into a 50,000-node cluster
The post opens with the workloads Python and Kubernetes share: Kubeflow for training, Ray on GKE for distributed compute, KServe for inference, Airflow for pipeline pods. Google says Python and Kubernetes almost always meet under the hood for these workloads, with the official client connecting them; that client is downloaded more than 73 million times a month on PyPI, roughly 1.7 million times a day, and has over 7,500 GitHub stars. Google's own framing puts it second only to client-go in popularity.
That volume explains why a library question became an infrastructure question. Clusters that once ran dozens of nodes now run 50,000-node environments in Google's description, and the client's limits started to appear as production incidents: watches that disconnect, list calls that stall, dependency conflicts next to PyTorch and TensorFlow.

An OpenAPI generator that upstream removed in May 2022
The machinery story is the most concrete part of the post. Up through Kubernetes 1.35, the client generated about 400,000 lines of API and model code with OpenAPI Generator v4.3.0, the python-legacy template set. That version was deprecated in 2020 and removed from the upstream OpenAPI Generator project in May 2022, so the client has been generating code from a tool nobody maintains, and newer Python releases have accumulated DeprecationWarning debt.

The project defines its intended scope as high-impact production gaps for Python developers and operators, with architectural priorities selected through AI/ML workload requirements. Complete feature parity with client-go falls outside that scope. The migration target is OpenAPI Generator v7.20.0 and above, with tracking of upstream releases built into the process. Google states the earlier attempts stalled on the scale of template and schema changes across hundreds of API models, which is a fair description of why an abandoned generator survived so long: the work is mechanical, large and invisible to users until something breaks.
asyncio and SharedInformer arrive inside the client
Three capabilities on this roadmap would change how Python workloads relate to the API server. Native asyncio support is being introduced in the official client, so async-first ML orchestrators, FastAPI control planes and notebooks will be able to issue concurrent, non-blocking calls through the official library. Until now the choice was the synchronous official client or a community async fork such as kubernetes-asyncio, plus third-party clients like kr8s and lightkube.

The second is the SharedInformer pattern, tracked in pull request #2515. Go controllers keep a local, event-driven cache of cluster resources and avoid polling the API server for every reconciliation; Python controllers had no equivalent, so applications watching thousands of training pods either pounded the API server or lost watches. Google says the planned Python implementation will include list-watch caching, automatic reconnection and the three resource event handlers.
The third roadmap capability concerns streaming. As Kubernetes moves remote command streaming away from SPDY toward WebSockets through the v5.channel.k8s.io subprotocol, the client gains WebSocket v5 channel support, tracked in pull request #2486 and KEP-4006, so exec, attach and port-forward keep working against newer control planes.

Deserialisation is the 30-second problem
The performance section contains the number that best explains the complaints. In large clusters, listing pods or nodes in Python could take 30+ seconds because the generated model layer repeatedly instantiates and reconfigures schema validation objects while parsing JSON, which issue #1921 records. The client is also built on a urllib3 transport restricted to HTTP/1.1, so Python workloads miss the HTTP/2 multiplexing and flow control that make client-go fast at scale.

Thirty seconds for a list call reframes a scheduling problem as a library problem. An autoscaler that lists pods to decide capacity, a job manager that checks training state, a controller that reconciles custom resources: each one carries that latency into its own loop, and each one multiplies it by the number of replicas. Google says its planned model-initialisation revamp under v7+ templates targets the deserialisation half. The HTTP/1.1 transport sits outside this announcement.
What a platform team can plan on now
Three planning facts stand out. The generator migration lands incrementally, so pinning a client version and reading the changelog before the next upgrade stays the safe habit. Native asyncio and SharedInformer reduce the reason to run a community fork, which over time means fewer divergent async implementations in one estate. WebSocket v5 support matters as control planes move off SPDY, and a client pinned to an old version will notice that transition first.

For teams running a self-hosted platform, the same logic that applies to sovereign infrastructure and cloud exit applies one layer down: the library an internal control plane imports is part of the estate's dependency surface, and it deserves the same version discipline as a database engine. Google's post names SIG API Machinery as the venue, kubernetes-client/gen as the generator repository and the bi-weekly triage meeting as the place to raise a use case, which is a practical route for anyone whose workloads expose a gap the roadmap has not covered.
The quiet signal in the announcement is what it says about Python's role. A client library with 73 million monthly downloads operated in low-maintenance mode for years as AI and ML clusters grew from dozens of nodes to 50,000-node environments, and the response is an engineering programme inside a SIG. That is how the substrate under AI infrastructure gets maintained, one unglamorous template migration at a time.
Sources
- Kubernetes Python client gets a modern overhaul for the AI/ML era, Google Open Source Blog, 12 November 2026
- kubernetes-client/python, issue #1921 on slow model deserialisation
- kubernetes-client/python, pull request #2515 introducing SharedInformer support
Source: the Google Open Source Blog post of 12 November 2026 and the two GitHub pages it cites for its own claims, all fetched on 13 November 2026. That post carries the download figures, the generator history, the node counts, the issue references and the capability list quoted above.