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.