Cross-namespace communication in Kubernetes - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does Kubernetes enable communication between services in different namespaces?

In Kubernetes, services are usually isolated within namespaces. Which method allows a pod in one namespace to reach a service in another namespace?

A Services in different namespaces cannot communicate directly; you must merge namespaces.

B Use the full DNS name of the service including the target namespace, like <code>service-name.namespace.svc.cluster.local</code>.

C Use the service name alone without namespace; Kubernetes automatically resolves cross-namespace services.

D Create a NodePort service and access it via the node IP and port.

💡 Hint

Think about how Kubernetes DNS resolves service names across namespaces.

Kubernetes DNS allows cross-namespace communication by using the full DNS name including the namespace. This is service-name.namespace.svc.cluster.local. Using only the service name works only within the same namespace.

💻 Command Output

intermediate

What is the output of this command querying a service in another namespace?

You run the following command inside a pod in namespace dev to check connectivity to a service api in namespace prod:

nslookup api.prod.svc.cluster.local

What output do you expect?

A A DNS response with the IP address of the <code>api</code> service in <code>prod</code> namespace.

B An error saying <code>api.prod.svc.cluster.local</code> not found.

C A DNS response with the IP address of a service named <code>api</code> in the <code>dev</code> namespace.

D A timeout error because cross-namespace DNS queries are blocked.

💡 Hint

Remember how Kubernetes DNS resolves fully qualified service names.

The command queries the fully qualified domain name of the service api in the prod namespace. Kubernetes DNS resolves this correctly and returns the service IP.

❓ Configuration

advanced

Which NetworkPolicy allows pods in namespace 'frontend' to access pods in namespace 'backend' on port 8080?

You want to restrict network access so only pods in the frontend namespace can connect to pods in the backend namespace on TCP port 8080. Which NetworkPolicy YAML snippet correctly implements this?

A

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: backend
spec:
  podSelector: {}
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 8080

B

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: frontend
spec:
  podSelector: {}
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 8080

C

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: backend
spec:
  podSelector: {}
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend
    ports:
    - protocol: TCP
      port: 8080

D

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: backend
spec:
  podSelector: {}
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

💡 Hint

NetworkPolicies are defined in the target namespace and use namespaceSelector to allow traffic from other namespaces.

The NetworkPolicy must be created in the backend namespace to control ingress to backend pods. It allows ingress from pods in namespaces labeled name: frontend on TCP port 8080.

❓ Troubleshoot

advanced

Why does a pod in namespace 'test' fail to reach a service in namespace 'prod' using only the service name?

A pod in the test namespace tries to connect to a service named db in the prod namespace by using the hostname db. The connection fails. What is the most likely reason?

A The pod's network policy explicitly denies all outbound traffic.

B The service <code>db</code> in <code>prod</code> namespace is not running any pods.

C Kubernetes blocks all cross-namespace service communication by default.

D The pod is using the short service name <code>db</code> which resolves only within its own namespace, so it cannot find the service in <code>prod</code> namespace.

💡 Hint

Think about how DNS resolves service names inside pods.

Using only the service name db resolves to a service in the pod's own namespace (test). To reach a service in another namespace, the full DNS name including namespace must be used.

✅ Best Practice

expert

What is the recommended way to securely enable cross-namespace communication between microservices?

You manage multiple microservices deployed in different namespaces. You want to enable secure, controlled communication between them. Which approach is best practice?

A Use Kubernetes NetworkPolicies to restrict traffic and service accounts with RBAC for authentication, combined with mutual TLS via a service mesh like Istio.

B Open all namespaces to unrestricted communication by disabling NetworkPolicies and use plain HTTP between services.

C Manually configure firewall rules on each node to allow traffic between namespaces and use basic authentication in services.

D Deploy all microservices in the same namespace to avoid cross-namespace communication issues.

💡 Hint

Consider security, scalability, and maintainability in multi-namespace environments.

Combining NetworkPolicies for network-level restrictions, RBAC for access control, and mutual TLS via a service mesh provides a robust, secure, and manageable way to enable cross-namespace communication.