Maximizar a largura de banda da rede da GPU em clusters no modo Autopilot

Nesta página, mostramos como maximizar a largura de banda e a capacidade de processamento para cargas de trabalho de GPU de alto desempenho nos clusters do Google Kubernetes Engine (GKE) Autopilot usando GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC e várias redes. Se você usa clusters padrão, consulte Maximizar a largura de banda da rede GPU em clusters no modo padrão.

Esta página é destinada a engenheiros de machine learning (ML) e administradores de plataforma que facilitam cargas de trabalho de ML. Para saber mais sobre papéis comuns e exemplos de tarefas que mencionamos no conteúdo do Trusted Cloud by S3NS , consulte Tarefas e funções de usuário comuns do GKE.

Aplicativos de inteligência artificial (IA), ML e computação de alto desempenho (HPC) exigem aceleração poderosa para otimizar o desempenho, reduzindo os tempos de conclusão de jobs. Por exemplo, os modelos de ML que se concentram em IA de conversação e geração de imagens exigem alta escalonabilidade e poder de computação.

Antes de ler esta página, confira se você conhece as tecnologias de rede, como placas de rede (NICs) e TCP, e as tecnologias de aceleração, como a Biblioteca de Comunicação Coletiva da NVIDIA (NCCL).

Sobre os supercomputadores de GPU Trusted Cloud

OTrusted Cloud tem supercomputadores otimizados para aceleradores que são desenvolvidos para modelos grandes e escalonáveis. Essas máquinas têm os seguintes benefícios:

  • Oito GPUs NVIDIA B200, H200 ou H100 por máquina.
  • Até 200 Gbps de largura de banda na placa de rede (NIC) principal.
  • NICs secundárias (até oito em tipos de máquina A3 Mega e até quatro em tipos de máquina A3 High), cada uma com suporte de largura de banda de até 200 Gbps para transferência de dados de GPU.

Sua carga de trabalho do GKE precisa usar todas as GPUs e NICs secundárias disponíveis em um único nó e usar uma parte significativa da largura de banda disponível. A solução descrita neste documento é ideal para cargas de trabalho que exigem alto desempenho, alta capacidade de processamento e baixa latência.

Recursos e funcionalidades necessários para maximizar a largura de banda

Para maximizar a largura de banda da rede nos nós de supercomputadores da GPU, use todos os recursos a seguir:

  • Pilha de rede GPUDirect: a série de máquinas A3 oferece suporte a três pilhas de rede para acesso direto à memória (RDMA, na sigla em inglês) personalizado e remoto:
    • Em tipos de máquina A3 High e GPUs NVIDIA H100, use o GPUDirect-TCPX para reduzir a sobrecarga necessária para transferir payloads de pacotes de e para GPUs, o que melhora significativamente a capacidade de processamento em escala em comparação com GPUs que não usam o GPUDirect.
    • Em tipos de máquina A3 Mega e GPUs NVIDIA H100 Mega, use o GPUDirect-TCPXO que melhora ainda mais a comunicação da GPU com a VM.
    • Em tipos de máquina A3 Ultra e GPUs NVIDIA H200, e tipos de máquina A4 e GPUs NVIDIA B200, use o GPUDirect RDMA para executar cargas de trabalho de IA distribuídas com mais melhorias na capacidade de processamento. Para começar, crie um cluster do GKE personalizado otimizado para IA.
  • gVNIC: ativa os recursos do GPUDirect, como divisão de cabeçalho de pacote, direcionamento de fluxo e gerenciamento de buffer. A gVNIC é necessária para usar o GPUDirect-TCPX ou o GPUDirect-TCPXO. Para detalhes sobre a gVNIC, consulte Aumentar a velocidade do tráfego de rede para nós da GPU.
  • Várias redes: adicione NICs secundárias à máquina otimizada para aceleradores. Cada placa de rede é associada a uma sub-rede separada na própria VPC para evitar conflitos. Para detalhes sobre o suporte a várias redes, consulte Configurar o suporte a várias redes para pods.
  • Políticas de posicionamento: use uma política de posicionamento de recursos para colocar todos os nós da GPU em uma carga de trabalho específica em servidores fisicamente próximos a fim de minimizar a latência. Para mais detalhes, consulte Definir um posicionamento compacto para nós do GKE.

