Three Clouds, Three Ways to Hide a Control Plane: Private Kubernetes Access Across EKS, GKE, and AKS

TL;DR: Each major managed Kubernetes service now offers its own flavor of private control plane access, and running clusters across all three means running three different access stacks. A cluster-side identity-aware proxy avoids the fragmentation. See the Twingate Kubernetes docs for the deployment pattern.
Last month a platform engineer I know spent half a week debugging why their new AKS cluster's API server wasn't reachable from the jump host that worked fine for their EKS and GKE clusters. The answer was Private Link endpoint policies interacting with a VNet peering setup that assumed a different DNS resolution path. Nothing was broken. Everything was configured exactly as each cloud's documentation prescribed. The clusters just didn't agree on what "private" meant.
This is the state of private Kubernetes control plane access in 2026. All three hyperscalers have landed on "the API server shouldn't be on the public internet," which is the right answer. But they got there by three different roads, and if you run clusters on more than one of them, you are now the integration layer.
The three private control plane models
Before getting into why this is a problem, it's worth pinning down what each provider actually offers. The shapes are genuinely different, not just branded differently.
EKS: private endpoints inside the VPC
Amazon EKS clusters can be configured with private endpoint access, which puts the API server behind an interface inside your VPC. Reaching it means being inside that VPC, inside a peered VPC, or routed in via Transit Gateway, Direct Connect, or Site-to-Site VPN. The endpoint resolves to an RFC 1918 address. Public DNS resolution of the cluster's FQDN still works, but it returns a private IP that only routes from connected networks.
Access control for the endpoint itself is network-level. IAM governs what you can do once you reach kube-apiserver, but reachability is a routing problem.
GKE: a DNS-based endpoint gated by IAM
Google introduced the DNS-based endpoint for GKE in 2024 and has been pushing it as the preferred model since. Each cluster gets a unique DNS name that resolves to an endpoint reachable from anywhere, but requests are gated by Google Cloud IAM at the frontend. No peering, no bastion, no authorized networks list to maintain.
It's a genuinely different model: the endpoint is globally reachable, but the authorization boundary sits at the Google front door rather than at the network edge. Whether this counts as "private" depends on your definition. For most compliance frameworks that care about network segmentation, it doesn't — which is why GKE still offers the older private cluster model with authorized networks.
AKS: API Server VNet Integration with Private Link
Azure's current recommended pattern is API Server VNet Integration combined with Private Link for fully private clusters. The API server is projected into a delegated subnet of your VNet, and Private Link gives you a private endpoint reachable through peered VNets or Azure ExpressRoute. Private DNS zones handle the FQDN resolution. The older "private cluster" model using a private endpoint to a Microsoft-managed network is still there, but VNet Integration is where Azure is steering new deployments.
Summary
EKS | GKE | AKS | |
|---|---|---|---|
Private model | Private endpoint in VPC | DNS-based endpoint, IAM-gated | API Server VNet Integration + Private Link |
Reachability | VPC, peered VPCs, VPN/Direct Connect | Anywhere with valid IAM | VNet, peered VNets, ExpressRoute/VPN |
Authorization boundary | Network edge | Google front door | Network edge |
DNS resolution | Public FQDN → private IP | Cluster-specific DNS name | Private DNS zone |
Access control | IAM + network routing | IAM only | Entra ID + network routing |
Each of these is a reasonable design. Each solves the "don't expose the API server" problem. They just don't solve it the same way.
What this costs multi-cloud teams
If you only live in one cloud, this is a non-issue. Pick the model, build the access path, move on. The pain starts when the same team operates clusters in two or three of these environments.
The engineer debugging access to a new cluster has to remember which cloud they're in, which access path applies, which identity system issues the credential that eventually gets mapped to Kubernetes RBAC, and which jump host or peering relationship is supposed to carry the connection. Three of these things used to be the same thing: you ran a VPN, you got on the network, you hit kube-apiserver. Now:
Reaching EKS might mean an AWS Client VPN, SSM Session Manager tunneling to a bastion, or a Direct Connect from the corporate network.
Reaching GKE's DNS endpoint means an IAM credential and nothing else, which is operationally lovely until you need to also audit the connection or require device posture.
Reaching AKS means being on a VNet, which in a hub-and-spoke topology means VPN or ExpressRoute into the hub and the right private DNS forwarding configured.
That's three identity systems (IAM, Google IAM, Entra ID), three network topologies, and at least three different runbooks for "I can't reach the cluster." The on-call rotation needs to know all of them. The platform team maintains all of them. Audit has to reconcile logs across all of them.
And none of this touches the actual Kubernetes RBAC question. Once you're through the front door, you still need the user's identity to map to a Kubernetes user or group so that kubectl commands are authorized against the cluster's role bindings. Each cloud handles that mapping differently too.
The categories of cross-cloud access options
Teams usually end up picking from one of four approaches. None of them are wrong. They have different tradeoffs.
Traditional VPNs and bastion hosts
Run an IPsec VPN or OpenVPN into each cloud's VPC/VNet, or SSH through a bastion. This is the "we've always done it this way" option. It's well understood, and most IAM-aware VPN appliances can enforce MFA at connection time.
The problem is that you get network-level access. Once you're on the VPC, you can reach anything the routing allows, which is usually more than kube-apiserver. You now have a VPN concentrator per cloud to patch, scale, and monitor, and the identity used at the VPN layer is separate from the identity Kubernetes sees.
Mesh VPN overlays (like Tailscale)
Install an agent on every node that needs connectivity, including subnet routers inside each cloud, and get a flat overlay network that spans clouds. This is operationally simpler than running three separate VPNs. Setup is fast.
The architectural tradeoff is the same as any mesh: everyone enrolled is on the same network. ACLs can restrict reachability, but the network is still enumerable from any compromised node, and lateral movement is a question of policy strictness rather than architecture. For a small team with high trust, this is fine. For an enterprise deploying hundreds of clusters across business units, the policy file becomes the bottleneck.
Cloud-native IAM gating
Use each cloud's native access path: IAP for GCP, SSM Session Manager for AWS, Azure Bastion for AKS. Each is well-integrated with its cloud's identity system. There's no software to install on your own network.
The limitation is that you now have three separate access stacks. Each one's logs land in that cloud's logging service. Device posture, if you enforce it, has to be configured three times. The user experience is three different login flows.
Cluster-side identity-aware proxy
Deploy a proxy inside each cluster (or network) that authenticates the user, passes their identity through to Kubernetes, and makes outbound-only connections to a control plane for coordination. The access path is the same regardless of which cloud the cluster lives in. One policy engine. One audit trail. One client.
This is the pattern Twingate's Kubernetes Operator implements, and it's the one worth looking at in detail.
How the cluster-side model works with Twingate
Twingate's architecture puts the trust boundary at the resource, not the network. For Kubernetes, that means the API server is treated as a resource, and access is granted per user to that specific resource. No VPC peering, no bastion, no exposed endpoints.
The Twingate Kubernetes Operator handles deployment: a Connector pod runs in the cluster and establishes an outbound-only connection to Twingate's Controller. The Operator also manages Gateway resources, which are the components that pass the authenticated user's identity through to kube-apiserver for RBAC evaluation.
Here's how the flow works for a kubectl command:
The user runs
kubectlon their laptop. The Twingate Client intercepts the DNS query for the cluster's API server hostname because an ACL entry matches.The Client requests authorization from the Controller, which checks the user's identity (via your IdP), device posture, and policy.
Once authorized, the Client establishes a TLS tunnel to the Gateway running in the cluster — direct peer-to-peer if possible, through a Relay if NAT prevents it. The Relay never decrypts traffic.
The Gateway independently verifies the ACL from the Controller, then proxies the request to kube-apiserver, injecting the user's identity.
Kubernetes RBAC evaluates the request against native Role and ClusterRole bindings for that user.
The two things that matter here for multi-cloud teams:
All three clusters look the same from the client's perspective. The EKS cluster, the GKE cluster, and the AKS cluster are each just a resource in Twingate. The user runs the same kubectl command. The policy engine is the same. The audit log is the same.
The user's real identity reaches Kubernetes RBAC. You write role bindings against your IdP's users and groups, not against IAM service accounts or shared kubeconfig credentials. This matters for audit: when someone deletes a production deployment, the audit log shows their name, not "the AWS role that someone assumed."
Deploying the Operator
A minimal installation of the Operator via Helm looks like this. The command installs the Operator into the twingate namespace with a reference to your Twingate tenant.
helm repo add twingate https://twingate.github.io/helm-charts helm install twingate-operator twingate/twingate-operator \ --namespace twingate --create-namespace \ --set twingateOperator.apiKey=$TWINGATE_API_KEY \ --set twingateOperator.network=$TWINGATE_NETWORK
From there, you define TwingateResource and TwingateConnector custom resources that map Kubernetes services (including kube-apiserver) to Twingate resources. The Operator handles reconciliation and keeps the Connector registered.
The same manifest shape works on EKS, GKE, and AKS. The underlying cluster still uses whatever control plane access model its cloud offers — it just no longer matters for the engineer doing the work.
What you give up, and what you don't
The cluster-side model doesn't eliminate your cloud's private control plane configuration. If anything, it coexists with it: the Connector is a workload inside the cluster, so it still needs network reachability to kube-apiserver, which is a short hop within the cluster itself. What you stop needing is any external access path to that endpoint — no VPN concentrator, no public endpoint, no authorized networks list to maintain.
You also don't get to drop IAM entirely. You'll still want IAM roles for workload identity and for your infrastructure pipelines. But for human access, the IdP becomes the single source of truth, and that's a meaningful simplification.
Closing
Multi-cloud Kubernetes is already complicated. Multi-cloud private control plane access shouldn't add to that complexity, but today it does, because each provider is solving the problem inside its own four walls. The cluster-side approach moves the access path out of the cloud provider's purview and into something you control uniformly.
For the full deployment walkthrough, Helm values reference, and examples of mapping Kubernetes services to Twingate resources, see the Twingate Kubernetes Operator documentation.
New to Twingate? You can use Twingate for free for up to 5 users, request a personalized demo, or reach out to the team over on the Twingate subreddit.
Rapidly implement a modern Zero Trust network that is more secure and maintainable than VPNs.
Three Clouds, Three Ways to Hide a Control Plane: Private Kubernetes Access Across EKS, GKE, and AKS

