## Chapter 7 : Networking & Service Access

### 7.1 Service

Service adalah resource di Kubernetes yang digunakan untuk membuat satu gerbang untuk mengakses satu atau lebih Pod. Service memiliki IP address dan Port yang tidak pernah berubah selama service itu ada.

Gambarannya, client bisa mengakses service tersebut, dan secara otomatis akan meneruskan ke Pod yang ada dibelakang service tersebut. Dengan begini Client tidak perlu tahu lokasi tiap Pod, dan Pod bisa bertambah, berkurang, atau berpindah, tanpa harus mengganggu Client.

Begini gambaran tanpa adanya services di Cluster :


Misal pada gamabr anda ingin mengakses Pod A, kita yang sevagai client tak tahu, Pod A itu berlokasi dimana dan sedangkan apakah sekelas klien harus tahu posisi Pod A berada dimana? Tentu tidak. Maka dari itu ada namanya services.
Dan untuk adanya services di Cluster gambarannnya sepert ini :


Services akan membantu pengguna agar tak harus menghafalkan lokasi Pod berada atau semacamnya, yang terpenting layanan terus terkoneksi di Cluster tersebut.

Karakterisitik dari Service yang perlu diketahui adalah :
- Service akan mendistribusikan trafik ke Pod yang ada di belakangnya secara seimbang,
- Service akan menggunakan label selector untuk mengetahui Pod mana yang ada dibelakang service tersebut.

Untuk membuat Service bisa menggunakan kode konfigurasi template kurang lebih seperti ini :
7.1.1-template-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: service-name
spec:
  selector:
    label-key1: label-value1
  ports:
  - port: 8080
    targetPort: 80

Contoh, bisa seperti di bawah ini :
7.1.2-nginx-service.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      name: nginx
  template:
    metadata:
      name: nginx
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    name: nginx
  ports:
    - port: 8080
      targetPort: 80

---

apiVersion: v1
kind: Pod
metadata:
  name: curl
  labels:
    name: curl
spec:
  containers:
    - name: curl
      image: khannedy/nginx-curl

Untuk perintah dalam Service kurang lebih seperti ini :
- Membuat Service

  $ kubectl create -f (filename.yaml)

- Melihat Service

  $ kubectl get services

- Menghapus Service

  $ kubectl delete service (servicename)

- Mengakses Service dari Dalam Cluster

  $ kubectl exec (podname)-it -- /bin/sh

  $ curl http://cluster-ip:port/

$ kubectl create -f 7.1.2-nginx-service.yaml
replicaset.apps/nginx created
service/nginx-service created
pod/curl created
$ kubectl get all
NAME              READY   STATUS    RESTARTS   AGE
pod/curl          1/1     Running   0          52s
pod/nginx-sqldr   1/1     Running   0          52s
pod/nginx-vlk5v   1/1     Running   0          52s
pod/nginx-w58b4   1/1     Running   0          52s

NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
service/kubernetes      ClusterIP   10.96.0.1        <none>        443/TCP    5d
service/nginx-service   ClusterIP   10.110.104.126   <none>        8080/TCP   52s

NAME                    DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx   3         3         3       52s

Jika dilihat layanan yang dibuat, bahwa terdapat service yang bertambah yaitu `service/nginx-service` dengan IP akses 10.110.104.126 dan port 8080.

> *Jika anda berpikir, kita bisa akses langusng dengan IP 10.110.104.126, maka kurang tepat, karena IP tersebut IP dalam Cluster Kubernetes*

Jika tersadar, pada konfigurasi Pod terakhir atau yang berisi curl, itu merupakan Pod yang digunakan untuk mengakses Pod nginx (Pod pertama) melalui service yang dibuat. Nanti, akan masuk ke Pod yang ke 3 (curl) tersebut untuk akses nginx.

Kita akan coba akses , melalui Pod ketiga dengan melewati service yang dibuat :

