Skip to main content

Documentation Index

Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt

Use this file to discover all available pages before exploring further.

Welcome to this tutorial on Kubernetes Services. In this guide, we’ll focus on the NodePort type, which enables external traffic to reach Pods through a port on each Node. Kubernetes Services provide stable network endpoints for Pods, enabling reliable communication both within the cluster and from outside clients.

​
Why Use Kubernetes Services?

Kubernetes Services decouple the front-end, back-end, and data-layer Pods, offering:
  • Stable endpoints: Consistent IPs or DNS names for Pods that may be recreated.
  • Load balancing: Distributes traffic evenly across multiple Pods.
  • Discoverability: Native service discovery within the cluster network.
Applications typically consist of:
  • Front-end Pods serving user interfaces
  • Back-end Pods processing business logic
  • Pods connecting to external data sources
With Services, these components can communicate without hardcoding Pod IPs.

​
External Access Use Case

By default, Pod IPs (e.g., 10.244.0.2) are only reachable inside the cluster network. To access a web server Pod from your laptop (192.168.1.10) without SSH’ing into the Node (192.168.1.2), you need a NodePort Service which maps a port on the Node to the Pod’s port. 
curl http://192.168.1.2:30008
Hello World!
Service TypeUse CaseExample Configuration
ClusterIPInternal-only service for Pod-to-Pod communicationtype: ClusterIP
NodePortExposes Pod on a port across all Nodes for external accesstype: NodePort
nodePort: 30008
LoadBalancerProvisions a cloud load balancer to distribute external traffictype: LoadBalancer
NodePort ranges from 30000 to 32767 by default. You can customize this in the API server flags.
The image illustrates a Kubernetes NodePort service setup, showing a service routing traffic from port 30008 to a pod at IP 10.244.0.2 on port 80.

​
NodePort Service Ports Explained

A NodePort Service uses three port definitions:
  • targetPort: Port on the Pod (e.g., 80)
  • port: Virtual Service port inside the cluster (e.g., 80)
  • nodePort: Port on each Node, accessible externally (e.g., 30008)
Traffic to <NodeIP>:<nodePort> → Service → port → Pod at targetPort.

​
Defining a NodePort Service

  1. Create a Pod with labels:
# pod-definition.yaml
apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp
    component: frontend
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80
  1. Define the NodePort Service, matching the Pod labels:
# service-definition.yaml
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: NodePort
  selector:
    app: myapp
    component: frontend
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30008
  1. Deploy and Verify:
kubectl apply -f pod-definition.yaml
kubectl apply -f service-definition.yaml
kubectl get svc
Expected output: 
NAME             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
kubernetes       ClusterIP   10.96.0.1        <none>        443/TCP          16d
myapp-service    NodePort    10.106.127.123   <none>        80:30008/TCP     5m
Access the application: 
curl http://192.168.1.2:30008
<html>
  <head><title>Welcome to nginx!</title></head>
  <body><h1>Welcome to nginx!</h1></body>
</html>
Exposing high ports on Nodes can pose security risks. Ensure proper firewall rules and network policies are in place.

​
Scaling with Multiple Pods and Nodes

In production, you’ll run multiple Pod replicas for high availability. A NodePort Service automatically load-balances incoming traffic across all Pods that match its selector, even when spread across multiple Nodes.
The image illustrates a Kubernetes NodePort service setup, showing how a user connects to a service that routes traffic to different pods across multiple nodes.
Simply scale your Deployment or Pod replicas: 
kubectl scale deployment myapp-deployment --replicas=3
Now, requests to any Node at NodeIP:30008 are distributed across all 3 Pods.

​
Summary

  • NodePort Services expose Pod ports on each Node for external access.
  • Key fields: type: NodePort, port, targetPort, and nodePort.
  • Match Services to Pods via label selector.
  • Kubernetes handles load balancing across Pods and Nodes automatically.
Next, explore the demo to see NodePort Services in action!

Watch Video