TL;DR: Each major managed Kubernetes service now offers its own flavor of private control plane access, and running clusters across all three means running three different access stacks. A cluster-side identity-aware proxy avoids the fragmentation. See the Twingate Kubernetes docs for the deployment pattern.
Last month a platform engineer I know spent half a week debugging why their new AKS cluster's API server wasn't reachable from the jump host that worked fine for their EKS and GKE clusters. The answer was Private Link endpoint policies interacting with a VNet peering setup that assumed a different DNS resolution path. Nothing was broken. Everything was configured exactly as each cloud's documentation prescribed. The clusters just didn't agree on what "private" meant.
This is the state of private Kubernetes control plane access in 2026. All three hyperscalers have landed on "the API server shouldn't be on the public internet," which is the right answer. But they got there by three different roads, and if you run clusters on more than one of them, you are now the integration layer.
The three private control plane models
Before getting into why this is a problem, it's worth pinning down what each provider actually offers. The shapes are genuinely different, not just branded differently.
EKS: private endpoints inside the VPC
Amazon EKS clusters can be configured with private endpoint access, which puts the API server behind an interface inside your VPC. Reaching it means being inside that VPC, inside a peered VPC, or routed in via Transit Gateway, Direct Connect, or Site-to-Site VPN. The endpoint resolves to an RFC 1918 address. Public DNS resolution of the cluster's FQDN still works, but it returns a private IP that only routes from connected networks.
Access control for the endpoint itself is network-level. IAM governs what you can do once you reach kube-apiserver, but reachability is a routing problem.
GKE: a DNS-based endpoint gated by IAM
Google introduced the DNS-based endpoint for GKE in 2024 and has been pushing it as the preferred model since. Each cluster gets a unique DNS name that resolves to an endpoint reachable from anywhere, but requests are gated by Google Cloud IAM at the frontend. No peering, no bastion, no authorized networks list to maintain.
It's a genuinely different model: the endpoint is globally reachable, but the authorization boundary sits at the Google front door rather than at the network edge. Whether this counts as "private" depends on your definition. For most compliance frameworks that care about network segmentation, it doesn't — which is why GKE still offers the older private cluster model with authorized networks.
AKS: API Server VNet Integration with Private Link
Azure's current recommended pattern is API Server VNet Integration combined with Private Link for fully private clusters. The API server is projected into a delegated subnet of your VNet, and Private Link gives you a private endpoint reachable through peered VNets or Azure ExpressRoute. Private DNS zones handle the FQDN resolution. The older "private cluster" model using a private endpoint to a Microsoft-managed network is still there, but VNet Integration is where Azure is steering new deployments.
Summary
EKS | GKE | AKS | |
|---|---|---|---|
Private model | Private endpoint in VPC | DNS-based endpoint, IAM-gated | API Server VNet Integration + Private Link |
Reachability | VPC, peered VPCs, VPN/Direct Connect | Anywhere with valid IAM | VNet, peered VNets, ExpressRoute/VPN |
Authorization boundary | Network edge | Google front door | Network edge |
DNS resolution | Public FQDN → private IP | Cluster-specific DNS name | Private DNS zone |
Access control | IAM + network routing | IAM only | Entra ID + network routing |
Each of these is a reasonable design. Each solves the "don't expose the API server" problem. They just don't solve it the same way.
What this costs multi-cloud teams
If you only live in one cloud, this is a non-issue. Pick the model, build the access path, move on. The pain starts when the same team operates clusters in two or three of these environments.
The engineer debugging access to a new cluster has to remember which cloud they're in, which access path applies, which identity system issues the credential that eventually gets mapped to Kubernetes RBAC, and which jump host or peering relationship is supposed to carry the connection. Three of these things used to be the same thing: you ran a VPN, you got on the network, you hit kube-apiserver. Now:
Reaching EKS might mean an AWS Client VPN, SSM Session Manager tunneling to a bastion, or a Direct Connect from the corporate network.
Reaching GKE's DNS endpoint means an IAM credential and nothing else, which is operationally lovely until you need to also audit the connection or require device posture.
Reaching AKS means being on a VNet, which in a hub-and-spoke topology means VPN or ExpressRoute into the hub and the right private DNS forwarding configured.
That's three identity systems (IAM, Google IAM, Entra ID), three network topologies, and at least three different runbooks for "I can't reach the cluster." The on-call rotation needs to know all of them. The platform team maintains all of them. Audit has to reconcile logs across all of them.
And none of this touches the actual Kubernetes RBAC question. Once you're through the front door, you still need the user's identity to map to a Kubernetes user or group so that kubectl commands are authorized against the cluster's role bindings. Each cloud handles that mapping differently too.
The categories of cross-cloud access options
Teams usually end up picking from one of four approaches. None of them are wrong. They have different tradeoffs.
Traditional VPNs and bastion hosts
Run an IPsec VPN or OpenVPN into each cloud's VPC/VNet, or SSH through a bastion. This is the "we've always done it this way" option. It's well understood, and most IAM-aware VPN appliances can enforce MFA at connection time.
The problem is that you get network-level access. Once you're on the VPC, you can reach anything the routing allows, which is usually more than kube-apiserver. You now have a VPN concentrator per cloud to patch, scale, and monitor, and the identity used at the VPN layer is separate from the identity Kubernetes sees.
Mesh VPN overlays (like Tailscale)
Install an agent on every node that needs connectivity, including subnet routers inside each cloud, and get a flat overlay network that spans clouds. This is operationally simpler than running three separate VPNs. Setup is fast.
The architectural tradeoff is the same as any mesh: everyone enrolled is on the same network. ACLs can restrict reachability, but the network is still enumerable from any compromised node, and lateral movement is a question of policy strictness rather than architecture. For a small team with high trust, this is fine. For an enterprise deploying hundreds of clusters across business units, the policy file becomes the bottleneck.
Cloud-native IAM gating
Use each cloud's native access path: IAP for GCP, SSM Session Manager for AWS, Azure Bastion for AKS. Each is well-integrated with its cloud's identity system. There's no software to install on your own network.
The limitation is that you now have three separate access stacks. Each one's logs land in that cloud's logging service. Device posture, if you enforce it, has to be configured three times. The user experience is three different login flows.
Cluster-side identity-aware proxy
Deploy a proxy inside each cluster (or network) that authenticates the user, passes their identity through to Kubernetes, and makes outbound-only connections to a control plane for coordination. The access path is the same regardless of which cloud the cluster lives in. One policy engine. One audit trail. One client.
This is the pattern Twingate's Kubernetes Operator implements, and it's the one worth looking at in detail.
How the cluster-side model works with Twingate
Twingate's architecture puts the trust boundary at the resource, not the network. For Kubernetes, that means the API server is treated as a resource, and access is granted per user to that specific resource. No VPC peering, no bastion, no exposed endpoints.
The Twingate Kubernetes Operator handles deployment: a Connector pod runs in the cluster and establishes an outbound-only connection to Twingate's Controller. The Operator also manages Gateway resources, which are the components that pass the authenticated user's identity through to kube-apiserver for RBAC evaluation.
Here's how the flow works for a kubectl command:
The user runs
kubectlon their laptop. The Twingate Client intercepts the DNS query for the cluster's API server hostname because an ACL entry matches.The Client requests authorization from the Controller, which checks the user's identity (via your IdP), device posture, and policy.
Once authorized, the Client establishes a TLS tunnel to the Gateway running in the cluster — direct peer-to-peer if possible, through a Relay if NAT prevents it. The Relay never decrypts traffic.
The Gateway independently verifies the ACL from the Controller, then proxies the request to kube-apiserver, injecting the user's identity.
Kubernetes RBAC evaluates the request against native Role and ClusterRole bindings for that user.
The two things that matter here for multi-cloud teams:
All three clusters look the same from the client's perspective. The EKS cluster, the GKE cluster, and the AKS cluster are each just a resource in Twingate. The user runs the same kubectl command. The policy engine is the same. The audit log is the same.
The user's real identity reaches Kubernetes RBAC. You write role bindings against your IdP's users and groups, not against IAM service accounts or shared kubeconfig credentials. This matters for audit: when someone deletes a production deployment, the audit log shows their name, not "the AWS role that someone assumed."
Deploying the Operator
A minimal installation of the Operator via Helm looks like this. The command installs the Operator into the twingate namespace with a reference to your Twingate tenant.
helm repo add twingate https://twingate.github.io/helm-charts helm install twingate-operator twingate/twingate-operator \ --namespace twingate --create-namespace \ --set twingateOperator.apiKey=$TWINGATE_API_KEY \ --set twingateOperator.network=$TWINGATE_NETWORK
From there, you define TwingateResource and TwingateConnector custom resources that map Kubernetes services (including kube-apiserver) to Twingate resources. The Operator handles reconciliation and keeps the Connector registered.
The same manifest shape works on EKS, GKE, and AKS. The underlying cluster still uses whatever control plane access model its cloud offers — it just no longer matters for the engineer doing the work.
What you give up, and what you don't
The cluster-side model doesn't eliminate your cloud's private control plane configuration. If anything, it coexists with it: the Connector is a workload inside the cluster, so it still needs network reachability to kube-apiserver, which is a short hop within the cluster itself. What you stop needing is any external access path to that endpoint — no VPN concentrator, no public endpoint, no authorized networks list to maintain.
You also don't get to drop IAM entirely. You'll still want IAM roles for workload identity and for your infrastructure pipelines. But for human access, the IdP becomes the single source of truth, and that's a meaningful simplification.
Closing
Multi-cloud Kubernetes is already complicated. Multi-cloud private control plane access shouldn't add to that complexity, but today it does, because each provider is solving the problem inside its own four walls. The cluster-side approach moves the access path out of the cloud provider's purview and into something you control uniformly.
For the full deployment walkthrough, Helm values reference, and examples of mapping Kubernetes services to Twingate resources, see the Twingate Kubernetes Operator documentation.
New to Twingate? You can use Twingate for free for up to 5 users, request a personalized demo, or reach out to the team over on the Twingate subreddit.
Rapidly implement a modern Zero Trust network that is more secure and maintainable than VPNs.
Three Clouds, Three Ways to Hide a Control Plane: Private Kubernetes Access Across EKS, GKE, and AKS