$ kubectl exec -it curl -- /bin/sh
/ #

Dan saat ini kita sudah berada di bash command Pod curl. Sekrang kita coba akses kontennya :

/ # curl http://10.110.104.126:8080
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>
/ #

Seperti itu untuk penggunaan Service, kurang lebih bisa di gambarkan seperti ini :


Oke, sekarnag kita akan bahas lebih dalam terkait Mengakses Service.

Bagaimana Cara Mengakses Service? Seandainya aplikasi di Pod butuh mengaskses Pod lain via Service, bagaimana cara mengetahui IP Address Service tersebut?

Cara manual adalah dengan membuat service terlebih dahulu, lalu memasukkannya ke dalam konfigurasi aplikasinya secara manual. Atau adakah cara yang lebih otomatis?

Untuk Mengakses Service dapat dilakukan dengan cara ini :
- Menggunakan Environment Variable
- Menggunakan DNS

Berikut perintah-perintahnya juga dengan kita mencoba langsung dengan service yang ada :

- Melihat Environment Variable

  $ kubectl exec (podname) -- (env)

Kita akan coba sesuai dengan yang ada di bawah ini :

  $ kubectl exec -it curl  -- /bin/sh
  / # env
  KUBERNETES_SERVICE_PORT=443
  KUBERNETES_PORT=tcp://10.96.0.1:443
  HOSTNAME=curl
  SHLVL=1
  HOME=/root
  PKG_RELEASE=1
  TERM=xterm
  KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
  NGINX_VERSION=1.17.10       
  PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
  NGINX_SERVICE_PORT_8080_TCP_ADDR=10.110.104.126
  NGINX_SERVICE_SERVICE_HOST=10.110.104.126
  KUBERNETES_PORT_443_TCP_PORT=443
  NJS_VERSION=0.3.9
  KUBERNETES_PORT_443_TCP_PROTO=tcp
  NGINX_SERVICE_PORT_8080_TCP_PORT=8080
  NGINX_SERVICE_PORT_8080_TCP_PROTO=tcp
  NGINX_SERVICE_PORT=tcp://10.110.104.126:8080
  NGINX_SERVICE_SERVICE_PORT=8080
  KUBERNETES_SERVICE_PORT_HTTPS=443
  KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
  NGINX_SERVICE_PORT_8080_TCP=tcp://10.110.104.126:8080
  KUBERNETES_SERVICE_HOST=10.96.0.1
  PWD=/

Perhatikan pada bagian `NGINX_SERVICE_SERVICE_HOST=10.110.104.126` dan `NGINX_SERVICE_SERVICE_PORT=8080`, nah sudah ketemu untuk akses IP dari service tersebut. Nis gunakan curl dengan IP address tersebut untuk mengakses.

- Mengakses Menggunakan DNS
Disetiap service yang dibuat, pasti disediakan local DNS oleh Kubernetes, dengan format seperti ini :

  (servicename).(namespacename).svc.cluster.local

Untuk mengaksesnya kita akan coba seperti di bawah ini :

  / # curl http://nginx-service.default.svc.cluster.local:8080
  <!DOCTYPE html>
  <html>
  <head>
  <title>Welcome to nginx!</title>
  <style>
  html { color-scheme: light dark; }
  body { width: 35em; margin: 0 auto;
  font-family: Tahoma, Verdana, Arial, sans-serif; }
  </style>
  </head>
  <body>
  <h1>Welcome to nginx!</h1>
  <p>If you see this page, the nginx web server is successfully installed and
  working. Further configuration is required.</p>

  <p>For online documentation and support please refer to
  <a href="http://nginx.org/">nginx.org</a>.<br/>
  Commercial support is available at
  <a href="http://nginx.com/">nginx.com</a>.</p>

  <p><em>Thank you for using nginx.</em></p>
  </body>
  </html>

