Docker & Kubernetes : Nginx Ingress Controller for Dashboard service on Minikube

The Dashboard of Minikube is not externally accessible (via http://mydashboard.com for example) and we get it internally.

In this post, on Minikube, we'll setup name based (hostname) Ingress rules and enable Ingress controller. With the setup, we'll be able to access the Dashboard externally. The Ingress controller takes over and then it will follow through the rules and forward requests to kubernetes-dashboard service. Also, we'll map Minikube's IP to a CNAME in our local /etc/hsots file.

Accessing minikube dashboard on Mac via ingress, please check out Setting up Ingress with NGINX Controller on Minikube (Mac): Minikube dashboard with Ingress.

Just like any other application, Ingress controllers are pods. They're part of the cluster and can see other pods and being inside the cluster themselves, we still need to expose them to the outside via a Service with a type of either NodePort or LoadBalancer.

While Ingress resources defines how we want the requests to the services to be routed via routing rules, Ingress controller processes (actually reouts) the ingress resource's information.

The controller, having the ability to inspect HTTP requests (layer 7), directs a client to the correct pod based on characteristics it finds, such as the URL path (URI) or the domain name (hostname).

In this post, we'll learn how to use Nginx Ingress Controller that comes with Minikube.

At the end, we will get our dashboard using domain name (dashboard.info) instead of using something like this: http://127.0.0.1:51617/api/v1/namespaces/kubernetes-dashboard/services...:

In addition to installing the Nginx Ingress Controller, we'll configure Ingress resources as kind: Ingress using yaml file and set an url to spec.rules.host: dashboard.info as routing rules in the file. After the configuration, because the dashboard.info is not registered domain, we map the ip of the Ingress service to dashboard.info in /etc/hosts file as an entry point.

Let's start our minikube:

To install the NGINX Ingress controller in Kubebernetes cluster on Minikube, all we have to do is enabling it:

It automatically starts Kubernetes Nginx implementation of Ingress Controller and we can see an ingress-nginx-controller pod is up and running in ingress-nginx namespace:

$ kubectl get pods -A
NAMESPACE              NAME                                         READY   STATUS             RESTARTS         AGE
ingress-nginx          ingress-nginx-admission-create-565mb         0/1     Completed          0                32m
ingress-nginx          ingress-nginx-admission-patch-q6jwb          0/1     Completed          1                32m
ingress-nginx          ingress-nginx-controller-7799c6795f-m6mvm    1/1     Running            0                32m
kube-system            coredns-5d78c9869d-zdzkq                     1/1     Running            1 (42h ago)      3d15h
kube-system            etcd-minikube                                1/1     Running            1 (42h ago)      3d15h
kube-system            kube-apiserver-minikube                      1/1     Running            1 (42h ago)      3d15h
kube-system            kube-controller-manager-minikube             1/1     Running            2 (42h ago)      3d15h
kube-system            kube-proxy-nfzdr                             1/1     Running            1                3d15h
kube-system            kube-scheduler-minikube                      1/1     Running            1 (42h ago)      3d15h
kube-system            storage-provisioner                          1/1     Running            15 (12h ago)     3d15h
kubernetes-dashboard   dashboard-metrics-scraper-5dd9cbfd69-vpcrb   1/1     Running            1 (42h ago)      3d15h
kubernetes-dashboard   kubernetes-dashboard-5c5cfc8747-xl7kf        1/1     Running            2 (42h ago)      3d15h

$ kubectl get ns
NAME                   STATUS   AGE
default                Active   3d18h
ingress-nginx          Active   166m
kube-node-lease        Active   3d18h
kube-public            Active   3d18h
kube-system            Active   3d18h
kubernetes-dashboard   Active   3d18h

The kubernetes-dashboard is for internal (we know it because the service Type is ClusterIP) and it's not externally accessible:

$ kubectl get all -n kubernetes-dashboard
NAME                                             READY   STATUS    RESTARTS      AGE
pod/dashboard-metrics-scraper-5dd9cbfd69-vpcrb   1/1     Running   3 (14m ago)   3d18h
pod/kubernetes-dashboard-5c5cfc8747-xl7kf        1/1     Running   5 (11m ago)   3d18h

NAME                                TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
service/dashboard-metrics-scraper   ClusterIP   10.106.160.151   <none>        8000/TCP   3d18h
service/kubernetes-dashboard        ClusterIP   10.100.22.24     <none>        80/TCP     3d18h

NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/dashboard-metrics-scraper   1/1     1            1           3d18h
deployment.apps/kubernetes-dashboard        1/1     1            1           3d18h

NAME                                                   DESIRED   CURRENT   READY   AGE
replicaset.apps/dashboard-metrics-scraper-5dd9cbfd69   1         1         1       3d18h
replicaset.apps/kubernetes-dashboard-5c5cfc8747        1         1         1       3d18h

Note: we may not get anything regarding the info about the kubernetes-dashboard until we run the following:

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml   
namespace/kubernetes-dashboard configured
serviceaccount/kubernetes-dashboard configured
service/kubernetes-dashboard configured
secret/kubernetes-dashboard-certs configured
secret/kubernetes-dashboard-csrf configured
secret/kubernetes-dashboard-key-holder configured
configmap/kubernetes-dashboard-settings configured
role.rbac.authorization.k8s.io/kubernetes-dashboard configured
clusterrole.rbac.authorization.k8s.io/kubernetes-dashboard configured
rolebinding.rbac.authorization.k8s.io/kubernetes-dashboard configured
deployment.apps/kubernetes-dashboard configured
service/dashboard-metrics-scraper configured
deployment.apps/dashboard-metrics-scraper configured
The ClusterRoleBinding "kubernetes-dashboard" is invalid: roleRef: Invalid value: rbac.RoleRef{APIGroup:"rbac.authorization.k8s.io", Kind:"ClusterRole", Name:"kubernetes-dashboard"}: cannot change roleRef

$ kubectl delete -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml   
namespace "kubernetes-dashboard" deleted
serviceaccount "kubernetes-dashboard" deleted
service "kubernetes-dashboard" deleted
secret "kubernetes-dashboard-certs" deleted
secret "kubernetes-dashboard-csrf" deleted
secret "kubernetes-dashboard-key-holder" deleted
configmap "kubernetes-dashboard-settings" deleted
role.rbac.authorization.k8s.io "kubernetes-dashboard" deleted
clusterrole.rbac.authorization.k8s.io "kubernetes-dashboard" deleted
rolebinding.rbac.authorization.k8s.io "kubernetes-dashboard" deleted
clusterrolebinding.rbac.authorization.k8s.io "kubernetes-dashboard" deleted
deployment.apps "kubernetes-dashboard" deleted
service "dashboard-metrics-scraper" deleted
deployment.apps "dashboard-metrics-scraper" deleted

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml   
namespace/kubernetes-dashboard created
serviceaccount/kubernetes-dashboard created
service/kubernetes-dashboard created
secret/kubernetes-dashboard-certs created
secret/kubernetes-dashboard-csrf created
secret/kubernetes-dashboard-key-holder created
configmap/kubernetes-dashboard-settings created
role.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrole.rbac.authorization.k8s.io/kubernetes-dashboard created
rolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
deployment.apps/kubernetes-dashboard created
service/dashboard-metrics-scraper created
deployment.apps/dashboard-metrics-scraper created

As we can see in the output from kubectl get all -n kubernetes-dashboard command, the pod and service for the Dashboard are already running.

So, all we have to do is setting up Ingress rules in order to access it via hostname.

Here is the dashboard-ingress.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: dashboard-ingress
  namespace: kubernetes-dashboard
spec:
  rules:
  - host: dashboard.info
    http:
      paths:
        - pathType: Prefix
          path: "/"
          backend:
            service:
              name: kubernetes-dashboard
              port:
                number: 80            

The rules basically forwarding every request for dashboard.info to internal kubernetes-dashboard service. Note that the namespace kubernetes-dashboard is within the same as the pod/kubernetes-dashboard-5c5cfc8747-xl7kf and the service/kubernetes-dashboard reside.

Create the ingress rules:

$ kubectl apply -f dashboard-ingress.yaml
ingress.networking.k8s.io/dashboard-ingress created  

$ kubectl get ingress -n kubernetes-dashboard
NAME                CLASS    HOSTS            ADDRESS        PORTS   AGE
dashboard-ingress   nginx    dashboard.info   192.168.49.2   80      27s

We need to put the information into /etc/hosts:

192.168.49.2    dashboard.info

With this configuration, when any requests are made to our Minikube cluster, the Ingress controller acts as a traffic manager. It examines the incoming requests and, based on the rules defined, determines where to forward those requests. In this specific case, if a request is made with the host 'dashboard.info' and any path, the Ingress controller will direct that request to a Kubernetes internal service named kubernetes-dashboard. This means that by accessing dashboard.info in our web browser, the Ingress controller will ensure that the request is sent to the Kubernetes Dashboard service for handling."

Now if we go to a browser and type in the domain name, dashboard.info. We can see the same page that we saw at the beginning of this post.

If none of the hosts or paths match the HTTP request in the Ingress rules, the traffic is routed to our default backend.

$ kubectl describe ingress dashboard-ingress -n kubernetes-dashboard
Name:             dashboard-ingress
Namespace:        kubernetes-dashboard
Address:          192.168.64.7
Default backend:  default-http-backend:80 (<error: endpoints "default-http-backend" not found>)
Rules:
  Host            Path  Backends
  ----            ----  --------
  dashboard.info  
                     kubernetes-dashboard:80 (172.17.0.3:9090)
Annotations:      Events:
  Type            Reason  Age   From                      Message
  ----            ------  ----  ----                      -------
  Normal          CREATE  37m   nginx-ingress-controller  Ingress kubernetes-dashboard/dashboard-ingress
  Normal          UPDATE  37m   nginx-ingress-controller  Ingress kubernetes-dashboard/dashboard-ingress

For example, "404 page not found" response when the path is not defined in any of Ingress objects:

This post addressed the simplest case and did not setup https (TLS).

For more info about the Ingress, please check out this page: https://kubernetes.io/docs/concepts/services-networking/ingress/:

1. It has the info about fanout configuration routes traffic from a single IP address to more than one Service (single host).
2. configuration routes for subdomains (multiple hosts).
3. TLS

1. Set up Ingress on Minikube with the NGINX Ingress Controller
2. Kubernetes Ingress Tutorial for Beginners | simply explained | Kubernetes Tutorial 22
3. KUBERNETES INGRESS FOR BEGINNERS

Docker & K8s

1. Docker install on Amazon Linux AMI
2. Docker install on EC2 Ubuntu 14.04
3. Docker container vs Virtual Machine
4. Docker install on Ubuntu 14.04
5. Docker Hello World Application
6. Nginx image - share/copy files, Dockerfile
7. Working with Docker images : brief introduction
8. Docker image and container via docker commands (search, pull, run, ps, restart, attach, and rm)
9. More on docker run command (docker run -it, docker run --rm, etc.)
10. Docker Networks - Bridge Driver Network
11. Docker Persistent Storage
12. File sharing between host and container (docker run -d -p -v)
13. Linking containers and volume for datastore
14. Dockerfile - Build Docker images automatically I - FROM, MAINTAINER, and build context
15. Dockerfile - Build Docker images automatically II - revisiting FROM, MAINTAINER, build context, and caching
16. Dockerfile - Build Docker images automatically III - RUN
17. Dockerfile - Build Docker images automatically IV - CMD
18. Dockerfile - Build Docker images automatically V - WORKDIR, ENV, ADD, and ENTRYPOINT
19. Docker - Apache Tomcat
20. Docker - NodeJS
21. Docker - NodeJS with hostname
22. Docker Compose - NodeJS with MongoDB
23. Docker - Prometheus and Grafana with Docker-compose
24. Docker - StatsD/Graphite/Grafana
25. Docker - Deploying a Java EE JBoss/WildFly Application on AWS Elastic Beanstalk Using Docker Containers
26. Docker : NodeJS with GCP Kubernetes Engine
27. Docker : Jenkins Multibranch Pipeline with Jenkinsfile and Github
28. Docker : Jenkins Master and Slave
29. Docker - ELK : ElasticSearch, Logstash, and Kibana
30. Docker - ELK 7.6 : Elasticsearch on Centos 7
31. Docker - ELK 7.6 : Filebeat on Centos 7
32. Docker - ELK 7.6 : Logstash on Centos 7
33. Docker - ELK 7.6 : Kibana on Centos 7
34. Docker - ELK 7.6 : Elastic Stack with Docker Compose
35. Docker - Deploy Elastic Cloud on Kubernetes (ECK) via Elasticsearch operator on minikube
36. Docker - Deploy Elastic Stack via Helm on minikube
37. Docker Compose - A gentle introduction with WordPress
38. Docker Compose - MySQL
39. MEAN Stack app on Docker containers : micro services
40. MEAN Stack app on Docker containers : micro services via docker-compose
41. Docker Compose - Hashicorp's Vault and Consul Part A (install vault, unsealing, static secrets, and policies)
42. Docker Compose - Hashicorp's Vault and Consul Part B (EaaS, dynamic secrets, leases, and revocation)
43. Docker Compose - Hashicorp's Vault and Consul Part C (Consul)
44. Docker Compose with two containers - Flask REST API service container and an Apache server container
45. Docker compose : Nginx reverse proxy with multiple containers
46. Docker & Kubernetes : Envoy - Getting started
47. Docker & Kubernetes : Envoy - Front Proxy
48. Docker & Kubernetes : Ambassador - Envoy API Gateway on Kubernetes
49. Docker Packer
50. Docker Cheat Sheet
51. Docker Q & A #1
52. Kubernetes Q & A - Part I
53. Kubernetes Q & A - Part II
54. Docker - Run a React app in a docker
55. Docker - Run a React app in a docker II (snapshot app with nginx)
56. Docker - NodeJS and MySQL app with React in a docker
57. Docker - Step by Step NodeJS and MySQL app with React - I
58. Installing LAMP via puppet on Docker
59. Docker install via Puppet
60. Nginx Docker install via Ansible
61. Apache Hadoop CDH 5.8 Install with QuickStarts Docker
62. Docker - Deploying Flask app to ECS
63. Docker Compose - Deploying WordPress to AWS
64. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI EC2 type)
65. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI Fargate type)
66. Docker - ECS Fargate
67. Docker - AWS ECS service discovery with Flask and Redis
68. Docker & Kubernetes : minikube
69. Docker & Kubernetes 2 : minikube Django with Postgres - persistent volume
70. Docker & Kubernetes 3 : minikube Django with Redis and Celery
71. Docker & Kubernetes 4 : Django with RDS via AWS Kops
72. Docker & Kubernetes : Kops on AWS
73. Docker & Kubernetes : Ingress controller on AWS with Kops
74. Docker & Kubernetes : HashiCorp's Vault and Consul on minikube
75. Docker & Kubernetes : HashiCorp's Vault and Consul - Auto-unseal using Transit Secrets Engine
76. Docker & Kubernetes : Persistent Volumes & Persistent Volumes Claims - hostPath and annotations
77. Docker & Kubernetes : Persistent Volumes - Dynamic volume provisioning
78. Docker & Kubernetes : DaemonSet
79. Docker & Kubernetes : Secrets
80. Docker & Kubernetes : kubectl command
81. Docker & Kubernetes : Assign a Kubernetes Pod to a particular node in a Kubernetes cluster
82. Docker & Kubernetes : Configure a Pod to Use a ConfigMap
83. AWS : EKS (Elastic Container Service for Kubernetes)
84. Docker & Kubernetes : Run a React app in a minikube
85. Docker & Kubernetes : Minikube install on AWS EC2
86. Docker & Kubernetes : Cassandra with a StatefulSet
87. Docker & Kubernetes : Terraform and AWS EKS
88. Docker & Kubernetes : Pods and Service definitions
89. Docker & Kubernetes : Service IP and the Service Type
90. Docker & Kubernetes : Kubernetes DNS with Pods and Services
91. Docker & Kubernetes : Headless service and discovering pods
92. Docker & Kubernetes : Scaling and Updating application
93. Docker & Kubernetes : Horizontal pod autoscaler on minikubes
94. Docker & Kubernetes : From a monolithic app to micro services on GCP Kubernetes
95. Docker & Kubernetes : Rolling updates
96. Docker & Kubernetes : Deployments to GKE (Rolling update, Canary and Blue-green deployments)
97. Docker & Kubernetes : Slack Chat Bot with NodeJS on GCP Kubernetes
98. Docker & Kubernetes : Continuous Delivery with Jenkins Multibranch Pipeline for Dev, Canary, and Production Environments on GCP Kubernetes
99. Docker & Kubernetes : NodePort vs LoadBalancer vs Ingress
100. Docker & Kubernetes : MongoDB / MongoExpress on Minikube
101. Docker & Kubernetes : Load Testing with Locust on GCP Kubernetes
102. Docker & Kubernetes : MongoDB with StatefulSets on GCP Kubernetes Engine
103. Docker & Kubernetes : Nginx Ingress Controller on Minikube
104. Docker & Kubernetes : Setting up Ingress with NGINX Controller on Minikube (Mac)
105. Docker & Kubernetes : Nginx Ingress Controller for Dashboard service on Minikube
106. Docker & Kubernetes : Nginx Ingress Controller on GCP Kubernetes
107. Docker & Kubernetes : Kubernetes Ingress with AWS ALB Ingress Controller in EKS
108. Docker & Kubernetes : Setting up a private cluster on GCP Kubernetes
109. Docker & Kubernetes : Kubernetes Namespaces (default, kube-public, kube-system) and switching namespaces (kubens)
110. Docker & Kubernetes : StatefulSets on minikube
111. Docker & Kubernetes : RBAC
112. Docker & Kubernetes Service Account, RBAC, and IAM
113. Docker & Kubernetes - Kubernetes Service Account, RBAC, IAM with EKS ALB, Part 1
114. Docker & Kubernetes : Helm Chart
115. Docker & Kubernetes : My first Helm deploy
116. Docker & Kubernetes : Readiness and Liveness Probes
117. Docker & Kubernetes : Helm chart repository with Github pages
118. Docker & Kubernetes : Deploying WordPress and MariaDB with Ingress to Minikube using Helm Chart
119. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 2 Chart
120. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 3 Chart
121. Docker & Kubernetes : Helm Chart for Node/Express and MySQL with Ingress
122. Docker & Kubernetes : Deploy Prometheus and Grafana using Helm and Prometheus Operator - Monitoring Kubernetes node resources out of the box
123. Docker & Kubernetes : Deploy Prometheus and Grafana using kube-prometheus-stack Helm Chart
124. Docker & Kubernetes : Istio (service mesh) sidecar proxy on GCP Kubernetes
125. Docker & Kubernetes : Istio on EKS
126. Docker & Kubernetes : Istio on Minikube with AWS EC2 for Bookinfo Application
127. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part I)
128. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part II - Prometheus, Grafana, pin a service, split traffic, and inject faults)
129. Docker & Kubernetes : Helm Package Manager with MySQL on GCP Kubernetes Engine
130. Docker & Kubernetes : Deploying Memcached on Kubernetes Engine
131. Docker & Kubernetes : EKS Control Plane (API server) Metrics with Prometheus
132. Docker & Kubernetes : Spinnaker on EKS with Halyard
133. Docker & Kubernetes : Continuous Delivery Pipelines with Spinnaker and Kubernetes Engine
134. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-dind (docker-in-docker)
135. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-kind (k8s-in-docker)
136. Docker & Kubernetes : nodeSelector, nodeAffinity, taints/tolerations, pod affinity and anti-affinity - Assigning Pods to Nodes
137. Docker & Kubernetes : Jenkins-X on EKS
138. Docker & Kubernetes : ArgoCD App of Apps with Heml on Kubernetes
139. Docker & Kubernetes : ArgoCD on Kubernetes cluster
140. Docker & Kubernetes : GitOps with ArgoCD for Continuous Delivery to Kubernetes clusters (minikube) - guestbook