Kubernetes Networking Services for Beginners: A Comprehensive Guide

Siddhartha GauravSiddhartha Gaurav
6 min read

Kubernetes (k8s) is a powerful orchestration tool for managing containerized applications, and understanding its networking model is crucial for effective deployment and management. In this blog, we'll explore Kubernetes networking services, breaking down complex concepts into easily digestible chunks with practical examples.

Table of Contents

  1. Introduction to Kubernetes Networking

  2. Basic Concepts and Terminologies

  3. Kubernetes Networking Model

  4. Kubernetes Networking Services

    • ClusterIP

    • NodePort

    • LoadBalancer

    • ExternalName

  5. Practical Examples

    • Setting up a ClusterIP Service

    • Exposing an Application with NodePort

    • Using LoadBalancer for External Access

  6. Conclusion

1. Introduction to Kubernetes Networking

Kubernetes networking is the backbone of communication within a Kubernetes cluster. It ensures seamless interaction between various components like pods, services, and external clients. The networking model is designed to be simple yet powerful, providing:

  • Pod-to-Pod Communication: Pods can communicate with each other without any network translation.

  • Pod-to-Service Communication: Services can be used to expose pods and allow access to them.

  • External-to-Service Communication: Services can be exposed to the outside world, enabling external clients to access the applications running inside the cluster.

2. Basic Concepts and Terminologies

Before diving into the specifics of Kubernetes networking services, let's clarify some essential concepts:

  • Pod: The smallest deployable unit in Kubernetes, encapsulating one or more containers. Each pod gets its own IP address.

  • Service: An abstraction that defines a logical set of pods and a policy to access them. It decouples the definition of an application from the instance of that application.

  • ClusterIP: The default service type, accessible only within the cluster, providing a stable internal IP.

  • NodePort: Exposes the service on each node’s IP at a specific port, allowing external access through the node’s IP and the defined port.

  • LoadBalancer: Integrates with the cloud provider’s load balancer to expose the service externally, providing a stable external IP.

  • ExternalName: Maps a service to an external DNS name, acting as a CNAME alias without creating proxy rules.

3. Kubernetes Networking Model

The Kubernetes networking model simplifies how containers in different pods communicate:

  • Flat Network: All pods in a cluster can communicate with each other without Network Address Translation (NAT).

  • Each Pod Gets an IP: Each pod has a unique IP address, which means no need for mapping container ports to host ports.

  • Service Discovery and DNS: Kubernetes has built-in service discovery, allowing pods to communicate using service names. A DNS server, kube-dns, is used for resolving these names to service IPs.

4. Kubernetes Networking Services

Kubernetes services abstract and manage network access to a group of pods. Let's explore the different types of services.

ClusterIP

ClusterIP is the default service type. It creates an internal IP address that can only be accessed within the cluster. This is useful for internal communication between pods within the same cluster.

  • Use Case: Internal microservices communication.

  • Example YAML Configuration:

apiVersion: v1
kind: Service
metadata:
  name: my-clusterip-service
spec:
  type: ClusterIP
  selector:
    app: MyApp
  ports:
    - port: 80
      targetPort: 8080

In this example, the service my-clusterip-service will route traffic to the pods labeled app: MyApp on port 80, which forwards to port 8080 in the pods.

NodePort

NodePort exposes the service on each node’s IP at a static port (30000-32767 range). This makes the service accessible externally by using the node’s IP address and the NodePort.

  • Use Case: Direct access from external clients when you don't have a cloud load balancer.

  • Example YAML Configuration:

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

In this example, the service my-nodeport-service exposes the application on port 30007 of each node’s IP address.

LoadBalancer

LoadBalancer integrates with the cloud provider’s load balancer to expose the service externally. It assigns an external IP to the service and forwards traffic to the designated pods.

  • Use Case: Exposing services to the internet with a managed load balancer.

  • Example YAML Configuration:

apiVersion: v1
kind: Service
metadata:
  name: my-loadbalancer-service
