Alibaba Cloud Service Mesh:Manage egress traffic with ASMEgressTrafficPolicy

Como funciona

Uma service mesh oferece suporte ao gerenciamento de tráfego de saída por meio da criação e interconexão de vários recursos, como ServiceEntry, VirtualService, Gateway e Destination. Após configurar esses recursos, a service mesh intercepta o tráfego de forma transparente e o roteia para um egress gateway, que o encaminha para serviços externos.

Esse processo de configuração é complexo, propenso a erros e exige um conhecimento profundo de vários campos. Para simplificar a configuração do tráfego de saída, o ASM introduz 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, você precisa definir apenas algumas configurações essenciais. A service mesh intercepta o tráfego de forma transparente, o roteia para um egress gateway e o encaminha para serviços externos via HTTP ou HTTPS.

Como o ASMEgressTrafficPolicy é uma abstração simplificada dos recursos nativos da service mesh, 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 egress gateway. Se você precisar de recursos avançados ou configurações personalizadas, consulte Configure a unified egress gateway for in-mesh traffic .

Recursos

O ASM fornece uma maneira unificada de conectar, gerenciar e proteger a comunicação entre aplicativos. Ao contrário dos métodos baseados em IP de rede, o ASM usa uma abordagem centrada no aplicativo que não exige alterações no código do aplicativo existente. O recurso ASMEgressTrafficPolicy define como gerenciar o tráfego de saída por meio de um egress gateway. Ao combinar um egress gateway do ASM com uma AuthorizationPolicy, você pode controlar o tráfego de saída com mais flexibilidade.

Este exemplo inclui os seguintes fluxos de tráfego:

1. Comunicação entre os proxies da mesh 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 os aplicativos e seus proxies da mesh, e entre o gateway e os serviços externos:

   a. Para usar os recursos avançados de L7 da service mesh, os aplicativos devem se comunicar com seus proxies da mesh usando texto simples sempre que possível. Isso permite que o proxy da mesh acesse informações de tráfego L7 e ofereça suporte a recursos mais avançados. Se um aplicativo precisar iniciar tráfego HTTPS diretamente, a service mesh poderá fornecer apenas recursos de L4.

   b. É possível configurar o protocolo de comunicação entre o egress gateway e os serviços externos. Há suporte para texto simples e HTTPS.

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

1. Acesse o 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 > Configure the agent parameters of the injected Sidecar.

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

Crie um namespace

1. Crie o namespace istio-egress. Para obter mais informações, consulte Manage global namespaces.

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.

Crie um egress gateway

No ASM, crie um egress gateway 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 obter mais informações, consulte Create an egress gateway service.

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

Crie um aplicativo de exemplo

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

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 seguinte comando para implantar os serviços sleep-a e nginx:

      kubectl apply -f test.yaml

3. Execute os seguintes comandos 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

   A saída de ambos os comandos é 502, indicando que o acesso falhou.

Opção 1: HTTP em texto simples entre o sidecar e o egress gateway

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

• O gerenciamento de tráfego é aplicado principalmente no sidecar do cliente e não exige um egress gateway.

• A observabilidade não depende de um egress gateway.

• Os recursos de segurança dependem do egress gateway. No entanto, sem o mTLS, todos os recursos de autorização baseados na identidade do cliente são desativados. O egress gateway só pode rejeitar todas as solicitações.

Opção 2: mTLS entre o sidecar e o egress gateway (recomendado)

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Acesse o 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 egress gateway 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 ASMEgressTrafficPolicy CRD Reference.

      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 seu cluster ACK, execute o seguinte comando para criar o recurso ASMEgressTrafficPolicy.

      kubectl apply -f egress-by-egressgateway.yaml

2. Verifique se o ASMEgressTrafficPolicy entrou em vigor.

   1. Execute o seguinte comando 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 o esperado.

   2. Execute o seguinte comando 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 o esperado.

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

      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 acessar http://www.httpbin.org.

   Confirme que o ASMEgressTrafficPolicy está funcionando corretamente com esses resultados.

Opção 1: mTLS entre o sidecar e o egress gateway (recomendado)

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Acesse o 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 as definições relacionadas para acessar https://www.httpbin.org foram adicionados ao campo spec. Para descrições dos campos, consulte ASMEgressTrafficPolicy CRD reference.

      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 seguinte comando 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 seguinte comando 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 pode acessar http://www.httpbin.org.

      2. Execute o seguinte comando para solicitar o endpoint anything do httpbin.org e verificar se o egress gateway atualiza a solicitação HTTP para uma solicitação 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 egress gateway atualizou a solicitação para https antes de encaminhá-la para httpbin.org.

      3. Execute o seguinte comando 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 pode acessar https://www.httpbin.org.

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

      1. Execute o seguinte comando 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 não conseguiu acessar http://www.httpbin.org.

      2. Execute o seguinte comando 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 não conseguiu acessar https://www.httpbin.org.

      3. Visualize o log de acesso do sidecar da carga de trabalho Nginx executando o seguinte comando para identificar o motivo da recusa da 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 é encaminhada para o BlackHoleCluster, que rejeita a conexão.

   3. Exclua o egress-by-egressgateway executando os seguintes comandos e, em seguida, acesse 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.

   Confirme que o ASMEgressTrafficPolicy funciona conforme o esperado com esses resultados.

Opção 2: HTTPS entre o sidecar e o egress gateway

1. Crie um ASMEgressTrafficPolicy.

   Console

   1. Acesse o 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 as definições para acessar diretamente https://www.httpbin.org foram adicionados ao campo spec. Para obter 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 seguinte comando 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 seguinte comando 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 não conseguiu acessar http://www.httpbin.org.

      2. Execute o seguinte comando 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 pode acessar https://www.httpbin.org.

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

      1. Execute o seguinte comando 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 não conseguiu acessar http://www.httpbin.org.

      2. Execute o seguinte comando 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 não conseguiu acessar https://www.httpbin.org.

      3. Visualize o log de acesso do sidecar da carga de trabalho Nginx executando o seguinte comando para identificar o motivo da recusa da 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 é encaminhada para o BlackHoleCluster, que rejeita a conexão.

   3. Exclua o egress-by-egressgateway executando os seguintes comandos e, em seguida, acesse 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.

      Confirme que a configuração do ASMEgressTrafficPolicy funciona conforme o esperado com esses resultados.

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