Descrição do procedimento

Para usar todos esses recursos juntos, faça o seguinte:

  1. Crie nuvens privadas virtuais (VPC) e sub-redes
  2. Crie o ambiente do GKE.
  3. Instalar o binário GPUDirect e o plug-in NCCL
  4. Implantar o plug-in de injeção de dispositivo NRI
  5. Implante uma carga de trabalho de teste para verificar a configuração do GPUDirect

Antes de começar

Antes de começar, verifique se você realizou as seguintes tarefas:

  • Ativar a API Google Kubernetes Engine.
    • Ativar a API Google Kubernetes Engine
  • Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
  • Verifique se você tem cota suficiente para GPUs H100. Para solicitar mais cotas, consulte as cotas de GPU.

Requisitos

Os requisitos a seguir se aplicam a GPUDirect-TCPX e GPUDirect-TCPXO, a menos que indicado de outra forma.

  • Seu cluster precisa usar o GKE versão 1.31.1-gke.1621000 ou posterior.
  • Os nós da GPU precisam usar o driver da NVIDIA versão 535 ou mais recente.
  • É preciso usar o GKE Dataplane V2.
  • Para cargas de trabalho do GPUDirect-TCPX ou GPUDirect-TCPXO executadas em vários pools de nós, todos os pools precisam estar nas mesmas zonas do Compute Engine e usar os mesmos conjuntos de rede, como VPCs e sub-redes.

Limitações

Considere as seguintes limitações:

  • O GPUDirect-TCPX e o GPUDirect-TCPXO não são compatíveis com GPUs de várias instâncias, compartilhamento de tempo de GPU ou NVIDIA MPS.
  • Não é possível usar o NCCL FastSocket com GPUDirect-TCPX ou GPUDirect-TCPXO .
  • Sua carga de trabalho do GKE precisa usar todas as GPUs e NICs secundárias disponíveis em um único nó. Vários pods não podem usar GPUDirect-TCPX ou GPUDirect-TCPXO em um único nó.
  • Só é possível usar os tipos de máquina a3-highgpu-8g e a3-megagpu-8g. Outros tipos de máquina A3 não são compatíveis.

Criar VPCs e sub-redes

Crie redes VPC separadas no seu projeto para cada placa de rede virtual que você adicionar aos nós. Cada rede VPC precisa ter uma sub-rede e uma regra de firewall que permita o tráfego de rede interno.

  1. Crie as redes VPC para GPUDirect no projeto, cada uma com uma sub-rede e uma regra de firewall: Escolha a guia "GPUDirect-TCPX" para tipos de máquina A3 High ou a guia "GPUDirect-TCPXO" para tipos de máquina A3 Mega e siga estas instruções:

    GPUDirect-TCPXO

    Para maximizar a largura de banda, recomendamos que você crie oito novas redes.

    for N in $(seq 1 8); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Substitua:

    • PROJECT_ID: o ID do projeto do Trusted Cloud .
    • REGION: a região do Compute Engine para cada sub-rede.
    • SUBNET_RANGE: o intervalo de endereços IP de cada sub-rede na notação CIDR. Este comando de exemplo itera para oito sub-redes. Portanto, use uma variável para alterar o endereço IP de cada sub-rede. Por exemplo, especifique 192.168.$N.0/24 para que a primeira sub-rede use 192.168.1.0/24, a segunda use 192.168.2.0/24 e assim por diante.
    • SOURCE_RANGE: o intervalo de endereços IP de origem para que a regra de firewall permita o tráfego de entrada, na notação CIDR. Por exemplo, 192.168.0.0/16.

    GPUDirect-TCPX

    Para maximizar a largura de banda, recomendamos que você crie quatro novas redes.

    for N in $(seq 1 4); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Substitua:

    • PROJECT_ID: o ID do projeto do Trusted Cloud .
    • REGION: a região do Compute Engine para cada sub-rede.
    • SUBNET_RANGE: o intervalo de endereços IP de cada sub-rede na notação CIDR. Este comando de exemplo faz a iteração de quatro sub-redes. Portanto, use uma variável para alterar o endereço IP de cada sub-rede. Por exemplo, especifique 192.168.$N.0/24 para que a primeira sub-rede use 192.168.1.0/24, a segunda use 192.168.2.0/24 etc.
    • SOURCE_RANGE: o intervalo de endereços IP de origem para que a regra de firewall permita o tráfego de entrada, na notação CIDR. Por exemplo, 192.168.0.0/16.

  2. Verifique se as redes foram criadas:

    gcloud compute networks list

