Traiter plus rapidement les paquets sur le réseau à l'aide de DPDK

Ce document explique comment activer le kit de développement de plan de données (DPDK) sur une instance de machine virtuelle (VM) pour un traitement plus rapide des paquets sur le réseau.

DPDK est un framework pour les applications exigeantes qui requièrent un traitement rapide des paquets, une faible latence et des performances constantes. DPDK fournit un ensemble de bibliothèques de plans de données, et une carte d'interface réseau qui contourne le réseau de kernel et qui s'exécute directement dans l'espace utilisateur. Par exemple, l'activation de DPDK sur votre VM, est utile lorsque vous exécutez les éléments suivants :

Déploiements de virtualisation des fonctions réseau (NFV)
Des applications de réseau défini par logiciel (SDN)
Des applications de flux vidéo ou voix sur IP

Vous pouvez exécuter DPDK sur une VM à l'aide de l'un des types de carte d'interface réseau virtuelle (vNIC) suivants :

Recommandé : gVNIC

Interface de réseau virtuel de nouvelle génération, hautement performante, évolutive et sécurisée spécialement conçue pour Compute Engine, qui prend la suite de VirtIO.
VirtIO-Net

Pilote Ethernet Open Source qui permet aux VM d'accéder efficacement au matériel physique, comme un stockage de blocs et des adaptateurs de mise en réseau.

Exécuter DPDK dans un environnement virtuel et pas sur un matériel physique présente un problème. Ces environnements virtuels ne sont pas compatibles avec SR-IOV ni avec l'unité de gestion de mémoire d'E/S (IOMMU) pour les applications hautement performantes. Pour contourner ce problème, vous devez exécuter DPDK sur des adresses physiques d'invité au lieu d'adresses virtuelles d'hôte en utilisant un des pilotes suivants :

Userspace I/O (UIO)
Virtual Function I/O (VFIO) sans IOMMU

Avant de commencer

Si vous souhaitez utiliser les exemples de ligne de commande de ce guide, procédez comme suit :
1. Installez la dernière version de la Google Cloud CLI ou appliquez la mise à jour correspondante.
2. Définissez une région et une zone par défaut.
Si vous voulez utiliser les exemples d'API de ce guide, configurez l'accès aux API.

Conditions requises

Prenez en compte les éléments suivants lorsque vous créez une VM sur laquelle exécuter DPDK.

Pour éviter un manque de connectivité réseau quand vous exécutez vos applications, utilisez deux réseaux de cloud privé virtuel :
- Un réseau VPC pour le plan de contrôle
- Un réseau VPC pour le plan de données
Chacun des deux réseaux VPC doit spécifier :
- Un sous-réseau avec une plage d'adresses IP unique
- La même région pour leurs sous-réseaux
- Le même type de vNIC, gVNIC ou VirtIO-Net
Lorsque vous créez la VM, vous devez spécifier :
- la même région que les sous-réseaux des deux réseaux VPC ;
- le type de vNIC que vous pensez utiliser avec DKDP ;
- une série de machines compatible pour gVNIC or VirtIO-Net.

Restrictions

Les restrictions suivantes s'appliquent lorsque vous exécutez DPDK sur une VM :

Vous ne pouvez utiliser que des sous-réseaux à pile unique pour les deux sous-réseaux VPC utilisés dans la VM.
Si le type de vNIC pour les deux réseaux VPC est gVNIC, assurez-vous de :
- utiliser DPDK version 22.11 ou ultérieure ;
- utiliser uniquement des images disque compatibles.
Si vous voulez activer les performances réseau Tier_1 par VM pour améliorer les performances des réseaux lorsque vous créez la VM, vous devez spécifier :
- gVNIC comme type de vNIC ;
- un type de machine compatible avec au moins 30 vCPU (processeur virtuel).

Configurer une VM sur laquelle exécuter DPDK

Cette section explique comment créer une VM sur laquelle exécuter DPDK.

Créer les réseaux VPC

Créez deux réseaux VPC, un pour le plan de données et l'autre pour le plan de contrôle, à l'aide de la console Google Cloud, de Google Cloud CLI, ou de l'API Compute Engine. Vous pouvez spécifier ces réseaux ultérieurement lorsque vous créez la VM.

Console