Terlihat aplikasi nginx sudah bisa di akses melalui local DNS.
- Melihat Semua Endpoint

  $ kubectl get endpoints

### 7.2 External Services

Biasanya Service digunakan sebagai gateway untuk internal Pod. Tetapi Service juga bisa digunakan sebagai gateway untuk aplikasi eksternal yang berada diluar kubernetes cluster.

Gambaran untuk external service kurang lebih seperti ini :


Untuk melihat Service Endpoint :

$ kubectl describe service (podname)

$ kubectl get endpoints (servicename)

Membuat Service bisa menggunakan kode konfiurasi berikut :
7.2.1-template-service-with-domain.yaml

apiVersion: v1
kind: Service
metadata:
  name: external-service
  labels:
    label-key1: label-value1
spec:
  type: ExternalName
  externalName: example.com
  ports:
    - port: 80

Berikut penjelasannya :
- **kind: Service**; yang jelas dan pasti untuk membuat Eksternal Service
- **type: ExternalName**; digunakan untuk mengakses aplikasi eksternal.
- **externalName: example.com**; kemana service akan terkoneksi, pada kasus ini akan terkoneksi example.com

Pada konfigurasi di atas, akan berarti ketika saya masuk ke external service tersebut, maka akan mas
Lalu, selain menggunakan domain, bisa juga melalui endpoint, seperti di bawah ini :
7.2.2-template-service-with-endpoint.yaml

apiVersion: v1
kind: Service
metadata:
  name: external-service
  labels:
    label-key1: label-value1
spec:
  ports:
    - port: 80

---

apiVersion: v1
kind: Endpoints
metadata:
  name: external-service
  labels:
    label-key1: label-value1
subsets:
  - addresses:
      - ip: 11.11.11.11
      - ip: 22.22.22.22
    ports:
      - port: 80

Berikut penjelasan singkatnya :
- **kind: Endpoints**; jadi untuk khusus endpoints akan di atur endpoints dan melempar ke sebuah terget.
- **ip**; IP untuk menargetkan koneksi ke sistem.

Seperti ini contohnya :
7.2.3-nginx-example-serviceexternal.yaml

apiVersion: v1
kind: Service
metadata:
  name: example-service
  labels:
    name: example-service
spec:
  type: ExternalName
  externalName: example.com
  ports:
    - port: 80

---

apiVersion: v1
kind: Pod
metadata:
  name: curl
  labels:
    name: curl
spec:
  containers:
    - name: curl
      image: khannedy/nginx-curl

Kita akan coba dengan catatan seperti di bawah :

$ kubectl create -f 7.2.3-nginx-example-serviceexternal.yaml
service/example-service created
pod/curl created
$ kubectl get all
NAME       READY   STATUS    RESTARTS   AGE
pod/curl   1/1     Running   0          36s

NAME                      TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/example-service   ExternalName   <none>       example.com   80/TCP    36s
service/kubernetes        ClusterIP      10.96.0.1    <none>        443/TCP   95s

Bisa diliat pada, Cluster IP untuk ExternalName tidak tersedia karena bersifat hanya mengakses example.com

$ kubectl exec -it curl -- bin/sh
/ # curl http://example-service.default.svc.cluster.local
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
        <head>
                <title>404 - Not Found</title>
        </head>
        <body>
                <h1>404 - Not Found</h1>
        </body>
</html>
/ #

Jika dilihat di atas, Pod telah berhasil mengambil data page dari example.com melalui External Service.

### 7.3 Mengekspos Service

Selanjutnya, akan dibahas tentang mengekspos Service, maksudnya aplikasi kita bisa diakses dari luar Pod. Pada dasarnya, untuk mengekspos Pod perlu cara tertentu, tidak bisa hanya dengan cara biasa melalui Port Forwarding karena hal tersebut ditujukan untuk tujuan berbeda.

