How to Run Kubernetes on AWS: A Step-by-Step Tutorial

Kubernetes (K8s) is the standard for running containers in production, and AWS is one of the most common places to run it. 

There are three main ways to run Kubernetes on AWS: the fully managed Amazon EKS service, a self-managed cluster on EC2 compute instances, or an automated Infrastructure as Code (IaC) workflow that provisions clusters for you. Within EKS, you can also choose EKS Auto Mode or Fargate to hand more of the operational work to AWS. 

Each option trades a different amount of control for a different amount of maintenance, and the right choice depends on your team’s size, budget, and appetite for managing infrastructure.

This tutorial covers all approaches step by step, with the benefits, drawbacks, and real costs of each, so you can pick the one that fits and get a cluster running.

We will cover:

1. Why run Kubernetes on AWS?
2. Ways to run Kubernetes on AWS
3. Using Amazon EKS
4. Manually deploying your own cluster using EC2 compute instances
5. Automating Kubernetes deployment to AWS using Infrastructure as Code (IaC)

AWS lets you reliably run Kubernetes in the cloud. You can locate your K8s cluster alongside your other AWS resources, avoiding the need to select an external Kubernetes service.

You can easily integrate your cluster with AWS networking and storage solutions, such as Elastic Load Balancers (ELB) and Elastic Block Store (EBS) volumes. Kubernetes becomes another resident in your cloud, able to share data and resources with your existing infrastructure components.

As we’ll see below, AWS also allows you to eliminate the complexity involved in manually provisioning and maintaining Kubernetes clusters. Elastic Kubernetes Service (EKS) can start a new cluster within minutes, leaving you to focus on your apps instead of infrastructure.

Some of the other benefits of Kubernetes on AWS include:

• Scalability – Scale your cluster by adding Nodes as demand grows. AWS supports hundreds of EC2 instance types, so you can tailor your cluster’s capacity to your exact requirements. Read more about scaling AWS infrastructure.
• Cost efficiency – Running Kubernetes on AWS can lower your total cost of ownership. Auto-scaling resizes your clusters to match demand, and native integration with other AWS services reduces the setup, maintenance, and training costs you carry over the life of the deployment.
• High availability and uptime guarantees – Your cluster inherits the platform’s reliability. EKS offers a 99.95% SLA on its standard control plane and 99.99% on Provisioned Control Plane, while EC2 offers a 99.99% Region-Level SLA across multiple Availability Zones and 99.5% for a single instance.

Is Kubernetes free on AWS?

AWS offers a free tier, but how it works depends on when you created your account, and either way you can’t run a real Kubernetes cluster for free. 

Accounts created before July 15, 2025 use the legacy tier: some services free for life, plus a 12-month trial with allowances like 750 EC2 hours per month. Accounts created on or after July 15, 2025 use a credit-based model instead: $100 in credits at sign-up, up to $200 total, usable for six months or until the credits run out.

The EKS managed Kubernetes engine isn’t included in the free tier. You’ll always be billed $0.10 per hour for each cluster you run on a supported Kubernetes version, in addition to the EC2 or Fargate costs associated with your Nodes. This charge only covers the managed control plane. 

Watch the version lifecycle: each minor version gets 14 months of standard support at $0.10 per hour, after which the cluster moves automatically into extended support at $0.60 per hour, a 6x jump of roughly $4,380 per cluster per year. Extended support is on by default, so clusters get enrolled at the higher rate unless you upgrade in time.

Even if you don’t use EKS, you’ll still need to pay to run Kubernetes on AWS. On the legacy free tier, EC2 gives you 750 hours per month for 12 months, but only on t2.micro and t3.micro instances. These offer just 1 GiB of RAM, so they’re too small to run most Kubernetes distributions. On the newer credit-based plan there’s no fixed EC2 allowance; you spend your limited credits on instances that still won’t leave much room for a cluster.

Read more about AWS Cost Optimization.

Now you’ve decided to run Kubernetes on AWS, how do you actually get started? Let’s look at three different ways to create your cluster, beginning with the simplest option.

1. Using Amazon EKS
2. Manually deploying your own cluster using EC2 compute instances
3. Automating Kubernetes deployment to AWS using Infrastructure as Code (IaC)

Which option should you choose?

Approach	Who manages Nodes	Best for	Main trade-off
EKS (standard)	You, via managed node groups	A managed control plane with Node-level control	Control-plane fee; you patch and scale Nodes
EKS Auto Mode	AWS	Minimizing Node operations	~10-12% management fee on compute
EKS on Fargate	AWS, serverless Pods	Bursty or per-Pod workloads	Less control; not suited to every workload
Self-managed on EC2	You, end to end	Full control or a specific distribution	Highest operational overhead
IaC with Spacelift	You, automated through Git	Repeatable clusters across teams	Adds a tool and a short learning curve

Amazon EKS is a fully managed Kubernetes engine. It lets you start a cluster without having to administer any physical hosts yourself.

