Permita o processamento mais rápido de pacotes de rede com o DPDK

Neste documento, explicamos como ativar o Kit de desenvolvimento do plano de dados (DPDK, na sigla em inglês) em uma instância de máquina virtual (VM) para agilizar o processamento de pacotes de rede.

O DPDK é um framework para aplicativos com alto desempenho que exigem processamento de pacotes rápido, baixa latência e desempenho consistente. O DPDK fornece um conjunto de bibliotecas de plano de dados e um controlador de interface de rede (NIC, na sigla em inglês) que ignora a rede do kernel e é executado diretamente no espaço do usuário. Por exemplo, ativar o DPDK na sua VM é útil ao executar o seguinte:

Implantações de virtualização de função de rede (NFV, na sigla em inglês)
Aplicativos de rede definida por software (SDN, na sigla em inglês)
Aplicativos de streaming de vídeo ou voz sobre IP

É possível executar o DPDK em uma VM usando um dos seguintes tipos de NIC virtual (vNIC, na sigla em inglês):

Recomendado: gVNIC

Uma interface de rede virtual segura, escalonável e de alto desempenho projetada especificamente para o Compute Engine e que tem sucesso virtIO como a vNIC de última geração.
VirtIO-Net

Um driver Ethernet de código aberto que permite às VMs acessar hardwares físicos de maneira eficiente, como armazenamento em blocos e adaptadores de rede.

Um problema ao executar o DPDK em um ambiente virtual, e não em hardware físico, é que os ambientes virtuais não oferecem suporte a SR-IOV e unidade de gerenciamento de memória de E/S (IOMMU, na sigla em inglês) para aplicativos de alto desempenho. Para superar essa limitação, você precisa executar o DPDK nos endereços físicos de convidados em vez de hospedá-los virtuais usando um dos drivers a seguir:

Antes de começar

Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine da seguinte maneira.

Selecione a guia para como planeja usar as amostras nesta página:
Console

Quando você usa o console do Google Cloud para acessar os serviços e as APIs do Google Cloud, não é necessário configurar a autenticação.
gcloud
1. Instale a Google Cloud CLI e inicialize-a executando o seguinte comando:
```
gcloud init
```
  Observação: se você instalou a CLI gcloud anteriormente, verifique se tem a versão mais recente executando gcloud components update.
2. Defina uma região e uma zona padrão.
REST

Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para a CLI gcloud.

Requisitos

Ao criar uma VM para executar o DPDK, verifique o seguinte:

Para evitar a falta de conectividade de rede ao executar seus aplicativos, use duas redes de nuvem privada virtual:
- Uma rede VPC para o plano de controle
- Uma rede VPC para o plano de dados
As duas redes VPC precisam especificar o seguinte:
- Uma sub-rede com um intervalo de endereços IP exclusivo
- A mesma região para as sub-redes
- O mesmo tipo de VNIC: gVNIC ou VirtIO-Net
Ao criar a VM:
- É preciso especificar a mesma região das duas sub-redes de redes VPC.
- É necessário especificar o tipo de vNIC que você planeja usar com o DPDK.
- É preciso especificar uma série de máquinas compatível para gVNIC ou VirtIO-Net.

Restrições

A execução do DPDK em uma VM tem as seguintes restrições:

Só é possível usar sub-redes de pilha única para as duas redes VPC usadas na VM.
Se você estiver usando a gVNIC como o tipo de vNIC para as duas redes VPC, verifique o seguinte:
- Use a versão 22.11 ou posterior do DPDK.
- Só é possível usar imagens de disco compatíveis.
Se você quiser ativar o desempenho de rede por VM de Tier_1 para maior desempenho de rede ao criar a VM, especifique o seguinte:
- gVNIC como o tipo de vNIC
- Um tipo de máquina compatível com 30 vCPUs ou mais

Configurar uma VM para executar o DPDK

Nesta seção, explicamos como criar uma VM para executar o DPDK.

Crie as redes VPC

Crie duas redes VPC: para o plano de dados e o plano de controle, usando o console do Google Cloud, a Google Cloud CLI ou a API Compute Engine. Posteriormente, é possível especificar essas redes ao criar a VM.

