> ## Content Index
> Fetch the complete content index at: https://scriptcrunch.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# How to Expose an Application in NodePort in a Kind Cluster
- URL: https://scriptcrunch.com/expose-nodeport-kind-cluster/
- Published: 2025-01-09T06:20:35.000Z
- Updated: 2026-06-23T08:55:54.000Z
- Author: Aswin Vijayan
- Tags: Kubernetes, #Migrated-1758801465347, #wp, #wp-post, #Import 2025-09-25 11:57

In this blog, we will explain how to expose an application using a **NodePort** service in a [Kind](https://kind.sigs.k8s.io/?ref=scriptcrunch.com) cluster.

We will keep everything simple and easy to understand.

## What is NodePort?

- A **NodePort** is a way to make your application reachable outside the [Kubernetes](https://scriptcrunch.com/tag/kubernetes/) cluster.
- With NodePort, Kubernetes will open a port on every node in your cluster.
- You can connect to your application by using the IP of your node and the **NodePort** port number.

## Why You Cannot Directly Access NodePort in Kind

When running a regular Kubernetes cluster on VMs or physical machines, NodePorts are exposed directly on the node's network interface.

But when you create a Kubernetes cluster using Kind, each Kubernetes node is actually **running inside a [Docker](https://scriptcrunch.com/tag/docker/) container**. By default, Docker containers have their own network, which is separate from your computer’s network. Even if you create a NodePort service, the port is only open inside the container’s network.

Because of this separation, you cannot just open `localhost:<NodePort>` on your computer to reach the service. It will not work unless you do extra port mappings from the container to your host machine.

**In short:** The NodePort is open in the Docker container’s internal network, not on your actual machine’s network. You need to map the container port to your machine’s port if you want to access it through `localhost`.

## Creating a Multi-Node Cluster with Port Mapping

To fix the problem, you can explicitly tell Kind to map ports from the Docker containers to your computer’s network. This way, if Kubernetes picks a NodePort like `30000`, it will be tied to `localhost:30000` on your machine.

You can map Node ports to 80 or 8080 as well. When you do this, you just need to make sure those ports are not already in use on your machine

### 1\. Create a Cluster Configuration File

Create a file named `multi-node-cluster.yaml` (or any name you like) with the following content:

```yml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: kind-dev-cluster
nodes:
  - role: control-plane
    extraPortMappings:
      - containerPort: 30000
        hostPort: 30000
        protocol: TCP
      - containerPort: 31000
        hostPort: 31000
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 8080
        hostPort: 8080
        protocol: TCP
  - role: worker
  - role: worker
```

- **name**: This is the name of your Kind cluster.
- **extraPortMappings**: This tells Docker to map the container’s ports (NodePorts) to matching ports on your computer. In this example, ports `30000`, `31000`, and `80` inside the cluster will be accessible on `localhost:30000`, `localhost:31000`, and `localhost:80` respectively.

### 2\. Create the Kind Cluster

Use this command to create your cluster:

```bash
kind create cluster --config=multi-node-cluster.yaml
```

Kind will start multiple nodes (one control-plane node and four worker nodes) inside Docker containers, using the port mappings you specified.

### 3\. Verify the Cluster

Check if your cluster is running:

```bash
kubectl cluster-info --context kind-multi-node-cluster
```

You should see information about your new multi-node cluster.

## Deploying and Exposing a Sample Application

Now that you have a cluster with port mappings, you can deploy any application and expose it using a NodePort.

### 1\. Deploy an Application (Nginx)

```bash
kubectl create deployment my-nginx --image=nginx
```

### 2\. Expose the Deployment as a NodePort

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

Run the following command to find out which NodePort was assigned:

```bash
kubectl get services
```

Look at the **PORT(S)** column for `my-nginx`. It should look like `80:30000/TCP` (or maybe `31000` or `32000`, depending on which port was chosen).

### 3\. Access the Application

If the service is using port `30000`, for example, open:

```bash
http://localhost:30000
```

You should see the Nginx welcome page.

---

## Summary

1. **Kind Runs in Containers**  
Each Kubernetes node in Kind is a Docker container, so you cannot directly access NodePorts from your computer’s network without extra port mappings.
2. **Use a Custom Kind Configuration**  
By adding `extraPortMappings` in your Kind configuration file, you map Docker container ports to your actual machine’s ports.
3. **Access via Localhost**  
After creating the Kind cluster with port mappings, you can reach NodePort services at `localhost:<port>`.

This setup makes it easy to create a local multi-node Kubernetes cluster for testing, [development](https://scriptcrunch.com/tag/development/), or learning—without needing extra hardware or a dedicated environment.

You can use this setup as a lab to prepare for the [CKA certification](https://scriptcrunch.com/kubernetes-exam-guide/). Also, check out the [CKA coupon](https://scriptcrunch.com/linux-foundation-coupon/) for big discounts on certification registration.