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?
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
If the Service IP changes, the application configuration must change.
With DNS:
backend-service
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 running inside the Kubernetes cluster.
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
Typical output:
coredns-xxxxx
coredns-yyyyy
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:
backend-service
CoreDNS resolves it to:
10.96.15.21
The application never needs to know the actual IP address.
Kubernetes DNS Naming
Every Service receives a fully qualified domain name (FQDN):
service-name.namespace.svc.cluster.local
Example:
backend-service.default.svc.cluster.local
Most applications use the shorter name:
backend-service
Kubernetes automatically appends the remaining DNS suffix.
DNS Lookup Flow
Application Pod
↓
DNS Query
↓
CoreDNS
↓
Service ClusterIP
↓
kube-proxy
↓
Backend Pod
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
Headless Service
If the Service uses:
clusterIP: None
CoreDNS returns individual Pod IPs:
database-0
database-1
database-2
This is commonly used by StatefulSets.
Common DNS Problems and Solutions
1. Service name not resolving?
Verify the Service exists:
kubectl get svc
2. Test DNS from a Pod
kubectl exec -it <pod> -- nslookup backend-service
3. Check CoreDNS Pods
kubectl get pods -n kube-system
4. View CoreDNS Logs
kubectl logs -n kube-system deployment/coredns
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.
