Use eRDMA in Docker containers to allow applications to directly access physical devices and improve data transmission and communication efficiency - Elastic Compute Service: Central de Documentação do Alibaba Cloud

Mapeie dispositivos eRDMA em contêineres Docker ou use o eRDMA Controller para expô-los a pods em um cluster Kubernetes autogerenciado.

Limitações

O eRDMA no Docker oferece suporte apenas às seguintes imagens.

Alibaba Cloud Linux 3, Ubuntu 22.04 e Ubuntu 24.04 (ARM e x86)
Alibaba Cloud Linux 2, CentOS 7, CentOS 8, Ubuntu 18.04, Ubuntu 20.04 e Ubuntu 24.04 (apenas x86)

Nota

As imagens do Anolis OS não são compatíveis.

Como funciona

Use a opção --device do Docker para mapear os dispositivos de caractere /dev/infiniband/rdma_cm e /dev/infiniband/uverbsX para o contêiner. Dessa forma, os programas em modo de usuário podem ignorar o kernel e acessar diretamente o dispositivo eRDMA.

/dev/infiniband/rdma_cm: dispositivo de caractere para gerenciamento de conexões eRDMA, que inclui a criação e destruição de conexões, além do tratamento de eventos de conexão.
/dev/infiniband/uverbsX: dispositivo de caractere para operações eRDMA no espaço de usuário, que inclui a abertura do dispositivo, o gerenciamento de endpoints de comunicação e o registro de buffers de memória.

Nota
/dev/infiniband/uverbsX: X é o número de índice do dispositivo. Execute ls /dev/infiniband | grep uverbs para encontrar o nome do dispositivo.

Configurar o eRDMA em um contêiner Docker

Etapa 1: Configurar o eRDMA para a instância

Verifique se o tipo de instância é compatível com o eRDMA, se uma Elastic RDMA Interface está anexada, se o driver eRDMA está implantado e se o dispositivo eRDMA funciona corretamente.

Instâncias de CPU de nível empresarial: consulte {{XREF_0}}.
Instâncias aceleradas por GPU: consulte {{XREF_1}}.

Etapa 2: (Opcional) Implantar o Docker na instância

Ignore esta etapa se o Docker já estiver instalado na instância.

Conecte-se à instância. Consulte {{XREF_2}}.
Verifique se o Docker está instalado.
```
kubectl apply -f example.yaml
```
Se o Docker estiver instalado, o sistema retornará um número de versão:
```
kubectl apply -f example.yaml
```
Se não estiver instalado, prossiga para {{XREF_3}}.
```
kubectl apply -f example.yaml
```
Implante o Docker na instância.
- Alibaba Cloud Linux ou CentOS: consulte {{XREF_4}}.
- Ubuntu: consulte a documentação do Ubuntu.

Etapa 3: (Opcional) Implantar uma imagem para o Docker

Ignore esta etapa se o seu ambiente Docker já possuir uma imagem base.

O exemplo a seguir baixa uma imagem base do Alibaba Cloud Linux. É necessário acesso à internet.

{{XREF_5}}.
Baixe uma imagem Docker do Alibaba Cloud Linux.
```
kubectl apply -f example.yaml
```
- <image_version>: a versão do Alibaba Cloud Linux, como 2 ou 3.
- <region_ID>: o ID da região da imagem, como cn-hangzhou.
- (Opcional) <TAG>: a tag da imagem Docker. O padrão é a versão mais recente, caso seja omitida.
Encontrar informações de região e tag da imagem
1. Acesse o Container Registry - Artifact Center.
2. Clique em alinux2/alinux2 ou alinux3/alinux3 para visualizar as informações de tag da imagem Docker do Alibaba Cloud Linux 2 e do Alibaba Cloud Linux 3.
  
  Por exemplo, a figura a seguir mostra os detalhes da imagem Docker do Alibaba Cloud Linux 3. ① indica a região da imagem e ② indica as tags da imagem.
Comandos de exemplo:
- Baixe a tag 220901.1 da imagem Docker do Alibaba Cloud Linux 3 na região cn-hangzhou.
```
kubectl apply -f example.yaml
```
- Baixe a imagem Docker mais recente do Alibaba Cloud Linux 2 na região cn-hangzhou.
```
kubectl apply -f example.yaml
```
Verifique a imagem baixada.
```
kubectl apply -f example.yaml
```
A saída confirma que a imagem 220901.1 do Alibaba Cloud Linux 3 e a imagem mais recente do Alibaba Cloud Linux 2 foram baixadas.