Kadang ada kebutuhan kita perlu untuk mengekspos service keluar
Tujuannya adalah agar aplikasi dari luar Kubernetes Cluster bisa mengakses Pod yang berada di belakang service tersebut.


Misal pada kasus di gambar, bagaimana cara agar Pod bisa terkoneksi dengan servis dan terkoneksi langsung dengan Mobile Application. Oke, kita akan mempelajarinya.

Sebelumnya, kita akan belajar tentang tipe-tipe service terlebih dahulu, yaitu :

- **ClusterIP**: Mengekpos Service di dalam internal kubernetes cluster.
- **ExternalName**: Memetakan Service ke externalName.(misalnya: example.com)
- **NodePort**: Mengekspos Service pada setiap IP node dan port yang sama. Kita dapat mengakses Service dengan tipe ini, dari luar cluster melalui `<NodeIP>:<NodePort>`.
- **LoadBalancer**: Mengekspos Service secara eksternal dengan menggunakan LoadBalancer yang disediakan oleh penyedia layanan cloud.

Dan macam cara untuk mengekspos Service :

- Dengan menggunakan NodePort, sehingga Node akan membuka port yang akan meneruskan request ke Service yang dituju.
- Dengan menggunakan LoadBalancer, sehingga Service bisa diakses via LoadBalancer, dan LoadBalancer akan meneruskan request ke NodePort dan dilanjutkan ke Service.
- Menggunakan Ingress, dimana Ingress adalah resource yang memang ditujukan untuk mengekspos Service. Namun Ingress hanya beroperasi di level HTTP.

#### 7.3.1 NodePort

Sebelumnya, kita udah bahas singkat tentang cara mengekspos service, dan salah satunya menggunakan metode NodePort. Pengertian NodePort bisa dilihat gambar di bawah ini :


Jadi, seperti di gambar. NodePort merupakan pengaturan yang membiarkan node membuka atau menyediakan port akses. Port bisa otomatis atau manual.

Seperti di gambar, jadi jika anda ingin mengakses Service, bisa melewati node-node tersebut dan akan di teruskan ke Service. Lalu Service akan meneruskan ke Pod-Pod yang di pilih.

Untuk melihat NodePort bisa jalankan perintah ini :

$ minikube service (servicename)

Dan untuk membuat Service dengan NodePort ikuti langkah ini :
7.3.1.1-template-service-nodeport.yaml

apiVersion: v1
kind: Service
metadata:
  name: service-name
  labels:
    label-key1: label-value1
spec:
  type: NodePort
  selector:
    label-key1: label-value1
  ports:
    - port: 80
      targetPort: 80
      nodePort: 32767

Sama seperti membuat service, tapi pastikan gunakan `type: NodePort` jika tidak, dia akan secara default menggunakan ClusterIP. Dan pastikan tulis pada port nodePort nya berapa. Sebagai contoh, kita aka buat dengan konfigurasi :
7.3.1.2-nginx-service-nodeport.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      name: nginx
  template:
    metadata:
      name: nginx
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    name: nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30001

Pada konfigurasi di atas, akan di buat Replica Set yang berisi 2 Pod Nginx dan service nodeport yang diatur di 30001.

Kita coba :

$ kubectl create -f 7.3.1.2-template-service-nodeport.yaml
replicaset.apps/nginx created
service/nginx-service created
$ kubectl get all
NAME              READY   STATUS    RESTARTS   AGE
pod/nginx-5v4tx   1/1     Running   0          34s
pod/nginx-kh9gn   1/1     Running   0          34s
pod/nginx-v4zhm   1/1     Running   0          34s

NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
service/kubernetes      ClusterIP   10.96.0.1        <none>        443/TCP        17h
service/nginx-service   NodePort    10.102.141.163   <none>        80:30001/TCP   34s

NAME                    DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx   3         3         3       34s

Jika kalian lihat, pada `service/nginx-service` Node sudah memiliki IP Address dengan port nodenya. Dan untuk tau kita bisa mengaksesnya kita bisa gunakan perintah :

