How To Provision an EKS Cluster Using Terraform EKS Module

Provisioning an Amazon Elastic Kubernetes Service (EKS) cluster with Terraform is an efficient way to manage Kubernetes resources on AWS. This guide will walk you step by step through the process of provisioning EKS cluster using Terraform EKS Module.


Before you begin, ensure you have the following:

  • An AWS account and appropriate permissions.
  • AWS CLI installed and configured with your credentials.
  • Terraform installed on your system.

Step 1: Set Up Terraform

Ensure that Terraform is installed on your system. If not, refer to our comprehensive guide on setting up Terraform.

Step 2: Configure AWS Credentials

Set up your AWS credentials to allow Terraform to manage resources on your behalf. This can be done by configuring the AWS CLI using the aws configure command, which will prompt you to enter your Access Key, Secret Key, and preferred AWS region.

Step 3: Create Terraform Configuration File

In this step, you’ll create a Terraform configuration file to define your EKS cluster. This file typically has a .tf extension, such as Here, you will specify the Terraform AWS provider and the terraform-aws-modules/eks/aws module.

Understanding the Terraform EKS Module

The terraform-aws-modules/eks/aws is a Terraform module specifically designed for creating and managing EKS clusters in AWS. A Terraform module is a collection of Terraform files which are used together to manage a collection of related resources. In this case, the EKS module encapsulates all the complexities and best practices for setting up an EKS cluster, such as VPC configuration, security groups, IAM roles, and node groups. Using this module significantly simplifies the process of provisioning an EKS cluster compared to writing all the resource definitions manually.

Example Configuration

Here’s how you can define an EKS cluster in your file using the Terraform EKS module:

