---
title: "How to Deploy a Kubernetes Cluster in 60 Seconds Using KinD on Ubuntu EC2 Instance"
source: "https://support.tools/deploy-kubernetes-cluster-kind-ubuntu-ec2/"
published: 2025-06-07
categories: ["Kubernetes","DevOps","Cloud"]
tags: ["Kubernetes","KinD","Docker","AWS","EC2"]
---


Deploying a Kubernetes cluster doesn't have to be a complex, time-consuming task. With **KinD (Kubernetes in Docker)**, you can set up a fully functional Kubernetes cluster in just 60 seconds using an Ubuntu EC2 instance on AWS. This guide will walk you through the process step-by-step, making it easy to test applications or set up a development environment quickly.

# [How to Deploy a Kubernetes Cluster in 60 Seconds Using KinD](#how-to-deploy-a-kubernetes-cluster-in-60-seconds-using-kind)

## Section 1: Introduction to KinD

**KinD** is a tool for running local Kubernetes clusters using Docker container "nodes." It's designed for testing Kubernetes itself, but it’s great for fast local development and Continuous Integration (CI) workflows. Here are some reasons why you might choose KinD:

- **Speed**: Rapid cluster provisioning and teardown.
- **Simplicity**: Easy to set up and manage.
- **Lightweight**: Runs clusters in Docker containers, consuming fewer resources.
- **Flexibility**: Ideal for local testing and CI pipelines.

## Section 2: Prerequisites

Before you begin, ensure you have the following:

- **AWS Account**: Access to launch EC2 instances.
- **Basic AWS Knowledge**: Familiarity with EC2 and security groups.
- **SSH Key Pair**: For connecting to your EC2 instance.

## Section 3: Step-by-Step Deployment Guide

### Step 1: Launch an Ubuntu EC2 Instance

1. **Log into AWS Management Console** and navigate to the EC2 dashboard.
2. **Launch a New Instance**:
   - **Choose AMI**: Select **Ubuntu Server 20.04 LTS**.
   - **Instance Type**: Choose at least a **t2.medium** for better performance.
   - **Configure Security Group**:
     - Allow **SSH (port 22)** from your IP.
     - Allow **HTTP (port 80)** and **HTTPS (port 443)** if you plan to expose services.
3. **Key Pair**: Select or create a key pair for SSH access.
4. **Launch the Instance**.

### Step 2: Connect to Your EC2 Instance

Use SSH to connect to your instance:

```bash
ssh -i /path/to/your-key-pair.pem ubuntu@your-ec2-public-ip
```

Replace `/path/to/your-key-pair.pem` with the path to your key pair file and `your-ec2-public-ip` with the public IP of your EC2 instance.

### Step 3: Install Docker

Update packages and install Docker:

```bash
sudo apt-get update
sudo apt-get install -y docker.io
```

Add your user to the Docker group to run Docker commands without `sudo`:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Verify Docker installation:

```bash
docker --version
```

### Step 4: Install KinD

Download and install KinD:

```bash
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind
```

Verify KinD installation:

```bash
kind --version
```

### Step 5: Create a Kubernetes Cluster with KinD

Create a configuration file for a multi-node cluster (optional):

```bash
cat <<EOF >kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
EOF
```

Create the cluster:

```bash
kind create cluster --config kind-config.yaml
```

*Note: If you skip the configuration file, KinD will create a single-node cluster by default.*

### Step 6: Install kubectl

Download and install kubectl:

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

Verify kubectl installation:

```bash
kubectl version --client
```

### Step 7: Interact with the KinD Cluster

List cluster nodes:

```bash
kubectl get nodes
```

Deploy a sample application:

```bash
kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
```

### Step 8: Access the Deployed Application

1. **Find the NodePort**:

   ```bash
   kubectl get svc
   ```

   Look for the `nginx` service and note the `NodePort` value.

2. **Access the Application**:

   Use `curl` to test the application from the EC2 instance:

   ```bash
   curl localhost:{NodePort}
   ```

   Replace `{NodePort}` with the actual port number (e.g., 30080).

3. **Optional - Access from Browser**:

   If your security group allows inbound traffic on the NodePort, you can access the application via:

   ```
   http://your-ec2-public-ip:{NodePort}
   ```

## Section 4: Conclusion

Congratulations! You've successfully deployed a Kubernetes cluster using KinD on an Ubuntu EC2 instance in just 60 seconds. This setup is perfect for testing applications, CI/CD pipelines, or learning Kubernetes without the overhead of a full-scale production cluster.