Deploying NGINX as an Ingress Controller in Kubernetes: A Comprehensive Step-by-Step Guide with Architectural Diagram

   Ensure you have Docker installed as the driver.

3. Verify the Cluster:


   kubectl cluster-info


   You should see output indicating that the Kubernetes master and services are running.

 Step 2: Install NGINX Ingress Controller

There are multiple ways to install the NGINX Ingress Controller in Kubernetes. Using Helm is the most straightforward method.

Using Helm to Install NGINX Ingress Controller

1. Add the NGINX Ingress Helm Repository:

   helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

   helm repo update

2. Create a Namespace for Ingress:

   kubectl create namespace ingress-nginx

3. Install the Ingress Controller:

   helm install nginx-ingress ingress-nginx/ingress-nginx \
     --namespace ingress-nginx \
     --set controller.publishService.enabled=true

 The `controller.publishService.enabled=true` flag ensures that the external IP is published correctly.*

4. Verify the Installation:

   kubectl get pods -n ingress-nginx

   You should see pods with names starting with `nginx-ingress-controller` in the `Running` state.

5.Retrieve the External IP:

   kubectl get svc -n ingress-nginx

   Look for the `EXTERNAL-IP` of the `nginx-ingress-controller`. For Minikube, you might need to use `minikube service` to access the service.

   minikube service nginx-ingress-ingress-nginx-controller -n ingress-nginx

   This command will open the service in your default web browser.

Alternative: Manual Deployment

If you prefer not to use Helm, you can deploy the NGINX Ingress Controller using Kubernetes manifests.

1. Apply the Mandatory YAML:

   kubectl apply -f 
https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml


2. Verify the Deployment:

   kubectl get pods -n ingress-nginx

 Step 3: Configure DNS

To route traffic to your Ingress Controller, you'll need to configure DNS records pointing your domain or subdomain to the Ingress Controller's external IP.

For Minikube Users

Minikube doesn't provide a real external IP. Instead, you can modify your `/etc/hosts` file to map a domain to Minikube's IP.

1. Get Minikube IP

   minikube ip

   Suppose the IP is `192.168.99.100`.

2. Edit `/etc/hosts`:

   Add the following line:

   192.168.99.100   example.com

   Replace `example.com` with your desired domain.

For Cloud Providers (GKE, EKS, AKS)

1. Obtain the External IP:


   kubectl get svc -n ingress-nginx

   Locate the `EXTERNAL-IP` of the `nginx-ingress-controller` service.

2. Update DNS Records:

   - Log in to your DNS provider's management console.
   - Create an `A` record for your domain pointing to the Ingress Controller's external IP.

   *Example:*

   | Type | Name    | Value         |
   |------|---------|---------------|
   | A    | @       | 203.0.113.10  |
   | A    | www     | 203.0.113.10  |


Step 4: Deploy a Sample Application

To demonstrate the Ingress Controller, deploy a simple web application. We'll use NGINX as the backend service.

 Create a Deployment and Service

1. Create a YAML file named `app-deployment.yaml`:

      yaml
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: demo-app
     labels:
       app: demo
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: demo
     template:
       metadata:
         labels:
           app: demo
       spec:
         containers:
         - name: demo-container
           image: nginx:latest
           ports:
           - containerPort: 80
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: demo-service
   spec:
     type: ClusterIP
     selector:
       app: demo
     ports:
       - port: 80
         targetPort: 80

2. Apply the Deployment

   kubectl apply -f app-deployment.yaml

3. Verify the Deployment:

   kubectl get deployments
   kubectl get pods
   kubectl get svc

   Ensure that the `demo-app` deployment is running with 2 replicas and that the `demo-service` is available.

Step 5: Create Ingress Resources

Now, configure the Ingress resource to route traffic from the Ingress Controller to your backend service based on the request's host and path.

Create an Ingress YAML File

1. Create a file named `demo-ingress.yaml`

     yaml
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: demo-ingress
     annotations:
       nginx.ingress.kubernetes.io/rewrite-target: /
   spec:
     ingressClassName: nginx
     rules:
     - host: example.com
       http:
         paths:
         - path: /
           pathType: Prefix
           backend:
             service:
               name: demo-service
               port:
                 number: 80

   Replace `example.com` with your domain name.

2. Apply the Ingress Resource:

   kubectl apply -f demo-ingress.yaml

3. Verify the Ingress:

   kubectl get ingress

   You should see the `demo-ingress` with an address corresponding to the Ingress Controller's external IP.

Step 6: Verify the Setup

Ensure that the Ingress Controller is correctly routing traffic to your application.

Access the Application

1. Open a Web Browser:

   Navigate to `http://example.com` (replace with your domain).

2. Expected Result:

   You should see the default NGINX welcome page served by the `demo-service`.

  Troubleshooting Tips

DNS Propagation: It might take some time for DNS changes to propagate. Use tools like [dig](https://www.tecmint.com/useful-dig-command-examples/) or [nslookup](https://www.nslookup.io/) to verify DNS records.

  dig example.com