Crie o ambiente do GKE

Crie um novo cluster do GKE que use várias redes (pré-lançamento). Não é possível atualizar um cluster atual para usar várias redes.

GPUDirect-TCPXO

  1. Escolha uma versão disponível do GKE compatível com o GPUDirect-TCPXO. Para listar as versões, execute este comando:

    gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID

    Substitua:

    • REGION: a região de computação do plano de controle do cluster.
    • PROJECT_ID: o ID do projeto do Trusted Cloud .

  2. Crie um cluster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Substitua:

    • CLUSTER_NAME: o nome do novo cluster;
    • VERSION: uma versão do GKE que oferece suporte ao GPUDirect-TCPXO, conforme descrito em Requisitos.
    • LOCATION: o local do Compute Engine para o cluster.

  3. Crie recursos de rede e GKENetworkParamSet no cluster que correspondem às redes e sub-redes VPC que você criou:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc5
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc5
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc6
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc6
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc7
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc7
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc8
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc8
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PREFIX-net-5
  vpcSubnet: PREFIX-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PREFIX-net-6
  vpcSubnet: PREFIX-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PREFIX-net-7
  vpcSubnet: PREFIX-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PREFIX-net-8
  vpcSubnet: PREFIX-sub-8
  deviceMode: NetDevice
EOF

    Esses recursos orientam o GKE a configurar as placas de rede (NICs) para o tráfego da GPU no modo de passagem. O GKE não aplica a programação de rede integrada usando eBPF a esse tráfego.

GPUDirect-TCPX

  1. Crie um cluster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Substitua:

    • CLUSTER_NAME: o nome do novo cluster;
    • VERSION: uma versão do GKE que oferece suporte ao GPUDirect-TCPX, conforme descrito em Requisitos.
    • LOCATION: o local do Compute Engine para o cluster.

  2. Crie recursos de rede e GKENetworkParamSet no cluster que correspondem às redes e sub-redes VPC que você criou:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
EOF

    Esses recursos orientam o GKE a configurar as placas de rede (NICs) para o tráfego da GPU no modo de passagem. O GKE não aplica a programação de rede integrada usando eBPF a esse tráfego.

Instalar o binário GPUDirect e configurar o NCCL

Esta seção mostra como instalar o binário GPUDirect com base no tipo de máquina A3 (GPUDirect-TCPX para A3 High, GPUDirect-TCPXO para A3 Mega) e uma versão específica da biblioteca NCCL usando um DaemonSet.

GPUDirect-TCPXO

Esse DaemonSet faz o seguinte:

  1. Pré-instalação para configurar configurações relacionadas ao GPUDirect-TCPXO.
  2. Instala a biblioteca NCCL e o binário GPUDirect-TCPXO no nó.
  3. Armazena a biblioteca e o binário no diretório /home/kubernetes/bin/nvidia/lib64 na VM. Por padrão, o GKE monta esse diretório no caminho /usr/local/nvidia/lib64 nos contêineres de GPU que precisam usar o NCCL e o GPUDirect-TCPXO.

Para instalar o binário e configurar o NCCL, siga estas etapas:

  1. Revise o manifesto do Daemonset nccl-tcpxo-installer-autopilot.yaml no GitHub.

  2. Crie um namespace dedicado:

    kubectl create ns gpudirect-system

  3. Implante o DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer-autopilot.yaml

    O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

GPUDirect-TCPX

Esse DaemonSet faz o seguinte:

  1. Instala a biblioteca NCCL e o binário GPUDirect-TCPX no nó.
  2. Armazena a biblioteca e o binário no diretório /home/kubernetes/bin/nvidia/lib64 na VM. Por padrão, o GKE monta esse diretório no caminho /usr/local/nvidia/lib64 nos contêineres de GPU que precisam usar o NCCL e o GPUDirect-TCPX.

