Alibaba Cloud Service Mesh:Gerenciar tráfego de saída com ASMEgressTrafficPolicy

Como funciona

Uma malha de serviços gerencia o tráfego de saída criando e interconectando diversos recursos, como ServiceEntry, VirtualService, Gateway e Destination. Após configurar esses recursos, a malha intercepta o tráfego transparentemente e o roteia para um gateway de saída, que então o encaminha aos serviços externos.

Esse processo é complexo, propenso a erros e exige conhecimento aprofundado sobre vários campos. Para simplificar a configuração do tráfego de saída, o ASM introduziu o recurso ASMEgressTrafficPolicy.

O recurso ASMEgressTrafficPolicy abstrai e simplifica a configuração do tráfego de saída. Em vez de criar e gerenciar manualmente recursos como ServiceEntry, VirtualService, Gateway e Destination, basta definir algumas configurações essenciais. A malha de serviços intercepta o tráfego transparentemente, o roteia para um gateway de saída e o encaminha para serviços externos via HTTP ou HTTPS.

Como o ASMEgressTrafficPolicy é uma abstração simplificada dos recursos nativos da malha de serviços, ele pode não oferecer suporte a casos de uso avançados, como roteamento de tráfego baseado em porcentagem ou iniciação de mTLS a partir do gateway de saída. Caso necessite de recursos avançados ou configurações personalizadas, consulte Configurar um gateway de saída unificado para tráfego na malha .

Recursos

O ASM fornece uma maneira unificada de conectar, gerenciar e proteger a comunicação entre aplicações. Diferentemente dos métodos baseados em IP de rede, o ASM utiliza uma abordagem centrada na aplicação que não exige alterações no código existente. O recurso ASMEgressTrafficPolicy define como gerenciar o tráfego de saída por meio de um gateway de saída. Ao combinar um gateway de saída do ASM com uma AuthorizationPolicy, você obtém um controle mais flexível do tráfego de saída.

Este exemplo inclui os seguintes fluxos de tráfego:

1. Comunicação entre proxies da malha e entre os proxies e o gateway: Por padrão, o ASM protege essa comunicação com mTLS e gerencia os certificados.

2. Comunicação entre aplicações e seus proxies da malha, e entre o gateway e serviços externos:

a. Para usar os recursos avançados de L7 da malha de serviços, as aplicações devem se comunicar com seus proxies da malha usando texto simples sempre que possível. Isso permite que o proxy da malha acesse informações de tráfego L7 e ofereça suporte a recursos mais avançados. Se uma aplicação precisar iniciar tráfego HTTPS diretamente, a malha de serviços fornecerá apenas capacidades de L4.

b. Configure o protocolo de comunicação entre o gateway de saída e os serviços externos. Tanto texto simples quanto HTTPS são suportados.

Definir a política de tráfego de saída

1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.

2. Na página Mesh Management, clique em nome da instância do ASM. No painel de navegação à esquerda, escolha Data Plane Component Management > Sidecar Proxy Setting.

3. Na aba global, clique em Outbound Traffic Policy. Em seguida, à direita de Outbound Traffic Policy, clique em REGISTRY_ONLY e depois clique em Update Settings.

Criar um namespace

1. Crie o namespace istio-egress. Para mais informações, consulte Gerenciar namespaces globais.

2. Na página Global Namespace, clique em Sync Automatic Sidecar Injection to Kubernetes Cluster para sincronizar o namespace com o cluster ACK gerenciado pela instância do ASM.

Criar um gateway de saída

No ASM, crie um gateway de saída chamado egressgateway-a. Em Port Mapping, configure HTTP na porta 80 e HTTPS nas portas 443 e 444. Em seguida, ative Support two-way TLS authentication. Para mais informações, consulte Criar um serviço de gateway de saída.

spec:
  podLabels:
    security.istio.io/tlsMode: istio

Criar uma aplicação de exemplo

1. Na instância do ASM, crie um namespace chamado mytest e ative a injeção automática de sidecar. Para mais informações, consulte Gerenciar namespaces globais.

