Deploying Containers with Kubernetes

✅ Chapter 3: Services, Networking, and Ingress Controllers

🔍 Introduction

In Kubernetes, Deployments manage application Pods — but how do you make these Pods communicate internally and expose your services externally?

That’s where Services, Networking, and Ingress Controllers come in.

This chapter will guide you through:

• Internal and external networking
• Different types of Kubernetes Services
• Service discovery
• Configuring Ingress Controllers
• Practical examples for exposing and routing traffic

🌐 Kubernetes Networking Model Overview

Kubernetes defines a simple but powerful networking model:

• Every Pod gets its own IP address.
• Every Pod can communicate with any other Pod (flat network space).
• Services provide stable IPs and DNS names to access dynamic Pods.

Key expectations:

🧱 Kubernetes Services: Core Concept

A Service in Kubernetes is an abstraction that defines a logical set of Pods and a policy by which to access them — typically via a stable IP address and DNS name.

When Pods die and recreate (which happens often), a Service ensures your applications stay accessible.

🧩 Main Types of Services

🔹 ClusterIP Service

• Default service type
• Accessible only within the cluster

yaml

apiVersion: v1

kind: Service

metadata:

  name: my-service

spec:

  selector:

    app: my-app

  ports:

    - protocol: TCP

      port: 80

      targetPort: 8080

  type: ClusterIP

• Access from another Pod using http://my-service:80

🔹 NodePort Service

• Makes your service accessible outside the cluster via <NodeIP>:<NodePort>.
• NodePort is typically between 30000–32767.

yaml

apiVersion: v1

kind: Service

metadata:

  name: my-nodeport-service

spec:

  type: NodePort

  selector:

    app: my-app

  ports:

    - port: 80

      targetPort: 8080

      nodePort: 30036

Access with:

text

http://<NodeIP>:30036

🔹 LoadBalancer Service

• Works with cloud providers (GKE, EKS, AKS).
• Allocates an external IP.

yaml

apiVersion: v1

kind: Service

metadata:

  name: my-loadbalancer

spec:

  selector:

    app: my-app

  ports:

    - port: 80

      targetPort: 8080

  type: LoadBalancer

Automatically provisions a cloud load balancer.

🔹 ExternalName Service

• Maps a Kubernetes Service to an external DNS name.

yaml

apiVersion: v1

kind: Service

metadata:

  name: external-service

spec:

  type: ExternalName

  externalName: example.com

Use case: access external database or APIs via internal cluster names.

🔄 How Services Find Pods: Label Selectors

Services bind to Pods using label selectors.

Example:

yaml

selector:

  app: my-app

If your Pods have the label app=my-app, the Service routes traffic to those Pods automatically.

🧪 Example: Create Deployment + Service Together

yaml

apiVersion: apps/v1

kind: Deployment

metadata:

  name: hello-world

spec:

  replicas: 2

  selector:

    matchLabels:

      app: hello

  template:

    metadata:

      labels:

        app: hello

    spec:

      containers:

      - name: hello

        image: nginx

        ports:

        - containerPort: 80

---

apiVersion: v1

kind: Service

metadata:

  name: hello-service

spec:

  selector:

    app: hello

  ports:

  - port: 80

    targetPort: 80

  type: NodePort

Apply:

bash

kubectl apply -f hello-world.yaml

🛡️ Kubernetes DNS-Based Service Discovery

Kubernetes automatically creates a DNS record for every Service.

Example:

• Service: hello-service
• Namespace: default
• DNS: hello-service.default.svc.cluster.local

Pods can simply refer to Services by name.

🌍 Ingress: Smarter External Access to Services

Ingress is an API object that manages external access to your Services, typically over HTTP.

Instead of exposing each service individually via NodePort or LoadBalancer, you define a single entry point using Ingress.

📋 Ingress Components

🛠️ Simple Ingress Example

Ingress Resource YAML:

yaml

apiVersion: networking.k8s.io/v1

kind: Ingress

metadata:

  name: my-ingress

  annotations:

    nginx.ingress.kubernetes.io/rewrite-target: /

spec:

  rules:

  - host: myapp.example.com

    http:

      paths:

      - path: /

        pathType: Prefix

        backend:

          service:

            name: hello-service

            port:

              number: 80

📋 How Ingress Works

⚙️ Setting Up NGINX Ingress Controller (Minikube Example)

1. Enable ingress addon:

bash

minikube addons enable ingress

2. Deploy your app and ingress resource.
3. Map hostnames via /etc/hosts:

text

<minikube_ip> myapp.example.com

📦 Comparing Service vs Ingress

🔒 Secure Your Ingress

• Use TLS Certificates (via cert-manager or manual)
• Redirect HTTP to HTTPS
• Use authentication and rate limiting (supported by NGINX annotations)

📚 Common Use Cases

🚀 Summary: What You Learned in Chapter 3

• Kubernetes Services enable access to Pods
• Different Service types (ClusterIP, NodePort, LoadBalancer) cover various use cases
• Ingress provides smart external routing and centralized management
• NGINX is a popular Ingress Controller for Kubernetes
• Combining Services and Ingress gives maximum flexibility and scalability