The best solutions for remote kubectl access without a public IP

TL;DR: A look at five ways to run
kubectlagainst a cluster with no public API endpoint: bastions, VPNs, mesh overlays, cloud private-access proxies, and outbound-only connectors. Each is judged on exposure, credential handling, and per-command auditability.
Microsoft's August 2026 Patch Tuesday fixed CVE-2026-50516, a CVSS 9.4 missing-authentication flaw in Azure Kubernetes Service that let any attacker with network reach to the cluster escalate privileges. It was the second critical AKS privilege-escalation bug in four months, following April's CVE-2026-33105.
You can't patch, inspect, or audit a managed control plane. What you can control is which networks and people can reach it. A private API endpoint shrinks the set of attackers who can even attempt a network-reachable flaw, but only if the way your engineers get in doesn't hand that reach back out.
This guide compares the five realistic ways to run kubectl against a private cluster, and shows which ones preserve what the private endpoint was meant to protect.
What "no public IP" actually means
Private clusters disable the public API server endpoint. In AKS this is the --enable-private-cluster flag; in GKE it's --enable-private-endpoint; in EKS it's setting endpointPublicAccess=false. The API server gets a VPC-internal address and DNS record. External kubectl calls fail at the network layer before TLS, before auth, before anything.
This is by design. A missing-auth bug in the control plane is an unexploitable bug if the attacker can't open a TCP connection to port 443 on the API server. You've moved the question from "is this managed service's auth correct?" (which you can't verify) to "can this person reach the network?" (which you can).
The five approaches below all answer "how do my engineers still run kubectl?" but they answer it differently, and some of them quietly re-open the attack surface the private cluster was meant to close.
Option 1: Bastion host with SSH tunnel
A jump box inside the VPC, SSH exposed on port 22 (or a non-standard port, which doesn't matter), engineers SSH in and either run kubectl on the bastion or forward a local port to the API server.
Exposure: Port 22 (or your chosen port) open to the internet, or to a restricted IP allowlist if you maintain one. SSH itself has a solid track record, but you are now responsible for patching sshd, rotating host keys, managing authorized_keys or an SSH CA, and preventing drift across bastions.
Credentials: Two layers: SSH keys for the bastion, kubeconfig for the cluster. Kubeconfigs end up sprawled across laptops. Rotation requires touching every engineer's machine. Offboarding a contractor means revoking SSH access and the kubeconfig, and hoping no one copied the token.
Audit trail: SSH login events, yes. Per-kubectl-command attribution? Only if you force everyone to run commands on the bastion itself and ship shell history to a SIEM, which no one actually does. Local port-forwards make the commands invisible to the bastion.
Bastions work. They scale poorly, they age badly, and they put a permanently-listening SSH daemon on the public internet. For a cluster whose entire purpose for being private was to not have a permanently-listening thing on the public internet, that trade is worth questioning.
Option 2: Traditional VPN (IPsec, OpenVPN)
Stand up a VPN concentrator in the VPC. Engineers connect, get a routable IP inside the network, and kubectl hits the private API server directly.
Exposure: VPN endpoint on the public internet. Historically this a rich target: Fortinet, Pulse Secure, and Ivanti have all shipped critical pre-auth RCEs in the last three years. A VPN appliance vulnerability doesn't just expose the cluster; it exposes the whole VPC.
Credentials: VPN credentials plus kubeconfig. You end up with the same sprawl problem as bastions. Worse, once on the VPN, the user has IP-level reach to everything in the subnet, not just the API server. A compromised laptop can scan the network, probe for other services, and attempt lateral movement well beyond Kubernetes.
Audit trail: Connection logs. No per-command visibility. The VPN has no idea whether the authenticated user ran kubectl get pods or kubectl delete deployment production-api.
Traditional VPNs give users network membership. For API server access, network membership is massively more than you need and more than you want to give.
Option 3: Mesh VPN overlay (like Tailscale)
Install an agent on the user's device and on something inside the VPC (often a subnet router node) and let the mesh route traffic between them. The API server stays private; the mesh provides the path.
Exposure: Nothing inbound. The mesh uses outbound connections to a coordination server (which, for the hosted option, sits on AWS US-East and is subject to the CLOUD Act). Better than a bastion or VPN on the exposure dimension.
Credentials: Still a kubeconfig per user. Mesh ACLs can restrict which users reach the API server, but the kubeconfig token itself is unchanged. That's the same sprawl, same rotation burden, and the same "did we actually remove this when the contractor left?" problem.
Audit trail: Mesh flow logs show connection metadata (which device talked to which, over which port). Per-command attribution is not a native feature. You get "user X opened a connection to the API server at 14:02"; you don't get "user X ran kubectl exec into the payments pod."
Mesh overlays are a significant improvement over bastions and VPNs on exposure. They don't solve credential distribution or command-level audit, and the mesh model still places users on a shared virtual network where a compromised node can enumerate peers.
Option 4: Cloud-provider private access proxies
AWS has EKS with VPC endpoints and the Pod Identity / IAM authenticator chain; GKE offers Connect Gateway; AKS has API Server VNet Integration with Azure Bastion or private endpoints. Each lets you route kubectl through cloud-native plumbing without a public API endpoint.
Exposure: Minimal. Everything routes through authenticated cloud APIs, making these tools strong on this dimension.
Credentials: Cloud IAM identities used to request short-lived tokens. This is the best credential story of the five if you are all-in on one cloud. Rotation is automatic, offboarding is federation-driven, and kubeconfig sprawl mostly disappears.
Audit trail: Cloud audit logs capture the authentication event (IAM principal X called the cluster auth API). Kubernetes audit logs capture the API-server-side action. Stitching the two together for a per-command trail is doable but non-trivial, and the trail lives in two separate systems you need to correlate.
Catch: You're locked to a single cloud's model. Multi-cloud or hybrid shops end up running a different access solution per cluster. And the control plane you're reaching through this path is the same managed control plane that just had the pre-auth CVE: the cloud's own IAM layer is doing the gating, which is strong, but it's gating access to the exact component that had the bug.
Option 5: Outbound-only connections with an identity-aware gateway
A connector runs inside the cluster (via Helm, as a pod), makes only outbound connections, and brokers access to the API server. An identity-aware gateway sits in front of kubectl sessions, authenticates each user against the corporate IdP, passes the user's identity through to the API server so native Kubernetes RBAC still handles authorization, and logs each command.
Exposure: Zero inbound. No listening ports on the internet, no bastion, no VPN concentrator. The connector reaches out; nothing reaches in. The cluster's attack surface from the internet is unchanged from a fully-private cluster with no access solution installed at all.
Credentials: Users don't hold long-lived kubeconfigs. They authenticate to the IdP (with MFA, conditional access, whatever the org already enforces), and the gateway mints the connection to the cluster using the user's passed-through identity. Offboarding is a single action in the IdP — disable the user, and their kubectl access ends with their next command.
Audit trail: Per-command logs, tied to the authenticated human, stored on the customer's own infrastructure. Not "a connection happened." The actual command.
This is where Twingate fits. Twingate's Connector is deployed into the cluster (there's a Helm chart for it), makes only outbound connections to the Twingate relay infrastructure, and is paired with Privileged Access for Kubernetes to handle the identity pass-through and per-command logging. Native Kubernetes RBAC still owns authorization — the gateway doesn't replace it, it feeds the user's verified identity into it.
Comparison
Approach | Internet exposure | Credential model | Per-command audit |
|---|---|---|---|
Bastion + SSH tunnel | SSH port open | Long-lived SSH keys + kubeconfig per user | No (connection logs only) |
Traditional VPN | VPN endpoint open | Long-lived VPN creds + kubeconfig per user | No (connection logs only) |
Mesh VPN overlay | None inbound | kubeconfig per user, mesh ACLs | No (flow logs only) |
Cloud private-access proxy | None inbound | Short-lived cloud-IAM tokens | Partial (split across cloud + K8s logs) |
Outbound-only connector + identity-aware gateway | None inbound | IdP auth, no user-held kubeconfigs | Yes (per command, tied to user) |
How to decide
If you're running one cluster on one cloud and your engineers are already deep in that cloud's IAM, the native private-access proxy is probably the cleanest answer. You trade portability for integration.
If you're multi-cloud, hybrid, or running clusters in places the cloud-native option doesn't reach (on-prem, edge, self-managed K8s on bare metal), the outbound-only connector model is the only one of the five that gives you consistent exposure, credential, and audit behavior across all of them.
If you're currently on a bastion or traditional VPN, the question isn't really about Kubernetes. It's whether you want to keep a listening service on the internet protecting infrastructure that exists specifically because you didn't want a listening service on the internet. The AKS CVEs are a reminder that the attacker doesn't need to compromise the thing you're protecting — they just need to reach it.
Closing
For more on deploying the Twingate Connector into a Kubernetes cluster and configuring Privileged Access for Kubernetes, see the Twingate Kubernetes documentation and the Privileged Access for Kubernetes guide.
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.
The best solutions for remote kubectl access without a public IP

TL;DR: A look at five ways to run
kubectlagainst a cluster with no public API endpoint: bastions, VPNs, mesh overlays, cloud private-access proxies, and outbound-only connectors. Each is judged on exposure, credential handling, and per-command auditability.
Microsoft's August 2026 Patch Tuesday fixed CVE-2026-50516, a CVSS 9.4 missing-authentication flaw in Azure Kubernetes Service that let any attacker with network reach to the cluster escalate privileges. It was the second critical AKS privilege-escalation bug in four months, following April's CVE-2026-33105.
You can't patch, inspect, or audit a managed control plane. What you can control is which networks and people can reach it. A private API endpoint shrinks the set of attackers who can even attempt a network-reachable flaw, but only if the way your engineers get in doesn't hand that reach back out.
This guide compares the five realistic ways to run kubectl against a private cluster, and shows which ones preserve what the private endpoint was meant to protect.
What "no public IP" actually means
Private clusters disable the public API server endpoint. In AKS this is the --enable-private-cluster flag; in GKE it's --enable-private-endpoint; in EKS it's setting endpointPublicAccess=false. The API server gets a VPC-internal address and DNS record. External kubectl calls fail at the network layer before TLS, before auth, before anything.
This is by design. A missing-auth bug in the control plane is an unexploitable bug if the attacker can't open a TCP connection to port 443 on the API server. You've moved the question from "is this managed service's auth correct?" (which you can't verify) to "can this person reach the network?" (which you can).
The five approaches below all answer "how do my engineers still run kubectl?" but they answer it differently, and some of them quietly re-open the attack surface the private cluster was meant to close.
Option 1: Bastion host with SSH tunnel
A jump box inside the VPC, SSH exposed on port 22 (or a non-standard port, which doesn't matter), engineers SSH in and either run kubectl on the bastion or forward a local port to the API server.
Exposure: Port 22 (or your chosen port) open to the internet, or to a restricted IP allowlist if you maintain one. SSH itself has a solid track record, but you are now responsible for patching sshd, rotating host keys, managing authorized_keys or an SSH CA, and preventing drift across bastions.
Credentials: Two layers: SSH keys for the bastion, kubeconfig for the cluster. Kubeconfigs end up sprawled across laptops. Rotation requires touching every engineer's machine. Offboarding a contractor means revoking SSH access and the kubeconfig, and hoping no one copied the token.
Audit trail: SSH login events, yes. Per-kubectl-command attribution? Only if you force everyone to run commands on the bastion itself and ship shell history to a SIEM, which no one actually does. Local port-forwards make the commands invisible to the bastion.
Bastions work. They scale poorly, they age badly, and they put a permanently-listening SSH daemon on the public internet. For a cluster whose entire purpose for being private was to not have a permanently-listening thing on the public internet, that trade is worth questioning.
Option 2: Traditional VPN (IPsec, OpenVPN)
Stand up a VPN concentrator in the VPC. Engineers connect, get a routable IP inside the network, and kubectl hits the private API server directly.
Exposure: VPN endpoint on the public internet. Historically this a rich target: Fortinet, Pulse Secure, and Ivanti have all shipped critical pre-auth RCEs in the last three years. A VPN appliance vulnerability doesn't just expose the cluster; it exposes the whole VPC.
Credentials: VPN credentials plus kubeconfig. You end up with the same sprawl problem as bastions. Worse, once on the VPN, the user has IP-level reach to everything in the subnet, not just the API server. A compromised laptop can scan the network, probe for other services, and attempt lateral movement well beyond Kubernetes.
Audit trail: Connection logs. No per-command visibility. The VPN has no idea whether the authenticated user ran kubectl get pods or kubectl delete deployment production-api.
Traditional VPNs give users network membership. For API server access, network membership is massively more than you need and more than you want to give.
Option 3: Mesh VPN overlay (like Tailscale)
Install an agent on the user's device and on something inside the VPC (often a subnet router node) and let the mesh route traffic between them. The API server stays private; the mesh provides the path.
Exposure: Nothing inbound. The mesh uses outbound connections to a coordination server (which, for the hosted option, sits on AWS US-East and is subject to the CLOUD Act). Better than a bastion or VPN on the exposure dimension.
Credentials: Still a kubeconfig per user. Mesh ACLs can restrict which users reach the API server, but the kubeconfig token itself is unchanged. That's the same sprawl, same rotation burden, and the same "did we actually remove this when the contractor left?" problem.
Audit trail: Mesh flow logs show connection metadata (which device talked to which, over which port). Per-command attribution is not a native feature. You get "user X opened a connection to the API server at 14:02"; you don't get "user X ran kubectl exec into the payments pod."
Mesh overlays are a significant improvement over bastions and VPNs on exposure. They don't solve credential distribution or command-level audit, and the mesh model still places users on a shared virtual network where a compromised node can enumerate peers.
Option 4: Cloud-provider private access proxies
AWS has EKS with VPC endpoints and the Pod Identity / IAM authenticator chain; GKE offers Connect Gateway; AKS has API Server VNet Integration with Azure Bastion or private endpoints. Each lets you route kubectl through cloud-native plumbing without a public API endpoint.
Exposure: Minimal. Everything routes through authenticated cloud APIs, making these tools strong on this dimension.
Credentials: Cloud IAM identities used to request short-lived tokens. This is the best credential story of the five if you are all-in on one cloud. Rotation is automatic, offboarding is federation-driven, and kubeconfig sprawl mostly disappears.
Audit trail: Cloud audit logs capture the authentication event (IAM principal X called the cluster auth API). Kubernetes audit logs capture the API-server-side action. Stitching the two together for a per-command trail is doable but non-trivial, and the trail lives in two separate systems you need to correlate.
Catch: You're locked to a single cloud's model. Multi-cloud or hybrid shops end up running a different access solution per cluster. And the control plane you're reaching through this path is the same managed control plane that just had the pre-auth CVE: the cloud's own IAM layer is doing the gating, which is strong, but it's gating access to the exact component that had the bug.
Option 5: Outbound-only connections with an identity-aware gateway
A connector runs inside the cluster (via Helm, as a pod), makes only outbound connections, and brokers access to the API server. An identity-aware gateway sits in front of kubectl sessions, authenticates each user against the corporate IdP, passes the user's identity through to the API server so native Kubernetes RBAC still handles authorization, and logs each command.
Exposure: Zero inbound. No listening ports on the internet, no bastion, no VPN concentrator. The connector reaches out; nothing reaches in. The cluster's attack surface from the internet is unchanged from a fully-private cluster with no access solution installed at all.
Credentials: Users don't hold long-lived kubeconfigs. They authenticate to the IdP (with MFA, conditional access, whatever the org already enforces), and the gateway mints the connection to the cluster using the user's passed-through identity. Offboarding is a single action in the IdP — disable the user, and their kubectl access ends with their next command.
Audit trail: Per-command logs, tied to the authenticated human, stored on the customer's own infrastructure. Not "a connection happened." The actual command.
This is where Twingate fits. Twingate's Connector is deployed into the cluster (there's a Helm chart for it), makes only outbound connections to the Twingate relay infrastructure, and is paired with Privileged Access for Kubernetes to handle the identity pass-through and per-command logging. Native Kubernetes RBAC still owns authorization — the gateway doesn't replace it, it feeds the user's verified identity into it.
Comparison
Approach | Internet exposure | Credential model | Per-command audit |
|---|---|---|---|
Bastion + SSH tunnel | SSH port open | Long-lived SSH keys + kubeconfig per user | No (connection logs only) |
Traditional VPN | VPN endpoint open | Long-lived VPN creds + kubeconfig per user | No (connection logs only) |
Mesh VPN overlay | None inbound | kubeconfig per user, mesh ACLs | No (flow logs only) |
Cloud private-access proxy | None inbound | Short-lived cloud-IAM tokens | Partial (split across cloud + K8s logs) |
Outbound-only connector + identity-aware gateway | None inbound | IdP auth, no user-held kubeconfigs | Yes (per command, tied to user) |
How to decide
If you're running one cluster on one cloud and your engineers are already deep in that cloud's IAM, the native private-access proxy is probably the cleanest answer. You trade portability for integration.
If you're multi-cloud, hybrid, or running clusters in places the cloud-native option doesn't reach (on-prem, edge, self-managed K8s on bare metal), the outbound-only connector model is the only one of the five that gives you consistent exposure, credential, and audit behavior across all of them.
If you're currently on a bastion or traditional VPN, the question isn't really about Kubernetes. It's whether you want to keep a listening service on the internet protecting infrastructure that exists specifically because you didn't want a listening service on the internet. The AKS CVEs are a reminder that the attacker doesn't need to compromise the thing you're protecting — they just need to reach it.
Closing
For more on deploying the Twingate Connector into a Kubernetes cluster and configuring Privileged Access for Kubernetes, see the Twingate Kubernetes documentation and the Privileged Access for Kubernetes guide.
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.
The best solutions for remote kubectl access without a public IP

TL;DR: A look at five ways to run
kubectlagainst a cluster with no public API endpoint: bastions, VPNs, mesh overlays, cloud private-access proxies, and outbound-only connectors. Each is judged on exposure, credential handling, and per-command auditability.
Microsoft's August 2026 Patch Tuesday fixed CVE-2026-50516, a CVSS 9.4 missing-authentication flaw in Azure Kubernetes Service that let any attacker with network reach to the cluster escalate privileges. It was the second critical AKS privilege-escalation bug in four months, following April's CVE-2026-33105.
You can't patch, inspect, or audit a managed control plane. What you can control is which networks and people can reach it. A private API endpoint shrinks the set of attackers who can even attempt a network-reachable flaw, but only if the way your engineers get in doesn't hand that reach back out.
This guide compares the five realistic ways to run kubectl against a private cluster, and shows which ones preserve what the private endpoint was meant to protect.
What "no public IP" actually means
Private clusters disable the public API server endpoint. In AKS this is the --enable-private-cluster flag; in GKE it's --enable-private-endpoint; in EKS it's setting endpointPublicAccess=false. The API server gets a VPC-internal address and DNS record. External kubectl calls fail at the network layer before TLS, before auth, before anything.
This is by design. A missing-auth bug in the control plane is an unexploitable bug if the attacker can't open a TCP connection to port 443 on the API server. You've moved the question from "is this managed service's auth correct?" (which you can't verify) to "can this person reach the network?" (which you can).
The five approaches below all answer "how do my engineers still run kubectl?" but they answer it differently, and some of them quietly re-open the attack surface the private cluster was meant to close.
Option 1: Bastion host with SSH tunnel
A jump box inside the VPC, SSH exposed on port 22 (or a non-standard port, which doesn't matter), engineers SSH in and either run kubectl on the bastion or forward a local port to the API server.
Exposure: Port 22 (or your chosen port) open to the internet, or to a restricted IP allowlist if you maintain one. SSH itself has a solid track record, but you are now responsible for patching sshd, rotating host keys, managing authorized_keys or an SSH CA, and preventing drift across bastions.
Credentials: Two layers: SSH keys for the bastion, kubeconfig for the cluster. Kubeconfigs end up sprawled across laptops. Rotation requires touching every engineer's machine. Offboarding a contractor means revoking SSH access and the kubeconfig, and hoping no one copied the token.
Audit trail: SSH login events, yes. Per-kubectl-command attribution? Only if you force everyone to run commands on the bastion itself and ship shell history to a SIEM, which no one actually does. Local port-forwards make the commands invisible to the bastion.
Bastions work. They scale poorly, they age badly, and they put a permanently-listening SSH daemon on the public internet. For a cluster whose entire purpose for being private was to not have a permanently-listening thing on the public internet, that trade is worth questioning.
Option 2: Traditional VPN (IPsec, OpenVPN)
Stand up a VPN concentrator in the VPC. Engineers connect, get a routable IP inside the network, and kubectl hits the private API server directly.
Exposure: VPN endpoint on the public internet. Historically this a rich target: Fortinet, Pulse Secure, and Ivanti have all shipped critical pre-auth RCEs in the last three years. A VPN appliance vulnerability doesn't just expose the cluster; it exposes the whole VPC.
Credentials: VPN credentials plus kubeconfig. You end up with the same sprawl problem as bastions. Worse, once on the VPN, the user has IP-level reach to everything in the subnet, not just the API server. A compromised laptop can scan the network, probe for other services, and attempt lateral movement well beyond Kubernetes.
Audit trail: Connection logs. No per-command visibility. The VPN has no idea whether the authenticated user ran kubectl get pods or kubectl delete deployment production-api.
Traditional VPNs give users network membership. For API server access, network membership is massively more than you need and more than you want to give.
Option 3: Mesh VPN overlay (like Tailscale)
Install an agent on the user's device and on something inside the VPC (often a subnet router node) and let the mesh route traffic between them. The API server stays private; the mesh provides the path.
Exposure: Nothing inbound. The mesh uses outbound connections to a coordination server (which, for the hosted option, sits on AWS US-East and is subject to the CLOUD Act). Better than a bastion or VPN on the exposure dimension.
Credentials: Still a kubeconfig per user. Mesh ACLs can restrict which users reach the API server, but the kubeconfig token itself is unchanged. That's the same sprawl, same rotation burden, and the same "did we actually remove this when the contractor left?" problem.
Audit trail: Mesh flow logs show connection metadata (which device talked to which, over which port). Per-command attribution is not a native feature. You get "user X opened a connection to the API server at 14:02"; you don't get "user X ran kubectl exec into the payments pod."
Mesh overlays are a significant improvement over bastions and VPNs on exposure. They don't solve credential distribution or command-level audit, and the mesh model still places users on a shared virtual network where a compromised node can enumerate peers.
Option 4: Cloud-provider private access proxies
AWS has EKS with VPC endpoints and the Pod Identity / IAM authenticator chain; GKE offers Connect Gateway; AKS has API Server VNet Integration with Azure Bastion or private endpoints. Each lets you route kubectl through cloud-native plumbing without a public API endpoint.
Exposure: Minimal. Everything routes through authenticated cloud APIs, making these tools strong on this dimension.
Credentials: Cloud IAM identities used to request short-lived tokens. This is the best credential story of the five if you are all-in on one cloud. Rotation is automatic, offboarding is federation-driven, and kubeconfig sprawl mostly disappears.
Audit trail: Cloud audit logs capture the authentication event (IAM principal X called the cluster auth API). Kubernetes audit logs capture the API-server-side action. Stitching the two together for a per-command trail is doable but non-trivial, and the trail lives in two separate systems you need to correlate.
Catch: You're locked to a single cloud's model. Multi-cloud or hybrid shops end up running a different access solution per cluster. And the control plane you're reaching through this path is the same managed control plane that just had the pre-auth CVE: the cloud's own IAM layer is doing the gating, which is strong, but it's gating access to the exact component that had the bug.
Option 5: Outbound-only connections with an identity-aware gateway
A connector runs inside the cluster (via Helm, as a pod), makes only outbound connections, and brokers access to the API server. An identity-aware gateway sits in front of kubectl sessions, authenticates each user against the corporate IdP, passes the user's identity through to the API server so native Kubernetes RBAC still handles authorization, and logs each command.
Exposure: Zero inbound. No listening ports on the internet, no bastion, no VPN concentrator. The connector reaches out; nothing reaches in. The cluster's attack surface from the internet is unchanged from a fully-private cluster with no access solution installed at all.
Credentials: Users don't hold long-lived kubeconfigs. They authenticate to the IdP (with MFA, conditional access, whatever the org already enforces), and the gateway mints the connection to the cluster using the user's passed-through identity. Offboarding is a single action in the IdP — disable the user, and their kubectl access ends with their next command.
Audit trail: Per-command logs, tied to the authenticated human, stored on the customer's own infrastructure. Not "a connection happened." The actual command.
This is where Twingate fits. Twingate's Connector is deployed into the cluster (there's a Helm chart for it), makes only outbound connections to the Twingate relay infrastructure, and is paired with Privileged Access for Kubernetes to handle the identity pass-through and per-command logging. Native Kubernetes RBAC still owns authorization — the gateway doesn't replace it, it feeds the user's verified identity into it.
Comparison
Approach | Internet exposure | Credential model | Per-command audit |
|---|---|---|---|
Bastion + SSH tunnel | SSH port open | Long-lived SSH keys + kubeconfig per user | No (connection logs only) |
Traditional VPN | VPN endpoint open | Long-lived VPN creds + kubeconfig per user | No (connection logs only) |
Mesh VPN overlay | None inbound | kubeconfig per user, mesh ACLs | No (flow logs only) |
Cloud private-access proxy | None inbound | Short-lived cloud-IAM tokens | Partial (split across cloud + K8s logs) |
Outbound-only connector + identity-aware gateway | None inbound | IdP auth, no user-held kubeconfigs | Yes (per command, tied to user) |
How to decide
If you're running one cluster on one cloud and your engineers are already deep in that cloud's IAM, the native private-access proxy is probably the cleanest answer. You trade portability for integration.
If you're multi-cloud, hybrid, or running clusters in places the cloud-native option doesn't reach (on-prem, edge, self-managed K8s on bare metal), the outbound-only connector model is the only one of the five that gives you consistent exposure, credential, and audit behavior across all of them.
If you're currently on a bastion or traditional VPN, the question isn't really about Kubernetes. It's whether you want to keep a listening service on the internet protecting infrastructure that exists specifically because you didn't want a listening service on the internet. The AKS CVEs are a reminder that the attacker doesn't need to compromise the thing you're protecting — they just need to reach it.
Closing
For more on deploying the Twingate Connector into a Kubernetes cluster and configuring Privileged Access for Kubernetes, see the Twingate Kubernetes documentation and the Privileged Access for Kubernetes guide.
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