2. No cluster ACK, implante o serviço sleep-a no namespace mytest e o serviço nginx no namespace padrão.

   1. Crie um arquivo chamado test.yaml com o seguinte conteúdo:

      Test.yaml

      apiVersion: v1
      kind: Service
      metadata:
        name: sleep-a
        namespace: mytest
        labels:
          app: sleep-a
          service: sleep-a
      spec:
        ports:
        - port: 80
          name: http
        selector:
          app: sleep-a
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: sleep-a
        namespace: mytest
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: sleep-a
        template:
          metadata:
            labels:
              app: sleep-a
          spec:
            terminationGracePeriodSeconds: 0
            containers:
            - name: sleep
              image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/curl:asm-sleep
              command: ["/bin/sleep", "infinity"]
              imagePullPolicy: IfNotPresent
              volumeMounts:
              - mountPath: /etc/sleep/tls
                name: secret-volume
            volumes:
            - name: secret-volume
              secret:
                secretName: sleep-secret
                optional: true
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        labels:
          app: nginx
        name: nginx
        namespace: default
      spec:
        progressDeadlineSeconds: 600
        replicas: 1
        revisionHistoryLimit: 10
        selector:
          matchLabels:
            app: nginx
        strategy:
          rollingUpdate:
            maxSurge: 25%
            maxUnavailable: 25%
          type: RollingUpdate
        template:
          metadata:
            creationTimestamp: null
            labels:
              app: nginx
          spec:
            containers:
            - image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/nginx:1.27.0
              imagePullPolicy: Always
              name: nginx
              resources: {}
              terminationMessagePath: /dev/termination-log
              terminationMessagePolicy: File
            dnsPolicy: ClusterFirst
            restartPolicy: Always
            schedulerName: default-scheduler
            securityContext: {}
            terminationGracePeriodSeconds: 30

   2. No cluster ACK, execute o comando a seguir para implantar os serviços sleep-a e nginx:

      kubectl apply -f test.yaml

3. Execute os comandos a seguir para acessar http://www.httpbin.org a partir dos serviços sleep-a e nginx:

   kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org
   kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org

   Ambos os comandos retornam 502, indicando falha no acesso.

Opção 1: HTTP em texto simples entre sidecar e gateway de saída

Esta opção não é prática em ambientes de produção. A comunicação em texto simples entre o contêiner da aplicação e o gateway de saída impede a autorização baseada na identidade do cliente. O ASMEgressTrafficPolicy não oferece suporte ao acesso ao gateway de saída via HTTP em texto simples.

• O gerenciamento de tráfego ocorre principalmente no sidecar do cliente e não requer um gateway de saída.

• A observabilidade não depende de um gateway de saída.

• Os recursos de segurança dependem do gateway de saída. No entanto, sem mTLS, todas as capacidades de autorização baseadas na identidade do cliente ficam desativadas. O gateway de saída só consegue rejeitar todas as solicitações.

Opção 2: mTLS entre sidecar e gateway de saída (recomendado)

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.

   2. Na página Mesh Management, clique em nome da instância do ASM. No painel de navegação à esquerda, escolha ASM Gateways > Egress Gateway.

   3. Clique em nome do gateway para acessar a página gateway overview. No painel de navegação à esquerda, clique em Outbound Traffic Policy.

      Configure a regra da política de tráfego de saída. Defina Egress Gateway como egressgateway. Na área In-cluster Service, defina Namespace como mytest, Workload Label Name como app e Label Value como sleep-a. Na área External Service, defina External Service Name como httpbin-service-http, adicione www.httpbin.org e httpbin.org à Domain List. Para Service Port, defina Port como 80, Port Name como http e Protocol como HTTP. Na área How to Access, selecione a porta do gateway de saída 80 e, para Upgrade to HTTPS, selecione No.

   kubectl

   1. Crie um arquivo chamado egress-by-egressgateway.yaml com o seguinte conteúdo.

      Para descrições dos campos, consulte Referência da CRD ASMEgressTrafficPolicy.

      apiVersion: istio.alibabacloud.com/v1
      kind: ASMEgressTrafficPolicy
      metadata:
        name: egress-by-egressgateway  # Convention: egress-by-{egress-gateway-name}.
        namespace: istio-egress         # Convention: Fixed to the istio-egress namespace.
      spec:
        byEgressGateway:
          name: egressgateway
        egressRules:
        - from:
          - namespace: mytest
            workloadSelector:
              app: sleep-a
          to:
          - name: httpbin-service-http
            hosts:
            - www.httpbin.org  # All hosts must resolve to the same IP addresses.
            - httpbin.org      # All hosts must resolve to the same IP addresses.
            port:
              name: http
              number: 80
              protocol: HTTP
            byEgressGateway:
              port: 80        # Traffic path: sidecar -> Gateway (port 80) -> Service (httpbin.org, port 80)

   2. No cluster ACK, execute o comando a seguir para criar o recurso ASMEgressTrafficPolicy.

      kubectl apply -f egress-by-egressgateway.yaml