Para instalar o binário e configurar o NCCL, faça o seguinte:

  1. Revise o manifesto do Daemonset nccl-tcpx-installer-autopilot.yaml no GitHub.

  2. Crie um namespace dedicado:

    kubectl create ns gpudirect-system

  3. Implante o DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yaml

    O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

Implantar o plug-in de injeção de dispositivo NRI

Esta seção mostra como instalar o injetor de dispositivo NRI usando um DaemonSet. Os dois tipos de máquina com GPU H100 instalam o mesmo plug-in de injeção de dispositivo NRI. Esse plug-in faz o seguinte:

  1. Ativa a interface de recursos do nó (NRI) no nó que tem GPUs H100. A NRI é ativada por padrão no GKE versão 1.29 e mais recente.
  2. Implanta um contêiner de plug-in de injeção de dispositivo NRI que injeta dispositivos de GPU em contêineres especificados por anotações de pod.

Para instalar o plug-in, proceda da seguinte maneira:

  1. Revise o manifesto de implantação nri-device-injector-autopilot.yaml no GitHub.

  2. Implante o DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector-autopilot.yaml

    O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

Implantar uma carga de trabalho de teste

Nesta seção, você vai implantar uma carga de trabalho de amostra para verificar se o NCCL e o GPUDirect-TCPX ou o GPUDirect-TCPXO funcionam conforme o esperado. Esta carga de trabalho de exemplo faz o seguinte:

  1. Implanta dois pods, cada um executado em um nó que tem GPUs H100.
  2. Implanta um contêiner de arquivo secundário em cada pod para permitir que eles usem o GPUDirect-TCPXO ou o GPUDirect-TCPX.

Para implantar essa carga de trabalho de exemplo, faça o seguinte:

GPUDirect-TCPXO

Essa carga de trabalho inclui um contêiner de arquivo secundário chamado tcpxo-daemon, que executa um serviço que permite ao pod usar o GPUDirect-TCPXO. Você precisa adicionar esse contêiner de arquivo secundário a qualquer pod no seu próprio ambiente que precise usar GPUDirect-TCPXO. Para conferir um snippet dos campos obrigatórios a serem adicionados aos manifestos, consulte Adicionar GPUDirect ao manifesto.

  1. Revise o manifesto nccl-test-latest-autopilot.yaml no GitHub.

  2. Implante dois pods com a carga de trabalho de teste:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-test-latest-autopilot.yaml

  3. Depois que os pods forem implantados, acione um teste de todos os nós:

    kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2

    O resultado será assim:

    #                                                              out-of-place                       in-place
#        size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#         (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
            0             0     float    none      -1     0.24    0.00    0.00      0     0.18    0.00    0.00      0
            0             0     float    none      -1     0.19    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
          256             4     float    none      -1    235.2    0.00    0.00      0    235.1    0.00    0.00      0
          512             8     float    none      -1    241.0    0.00    0.00      0    236.1    0.00    0.00      0
         1024            16     float    none      -1    236.3    0.00    0.00      0    233.3    0.00    0.00      0
         2048            32     float    none      -1    234.1    0.01    0.01      0    233.4    0.01    0.01      0
         4096            64     float    none      -1    237.1    0.02    0.02      0    235.3    0.02    0.02      0
         8192           128     float    none      -1    236.2    0.03    0.03      0    235.2    0.03    0.03      0
        16384           256     float    none      -1    236.6    0.07    0.06      0    238.5    0.07    0.06      0
        32768           512     float    none      -1    237.9    0.14    0.13      0    238.8    0.14    0.13      0
        65536          1024     float    none      -1    242.3    0.27    0.25      0    239.4    0.27    0.26      0
       131072          2048     float    none      -1    263.0    0.50    0.47      0    275.1    0.48    0.45      0
       262144          4096     float    none      -1    279.2    0.94    0.88      0    269.9    0.97    0.91      0
       524288          8192     float    none      -1    273.5    1.92    1.80      0    273.5    1.92    1.80      0
      1048576         16384     float    none      -1    315.1    3.33    3.12      0    314.1    3.34    3.13      0
      2097152         32768     float    none      -1    319.2    6.57    6.16      0    311.5    6.73    6.31      0
      4194304         65536     float    none      -1    331.8   12.64   11.85      0    331.3   12.66   11.87      0
      8388608        131072     float    none      -1    356.3   23.54   22.07      0    353.8   23.71   22.23      0
     16777216        262144     float    none      -1    409.1   41.01   38.45      0    405.2   41.40   38.81      0
     33554432        524288     float    none      -1    451.4   74.34   69.69      0    447.7   74.94   70.26      0
     67108864       1048576     float    none      -1    713.4   94.07   88.19      0    713.8   94.01   88.13      0
    134217728       2097152     float    none      -1   1122.1  119.62  112.14      0   1116.3  120.23  112.72      0
    268435456       4194304     float    none      -1   1785.8  150.32  140.92      0   1769.2  151.72  142.24      0
    536870912       8388608     float    none      -1   2859.7  187.74  176.00      0   2852.6  188.20  176.44      0
   1073741824      16777216     float    none      -1   5494.1  195.44  183.22      0   5568.2  192.83  180.78      0
   2147483648      33554432     float    none      -1    10841  198.09  185.71      0    10798  198.88  186.45      0
   4294967296      67108864     float    none      -1    21453  200.21  187.70      0    21490  199.86  187.37      0
   8589934592     134217728     float    none      -1    42603  201.63  189.03      0    42670  201.31  188.73      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 45.7587
