Acelere o desempenho de rede pod a pod no ASM com eRDMA - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

O Alibaba Cloud Linux 3 oferece o Shared Memory Communication (SMC), uma pilha de protocolos de rede do kernel de alto desempenho compatível com a camada de socket. Essa tecnologia usa Remote Direct Memory Access (RDMA) para otimizar transparentemente o desempenho de rede de aplicações TCP. No entanto, ao usar o SMC para otimizar o desempenho em um ambiente ECS nativo, mantenha cuidadosamente a lista de permissões e as configurações do SMC nos namespaces de rede dos contêineres para evitar que o SMC sofra degradação inesperada para TCP. O ASM fornece um ambiente controlado (dentro do cluster) para a otimização via SMC. Ele otimiza automaticamente o tráfego entre pods na malha de serviços e elimina a necessidade de gerenciar configurações específicas do SMC.

Pré-requisitos

O cluster foi adicionado à instância do ASM.

Limitações

Os nós devem ser instâncias ECS com suporte a eRDMA. Para mais informações, consulte Ativar eRDMA para instâncias de nível empresarial.
Os nós devem executar o Alibaba Cloud Linux 3. Para mais detalhes, consulte Alibaba Cloud Linux 3.
A versão da instância do ASM deve ser 1.23 ou superior. Para saber como atualizar uma instância, consulte Atualizar uma instância do ASM.
O cluster ACK deve usar o plug-in de rede Terway. Para mais informações, consulte Usar o plug-in de rede Terway.
O cluster ACK deve permitir acesso à internet ao servidor de API. Para mais informações, consulte Controlar o acesso à internet ao servidor de API.

Procedimento

Etapa 1: Inicializar o ambiente do nó

O SMC usa a interface elástica RDMA para acelerar o desempenho da rede. Antes de ativar o SMC, inicialize os nós.

Verifique se a versão do kernel do Alibaba Cloud Linux 3 é 5.10.134-17.3 ou superior. Para obter instruções sobre como atualizar o kernel, consulte Alterar a versão do kernel.
Instale o componente erdma-controller nos nós e ative a aceleração transparente para SMC-R. Para mais informações, consulte Usar eRDMA para acelerar a rede de contêineres.

Etapa 2: Implantar a aplicação de teste

Ative a injeção automática de proxy sidecar no namespace default usado para testes. Para mais informações, consulte Ativar injeção automática de sidecar.

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

fortioserver.yaml

---
apiVersion: v1
kind: Service
metadata:
  name: fortioserver
spec:
  ports:
  - name: http-echo
    port: 8080
    protocol: TCP
  - name: tcp-echoa
    port: 8078
    protocol: TCP
  - name: grpc-ping
    port: 8079
    protocol: TCP
  selector:
    app: fortioserver
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: fortioserver
  name: fortioserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fortioserver
  template:
    metadata:
      labels:
        app: fortioserver
      annotations:
        sidecar.istio.io/inject: "true"
        sidecar.istio.io/proxyCPULimit: 2000m
        proxy.istio.io/config: |
          concurrency: 2 
    spec:
      shareProcessNamespace: true
      containers:
      - name: captured
        image: fortio/fortio:latest_release
        ports:
        - containerPort: 8080
          protocol: TCP
        - containerPort: 8078
          protocol: TCP
        - containerPort: 8079
          protocol: TCP
      - name: anolis
        securityContext:
          runAsUser: 0
        image: openanolis/anolisos:latest
        args:
        - /bin/sleep
        - 3650d
---
apiVersion: v1
kind: Service
metadata:
  annotations:
      service.beta.kubernetes.io/alibaba-cloud-loadbalancer-health-check-switch: "off"
  name: fortioclient
spec:
  ports:
  - name: http-report
    port: 8080
    protocol: TCP
  selector:
    app: fortioclient
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: fortioclient
  name: fortioclient
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fortioclient
  template:
    metadata:
      annotations:
        sidecar.istio.io/inject: "true"
        sidecar.istio.io/proxyCPULimit: 4000m
        proxy.istio.io/config: |
           concurrency: 4
      labels:
        app: fortioclient
    spec:
      shareProcessNamespace: true
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - fortioserver
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: captured
        volumeMounts:
        - name: shared-data
          mountPath: /var/lib/fortio
        image: fortio/fortio:latest_release
        ports:
        - containerPort: 8080
          protocol: TCP
      - name: anolis
        securityContext:
          runAsUser: 0
        image: openanolis/anolisos:latest
        args:
        - /bin/sleep
        - 3650d
      volumes:
      - name: shared-data
        emptyDir: {}

Com o arquivo kubeconfig do cluster ACK, execute o comando abaixo para implantar a aplicação de teste:
```
kubectl apply -f fortioserver.yaml
```

Execute o seguinte comando para verificar o status da aplicação de teste.

kubectl get pods | grep fortio

Saída esperada:

NAME                            READY   STATUS    RESTARTS      
fortioclient-8569b98544-9qqbj   3/3     Running   0
fortioserver-7cd5c46c49-mwbtq   3/3     Running   0

Essa saída confirma que ambas as aplicações estão em execução.

Etapa 3: Executar um teste de linha de base

Após a inicialização, a aplicação Fortio escuta na porta 8080. Acesse essa porta para abrir o console web do Fortio. Para gerar tráfego de teste, use o port-forwarding para mapear a porta do serviço fortioclient para sua máquina local e abra o console do Fortio.