Console

Crie uma rede VPC para o plano de dados:
1. No Console do Google Cloud, acesse Redes VPC.
  
  Acessar redes VPC
  
  A página Redes VPC é aberta.
2. Clique em Criar rede VPC.
  
  A página Criar uma rede VPC é aberta.
3. No campo Nome, insira um nome para sua rede.
4. Na seção Nova sub-rede, faça o seguinte:
  1. No campo Nome, insira um nome para sua sub-rede.
  2. No menu Região, selecione uma região para a sub-rede.
  3. Selecione IPv4 (pilha única) (padrão).
  4. No Intervalo IPv4, insira um endereço de intervalo IPv4 válido na notação CIDR.
  5. Clique em Concluído.
5. Clique em Criar.
  
  A página Redes VPC é aberta. A criação da rede VPC pode levar até um minuto para ser concluída.
Crie uma rede VPC para o plano de controle com uma regra de firewall que permita conexões SSH na VM:
1. Clique em Criar rede VPC novamente.
  
  A página Criar uma rede VPC é aberta.
2. No campo Nome, insira um nome para sua rede.
3. Na seção Nova sub-rede, faça o seguinte:
  1. No campo Nome, insira um nome para a sub-rede.
  2. No menu Região, selecione a mesma região especificada para a sub-rede da rede do plano de dados.
  3. Selecione IPv4 (pilha única) (padrão).
  4. No Intervalo IPv4, insira um endereço de intervalo IPv4 válido na notação CIDR.
    
    Importante: especifique um intervalo IPv4 diferente do especificado na sub-rede para a rede do plano de dados. Caso contrário, a criação da rede vai falhar.
  5. Clique em Concluído.
4. Na guia Regras de firewall IPv4, marque a caixa de seleção NETWORK_NAME-allow-ssh.
  
  Em que NETWORK_NAME é o nome da rede que você especificou nas etapas anteriores.
5. Clique em Criar.
  
  A página Redes VPC é aberta. A criação da rede VPC pode levar até um minuto para ser concluída.

gcloud

Para criar uma rede VPC para o plano de dados, siga estas etapas:
1. Crie uma rede VPC com uma sub-rede criada manualmente usando o comando gcloud compute networks create com a sinalização --subnet-mode definida como custom.
```
gcloud compute networks create DATA_PLANE_NETWORK_NAME \
    --bgp-routing-mode=regional \
    --mtu=MTU \
    --subnet-mode=custom
```
  Substitua:
  - DATA_PLANE_NETWORK_NAME: o nome da rede VPC do plano de dados.
  - MTU: a unidade máxima de transmissão (MTU), que é o maior tamanho de pacote da rede. O valor precisa estar entre 1300 e 8896. O valor padrão é 1460. Antes de definir a MTU como um valor maior que 1460, consulte Unidade máxima de transmissão.
2. Crie uma sub-rede para a rede do plano de dados VPC recém-criado usando o comando gcloud compute networks subnets create.
```
gcloud compute networks subnets create DATA_PLANE_SUBNET_NAME \
    --network=DATA_PLANE_NETWORK_NAME \
    --range=DATA_PRIMARY_RANGE \
    --region=REGION
```
  Substitua:
  - DATA_PLANE_SUBNET_NAME: o nome da sub-rede da rede do plano de dados.
  - DATA_PLANE_NETWORK_NAME: o nome da rede do plano de dados que você especificou nas etapas anteriores.
  - DATA_PRIMARY_RANGE: um intervalo IPv4 válido para a sub-rede na notação CIDR.
  - REGION: a região em que a sub-rede será criada.
Para criar uma rede VPC para o plano de controle com uma regra de firewall que permita conexões SSH na VM, siga estas etapas:
1. Crie uma rede VPC com uma sub-rede criada manualmente usando o comando gcloud compute networks create com a sinalização --subnet-mode definida como custom.
```
gcloud compute networks create CONTROL_PLANE_NETWORK_NAME \
    --bgp-routing-mode=regional \
    --mtu=MTU \
    --subnet-mode=custom
```
  Substitua:
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede VPC do plano de controle.
  - MTU: a MTU, que é o maior tamanho de pacote da rede. O valor precisa estar entre 1300 e 8896. O valor padrão é 1460. Antes de definir a MTU como um valor maior que 1460, consulte Unidade máxima de transmissão.
