Entrada usando o contorno

Um recurso de entrada do Kubernetes fornece roteamento HTTP ou HTTPS de fora do cluster para um ou mais serviços dentro do cluster. Os clusters TKG oferecem suporte à entrada por meio de controladores de terceiros, como o Contour.

Este tutorial demonstra como implantar o controlador de entrada Contour para rotear o tráfego externo para serviços em um cluster TKG. O Contour é um projeto de código aberto com o qual VMware contribui.

Pré-requisitos

Revise o recurso Ingress na documentação do Kubernetes.
Revise o controlador de entrada Contour.
Provisione um cluster TKG.
Conecte-se ao cluster TKG.

Procedimento

Crie um ClusterRoleBinding permitindo que as contas de serviço gerenciem todos os recursos do cluster.
```
kubectl create clusterrolebinding default-tkg-admin-privileged-binding 
--clusterrole=psp:vmware-system-privileged --group=system:authenticated
```
Observação: Se uma segurança mais rígida for necessária, use um RoleBinding no namespace projectcontour. Consulte Exemplo de RBAC para política de segurança de pod.
Crie um namespace chamado projectcontour.
Este é o namespace padrão para a implantação do controlador de ingresso Contour
```
kubectl create ns projectcontour
```
Faça download do YAML mais recente do controlador de ingresso do Contour: Implantação do Ingress do Contour.
Abra o arquivo contour.yaml usando um editor de texto.

Comente as duas linhas a seguir acrescentando cada linha com o símbolo #:

Linha 1632:

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

Linha 1634:

# externalTrafficPolicy: Local

Implemente o Contour aplicando o arquivo contour.yaml.
```
kubectl apply -f contour.yaml
```

Verifique se o controlador de entrada do Contour e o serviço de balanceador de carga do Envoy estão implantados.

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 se os pods do Contour e do Envoy estão em execução.

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

Faça ping no balanceador de carga usando o endereço IP externo.

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

Crie um recurso de entrada chamado ingress-nihao.yaml.

Crie o YAML.

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

Aplique o YAML.

kubectl apply -f ingress-nihao.yaml

Verifique se o recurso de entrada foi criado.

kubectl get ingress

O endereço IP externo do Envoy LoadBalancer ( 192.168.123.5 neste exemplo) é usado pelo objeto de entrada.

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

Implante um serviço de teste com um aplicativo de back-end.

Crie o seguinte arquivo YAML chamado 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 o YAML.

kubectl apply -f ingress-nihao-test.yaml

Verifique se o serviço nihao foi criado.

kubectl get services

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

Verifique se a implantação de back-end foi criada.

kubectl get deployments

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

Verifique se os pods de back-end existem.

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

Obtenha o endereço IP público do balanceador de carga usado pelo controlador de entrada Contour.

kubectl get ingress

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

Usando um navegador, navegue até o IP público e inclua o caminho de entrada.
```
http://10.19.14.76/nihao
```
A mensagem "hello" é retornada.
```
{"message":"Hello"}
```

Resultados

O aplicativo de back-end que é liderado pelo serviço em execução dentro do cluster é acessado externamente pelo navegador por meio do controlador de entrada usando o endereço IP externo do balanceador de carga.