2. Verifique se o ASMEgressTrafficPolicy entrou em vigor.

   1. Execute o comando a seguir para testar o acesso do serviço nginx no namespace padrão a http://www.httpbin.org.

      kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org

      O comando retorna 502, indicando que o acesso do serviço nginx a http://www.httpbin.org foi bloqueado conforme esperado.

   2. Execute o comando a seguir para testar o acesso do serviço sleep-a no namespace mytest a http://www.httpbin.org.

      kubectl -n mytest exec deployment/sleep-a -- curl  -s -o /dev/null -w "%{http_code}\n"  http://www.httpbin.org

      O comando retorna 200, indicando que o acesso foi permitido conforme esperado.

   3. Execute os comandos a seguir para excluir a política egress-by-egressgateway e, em seguida, teste novamente o acesso do serviço sleep-a no namespace mytest a http://www.httpbin.org.

      kubectl -n istio-egress delete ASMEgressTrafficPolicy  egress-by-egressgateway
      kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org

      O comando retorna 502, indicando que, após a exclusão do ASMEgressTrafficPolicy, o serviço sleep-a não consegue mais acessar http://www.httpbin.org.

   Esses resultados confirmam que o ASMEgressTrafficPolicy está funcionando corretamente.

Opção 1: mTLS entre sidecar e gateway de saída (recomendado)

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.

   2. Na página Mesh Management, clique em nome da instância do ASM. No painel de navegação à esquerda, escolha ASM Gateways > Egress Gateway.

   3. Clique em nome do gateway para abrir a página gateway overview. No painel de navegação à esquerda, clique em Outbound Traffic Policy.

      Configure uma regra de tráfego de saída. Na seção in-cluster service, defina Namespace como mytest, Label Name como app e Label Value como sleep-a. Na seção external service, defina External Service Name como httpbin-service-http, adicione www.httpbin.org e httpbin.org à Domain List e configure a Service Port com Port: 80, Port Name: http e Protocol: HTTP. Na seção How to Access, defina Egress Gateway Port como 80, Upgrade to HTTPS como Yes e HTTPS Port como 443.

   Kubectl

   1. Atualize o arquivo egress-by-egressgateway.yaml com o seguinte conteúdo.

      O campo httpsUpgrade e definições relacionadas para acessar https://www.httpbin.org foram adicionados ao campo spec. Para descrições dos campos, consulte Referência da CRD ASMEgressTrafficPolicy.

      apiVersion: istio.alibabacloud.com/v1
      kind: ASMEgressTrafficPolicy
      metadata:
        name: egress-by-egressgateway  # Convention: egress-by-{egress-gateway-name}.
        namespace: istio-egress          # Convention: Fixed to the istio-egress namespace.
      spec:
        byEgressGateway:
          name: egressgateway
        egressRules:
        - from:
           - namespace: mytest
             workloadSelector:
                app: sleep-a
          to:
          - name: httpbin-service-http
            hosts:
            - www.httpbin.org  # The IP addresses to which the multiple domain names resolve must be the same.
            - httpbin.org      # The IP addresses to which the multiple domain names resolve must be the same.
            port:
              name: http
              number: 80
              protocol: HTTP
            byEgressGateway:
              port: 80        # Sidecar -> Port 80 of Gateway -> Port 80 of Service (httpbin.org)
            httpsUpgrade:
              enabled: true   # If enabled is set to false, the port setting for httpsUpgrade has no effect.
              port: 443       # Sidecar -> Port 80 of Gateway -> Port 443 of Service (httpbin.org)

   2. No cluster ACK, execute o comando a seguir para criar o recurso ASMEgressTrafficPolicy:

      kubectl apply -f egress-by-egressgateway.yaml

