NodePort service type in Kubernetes - Commands & Configuration

Introduction

Sometimes you want to make your app inside Kubernetes accessible from outside the cluster. NodePort service type opens a specific port on every node to forward traffic to your app.

When you want to expose a simple app running in Kubernetes to your local network for testing.

When you need to access your app from outside the cluster without setting up a cloud load balancer.

When you want to quickly share your app with teammates on the same network.

When you run Kubernetes on your laptop or bare metal and want external access.

When you want to debug or demo your app without complex networking.

Config File - nodeport-service.yaml

nodeport-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: example-nodeport-service
spec:
  type: NodePort
  selector:
    app: example-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
      nodePort: 30080

This file creates a Service named example-nodeport-service.

The type: NodePort tells Kubernetes to open port 30080 on every node.

The selector matches pods with label app: example-app.

The service listens on port 80 and forwards traffic to pod port 8080.

The nodePort: 30080 is the external port on each node.

Commands

This command creates the NodePort service in Kubernetes using the configuration file.

Terminal

kubectl apply -f nodeport-service.yaml

Expected Output

service/example-nodeport-service created

This command checks that the service is created and shows its details including the NodePort.

Terminal

kubectl get services example-nodeport-service

Expected Output

NAME                     TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE

example-nodeport-service NodePort   10.96.123.45    <none>        80:30080/TCP   10s

This command lists the pods that the service will send traffic to, ensuring they are running.

Terminal

kubectl get pods -l app=example-app

Expected Output

NAME                           READY   STATUS    RESTARTS   AGE

example-app-abc123def-xyz789   1/1     Running   0          5m

Key Concept

If you remember nothing else from this pattern, remember: NodePort opens a fixed port on every node to let external traffic reach your app inside Kubernetes.

Common Mistakes

Not specifying the nodePort field and expecting a specific port.

Kubernetes will assign a random port in the default range, which may be hard to find or blocked by firewalls.

Always specify nodePort explicitly if you need a known port number.

Using NodePort without matching pod labels correctly.

The service won't forward traffic to any pods if the selector labels don't match, causing connection failures.

Ensure the service selector matches the labels on your pods exactly.

Trying to access the NodePort on the cluster IP instead of the node IP.

NodePort listens on the node's IP address, not the cluster IP, so connections to cluster IP won't work externally.

Use the IP address of any cluster node with the NodePort to access the service.

Summary

Create a NodePort service YAML to expose your app on a fixed port on all nodes.

Apply the YAML with kubectl apply to create the service.

Verify the service and pods with kubectl get commands to ensure proper setup.

Practice

1. What does a Kubernetes NodePort service do?

easy

A. Exposes the service on a static port on each node's IP address

B. Creates an internal cluster IP only accessible inside the cluster

C. Routes traffic through an external load balancer automatically

D. Runs the service only on a single node in the cluster

Solution

1. Step 1: Understand NodePort service purpose

   A NodePort service exposes the application on a fixed port on every node's IP, allowing external access.

2. Step 2: Compare with other service types

   ClusterIP is internal only, LoadBalancer uses external balancers, and NodePort is not limited to a single node.

3. Final Answer:

   Exposes the service on a static port on each node's IP address -> Option A

4. Quick Check:

   NodePort = fixed port on all nodes [OK]

Hint: NodePort always opens a fixed port on every node IP [OK]

Common Mistakes:

• Confusing NodePort with ClusterIP (internal only)
• Thinking NodePort uses external load balancers automatically
• Assuming NodePort restricts service to one node

2. Which of the following is the correct YAML snippet to define a NodePort service?

easy

A. apiVersion: v1\nkind: Pod\nmetadata:\n name: my-service\nspec:\n containers:\n - name: app\n image: my-app-image

B. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: ClusterIP\n selector:\n app: my-app\n ports:\n - port: 80\n targetPort: 8080\n nodePort: 30007

C. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: NodePort\n selector:\n app: my-app\n ports:\n - port: 80\n targetPort: 8080\n nodePort: 30007

D. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: LoadBalancer\n selector:\n app: my-app\n ports:\n - port: 80\n targetPort: 8080\n nodePort: 30007

Solution