provider "aws" {
  region = "us-west-2"  # Example AWS region

module "eks" {
  source          = "terraform-aws-modules/eks/aws"  # The EKS module
  cluster_name    = "my-cluster"  # Name of the EKS cluster
  cluster_version = "1.17"  # EKS version
  subnets         = ["subnet-abcde012", "subnet-bcde012a", "subnet-fghi345a"]  # Subnets for the EKS cluster

  vpc_id = "vpc-1234556abcdef"  # VPC where the EKS cluster will be created
  node_groups = {
    example = {
      desired_capacity = 2
      max_capacity     = 3
      min_capacity     = 1

      instance_type = "m4.large"  # Instance type for the worker nodes

In this configuration:

  • The provider block initializes the AWS provider, which allows Terraform to interact with AWS.
  • The module block calls the EKS module from the Terraform registry, with parameters like cluster_namecluster_version, and node_groups that define the specifics of your EKS cluster.

Remember to replace the values of subnetsvpc_id, and other parameters with the actual values relevant to your AWS environment.

Step 4: Initialize Terraform

Run terraform init in your project directory. This command initializes Terraform, downloading the AWS provider and the EKS module.

Step 5: Plan and Apply

Execute terraform plan to preview the actions Terraform will perform. After reviewing, run terraform apply to create your EKS cluster. Terraform will request your confirmation before proceeding with the creation.

Step 6: Apply Terraform Configuration and Verify Cluster Creation

After you’ve configured your Terraform files, it’s time to apply the configuration and create the EKS cluster. This is done using the Terraform CLI.

Applying the Configuration

Run the following commands in your terminal:

  1. Initialize Terraform:terraform init This initializes the Terraform environment and downloads necessary plugins and modules.
  2. Apply Terraform Configuration:terraform apply This command will show you the resources that will be created. You must confirm the action by typing yes.

Verifying Cluster Creation

To confirm that your EKS cluster has been successfully created, follow these steps:

  1. Update kubeconfig: Run the following command to update your kubeconfig file with your new EKS cluster information. This allows kubectl to interact with your eks update-kubeconfig --region [region] --name [cluster_name] Replace [region] and [cluster_name] with your cluster’s region and name.
  2. Verify with kubectl: Use kubectl, a command line tool for Kubernetes, to verify the cluster. Run:kubectl cluster-info This should display information about your EKS cluster’s control plane and core services.
  3. Check Nodes: Verify that the worker nodes are correctly registered and in a healthy state by running:kubectl get nodes This command lists all the nodes along with their status. All nodes should be in the Ready state.
  4. Additional Checks:
    • Pods Status: Run kubectl get pods --all-namespaces to see all the pods running in all namespaces. This ensures that system pods are up and running.
    • EKS Console: Log into the AWS Management Console and navigate to the EKS section to visually inspect the cluster and its components.

These steps will help you ensure that your EKS cluster is properly set up and operational. Any issues or discrepancies in the output may indicate a problem with the cluster’s configuration or network settings, which should be investigated and resolved.

Step 7: Deploy Applications to the EKS Cluster

Once your EKS cluster is up and running, the next step is to deploy applications to it. This involves several sub-steps, from packaging your application to monitoring its performance.

7.1 Preparing Your Application

Before deploying, ensure your application is containerized. This typically means:

  • Containerizing the Application: Package your application in a Docker container. Define a Dockerfile that specifies the base image, dependencies, and build instructions for your application.
  • Pushing the Container Image to a Registry: Upload your container image to a container registry. AWS offers Elastic Container Registry (ECR), but you could also use Docker Hub or other third-party services.

7.2 Creating Kubernetes Manifests

Kubernetes manifests are YAML files that describe how your application should be deployed. They include details like the number of replicas, network settings, and storage requirements. You’ll need to create manifests for different Kubernetes resources such as Deployments, Services, and Ingress.

7.3 Deploying the Application

Deploy your application to the EKS cluster using kubectl, the command-line interface for running commands against Kubernetes clusters. Here’s how you do it:

  1. Apply the Manifests: Run kubectl apply -f <manifest-file.yaml> to create the resources defined in your manifest file in your EKS cluster.
  2. Verify the Deployment: Use commands like kubectl get podskubectl describe deployment <deployment-name>, and kubectl logs <pod-name> to check the status and logs of your deployed application.

7.4 Configuring Load Balancing and Networking

If your application needs to be accessible from the internet or within a private network, set up load balancing and networking:

  • Load Balancer: Use AWS Load Balancer with EKS to manage incoming traffic. You can define a Kubernetes Service of type LoadBalancer in your manifest file.
  • Networking Policies: Define Kubernetes network policies for secure communication between pods and external networks.

7.5 Setting Up Autoscaling

For applications with variable loads, consider setting up autoscaling:

  • Horizontal Pod Autoscaler (HPA): Automatically scale the number of pods in a deployment or replica set based on observed CPU utilization or custom metrics.
  • Cluster Autoscaler: Automatically adjust the size of your EKS cluster. It adds or removes nodes depending on the demand.

7.6 Monitoring and Logging

Finally, set up monitoring and logging to keep track of your application’s health and performance:

  • Monitoring: Tools like Prometheus and Grafana can be used for monitoring the performance of your applications and Kubernetes cluster.
  • Logging: Centralize logs using AWS CloudWatch or Elasticsearch. This helps in debugging and keeping track of your application’s behavior.

Deploying applications to an EKS cluster requires careful planning and understanding of Kubernetes concepts. Each of these steps plays a critical role in ensuring that your application runs smoothly and efficiently in the cloud environment.


This guide provides step-by-step instructions for provisioning an EKS cluster using Terraform. It’s a starting point, and real-world scenarios might require additional configurations such as setting up IAM roles and security groups. For more detailed information and advanced configurations, refer to our Terraform channel.

FAQs for Setting up EKS Cluster using Terraform EKS Module

What is the Terraform EKS Module?

The Terraform EKS Module is a pre-built module in Terraform, specifically designed to create and manage AWS Elastic Kubernetes Service (EKS) clusters. It simplifies the process of provisioning and configuring EKS clusters in AWS.

Can You Provide a Terraform EKS Module Example?

Sure! A basic example of using the Terraform EKS module would include defining a provider for AWS and specifying the terraform-aws-modules/eks/aws module with desired configurations like cluster name, version, and node groups in a Terraform configuration file.

How Does Terraform Help in Creating an EKS Cluster?

Terraform automates the creation of an EKS cluster by managing the underlying resources like VPC, subnets, IAM roles, and security groups. It ensures that all these components are configured correctly and work together seamlessly.

What EKS Resources Can Be Managed by Terraform?

Terraform can manage a wide range of EKS resources, including the Kubernetes master nodes, worker nodes, IAM roles for EKS, security groups, and networking configurations like VPCs and subnets.

What are the Key Features of the terraform-aws-modules/eks/aws Module?

The terraform-aws-modules/eks/aws module offers several key features such as easy creation and management of EKS clusters, support for creating and managing node groups, integration with AWS networking, and IAM configurations for Kubernetes.

Is the Terraform EKS Module Suitable for Production Environments?

Yes, the Terraform EKS module is designed for robustness and scalability, making it suitable for production environments. It incorporates best practices and is widely used in the industry for managing EKS clusters.

How Does the Terraform EKS Cluster Module Handle Versioning?

The Terraform EKS module allows users to specify the version of the EKS cluster, ensuring that you can deploy and maintain the Kubernetes version that best suits your needs.

What Are Some Common Use Cases for the Terraform EKS Module?

Common use cases include automated provisioning of EKS clusters, infrastructure as code (IaC) for Kubernetes, scalable and repeatable EKS deployments, and integrating EKS with other AWS services.

How to Upgrade an EKS Cluster Using Terraform?

To upgrade an EKS cluster using Terraform, you simply update the desired Kubernetes version in the Terraform configuration file and apply the changes. Terraform then handles the upgrade process.

Are There Any Best Practices When Using terraform-aws-modules/eks/aws for EKS?

Yes, some best practices include defining clear and concise configurations, keeping your Terraform version up to date, regularly updating the EKS module to leverage new features and fixes, and thoroughly testing changes in a staging environment before applying them to production.