2. Crie uma sub-rede para a rede do plano de controle da VPC que você acabou de criar usando o comando gcloud compute networks subnets create.
```
gcloud compute networks subnets create CONTROL_PLANE_SUBNET_NAME \
    --network=CONTROL_PLANE_NETWORK_NAME \
    --range=CONTROL_PRIMARY_RANGE \
    --region=REGION
```
  Substitua:
  - CONTROL_PLANE_SUBNET_NAME: o nome da sub-rede para a rede do plano de controle.
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle especificada nas etapas anteriores.
  - CONTROL_PRIMARY_RANGE: um intervalo IPv4 válido para a sub-rede na notação CIDR.
    
    Importante: especifique um intervalo IPv4 diferente do especificado na sub-rede da rede do plano de dados. Caso contrário, a criação da sub-rede vai falhar.
  - REGION: a região em que a sub-rede será criada, que precisa corresponder à região especificada na sub-rede da rede do plano de dados.
3. Crie uma regra de firewall de VPC que permita o SSH na rede do plano de controle usando o comando gcloud compute firewall-rules create com a sinalização --allow definida como tcp:22.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME \
    --action=allow \
    --network=CONTROL_PLANE_NETWORK_NAME \
    --rules=tcp:22
```
  Substitua:
  - FIREWALL_RULE_NAME: o nome da regra de firewall.
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle que você criou nas etapas anteriores.

API

Para criar uma rede VPC para o plano de dados, siga estas etapas:
1. Crie uma rede VPC com uma sub-rede criada manualmente fazendo uma solicitação POST ao método networks.insert com o campo autoCreateSubnetworks definido como false.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "autoCreateSubnetworks": false,
  "name": "DATA_PLANE_NETWORK_NAME",
  "mtu": MTU
}
```
  Substitua:
  - PROJECT_ID: o ID do projeto atual.
  - DATA_PLANE_NETWORK_NAME: o nome da rede para o plano de dados.
  - MTU: a unidade máxima de transmissão (MTU), que é o maior tamanho de pacote da rede. O valor precisa estar entre 1300 e 8896. O valor padrão é 1460. Antes de definir a MTU como um valor maior que 1460, consulte Unidade máxima de transmissão.
2. Crie uma sub-rede para a rede do plano de dados VPC fazendo uma solicitação POST ao método subnetworks.insert.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks

{
  "ipCidrRange": "DATA_PRIMARY_RANGE",
  "name": "DATA_PLANE_SUBNET_NAME",
  "network": "projects/PROJECT_ID/global/networks/DATA_PLANE_NETWORK_NAME"
}
```
  Substitua:
  - PROJECT_ID: o ID do projeto em que a rede do plano de dados está localizada.
  - REGION: a região em que você quer criar a política.
  - DATA_PRIMARY_RANGE: o intervalo IPv4 principal da nova sub-rede, em notação CIDR.
  - DATA_PLANE_SUBNET_NAME: o nome da sub-rede para a rede do plano de dados criada na etapa anterior.
  - DATA_PLANE_NETWORK_NAME: o nome da rede do plano de dados que você criou na etapa anterior.
Para criar uma rede VPC para o plano de controle com uma regra de firewall que permita SSH na VM, siga estas etapas:
1. Crie uma rede VPC com uma sub-rede criada manualmente fazendo uma solicitação POST ao método networks.insert com o campo autoCreateSubnetworks definido como false.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "autoCreateSubnetworks": false,
  "name": "CONTROL_PLANE_NETWORK_NAME",
  "mtu": MTU
}
```
  Substitua:
  - PROJECT_ID: o ID do projeto atual.
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle.
  - MTU: a MTU, que é o maior tamanho de pacote da rede. O valor precisa estar entre 1300 e 8896. O valor padrão é 1460. Antes de definir a MTU como um valor maior que 1460, consulte Unidade máxima de transmissão.
