Devops Shack 1729938369

DevOps Shack
DevOps Shack
Networking in DevOps: Service Discovery, Load
Balancing, and Routing
Introduction
In DevOps, networking plays a crucial role in ensuring efficient communication
between various components of the application, especially in microservices and
containerized environments. Kubernetes offers networking solutions that handle
1
DevOps Shack
service discovery, load balancing, and traffic routing, making it easier to manage
distributed applications in production.
In this document, we have already demonstrated how to create a CI/CD pipeline,
so we won’t go into the specifics of the implementation here. However, to
provide an overview, a CI/CD pipeline automates the processes of integrating
code changes, testing them, and deploying the application to production
environments. Continuous Integration (CI) ensures that code changes from
multiple developers are merged into a central repository frequently, with
automated tests verifying that these changes do not introduce new bugs.
Continuous Deployment (CD) extends this by automatically deploying the
validated code to production, allowing for faster delivery of features and bug
fixes. This streamlined approach reduces manual intervention, minimizes the risk
of human error, and allows development teams to focus on writing code while
maintaining high software quality. The result is a more efficient development
process that enhances collaboration, accelerates delivery, and improves overall
project agility.
Step-by-Step Breakdown of the Workflow:

1. User Requests (Clients)
The application will be accessed by users (clients) via a browser or API calls. Users
enter a URL or access the application via an IP address. The first step is to ensure
that the request reaches the application reliably.
2. Load Balancer
A Load Balancer (e.g., AWS Load Balancer or an on-premise one like NGINX) will
handle traffic distribution. It ensures:
• High availability: Traffic is balanced across multiple instances of the
application.
• Redundancy: If one instance goes down, traffic is redirected to healthy
instances.
2
DevOps Shack
• Efficient load distribution: It prevents one server from being overwhelmed

