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

1. 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.
2. Crie um namespace chamado projectcontour.
   Este é o namespace padrão para a implantação do controlador de ingresso Contour

   kubectl create ns projectcontour

3. Faça download do YAML mais recente do controlador de ingresso do Contour: Implantação do Ingress do Contour.
4. Abra o arquivo contour.yaml usando um editor de texto.
5. 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
   

6. Implemente o Contour aplicando o arquivo contour.yaml.

   kubectl apply -f contour.yaml

7. 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

8. 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

9. 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
   

10. 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

11. 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

12. 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

13. 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.