2. Crie uma sub-rede para a rede de controle de dados VPC fazendo uma solicitação POST ao método subnetworks.insert.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks

{
  "ipCidrRange": "CONTROL_PRIMARY_RANGE",
  "name": "CONTROL_PLANE_SUBNET_NAME",
  "network": "projects/PROJECT_ID/global/networks/CONTROL_PLANE_NETWORK_NAME"
}
```
  Substitua:
  - PROJECT_ID: o ID do projeto em que a rede do plano de controle está localizada.
  - REGION: a região em que você quer criar a política.
  - CONTROL_PRIMARY_RANGE: o intervalo IPv4 principal da nova sub-rede, em notação CIDR.
    
    Importante: especifique um intervalo IPv4 diferente do especificado na sub-rede da rede do plano de dados. Caso contrário, a criação da sub-rede vai falhar.
  - CONTROL_PLANE_SUBNET_NAME: o nome da sub-rede para a rede do plano de controle que você criou na etapa anterior.
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle que você criou na etapa anterior.
3. Crie uma regra de firewall da VPC que permita o SSH na rede do plano de controle fazendo uma solicitação POST ao método firewalls.insert. Na solicitação, defina o campo IPProtocol como tcp e o campo ports como 22.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [ "22" ]
    }
  ],
  "network": "projects/PROJECT_ID/global/networks/CONTROL_PLANE_NETWORK_NAME"
}
```
  Substitua:
  - PROJECT_ID: o ID do projeto em que a rede do plano de controle está localizada.
  - CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle que você criou nas etapas anteriores.

Para mais opções de configuração ao criar uma rede VPC, consulte Criar e gerenciar redes VPC.

Criar uma VM que use as redes VPC para DPDK

Crie uma VM que ative a gVNIC ou o virtIO-Net nas duas redes VPC criadas anteriormente usando o console do Google Cloud, a CLI gcloud e a API Compute Engine.

Recomendado: especifique Ubuntu LTS ou Ubuntu Pro como a imagem do sistema operacional devido ao suporte do gerenciador de pacotes para a UIO e a VFIO sem IOMMU motivadores. Se você não quiser especificar nenhum desses sistemas operacionais, é recomendável especificar o Debian 11 ou posterior para agilizar o processamento de pacotes.

Console

Crie uma VM que use as duas sub-redes da rede VPC criadas nas etapas anteriores da seguinte maneira:

No console do Google Cloud, acesse Instâncias de VM.

Acessar instâncias de VM

A página Instâncias de VM é aberta.
Clique em Criar instância.

A página Criar uma instância é aberta.
No campo Nome, insira um nome para a VM.
No menu Região, selecione a mesma região em que você criou suas redes nas etapas anteriores.

Importante: a tentativa de criar uma VM em uma região diferente da onde estão as redes de plano de dados e controle causa erros.
No menu Zona, selecione uma zona para sua VM.
Na seção Configuração da máquina, faça o seguinte:
1. Selecione uma das seguintes opções:
  - Para cargas de trabalho comuns, clique na guia Uso geral (padrão).
  - Para cargas de trabalho que exigem alto desempenho, clique na guia Otimização de computação.
  - Para cargas de trabalho com altas proporções entre memória e vCPUs, clique na guia Otimização de memória.
  - Para cargas de trabalho que usam unidades de processamento gráfico (GPUs), clique na guia GPUs.
2. Opcional. Se você especificou GPUs na etapa anterior e quer alterar a GPU para anexar à VM, siga um ou mais destes procedimentos:
  1. No menu Tipo de GPU, selecione um tipo de GPU.
  2. No menu Número de GPUs, selecione o número de GPUs.
3. Na lista Série, selecione uma série de máquina.
  
  Importante: a gVNIC é compatível com todas as séries de máquinas, mas o VirtIO-Net não é compatível com a série de máquinas mais recente (terceira geração e T2A). Se você escolher uma série de máquinas que não oferece suporte ao tipo de vNIC, a criação da VM vai falhar.