#

GPUDirect-TCPX

Essa carga de trabalho inclui um contêiner de arquivo secundário chamado tcpx-daemon, que executa um serviço que permite ao pod usar o GPUDirect-TCPX. Você precisa adicionar esse contêiner de arquivo secundário a qualquer pod no seu próprio ambiente que precise usar GPUDirect-TCPX. Para conferir um snippet dos campos obrigatórios a serem adicionados aos manifestos, consulte Adicionar GPUDirect ao manifesto.

  1. Revise o manifesto ConfigMap nccl-config.yaml no GitHub. Esse manifesto implanta scripts que inicializam um teste all-gather do NCCL e define configurações específicas do NCCL.

  2. Revise o manifesto de implantação nccl-test-latest-autopilot.yaml no GitHub.

  3. Implante o ConfigMap e a carga de trabalho de teste:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest-autopilot.yaml

  4. Execute os seguintes comandos para acionar um teste de todos os nós do NCCL:

    kubectl exec \
  --stdin --tty --container=nccl-test nccl-test-host-1 \
  -- /configs/allgather.sh nccl-host-1 nccl-host-2

    O resultado será assim:

    #                                                              out-of-place                       in-place
#       size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#        (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
    1048576         16384     float    none      -1    696.8    1.50    1.41      0    729.0    1.44    1.35      0
    2097152         32768     float    none      -1    776.4    2.70    2.53      0    726.7    2.89    2.71      0
    4194304         65536     float    none      -1    774.3    5.42    5.08      0    805.1    5.21    4.88      0
    8388608        131072     float    none      -1    812.1   10.33    9.68      0    817.6   10.26    9.62      0
   16777216        262144     float    none      -1   1035.2   16.21   15.19      0   1067.8   15.71   14.73      0
   33554432        524288     float    none      -1   1183.3   28.36   26.59      0   1211.8   27.69   25.96      0
   67108864       1048576     float    none      -1   1593.4   42.12   39.49      0   1510.5   44.43   41.65      0
  134217728       2097152     float    none      -1   2127.8   63.08   59.13      0   2312.7   58.03   54.41      0
  268435456       4194304     float    none      -1   3603.0   74.50   69.85      0   3586.2   74.85   70.17      0
  536870912       8388608     float    none      -1   7101.7   75.60   70.87      0   7060.9   76.03   71.28      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 29.8293

Usar as configurações necessárias do NCCL para melhorar o desempenho

Os pares de chave-valor a seguir são as configurações de configuração do NCCL necessárias para GPUDirect-TCPX e GPUDirect-TCPXO Ao implantar cargas de trabalho que usam o NCCL, defina-as como variáveis de ambiente para otimizar o desempenho.

GPUDirect-TCPXO