spec:
  type: LoadBalancer
  selector:
    app: MyApp
  ports:
    - port: 80
      targetPort: 8080

In this example, the service my-loadbalancer-service will be assigned an external IP by the cloud provider, allowing external traffic to access the service.

ExternalName

ExternalName maps a service to an external DNS name by returning a CNAME record. It doesn’t create a proxy and simply provides an alias.

  • Use Case: Redirecting traffic to an external service or a service outside the cluster.

  • Example YAML Configuration:

apiVersion: v1
kind: Service
metadata:
  name: my-externalname-service
spec:
  type: ExternalName
  externalName: example.com

In this example, the service my-externalname-service will resolve to example.com.

5. Practical Examples

Let's look at some practical examples to understand how these services work.

Setting up a ClusterIP Service

  1. Create a Deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: MyApp
  template:
    metadata:
      labels:
        app: MyApp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8080
  1. Create a ClusterIP Service:
apiVersion: v1
kind: Service
metadata:
  name: myapp-clusterip
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Apply these configurations:

[root@sid-vm services]# kubectl apply -f myapp-deployemnt.yml
deployment.apps/myapp-deployment created
[root@sid-vm services]#
[root@sid-vm services]# kubectl apply -f myapp-clusterip.yml
service/myapp-clusterip created
[root@sid-vm services]#

This will create a deployment with 3 replicas and expose it internally within the cluster using the ClusterIP service.

[root@sid-vm services]# kubectl get rs
NAME                          DESIRED   CURRENT   READY   AGE
myapp-deployment-75f5d9b8b9   3         3         0       2m23s
[root@sid-vm services]#
[root@sid-vm services]# kubectl get svc
NAME              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
kubernetes        ClusterIP   10.96.0.1       <none>        443/TCP   29d
myapp-clusterip   ClusterIP   10.102.99.100   <none>        80/TCP    2m19s
[root@sid-vm services]#

Exposing an Application with NodePort

  1. Create a NodePort Service:
apiVersion: v1
kind: Service
metadata:
  name: myapp-nodeport
spec:
  type: NodePort
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
      nodePort: 30007

Apply the configuration:

[root@sid-vm services]# kubectl apply -f myapp-nodeport.yml
service/myapp-nodeport created
[root@sid-vm services]#
[root@sid-vm services]# kubectl get svc
NAME              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes        ClusterIP   10.96.0.1       <none>        443/TCP        29d
myapp-clusterip   ClusterIP   10.102.99.100   <none>        80/TCP         4m10s
myapp-nodeport    NodePort    10.107.59.253   <none>        80:30007/TCP   18s
[root@sid-vm services]#

You can access the service externally using http://<NodeIP>:30007.

Using LoadBalancer for External Access

  1. Create a LoadBalancer Service:
apiVersion: v1
kind: Service
metadata:
  name: myapp-loadbalancer
spec:
  type: LoadBalancer
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Apply the configuration:

kubectl apply -f service-loadbalancer.yaml

The cloud provider will assign an external IP to the service, making it accessible via this IP.

6. Conclusion

Kubernetes networking services play a vital role in enabling communication within the cluster and with the outside world. By understanding and utilizing ClusterIP, NodePort, LoadBalancer, and ExternalName services, you can effectively manage your applications' networking requirements. With practical examples and configurations, you now have a solid foundation to start implementing Kubernetes networking services in your own projects. Happy networking!

0
Subscribe to my newsletter

Read articles from Siddhartha Gaurav directly inside your inbox. Subscribe to the newsletter, and don't miss out.

load balancer in k8scluster ipKubernetesk8snetworkingservices in kubernetesKubernetes nodeport

Written by

Siddhartha Gaurav
Siddhartha Gaurav

I'm a passionate DevOps engineer with a knack for streamlining development workflows and ensuring seamless deployment pipelines. With experience in managing cloud infrastructure, implementing DevOps best practices, and leveraging automation tools, I thrive on tackling complex challenges and driving efficiency in software delivery. Let's connect and explore how I can contribute to your projects!