2. Verifique a configuração do ASMEgressTrafficPolicy.

   1. Verifique o serviço sleep-a no namespace mytest.

      1. Execute o comando a seguir para acessar http://www.httpbin.org a partir do serviço sleep-a.

         kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n" http://httpbin.org

         Um código de status 200 indica que o serviço sleep-a consegue acessar http://www.httpbin.org.

      2. Execute o comando a seguir para solicitar o endpoint anything de httpbin.org e verificar se o gateway de saída atualiza a solicitação HTTP para HTTPS.

         kubectl -n mytest exec deployment/sleep-a -- sh -c "curl -s  http://httpbin.org/anything |grep url"

         Saída esperada:

         "url": "https://httpbin.org/anything"

         O valor do campo url começa com https, confirmando que o gateway de saída atualizou a solicitação para https antes de encaminhá-la para httpbin.org.

      3. Execute o comando a seguir para acessar https://www.httpbin.org a partir do serviço sleep-a no namespace mytest.

         kubectl -n mytest exec deployment/sleep-a -- curl  -s -o /dev/null -w "%{http_code}\n"  https://www.httpbin.org

         Um código de status 200 indica que o serviço sleep-a consegue acessar https://www.httpbin.org.

   2. Verifique o serviço Nginx no namespace padrão.

      1. Execute o comando a seguir para acessar http://www.httpbin.org a partir do serviço Nginx.

         kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org

         Um código de status 502 indica que o serviço Nginx falhou ao acessar http://www.httpbin.org.

      2. Execute o comando a seguir para acessar https://www.httpbin.org a partir do serviço Nginx.

         kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" https://www.httpbin.org

         Um erro de conexão recusada indica que o serviço Nginx falhou ao acessar https://www.httpbin.org.

      3. Execute o comando a seguir para visualizar o log de acesso do sidecar da carga de trabalho Nginx e identificar o motivo da recusa de conexão.

          kubectl -n default  logs -f deployment/nginx -c istio-proxy   --tail=1 

         Saída esperada:

         {"authority":"-","bytes_received":"0","bytes_sent":"0","downstream_local_address":"52.86.XX.XX:443","downstream_remote_address":"172.16.0.199:56748","duration":"0","istio_policy_status":"-","method":"-","path":"-","protocol":"-","request_id":"-","requested_server_name":"-","response_code":"0","response_flags":"UH","route_name":"-","start_time":"2023-04-11T02:00:07.409Z","trace_id":"-","upstream_cluster":"BlackHoleCluster","upstream_host":"-","upstream_local_address":"-","upstream_service_time":"-","upstream_transport_failure_reason":"-","user_agent":"-","x_forwarded_for":"-"}

         A saída mostra que a solicitação foi encaminhada para o BlackHoleCluster, que rejeitou a conexão.

   3. Execute os comandos a seguir para excluir egress-by-egressgateway e, em seguida, tente acessar http://www.httpbin.org e https://www.httpbin.org novamente a partir do serviço sleep-a no namespace mytest.

      kubectl -n istio-egress delete ASMEgressTrafficPolicy  egress-by-egressgateway
      kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n"  http://www.httpbin.org
      kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n"  https://www.httpbin.org

      As solicitações para http://www.httpbin.org retornam 502, e as solicitações para https://www.httpbin.org são rejeitadas. Após a exclusão da configuração do ASMEgressTrafficPolicy, o serviço sleep-a não consegue mais acessar http://www.httpbin.org ou https://www.httpbin.org.

   Esses resultados confirmam que o ASMEgressTrafficPolicy funciona conforme esperado.

Opção 2: HTTPS entre o sidecar e o gateway de saída

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.

   2. Na página Mesh Management, clique em nome da instância do ASM. No painel de navegação à esquerda, escolha ASM Gateways > Egress Gateway.

   3. Clique em nome do gateway para abrir a página gateway overview. No painel de navegação à esquerda, clique em Outbound Traffic Policy.

      Na página de regras de tráfego de saída, clique em Add Rule e configure os parâmetros da regra. Defina Namespace como mytest. Para Workload Labels, defina o nome do rótulo como app e o valor do rótulo como sleep-a. Defina External Service Name como httpbin-service-https. Adicione www.httpbin.org e httpbin.org à Domain List. Para Service Port, defina a porta como 443, o nome da porta como https e Protocol como HTTPS. Para How to Access, selecione Via egress gateway port e defina a porta como 444.

   Kubectl

   1. Atualize o arquivo egress-by-egressgateway.yaml com o seguinte conteúdo.

      O campo httpsUpgrade e definições para acessar diretamente https://www.httpbin.org foram adicionados ao campo spec. Para uma descrição dos campos, consulte ASMEgressTrafficPolicy CRD.

      apiVersion: istio.alibabacloud.com/v1
      kind: ASMEgressTrafficPolicy
      metadata:
        name: egress-by-egressgateway  # Convention: egress-by-{egress-gateway-name}.
        namespace: istio-egress          # Convention: Fixed to the istio-egress namespace.
      spec:
        byEgressGateway:
          name: egressgateway
        egressRules:
        - from:
           - namespace: mytest
             workloadSelector:
                app: sleep-a
          to:
          - name: httpbin-service-https
            hosts:
            - www.httpbin.org
            - httpbin.org
            port:
              name: https
              number: 443
              protocol: HTTPS
            byEgressGateway:
              port: 444   # The HTTPS port 444 that is defined for the egress gateway in the prerequisites.

   2. No cluster ACK, execute o comando a seguir para criar o recurso ASMEgressTrafficPolicy:

      kubectl apply -f egress-by-egressgateway.yaml