"NCCL_FASTRAK_CTRL_DEV=eth0",
"NCCL_FASTRAK_IFNAME=eth1,eth2,eth3,eth4,eth5,eth6,eth7,eth8",
"NCCL_SOCKET_IFNAME=eth0",
"NCCL_CROSS_NIC=0",
"NCCL_ALGO=Ring,Tree",
"NCCL_PROTO=Simple,LL128",
"NCCL_MIN_NCHANNELS=4",
"NCCL_TUNER_PLUGIN=libnccl-tuner.so",
"NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config.textproto",
"NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config.textproto",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_FASTRAK_NUM_FLOWS=2",
"NCCL_FASTRAK_USE_SNAP=1",
"NCCL_FASTRAK_PLUGIN_ACCEPT_TIMEOUT_MS=600000",
"NCCL_FASTRAK_ENABLE_CONTROL_CHANNEL=0",
"NCCL_BUFFSIZE=8388608",
"CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_FASTRAK_ENABLE_HOTPATH_LOGGING=0",
"NCCL_FASTRAK_USE_LLCM=1",
"NCCL_NVLS_ENABLE=0"

Também é possível definir todas as configurações de uma vez seguindo estas etapas:

  1. No manifesto do contêiner da carga de trabalho, adicione o seguinte par de chave-valor como uma variável de ambiente:

    NCCL_LIB_DIR="/usr/local/nvidia/lib64"

  2. Confira se o script nccl-env-profile.sh é executado quando o contêiner de carga de trabalho é iniciado. Por exemplo, você pode fazer isso na especificação do pod substituindo o comando do contêiner para incluir o seguinte:

    source ${NCCL_LIB_DIR}/nccl-env-profile.sh

Suporte a LL128

O protocolo de comunicação NVIDIA LL128 (baixa latência 128) NCCL pode melhorar significativamente a performance para coletivos de pequeno a médio porte. O GPUDirect-TCPXO é compatível com o protocolo LL128.

Para usar o LL128, verifique se o arquivo nccl-tcpxo-installer.yaml na seção "Instalar o binário GPUDirect e configurar o NCCL" usa a seguinte versão da imagem do contêiner ou uma mais recente:

us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1

Para configurar o LL128, faça o seguinte:

  • Para a versão do plug-in us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1 NCCL, siga estas etapas:

    1. No manifesto da carga de trabalho, defina a seguinte variável de ambiente:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configure sua carga de trabalho para executar o script nccl-env-profile-ll128.sh quando o contêiner for iniciado. No manifesto da carga de trabalho, defina o seguinte comando:

      source ${NCCL_LIB_DIR}/nccl-env-profile-ll128.sh

      O script nccl-env-profile-ll128.sh tem as seguintes variáveis de ambiente:

      NCCL_PROTO=Simple,LL128
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_ll128.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config_ll128.textproto

  • Para o plug-in NCCL us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1 versão e mais recentes, LL128 se torna um parâmetro padrão. Portanto, usar o script nccl-env-profile.sh ou nccl-env-profile-ll128.sh ativa o LL128. Para desativar o LL128:

    1. No manifesto da carga de trabalho, defina a seguinte variável de ambiente:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configure sua carga de trabalho para executar o script nccl-env-profile-ll128.sh quando o contêiner for iniciado. No manifesto da carga de trabalho, defina o seguinte comando:

      source ${NCCL_LIB_DIR}/nccl-env-profile-simple.sh

      O script nccl-env-profile-simple.sh tem as seguintes variáveis de ambiente:

      NCCL_PROTO=Simple
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto

GPUDirect-TCPX


"NCCL_SOCKET_IFNAME=\"eth0\"",
"NCCL_ALGO=Ring",
"NCCL_PROTO=Simple",
"NCCL_CROSS_NIC=0",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_P2P_PXN_LEVEL=0",
"NCCL_GPUDIRECTTCPX_SOCKET_IFNAME=eth1,eth2,eth3,eth4",
"NCCL_GPUDIRECTTCPX_CTRL_DEV=eth0",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_BUFFSIZE=4194304",
"NCCL_NSOCKS_PERTHREAD=4",
"NCCL_SOCKET_NTHREADS=1",
"NCCL_GPUDIRECTTCPX_TX_BINDINGS=\"eth1:8-21,112-125;eth2:8-21,112-125;eth3:60-73,164-177;eth4:60-73,164-177\"",
"NCCL_GPUDIRECTTCPX_RX_BINDINGS=\"eth1:22-35,126-139;eth2:22-35,126-139;eth3:74-87,178-191;eth4:74-87,178-191\"",
"NCCL_GPUDIRECTTCPX_PROGRAM_FLOW_STEERING_WAIT_MICROS=500000"