The EKS service provides the Kubernetes control plane with performance and reliability guarantees. It also automates the process of provisioning worker Nodes and joining them to your cluster. You can run your Nodes on either EC2 or Fargate or hand Node management to AWS entirely with EKS Auto Mode.

EKS has built-in support for auto-scaling, allowing your cluster to resize itself as utilization changes. It also includes a full graphical console for managing your cluster, as well as automated security patches to keep Kubernetes updated. There are direct integrations with other AWS services, including VPC and ELB networking, EBS storage, and IAM identity management.

How to create an EKS cluster

To start a new Kubernetes cluster with EKS using the AWS console, first log in to your AWS account and open up the Web Console.

Create the IAM roles

Begin by heading to the IAM Dashboard. You can find it using the search bar at the top of the page:

Click the “Roles” link in the left sidebar, followed by the blue “Create role” button on the Roles page:

Select “AWS service” as the “Trusted entity type” for your new role. Scroll down to the “Use case” section, choose “EKS” from the dropdown menu, and then use the radio button to select the “EKS – Cluster” use case. Scroll down the page and click the blue “Next” button.

Click through the following pages without making any changes, until you reach the “Name, review, and create” screen. Name your role, then click the blue “Create role” button at the bottom of the screen. This IAM role will allow EKS to manage other resources in your AWS account on your behalf.

Next, repeat the steps listed above, but select the “EC2” use case when choosing the role’s entity type. On the following “Add permissions” page, use the “Filter policies” box to attach the extra AmazonEKSWorkerNodePolicy, AmazonEC2ContainerRegistryReadOnly, and AmazonEKS_CNI_Policy permissions to the role.

This role allows the Kubelet process on your worker nodes to interact with the EKS and AWS services it requires.

If you want to learn more about IAM Roles, check out AWS IAM Roles – Everything You Need to Know & Examples.

Create your cluster

Next, switch to the EKS dashboard by searching in the search bar at the top of the page. The dashboard will show as “Elastic Kubernetes Service” under “Services” in the search results:

On the EKS landing page, click the “Add cluster” button, then “Create” in the dropdown menu that appears:

Enter a name for your cluster and select the Kubernetes version to deploy. Accept the default version unless you know you need an alternative because it’s usually the best-supported option.

Check that the cluster role you created above is selected in the “Cluster service role” dropdown, then scroll down the page and press the yellow “Next” button.

Accept the default configurations on the following four screens, as we’re only creating a basic cluster.

Click through the screens until you reach Step 6, “Review and create,” then press the yellow “Create” button at the bottom to provision your cluster.

You’ll be taken to your cluster’s dashboard. Wait while the creation process completes – the “Status” displayed under “Cluster info” will change from “Creating” to “Active” once it’s ready.

Add nodes

Next, switch to the “Compute” tab in the tab strip near the top of the page. Your cluster doesn’t have any Nodes yet, so it can’t run any workloads. Scroll down and click the “Add node group” button to begin provisioning your first Nodes as EC2 instances.

Give your Node group a name, then check the node IAM role you created earlier is selected in the dropdown.

On the next page, configure the type of EC2 instance to provision for this Node group. The defaults are sufficient for this example.

Further down the page, choose the number of Nodes to provision. More Nodes will increase your cluster’s redundancy and capacity.

Step through the remaining pages to review and create your Node group, then wait while your Nodes are provisioned. This may take some time as new EC2 instances are created.

Connect to your cluster

Your cluster will be ready to use once the Node group’s status changes to “Active.”

You now need to add the cluster’s Kubeconfig file to your ~/.kube directory so Kubectl can access it.

The easiest way to do this is through the AWS CLI. Follow the documentation to install and authenticate the CLI if needed, then run the following command to update your local Kubeconfig to include your EKS cluster:

$ aws eks update-kubeconfig --name <your-cluster-name>

Now you can use Kubectl to interact with your cluster:

$ kubectl get nodes
NAME                                         STATUS   ROLES    AGE     VERSION
ip-172-31-39-83.eu-west-2.compute.internal   Ready    <none>   3m48s   v1.33.0-eks-xxxxxxx
ip-172-31-7-11.eu-west-2.compute.internal    Ready    <none>   3m49s   v1.33.0-eks-xxxxxxx

Read more about how to use kubectl get nodes.

Why use EKS?

EKS is popular because it’s so simple to configure and maintain. You don’t need to understand the details of how Kubernetes works or how Nodes are joined to your cluster and secured. The EKS service automates cluster management procedures, leaving you free to focus on your workloads.

This simplicity can come at a cost, though: you could find EKS becomes inflexible as you grow, and it might be challenging to migrate from if you switch to a different cloud provider. Actual EKS costs can swell as you add more clusters, too. The $0.10 per hour control plane fee sometimes becomes significant for smaller organizations that need to use multiple clusters

EKS Auto Mode

EKS Auto Mode, announced at re:Invent in December 2024, removes most of the day-to-day work of running a cluster. 