Créez un réseau VPC pour le plan de données :
1. Dans la console Google Cloud, accédez à la page Réseaux VPC.
  
  Accéder aux réseaux VPC
  
  La page Réseaux VPC s'ouvre.
2. Cliquez sur Créer un réseau VPC.
  
  La page Créer un réseau VPC s'ouvre.
3. Dans le champ Nom, saisissez le nom du réseau.
4. Dans la section Nouveau sous-réseau, effectuez les opérations suivantes :
  1. Dans le champ Nom, saisissez le nom du sous-réseau.
  2. Dans le menu Région, sélectionnez la région du sous-réseau.
  3. Sélectionnez IPv4 (pile unique) (par défaut).
  4. Dans la plage IPv4, entrez une plage d'adresses IPv4 valide, au format CIDR.
  5. Cliquez sur OK.
5. Cliquez sur Créer.
  
  La page Réseaux VPC s'ouvre. La création du réseau VPC peut prendre jusqu'à une minute.
Créez un réseau VPC pour le plan de contrôle avec une règle de pare-feu autorisant les connexions SSH dans la VM :
1. Cliquez à nouveau sur Créer un réseau VPC.
  
  La page Créer un réseau VPC s'ouvre.
2. Dans le champ Nom, saisissez le nom du réseau.
3. Dans la section Nouveau sous-réseau, effectuez les opérations suivantes :
  1. Dans le champ Nom, saisissez un nom pour le sous-réseau.
  2. Dans le menu Région, sélectionnez la même région que vous avez spécifiée pour le sous-réseau du réseau de plan de données.
  3. Sélectionnez IPv4 (pile unique) (par défaut).
  4. Dans la plage IPv4, entrez une plage d'adresses IPv4 valide, au format CIDR.
    
    Important : Spécifiez une plage IPv4 différente de celle que vous avez indiquée dans le sous-réseau pour le réseau de plan de données. Sinon, vous ne pourrez pas créer le réseau.
  5. Cliquez sur OK.
4. Dans l'onglet Règles de pare-feu IPv4, cochez la case NETWORK_NAME-allow-ssh.
  
  Où NETWORK_NAME représente le nom du réseau que vous avez spécifié aux étapes précédentes.
5. Cliquez sur Créer.
  
  La page Réseaux VPC s'ouvre. La création du réseau VPC peut prendre jusqu'à une minute.

gcloud

Pour créer un réseau VPC pour le plan de données, procédez comme suit :
1. Créez un réseau VPC avec un sous-réseau créé manuellement à l'aide de la commande gcloud compute networks create avec l'option --subnet-mode définie sur custom.
```
gcloud compute networks create DATA_PLANE_NETWORK_NAME \
    --bgp-routing-mode=regional \
    --mtu=MTU \
    --subnet-mode=custom
```
  Remplacez les éléments suivants :
  - DATA_PLANE_NETWORK_NAME : nom du réseau VPC pour le plan de données.
  - MTU : unité de transmission maximale (MTU), qui est la plus grande taille de paquets du réseau. La valeur doit être comprise entre 1300 et 8896. La valeur par défaut est 1460. Avant de définir la MTU sur une valeur supérieure à 1460, consultez la section Unité de transmission maximale.
2. Créez un sous-réseau pour le réseau VPC de plan de données que vous venez de créer à l'aide de la commande 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
```
  Remplacez les éléments suivants :
  - DATA_PLANE_SUBNET_NAME : nom du sous-réseau pour le réseau de plan de données.
  - DATA_PLANE_NETWORK_NAME : nom du réseau de plan de données spécifié aux étapes précédentes.
  - DATA_PRIMARY_RANGE : plage IPv4 valide pour le sous-réseau, au format CIDR.
  - REGION : région dans laquelle créer le sous-réseau.
Pour créer un réseau VPC pour le plan de contrôle avec une règle de pare-feu autorisant les connexions SSH dans la VM, procédez comme suit.
1. Créez un réseau VPC avec un sous-réseau créé manuellement à l'aide de la commande gcloud compute networks create avec l'option --subnet-mode définie sur custom.
```
gcloud compute networks create CONTROL_PLANE_NETWORK_NAME \
    --bgp-routing-mode=regional \
    --mtu=MTU \
    --subnet-mode=custom
