Creating an Amazon EKS (Elastic Kubernetes Service) cluster using Terraform involves a series of carefully orchestrated steps. Each step can be encapsulated within its own Terraform module for better modularity and reusability. Here’s a breakdown of how to structure your Terraform project to deploy an EKS cluster on AWS.
1. VPC Module
- Create a Virtual Private Cloud (VPC): This is where your EKS cluster will reside.
- Set Up Subnets: Establish both public and private subnets within the VPC to segregate your resources effectively.
2. EKS Module
- Deploy the EKS Cluster: Link the components created in the VPC module to your EKS cluster.
- Define Security Rules: Set up security groups and rules for both the EKS master nodes and worker nodes.
- Configure IAM Roles: Create IAM roles and policies needed for the EKS master and worker nodes.
Project Directory Structure
Let’s begin by creating a root project directory named terraform-eks-project. Below is the suggested directory structure for the entire Terraform project:
terraform-eks-project/
│
├── modules/ # Root directory for all modules
│ ├── vpc/ # VPC module: VPC, Subnets (public & private)
│ │ ├── main.tf
│ │ ├── variables.tf
│ │ └── outputs.tf
│ │
│ └── eks/ # EKS module: cluster, worker nodes, IAM roles, security groups
│ ├── main.tf
│ ├── variables.tf
│ ├── outputs.tf
│ └── worker_userdata.tpl
│
├── backend.tf # Backend configuration (e.g., S3 for remote state)
├── main.tf # Main file to call and stitch modules together
├── variables.tf # Input variables for the main configuration
├── outputs.tf # Output values from the main configuration
├── provider.tf # Provider block for the main configuration
├── terraform.tfvars # Variable definitions file
└── README.md # Documentation and instructionsRoot Configuration Files Overview
backend.tf: Specifies how Terraform state is managed and where it’s stored (e.g., in an S3 bucket).main.tf: The central configuration file that integrates the various modules and manages the AWS resources.variables.tf: Declares the variables used throughout the project.outputs.tf: Manages the outputs from the Terraform scripts, such as IDs and ARNs.terraform.tfvars: Contains user-defined values for the variables.README.md: Provides documentation and usage instructions for the project.
Backend Configuration (backend.tf)
The backend.tf file is responsible for defining how Terraform state is loaded and how operations are executed. For instance, using an S3 bucket as the backend allows for secure and durable state storage.
terraform {
backend "s3" {
bucket = "my-terraform-state-bucket" # Replace with your S3 bucket name
key = "path/to/my/key" # Path to the state file within the bucket
region = "us-west-1" # AWS region of your S3 bucket
encrypt = true # Enable server-side encryption of the state file
# Optional: DynamoDB for state locking and consistency
dynamodb_table = "my-terraform-lock-table" # Replace with your DynamoDB table name
# Optional: If S3 bucket and DynamoDB table are in different AWS accounts or need specific credentials
# profile = "myprofile" # AWS CLI profile name
}
}Main Configuration (main.tf)
The main.tf file includes module declarations for the VPC and EKS components.
VPC Module
The VPC module creates the foundational network infrastructure components.
module "vpc" {
source = "./modules/vpc" # Location of the VPC module
env = terraform.workspace # Current workspace (e.g., dev, prod)
app = var.app # Application name or type
vpc_cidr = lookup(var.vpc_cidr_env, terraform.workspace) # CIDR block specific to workspace
public_subnet_number = 2 # Number of public subnets
private_subnet_number = 2 # Number of private subnets
db_subnet_number = 2 # Number of database subnets
region = var.aws_region # AWS region
# NAT Gateways settings
vpc_enable_nat_gateway = var.vpc_enable_nat_gateway # Enable/disable NAT Gateway
enable_dns_hostnames = true # Enable DNS hostnames in the VPC
enable_dns_support = true # Enable DNS resolution in the VPC
}EKS Module
The EKS module sets up a managed Kubernetes cluster on AWS.
module "eks" {
source = "./modules/eks"
env = terraform.workspace
app = var.app
vpc_id = module.vpc.vpc_id
cluster_name = var.cluster_name
cluster_service_ipv4_cidr = lookup(var.cluster_service_ipv4_cidr, terraform.workspace)
public_subnets = module.vpc.public_subnet_ids
cluster_version = var.cluster_version
cluster_endpoint_private_access = var.cluster_endpoint_private_access
cluster_endpoint_public_access = var.cluster_endpoint_public_access
cluster_endpoint_public_access_cidrs = var.cluster_endpoint_public_access_cidrs
sg_name = var.sg_external_eks_name
}Outputs Configuration (outputs.tf)
The outputs.tf file defines the values that Terraform will output after applying the configuration. These outputs can be used for further automation or simply for inspection.
output "vpc_id" {
value = module.vpc.vpc_id
}
output "cluster_id" {
value = module.eks.cluster_id
}
output "cluster_arn" {
value = module.eks.cluster_arn
}
output "cluster_certificate_authority_data" {
value = module.eks.cluster_certificate_authority_data
}
output "cluster_endpoint" {
value = module.eks.cluster_endpoint
}
output "cluster_version" {
value = module.eks.cluster_version
}Variable Definitions (terraform.tfvars)
The terraform.tfvars file is where you define the values for variables that Terraform will use.
aws_region = "us-east-1"
# VPC Core
vpc_cidr_env = {
"dev" = "10.101.0.0/16"
#"test" = "10.102.0.0/16"
#"prod" = "10.103.0.0/16"
}
cluster_service_ipv4_cidr = {
"dev" = "10.150.0.0/16"
#"test" = "10.201.0.0/16"
#"prod" = "10.1.0.0/16"
}
enable_dns_hostnames = true
enable_dns_support = true
vpc_enable_nat_gateway = false
# EKS Configuration
cluster_name = "test_cluster"
cluster_version = "1.27"
cluster_endpoint_private_access = true
cluster_endpoint_public_access = true
cluster_endpoint_public_access_cidrs = ["0.0.0.0/0"]
sg_external_eks_name = "external_kubernetes_sg"Variable Declarations (variables.tf)
The variables.tf file is where you declare all the variables used in your Terraform configuration. This allows for flexible and reusable configurations.
variable "aws_region" {
description = "Region in which AWS Resources to be created"
type = string
default = "us-east-1"
}
variable "zone" {
description = "The zone where VPC is"
type = list(string)
default = ["us-east-1a", "us-east-1b"]
}
variable "azs" {
type = list(string)
description = "List of availability zones suffixes."
default = ["a", "b", "c"]
}
variable "app" {
description = "The APP name"
default = "ekstestproject"
}
variable "env" {
description = "The Environment variable"
type = string
default = "dev"
}
variable "vpc_cidr_env" {}
variable "cluster_service_ipv4_cidr" {}
variable "enable_dns_hostnames" {}
variable "enable_dns_support" {}
# VPC Enable NAT Gateway (True or False)
variable "vpc_enable_nat_gateway" {
description = "Enable NAT Gateways for Private Subnets Outbound Communication"
type = bool
default = true
}
# VPC Single NAT Gateway (True or False)
variable "vpc_single_nat_gateway" {
description = "Enable only single NAT Gateway in one Availability Zone to save costs during our demos"
type = bool
default = true
}
# EKS Variables
variable "cluster_name" {
description = "The EKS cluster name"
default = "k8s"
}
variable "cluster_version" {
description = "The Kubernetes minor version to use for the
EKS cluster (for example 1.26)"
type = string
default = null
}
variable "cluster_endpoint_private_access" {
description = "Indicates whether the Amazon EKS private API server endpoint is enabled."
type = bool
default = false
}
variable "cluster_endpoint_public_access" {
description = "Indicates whether the Amazon EKS public API server endpoint is enabled."
type = bool
default = true
}
variable "cluster_endpoint_public_access_cidrs" {
description = "List of CIDR blocks which can access the Amazon EKS public API server endpoint."
type = list(string)
default = ["0.0.0.0/0"]
}
variable "sg_external_eks_name" {
description = "The SG name."
}Conclusion
This guide outlines the key components of setting up an Amazon EKS cluster using Terraform. By organizing your Terraform code into reusable modules, you can efficiently manage and scale your infrastructure across different environments. The modular approach not only simplifies management but also promotes consistency and reusability in your Terraform configurations.