TL;DR: Each major managed Kubernetes service now offers its own flavor of private control plane access, and running clusters across all three means running three different access stacks. A cluster-side identity-aware proxy avoids the fragmentation. See the Twingate Kubernetes docs for the deployment pattern.
Last month a platform engineer I know spent half a week debugging why their new AKS cluster's API server wasn't reachable from the jump host that worked fine for their EKS and GKE clusters. The answer was Private Link endpoint policies interacting with a VNet peering setup that assumed a different DNS resolution path. Nothing was broken. Everything was configured exactly as each cloud's documentation prescribed. The clusters just didn't agree on what "private" meant.
This is the state of private Kubernetes control plane access in 2026. All three hyperscalers have landed on "the API server shouldn't be on the public internet," which is the right answer. But they got there by three different roads, and if you run clusters on more than one of them, you are now the integration layer.
The three private control plane models
Before getting into why this is a problem, it's worth pinning down what each provider actually offers. The shapes are genuinely different, not just branded differently.
EKS: private endpoints inside the VPC
Amazon EKS clusters can be configured with private endpoint access, which puts the API server behind an interface inside your VPC. Reaching it means being inside that VPC, inside a peered VPC, or routed in via Transit Gateway, Direct Connect, or Site-to-Site VPN. The endpoint resolves to an RFC 1918 address. Public DNS resolution of the cluster's FQDN still works, but it returns a private IP that only routes from connected networks.
Access control for the endpoint itself is network-level. IAM governs what you can do once you reach kube-apiserver, but reachability is a routing problem.
GKE: a DNS-based endpoint gated by IAM
Google introduced the DNS-based endpoint for GKE in 2024 and has been pushing it as the preferred model since. Each cluster gets a unique DNS name that resolves to an endpoint reachable from anywhere, but requests are gated by Google Cloud IAM at the frontend. No peering, no bastion, no authorized networks list to maintain.
It's a genuinely different model: the endpoint is globally reachable, but the authorization boundary sits at the Google front door rather than at the network edge. Whether this counts as "private" depends on your definition. For most compliance frameworks that care about network segmentation, it doesn't — which is why GKE still offers the older private cluster model with authorized networks.
AKS: API Server VNet Integration with Private Link
Azure's current recommended pattern is API Server VNet Integration combined with Private Link for fully private clusters. The API server is projected into a delegated subnet of your VNet, and Private Link gives you a private endpoint reachable through peered VNets or Azure ExpressRoute. Private DNS zones handle the FQDN resolution. The older "private cluster" model using a private endpoint to a Microsoft-managed network is still there, but VNet Integration is where Azure is steering new deployments.
Summary
EKS | GKE | AKS | |
|---|---|---|---|
Private model | Private endpoint in VPC | DNS-based endpoint, IAM-gated | API Server VNet Integration + Private Link |
Reachability | VPC, peered VPCs, VPN/Direct Connect | Anywhere with valid IAM | VNet, peered VNets, ExpressRoute/VPN |
Authorization boundary | Network edge | Google front door | Network edge |
DNS resolution | Public FQDN → private IP | Cluster-specific DNS name | Private DNS zone |
Access control | IAM + network routing | IAM only | Entra ID + network routing |
Each of these is a reasonable design. Each solves the "don't expose the API server" problem. They just don't solve it the same way.
What this costs multi-cloud teams
If you only live in one cloud, this is a non-issue. Pick the model, build the access path, move on. The pain starts when the same team operates clusters in two or three of these environments.
The engineer debugging access to a new cluster has to remember which cloud they're in, which access path applies, which identity system issues the credential that eventually gets mapped to Kubernetes RBAC, and which jump host or peering relationship is supposed to carry the connection. Three of these things used to be the same thing: you ran a VPN, you got on the network, you hit kube-apiserver. Now:
Reaching EKS might mean an AWS Client VPN, SSM Session Manager tunneling to a bastion, or a Direct Connect from the corporate network.
Reaching GKE's DNS endpoint means an IAM credential and nothing else, which is operationally lovely until you need to also audit the connection or require device posture.
Reaching AKS means being on a VNet, which in a hub-and-spoke topology means VPN or ExpressRoute into the hub and the right private DNS forwarding configured.
That's three identity systems (IAM, Google IAM, Entra ID), three network topologies, and at least three different runbooks for "I can't reach the cluster." The on-call rotation needs to know all of them. The platform team maintains all of them. Audit has to reconcile logs across all of them.
And none of this touches the actual Kubernetes RBAC question. Once you're through the front door, you still need the user's identity to map to a Kubernetes user or group so that kubectl commands are authorized against the cluster's role bindings. Each cloud handles that mapping differently too.
The categories of cross-cloud access options
Teams usually end up picking from one of four approaches. None of them are wrong. They have different tradeoffs.
Traditional VPNs and bastion hosts
Run an IPsec VPN or OpenVPN into each cloud's VPC/VNet, or SSH through a bastion. This is the "we've always done it this way" option. It's well understood, and most IAM-aware VPN appliances can enforce MFA at connection time.
The problem is that you get network-level access. Once you're on the VPC, you can reach anything the routing allows, which is usually more than kube-apiserver. You now have a VPN concentrator per cloud to patch, scale, and monitor, and the identity used at the VPN layer is separate from the identity Kubernetes sees.
Mesh VPN overlays (like Tailscale)
Install an agent on every node that needs connectivity, including subnet routers inside each cloud, and get a flat overlay network that spans clouds. This is operationally simpler than running three separate VPNs. Setup is fast.
The architectural tradeoff is the same as any mesh: everyone enrolled is on the same network. ACLs can restrict reachability, but the network is still enumerable from any compromised node, and lateral movement is a question of policy strictness rather than architecture. For a small team with high trust, this is fine. For an enterprise deploying hundreds of clusters across business units, the policy file becomes the bottleneck.
Cloud-native IAM gating
Use each cloud's native access path: IAP for GCP, SSM Session Manager for AWS, Azure Bastion for AKS. Each is well-integrated with its cloud's identity system. There's no software to install on your own network.
The limitation is that you now have three separate access stacks. Each one's logs land in that cloud's logging service. Device posture, if you enforce it, has to be configured three times. The user experience is three different login flows.
Cluster-side identity-aware proxy
Deploy a proxy inside each cluster (or network) that authenticates the user, passes their identity through to Kubernetes, and makes outbound-only connections to a control plane for coordination. The access path is the same regardless of which cloud the cluster lives in. One policy engine. One audit trail. One client.
This is the pattern Twingate's Kubernetes Operator implements, and it's the one worth looking at in detail.
How the cluster-side model works with Twingate
Twingate's architecture puts the trust boundary at the resource, not the network. For Kubernetes, that means the API server is treated as a resource, and access is granted per user to that specific resource. No VPC peering, no bastion, no exposed endpoints.
The Twingate Kubernetes Operator handles deployment: a Connector pod runs in the cluster and establishes an outbound-only connection to Twingate's Controller. The Operator also manages Gateway resources, which are the components that pass the authenticated user's identity through to kube-apiserver for RBAC evaluation.
Here's how the flow works for a kubectl command:
The user runs
kubectlon their laptop. The Twingate Client intercepts the DNS query for the cluster's API server hostname because an ACL entry matches.The Client requests authorization from the Controller, which checks the user's identity (via your IdP), device posture, and policy.
Once authorized, the Client establishes a TLS tunnel to the Gateway running in the cluster — direct peer-to-peer if possible, through a Relay if NAT prevents it. The Relay never decrypts traffic.
The Gateway independently verifies the ACL from the Controller, then proxies the request to kube-apiserver, injecting the user's identity.
Kubernetes RBAC evaluates the request against native Role and ClusterRole bindings for that user.
The two things that matter here for multi-cloud teams:
All three clusters look the same from the client's perspective. The EKS cluster, the GKE cluster, and the AKS cluster are each just a resource in Twingate. The user runs the same kubectl command. The policy engine is the same. The audit log is the same.
The user's real identity reaches Kubernetes RBAC. You write role bindings against your IdP's users and groups, not against IAM service accounts or shared kubeconfig credentials. This matters for audit: when someone deletes a production deployment, the audit log shows their name, not "the AWS role that someone assumed."
Deploying the Operator
A minimal installation of the Operator via Helm looks like this. The command installs the Operator into the twingate namespace with a reference to your Twingate tenant.
helm repo add twingate https://twingate.github.io/helm-charts helm install twingate-operator twingate/twingate-operator \ --namespace twingate --create-namespace \ --set twingateOperator.apiKey=$TWINGATE_API_KEY \ --set twingateOperator.network=$TWINGATE_NETWORK
From there, you define TwingateResource and TwingateConnector custom resources that map Kubernetes services (including kube-apiserver) to Twingate resources. The Operator handles reconciliation and keeps the Connector registered.
The same manifest shape works on EKS, GKE, and AKS. The underlying cluster still uses whatever control plane access model its cloud offers — it just no longer matters for the engineer doing the work.
What you give up, and what you don't
The cluster-side model doesn't eliminate your cloud's private control plane configuration. If anything, it coexists with it: the Connector is a workload inside the cluster, so it still needs network reachability to kube-apiserver, which is a short hop within the cluster itself. What you stop needing is any external access path to that endpoint — no VPN concentrator, no public endpoint, no authorized networks list to maintain.
You also don't get to drop IAM entirely. You'll still want IAM roles for workload identity and for your infrastructure pipelines. But for human access, the IdP becomes the single source of truth, and that's a meaningful simplification.
Closing
Multi-cloud Kubernetes is already complicated. Multi-cloud private control plane access shouldn't add to that complexity, but today it does, because each provider is solving the problem inside its own four walls. The cluster-side approach moves the access path out of the cloud provider's purview and into something you control uniformly.
For the full deployment walkthrough, Helm values reference, and examples of mapping Kubernetes services to Twingate resources, see the Twingate Kubernetes Operator documentation.
New to Twingate? You can use Twingate for free for up to 5 users, request a personalized demo, or reach out to the team over on the Twingate subreddit.
Solutions
Solutions
The VPN replacement your workforce will love.
Solutions