```
  Remplacez les éléments suivants :
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau VPC pour le plan de contrôle.
  - MTU : MTU, qui est la plus grande taille de paquets du réseau. La valeur doit être comprise entre 1300 et 8896. La valeur par défaut est 1460. Avant de définir la MTU sur une valeur supérieure à 1460, consultez la section Unité de transmission maximale.
2. Créez un sous-réseau pour le réseau VPC de plan de contrôle que vous venez de créer à l'aide de la commande 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
```
  Remplacez les éléments suivants :
  - CONTROL_PLANE_SUBNET_NAME : nom du sous-réseau pour le réseau de plan de contrôle.
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle spécifié aux étapes précédentes.
  - CONTROL_PRIMARY_RANGE : plage IPv4 valide pour le sous-réseau, au format CIDR.
    
    Important : Spécifiez une plage IPv4 différente de celle que vous avez indiquée dans le sous-réseau du réseau de plan de contrôle. Sinon, vous ne pourrez pas créer le sous-réseau.
  - REGION : région dans laquelle créer le sous-réseau, qui doit correspondre à celle spécifiée dans le sous-réseau du réseau de plan de données.
3. Créez une règle de pare-feu VPC autorisant SSH dans le réseau de plan de contrôle à l'aide de la commande gcloud compute firewall-rules create avec l'option --allow définie sur tcp:22.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME \
    --action=allow \
    --network=CONTROL_PLANE_NETWORK_NAME \
    --rules=tcp:22
