Ingresso mediante Contour

Una risorsa di ingresso Kubernetes fornisce il routing HTTP o HTTPS dall'esterno del cluster a uno o più servizi all'interno del cluster. I cluster TKG supportano l'ingresso tramite controller di terze parti, ad esempio Contour.

In questo tutorial viene illustrato come distribuire un controller di ingresso di Contour per il routing del traffico esterno ai servizi in un cluster TKG. Contour è un progetto open source a cui VMware contribuisce.

Prerequisiti

Esaminare la risorsa Ingresso nella documentazione di Kubernetes.
Esaminare il controller di ingresso Contour.
Effettuare il provisioning di un cluster TKG.
Connettersi al cluster TKG.

Procedura

Creare un ClusterRoleBinding che consenta agli account di servizio di gestire tutte le risorse del cluster.
```
kubectl create clusterrolebinding default-tkg-admin-privileged-binding 
--clusterrole=psp:vmware-system-privileged --group=system:authenticated
```
Nota: Se è necessaria una protezione maggiore, usare RoleBinding sullo spazio dei nomi di projectcontour. Vedere Applicazione del criterio di sicurezza del pod predefinito nei cluster TKG Service.
Creare uno spazio dei nomi chiamato projectcontour
Questo è lo spazio dei nomi predefinito per la distribuzione del controller di ingresso di Contour
```
kubectl create ns projectcontour
```
Scaricare l'ultimo file YAML del controller di ingresso di Contour: Distribuzione dell'ingresso di Contour.
Aprire il file contour.yaml in un editor di testo.

Commentare le due righe seguenti anteponendo il simbolo # a ogni riga:

Riga 1632:

# service.beta.kubernetes.io/aws-load-balancer-backend-protocol: tcp

Riga 1634:

# externalTrafficPolicy: Local

Distribuire Contour applicando il file contour.yaml.
```
kubectl apply -f contour.yaml
```

Verificare che il controller di ingresso di Contour e il servizio di bilanciamento del carico di Envoy siano distribuiti.

kubectl get services -n projectcontour

NAME      TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                      AGE
contour   ClusterIP      198.63.146.166   <none>          8001/TCP                     120m
envoy     LoadBalancer   198.48.52.47     192.168.123.5   80:30501/TCP,443:30173/TCP   120m

Verificare che i pod di Contour e Envoy siano in esecuzione.

kubectl get pods -n projectcontour

NAME                       READY   STATUS      RESTARTS   AGE
contour-7966d6cdbf-skqfl   1/1     Running     1          21h
contour-7966d6cdbf-vc8c7   1/1     Running     1          21h
contour-certgen-77m2n      0/1     Completed   0          21h
envoy-fsltp                1/1     Running     0          20h

Eseguire un ping al bilanciamento del carico utilizzando l'indirizzo IP esterno.

ping 192.168.123.5

PING 192.168.123.5 (192.168.123.5) 56(84) bytes of data.
64 bytes from 192.168.123.5: icmp_seq=1 ttl=62 time=3.50 ms

Creare una risorsa in ingresso denominata ingress-nihao.yaml.

Creare l'YAML.

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-nihao
spec:
  rules:
  - http:
      paths:
      - path: /nihao
        backend:
          serviceName: nihao
          servicePort: 80

Applicare il file YAML.

kubectl apply -f ingress-nihao.yaml

Verificare che la risorsa in ingresso sia stata creata.

kubectl get ingress

L'indirizzo IP esterno per LoadBalancer ( 192.168.123.5 in questo esempio) viene utilizzato dall'oggetto in ingresso.

NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
ingress-nihao   <none>   *       192.168.123.5     80      17s

Distribuire un servizio di test con un'applicazione back-end.

Creare il seguente file YAML denominato ingress-nihao-test.yaml

kind: Service
apiVersion: v1
metadata:
  name: nihao
spec:
  selector:
    app: nihao
    tier: backend
  ports:
  - protocol: TCP
    port: 80
    targetPort: http
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nihao
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nihao
      tier: backend
      track: stable
  template:
    metadata:
      labels:
        app: nihao
        tier: backend
        track: stable
    spec:
      containers:
        - name: nihao
          image: "gcr.io/google-samples/hello-go-gke:1.0"
          ports:
            - name: http
              containerPort: 80

Applicare il file YAML.

kubectl apply -f ingress-nihao-test.yaml

Verificare che il servizio nihao sia stato creato.

kubectl get services

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
nihao        ClusterIP   10.14.21.22     <none>        80/TCP     15s

Verificare che la distribuzione back-end sia stata creata.

kubectl get deployments

NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nihao   3/3     3            3           2m25s

Verificare che i pod back-end esistano.

kubectl get pods

NAME                     READY   STATUS    RESTARTS   AGE
nihao-8646584495-9nm8x   1/1     Running   0          106s
nihao-8646584495-vscm5   1/1     Running   0          106s
nihao-8646584495-zcsdq   1/1     Running   0          106s

Recuperare l'indirizzo IP pubblico del bilanciamento del carico utilizzato dal controller di ingresso di Contour.

kubectl get ingress

NAME            CLASS    HOSTS   ADDRESS         PORTS   AGE
ingress-nihao   <none>   *       10.19.14.76     80      13m

Utilizzando un browser, passare all'IP pubblico e includere il percorso di ingresso.
```
http://10.19.14.76/nihao
```
Viene restituito il messaggio "hello".
```
{"message":"Hello"}
```

risultati

Il browser accede esternamente all'app di back-end, avente come fron-end il servizio in esecuzione all'interno del cluster, tramite il controller di ingresso utilizzando l'indirizzo IP esterno del bilanciamento del carico.