Configure um gateway de egress unificado para segurança do mesh - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

Quando as aplicações no mesh precisam se comunicar com serviços externos, use um gateway de egress como ponto de saída centralizado para gerenciar todo o tráfego de saída. Configurar um gateway de egress permite aplicar controles de segurança e políticas de roteamento, o que melhora a segurança e a observabilidade das aplicações.

Importante

Antes de ler este artigo, certifique-se de conhecer o conteúdo em Use ASMEgressTrafficPolicy to manage egress traffic. Este tópico usa recursos do service mesh para interceptar transparentemente requisições destinadas a serviços fora do cluster e redirecioná-las a um gateway de egress. Em seguida, o gateway de egress aplica políticas de segurança e envia as requisições aos serviços externos ao cluster. Essa configuração é relativamente complexa. Se o conteúdo em Use ASMEgressTrafficPolicy to manage egress traffic não atender aos seus requisitos, consulte este artigo.

Pré-requisitos

Processo de configuração

配置流程

Etapa 1: Implantar uma aplicação de exemplo

Implante a aplicação sleep.

Crie um arquivo chamado sleep.yaml com o seguinte conteúdo.

sleep.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: sleep
---
apiVersion: v1
kind: Service
metadata:
  name: sleep
  labels:
    app: sleep
    service: sleep
spec:
  ports:
  - port: 80
    name: http
  selector:
    app: sleep
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sleep
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sleep
  template:
    metadata:
      labels:
        app: sleep
    spec:
      terminationGracePeriodSeconds: 0
      serviceAccountName: sleep
      containers:
      - name: sleep
        image: curlimages/curl
        command: ["/bin/sleep", "infinity"]
        imagePullPolicy: IfNotPresent
        volumeMounts:
        - mountPath: /etc/sleep/tls
          name: secret-volume
      volumes:
      - name: secret-volume
        secret:
          secretName: sleep-secret
          optional: true
---

Com o KubeConfig do cluster ACK, execute o comando abaixo para implantar a aplicação sleep.

Para mais informações sobre como usar o kubectl para gerenciar um cluster, consulte Obtain the KubeConfig of a cluster and use kubectl to connect to the cluster.
```
kubectl apply -f sleep.yaml
```

Execute os comandos abaixo para abrir um shell no pod sleep e acessar um serviço externo.

Execute o comando kubectl get pod -n default para visualizar o nome do pod sleep.
```
kubectl exec -it ${sleep-pod-name} -- /bin/sh
curl aliyun.com -I
```
Saída de exemplo:
```
HTTP/1.1 301 Moved Permanently
server: envoy
date: Thu, 14 Dec 2023 03:05:41 GMT
content-type: text/html
content-length: 239
location: https://aliyun.com/
eagleeye-traceid: 0b57ff8717025231418255220e****
timing-allow-origin: *
x-envoy-upstream-service-time: 69
```
Uma resposta 301 indica que a aplicação no mesh consegue acessar o serviço externo. Por padrão, o pod usa HTTP para acesso e o site retorna um redirecionamento.

Nota
Essa abordagem não oferece controle de segurança e impede o uso dos recursos de observabilidade do mesh. Recomendamos ativar REGISTRY_ONLY para restringir o acesso a serviços registrados e usar um gateway de egress como ponto de saída unificado para o tráfego, conforme descrito nas etapas a seguir.

(Opcional) Etapa 2: Ativar REGISTRY_ONLY

A política padrão de tráfego de saída do ASM é ALLOW_ANY. Recomendamos alterá-la para REGISTRY_ONLY. Nesse modo, o proxy sidecar bloqueia o acesso a qualquer host externo sem um ServiceEntry correspondente no mesh. Essa configuração aumenta a segurança da aplicação.

Nota

Se você ativar REGISTRY_ONLY mas não tiver criado um ServiceEntry para um serviço externo, o acesso a esse serviço será negado.
Caso não ative REGISTRY_ONLY e não tenha criado um ServiceEntry, ainda será possível acessar serviços externos, porém a configuração do gateway de egress não terá efeito.

Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
Na página Mesh Management, clique em o nome da instância ASM. No painel de navegação à esquerda, escolha Data Plane Component Management > Sidecar Proxy Setting.
Na página Configure the agent parameters of the injected Sidecar, clique em a aba global, clique em Outbound Traffic Policy, defina a Outbound Traffic Policy como REGISTRY_ONLY e clique em Update Settings.
Execute os comandos abaixo para abrir um shell no pod sleep e acessar o serviço externo.
```
kubectl exec -it ${sleep-pod-name} -- /bin/sh
curl aliyun.com -I
```
Saída de exemplo:
```
HTTP/1.1 502 Bad Gateway
date: Thu, 14 Dec 2023 03:08:46 GMT
server: envoy
transfer-encoding: chunked
```
Uma resposta 502 indica que as aplicações no mesh não conseguem acessar serviços externos não registrados.

Etapa 3: Criar um ServiceEntry para o serviço externo

