Amazon Elastic Kubernetes Service adoption requires more than launching a control plane. Organizations need networking, security, observability, and workload tooling integrated before applications can run reliably. AWS EKS Blueprints for Terraform address that gap by providing open-source templates and reference architectures designed to simplify the deployment and management of Kubernetes clusters on Amazon EKS. The patterns include pre-configured modules for networking, add-ons such as VPC CNI, CoreDNS, and Prometheus, and integrations with tools like Argo CD or IAM roles for service accounts.
The project is positioned as a better, more flexible CI/CD experience for Terraform, offering maximum security without sacrificing functionality. For teams new to Terraform or Kubernetes, the blueprints reduce the time spent assembling operational components and provide a starting point that can be extended rather than rebuilt from scratch.
What EKS Blueprints Are
AWS EKS Blueprints are open-source templates and reference architectures designed to simplify the deployment and management of Kubernetes clusters on Amazon Elastic Kubernetes Service. They include pre-configured modules for networking, add-ons like VPC CNI, CoreDNS, and Prometheus, and integrations with tools like Argo CD or IAM roles for service accounts.
Welcome to Amazon EKS Blueprints for Terraform. This project contains a collection of Amazon EKS cluster patterns implemented in Terraform that demonstrate how fast and easy it is for customers to adopt Amazon EKS. The patterns can be used by AWS customers, partners, and internal AWS teams to configure and manage complete EKS clusters that are fully bootstrapped with the operational software that is needed to deploy and operate workloads.
Kubernetes is a powerful and extensible container orchestration technology that allows you to deploy and manage containerized applications at scale. The extensible nature of Kubernetes also allows you to use a wide range of popular open-source tools in Kubernetes clusters. However, with the wide array of tooling and design choices available, configuring an EKS cluster that meets your organization’s specific needs can take a significant amount of time. It involves integrating a wide range of open-source tools and AWS services as well as expertise in AWS and Kubernetes.
AWS customers have asked for patterns that demonstrate how to integrate the landscape of Kubernetes tools and make it easy for them to provision complete, opinionated EKS clusters that meet specific application requirements.
Why Patterns Matter for EKS Adoption
In this blog post, we will explore Amazon EKS Blueprints for Terraform, a set of patterns that make it easier and quicker for users to provision complete Amazon Elastic Kubernetes Service clusters.
If you are new to Terraform or interested in other Terraform concepts, these Terraform tutorials on Spacelift’s blog might be handy. Similarly, check these Kubernetes blog posts if you are learning about Kubernetes.
We will cover:
- What is Amazon EKS Blueprints for Terraform
- Adopting Kubernetes as your container orchestration platform is a challenging task. Before considering application deployments, you must design a robust Kubernetes setup, install operational tooling, and build a platform on top of which we will host workloads.
Kubernetes offers a vibrant ecosystem of popular open-source tools that we can leverage to build our production-grade clusters, commonly called addons. Selecting and implementing the appropriate tooling for your needs and integrating, and in the case of EKS, integrating the cluster to the rest of your AWS setup is a time-consuming and operationally heavy task.
We will look at the EKS Blueprints for Terraform framework to facilitate and fast-track this process.
Core Concepts and Architecture
The blueprint approach treats an EKS cluster as a product rather than a collection of individual resources. The core concepts are:
- Opinionated defaults for networking and security
- Modular add-on installation
- Reusable patterns for managed node groups and IAM
- Infrastructure-as-code via Terraform
By combining Terraform’s infrastructure-as-code capabilities with AWS’s EKS Blueprints Addons, users can create a scalable, production-ready Kubernetes environment without the usual complexity.
In this article, I’ll guide you through using Terraform to deploy EKS with essential add-ons, which streamline the configuration and management of your Kubernetes clusters. With these modular add-ons, you can quickly incorporate features like CoreDNS, the AWS Load Balancer Controller, and other powerful tools to customize and enhance your setup. Whether you’re new to container orchestration or just seeking an efficient AWS solution, this guide will help you build a resilient EKS environment in a few straightforward steps.
Add-on landscape
The following table summarizes add-ons referenced in the reference material and their typical role in a bootstrapped cluster.
| Add-on | Category | Purpose |
|---|---|---|
| vpc-cni | EKS Add-on | AWS VPC CNI for pod networking |
| coredns | EKS Add-on | Kubernetes DNS |
| kube-proxy | EKS Add-on | Service proxy |
| aws-load-balancer-controller | Self-managed Add-on | Load balancer provisioning |
| metrics server | Self-managed Add-on | Cluster metrics |
| cluster-autoscaler | Self-managed Add-on | Node scaling |
| aws-for-fluentbit | Self-managed Add-on | Logging |
| aws-efs-csi-driver | Self-managed Add-on | EFS storage |
| aws-ebs-csi-driver | EKS Add-on | EBS storage |
Terraform Module Structure and Add-ons
The following Terraform example represents a simple blueprint that will deploy a new EKS cluster with a managed node group. It will also bootstrap the cluster with vpc-cni, coredns, kube-proxy, aws-load-balancer-controller, metrics server, and cluster-autoscaler add-ons. Indicating that an add-on should be installed in an EKS cluster is as simple as setting a boolean value to true:
hcl
module "eks_blueprints" {
source = "github.com/aws-ia/terraform-aws-eks-blueprints?ref=v4.0.2"
# EKS Cluster VPC and Subnet mandatory config
vpc_id = <vpc_id>
private_subnet_ids = <private_subnet_ids>
# EKS CLUSTER VERSION
cluster_version = "1.21"
# EKS MANAGED NODE GROUPS
managed_node_groups = {
mg_5 = {
node_group_name = "managed-ondemand"
instance_types = ["m5.large"]
min_size = "2"
}
}
}
Add-ons are applied via a separate module:
hcl
module "kubernetes_addons" {
source = "github.com/aws-ia/terraform-aws-eks-blueprints//modules/kubernetes-addons?ref=v4.0.2"
eks_cluster_id = module.eks_blueprints.eks_cluster_id
# EKS Add-ons
enable_amazon_eks_vpc_cni = true
enable_amazon_eks_coredns = true
enable_amazon_eks_kube_proxy = true
enable_amazon_eks_aws_ebs_csi_driver = true
# Self-managed Add-ons
enable_aws_for_fluentbit = true
enable_aws_load_balancer_controller = true
enable_aws_efs_csi_driver = true
enable_cluster_autoscaler = true
enable_metrics_server = true
}
With CDK, you can do the following:
Kubernetes add-on customization
Each add-on points to an open-source, upstream Helm repository
VPC Foundations for EKS
Setting Up the VPC for EKS
The VPC configuration is foundational for your EKS cluster, establishing a secure, isolated environment with both public and private subnets. Private subnets are typically used to host your Kubernetes nodes, keeping them inaccessible from the internet.
The blueprint pattern expects VPC ID and private subnet IDs as mandatory inputs. This separation allows the control plane to be managed by AWS while worker nodes reside in private subnets with controlled egress.
Community, Availability and Support Model
Lastly, the EKS Blueprints community is open to everyone. We have a small but growing open-source community that is contributing to the project, and we want to grow our base of contributors. If you are interested in getting involved with the project, we welcome all contributions to Terraform or CDK projects, including bug reports, new features, corrections, or additional documentation.
Next steps
To get started with EKS Blueprints, please visit either the EKS Blueprints for Terraform or EKS Blueprints for CDK repositories. There you will find links to complete project documentation and instructions on getting started.
Availability, pricing, and support
- EKS Blueprints for Terraform and CDK are available today on GitHub. They can be used to provision EKS environments in any AWS Region where EKS is currently available. EKS Anywhere support is on our roadmap.
- EKS Blueprints is free to use, and you pay for only the resources you deploy. For example, when you deploy an EKS cluster with a managed node group, you will incur standard EKS and EC2 charges.
- EKS Blueprints is a community-driven open-source project, not part of an AWS service, so it is therefore not included in AWS enterprise support. All AWS services provisioned by EKS Blueprints, such as EKS, are fully supported. If you need help using EKS Blueprints, please create an issue in our GitHub repository
The following table captures availability and cost characteristics:
| Aspect | Detail |
|---|---|
| Distribution | GitHub open source |
| Regions | Any AWS Region where EKS is available |
| EKS Anywhere | On roadmap |
| Pricing model | Free blueprint, pay for deployed resources |
| Support | Community driven, AWS services supported natively |
Operational Workflow
The blueprint workflow follows a standard Terraform lifecycle.
- Provision the EKS control plane and managed node groups via the eks_blueprints module
- Bootstrap operational add-ons via the kubernetes-addons module
- Customize via boolean flags for each add-on
- Destroy resources when the demo ends
To avoid paying for resources that you have created with this demo, run:
bash
terraform destroy
Key points
In this blog post, we explored the EKS Blueprints for Terraform as an enabler to implement and adopt EKS and provision complete “batteries-included” clusters. We went over the motivation behind this solution, its core concepts, and architecture, and finally, we ran a hands-on demo of provisioning an EKS cluster with Terraform and setting up various tooling as EKS Blueprints addons.
We encourage you also to explore how Spacelift makes it easy to work with Terraform. If you need any help managing your Terraform infrastructure, building more complex workflows based on Terraform, and managing AWS credentials per run, instead of using a static pair on your local machine, Spacelift is a fantastic tool for this. It supports Git workflows, policy as code, programmatic configuration, context sharing, drift detection, and many more great features right out of the box. You can also see Spacelift integration with AWS, with our Cloud Integrations section and our update to support account-level AWS integrations. Try it for free or book a demo with one of our engineers.
What additional add-ons would be useful? What new blueprints can we build?
The open questions highlight the extensibility of the project. Because each add-on points to an open-source upstream Helm repository, new capabilities can be added by toggling additional boolean flags or by contributing new modules.
Conclusion
Amazon EKS Blueprints for Terraform provide a pragmatic way to move from manual cluster assembly to repeatable, opinionated infrastructure. The patterns reduce the design burden for networking, security, and operational tooling by offering pre-configured modules for VPC CNI, CoreDNS, kube-proxy, AWS Load Balancer Controller, metrics server, and cluster-autoscaler among others.
The approach is built around Terraform modules that accept VPC and subnet inputs, cluster version, and managed node group definitions, then bootstrap a complete “batteries-included” cluster. Add-on installation is simplified to boolean flags, and the community model allows contributions for new features, corrections, and documentation.
Availability is broad, with support for any AWS Region where EKS is available today and EKS Anywhere on the roadmap. The blueprints themselves are free to use, with costs limited to the underlying AWS resources such as EKS and EC2 charges for managed node groups. Support is community driven via GitHub issues, while the AWS services provisioned remain fully supported by AWS.
For teams seeking to adopt Kubernetes quickly without sacrificing production readiness, the combination of Terraform infrastructure-as-code with EKS Blueprints add-ons delivers a scalable, production-ready environment with reduced complexity and operational overhead.