As cloud-native applications continue to evolve, Kubernetes has emerged as the orchestration tool of choice for developers and operators alike. One of the more critical components of a Kubernetes cluster is its internal DNS system, which enables services to discover and communicate with each other seamlessly. In this article, we’ll dive into the intricacies of Kubernetes internal DNS and provide a step-by-step guide to mastering it.

What is Kubernetes Internal DNS?

Kubernetes has a built-in DNS service that allows pods (the smallest deployable units in Kubernetes) to resolve service names to their respective IP addresses. This service plays a crucial role in the dynamic nature of Kubernetes, where pods may come and go, and their IPs can change frequently. By using DNS, developers can use predictable names instead of IP addresses, reducing complexity and increasing reliability.

Key Features of Kubernetes DNS

  1. Automatic DNS Resolution: Unlike traditional environments where DNS needs to be pre-configured, Kubernetes automatically sets up DNS resolution for all services and pods.

  2. Service Discovery: By providing a simple name (e.g., my-service.my-namespace.svc.cluster.local), Kubernetes enables service discovery, which simplifies communication between different components of an application.

  3. Headless Services: Kubernetes allows for headless services, which means you can access individual pod IPs instead of a single service IP.

  4. Custom DNS Records: Users can create custom DNS records via Endpoints and Service resources.

Getting Started with Kubernetes Internal DNS

Prerequisites

  1. A running Kubernetes cluster (you can use Minikube for testing).

  2. kubectl command-line tool configured for your cluster.

  3. Basic knowledge of Kubernetes concepts like pods, services, and namespaces.

Step 1: Verify the DNS Service

Kubernetes deploys a DNS service (usually CoreDNS or kube-dns) by default. You can verify if it’s running by executing the following command:

sh
kubectl get pods –namespace=kube-system

You should see a pod named coredns or kube-dns running. If it’s not present, you will need to deploy it using your cluster’s setup instructions.

Step 2: Create a Sample Deployment and Service

Let’s create a simple deployment and a corresponding service to see how internal DNS works.

  1. Create a Deployment:

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

  • name: nginx
    image: nginx:nginx
    ports:

    • containerPort: 80

Save this to a file named nginx-deployment.yaml and run:

sh
kubectl apply -f nginx-deployment.yaml

  1. Create a Service:

Next, create a service to expose this deployment:

yaml
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
selector:
app: nginx
ports:

  • protocol: TCP
    port: 80
    targetPort: 80
    type: ClusterIP

Save this to a file named nginx-service.yaml and run:

sh
kubectl apply -f nginx-service.yaml

Step 3: Test DNS Resolution

To test if DNS is functioning properly, create another pod that will attempt to reach the service using its DNS name.

yaml
apiVersion: v1
kind: Pod
metadata:
name: dns-test
spec:
containers:

  • name: dnsutils
    image: tutum/dnsutils
    command:

    • “sleep”

    • “3600”

Save it to dns-test.yaml and run:

sh
kubectl apply -f dns-test.yaml

Once the pod is running, you can exec into it and test DNS resolution:

sh
kubectl exec -ti dns-test — nslookup nginx-service

You should see the IP addresses of the NGINX service returned.

Step 4: Explore Headless Services

Sometimes you may want direct access to the pods without going through a single IP service. For this, you can create a headless service by setting the clusterIP field to None.

yaml
apiVersion: v1
kind: Service
metadata:
name: nginx-headless
spec:
clusterIP: None
selector:
app: nginx
ports:

  • protocol: TCP
    port: 80
    targetPort: 80

Deploy this configuration and check the DNS resolution in a similar way you did before. You can now directly access the pod IPs.

Step 5: Troubleshooting DNS Issues

If you encounter problems with DNS resolution, you can check the following:

  1. Logs: Check the logs of the DNS pods with:
    sh
    kubectl logs -n kube-system -l k8s-app=kube-dns

  2. CoreDNS Configuration: Ensure your CoreDNS config map is correctly set up by running:
    sh
    kubectl get configmap coredns -n kube-system -o yaml

  3. Networking: Ensure that the network policies (if any) are not hindering communication.

Conclusion

Kubernetes internal DNS is a powerful feature that streamlines service discovery and communication in a dynamic environment. By mastering it, you’ll not only enhance your application’s reliability, but you’ll also simplify your Kubernetes deployment strategies. With the steps provided, you should be well-equipped to implement and troubleshoot Kubernetes DNS in your applications.

Happy Kubernetes-ing!