Para acessar serviços fora do cluster pelo gateway de egress, crie um ServiceEntry para o serviço externo.

Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
Na página Mesh Management, clique em o nome da instância ASM. No painel de navegação à esquerda, escolha Cluster & Workload Management > External Service(ServiceEntry). Na página exibida, clique em Create from YAML.

Na página Create, selecione os Namespaces onde a aplicação sleep reside, selecione Access mesh external services para o Scenario Template, configure o YAML conforme o exemplo abaixo e clique em Create.

apiVersion: networking.istio.io/v1beta1
kind: ServiceEntry
metadata:
  name: external-svc-http
spec:
  hosts:
  - aliyun.com
  location: MESH_EXTERNAL
  ports:
  - number: 80
    name: http
    protocol: HTTP
  resolution: DNS

Execute os comandos abaixo para abrir um shell no pod sleep e acessar o serviço externo.
```
kubectl exec -it ${sleep-pod-name} -- /bin/sh
curl aliyun.com -I
```
Uma resposta 301 indica que a aplicação agora consegue acessar o serviço externo. Como você registrou aliyun.com com um ServiceEntry no mesh, o acesso é permitido. Neste momento, o tráfego de saída ainda flui diretamente do pod, sem passar pelo gateway de egress.

Etapa 4: Roteie o tráfego pelo gateway de egress

Após criar um ServiceEntry para aliyun.com, use recursos como VirtualService e Gateway para gerenciar o tráfego destinado a aliyun.com.

Crie um gateway de egress que escute tráfego HTTP na porta 80. Para mais informações, consulte Create an egress gateway.
Crie um recurso Gateway conforme descrito abaixo. Para mais informações, consulte Manage Istio gateways.

Na página de criação do Gateway, defina o Namespace como default e o Name como egress-gw. Na área Gateway instance, defina a Label key como istio e o Label value como egressgateway. Na área Exposed services, defina o Name do serviço como http, a Port como 80, o Protocol como HTTP e o Service Domain como aliyun.com. Em seguida, clique em Create.

Use o YAML abaixo para criar um VirtualService. Para mais informações, consulte Manage VirtualServices.

VirtualService YAML

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: egressgateway-vs
spec:
  hosts:
  - aliyun.com
  gateways:
  - egress-gw  # The name of the Gateway you created in the previous step.
  - mesh
  http:
  - match:
    - gateways:
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        port:
          number: 80
      weight: 100
  - match:
    - gateways:
      - egress-gw
      port: 80
    route:
    - destination:
        host: aliyun.com
        port:
          number: 80
      weight: 100

Teste o acesso ao serviço externo.
1. Execute os comandos abaixo para abrir um shell no pod sleep e acessar o serviço externo.
```
kubectl exec -it ${sleep-pod-name} -- /bin/sh
curl aliyun.com -I
```
  Uma resposta 301 indica que a aplicação ainda consegue acessar o serviço externo. Agora, a aplicação roteia o tráfego pelo gateway de egress em vez de acessar o serviço diretamente do pod.
2. Execute o comando abaixo para verificar os logs de acesso no pod do gateway.
  Nota
  
  Se o gateway de egress possuir múltiplas réplicas, o log de acesso poderá aparecer em qualquer uma delas. Talvez seja necessário verificar cada pod do gateway para encontrar a entrada.
  
  Caso tenha ativado o registro de logs de acesso para o gateway de egress, também é possível visualizar os registros no console do Simple Log Service.
```
kubectl -n istio-system logs ${egress-gateway-pod-name} -c istio-proxy | grep aliyun.com | tail -n 1
```
  Saída de exemplo:
```
{"trace_id":null,"upstream_host":"106.11.XXX.XX:80","downstream_remote_address":"10.34.0.140:47942","requested_server_name":null,"response_code":301,"upstream_service_time":"24","user_agent":"curl/7.86.0-DEV","path":"/","route_name":null,"bytes_sent":0,"response_flags":"-","upstream_local_address":"10.34.0.141:60388","duration":24,"upstream_cluster":"outbound|80||aliyun.com","upstream_transport_failure_reason":null,"authority":"aliyun.com","request_id":"55789d59-9b81-4e39-b64a-66baf44e****","protocol":"HTTP/1.1","bytes_received":0,"method":"HEAD","downstream_local_address":"10.34.0.141:80","start_time":"2022-11-30T08:03:01.315Z","istio_policy_status":null,"x_forwarded_for":"10.34.0.140"}
```
  O campo downstream_remote_address exibe o endereço IP do pod sleep.
  
  Após concluir essas etapas, todo o tráfego de saída destinado ao serviço externo será roteado pelo gateway de egress.

Documentos relacionados

Use as capacidades de observabilidade e segurança do ASM em um gateway de egress para gerenciar o tráfego de saída com mais eficiência. Para mais informações, consulte Observability capabilities e Security support and dynamic certificate loading.
Use o CRD ASMEgressTrafficPolicy para personalizar o gerenciamento e o acesso ao tráfego externo por um gateway de egress. Para mais informações, consulte Use ASMEgressTrafficPolicy to manage egress traffic.
Para mais detalhes sobre os recursos do gateway, consulte Overview of ASM gateways.