2. Verifique a configuração do ASMEgressTrafficPolicy.

   1. Verifique o serviço sleep-a no namespace mytest.

      1. Execute o comando a seguir para acessar http://www.httpbin.org a partir do serviço sleep-a.

         kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n" http://httpbin.org

         Um código de status 502 indica que o serviço sleep-a falhou ao acessar http://www.httpbin.org.

      2. Execute o comando a seguir para acessar https://www.httpbin.org a partir do serviço sleep-a no namespace mytest.

         kubectl -n mytest exec deployment/sleep-a -- curl  -s -o /dev/null -w "%{http_code}\n"  https://www.httpbin.org

         Um código de status 200 indica que o serviço sleep-a consegue acessar https://www.httpbin.org.

   2. Verifique o serviço Nginx no namespace padrão.

      1. Execute o comando a seguir para acessar http://www.httpbin.org a partir do serviço Nginx.

         kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" http://www.httpbin.org

         Um código de status 502 indica que o serviço Nginx falhou ao acessar http://www.httpbin.org.

      2. Execute o comando a seguir para acessar https://www.httpbin.org a partir do serviço Nginx.

         kubectl -n default exec deployment/nginx -- curl -s -o /dev/null -w "%{http_code}\n" https://www.httpbin.org

         Um erro de conexão recusada indica que o serviço Nginx falhou ao acessar https://www.httpbin.org.

      3. Execute o comando a seguir para visualizar o log de acesso do sidecar da carga de trabalho Nginx e identificar o motivo da recusa de conexão.

          kubectl -n default  logs -f deployment/nginx -c istio-proxy   --tail=1 

         Saída esperada:

         {"authority":"-","bytes_received":"0","bytes_sent":"0","downstream_local_address":"52.86.XX.XX:443","downstream_remote_address":"172.16.0.199:56748","duration":"0","istio_policy_status":"-","method":"-","path":"-","protocol":"-","request_id":"-","requested_server_name":"-","response_code":"0","response_flags":"UH","route_name":"-","start_time":"2023-04-11T02:00:07.409Z","trace_id":"-","upstream_cluster":"BlackHoleCluster","upstream_host":"-","upstream_local_address":"-","upstream_service_time":"-","upstream_transport_failure_reason":"-","user_agent":"-","x_forwarded_for":"-"}

         A saída mostra que a solicitação foi encaminhada para o BlackHoleCluster, que rejeitou a conexão.

   3. Execute os comandos a seguir para excluir egress-by-egressgateway e, em seguida, tente acessar http://www.httpbin.org e https://www.httpbin.org novamente a partir do serviço sleep-a no namespace mytest.

      kubectl -n istio-egress delete ASMEgressTrafficPolicy  egress-by-egressgateway
      kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n"  http://www.httpbin.org
      kubectl -n mytest exec deployment/sleep-a -- curl -s -o /dev/null -w "%{http_code}\n"  https://www.httpbin.org

      As solicitações para http://www.httpbin.org retornam 502, e as solicitações para https://www.httpbin.org são rejeitadas. Após a exclusão da configuração do ASMEgressTrafficPolicy, o serviço sleep-a não consegue mais acessar http://www.httpbin.org ou https://www.httpbin.org.

      Esses resultados confirmam que o ASMEgressTrafficPolicy funciona conforme esperado.

Negar solicitações POST de um namespace específico

kind: AuthorizationPolicy
apiVersion: security.istio.io/v1beta1
metadata:
  name: sleep-a-egress-www-httpbin-org
  namespace: istio-system
spec:
  action: DENY
  rules:
    - to:
        - operation:
            hosts:
            - www.httpbin.org
            - httpbin.org
            methods:
              - POST
      from:
        - source:
            namespaces: ["mytest"]
  selector:
    matchLabels:
      istio: egressgateway-a

Após aplicar essa configuração, as solicitações POST do serviço sleep-a para www.httpbin.org retornam RBAC: access. As solicitações GET do serviço sleep-a para www.httpbin.org não são afetadas.