The fastest way to connect two Kubernetes clusters in different clouds is also the most dangerous way: join them into one flat network, share service discovery, and let any pod in one cluster reach any service in the other. It demos well. It also means a compromised workload in the least protected cluster now has a network path into every cluster, and an outage or a bad route in one place can spread to all of them.
Multi-cloud Kubernetes is common for ordinary reasons. One cloud hosts the GPU training cluster, another hosts the customer facing services, a third was inherited or chosen for a specific managed service. The clusters need to talk. They do not need to become one cluster, and they should not become one trust zone.
Start with the flows, not with connectivity
Before choosing any tool, list the actual cross-cluster flows. In most estates the real list is short:
- A named service in cluster A calls a named service in cluster B, on a known port, for a known reason.
- A data job reads from or writes to a store that happens to live near the other cluster.
- Operators need logs, metrics, and traces from both clusters in one place.
That list is the design. If a flow is not on it, it should not work by default. Connectivity products and mesh tools make it easy to connect everything first and restrict later, but later rarely arrives. Start restricted, with the named flows working, and add flows deliberately as teams request them with an owner and a reason.
This also settles the addressing argument early. Pod and service address ranges often overlap between clusters, especially when each cluster was built from the same tutorial defaults. Overlap only matters for flows that actually cross. A gateway pattern, described below, avoids renumbering every cluster just so that two services can talk.
Connect services through gateways, not networks through tunnels
Treat each cluster as its own network domain, with its own pod ranges, service ranges, policies, and failure modes. Between domains, place an explicit crossing point:
- Each cluster exposes only the services that other clusters are allowed to use, through a dedicated gateway or egress and ingress pair, not through direct pod to pod routing.
- Traffic crosses the private cross-cloud path between those gateways, so the path can be measured, encrypted, and audited in one place.
- Inside the receiving cluster, the gateway hands traffic to the target service only. It does not become a general router into the pod network.
The cost is a small amount of extra latency and one more component to run. The gain is large: each cluster keeps its own addressing, its own network policy, and its own blast radius. A route leak, a misconfigured policy, or a noisy workload inside one cluster stays inside that cluster, because there is no flat network for it to leak across.
It also makes the cross-cloud path honest. When all cross-cluster traffic passes through known gateways, capacity, errors, and latency on that path can be measured per flow. When traffic can cross anywhere, nobody can say which flows depend on the link until the link fails.
Identity should cross, addresses should not be trusted
On a flat network, teams quietly start trusting source addresses: allow traffic from the other cluster range. That trust is misplaced. An address says where a packet came from, not which workload sent it or whether that workload was allowed to call this service.
Use workload identity at the gateway and at the receiving service:
- Each calling service presents a verifiable identity, issued per cluster and rotated automatically, rather than a shared secret copied between clusters.
- The receiving service authorises the calling identity for that specific operation, not the source network for all operations.
- Identity mappings are written down per flow, matching the flow list from the first section, so a reviewer can check who can call what without reading packet rules.
This is where many multi-cloud designs quietly fail. The two clouds issue identity differently, so teams fall back to network rules because they work everywhere. Resist that fallback for cross-cluster calls. Network rules can stay as a second layer, limiting which gateways can talk, while identity decides which workloads can.
Keep discovery local, publish a small directory
Shared global service discovery sounds convenient and creates a hidden dependency: when discovery breaks or returns stale answers, calls fail across every cluster at once, and a service that was only meant to be local becomes reachable everywhere because it was registered globally.
A safer pattern is boring. Each cluster keeps its own local discovery for its own services. For the small set of cross-cluster services, publish a small, explicit directory: name, owning team, gateway address, port, and the identity allowed to call it. That directory can be configuration in the gateway or a simple internal record, as long as it is reviewed like code and changes to it are visible.
When a cross-cluster service moves, only its directory entry changes. When a team wants a new cross-cluster dependency, adding the entry is the review point. That friction is a feature. Cross-cluster dependencies are architectural decisions, not accidents of discovery.
Plan for one cluster to be down, or untrusted
Two failure questions should be answered before the design ships:
First, if one cluster is down, what should the other cluster do? With gateway connections and local discovery, the answer can be per flow: queue the work, serve a cached answer, or fail that one feature. On a flat joined network, the failure tends to be global and surprising, because timeouts and retries cross the boundary in ways nobody listed.
Second, if one cluster is compromised, what can an attacker reach? The honest answer should be: the gateway, and only the services and operations that gateway was allowed to present, with identities that the compromised cluster cannot mint for other clusters. Test this. From a test workload in one cluster, try to reach a service that is not on the flow list, a pod address directly, and the other cluster API. All three should fail, and the attempts should be visible in logs.
Retries deserve a specific mention here. A calling service that retries aggressively across a slow cross-cloud path can turn a small problem in one cluster into a load problem in both. Set retry budgets and timeouts for cross-cluster calls separately from local calls, and make them stricter, because the path is longer and the shared resource, the link, is smaller.
A practical rollout order
For an estate connecting clusters that already exist, this order works without a flag day:
- Inventory the flows that already cross informally, including scripts, jobs, and operator access, not just application calls.
- Stand up the gateways on the private path and route one low risk flow through them, measuring latency and errors against the old route.
- Add identity checks for that flow, then remove the old network level permission for it.
- Move remaining flows one at a time, deleting the broad rule that made the informal route work only after the last flow has moved.
- Run the down cluster and untrusted cluster tests, and record the results with the flow list.
Notice what is not in that list: renumbering clusters, replacing the container network, or adopting a single control plane for every cluster. Those may be worth doing for other reasons, but they are not prerequisites for safe cross-cluster traffic, and tying them together turns a bounded network project into an open ended platform rebuild.
The design point
Clusters in different clouds need to cooperate, not merge. Keep each cluster as its own domain, cross between domains only at gateways, authorise workloads by identity rather than by address, publish only the services that are genuinely shared, and test what happens when one side is down or untrusted.
That kind of bounded, private multi-cloud design across AWS, Azure, Google Cloud, and Oracle estates is part of the work described at CloudVerg, where VergMesh covers multi-cloud networking and VergShield covers zero-trust security, alongside SOC 2 readiness support and managed services.
The test is simple. Pick any service in one cluster and ask what it can reach in the other, who approved that reach, and what happens if the other cluster disappears. If the team can answer from a short flow list, the clusters are connected well. If the answer is everything, they are not connected. They are flattened.
Top comments (0)