How do I schedule workloads across multiple Kubernetes clusters?

Scheduling workloads across multiple Kubernetes clusters is usually done with a multi-cluster management layer rather than plain Kubernetes scheduling alone.

Common approaches

1) Use a multi-cluster orchestrator

Tools that can place workloads across clusters based on policies, capacity, latency, cost, or geography:

• Karmada: multi-cluster scheduling and propagation
• Open Cluster Management (OCM) / Red Hat ACM
• Google Anthos / Azure Arc / AWS EKS Anywhere integrations
• Rancher Fleet for GitOps-style multi-cluster deployment
• Argo CD / Flux for deploying the same app to many clusters

These tools manage:

• where a workload should run
• how many replicas per cluster
• failover / drift detection
• policy-based placement

2) Use GitOps + per-cluster placement

If you don’t need dynamic cross-cluster scheduling, you can:

• define the app in Git
• deploy to each cluster separately
• use cluster-specific overlays or values
• let an external controller decide placement

This is simpler and very common.

3) Use a global service layer

If the main goal is traffic distribution rather than workload placement:

• keep workloads in multiple clusters
• use global load balancing / DNS / service mesh
• route users to the nearest/healthiest cluster

Examples:

• Cloud load balancers
• ExternalDNS + geo DNS
• Istio multi-cluster / service mesh
• Cilium Cluster Mesh

How it works conceptually

A multi-cluster scheduler typically considers:

• node/cluster resource availability
• taints/tolerations
• labels/affinity/anti-affinity
• region/zone constraints
• SLA or cost policies
• failover rules

It then creates or migrates workloads into the chosen cluster.

If you want to build your own

A basic pattern is:

1. Register clusters in a central control plane
2. Collect cluster inventory:
   • CPU/memory capacity
   • health
   • labels like region, env, GPU availability
3. Define placement policy
   • e.g. “run prod in 2 regions,” “prefer cheapest cluster,” “keep data close”
4. Select target cluster(s)
5. Apply manifests to that cluster using kubeconfigs/service accounts
6. Continuously reconcile
   • move workloads if cluster becomes unhealthy or overloaded

Important Kubernetes primitives

Kubernetes itself schedules pods within one cluster using:

• nodeSelector
• affinity / anti-affinity
• taints / tolerations
• topologySpreadConstraints

For multiple clusters, you need something above native Kubernetes.

Recommended choice by use case

• Need true multi-cluster placement and failover: Karmada or OCM
• Need simple deployment to many clusters: Argo CD / Flux / Rancher Fleet
• Need traffic only across clusters: global LB / service mesh
• Need cloud-native managed solution: Anthos / Arc / ACM depending on provider

If you want, I can also show:

1. a reference architecture for multi-cluster scheduling, or
2. an example using Karmada / Argo CD / OCM.