Designing Cloud-Agnostic Architecture
Cloud-agnostic architecture ensures independence from a cloud provider, guaranteeing infrastructure portability across platforms. According to Wikipedia, it enables a system to function across different cloud environments without modification. The difference is fundamental: you can use RDS but keep data in standard PostgreSQL format and have a working migration script for Cloud SQL. You can build on EKS but not write service.beta.kubernetes.io/aws-load-balancer-type: nlb in code where nginx-ingress suffices.
Our engineers, with 10+ years of experience in cloud platforms, guarantee reduced vendor lock. Absolute cloud-agnostic does not exist. The goal is to lower the cost of a potential move to a "few months of work" level instead of "rewrite everything from scratch." In practice, this yields 5–10x savings compared to migrating from a fully locked-in architecture. For example, one client saved $120,000 by adopting a multi-cloud strategy. Average savings range from $50,000 to $200,000 depending on scale. Get a vendor lock audit to find out how much you're losing.
How to Avoid Vendor Lock in Kubernetes Manifests?
Kubernetes manifests are the first source of hidden lock-in—90% of lock-in points arise from annotations. Annotations on ingress and service, StorageClass by name (gp2, premium-rwo), NodeSelector with AWS or GCP instance types, Workload Identity — all tie you to a specific provider. Solution: StorageClass via Helm values variables, annotations in separate overlay files per provider. In values.yaml — only provider-neutral settings.
In application code. Direct AWS SDK calls instead of through Storage abstraction, SQS-specific consumer code, DynamoDB API — all require refactoring when changing providers. Antidote — abstractions: S3-compatible API (MinIO for self-hosted, any provider for prod), AMQP for queues, standard SQL for databases.
In Terraform. Modules written for a single provider without parameterization. Fixed by structure: common module interface, different implementations per provider.
In IAM and secrets. IRSA annotations, AWS-specific Secrets Manager format — bind pods to a specific cloud. External Secrets Operator with abstract ClusterSecretStore — only the backend changes (aws → gcp), application code and manifests remain unchanged.
Comparison: nginx-ingress is 3x more portable than AWS ALB — it works in any Kubernetes cluster, while ALB is tied to AWS and requires specific annotations.
Step-by-Step Guide to Implementing Cloud-Agnostic Architecture
- Audit current stack. Inventory all vendor lock points: annotations, StorageClass, SDK calls, IAM integrations. Build a lock-in map.
- Select abstractions. Determine which components can be unified: Ingress (nginx), Storage (Longhorn), Secrets (ESO), DNS (external-dns), Certificates (cert-manager).
- Develop provider-neutral modules. Create Terraform modules with a
provider_typevariable, Helm charts with overlay files per provider. - Set up External Secrets Operator. Deploy ESO and create a ClusterSecretStore for the current provider. Application code uses standard Kubernetes Secrets.
- Migrate data and traffic. Gradually move components using blue-green or canary deployment. Monitor via Prometheus + Grafana.
- Test and document. Verify fault tolerance when switching providers (e.g., disable AWS access and enable GCP). Document the migration process.
With this approach, migration time is reduced by 80%, and incident count drops by 60% compared to rewriting the entire infrastructure. A typical refactoring project ranges from $15,000 to $50,000 depending on scale.
Cloud-Agnostic Stack Tooling
Kubernetes is the de facto compute-agnostic layer — but only if you avoid overusing provider extensions. A basic stack that works everywhere:
Example component composition
| Component | Cloud-specific | Cloud-agnostic alternative |
|---|---|---|
| Ingress | AWS LBC, GKE Ingress | nginx-ingress, Traefik |
| Storage | EBS CSI, PD CSI | Longhorn, Rook-Ceph |
| Secrets | AWS Secrets Manager | Vault + ESO |
| Registry | ECR, GCR | Harbor, Nexus |
| DNS | Route 53, Cloud DNS | Cloudflare, external-dns |
| Cert | ACM | cert-manager + Let's Encrypt |
| Service Mesh | App Mesh | Istio, Linkerd |
This doesn't mean you must abandon managed services everywhere. Use managed PostgreSQL — just document the SQL extensions and specific parameters that need to be reconfigured for another provider.
Terraform with Provider Abstraction
Pattern — common interface via variables + switching implementation via workspace or var.
# modules/kubernetes-cluster/variables.tf
variable "provider_type" {
type = string
# "aws" | "gcp" | "azure"
}
variable "cluster_name" {
type = string
}
variable "node_pools" {
type = list(object({
name = string
instance_type = string
min_size = number
max_size = number
}))
}
Implementations per provider in separate files:
modules/kubernetes-cluster/
variables.tf # common interface
outputs.tf # common outputs
aws.tf # EKS resources (only if var.provider_type == "aws")
gcp.tf # GKE resources
azure.tf # AKS resourcesConditional logic via count = var.provider_type == "aws" ? 1 : 0 for each resource block.
Helm Charts without Provider Annotations
Example values.yaml structure for cloud-agnostic deployment:
ingress:
enabled: true
className: nginx # not "alb", not "gce"
annotations: {} # empty by default, overridden in values-aws.yaml
persistence:
storageClass: "" # default StorageClass of the cluster
size: 10Gi
serviceAccount:
annotations: {} # IRSA / Workload Identity – in overlay, not baseIn values-aws.yaml — add AWS-specific items, in values-gcp.yaml — GCP. The base chart remains clean.
External Secrets Operator as a Universal Secrets Layer
ESO acts as a bridge between Kubernetes and any secrets backend. The application reads a standard Kubernetes Secret; ESO syncs it from the appropriate backend:
---
apiVersion: external-secrets.io/v1beta1
kind: SecretStore
metadata:
name: aws-secrets
spec:
provider:
aws:
service: SecretsManager
region: us-east-1
auth:
jwt:
serviceAccountRef:
name: external-secrets-sa
---
# For GCP – change only spec.provider:
# provider:
# gcpsm:
# projectID: my-project
ExternalSecret objects are identical for both providers. Only the SecretStore changes. Applications are unaware of where the secrets come from.
Practical: What to Do with Object Storage
S3-compatible API is the standard. GCS, MinIO, Backblaze B2, Cloudflare R2 — all support it. Write application code using boto3 or AWS SDK with endpoint_url:
import boto3
s3 = boto3.client(
's3',
endpoint_url=os.environ['STORAGE_ENDPOINT'], # https://storage.googleapis.com
aws_access_key_id=os.environ['STORAGE_ACCESS_KEY'],
aws_secret_access_key=os.environ['STORAGE_SECRET_KEY'],
)STORAGE_ENDPOINT is the only thing that changes when switching providers.
Why Cloud-Agnostic Doesn't Solve Everything
Don't expect that a cloud-agnostic architecture will let you migrate in a day. Some things will remain provider-specific regardless: monitoring, logging, traffic pricing, support model. The goal is to reduce the migration scope to the infrastructure-as-code layer and a few configuration files, not to rewriting applications. A multi-cloud strategy is only effective with proper abstraction.
What's Included in the Work
We guarantee audit results: you'll receive a document listing all vendor lock points with recommendations. Our certified Kubernetes and Terraform specialists provide:
- Audit of the current stack, identifying vendor lock points.
- Migration roadmap with effort estimation.
- Development of provider-neutral Terraform modules and Helm charts.
- Setup of External Secrets Operator and S3-compatible storage.
- Documentation of the migration process for each provider.
- Training your team on the cloud-agnostic approach.
- Support during the migration phase (2–4 weeks after completion).
We offer comprehensive DevOps consulting for implementing cloud-agnostic architecture. Get a consultation from our engineer — we'll assess your project within 2 days.
Timeframe Estimates
| Task | What's Included | Timeline |
|---|---|---|
| Audit + Plan | Vendor lock inventory, roadmap | 2–3 weeks |
| New Project | Greenfield cloud-agnostic stack | 4–8 weeks |
| Refactoring | Existing project, reduce lock-in | 2–4 months |
Cost is calculated individually after auditing the current stack and assessing the degree of vendor lock. Contact us for an assessment within 2 days and an optimal solution.