4. Na lista Tipo de máquina, selecione um tipo de máquina.
5. Opcional: expanda Configurações avançadas e siga as instruções para personalizar ainda mais a máquina para essa VM.
Opcional: na seção Disco de inicialização, clique em Alterar e siga as instruções para alterar a imagem do disco.

Importante: se você especificar a gVNIC como o tipo de vNIC para essa VM, especifique uma imagem de disco compatível. Caso contrário, a criação da VM irá falhar.
Expanda a seção Opções avançadas.
Expanda a seção Rede.
Na seção Configuração de desempenho da rede, faça o seguinte:
1. No menu Card de interface de rede, selecione uma das seguintes opções:
  - Para usar a gVNIC, selecione gVNIC.
  - Para usar o VirtIO-Net, selecione VirtIO.
  Observação: o valor - no menu Card de interface de rede indica que o tipo de vNIC pode ser gVNIC ou VirtIO-Net, dependendo do tipo da família de máquinas. Se a gVNIC e o VirtIO-Net estiverem disponíveis para uma VM, o padrão será o VirtIO-Net.
2. Opcional: para maior desempenho de rede e latência reduzida, marque a caixa de seleção Ativar rede Tier_1.
  
  Importante: só é possível ativar a rede Tier_1 ao usar gVNIC e especificar um tipo de máquina compatível que tenha 30 vCPUs ou mais. Caso contrário, a criação da VM irá falhar.
Na seção Interfaces de rede, faça o seguinte:
1. Na linha padrão, clique em Excluir item "padrão".
2. Clique em Adicionar interface de rede.
  
  A seção Nova interface de rede é exibida.
3. No menu Rede, selecione a rede do plano de controle criada nas etapas anteriores.
4. Clique em Concluído.
5. Clique em Adicionar interface de rede novamente.
  
  A seção Nova interface de rede é exibida.
6. No menu Rede, selecione a rede do plano de dados que você criou nas etapas anteriores.
7. Clique em Concluído.
Clique em Criar.

A página Instâncias de VM é aberta. A criação da VM pode levar até um minuto para ser concluída.

gcloud

Crie uma VM que use as duas sub-redes da rede VPC criadas nas etapas anteriores usando o comando gcloud compute instances create com as sinalizações a seguir:

gcloud compute instances create VM_NAME \
    --image-family=IMAGE_FAMILY \
    --image-project=IMAGE_PROJECT \
    --machine-type=MACHINE_TYPE  \
    --network-interface=network=CONTROL_PLANE_NETWORK_NAME,subnet=CONTROL_PLANE_SUBNET_NAME,nic-type=VNIC_TYPE \
    --network-interface=network=DATA_PLANE_NETWORK_NAME,subnet=DATA_PLANE_SUBNET_NAME,nic-type=VNIC_TYPE \
    --zone=ZONE

Substitua:

VM_NAME: o nome da VM.
IMAGE_FAMILY: a família de imagens do sistema operacional com que o disco de inicialização será inicializado. Como alternativa, é possível especificar a sinalização --image=IMAGE e substituir IMAGE por uma versão específica de uma imagem. Saiba como visualizar uma lista de imagens disponíveis no projeto de imagens do Compute Engine.
IMAGE_PROJECT: o nome do projeto de imagem que contém a imagem do disco.

Importante: se você especificar a gVNIC como o tipo de vNIC para essa VM, especifique um projeto e uma família de imagens compatíveis de dois minutos. Caso contrário, a criação da VM irá falhar.
MACHINE_TYPE: um tipo de máquina, predefinido ou personalizado, para a VM.