```
  Remplacez les éléments suivants :
  - FIREWALL_RULE_NAME : nom de la règle de pare-feu.
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle créé aux étapes précédentes.

API

Pour créer un réseau VPC pour le plan de données, procédez comme suit :
1. Créez un réseau VPC avec un sous-réseau créé manuellement en envoyant une requête POST à la méthode networks.insert avec le champ autoCreateSubnetworks défini sur false.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "autoCreateSubnetworks": false,
  "name": "DATA_PLANE_NETWORK_NAME",
  "mtu": MTU
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID : ID du projet actuel.
  - DATA_PLANE_NETWORK_NAME : nom du réseau pour le plan de données.
  - MTU : unité de transmission maximale (MTU), qui est la plus grande taille de paquets du réseau. La valeur doit être comprise entre 1300 et 8896. La valeur par défaut est 1460. Avant de définir la MTU sur une valeur supérieure à 1460, consultez la section Unité de transmission maximale.
2. Créez un sous-réseau pour le réseau VPC de plan de données en envoyant une requête POST à la méthode 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"
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID : ID du projet contenant le réseau de plan de données.
  - REGION : région dans laquelle vous voulez créer le sous-réseau.
  - DATA_PRIMARY_RANGE : plage IPv4 principale pour le nouveau sous-réseau, au format CIDR.
  - DATA_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de données que vous avez créé à l'étape précédente.
  - DATA_PLANE_NETWORK_NAME : nom du réseau de plan de données que vous avez créé à l'étape précédente.
Pour créer un réseau VPC pour le plan de contrôle avec une règle de pare-feu autorisant SSH dans la VM, procédez comme suit.
1. Créez un réseau VPC avec un sous-réseau créé manuellement en envoyant une requête POST à la méthode networks.insert avec le champ autoCreateSubnetworks défini sur false.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "autoCreateSubnetworks": false,
  "name": "CONTROL_PLANE_NETWORK_NAME",
  "mtu": MTU
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID : ID du projet actuel.
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau pour le plan de contrôle.
  - MTU : MTU, qui est la plus grande taille de paquets du réseau. La valeur doit être comprise entre 1300 et 8896. La valeur par défaut est 1460. Avant de définir la MTU sur une valeur supérieure à 1460, consultez la section Unité de transmission maximale.
2. Créez un sous-réseau pour le réseau VPC de contrôle de données en envoyant une requête POST à la méthode 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"
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID : ID du projet contenant le réseau de plan de contrôle.
  - REGION : région dans laquelle vous voulez créer le sous-réseau.
  - CONTROL_PRIMARY_RANGE : plage IPv4 principale pour le nouveau sous-réseau, au format CIDR.
    
    Important : Spécifiez une plage IPv4 différente de celle que vous avez indiquée dans le sous-réseau du réseau de plan de données. Sinon, vous ne pourrez pas créer le sous-réseau.
  - CONTROL_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de contrôle que vous avez créé à l'étape précédente.
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle créé à l'étape précédente.
3. Créez une règle de pare-feu VPC autorisant SSH dans le réseau de plan de contrôle en envoyant une requête POST à la méthode firewalls.insert. Dans la requête, définissez le champ IPProtocol sur tcp et le champ ports sur 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"
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID : ID du projet contenant le réseau de plan de contrôle.
  - CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle créé aux étapes précédentes.

Pour davantage d'options de configuration lorsque vous créez un réseau VPC, consultez la section Créer et gérer des réseaux VPC.

Créer une VM qui utilise les réseaux VPC pour DPDK

Créez une VM qui active gVNIC ou virtIO-Net sur les deux réseaux VPC que vous avez créés précédemment à l'aide de la console Google Cloud, de gcloud CLI et de l'API Compute Engine.

Recommandé : Spécifiez Ubuntu LTS ou Ubuntu Pro comme image du système d'exploitation, car leur gestionnaire de paquets est compatible avec les pilotes UIO et VFIO sans IOMMU. Si vous ne voulez pas spécifier ces systèmes d'exploitation, nous vous recommandons d'indiquer Debian 11 ou version ultérieure pour un traitement plus rapide des paquets.

Console

Créez une VM qui utilise les deux sous-réseaux de réseau VPC que vous avez créés aux étapes précédentes en procédant comme suit.

Dans la console Google Cloud, accédez à Instances de VM.

Accéder à la page Instances de VM

La page Instances de VM s'ouvre.
Cliquez sur Créer une instance.

La page Créer une instance s'ouvre.
Dans le champ Nom, saisissez le nom de la VM.
Dans le menu Région, sélectionnez la même région dans laquelle vous avez créé les réseaux aux étapes précédentes.

Important : Si vous essayez de créer une VM dans une région différente de celle contenant les réseaux de plan de données et de contrôle, cela entraînera des erreurs.
Dans le menu Zone, sélectionnez une zone pour la VM.
Dans la section Configuration de la machine, procédez comme suit :
1. Sélectionnez l'une des options suivantes :
  - Pour les charges de travail courantes, sélectionnez l'onglet Usage général (par défaut).
  - Pour les charges de travail exigeantes en performances, sélectionnez l'onglet Optimisé pour le calcul.
  - Pour les charges de travail nécessitant des ratios mémoire/vCPU élevés, sélectionnez l'onglet À mémoire optimisée.
  - Pour les charges de travail utilisant des processeurs graphiques (GPU), sélectionnez l'onglet GPU.
2. Facultatif. Si vous avez spécifié GPU à l'étape précédente et que vous souhaitez modifier le GPU à rattacher à la VM, effectuez une ou plusieurs des opérations suivantes :
  1. Dans le menu Type de GPU, sélectionnez un type de GPU.
  2. Dans le menu Nombre de GPU, sélectionnez le nombre de GPU.
3. Dans le menu Séries, sélectionnez une série de machines.
  
  Important : gVNIC est compatible avec toutes les séries de machines, mais VirtIO-Net ne l'est pas avec les séries de machines les plus récentes (troisième génération et T2A). Si vous choisissez une série de machines qui n'est pas compatible avec votre type de vNIC, la création de la VM échouera.
4. Dans le menu Type de machine, sélectionnez un type de machine.
5. Facultatif : développez Configurations avancées et suivez les invites pour personnaliser davantage la machine pour cette VM.
Facultatif : dans la section Disque de démarrage, cliquez sur Modifier, puis suivez les invites pour modifier l'image disque.

Important : Si le type de vNIC que vous spécifiez pour cette VM est gVNIC, veillez à indiquer une image disque compatible. Sinon, la création de la VM échouera.
Développez la section Options avancées.
Développez la section Mise en réseau.
Dans la section Configuration des performances du réseau, effectuez les tâches suivantes.
1. Dans le menu Carte d'interface réseau, sélectionnez l'une des options ci-dessous :
  - Pour utiliser gVNIC, sélectionnez gVNIC.
  - Pour utiliser VirtIO-Net, sélectionnez VirtIO.
  Remarque : La valeur - dans le menu Carte d'interface réseau indique que le type de vNIC peut être gVNIC ou VirtIO-Net, en fonction de la famille de types de machines. Si gVNIC et VirtIO-Net sont tous deux disponibles pour une VM, le type par défaut est VirtIO-Net.
2. Facultatif : pour des réseaux hautes performances et une latence réduite, cochez la case Activer la mise en réseau Tier_1.
  
  Important : Vous ne pouvez activer la mise en réseau Tier_1 que lorsque vous utilisez gVNIC et que vous spécifiez un type de machine compatible ayant au moins 30 vCPU. Sinon, la création de la VM échouera.
Dans la section Interfaces réseau, effectuez les opérations suivantes :
1. Dans la ligne par défaut, cliquez sur Supprimer l'élément "par défaut".
2. Cliquez sur Ajouter une interface réseau.
  
  La section Nouvelle interface réseau apparaît.
3. Dans le menu Réseau, sélectionnez le réseau de plan de contrôle que vous avez créé aux étapes précédentes.
4. Cliquez sur OK.
5. Cliquez à nouveau sur Ajouter une interface réseau.
  
  La section Nouvelle interface réseau apparaît.
6. Dans le menu Réseau, sélectionnez le réseau de plan de données que vous avez créé aux étapes précédentes.
7. Cliquez sur OK.
Cliquez sur Créer.

La page Instances de VM s'ouvre. La création des VM peut prendre jusqu'à une minute.

gcloud

Créez une VM qui utilise les deux sous-réseaux de réseau VPC que vous avez créés aux étapes précédentes en utilisant la commande gcloud compute instances create avec les options suivantes.

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

Remplacez les éléments suivants :

VM_NAME : nom de la VM.
IMAGE_FAMILY : famille de l'image pour le système d'exploitation avec lequel le disque de démarrage sera initialisé. Vous pouvez également spécifier l'option --image=IMAGE et remplacer IMAGE par une version spécifique d'une image. Découvrez comment afficher la liste des images disponibles dans le projet d'image Compute Engine.
IMAGE_PROJECT : nom du projet d'image qui contient l'image disque.

Important : Si le type de vNIC que vous spécifiez pour cette VM est gVNIC, veillez à indiquer un projet et une famille d'images compatibles. Sinon, la création de la VM échouera.
MACHINE_TYPE : type de machine, prédéfini ou personnalisé, de la VM.

Important : gVNIC est compatible avec toutes les séries de machines, mais VirtIO-Net ne l'est pas avec les séries de machines les plus récentes (troisième génération et T2A). Si vous choisissez une série de machines qui n'est pas compatible avec votre type de vNIC, la création de la VM échouera.
VNIC_TYPE : type de vNIC à utiliser pour les réseaux de plan de contrôle et de plan de données. La valeur doit correspondre à l'un des éléments suivants :
- Si vous voulez utiliser gVNIC, spécifiez GVNIC.
- Si vous voulez utiliser VirtIO-Net, spécifiez VIRTIO_NET.
CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle que vous avez créé aux étapes précédentes.
CONTROL_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de contrôle que vous avez créé aux étapes précédentes.
DATA_PLANE_NETWORK_NAME : nom du réseau de plan de données que vous avez créé aux étapes précédentes.
DATA_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de contrôle que vous avez automatiquement créé aux étapes précédentes.
ZONE : zone dans laquelle créer la VM. Spécifiez une zone dans la même région du sous-réseau que vous avez créé aux étapes précédentes.

Par exemple, si vous voulez créer une VM nommée dpdk-vm dans la zone us-central1-a qui spécifie un disque persistant SSD de 512 Go, un type de machine C2 prédéfini avec 60 vCPU, un réseau Tier_1, ainsi qu'un réseau de plan de contrôle et un réseau de plan de données qui utilisent tous les deux gVNIC, exécutez la commande suivante :

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

Créez une VM qui utilise les deux sous-réseaux de réseau VPC que vous avez créés aux étapes précédentes en envoyant une requête POST à la méthode instances.insert avec les champs suivants :

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

{
  "name": "VM_NAME",
  "machineType": "zones/ZONE/machineTypes/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"
    }
  ]
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet contenant le réseau VPC de plan de contrôle et le réseau VPC de plan de données.
ZONE : zone dans laquelle créer la VM.
Important : Assurez-vous que la zone spécifiée répond aux exigences ci-dessous.
- La zone doit se trouver dans la même région que les sous-réseaux des réseaux de plan de contrôle et de plan de données.
- La zone de la VM doit correspondre à la zone contenant le type de machine à utiliser pour la VM.
Si vous essayez de créer une VM en dehors de la région qui contient les sous-réseaux spécifiés ou dans une zone qui ne correspond pas à celle du type de machine spécifié, cela entraînera des erreurs.
VM_NAME : nom de la VM.
MACHINE_TYPE : type de machine, prédéfini ou personnalisé, de la VM.

Important : gVNIC est compatible avec toutes les séries de machines, mais VirtIO-Net ne l'est pas avec les séries de machines les plus récentes (troisième génération et T2A). Si vous choisissez une série de machines qui n'est pas compatible avec votre type de vNIC, la création de la VM échouera.
IMAGE_PROJECT : nom du projet d'image qui contient l'image disque.
IMAGE_FAMILY : famille de l'image pour le système d'exploitation avec lequel le disque de démarrage sera initialisé. Vous pouvez également indiquer la version spécifique d'une image. Découvrez comment afficher la liste des images disponibles dans le projet d'image Compute Engine.

Important : Si le type de vNIC que vous spécifiez pour cette VM est gVNIC, veillez à indiquer une image disque compatible. Sinon, la création de la VM échouera.
CONTROL_PLANE_NETWORK_NAME : nom du réseau de plan de contrôle que vous avez créé aux étapes précédentes.
REGION : région contenant les sous-réseaux des réseaux de plan de contrôle et de plan de données.
CONTROL_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de contrôle que vous avez créé aux étapes précédentes.
VNIC_TYPE : type de vNIC à utiliser pour les réseaux de plan de contrôle et de plan de données. La valeur doit correspondre à l'un des éléments suivants :
- Si vous voulez utiliser gVNIC, spécifiez GVNIC.
- Si vous voulez utiliser VirtIO-Net, spécifiez VIRTIO_NET.
DATA_PLANE_NETWORK_NAME : nom du réseau de plan de données que vous avez créé aux étapes précédentes.
DATA_PLANE_SUBNET_NAME : nom du sous-réseau du réseau de plan de contrôle que vous avez créé aux étapes précédentes.

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

{
  "name": "dpdk-vm",
  "machineType": "zones/us-central1-a/machineTypes/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"
  }
}

Pour davantage d'options de configuration lorsque vous créez une VM, consultez la section Créer et démarrer une instance de VM.

Installer DPDK sur votre VM

Pour installer DPDK sur votre VM, procédez comme suit.

Connectez-vous à la VM que vous avez créée à la section précédente à l'aide de SSH.

Configurez les dépendances pour l'installation de 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

Installez DPDK :
```
wget https://fast.dpdk.org/rel/dpdk-23.07.tar.xz
tar xvf dpdk-23.07.tar.xz
cd dpdk-23.07
```
Important : Si le type de vNIC que vous avez spécifié aux étapes précédentes est gVNIC, vous devez installer DPDK version 22.11 ou ultérieure. Si vous utilisez une version antérieure de DPDK, vous recevrez des erreurs lorsque vous essaierez de tester ou d'utiliser DPDK sur votre VM.

Compilez DPDK avec les exemples :

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

Installer le pilote

Pour préparer l'exécution de DPDK sur un pilote, installez le pilote en sélectionnant une des méthodes suivantes :

Installez un pilote VFIO sans IOMMU.
Installez UIO.

Installer un pilote VFIO sans IOMMU

Pour installer le pilote VFIO sans IOMMU, procédez comme suit.

Assurez-vous que VFIO est activé :
```
cat /boot/config-$(uname -r) | grep NOIOMMU
```
Si VFIO n'est pas activé, effectuez les opérations dans la section Installer UIO.

Activez le mode No-IOMMU dans VFIO :

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

Installer UIO

Installez le pilote UIO sur DPDK à l'aide de l'une des méthodes suivantes :

Installez UIO à l'aide de git.
Installez UIO à l'aide des packages Linux.

Installer UIO à l'aide de git

Pour installer le pilote UIO sur DPDK en utilisant git, effectuez les étapes suivantes :

Clonez le dépôt git igb_uio dans un disque de votre VM :
```
git clone https://dpdk.org/git/dpdk-kmods
```
À partir du répertoire parent du dépôt git cloné, compilez le module et installez le pilote UIO sur DPDK :
```
pushd dpdk-kmods/linux/igb_uio
sudo make
sudo depmod && sudo insmod igb_uio.ko
popd
```

Installer UIO à l'aide des packages Linux

Pour installer le pilote UIO sur DPDK en utilisant des packages Linux, procédez comme suit.

Installez le package dpdk-igb-uio-dkms :

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

Installez le pilote UIO sur DPDK :
```
sudo modprobe igb_uio
```

Lier DPDK à un pilote et le tester

Pour lier DPDK au pilote que vous avez installé à la section précédente, procédez comme suit :

Obtenez le numéro d'emplacement de l'interface PCI (Peripheral Component Interconnect) pour l'interface réseau actuelle :
```
sudo lspci | grep -e "gVNIC" -e "Virtio network device"
```
Par exemple, si la VM utilise ens4 comme interface réseau, le numéro d'emplacement de la PCI est 00:04.0.
Arrêtez l'interface réseau connectée à l'adaptateur réseau :
```
sudo ip link set NETWORK_INTERFACE_NAME down
```
Remplacez NETWORK_INTERFACE_NAME par le nom de l'interface réseau spécifiée dans les réseaux VPC. Pour voir l'interface réseau que la VM utilise, consultez la configuration de l'interface réseau :
```
sudo ifconfig
```
Liez DPDK au pilote :
```
sudo dpdk-devbind.py --bind=DRIVER PCI_SLOT_NUMBER
```
Remplacez les éléments suivants :
- DRIVER : pilote à lier à DPDK. Spécifiez une des valeurs suivantes :
  - Pilote UIO : igb_uio
  - Pilote VFIO sans IOMMU : vfio-pci
- PCI_SLOT_NUMBER : numéro d'emplacement de la PCI de l'interface réseau actuelle au format 00:0NUMBER.0.

Créez le répertoire /mnt/huge, puis des "hugepages" que DPDK utilisera comme tampons :

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'

Testez DPDK pour vous assurer qu'il peut utiliser l'interface réseau que vous avez créée aux étapes précédentes. Pour ce faire, exécutez l'exemple d'application testpmd qui est inclus avec les bibliothèques DPDK :
```
sudo ./build/app/dpdk-testpmd
```
Pour en savoir plus sur les tests de DPDK, consultez la page Options de ligne de commande testpmd.

Annuler la liaison de DPDK

Après avoir utilisé DPDK, vous pouvez annuler sa liaison au pilote que vous avez installé à la section précédente. Pour annuler la liaison de DPDK, procédez comme suit.

Annulez la liaison de DPDK au pilote :
```
sudo dpdk-devbind.py -u PCI_SLOT_NUMBER
```
Remplacez PCI_SLOT_NUMBER par le numéro d'emplacement de la PCI que vous avez spécifié aux étapes précédentes. Si vous voulez vérifier le numéro d'emplacement de la PCI de l'interface réseau actuelle, utilisez :
```
sudo lspci | grep -e "gVNIC" -e "Virtio network device"
```
Par exemple, si la VM utilise ens4 comme interface réseau, le numéro d'emplacement de la PCI est 00:04.0.
Actualisez le pilote de réseau Compute Engine :
```
sudo bash -c 'echo PCI_SLOT_NUMBER > /sys/bus/pci/drivers/VNIC_DIRECTORY/bind'
sudo ip link set NETWORK_INTERFACE_NAME up
```
Remplacez les éléments suivants :
- PCI_SLOT_NUMBER : numéro d'emplacement de la PCI que vous avez spécifié aux étapes précédentes.
- VNIC_DIRECTORY : répertoire de la vNIC. Selon le le type de vNIC que vous utilisez, spécifiez une des valeurs suivantes :
  - gVNIC : gvnic
  - VirtIO-Net : virtio-pci
- NETWORK_INTERFACE_NAME : nom de l'interface réseau que vous avez spécifiée à la section précédente.

Étapes suivantes

Consultez les débits de bande passante réseau pour votre type de machine.
Apprenez-en plus sur la création et la gestion des réseaux VPC.
Apprenez-en plus sur les paramètres d'une MTU plus élevée avec des trames géantes.
Apprenez-en plus sur l'optimisation de TCP pour améliorer les performances réseau.