$ minikube service nginx-service
|-----------|---------------|-------------|---------------------------|
| NAMESPACE |     NAME      | TARGET PORT |            URL            |
|-----------|---------------|-------------|---------------------------|
| default   | nginx-service |          80 | http://192.168.49.2:30001 |
|-----------|---------------|-------------|---------------------------|
* Opening service default/nginx-service in default browser...
  http://192.168.49.2:30001
$ curl http://192.168.49.2:30001
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Diperhatikan, IP Port Cluster berbeda dengan IP Port Node yang diakses diluar. Jika coba cek pakai yg IP Port Cluster .

$ curl 10.102.141.163:80
^C
$ curl 10.102.141.163:30001
^C

Maka tak ada hasil, karena tugas jalinan data itu hanya melalui service yang sudah di buat.

#### 7.3.2 LoadBalancer

Kubernetes bisa menggunakan LoadBalancer bawaan dari Cloud Provider sebagai cara untuk mengekspos Service. Cloud Provider seperti Google Cloud atau Amazon Web Service biasanya memiliki Cloud LoadBalancer. LoadBalancer akan melakukan load balance request ke NodePort. Sayangnya Service LoadBalancer ini tidak bisa di test di local seperti menggunakan Minikube.

Begini untuk pola kerja dari LoadBalancer :


Sebenarnya mirip seperti NodePort, yang dimana node menyediakan port dan mengakses ke service lalu ke Pod. Tetapi, untuk LoadBalancer dibedakan dengan adanya load balancer untuk menyeimbangkan beban trafik.

Jika berdasarkan gambar, alur trafik dari client akan di urus oleh LoadBalancer, beban akan di atur antara melewati Node 1 atau Node 2 tergantung algoritma yang diatur, dan tidak ribet bingung juga untuk mengatur jalan antara Node 1 atau Node 2. Coba kita lihat untuk 2 Service :


Pada gambar, 2 service akan terdapat 2 LoadBalancer. Satu untuk Service 1 & 1 untuk 2 Service 2, jadi otomatis beban klien akan diatur dengan LoadBalancer, klien hanya menentukan jalur kemana dia akan pergi.

Begini untuk membuat Service berbasis, bisa dilihat template di bawah ini :
7.3.2.1-template-service-loadbalancer.yaml

apiVersion: v1
kind: Service
metadata:
  name: service-name
  labels:
    label-key1: label-value1
spec:
  type: LoadBalancer
  selector:
    label-key1: label-value1
  ports:
    - port: 80
      targetPort: 80

Pastikan typenya LoadBalancer, dan node port juga tida k diperlukan karena node port akan ditentukan otomati oleh Service. Bisa lihat, contoh langsungnya :
7.3.2.2-3x-nginx-servicelaodbalancer.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      name: nginx
  template:
    metadata:
      name: nginx
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: LoadBalancer
  selector:
    name: nginx
  ports:
    - port: 80
      targetPort: 80

Pada YAML di atas, berisikan replica set yang diisi 3 pod nginx dengan adanya service berbasis loadBalancer. Kita coba jalankan (walau tak sampai loadBalancer karena loadBalancer hanya ada di Cloud Service) :

$ kubectl create -f 7.3.2.2-3x-nginx-servicelaodbalancer.yaml
replicaset.apps/nginx created
service/nginx-service created
$ kubectl get all
NAME              READY   STATUS    RESTARTS   AGE
pod/nginx-pr2b9   1/1     Running   0          53s
pod/nginx-rlkp5   1/1     Running   0          53s
pod/nginx-svhsj   1/1     Running   0          53s

NAME                    TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/kubernetes      ClusterIP      10.96.0.1       <none>        443/TCP        48s
service/nginx-service   LoadBalancer   10.104.158.87   <pending>     80:30627/TCP   53s

