From Laptop to Cloud: Setting Up Kubernetes Clusters the Right Way

Mark Dsouza — Tue, 21 Apr 2026 18:17:41 +0000

Building Kubernetes Clusters: From Local to Production

Kubernetes is everywhere — powering modern applications, scaling startups, and running critical infrastructure across the globe. But here's the problem: most developers use Kubernetes without ever truly understanding how a cluster is built.

If you've ever run a few kubectl commands, deployed a YAML file, or followed a quick tutorial, you've only scratched the surface.

In this guide, we're going deeper. Instead of just using Kubernetes, we'll build and explore clusters across different environments, starting from your local machine and gradually moving toward production-grade setups. Along the way, you'll not only learn how to set things up, but more importantly, why each approach exists.

What We'll Cover

Kind — the fastest way to spin up a lightweight Kubernetes cluster using Docker
Minikube — a more feature-rich local environment for development and testing
Kubeadm — the real way to bootstrap your own Kubernetes cluster from scratch
Amazon EKS — a production-ready, managed Kubernetes service used in industry

By the end of this article, you'll understand:

How Kubernetes clusters actually work under the hood
The differences between local, self-managed, and managed clusters
Which setup is right for your use case

Kubernetes Architecture

Before we start installing anything, let's quickly understand what a Kubernetes cluster actually looks like.

A Kubernetes cluster has two main parts:

1. Control Plane (the brain 🧠)

This is the part that makes decisions. It decides what should run, where it should run, and when to restart something if it fails.

Component	Role
API Server	Entry point — everything talks to this
Scheduler	Decides which node runs your app
Controller Manager	Keeps things in the desired state
etcd	Stores all cluster data

2. Worker Nodes (the machines ⚙️)

This is where your actual applications run.

Component	Role
kubelet	Talks to the control plane
kube-proxy	Handles networking
Pods	Smallest unit where your containers run

Simple Mental Model

Think of Kubernetes like a company:

Control Plane = Manager (assigns work, checks everything)
Worker Nodes = Employees (do the actual work)

Cluster Setup Options

Tool	Best For
Kind	Lightweight multi-node clusters inside Docker
Minikube	Simple single-node local setup
Kubeadm	Real multi-node clusters from scratch
EKS / AKS / GKE	Enterprise-level managed clusters

1. Kind

Kind (Kubernetes in Docker) lets you create a Kubernetes cluster using Docker containers instead of real machines. It's the fastest and easiest way to spin up a local cluster for learning, testing, and development.

Step 1: Install Docker

Make sure Docker is installed on your system: Docker Installation Guide

Step 2: Install Kind

Run the appropriate install script for your OS:

Linux (install.sh)

#!/bin/bash

set -e
set -o pipefail

echo "Starting installation of Docker, Kind, and kubectl..."

# Install Docker
if ! command -v docker &>/dev/null; then
  echo "Installing Docker..."
  sudo apt-get update -y
  sudo apt-get install -y docker.io
  sudo usermod -aG docker "$USER"
  echo "Docker installed and user added to docker group."
else
  echo "Docker is already installed."
fi

# Install Kind
if ! command -v kind &>/dev/null; then
  echo "Installing Kind..."
  ARCH=$(uname -m)
  if [ "$ARCH" = "x86_64" ]; then
    curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.29.0/kind-linux-amd64
  elif [ "$ARCH" = "aarch64" ]; then
    curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.29.0/kind-linux-arm64
  else
    echo "Unsupported architecture: $ARCH"
    exit 1
  fi
  chmod +x ./kind
  sudo mv ./kind /usr/local/bin/kind
  echo "Kind installed successfully."
else
  echo "Kind is already installed."
fi

# Install kubectl
if ! command -v kubectl &>/dev/null; then
  echo "Installing kubectl (latest stable version)..."
  curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
  sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
  rm -f kubectl
  echo "kubectl installed successfully."
else
  echo "kubectl is already installed."
fi

echo "Installed Versions:"
docker --version
kind --version
kubectl version --client --output=yaml

macOS (install.sh)

#!/bin/bash

set -e
set -o pipefail

echo "Starting installation of Docker, Kind, and kubectl on macOS (M1/M2)..."

# Install Homebrew
if ! command -v brew &>/dev/null; then
  echo "Installing Homebrew..."
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
  eval "$(/opt/homebrew/bin/brew shellenv)"
else
  echo "Homebrew is already installed."
fi

# Install Docker
if ! command -v docker &>/dev/null; then
  echo "Installing Docker Desktop..."
  brew install --cask docker
  echo "Please launch Docker Desktop manually after installation."
else
  echo "Docker is already installed."
fi

# Install Kind
if ! command -v kind &>/dev/null; then
  brew install kind
  echo "Kind installed successfully."
else
  echo "Kind is already installed."
fi

# Install kubectl
if ! command -v kubectl &>/dev/null; then
  brew install kubectl
  echo "kubectl installed successfully."
else
  echo "kubectl is already installed."
fi

echo "Installed Versions:"
docker --version || echo "Docker not running yet (open Docker Desktop)."
kind --version
kubectl version --client --output=yaml

Step 3: Create a Kind Cluster

Create a configuration file named kind-cluster.yml:

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    image: kindest/node:v1.33.1
  - role: worker
    image: kindest/node:v1.33.1
  - role: worker
    image: kindest/node:v1.33.1
  - role: worker
    image: kindest/node:v1.33.1

Then create the cluster:

kind create cluster --config kind-cluster.yml --name mark-cluster

Step 4: Verify the Cluster

# Check running nodes
kubectl get nodes

# View cluster info
kubectl cluster-info

Learning Resource: For a quick setup with hands-on examples, check out themark007/Kubernetes-learning on GitHub.

2. Minikube

Kind vs. Minikube

	Kind	Minikube
Node setup	Multi-node	Single-node
Best for	Quick multi-node simulation	Beginner-friendly local dev

Step 1: Install Minikube

macOS

brew install minikube

Linux

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

Step 2: Start the Cluster

minikube start

This will create a single-node Kubernetes cluster and configure kubectl automatically.

Step 3: Verify the Cluster

kubectl get nodes

You should see one node in Ready state.

Step 4: Access Your App (Optional)

minikube service <service-name>

This opens your service in the browser.

What's Next?

Kind and Minikube make Kubernetes easy to get started with locally. But to truly understand Kubernetes end-to-end:

Kubeadm shows you how a real cluster is bootstrapped from scratch
Amazon EKS shows how Kubernetes runs in production at scale

Check out the detailed guides on Kubeadm and EKS on the author's profile.

DEV Community: Mark Dsouza