Etapa 4: Iniciar o contêiner e anexar o dispositivo eRDMA

Use a opção --device do Docker para mapear os dispositivos de caractere /dev/infiniband/rdma_cm e /dev/infiniband/uverbsX para o contêiner. Consulte {{XREF_6}}.

Conecte-se à instância ECS. Consulte {{XREF_7}}.
Inicie um contêiner Docker e mapeie os dispositivos de caractere eRDMA para ele.
```
kubectl apply -f example.yaml
```
Parâmetros:
- --net=host: define o modo de rede do contêiner como host. Os aplicativos no contêiner compartilham as interfaces e configurações de rede do host.
- --device=/dev/infiniband/uverbsX e --device=/dev/infiniband/rdma_cm: expõem os dispositivos de caractere em modo de usuário do eRDMA para o contêiner.
  
  Visualize o nome do dispositivo de caractere (o X em uverbsX ):
```
kubectl apply -f example.yaml
```
```
kubectl apply -f example.yaml
```
- --ulimit memlock=-1: define maxlockedmemory como unlimited, permitindo que usuários sem privilégios de root bloqueiem memória suficiente para as operações do eRDMA.
- <IMAGE ID>: o ID da imagem Docker. Execute sudo docker images para visualizá-lo.
  
  Visualize o ID da imagem de destino:
```
kubectl apply -f example.yaml
```
  Este exemplo usa a imagem do Alibaba Cloud Linux de {{XREF_8}}. Saída de exemplo:
```
kubectl apply -f example.yaml
```
Comando de exemplo
```
kubectl apply -f example.yaml
```

Etapa 5: Implantar o pacote de driver eRDMA para o contêiner Docker

O pacote de driver em modo de usuário do eRDMA também deve ser implantado no contêiner. Sem ele, não é possível detectar os dispositivos eRDMA de dentro do contêiner. O Alibaba Cloud fornece fontes yum e apt para facilitar a instalação.

Conecte-se à instância. Consulte {{XREF_9}}.
Entre no contêiner de destino.

Se você executou o comando em {{XREF_10}}, já está dentro do contêiner. Prossiga para {{XREF_11}}.
1. Visualize o ID do contêiner de destino.
```
kubectl apply -f example.yaml
```
  Este exemplo usa o contêiner de {{XREF_12}}. Saída de exemplo:
  
  O ID do contêiner de destino é b4ec2fbaedf7 (o contêiner do Alibaba Cloud Linux 3 iniciado na Etapa 4).
```
kubectl apply -f example.yaml
```
2. Entre no contêiner.
```
kubectl apply -f example.yaml
```
  Substitua CONTAINER ID pelo ID do contêiner de destino da etapa anterior.
Instale o pacote de driver em modo de usuário no contêiner.

Importante
Nos exemplos a seguir, http://mirrors.cloud.aliyuncs.com é um endereço de fonte interno. Para acessar a fonte pela internet, substitua http://mirrors.cloud.aliyuncs.com por https://mirrors.aliyun.com. O acesso à internet pode gerar taxas de tráfego. Consulte {{XREF_13}}.
CentOS 7/CentOS 8
1. Crie um arquivo de fonte erdma.repo em /etc/yum.repos.d.
```
kubectl apply -f example.yaml
```
2. Adicione o seguinte conteúdo ao erdma.repo e salve o arquivo.
```
kubectl apply -f example.yaml
```
3. Atualize o cache da fonte yum.
```
kubectl apply -f example.yaml
```
4. Instale o pacote de driver em modo de usuário.
```
kubectl apply -f example.yaml
```
Alibaba Cloud Linux
1. Adicione o repositório.
```
kubectl apply -f example.yaml
```
  Nota
  Se o yum-config-manager não estiver instalado, execute sudo yum install -y yum-utils para instalá-lo. O yum-config-manager faz parte do pacote yum-utils.
2. Atualize o cache da fonte yum.
```
kubectl apply -f example.yaml
```
3. Instale o pacote de driver em modo de usuário.
```
kubectl apply -f example.yaml
```
Ubuntu 18.04/20.04/22.04/24.04
1. Adicione a assinatura PGP.
  - Ubuntu 18.04/Ubuntu 20.04
    
    kubectl apply -f example.yaml
  - Ubuntu 22.04/24.04
    
    kubectl apply -f example.yaml
2. Adicione a fonte apt.
  - Ubuntu 18.04
    
    kubectl apply -f example.yaml
  - Ubuntu 20.04
    
    kubectl apply -f example.yaml
  - Ubuntu 22.04
    
    kubectl apply -f example.yaml
  - Ubuntu 24.04
    
    kubectl apply -f example.yaml
