NodePort service type in Kubernetes - Step-by-Step Execution

Process Flow - NodePort service type

Create Service YAML

↓

kubectl apply -f service.yaml

↓

Kubernetes API Server creates NodePort Service

↓

Assign port in range 30000-32767

↓

Service listens on all nodes at NodePort

↓

External client sends request to NodeIP:NodePort

↓

Request forwarded to target Pods via ClusterIP

This flow shows how a NodePort service is created and how it exposes pods on a port accessible from outside the cluster.

Execution Sample

Kubernetes

apiVersion: v1
kind: Service
metadata:
  name: my-nodeport-service
spec:
  type: NodePort
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 30007

Defines a NodePort service exposing pods with label app=myapp on port 80, forwarding to pod port 8080, accessible externally on port 30007.

Process Table

Step	Action	Result	Details
1	Create YAML file with NodePort service spec	YAML file ready	Defines service type NodePort with nodePort 30007
2	Run kubectl apply -f service.yaml	Service created	Kubernetes API server processes the service definition
3	Kubernetes assigns NodePort 30007	Port reserved	Port 30007 is within allowed range 30000-32767
4	Service listens on all cluster nodes at port 30007	NodePort active	External traffic can reach any node on port 30007
5	External client sends request to NodeIP:30007	Request received	Node forwards request to service
6	Service forwards request to pod on port 8080	Pod receives request	Pod with label app=myapp handles traffic
7	Response sent back to client	Communication complete	Client receives pod response
8	End	Process complete	NodePort service is operational

💡 NodePort service exposes pods externally via fixed port 30007 on all nodes

Status Tracker

Variable	Start	After Step 3	After Step 4	Final
nodePort	undefined	30007 assigned	30007 listening on nodes	30007 active for external access
serviceStatus	Not created	Created	Active	Active
podTraffic	No traffic	No traffic	No traffic	Traffic flowing

Key Moments - 3 Insights

Why must the nodePort be in the range 30000-32767?

Kubernetes reserves ports in this range for NodePort services to avoid conflicts with system ports. See execution_table step 3 where port 30007 is assigned within this range.

Does NodePort expose the pod port directly to the outside?

No, NodePort exposes a port on each node, which forwards traffic to the pod's targetPort inside the cluster. See execution_table steps 5 and 6 for request forwarding.

Can external clients access the pod using the pod IP directly?

No, external clients access the node IP and NodePort. Kubernetes routes the traffic to pods internally. See execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the NodePort assigned?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Check the 'Action' column for 'Kubernetes assigns NodePort' in execution_table.

According to variable_tracker, what is the state of 'podTraffic' after step 4?

A Traffic forwarded

B No traffic

C Traffic flowing

D Undefined

💡 Hint

Look at the 'podTraffic' row under 'After Step 4' in variable_tracker.

If the nodePort was set outside the allowed range, what would happen in the execution flow?

A NodePort would be assigned anyway at step 3

B Traffic would be forwarded incorrectly at step 6

C Service creation would fail at step 2

D No effect, service works normally

💡 Hint

Refer to step 3 in execution_table where port assignment must be in range.

Concept Snapshot

NodePort Service exposes pods on a static port (30000-32767) on each node.
External clients access NodeIP:NodePort to reach pods.
Service forwards traffic from NodePort to pod's targetPort.
NodePort must be in allowed range or Kubernetes assigns one.
Useful for simple external access without load balancer.

Full Transcript

This visual execution shows how a Kubernetes NodePort service works. First, you create a YAML file defining the service with type NodePort and specify ports. Then, you apply this file with kubectl. Kubernetes assigns a port in the range 30000-32767 if not specified. The service listens on this port on all cluster nodes. External clients send requests to any node's IP and this port. The service forwards the requests to the pods on their target port. Responses go back to the client. Variables like nodePort and podTraffic change state as the service becomes active and traffic flows. Key points include the port range restriction and that NodePort exposes node ports, not pod IPs directly. The quizzes test understanding of port assignment, traffic state, and error cases. This helps beginners see step-by-step how NodePort services expose pods externally.

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