NAME                    DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx   3         3         3       53s

Seperti yang terlihat di atas, sudah berisi pengaturan yang sama tapi hanya beda di `service/nginx-service` yang hanya bertipe LoadBalancer. Kita akan coba akses seperti biasa dahulu :

$ minikube service nginx-service
|-----------|---------------|-------------|---------------------------|
| NAMESPACE |     NAME      | TARGET PORT |            URL            |
|-----------|---------------|-------------|---------------------------|
| default   | nginx-service |          80 | http://192.168.49.2:30627 |
|-----------|---------------|-------------|---------------------------|
* Opening service default/nginx-service in default browser...
  http://192.168.49.2:30627
$ curl 192.168.49.2:30627
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Ya, bisa dilihat, Loadbalancer mirip dengan NodePort, dengan menggunakan cara akses yang sama seperti NodePort.

#### 7.3.3 Ingress

Ingress adalah salah satu cara yang bisa digunakan untuk mengekspos Service yang berbeda dengan LoadBalancer atau NodePort, jika menggunakan Ingress, client hanya butuh tahu satu lokasi IP Address Ingress. Ketika client melakukan request ke Ingress, pemilihan service nya ditentukan menggunakan hostname dari request, dan Ingress hanya mendukung protokol HTTP.

Ingress bisa menjawab dari massalah masalah sebelumnya, seperti di bawah ini :
- **Jika menggunakan NodePort**, maka semua Node harus terekspos ke public, dan client harus tau semua IP Address semua Node
- **Jika menggunakan LoadBalancer**, maka semua LoadBalancer harus terekspos ke public, dan client harus tau semua IP Address semua LoadBalancer

Untuk diagram Ingres bisa dilihat di gambar di bawah ini :


Sebenarnya Ingress adalah nginx, cara kerjanya pun mirip server yang berjalan nginx yang bisa menerima dan mengirim request dari domain. Oke, saatnya kita mencoba ingress dengan bantuan perintah di bawah ini :

Untuk melihat addons (termasuk Ingress) :

$ minikube addons list

Untuk mengenable addons (termasuk Ingress) yang terdisable gunakan perintah ini :

$ minikube addons enable (addonsname)

Untuk melihat apakah sebuah addons udah berjalan gunakan perintah ini :

$ kubectl get pod --namespace ingress-nginx

Kita akan coba untuk addons Ingress :

$ minikube addons enable ingress
* ingress is an addon maintained by Kubernetes. For any concerns contact minikube on GitHub.
You can view the list of minikube maintainers at: https://github.com/kubernetes/minikube/blob/master/OWNERS
  - Using image registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.4.1
  - Using image registry.k8s.io/ingress-nginx/controller:v1.10.1
  - Using image registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.4.1
* Verifying ingress addon...
* The 'ingress' addon is enabled

Terlihat bahwa minikube menginstall addons terlebih dahulu untuk menjalankan Ingress

