Entrada mediante Contour

Un recurso de entrada de Kubernetes proporciona enrutamiento HTTP o HTTPS desde fuera del clúster a uno o varios servicios dentro del clúster. Los clústeres de TKG admiten la entrada a través de controladoras de terceros, como Contour.

En este tutorial se demuestra cómo implementar la controladora de entrada de Contour para enrutar el tráfico externo a los servicios en un clúster de TKG. Contour es un proyecto de código abierto al que VMware contribuye.

Requisitos previos

Revise el recurso de Entrada en la documentación de Kubernetes.
Revise la controladora de entrada de Contour.
Aprovisione un clúster de TKG.
Conéctese al clúster de TKG.

Procedimiento

Cree un objeto de ClusterRoleBinding que permita a las cuentas de servicio administrar todos los recursos del clúster.
```
kubectl create clusterrolebinding default-tkg-admin-privileged-binding 
--clusterrole=psp:vmware-system-privileged --group=system:authenticated
```
Nota: Si se requiere una seguridad más estricta, use un objeto RoleBinding en el espacio de nombres de projectcontour. Consulte Aplicar la directiva de seguridad de pods predeterminada a clústeres de servicio TKG.
Cree un espacio de nombres denominado projectcontour.
Este es el espacio de nombres predeterminado para la implementación de la controladora de entrada de Contour.
```
kubectl create ns projectcontour
```
Descargue el archivo YAML más reciente de la controladora de entrada de Contour: Implementación de entrada de Contour.
Abra el archivo contour.yaml con un editor de texto.

Comente las dos líneas siguientes anteponiendo el símbolo # a cada línea:

Línea 1632:

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

Línea 1634:

# externalTrafficPolicy: Local

Implemente Contour mediante la aplicación del archivo contour.yaml.
```
kubectl apply -f contour.yaml
```

Compruebe que se hayan implementado el servicio de equilibrador de carga de Envoy y la controladora de entrada de Contour.

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

Verifique que los pods de Contour y Envoy estén en ejecución.

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

Ejecute ping en el equilibrador de carga utilizando la dirección IP externa.

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

Cree un recurso de entrada denominado ingress-nihao.yaml.

Cree el archivo YAML.

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

Aplique el archivo YAML.

kubectl apply -f ingress-nihao.yaml

Compruebe que se haya creado el recurso de entrada.

kubectl get ingress

El objeto de entrada utiliza la dirección IP externa para el equilibrador de carga Envoy ( 192.168.123.5 en este ejemplo).

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

Implemente un servicio de prueba con una aplicación de back-end.

Cree el siguiente archivo YAML con el nombre 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

Aplique el archivo YAML.

kubectl apply -f ingress-nihao-test.yaml

Compruebe que se haya creado el servicio nihao.

kubectl get services

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

Compruebe que se haya creado la implementación de back-end.

kubectl get deployments

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

Compruebe que existan los pods de back-end.

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

Obtenga la dirección IP pública del equilibrador de carga que utiliza la controladora de entrada de Contour.

kubectl get ingress

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

Con un navegador, desplácese hasta la dirección IP pública y escriba la ruta de entrada.
```
http://10.19.14.76/nihao
```
Se devolverá el mensaje "Hello".
```
{"message":"Hello"}
```

Resultados

El navegador permite acceder externamente a la aplicación de back-end que ofrece el servicio en ejecución dentro del clúster a través de la controladora de entrada con la dirección IP externa del equilibrador de carga.