1. Step 1: Identify correct service type

   The service type must be NodePort to expose on a node port.

2. Step 2: Check YAML structure and fields

   The YAML must define kind: Service, type: NodePort, and specify nodePort under ports.

3. Final Answer:

   YAML with type NodePort and nodePort field -> Option C

4. Quick Check:

   NodePort type + nodePort field = correct YAML [OK]

Hint: NodePort service YAML must have type: NodePort and nodePort set [OK]

Common Mistakes:

• Using ClusterIP or LoadBalancer instead of NodePort
• Defining nodePort in a Pod instead of Service
• Missing the nodePort field in ports

3. Given this NodePort service YAML, what port will you use to access the app externally?

apiVersion: v1
kind: Service
metadata:
  name: example-service
spec:
  type: NodePort
  selector:
    app: example
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 31000

medium

A. Port 31000 on the node IP

B. Port 80 on the node IP

C. Port 8080 on the node IP

D. Port 80 on the pod IP

Solution

1. Step 1: Understand NodePort port usage

   The nodePort field defines the port exposed on each node's IP for external access.

2. Step 2: Identify the correct port from YAML

   The YAML sets nodePort: 31000, so external access uses port 31000 on any node IP.

3. Final Answer:

   Port 31000 on the node IP -> Option A

4. Quick Check:

   External access uses nodePort value = 31000 [OK]

Hint: Use the nodePort value to access service externally [OK]

Common Mistakes:

• Using targetPort or port instead of nodePort externally
• Trying to access pod IP directly
• Confusing port and nodePort fields

4. You created a NodePort service but cannot access your app externally. Which is the most likely cause?

medium

A. The pod selector labels do not match any pods

B. All of the above

C. The service type is set to ClusterIP instead of NodePort

D. The nodePort value is outside the allowed range (30000-32767)

Solution

1. Step 1: Check nodePort range validity

   NodePort must be between 30000 and 32767; outside this range causes failure.

2. Step 2: Verify pod selector and service type

   If selector labels don't match pods or service type is not NodePort, external access fails.

3. Step 3: Combine all issues

   Any of these issues can cause access failure, so all are likely causes.

4. Final Answer:

   All of the above -> Option B

5. Quick Check:

   Invalid port, selector, or type = no external access [OK]

Hint: Check port range, selector labels, and service type [OK]

Common Mistakes:

• Ignoring nodePort range limits
• Not verifying pod labels match selector
• Assuming service type is correct without checking

5. You want to expose a web app on port 80 inside the cluster and port 32000 externally using NodePort. Which YAML snippet correctly achieves this?

hard

A. apiVersion: v1\nkind: Service\nmetadata:\n name: webapp-service\nspec:\n type: ClusterIP\n selector:\n app: webapp\n ports:\n - port: 80\n targetPort: 80\n nodePort: 32000

B. apiVersion: v1\nkind: Service\nmetadata:\n name: webapp-service\nspec:\n type: LoadBalancer\n selector:\n app: webapp\n ports:\n - port: 32000\n targetPort: 80\n nodePort: 80

C. apiVersion: v1\nkind: Service\nmetadata:\n name: webapp-service\nspec:\n type: NodePort\n selector:\n app: webapp\n ports:\n - port: 32000\n targetPort: 32000\n nodePort: 80

D. apiVersion: v1\nkind: Service\nmetadata:\n name: webapp-service\nspec:\n type: NodePort\n selector:\n app: webapp\n ports:\n - port: 80\n targetPort: 80\n nodePort: 32000

Solution

1. Step 1: Match internal and external ports correctly

   The port is the internal cluster port (80), targetPort is the container port (80), and nodePort is the external port (32000).

2. Step 2: Verify service type and port fields

   Service type must be NodePort and ports must be set accordingly to expose externally on 32000.

3. Final Answer:

   YAML with type NodePort, port 80, targetPort 80, nodePort 32000 -> Option D

4. Quick Check:

   NodePort type + nodePort 32000 + port 80 = correct setup [OK]

Hint: Set port=internal, targetPort=container, nodePort=external port [OK]

Common Mistakes:

• Swapping port and nodePort values
• Using LoadBalancer or ClusterIP instead of NodePort
• Setting nodePort outside allowed range