Use an Ingress controller to mirror network traffic - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O espelhamento de tráfego, também conhecido como shadowing, envia uma cópia do tráfego em tempo real do cluster de produção para um cluster de staging sem afetar o caminho principal da requisição. Use essa técnica para executar testes de estresse ou solucionar problemas de produção sem interromper seus serviços.

Este guia demonstra como configurar o controlador NGINX Ingress para espelhar 100% do tráfego de um cluster Container Service for Kubernetes (ACK) para outro.

Pré-requisitos

Antes de começar, verifique se você tem:

Dois clusters ACK: um para produção (K8s Product Cluster) e outro para staging (K8s Stage Cluster). Consulte Criar um cluster gerenciado ACK
O controlador NGINX Ingress v1.2.1 ou posterior instalado. Consulte Gerenciar o controlador NGINX Ingress
kubectl configurado com o arquivo kubeconfig de cada cluster. Consulte Conectar-se a clusters ACK usando kubectl

Casos de uso

Testes de estresse antes do lançamento: Espelhe o tráfego de produção para staging para simular cargas de trabalho reais, incluindo tráfego anômalo, antes de liberar um novo sistema. Essa abordagem fornece um perfil de carga mais preciso do que benchmarks sintéticos.
Solução de problemas de produção: Se não for possível identificar um gargalo de desempenho em produção, espelhe o tráfego para staging para reproduzir e diagnosticar o problema com segurança.

Como funciona

Todas as requisições destinadas a example.com no cluster de produção são replicadas e enviadas para example1.com no cluster de staging. O cluster de staging recebe o tráfego espelhado sem alterações no roteamento do cluster de produção.

Architecture diagram showing traffic mirroring between K8s Product Cluster and K8s Stage Cluster

O controlador NGINX Ingress usa a anotação nginx.ingress.kubernetes.io/mirror-target para duplicar requisições para um destino especificado. Use a anotação mirror-host para definir o valor exato do cabeçalho Host na requisição espelhada.

Anotações de espelhamento

Anotação	Tipo	Descrição
`nginx.ingress.kubernetes.io/mirror-target`	string	URL de destino para o tráfego espelhado. Aplica-se apenas a HTTP e HTTPS. Consulte a documentação de mirror do ingress-nginx.
`nginx.ingress.kubernetes.io/mirror-host`	string	Substitui o cabeçalho `Host` da requisição espelhada.
`nginx.ingress.kubernetes.io/mirror-request-body`	string	Defina como `"off"` para excluir o corpo da requisição do tráfego espelhado. Remova esta anotação para incluir o corpo.

Etapa 1: Implantar uma aplicação no cluster de staging

Implante uma aplicação receptora no K8s Stage Cluster. Essa implantação fornece um destino para o tráfego espelhado. Não altere nenhuma configuração do cluster de produção nesta etapa.

Crie o arquivo my-nginx.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: NodePort
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
spec:
  rules:
  - host: example1.com
    http:
      paths:
      - path: /
        backend:
          service:
            name: nginx-service
            port:
              number: 80
        pathType: ImplementationSpecific

Implante a aplicação:
```
kubectl apply -f my-nginx.yaml
```
Verifique se o Ingress recebeu um endereço IP externo:
```
kubectl get ing nginx-ingress
```
Saída esperada:
```
NAME            HOSTS         ADDRESS       PORTS   AGE
nginx-ingress   example1.com  47.**.**.53   80      8m
```
Anote o valor de ADDRESS (47.**.**.53). Você usará esse endereço IP ao configurar o espelhamento de tráfego na Etapa 2.
Confirme se a aplicação de staging está acessível:
```
curl http://example1.com
```

Etapa 2: Configurar o espelhamento de tráfego no cluster de produção

Implante a aplicação e o Ingress no K8s Product Cluster e adicione as anotações de espelhamento para redirecionar uma cópia de todo o tráfego para o cluster de staging.

Crie o arquivo my-nginx.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx
  type: NodePort

Implante a aplicação:
```
kubectl apply -f my-nginx.yaml
```

Crie o arquivo my-ingress.yaml com as anotações de espelhamento. Substitua 47.**.**.53 pelo valor de ADDRESS obtido na Etapa 1 e example1.com pelo valor de HOSTS do cluster de staging:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/mirror-target: "http://47.**.**.53$request_uri"
    nginx.ingress.kubernetes.io/mirror-request-body: "off"
    nginx.ingress.kubernetes.io/mirror-host: "example1.com"
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        backend:
          service:
            name: nginx-service
            port:
              number: 80
        pathType: ImplementationSpecific

Implante o Ingress:
```
kubectl apply -f my-ingress.yaml
```

Verifique se o Ingress de produção está ativo:

kubectl get ing nginx-ingress

Saída esperada:

NAME            HOSTS        ADDRESS       PORTS   AGE
nginx-ingress   example.com  39.**.**.54   80      1m

Confirme se a aplicação de produção está acessível:
```
curl http://example.com
```

Verificar o espelhamento de tráfego

Envie uma requisição para o domínio de produção e verifique os logs do controlador NGINX Ingress para confirmar se o tráfego está sendo duplicado para o cluster de staging.

Envie uma requisição para a aplicação de produção:
```
curl http://example.com
```
Verifique os logs do controlador NGINX Ingress no namespace kube-system do K8s Product Cluster:
```
kubectl -n kube-system logs --tail=0 -f nginx-ingress-controller-674c96ffbc-9mc8n
```
A saída de log mostra entradas duplicadas: uma para a requisição original destinada a example.com e outra para a requisição espelhada encaminhada ao cluster de staging.