while others are idle.
The Load Balancer forwards user requests to the Ingress Controller in the
Kubernetes cluster.
3. Ingress Controller
The Ingress Controller (NGINX, Traefik, etc.) routes incoming traffic to the correct
services inside the Kubernetes cluster. It defines rules for traffic routing, such as:
• Path-based routing: /api/* might route to the backend service, while
/frontend/* routes to the frontend service.
• Domain-based routing: Requests to app.example.com go to the main app,
and admin.example.com routes to an admin service.
The Ingress Controller ensures external access to the cluster while securing and
managing traffic efficiently.
4. Kubernetes Service
A Kubernetes Service exposes a set of Pods (containerized application instances)
to the network. It acts as an abstraction over the application’s pods and ensures:
• Internal Communication: Other services within the cluster can
communicate with the application through the service.
• External Access: It allows external requests (via the Ingress Controller) to
reach the appropriate pods.
This service makes it possible to scale up or down the number of pods without
affecting how traffic is routed to them.
5. Application Pods
The actual web application runs in Pods, which are the smallest deployable units
in Kubernetes. Each pod contains one or more containers (in this case, the web
app and maybe a database or other service). Kubernetes manages these pods,
including:
3
DevOps Shack
• Scaling: If traffic increases, Kubernetes can scale the application by creating

more pods.
• Self-healing: If a pod fails, Kubernetes will automatically restart or replace
it.
6. Service Discovery (CoreDNS)
Service Discovery ensures that the application pods are dynamically discoverable.
In Kubernetes, CoreDNS is the service that provides DNS within the cluster:
• It resolves service names to the IP addresses of the pods.
• It keeps track of which pods are healthy and available to handle traffic.
• This ensures that traffic is always routed to the right pod, even when pods
are added or removed during scaling.
7. Monitoring & Logging
Prometheus and Grafana are tools used to monitor the system in real-time:
• Prometheus: Collects metrics like CPU, memory, and network usage for
pods, services, and the Ingress Controller.
• Grafana: Provides dashboards and visualizations for these metrics.
• Logging: Logs (from the application and services) are gathered to track
events, errors, and performance bottlenecks.
This allows the DevOps team to:
• Ensure the application is performing well.
• Diagnose and fix any issues quickly.
• Get alerts when something goes wrong (e.g., a pod crashing or high latency
in service).
1. Load Balancing
4
DevOps Shack
Load balancing ensures that incoming traffic is evenly distributed across the
available instances of an application, improving fault tolerance and scalability. In
Kubernetes, Services abstract the underlying pods, allowing the Load Balancer to
route traffic dynamically to healthy pods.
Example: Deploying a Load Balancer in Kubernetes
apiVersion: v1
kind: Service
metadata:
name: my-loadbalancer
namespace: default
spec:
type: LoadBalancer
selector:
app: webapp
ports:
- protocol: TCP
port: 80 # External port
targetPort: 8080 # Internal container port
• Explanation: This configuration creates a Kubernetes service of type
LoadBalancer, which directs external traffic to port 80 and routes it to the
web application's pods running on port 8080 inside the cluster. In cloud
environments like AWS or GCP, this will provision an external load balancer.
2. Ingress Controller
5
DevOps Shack
An Ingress Controller is used to manage external access to the services inside a

Kubernetes cluster. It allows traffic routing based on hostnames and paths while
providing SSL termination for secure access.
Example: Setting up an Ingress Controller with NGINX
1. Install NGINX Ingress Controller
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-
nginx/main/deploy/static/provider/cloud/deploy.yaml
2. Create an Ingress Resource
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
rules:
- host: example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: webapp-service
port:
6
DevOps Shack
number: 80
• Explanation:
o The Ingress resource defines rules for routing traffic.
o Requests to example.com will be routed to the webapp-service on
port 80.
o The Ingress Controller (NGINX in this case) handles the traffic and
forwards it based on these rules.
3. Service Discovery (CoreDNS)

Service Discovery in Kubernetes is achieved via CoreDNS, which maintains an
updated list of all services in the cluster and resolves their DNS. This allows
services to communicate with each other without knowing the exact IP addresses
of the pods.
Example: CoreDNS Configuration
CoreDNS is usually pre-installed in most Kubernetes clusters. To customize DNS
behavior, you can modify the CoreDNS ConfigMap.
apiVersion: v1
kind: ConfigMap
metadata:
name: coredns
namespace: kube-system
data:
Corefile: |
.:53 {
errors
health
7
DevOps Shack
kubernetes cluster.local in-addr.arpa ip6.arpa {

pods insecure
fallthrough in-addr.arpa ip6.arpa
}
prometheus :9153
forward . /etc/resolv.conf
cache 30
loop
reload
loadbalance
}
• Explanation:
o This configuration specifies how CoreDNS resolves the internal
Kubernetes services and pods.
o It listens on port 53 and forwards DNS queries to the appropriate
service IPs in the cluster.local domain.
Testing Service Discovery
You can check if service discovery is working properly by running the following
inside a pod:
kubectl exec -it <pod-name> -- nslookup webapp-service
This will resolve the DNS name webapp-service to its corresponding pod IPs.
4. Monitoring and Logging (Prometheus & Grafana)
8
DevOps Shack
Monitoring and logging of network traffic are essential for diagnosing bottlenecks
and ensuring the application is running smoothly. Prometheus and Grafana are
popular tools for collecting metrics and visualizing them.
Example: Setting up Prometheus and Grafana for Network Monitoring
1. Install Prometheus
kubectl apply -f https://github.com/prometheus-operator/prometheus-
operator/blob/main/bundle.yaml
2. Prometheus Configuration
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
name: prometheus-service-monitor
labels:
release: prometheus
spec:
selector:
matchLabels:
app: webapp
endpoints:
- port: http
interval: 30s
3. Install Grafana
kubectl apply -f
https://raw.githubusercontent.com/grafana/grafana/master/deploy/kubernetes/
grafana.yaml
4. Accessing Metrics in Grafana
9
DevOps Shack
o Add Prometheus as a data source in Grafana.

o Create a dashboard to visualize network traffic metrics like:
▪ Incoming/Outgoing requests.
▪ Latency between services.
▪ Network errors.
Conclusion
In this document, we explored the networking components essential for a
modern DevOps workflow, focusing on Load Balancing, Ingress Controllers,
Service Discovery, and Monitoring. These components ensure that traffic is
managed effectively and services are discoverable within the cluster.
The combination of these tools and concepts provides a robust and scalable
environment, capable of handling microservice architectures, managing traffic,
and providing valuable insights through monitoring.
By applying these configurations and practices, DevOps teams can ensure high
availability, reliability, and smooth network traffic flow for their containerized
applications in Kubernetes.
10

Devops Shack 1729938369

Uploaded by

Copyright:

Available Formats

Devops Shack 1729938369

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Devops Shack 1729938369

Uploaded by

Copyright:

Available Formats

DevOps Shack

Step-by-Step Breakdown of the Workflow:

• Efficient load distribution: It prevents one server from being overwhelmed

• Scaling: If traffic increases, Kubernetes can scale the application by creating

An Ingress Controller is used to manage external access to the services inside a

3. Service Discovery (CoreDNS)

kubernetes cluster.local in-addr.arpa ip6.arpa {

4. Monitoring and Logging (Prometheus & Grafana)

o Add Prometheus as a data source in Grafana.

You might also like