Mastering Kubernetes Ingress: A Step-by-Step Guide#

Kubernetes Ingress is a powerful resource that manages external access to services within a cluster. In this guide, we’ll walk through the process of deploying a simple application, creating a service for it, and exposing it to the external world using Ingress. Let’s dive in!

Prerequisites#

Before we begin, ensure you have:

A running Kubernetes cluster
kubectl configured to communicate with your cluster
Docker installed on your local machine
An Ingress Controller installed in your cluster (e.g., NGINX Ingress Controller)

Step 1: Building and Pushing the Docker Image#

First, let’s build our application image:

1
docker build -t hello-world .

Tag and push the image to Docker Hub:

1
docker tag hello-world <dockerhub-username>/hello-world
2
docker push <dockerhub-username>/hello-world

Replace <dockerhub-username> with your Docker Hub username.

Step 2: Creating the Deployment#

Create a file named deployment.yaml:

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: web
5
spec:
6
  replicas: 1
7
  selector:
8
    matchLabels:
9
      app: web
10
  template:
11
    metadata:
12
      labels:
13
        app: web
14
    spec:
15
      containers:
16
        - name: web
17
          image: <dockerhub-username>/hello-world:latest
18
          ports:
19
            - containerPort: 3000

Apply the deployment:

1
kubectl apply -f deployment.yaml

Step 3: Creating the Service#

Create a file named service.yaml:

1
apiVersion: v1
2
kind: Service
3
metadata:
4
  name: web
5
spec:
6
  selector:
7
    app: web
8
  ports:
9
    - protocol: TCP
10
      port: 80
11
      targetPort: 3000

Apply the service:

1
kubectl apply -f service.yaml

Step 4: Creating the Ingress#

Create a file named ingress.yaml:

1
apiVersion: networking.k8s.io/v1
2
kind: Ingress
3
metadata:
4
  name: hello-world-ingress
5
  annotations:
6
    nginx.ingress.kubernetes.io/rewrite-target: /$1
7
spec:
8
  rules:
9
    - host: hello-world.exposed
10
      http:
11
        paths:
12
          - path: /
13
            pathType: Prefix
14
            backend:
15
              service:
16
                name: web
17
                port:
18
                  number: 80

Apply the Ingress:

1
kubectl apply -f ingress.yaml

Step 5: Verifying the Setup#

List the Ingress object:
Terminal window
```
1
kubectl get ingress
```
Add an entry to your /etc/hosts file:
```
1
<ingress-controller-ip> hello-world.exposed
```
Replace <ingress-controller-ip> with the external IP of your Ingress controller.
Test the application:
Terminal window
```
1
curl http://hello-world.exposed
```
You should see the “Hello World” message.

Key Takeaways#

Ingress Controller: Ensure an Ingress Controller is running in your cluster. It’s crucial for Ingress rules to take effect.
Host-based Routing: Ingress allows you to route traffic based on hostnames, enabling multiple services to share a single IP address.
Path-based Routing: You can route to different services based on URL paths, allowing for flexible application architectures.
Annotations: Ingress annotations provide a way to customize the behavior of your Ingress controller.
SSL/TLS: While not covered in this basic example, Ingress can be configured to manage SSL/TLS termination for secure communication.

Conclusion#

Kubernetes Ingress provides a powerful way to expose your services to the outside world. By following this guide, you’ve learned how to deploy an application, create a service, and expose it using Ingress. As you continue your Kubernetes journey, explore more advanced Ingress features like SSL/TLS termination, authentication, and rate limiting to build robust, production-ready applications.

Remember, Ingress is just one piece of the Kubernetes networking puzzle. Combine it with other resources like Services, NetworkPolicies, and external load balancers to create comprehensive networking solutions for your applications.