Instead of you sizing, provisioning, patching, and scaling Nodes, AWS selects and manages the EC2 instances for compute, storage, and networking automatically. You can turn it on for any new or existing cluster running Kubernetes 1.29 or later.

The trade-off is cost. On top of the $0.10 per hour control-plane fee and your normal EC2 charges, Auto Mode adds a management fee of roughly 10 to 12% of the instance price. If it saves your team more operational time than that fee costs, it pays for itself. If you already have solid Node automation, standard EKS keeps the bill lower.

Amazon EC2 provides virtual compute instances that you can use to manually deploy your own Kubernetes clusters. EC2 instances behave like regular virtual machines; to create your cluster, you’ll need multiple EC2 machines, one to act as the K8s master node that hosts the control plane, and the others configured in worker node roles.

Deploying directly to EC2 gives you full control over your cluster, including its control plane components. This can make it easier to configure Kubernetes in advanced situations.

Running a cluster directly on EC2 also gives you the choice of using any available Kubernetes distribution, such as Minikube, K3s, or standard Kubernetes as deployed by Kubeadm. You deploy your cluster directly on the operating system as if you were running it locally. This allows you to standardize on one distribution, such as K3s, across all the environments where you require Kubernetes – on your laptop, on AWS, and in the other clouds you use. 

The drawbacks of direct deployment have directly led to the rise of managed alternatives like EKS, however. Manually administering Kubernetes increases your maintenance overheads and can be daunting to inexperienced operators. You’ll be responsible for applying cluster upgrades and preserving reliability. It’s also challenging to configure auto-scaling for non-managed compute instances, which can affect your cluster’s long-term suitability.

Neither of the methods shown above are ideal in environments where you require several clusters or need them to be provisioned in a consistent way by multiple people.

Automating Kubernetes deployments to AWS using an IaC provider such as Terraform allows you to take a hands-off approach to cluster administration. You can version your cluster configuration alongside your source code to easily track infrastructure changes. When you need to start a new cluster, you can reuse your configuration to quickly provision another instance.

Adopting IaC does mean you’ll be increasing your tool count and slightly increasing the learning curve for new team members. Having to run through an IaC workflow can also feel more clunky when creating a one-off or short-lived cluster for testing and experimentation.

However, the increased safety, consistency, and repeatability enabled by automation means it’s usually advantageous overall.

Using Terraform to deploy Kubernetes on AWS

Terraform can be used to deploy Kubernetes using both standalone EC2 instances and EKS. You can see an example of how to use Terraform to deploy an EKS cluster in the official demo repository.

First, make sure you have the AWS CLI installed and connected to your AWS account.

Next, clone the Terraform sample repository to your machine:

$ git clone https://github.com/hashicorp/learn-terraform-provision-eks-cluster

$ cd learn-terraform-provision-eks-cluster

Next, open the terraform.tf file in the repository and remove the cloud block near the top.

This configures Terraform for local use, without a Terraform Cloud account.

# Remove this section
cloud {
	workspaces {
		name = "learn-terraform-eks"
	}
}

Now, run terraform init to initialize the configuration and install the correct Terraform providers:

$ terraform init

Next, use terraform apply to apply the configuration and create the required resources in your AWS account.

The planned actions will be displayed in your terminal; type yes at the prompt to confirm the operation. It could take several minutes to complete.

$ terraform apply

This procedure automates the cluster deployment process, removing the need to manually click through AWS web console screens or manually make API requests.

You can edit the created resources and change your cluster’s configuration by altering the repository’s Terraform state files.

Learn more about managing Infrastructure as Code (IaC) with Terraform.

IaC management with Spacelift

You can extend automated Terraform and Kubernetes deployments with Spacelift’s IaC management platform. Spacelift integrates your IaC and CI/CD pipelines into your Git workflows, allowing you to automatically apply infrastructure changes when pull requests are created and merged.

Spacelift makes it easy to configure self-service infrastructure. Any team member can create a new on-demand EKS cluster for a pull request, for example, without leaving GitHub. Spacelift automates the entire workflow, eliminating the need for individual developers to understand or access Terraform and EKS configurations.

Spacelift also automatically discovers and fixes infrastructure drift, ensuring your environments remain stable over the long term. The platform visualizes your deployed resources, so you can check exactly what’s running at any time.

Running Kubernetes on AWS can provide reliability, scalability, and efficiency benefits. You can position your Kubernetes cluster alongside your other AWS infrastructure, enabling easy integration with existing resources.

It’s simple to deploy Kubernetes to AWS: the fully managed EKS service provisions new clusters in just a few clicks, while EC2 gives you the tools to manually run the Kubernetes control plane and join your Nodes in situations where you require more control.

Both these approaches can be difficult to manage at scale, however. Avoid inconsistencies by using IaC and CI/CD pipelines to automate the creation of Kubernetes clusters in your AWS account, using tools such as Spacelift. Spacelift is an infrastructure orchestration platform for IaC that helps DevOps teams deploy infrastructure and ship changes quickly and with confidence.