Coletar registros de depuração do NCCL

Para registrar erros do NCCL, recomendamos que você adicione a seguinte configuração do NCCL:

NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
  • NCCL_DEBUG=INFO: imprime informações de depuração.
    • Para cargas de trabalho de grande escala (64 nós ou mais), o registro em registros extenso pode ocorrer. Para evitar esse cenário, e a menos que você tenha especificado NCCL_DEBUG_FILE, recomendamos definir NCCL_DEBUG=WARN para limitar os registros apenas a erros.

  • NCCL_DEBUG_SUBSYS: filtra os subsistemas para os quais o NCCL coleta informações de depuração. Recomendamos que você colete registros dos seguintes subsistemas:

    • INIT: a fase de inicialização do NCCL.
    • NET: a rede NCCL.
    • ENV: as variáveis de ambiente usadas pela NCCL.
    • COLL: operações coletivas.
    • GRAPH: detecção de topologia e pesquisa de gráficos.

    Se você quiser coletar registros de diferentes subsistemas, consulte NCCL_DEBUG_SUBSYS na documentação do NCCL para ver uma lista de valores aceitos.

  • NCCL_DEBUG_FILE (opcional): direciona a saída de registro de depuração do NCCL para um arquivo que você especifica. Essa variável grava os registros do NCCL em arquivos padrão, o que evita que a saída do registro se misture com a saída do aplicativo. Essa variável também grava registros de diferentes classificações do NCCL em arquivos diferentes, o que evita que os registros se misturem.

    Use o seguinte formato de nome de arquivo:

    /DIRECTORY/FILE_NAME.%h.%p

    Substitua:

    • DIRECTORY: o diretório em que você quer armazenar os arquivos de registro.
    • FILE_NAME: o nome dos arquivos de registro.

    O marcador de posição %h é resolvido como o nome do host do nó, enquanto %p é resolvido como o ID do processo (PID) que está gerando o registro.

Para mais informações sobre como depurar registros do NCCL, consulte Solucionar problemas de GPUs no GKE.

Adicionar GPUDirect aos manifestos

Esta seção mostra os campos obrigatórios que você precisa adicionar aos manifestos do Kubernetes para que seus pods usem o GPUDirect.

No modo Autopilot, também é necessário selecionar as GPUs adequadas nos manifestos do pod para que o GKE provisione o hardware. Para GPUs H100 Mega, use o GPUDirect-TCPXO. Para GPUs H100, use o GPUDirect-TCPX.

Adicione os seguintes seletores de nós ao pod:

nodeSelector:
  cloud.google.com/gke-accelerator: GPU_NAME
  cloud.google.com/gke-gpu-driver-version: latest

Substitua GPU_NAME pelo nome da GPU. Confira os valores aceitos:

  • nvidia-h100-mega-80gb
  • nvidia-h100-80gb

Dependendo do tipo de GPUDirect, faça o seguinte:

GPUDirect-TCPXO

  1. Adicione as seguintes anotações aos metadados do pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpxo-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
      - path: /dev/dmabuf_import_helper
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
        {"interfaceName":"eth5","network":"vpc5"},
        {"interfaceName":"eth6","network":"vpc6"},
        {"interfaceName":"eth7","network":"vpc7"},
        {"interfaceName":"eth8","network":"vpc8"}
      ]

  2. Adicione os seguintes campos à especificação do pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

  3. Adicione o contêiner a seguir ao manifesto para executar o serviço tcpxo-daemon. Substitua (TCPXO_DAEMON_IMAGE) pela imagem mais recente, us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.17:

    - name: tcpxo-daemon
  image: TCPXO_DAEMON_IMAGE
  imagePullPolicy: Always
  command: ["/bin/sh", "-c"]
  args:
    - |
      set -ex
      chmod 755 /fts/entrypoint_rxdm_container.sh
      /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
  securityContext:
    capabilities:
      add:
        - NET_ADMIN
        - NET_BIND_SERVICE
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. Adicione a seguinte variável de ambiente a cada contêiner de GPU:

    env:

- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

  5. Adicione as seguintes volumeMounts a cada contêiner de GPU. Sem as configurações de aperture_devices, o privileged:true é necessário para contêineres de GPU:

    volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices

  6. Adicione variáveis de ambiente para configurar as opções da NCCL. Para mais detalhes, consulte Usar as configurações recomendadas do NCCL para melhorar o desempenho.

Uma especificação de pod completa tem esta aparência:

apiVersion: v1
kind: Pod
metadata:
name: a3plus-workloads
annotations:
  devices.gke.io/container.tcpxo-daemon: |+
    - path: /dev/nvidia0
    - path: /dev/nvidia1
    - path: /dev/nvidia2
    - path: /dev/nvidia3
    - path: /dev/nvidia4
    - path: /dev/nvidia5
    - path: /dev/nvidia6
    - path: /dev/nvidia7
    - path: /dev/nvidiactl
    - path: /dev/nvidia-uvm
    - path: /dev/dmabuf_import_helper
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"},
      {"interfaceName":"eth5","network":"vpc5"},
      {"interfaceName":"eth6","network":"vpc6"},
      {"interfaceName":"eth7","network":"vpc7"},
      {"interfaceName":"eth8","network":"vpc8"}
    ]
...
containers:
  - name: tcpxo-daemon
    image: TCPXO_DAEMON_IMAGE
    imagePullPolicy: Always
    command: ["/bin/sh", "-c"]
    args:
      - |
        set -ex
        chmod 755 /fts/entrypoint_rxdm_container.sh
        /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
    securityContext:
      capabilities:
        add:
          - NET_ADMIN
          - NET_BIND_SERVICE
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    
  - name: main-application-container
...
   
      - name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
        value: /dev/aperture_devices
    securityContext:
    volumeMounts:
      - name: aperture-devices
        mountPath: /dev/aperture_devices
    resources:
      limits:
        nvidia.com/gpu: 8
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

GPUDirect-TCPX

  1. Adicione as seguintes anotações aos metadados do pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpx-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
      ]

  2. Adicione os seguintes campos à especificação do pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

  3. Adicione o seguinte contêiner ao manifesto para executar o serviço tcpx-daemon:

    - name: tcpx-daemon
  image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.9
  command:
    - /tcpgpudmarxd/build/app/tcpgpudmarxd
    - --gpu_nic_preset
    - a3vm
    - --gpu_shmem_type
    - fd
    - --uds_path
    - /run/tcpx
    - --setup_param
    - \"--verbose 128 2 0 \"
  securityContext:
    capabilities:
        add:
          - NET_ADMIN
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: tcpx-socket
      mountPath: /run/tcpx
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. Adicione as seguintes montagens de volume a todos os contêineres que solicitarem GPUs:

    volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64

  5. Adicione variáveis de ambiente para configurar as opções da NCCL. Para mais detalhes, consulte a seção Usar as configurações recomendadas do NCCL para melhorar o desempenho neste documento.

Uma especificação de pod completa tem esta aparência:

apiVersion: v1
kind: Pod
metadata:
name: a3-gpu-workloads-example
labels:
  name: a3-gpu-workloads-example
annotations:
  devices.gke.io/container.tcpx-daemon: |+
        - path: /dev/nvidia0
        - path: /dev/nvidia1
        - path: /dev/nvidia2
        - path: /dev/nvidia3
        - path: /dev/nvidia4
        - path: /dev/nvidia5
        - path: /dev/nvidia6
        - path: /dev/nvidia7
        - path: /dev/nvidiactl
        - path: /dev/nvidia-uvm
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"}
    ]
spec:
containers:
  - name: tcpx-daemon
    image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.11
    imagePullPolicy: Always
    command:
      - /tcpgpudmarxd/build/app/tcpgpudmarxd
      - --gpu_nic_preset
      - a3vm
      - --gpu_shmem_type
      - fd
      - --uds_path
      - /run/tcpx
      - --setup_param
      - \"--verbose 128 2 0 \"
    securityContext:
capabilities:
        add:
          - NET_ADMIN
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
      - name: tcpx-socket
        mountPath: /run/tcpx
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    
  - name: a3-gpu-workloads-example
    ...
    volumeMounts:
      - name: tcpx-socket
        mountPath: /tmp
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
    resources:
      limits:
        nvidia.com/gpu: 8
    
...
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: tcpx-socket
    emptyDir:
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

A seguir