$ minikube addons list
|-----------------------------|----------|--------------|--------------------------------|
|         ADDON NAME          | PROFILE  |    STATUS    |           MAINTAINER           |
|-----------------------------|----------|--------------|--------------------------------|
| ambassador                  | minikube | disabled     | 3rd party (Ambassador)         |
| auto-pause                  | minikube | disabled     | minikube                       |
| cloud-spanner               | minikube | disabled     | Google                         |
| csi-hostpath-driver         | minikube | disabled     | Kubernetes                     |
| dashboard                   | minikube | disabled     | Kubernetes                     |
| default-storageclass        | minikube | enabled ✅   | Kubernetes                     |
| efk                         | minikube | disabled     | 3rd party (Elastic)            |
| freshpod                    | minikube | disabled     | Google                         |
| gcp-auth                    | minikube | disabled     | Google                         |
| gvisor                      | minikube | disabled     | minikube                       |
| headlamp                    | minikube | disabled     | 3rd party (kinvolk.io)         |
| helm-tiller                 | minikube | disabled     | 3rd party (Helm)               |
| inaccel                     | minikube | disabled     | 3rd party (InAccel             |
|                             |          |              | [[e-mail]])            |
| ingress                     | minikube | enabled ✅   | Kubernetes                     |
| ingress-dns                 | minikube | disabled     | minikube                       |
| inspektor-gadget            | minikube | disabled     | 3rd party                      |
|                             |          |              | (inspektor-gadget.io)          |
| istio                       | minikube | disabled     | 3rd party (Istio)              |
| istio-provisioner           | minikube | disabled     | 3rd party (Istio)              |
| kong                        | minikube | disabled     | 3rd party (Kong HQ)            |
| kubeflow                    | minikube | disabled     | 3rd party                      |
| kubevirt                    | minikube | disabled     | 3rd party (KubeVirt)           |
| logviewer                   | minikube | disabled     | 3rd party (unknown)            |
| metallb                     | minikube | disabled     | 3rd party (MetalLB)            |
| metrics-server              | minikube | disabled     | Kubernetes                     |
| nvidia-device-plugin        | minikube | disabled     | 3rd party (NVIDIA)             |
| nvidia-driver-installer     | minikube | disabled     | 3rd party (Nvidia)             |
| nvidia-gpu-device-plugin    | minikube | disabled     | 3rd party (Nvidia)             |
| olm                         | minikube | disabled     | 3rd party (Operator Framework) |
| pod-security-policy         | minikube | disabled     | 3rd party (unknown)            |
| portainer                   | minikube | disabled     | 3rd party (Portainer.io)       |
| registry                    | minikube | disabled     | minikube                       |
| registry-aliases            | minikube | disabled     | 3rd party (unknown)            |
| registry-creds              | minikube | disabled     | 3rd party (UPMC Enterprises)   |
| storage-provisioner         | minikube | enabled ✅   | minikube                       |
| storage-provisioner-gluster | minikube | disabled     | 3rd party (Gluster)            |
| storage-provisioner-rancher | minikube | disabled     | 3rd party (Rancher)            |
| volumesnapshots             | minikube | disabled     | Kubernetes                     |
| yakd                        | minikube | disabled     | 3rd party (marcnuri.com)       |
|-----------------------------|----------|--------------|--------------------------------|
$ kubectl get pods --namespace ingress-nginx
NAME                                        READY   STATUS      RESTARTS        AGE
ingress-nginx-admission-create-b4gtq        0/1     Completed   0               2d6h
ingress-nginx-admission-patch-xdwxz         0/1     Completed   0               2d6h
ingress-nginx-controller-768f948f8f-lnq7f   1/1     Running     1 (6m37s ago)   2d6h
$ kubectl get all --namespace ingress-nginx
NAME                                            READY   STATUS      RESTARTS      AGE
pod/ingress-nginx-admission-create-b4gtq        0/1     Completed   0             2d6h
pod/ingress-nginx-admission-patch-xdwxz         0/1     Completed   0             2d6h
pod/ingress-nginx-controller-768f948f8f-lnq7f   1/1     Running     1 (24m ago)   2d6h

NAME                                         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
service/ingress-nginx-controller             NodePort    10.99.252.218   <none>        80:32019/TCP,443:31461/TCP   2d6h
service/ingress-nginx-controller-admission   ClusterIP   10.111.39.15    <none>        443/TCP                      2d6h

NAME                                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/ingress-nginx-controller   1/1     1            1           2d6h

NAME                                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/ingress-nginx-controller-768f948f8f   1         1         1       2d6h

NAME                                       STATUS     COMPLETIONS   DURATION   AGE
job.batch/ingress-nginx-admission-create   Complete   1/1           4m22s      2d6h
job.batch/ingress-nginx-admission-patch    Complete   1/1           5m11s      2d6h

