Prompt
How do I choose an infrastructure as code tool for a multi-cloud setup?
Latest observation
Choosing an infrastructure as code (IaC) tool for a multi-cloud setup is mostly about balancing cloud coverage, abstraction level, team skills, and long-term maintainability.
1) Start with your requirements
Ask these first:
- Which clouds? AWS, Azure, GCP, Kubernetes, on-prem?
- How much portability do you really need?
- “Use multiple clouds” is different from “keep all infrastructure identical across clouds.”
- What are you provisioning?
- Cloud resources, networking, IAM, Kubernetes, databases, SaaS, edge, etc.
- Who will use it?
- DevOps, platform engineers, application teams?
- What matters most?
- Speed, standardization, safety, flexibility, or portability?
2) Compare the main IaC options
Terraform / OpenTofu
Best when you need broad multi-cloud support.
Pros
- Very large provider ecosystem
- Works well across AWS, Azure, GCP, Kubernetes, and many SaaS tools
- Mature state management and workflow
- Strong community and module ecosystem
Cons
- Can become complex at scale
- Abstraction is limited if you want one “universal” model across clouds
- Provider differences still leak into your code
- Licensing concerns with Terraform may push some teams to OpenTofu
Best for
- Most multi-cloud infrastructure provisioning use cases
Pulumi
Best when your team prefers general-purpose programming languages.
Pros
- Use Python, TypeScript, Go, C#, Java
- Good for reusable abstractions and programmatic logic
- Strong for teams that want software engineering practices in IaC
Cons
- Smaller ecosystem than Terraform/OpenTofu
- More freedom can mean more inconsistency
- State and lifecycle concepts still need discipline
Best for
- Teams comfortable writing infrastructure in code, not just declarative syntax
Crossplane
Best when you want Kubernetes as the control plane for infrastructure.
Pros
- Kubernetes-native approach
- Good for platform engineering and internal developer platforms
- Can manage cloud resources via Kubernetes CRDs
Cons
- Learning curve is steep
- Best fit depends on strong Kubernetes adoption
- Not always the simplest for general-purpose infrastructure
Best for
- Organizations already deeply invested in Kubernetes
Cloud-native tools
Examples:
- AWS CloudFormation/CDK
- Azure Bicep/ARM
- GCP Deployment Manager / Config Connector
Pros
- Best support for that cloud
- Often the most feature-complete for provider-specific capabilities
Cons
- Poor multi-cloud portability
- More than one tool to maintain if you use multiple clouds
Best for
- Single-cloud or cloud-specific teams, or specific edge cases within a multi-cloud estate
3) Key decision criteria
A. Multi-cloud support
- If you need one tool across multiple providers, Terraform/OpenTofu is usually the default choice.
- If you want deeper programmatic control, consider Pulumi.
- If your platform is Kubernetes-centric, consider Crossplane.
B. Abstraction vs. direct cloud control
- Low abstraction: Terraform/OpenTofu, CloudFormation/Bicep
Good when you want explicit, predictable infrastructure. - Higher abstraction: Pulumi, Crossplane
Good when you want reusable patterns and platform APIs.
C. Team expertise
- Terraform/OpenTofu: good if the team likes declarative config and standard IaC workflows.
- Pulumi: good if the team is strong in software development.
- Crossplane: good if the team knows Kubernetes deeply.
D. Ecosystem and provider support
Check whether your needed services are supported:
- VPC/VNet networking
- IAM/identity
- Kubernetes clusters
- Databases and managed services
- DNS, secrets, observability, CI/CD integrations
E. Operational maturity
Consider:
- State management
- Drift detection
- Testing support
- Module/versioning strategy
- Policy enforcement
- Secret handling
- CI/CD integration
4) Practical recommendation by scenario
Choose Terraform/OpenTofu if:
- You need broad, proven multi-cloud support
- You want the safest default
- You want a large ecosystem of modules and providers
- You need many different teams to adopt the same standard
Choose Pulumi if:
- Your team wants infrastructure in real programming languages
- You need complex logic, reusable libraries, or abstraction layers
- Developer experience matters more than strict declarative simplicity
Choose Crossplane if:
- Kubernetes is already your platform foundation
- You want self-service infrastructure through Kubernetes APIs
- You’re building an internal platform for app teams
Use cloud-native tools if:
- Your “multi-cloud” is really several separate cloud-specific stacks
- You need provider-specific features not well modeled elsewhere
- You’re optimizing for cloud-native best practices in each environment
5) A simple selection framework
If you want a quick rule:
-
Need broad multi-cloud support?
→ Start with Terraform/OpenTofu -
Need more expressive code and custom logic?
→ Consider Pulumi -
Kubernetes is your operating model?
→ Consider Crossplane -
Mostly one cloud with some extras?
→ Use that cloud’s native IaC for core components, and a cross-cloud tool where needed
6) Don’t forget these non-tool decisions
Your success depends as much on process as on the tool:
- Remote state backend and locking
- Module/version standards
- Environment separation
- Policy-as-code
- Secrets management
- Code review and CI/CD
- Drift detection and remediation
- Naming/tagging standards
7) A good default
For most organizations starting a multi-cloud IaC practice:
- Default choice: Terraform or OpenTofu
- If you want richer language support: Pulumi
- If you’re Kubernetes-first: Crossplane
If you want, I can also give you:
- a decision matrix comparing Terraform, Pulumi, and Crossplane, or
- a recommended architecture for multi-cloud IaC in a real organization.