DEV Community

Sreekanth Kuruba
Sreekanth Kuruba

Posted on • Edited on

How CoreDNS Powers Service Discovery in Kubernetes

#kubernetes #devops #cloudnative #networking

CoreDNS is the DNS server that powers service discovery in Kubernetes. This post explains how Pods translate Service names into IP addresses, explores common DNS records, and provides practical troubleshooting commands for debugging connectivity issues.

In the previous post, we learned how Kubernetes Services provide stable virtual IPs for Pods.

But another question remains:

How do applications find those Services?

Before kube-proxy can forward traffic to a Service, Kubernetes first needs to translate the Service name into its ClusterIP. That's exactly what CoreDNS does.

Applications rarely communicate using IP addresses. Instead, they use names such as:

  • backend-service
  • mysql-service
  • redis-service

So how does a Pod translate those names into IP addresses?

That's where CoreDNS comes in.

Why Do We Need DNS in Kubernetes?

Imagine a frontend application connecting to a backend Service.

Without DNS:

Backend IP = 10.96.15.21
Enter fullscreen mode Exit fullscreen mode

If the Service IP changes, the application configuration must change.

With DNS:

backend-service
Enter fullscreen mode Exit fullscreen mode

CoreDNS automatically resolves the name to the correct Service IP.

This allows applications to communicate without knowing actual IP addresses.

What Is CoreDNS?

CoreDNS is the DNS server for Kubernetes clusters.

It watches Kubernetes resources and automatically creates DNS records for:

  • Services
  • Pods (optional)
  • Namespaces

Applications can then use Service names instead of IP addresses.

Where Does CoreDNS Run?

CoreDNS runs as Pods inside the kube-system namespace.

Verify this with:

kubectl get pods -n kube-system
Enter fullscreen mode Exit fullscreen mode

Typical output:

coredns-xxxxx
coredns-yyyyy
Enter fullscreen mode Exit fullscreen mode

Multiple replicas provide high availability.

How Service Discovery Works

Suppose we have:

  • Service Name: backend-service
  • Namespace: default
  • ClusterIP: 10.96.15.21

A Pod sends a request to:

backend-service
Enter fullscreen mode Exit fullscreen mode

CoreDNS resolves it to:

10.96.15.21
Enter fullscreen mode Exit fullscreen mode

The application never needs to know the actual IP address.

Kubernetes DNS Naming

DNS Name Used When
backend-service Same namespace
backend-service.default Specify the namespace
backend-service.default.svc Include the Service domain
backend-service.default.svc.cluster.local Fully Qualified Domain Name (FQDN)

Most applications simply use backend-service because Kubernetes automatically appends the remaining DNS suffix.

Why Does backend-service Work Without Typing the Full DNS Name?

Every Pod receives a DNS configuration file:

cat /etc/resolv.conf
Enter fullscreen mode Exit fullscreen mode

It contains the CoreDNS nameserver and search domains, allowing short Service names like backend-service to resolve automatically without typing the full FQDN.

DNS Lookup Flow

Application Pod
        ↓
DNS Query
        ↓
CoreDNS
        ↓
Service ClusterIP
        ↓
kube-proxy
        ↓
Backend Pod
Enter fullscreen mode Exit fullscreen mode

The entire process usually takes only a few milliseconds.

Important DNS Records

ClusterIP Service

CoreDNS returns the Service IP:

backend-service → 10.96.15.21
Enter fullscreen mode Exit fullscreen mode

Headless Service

If the Service uses:

clusterIP: None
Enter fullscreen mode Exit fullscreen mode

CoreDNS returns the individual Pod IPs:

database-0
database-1
database-2
Enter fullscreen mode Exit fullscreen mode

This is commonly used by StatefulSets.

Common DNS Problems and Solutions

1. Service name not resolving?

Verify the Service exists:

kubectl get svc
Enter fullscreen mode Exit fullscreen mode

2. Test DNS from a Pod

kubectl exec -it <pod> -- nslookup backend-service
Enter fullscreen mode Exit fullscreen mode

3. Check CoreDNS Pods

kubectl get pods -n kube-system
Enter fullscreen mode Exit fullscreen mode

4. View CoreDNS Logs

kubectl logs -n kube-system deployment/coredns
Enter fullscreen mode Exit fullscreen mode

Why CoreDNS Matters

Without CoreDNS:

  • Applications would need hardcoded IP addresses.
  • Configuration changes would happen frequently.
  • Service discovery would become difficult.
  • Microservices communication would break easily.

CoreDNS makes Kubernetes applications independent of changing IP addresses.

Summary

Pods communicate using names, not IP addresses.

CoreDNS acts as the phonebook of Kubernetes, translating Service names into IP addresses.

Understanding CoreDNS helps you:

  • Debug Service discovery problems.
  • Troubleshoot application connectivity.
  • Understand Kubernetes networking better.
  • Build resilient microservices.

Next in the Series:
Ingress Explained – How External Traffic Enters Your Kubernetes Cluster.

Top comments (0)