Kubernetes Services and Endpoint

Introduction to Kubernetes

Kubernetes, also known as "k8s," is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications across a cluster of nodes¹². It provides a powerful framework for managing workloads, networking, and services within a distributed environment.

Creating Deployments and Services

Creating Deployments

In Kubernetes, a Deployment defines a desired state for a set of Pods. Let's create a Deployment running Nginx:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx

Apply the Deployment:

kubectl apply -f nginx-deployment.yaml

Creating Services

Now let's create a ClusterIP Service that points to the Nginx Deployment:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Apply the Service:

kubectl apply -f nginx-service.yaml

Testing ClusterIP Service

Create a busybox pod:

kubectl run busybox --image=busybox --restart=Never -- sleep 3600

Execute a curl command to check if the ClusterIP service is listening to the Nginx webpage:

kubectl exec -it busybox -- sh
curl nginx-service
# Expected output: The HTML content of the Nginx webpage

Delete the busybox pod:
```
kubectl delete pod busybox
```

Creating NodePort Service

Next, let's create a NodePort Service:

apiVersion: v1
kind: Service
metadata:
  name: nginx-nodeport
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  # Specify the nodePort (e.g., 30080) to expose the service externally
  nodePort: 30080

Apply the NodePort Service:

kubectl apply -f nginx-nodeport.yaml

Testing NodePort Service

Get the IP address of any node in your cluster:
```
kubectl get nodes -o wide
```
Use the node's IP address and the specified nodePort (e.g., 30080) to access the Nginx service externally:
```
http://<node_ip>:30080
```

Comparing Endpoint IPs with Pods

Endpoints represent the IP addresses of one or more Pods dynamically assigned to a Service.

First, let's assume we have two Pods associated with our Nginx Deployment. We'll use the following Pod names:
- nginx-pod-1
- nginx-pod-2

Now, let's retrieve the IP addresses of these Pods using the kubectl get pods -o wide command:

$ kubectl get pods -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP            NODE
nginx-pod-1    1/1     Running   0          5m    10.244.1.10   node-1
nginx-pod-2    1/1     Running   0          5m    10.244.2.20   node-2

In this example:

nginx-pod-1 has an IP address of 10.244.1.10.
nginx-pod-2 has an IP address of 10.244.2.20.

Let's get more information about the nginx-service using kubectl describe:

kubectl describe service nginx-service

This command will provide detailed information about the service, including its IP address, ports, and associated endpoints.

Next, let's check the Endpoints associated with our nginx-service using the kubectl get endpoints nginx-service command:
```
$ kubectl get endpoints nginx-service
NAME            ENDPOINTS                      AGE
nginx-service   10.244.1.10:80,10.244.2.20:80   5m
```
Here, the nginx-service has endpoints corresponding to both Pods:
- 10.244.1.10:80 (associated with nginx-pod-1)
- 10.244.2.20:80 (associated with nginx-pod-2)
Finally, we can compare the IP addresses from the Endpoints with the Pod IPs to verify that they match.

Remember that these IP addresses are internal to the cluster and are used for communication between services and Pods. The Service abstraction ensures seamless connectivity without exposing individual Pod IPs externally.

References

PreviousAdvanced Kubernetes Deployment Exercise

Last updated 13 days ago

Table of Contents