How to Set Up a Multi-Node Kubernetes Cluster Locally Using Kind

Scope of this article is to enable learners and developers to run a local cluster locally. In this guide, we will walk through the process of setting up a three-node Kubernetes (K8s) cluster on your local machine using Kind (Kubernetes in Docker). This multi-node setup is perfect for simulating a production environment, allowing you to test your applications and Kubernetes configurations locally before deploying them to a real cluster.

Prerequisites

Before we begin, ensure you have the following installed on your local machine:

1. Docker: Kind runs Kubernetes clusters in Docker containers, so Docker needs to be installed and running. You can download and install Docker from here.
2. kubectl: kubectl is the command-line tool for interacting with your Kubernetes cluster. You can install it by following the official instructions here.
3. Kind: Install Kind by following the steps below.

Step 1: Install Kind

On macOS/Linux (using Homebrew):

brew install kind

On Windows (using Chocolatey):

choco install kind

Direct Installation (for other OS):

Download the latest binary from the Kind GitHub releases and move it to a directory in your PATH.

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

Step 2: Create a Three-Node Kubernetes Cluster

With Kind installed, let’s create a multi-node Kubernetes cluster.

Create a Custom Cluster Configuration

First, create a configuration file that defines a cluster with one control-plane node and two worker nodes:

# kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker

Save this file as kind-config.yaml.

Create the Cluster

Use the configuration file to create your Kubernetes cluster:

kind create cluster - config=kind-config.yaml

Kind will create a cluster with one control-plane node and two worker nodes. This might take a few minutes.

Screenshot: creating a cluster.

Verify the Cluster

To ensure that the cluster was created successfully, run the following command:

kubectl get nodes

You should see three nodes listed: one control-plane node and two worker nodes.

Screenshot: Take a screenshot showing the output of the kubectl get nodes command.

Step 3: Deploying a Sample Application on the Multi-Node Cluster

Now that your cluster is up and running, let’s deploy a simple application to it.

Deploy an Nginx Application

We will deploy an Nginx web server using a Kubernetes deployment. This deployment will automatically distribute the pods across the available nodes.

kubectl create deployment nginx - image=nginx

Scale the Deployment

To see how the workload is distributed across the nodes, scale the deployment to run multiple replicas:

kubectl scale deployment nginx - replicas=3

Check the distribution of the pods:

kubectl get pods -o wide

This command will show on which nodes the Nginx pods are running.

Screenshot: Scaled deployment

Expose the Deployment

To access the Nginx service, expose it as a NodePort:

kubectl expose deployment nginx - type=NodePort - port=80

Access the Application

Get the NodePort and access the service in your browser:

kubectl get service nginx

Take note of the NodePort and use it to access the application:

http://localhost:<NodePort>

Step 4: Managing Your Multi-Node Cluster

Checking Node Status

To see the status of your nodes:

kubectl get nodes

Checking Pod Distribution

You can observe how the workload is distributed across the nodes by listing the pods with details:

kubectl get pods -o wide

This will give you an idea of how Kubernetes schedules your workloads across the cluster.

Deleting the Cluster

Once you’re done, you can delete the cluster:

kind delete cluster

This command will remove the entire cluster, freeing up resources on your local machine.

Screenshot: terminal after the cluster deletion.

Insights and Best Practices

1. Resource Allocation

• Even though this is a local setup, it’s important to monitor Docker’s resource usage. You can adjust Docker’s CPU and memory allocation to ensure that your multi-node cluster runs smoothly.

2. Cluster Configurations

• For more complex scenarios, you can modify the Kind configuration file to simulate different environments, such as adding more worker nodes, simulating network partitions, or setting up specific resource constraints.

3. Realistic Testing

• Use this multi-node setup to test your applications’ behavior in a distributed environment. This can help identify issues related to load balancing, scaling, and node failures before deploying to a production environment.

You’ve successfully set up a multi-node Kubernetes cluster on your local machine using Kind. This setup provides a powerful way to simulate a production environment for testing and development. By deploying and scaling applications on this cluster, you gain valuable insights into how your application might perform in a real-world scenario.

This local setup not only saves you the cost and complexity of spinning up multiple cloud VMs but also allows you to learn and test Kubernetes in a controlled environment. It’s an ideal solution for experimenting with new features, troubleshooting configurations, and refining your deployment strategies without relying on cloud resources.