Use o kubeconfig do cluster ACK para executar o comando a seguir e encaminhar a porta 8080 do serviço fortioclient para a porta 8080 da sua máquina local.
```
kubectl port-forward service/fortioclient 8080:8080
```

No navegador, acesse http://localhost:8080/fortio para abrir o console do cliente Fortio e modificar os parâmetros de teste.

Após configurar os parâmetros, clique em Start na parte inferior da página do console Fortio para iniciar o teste de carga.

Modifique os parâmetros na página conforme descrito na tabela a seguir.

Parâmetro	Valor
URL	http://fortioserver:8080/echo
QPS	100000
Duration	30s
Threads/simultaneous connections	64
Payload	Insira a seguinte string de 128 bytes: xhsyL4ELNoUUbC3WEyvaz0qoHcNYUh0j2YHJTpltJueyXlSgf7xkGqc5RcSJBtqUENNjVHNnGXmoMyILWsrZL1O2uordH6nLE7fY6h5TfTJCZtff3Wib8YgzASha8T8g

Concluída a configuração, clique em Start na parte inferior da página para iniciar o teste. Aguarde a conclusão da barra de progresso.

Ao final do teste, os resultados serão exibidos na página. A figura a seguir serve apenas como referência. Os resultados reais podem variar dependendo do seu ambiente.

O gráfico de resultados exibe a latência das requisições no eixo x e o número de requisições concluídas no eixo y. A distribuição das barras mostra a distribuição da latência, enquanto a curva roxa indica o número de requisições concluídas dentro de faixas específicas de tempo de resposta. O gráfico também lista os dados de latência P50, P75, P90, P99 e P99,9. Após obter esses dados de linha de base, ative o SMC para medir a melhoria de desempenho proporcionada pela aceleração.

Etapa 4: Ativar a aceleração SMC

Use o kubeconfig da malha de serviços para editar a configuração da malha. Adicione smcEnabled: true para ativar o recurso de aceleração SMC.

$ kubectl edit asmmeshconfig
apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMMeshConfig
metadata:
  name: default
spec:
  ambientConfiguration:
    redirectMode: ""
    waypoint: {}
    ztunnel: {}
  cniConfiguration:
    enabled: true
    repair: {}
  smcEnabled: true

Com o kubeconfig do cluster ACK, execute os comandos a seguir para modificar os Deployments fortioserver e fortioclient e adicionar uma anotação aos pods.

Depois de ativar a aceleração para a instância do ASM, ative-a também para as cargas de trabalho. Para isso, adicione a anotação smc.asm.alibabacloud.com/enabled: "true" aos pods. Ative a aceleração para as cargas de trabalho em ambas as extremidades da comunicação que deseja otimizar.
1. Edite a definição do Deployment fortioclient.
```
$ kubectl edit deployment fortioclient
apiVersion: apps/v1
kind: Deployment
metadata:
  ......
  name: fortioclient
spec:
  ......
  template:
    metadata:
      ......
      annotations:
        smc.asm.alibabacloud.com/enabled: "true"
        
```
2. Edite a definição do Deployment fortioserver.
```
$ kubectl edit deployment fortioserver
apiVersion: apps/v1
kind: Deployment
metadata:
  ......
  name: fortioserver
spec:
  ......
  template:
    metadata:
      ......
      annotations:
        smc.asm.alibabacloud.com/enabled: "true"
        
```

Etapa 5: Executar o teste acelerado

A modificação do Deployment reinicia as cargas de trabalho. Restabeleça o encaminhamento de porta para o serviço fortioclient conforme descrito na Etapa 3 e execute o teste novamente. Aguarde a conclusão do teste e visualize os resultados.

A comparação com os dados de linha de base demonstra que a ativação da aceleração SMC no ASM reduz a latência e aumenta significativamente o QPS.

Perguntas frequentes

Por que o acesso a alguns serviços de banco de dados trava e falha ao estabelecer conexão após a ativação do SMC?

Esse problema ocorre porque o tráfego para serviços de banco de dados geralmente passa por um balanceador de carga. Algumas implementações de balanceadores de carga não seguem rigorosamente os padrões de opções TCP e lidam incorretamente com a opção TCP do tipo 254 especificada no protocolo SMC. Isso causa falhas de conexão e impede o acesso ao serviço.

Para diagnosticar esse problema, execute as etapas a seguir:
1. Instale o kit de ferramentas aliyun-smc-extensions no nó:
```
sudo yum install -y aliyun-smc-extensions
```
2. Use o aliyunsmc-check para verificar o link de comunicação com a URL de destino:
```
aliyunsmc-check syn_check --url <url>
```
  O comando aliyunsmc-check verifica problemas de replay de opções TCP, conflitos e comprimento excessivo no caminho de acesso à URL de destino. Veja abaixo um exemplo da saída:
```
The check results mean:
PASS: pass the test or meet the requirement.
SKIP: encounter some problems when running the check.
FAIL: test failed or requirements are not met.
XXXX: information, e.g. smcr_tcp2smc config, ipv6_disable config,.
Check: syn_check
Begin to run syn checks. Please make sure scapy have been installed(python3 -m pip install scapy).
        Name              Result                          Desc                                       result info
---------------------- -------------------- ---------------------------------------------------- -------------------------------------------
 syn_option_replay          PASS             check whether smc option is replayed
 syn_option_conflict        PASS             check whether smc option kind is conflict
 syn_option_long            PASS             check whether syn options is overly long
```
Se a verificação confirmar o tratamento não padrão das opções TCP no caminho de acesso ao serviço, desative a aceleração SMC para o pod que acessa esse serviço.