Kubernetes Services and Networking

In this lesson, we will explore how Kubernetes services enable communication between different components of your applications and provide stable endpoints for accessing them.

What are Kubernetes Services?

Kubernetes services are an abstraction that defines a logical set of Pods and a policy by which to access them. Services allow you to expose your application running on a set of Pods as a network service.

Types of Services

Kubernetes supports several types of services:

Creating a Service

To create a service, you can use a YAML configuration file. Below is an example of a simple ClusterIP service that exposes a Deployment called my-app:

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

Explanation of the Service Configuration:

• metadata.name: The name of the service.
• spec.type: The type of service (ClusterIP in this case).
• spec.selector: This selects the Pods that will be exposed by this service based on their labels.
• spec.ports: Defines the ports that the service will expose. port is the port that the service listens on, and targetPort is the port on the Pod that the traffic is directed to.

Accessing the Service

Once the service is created, you can access it using the service name within the cluster. For example, if you have a Pod that needs to communicate with my-app-service, it can do so by simply using the DNS name my-app-service.

Example: Accessing the Service from a Pod

Here’s how you can access the service from a Pod:

# Assuming you have a Pod running a shell (like busybox)
kubectl run -i --tty --rm debug --image=busybox -- sh

# Inside the Pod, you can use curl to access the service:
curl http://my-app-service

Best Practices

• Use Labels and Selectors: Always use labels and selectors to manage your Pods and Services effectively.
• Service Discovery: Leverage Kubernetes' built-in service discovery to access services using their names.

Common Mistake: Forgetting to specify the correct targetPort can lead to connectivity issues, as the service will not know which port on the Pod to forward traffic to.

Summary

In this lesson, you learned about Kubernetes services and networking. You now know how to create and access services, as well as the different types of services available in Kubernetes. Understanding services is vital for building scalable and resilient applications in Kubernetes.

Exercise 1: Create a NodePort Service

1. Create a NodePort service for your existing application.
2. Use the following YAML template:

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

Exercise 2: Access the Service

1. Once the NodePort service is created, access it from your browser or using curl: - Use the Node IP and the port 30000.

Exercise 3: Create an ExternalName Service

1. Create an ExternalName service that points to an external service (like Google).
2. Use the following YAML template:

apiVersion: v1
kind: Service
metadata:
  name: external-google
spec:
  type: ExternalName
  externalName: www.google.com

• Kubernetes services provide stable endpoints for accessing Pods.
• There are different types of services: ClusterIP, NodePort, LoadBalancer, and ExternalName.
• Services use selectors to route traffic to the appropriate Pods.
• Always use labels for effective management of Pods and Services.
• Leverage built-in service discovery for accessing services by name.