3. Atualize a fonte apt.
```
kubectl apply -f example.yaml
```
4. Instale o driver em modo de usuário.
```
kubectl apply -f example.yaml
```
Visualize as informações do dispositivo eRDMA de dentro do contêiner.
```
kubectl apply -f example.yaml
```
```
kubectl apply -f example.yaml
```
O sistema detecta o dispositivo eRDMA de dentro do contêiner.

Para integrar o eRDMA a aplicativos TCP dentro do contêiner com SMC-R ou NetACC, consulte {{XREF_14}}.

Usar o eRDMA Controller para implantar um pod eRDMA em um cluster Kubernetes autogerenciado

Etapa 1: Instalar o eRDMA Controller

Instale o Helm no nó mestre.

O Helm gerencia a instalação e a desinstalação dos componentes do eRDMA Controller. Após a instalação, execute helm version para verificar.
```
kubectl apply -f example.yaml
```
Baixe o código-fonte do eRDMA Controller no nó mestre.
```
kubectl apply -f example.yaml
```
O arquivo de configuração de instalação é deployment/helm/values.yaml. Modifique este arquivo para selecionar um modo de operação e configurar os parâmetros. Há suporte para dois modos:
- Modo Regular: o eRDMA Controller gerencia automaticamente as Elastic RDMA Interfaces (ERIs) e aloca dinamicamente os recursos do eRDMA.
- Modo Local: o ambiente eRDMA já está preparado nos nós do Kubernetes e os dispositivos eRDMA estão expostos aos pods. Não há gerenciamento dinâmico de recursos envolvido.
Itens de configuração:
- localERIDiscovery: o modo de operação do controller.
  - true: Modo Local.
  - false: Modo Regular (padrão).
- credentials: no Modo Regular, o controller acessa as APIs do Alibaba Cloud para consultar e configurar instâncias ECS e ENIs. Crie uma função RAM e conceda as permissões necessárias primeiro.
  
  Há suporte para autenticação AccessKey. Defina type como access_key e insira o AccessKey ID e o secret.
```
kubectl apply -f example.yaml
```
  Não é necessário no Modo Local.
- preferDriver: o tipo de driver eRDMA para o nó.
  - default: modo de driver padrão.
  - compat: modo de driver compatível com RoCE.
  - ofed: modo de driver baseado em OFED, adequado para tipos de instância acelerados por GPU.
- allocateAllDevices: política de alocação de dispositivos no Modo Regular.
  - true: aloca todos os dispositivos eRDMA no nó para o pod.
  - false: aloca um dispositivo eRDMA com base na topologia NUMA.
- exposedLocalERIs: os dispositivos eRDMA no nó a serem expostos aos pods no Modo Local. Consulte o exemplo para o formato de configuração.
```
kubectl apply -f example.yaml
```
- Configuração de imagem: a imagem padrão do erdma-agent (registry.aliyuncs.com/erdma/agent) não é compatível com o Modo Local. Crie uma imagem de agente e envie-a para um repositório de imagens personalizado.
  
  Crie e envie a imagem. O exemplo usa o Alibaba Cloud Container Registry (ACR). Crie um namespace e um repositório de imagens antecipadamente.
```
kubectl apply -f example.yaml
```
Instale o componente erdma-controller com o helm.
```
kubectl apply -f example.yaml
```
Verifique a instalação.
- No Modo Regular, verifique se os pods erdma-agent e erdma-controller foram criados:
```
kubectl apply -f example.yaml
```
  Consulte os recursos do dispositivo eRDMA no nó:
```
kubectl apply -f example.yaml
```
- No Modo Local, apenas o pod erdma-agent é criado. O pod erdma-controller e os recursos erdmadevices não ficam disponíveis.

Etapa 2: Criar um pod com suporte a aceleração de rede eRDMA

Declare aliyun/erdma: 1 em resources.limits da especificação do contêiner. Substitua <ERDMA_POD_IMAGE> pelo endereço da imagem do seu contêiner:
```
kubectl apply -f example.yaml
```
Para ativar a aceleração transparente com SMC-R, adicione a anotação network.alibabacloud.com/erdma-smcr: "true" . Requer o Alibaba Cloud Linux 3 com kernel 5.10.134-17 ou superior.
Implante o deployment com base no arquivo de configuração. O deployment inicia o número especificado de réplicas de pod.
```
kubectl apply -f example.yaml
```

Referências

Para configurar o eRDMA em um cluster ACK, consulte {{XREF_15}}.