Terlihat ingress sudah berjalan, pada terminal di atas cukup untuk menggambarkan proses peng-enablean Ingress. Untuk selanjutnya cara untuk membuat Ingress di Minikube, tapi sebelum membuat, bisa di perhatikan lagi perintah-perintah di bawah :

Untuk membuat Ingress bisa menggunakan perintah ini :

$ kubectl create -f (ingress.yaml)

Untuk melihat Ingress :

$ kubectl get ingresses

Menghapus Ingress :

$ kubectl delete ingress (ingressname)

Melihat IP Adress Minikube :

$ minikube ip

Dan Ingress bisa di buat dengan file konfigurasi seperti ini :
7.3.3.1-template-ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-name
  labels:
    label-key1: label-value1
spec:
  rules:
    - host: sub.domain.com
      http:
        paths:
          - path: /
            pathType: Prefix  
            backend:
              service:
                name: service-name 
                port:
                  number: 80 

Berikut pernjelasannya :
- **host**, untuk mengakses suatu ingress menggunakan host apa? maka dari itu ada konfigurasi host. Contoh : service1.sigma.com
- **path**, disini bisa di atur untuk direktori mana yang ingin di tembak ke ingress.
- **pathType** : Pada versi terbaru, field pathType wajib ada, biasanya menggunakan nilai Prefix untuk rute yang dimulai dengan path tertentu.
- **service-name, port** : menentukan nama service atau port service yang ingin di tembak.

Dan berikut contohnya :
7.3.3.2-ingress-replicaset-nginx.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      name: nginx
  template:
    metadata:
      name: nginx
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    name: nginx
  ports:
    - port: 80
      targetPort: 80

---

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  labels:
    name: nginx-ingress
spec:
  rules:
    - host: nginx.khannedy.local
      http:
        paths:
          - path: /

Disini, konfigurasi terdapat 3 point, yaitu : Replica Set, qService(untuk ekspos Ingress), dan Ingress. Dan bisa di lihat untuk serviceName dan servicePort sesuai yang ada. Mari kita eksekusi :

$ kubectl create -f 7.3.3.2-ingress-replicaset-nginx.yaml
replicaset.apps/nginx created
service/nginx-service created
ingress.networking.k8s.io/nginx-ingress created
$ kubectl get all
NAME              READY   STATUS    RESTARTS   AGE
pod/nginx-9ppvg   1/1     Running   0          4m56s
pod/nginx-pd9zv   1/1     Running   0          4m56s
pod/nginx-xqvfn   1/1     Running   0          4m56s

NAME                    TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
service/kubernetes      ClusterIP   10.96.0.1      <none>        443/TCP   4m57s
service/nginx-service   ClusterIP   10.111.96.73   <none>        80/TCP    4m55s

NAME                    DESIRED   CURRENT   READY   AGE
replicaset.apps/nginx   3         3         3       4m57s
$ kubectl get ingresses
NAME            CLASS   HOSTS                  ADDRESS        PORTS   AGE
nginx-ingress   nginx   nginx.khannedy.local   192.168.49.2   80      5m56s

Terlihat sudah terbuat dan berjalan. Danuntuk menggunakan domain `nginx.khannedy.local` tinggal di daftar kan ke mesin host dan di domainkan dengan membeli atau menggunakan jasa domain dari luar. Jadi, saat mengakses `nginx.kannedy.local` akan di lempar ke Ingress dengan IP Address tertentu dan di akseskannya isi konten. Kita akan coba masukkan IP Address ke Host agar bisa akses melalui domain :

$ minikube ip
192.168.49.2
$ sudo nano /etc/hosts
127.0.0.1       localhost
127.0.1.1       minkube
192.168.49.2    nginx.khannedy.local #tambahkan ini

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
$ curl nginx.khannedy.local
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Dan terllihat, jika sudah akses menggunakan `nginx.khannedy.local` nginx akan berjalan.