Importante: a gVNIC é compatível com todas as séries de máquinas, mas o VirtIO-Net não é compatível com a série de máquinas mais recente (terceira geração e T2A). Se você escolher uma série de máquinas que não oferece suporte ao seu tipo de vNIC, a criação da VM vai falhar.
VNIC_TYPE: o tipo de vNIC a ser usado para o plano de controle e as redes dele. O valor precisa ser um dos indicados abaixo:
- Para usar a gVNIC, especifique GVNIC.
- Para usar o VirtIO-Net, especifique VIRTIO_NET.
CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle que você criou nas etapas anteriores.
CONTROL_PLANE_SUBNET_NAME: o nome da sub-rede da rede do plano de controle criada nas etapas anteriores.
DATA_PLANE_NETWORK_NAME: o nome da rede do plano de dados que você criou nas etapas anteriores.
DATA_PLANE_SUBNET_NAME: o nome da sub-rede da rede do plano de controle que você criou automaticamente nas etapas anteriores.
ZONE: a zona em que a VM será criada. Especifique uma zona dentro da mesma região da sub-rede criada nas etapas anteriores.

Por exemplo, para criar uma VM chamada dpdk-vm na zona us-central1-a que especifica um disco permanente SSD de 512 GB, um tipo de máquina C2 predefinido com 60 vCPUs, rede Tier_1 e um e uma rede do plano de controle que usem a gVNIC, execute este comando:

gcloud compute instances create dpdk-vm \
    --boot-disk-size=512GB \
    --boot-disk-type=pd-ssd \
    --image-project=ubuntu-os-cloud \
    --image-family=ubuntu-2004-lts \
    --machine-type=c2-standard-60 \
    --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
    --network-interface=network=control,subnet=control,nic-type=GVNIC \
    --network-interface=network=data,subnet=data,nic-type=GVNIC \
    --zone=us-central1-a

API

Crie uma VM que use as duas sub-redes da rede VPC criadas nas etapas anteriores fazendo uma solicitação POST ao método instances.insert com o seguinte: campos:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
  "name": "VM_NAME",
  "machineType": "MACHINE_TYPE",
  "disks": [
    {
      "initializeParams": {
        "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE_FAMILY"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/CONTROL_PLANE_NETWORK_NAME",
      "subnetwork": "regions/REGION/subnetworks/CONTROL_PLANE_SUBNET_NAME",
      "nicType": "VNIC_TYPE"
    },
    {
      "network": "global/networks/DATAPLANE_NETWORK_NAME",
      "subnetwork": "regions/REGION/subnetworks/DATA_PLANE_SUBNET_NAME",
      "nicType": "VNIC_TYPE"
    }
  ]
}

Substitua:

PROJECT_ID: o ID do projeto em que a rede VPC do plano de controle e a rede VPC do plano de dados estão localizadas.
ZONE: a zona em que a VM será criada.
Importante: especifique uma zona que atenda aos seguintes requisitos:
- A zona está dentro da mesma região onde estão localizadas as sub-redes das redes de plano de dados e controle.
- A zona da VM e a zona que contém o tipo de máquina a ser usado para a VM são correspondentes.
A tentativa de criar uma VM fora da região em que as sub-redes especificadas existem ou em uma zona que não corresponde à zona do tipo de máquina especificado causa erros.
VM_NAME: o nome da VM.
MACHINE_TYPE: um tipo de máquina, predefinido ou personalizado, para a VM.

Importante: a gVNIC é compatível com todas as séries de máquinas, mas o VirtIO-Net não é compatível com a série de máquinas mais recente (terceira geração e T2A). Se você escolher uma série de máquinas que não oferece suporte ao seu tipo de vNIC, a criação da VM vai falhar.
IMAGE_PROJECT: o nome do projeto de imagem que contém a imagem do disco.
IMAGE_FAMILY: a família de imagens do sistema operacional com que o disco de inicialização será inicializado. Como alternativa, especifique uma versão específica de uma imagem. Saiba como visualizar uma lista de imagens no projeto de imagens do Compute Engine.

Importante: se você especificar a gVNIC como o tipo de vNIC para essa VM, especifique uma imagem de disco compatível. Caso contrário, a criação da VM irá falhar.
CONTROL_PLANE_NETWORK_NAME: o nome da rede do plano de controle que você criou nas etapas anteriores.
REGION: a região onde estão as sub-redes do plano de controle e das redes do plano de dados.
CONTROL_PLANE_SUBNET_NAME: o nome da sub-rede da rede do plano de controle criada nas etapas anteriores.
VNIC_TYPE: o tipo de vNIC a ser usado para o plano de controle e as redes dele. O valor precisa ser um dos indicados abaixo:
- Para usar a gVNIC, especifique GVNIC.
- Para usar o VirtIO-Net, especifique VIRTIO_NET.
DATA_PLANE_NETWORK_NAME: o nome da rede do plano de dados que você criou nas etapas anteriores.
DATA_PLANE_SUBNET_NAME: o nome da sub-rede da rede do plano de controle criada nas etapas anteriores.

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances

{
  "name": "dpdk-vm",
  "machineType": "c2-standard-60",
  "disks": [
    {
      "initializeParams": {
        "diskSizeGb": "512GB",
        "diskType": "pd-ssd",
        "sourceImage": "projects/ubuntu-os-cloud/global/images/ubuntu-2004-lts"
      },
      "boot": true
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/control",
      "subnetwork": "regions/us-central1/subnetworks/control",
      "nicType": "GVNIC"
    },
    {
      "network": "global/networks/data",
      "subnetwork": "regions/us-central1/subnetworks/data",
      "nicType": "GVNIC"
    }
  ],
  "networkPerformanceConfig": {
    "totalEgressBandwidthTier": "TIER_1"
  }
}

Para mais opções de configuração ao criar uma VM, consulte Criar e iniciar uma instância de VM.

Instalar o DPDK na sua VM

Para instalar o DPDK na sua VM, siga estas etapas:

Conecte-se à VM criada na seção anterior usando SSH.

Configure as dependências para a instalação do DPDK:

sudo apt-get update && sudo apt-get upgrade -yq
sudo apt-get install -yq build-essential ninja-build python3-pip \
    linux-headers-$(uname -r) pkg-config libnuma-dev
sudo pip install pyelftools meson

Instale o DPDK:
```
wget https://fast.dpdk.org/rel/dpdk-23.07.tar.xz
tar xvf dpdk-23.07.tar.xz
cd dpdk-23.07
```
Importante: se você especificou a gVNIC como o tipo de vNIC nas etapas anteriores, instale o DPDK versão 22.11 ou mais recente. O uso de uma versão anterior do DPDK causa erros quando você tenta testar ou usar o DPDK na VM.

Para criar o DPDK com os exemplos:

meson setup -Dexamples=all build
sudo ninja -C build install; sudo ldconfig

Instale o driver

Para preparar o DPDK para execução em um driver, instale o driver selecionando um dos seguintes métodos:

Instale um VFIO sem IOMMU.
Instale o UIO.

Instalar um VFIO sem IOMMU

Para instalar o driver VFIO sem IOMMU, siga estas etapas:

Verifique se a VFIO está ativada:
```
cat /boot/config-$(uname -r) | grep NOIOMMU
```
Se a VFIO não estiver ativada, siga as etapas em Instalar o UIO.

Ative o modo sem IOMMU na VFIO:

sudo bash -c 'echo 1 > /sys/module/vfio/parameters/enable_unsafe_noiommu_mode'

Instalar o UIO

Para instalar o driver UIO no DPDK, selecione um dos seguintes métodos:

Instale o UIO usando o git.
Instale o UIO usando pacotes do Linux.

Instalar o UIO usando git

Para instalar o driver UIO no DPDK usando git, siga estas etapas:

Clone o repositório git igb_uio (link em inglês) para um disco na sua VM:
```
git clone https://dpdk.org/git/dpdk-kmods
```
No diretório pai do repositório git clonado, crie o módulo e instale o driver UIO no DPDK:
```
pushd dpdk-kmods/linux/igb_uio
sudo make
sudo depmod && sudo insmod igb_uio.ko
popd
```

Instalar o UIO usando pacotes do Linux

Para instalar o driver UIO no DPDK usando pacotes do Linux, siga estas etapas:

Instale o dpdk-igb-uio-dkms pacote:

sudo apt-get install -y dpdk-igb-uio-dkms

Instale o driver UIO no DPDK:
```
sudo modprobe igb_uio
```

Vincular o DPDK a um driver e testá-lo

Para vincular o DPDK ao driver instalado na seção anterior, siga estas etapas:

Consiga o número do slot da Interconexão de componentes periféricos (PCI, na sigla em inglês) para a interface de rede atual:
```
sudo lspci | grep -e "gVNIC" -e "Virtio network device"
```
Por exemplo, se a VM estiver usando ens4 como a interface de rede, o número do slot do PCI será 00:04.0.
Pare a interface de rede conectada ao adaptador de rede:
```
sudo ip link set NETWORK_INTERFACE_NAME down
```
Substitua NETWORK_INTERFACE_NAME pelo nome da interface de rede especificada nas redes VPC. Para verificar qual interface de rede a VM está usando, veja a configuração da interface de rede:
```
sudo ifconfig
```
Vincule o DPDK ao driver:
```
sudo dpdk-devbind.py --bind=DRIVER PCI_SLOT_NUMBER
```
Substitua:
- DRIVER: o driver que vai ser ativado para vincular o DPDK. Especifique um dos seguintes valores:
  - Driver de UIO: igb_uio
  - Driver VFIO sem IOMMU: vfio-pci
- PCI_SLOT_NUMBER: o número do slot do PCI da interface de rede atual formatado como 00:0NUMBER.0.

Crie o diretório /mnt/huge e crie algumas páginas enormes para o DPDK usar para buffers:

sudo mkdir /mnt/huge
sudo mount -t hugetlbfs -o pagesize=1G none /mnt/huge
sudo bash -c 'echo 4 > /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages'
sudo bash -c 'echo 1024 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages'

Teste se o DPDK pode usar a interface de rede criada nas etapas anteriores executando o aplicativo de exemplo testpmd incluído nas bibliotecas do DPDK:
```
sudo ./build/app/dpdk-testpmd
```
Para mais informações sobre como testar o DPDK, consulte Opções de linha de comando Testpmd.

Desvincular DPDK

Depois de usar o DPDK, você pode desvinculá-lo do driver instalado na seção anterior. Para desvincular o DPDK, siga estas etapas:

Desvincular o DPDK do driver:
```
sudo dpdk-devbind.py -u PCI_SLOT_NUMBER
```
Substitua PCI_SLOT_NUMBER pelo número do slot PCI especificado nas etapas anteriores. Se você quiser verificar o número do slot do PCI para a interface de rede atual, faça o seguinte:
```
sudo lspci | grep -e "gVNIC" -e "Virtio network device"
```
Por exemplo, se a VM estiver usando ens4 como a interface de rede, o número do slot do PCI será 00:04.0.
Atualize o driver de rede do Compute Engine:
```
sudo bash -c 'echo PCI_SLOT_NUMBER > /sys/bus/pci/drivers/VNIC_DIRECTORY/bind'
sudo ip link set NETWORK_INTERFACE_NAME up
```
Substitua:
- PCI_SLOT_NUMBER: o número do slot do PCI especificado nas etapas anteriores.
- VNIC_DIRECTORY: o diretório da vNIC. Dependendo do tipo de vNIC que você está usando, especifique um dos seguintes valores:
  - gVNIC: gvnic
  - VirtIO-Net: virtio-pci
- NETWORK_INTERFACE_NAME: o nome da interface de rede que você especificou na seção anterior.

A seguir

Revise as taxas de largura de banda da rede para seu tipo de máquina.
Saiba mais sobre como criar e gerenciar redes VPC.
Saiba mais sobre configurações mais altas de MTU com frames jumbo.
Saiba mais sobre a otimização do TCP para melhorar o desempenho da rede.

Permita o processamento mais rápido de pacotes de rede com o DPDK

Antes de começar

Console

gcloud

REST

Requisitos

Restrições

Configurar uma VM para executar o DPDK

Crie as redes VPC

Console

gcloud

API

Criar uma VM que use as redes VPC para DPDK

Console

gcloud

API

Instalar o DPDK na sua VM

Instale o driver

Instalar um VFIO sem IOMMU

Instalar o UIO

Instalar o UIO usando git

Instalar o UIO usando pacotes do Linux

Vincular o DPDK a um driver e testá-lo

Desvincular DPDK

A seguir