Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Optimiser les performances de gcloud CLI pour les buckets zonaux

Lorsque vous lisez des objets à partir de buckets zonaux dans Rapid Bucket à l'aide de la Google Cloud CLI, celle-ci applique automatiquement des configurations de simultanéité et de segmentation par défaut en fonction des ressources système disponibles.

Ce document décrit ces configurations par défaut et explique comment ajuster les performances de gcloud CLI pour des charges de travail spécifiques en configurant la simultanéité, la mise à l'échelle des processus et les fonctionnalités activables, telles que l'isolation NIC.

Avant de régler les paramètres de performances, vous devez créer un bucket zonal. Si vous téléchargez des objets sur un volume de stockage associé, tel qu'un Hyperdisk ou un SSD local, formatez et installez le volume dans votre environnement. Si vous prévoyez d'installer des buckets zonaux en tant que système de fichiers au lieu d'utiliser gcloud CLI, consultez Performances de Cloud Storage FUSE pour les buckets rapides. Pour en savoir plus sur les concepts généraux de segmentation, consultez Téléchargements d'objets segmentés.

Configurations par défaut de la simultanéité et du découpage

Les configurations par défaut décrites dans cette section s'appliquent spécifiquement lorsque vous lisez des objets à partir de buckets zonaux dans Rapid Bucket à l'aide de la gcloud CLI version 583.0.0 ou ultérieure. Pour les buckets Cloud Storage standards, gcloud CLI applique ses propres paramètres de concurrence par défaut.

Pour les buckets zonaux, la gcloud CLI définit automatiquement les paramètres de simultanéité et de segmentation par défaut en fonction du nombre de cœurs de processeur virtuel (vCPU) disponibles et du nombre d'objets que vous téléchargez (un ou plusieurs). Ces valeurs par défaut configurent les propriétés suivantes :

Nombre de processus : storage/process_count
Nombre de threads : storage/thread_count
Seuil de segmentation : storage/sliced_object_download_threshold
Nombre maximal de composants : storage/sliced_object_download_max_components
Taille du composant : storage/sliced_object_download_component_size

Les sections suivantes listent les valeurs par défaut pour les téléchargements d'un ou de plusieurs objets.

Téléchargements d'un seul objet

Lorsque vous téléchargez un seul objet, gcloud CLI applique les valeurs par défaut suivantes :

vCPU disponibles	Nombre de processus	Nombre de threads	Seuil de segmentation	Nombre maximal de composants	Taille du composant
`≥ 8`	`8`	`2`	`50 MiB`	`16`	`5 MiB`
`< 8`	`4`	`2`	`50 MiB`	`8`	`5 MiB`

Téléchargements de plusieurs objets

Lorsque vous téléchargez plusieurs objets simultanément, gcloud CLI applique les valeurs par défaut suivantes :

vCPU disponibles	Nombre de processus	Nombre de threads	Seuil de segmentation	Nombre maximal de composants	Taille du composant
`≥ 48`	`min(96, available_cores * 0.75)`	`1`	`10 MiB`	`5`	`5 MiB`
`4 to 47`	`16`	`4`	`10 MiB`	`10`	`5 MiB`
`< 4`	`2`	`10`	`50 MiB`	`10`	`5 MiB`

Configurer les propriétés de concurrence et de segmentation

Pour configurer et appliquer des paramètres d'optimisation personnalisés, procédez comme suit :

Installez ou mettez à jour la Google Cloud CLI vers la version 583.0.0 ou ultérieure.
Dans votre environnement de développement, exécutez la commande gcloud config configurations create pour créer et activer un profil de configuration :
```
gcloud config configurations create CONFIGURATION_NAME
```
Remplacez CONFIGURATION_NAME par le nom de votre profil de configuration, par exemple rapid-perf.
Exécutez la commande gcloud config set pour configurer les propriétés de simultanéité et de segmentation :
```
gcloud config set storage/thread_count THREAD_COUNT
gcloud config set storage/process_count PROCESS_COUNT
gcloud config set storage/sliced_object_download_threshold THRESHOLD_SIZE
gcloud config set storage/sliced_object_download_component_size COMPONENT_SIZE
gcloud config set storage/sliced_object_download_max_components MAX_COMPONENTS
```
Remplacez les éléments suivants :
- THREAD_COUNT : nombre de threads par processus de nœud de calcul, tel que 1.
- PROCESS_COUNT : nombre de processus de nœud de calcul, tel que 64.
- THRESHOLD_SIZE : seuil de taille d'objet minimal pour déclencher le fractionnement, tel que 128 MiB pour les charges de travail de plusieurs gigaoctets (ou 32 MiB pour les objets plus petits).
- COMPONENT_SIZE : taille cible de chaque partie de téléchargement, par exemple 128 MiB pour les charges de travail de plusieurs gigaoctets (ou 32 MiB pour les objets plus petits).
- MAX_COMPONENTS : nombre maximal de composants de tranche par objet, par exemple 16.
Pour en savoir plus sur ces propriétés, consultez Recommandations d'optimisation.
Pour télécharger des objets vers votre chemin de stockage local, exécutez la commande gcloud storage cp :
```
gcloud storage cp -r gs://BUCKET_NAME/SOURCE_PATH LOCAL_DESTINATION_PATH
```
Remplacez les éléments suivants :
- BUCKET_NAME : nom de votre bucket zonal.
- SOURCE_PATH : chemin d'accès au répertoire ou à l'objet source dans votre bucket.
- LOCAL_DESTINATION_PATH : chemin d'accès à votre répertoire local (par exemple, ./data/) ou point d'installation de votre volume de stockage local (par exemple, /mnt/hyperdisk/data/).

Recommandations de réglage

Suivez les recommandations ci-dessous pour ajuster la simultanéité, le fractionnement et les ressources système pour vos charges de travail.

Nombre de processus

Définissez la propriété storage/process_count pour mettre à l'échelle les processus de nœuds de calcul parallèles en fonction des cœurs de processeur disponibles. Limitez le nombre de processus à 80% maximum des cœurs de processeur disponibles :

storage/process_count = min(target_cores, 0.8 * available_cores)

Où :

target_cores : nombre de cœurs de processeur ou de processus de nœud de calcul que vous souhaitez allouer à votre transfert (par exemple, 64).
available_cores : nombre total de processeurs virtuels (vCPU) disponibles sur votre machine (par exemple, en exécutant nproc sur Linux).

Par exemple, si votre cible est de 64 processus de nœud de calcul sur une machine avec 80 processeurs virtuels ou plus, définissez storage/process_count sur 64. Sur une machine comportant moins de 80 processeurs virtuels, définissez storage/process_count sur 80% des processeurs virtuels disponibles (par exemple, 51 sur une VM à 64 processeurs virtuels).

Nombre de threads

Définissez la propriété storage/thread_count pour contrôler le nombre de threads par processus de nœud de calcul. Sur les machines comportant 48 processeurs virtuels ou plus, définissez storage/thread_count sur 1.

Limiter chaque processus de nœud de calcul à un seul thread sur les machines comportant 48 processeurs virtuels ou plus permet de réduire la contention des threads GIL (Global Interpreter Lock) et gRPC de Python.

Seuil de segmentation

Définissez la propriété storage/sliced_object_download_threshold pour spécifier la taille d'objet minimale requise pour déclencher les téléchargements fractionnés.

Nous vous recommandons de définir storage/sliced_object_download_threshold sur une valeur supérieure ou égale à storage/sliced_object_download_component_size.

Secteurs par objet

Définissez les propriétés storage/sliced_object_download_component_size et storage/sliced_object_download_max_components pour contrôler le nombre de sections parallèles générées par objet. gcloud CLI calcule les tranches par objet à l'aide de la formule suivante :

Slices per object = min(object_size / component_size, max_components)

Si un objet est suffisamment volumineux pour que le découpage par la valeur component_size dépasse la valeur max_components, la gcloud CLI ignore la valeur component_size et divise l'objet de manière égale en max_components tranches. Par exemple, le téléchargement d'un objet de 100 Gio avec component_size=128 MiB et max_components=16 produit 16 tranches de 6,25 Gio chacune.

La gcloud CLI télécharge chaque tranche indépendamment et en parallèle en fonction de votre capacité totale de nœuds de calcul (storage/process_count × storage/thread_count).

Saturation des nœuds de calcul

Pour maintenir une utilisation élevée des nœuds de calcul tout au long d'un transfert, vous devez ajuster le nombre de processus, le nombre de threads, la taille des composants et le nombre maximal de composants. Ces ajustements garantissent que les transferts standards génèrent suffisamment de tranches totales pour égaler ou dépasser votre capacité totale de workers :

Total slices across all objects >= storage/process_count * storage/thread_count

Par exemple, imaginons que vous téléchargiez quatre objets à l'aide de 64 processus de nœud de calcul (process_count=64 et thread_count=1) :

Quatre objets de 2 Gio : la définition de component_size=128 MiB génère 16 tranches par objet (4 × 16 = 64 tranches), ce qui utilise pleinement les 64 processus de nœud de calcul.
Quatre objets de 512 Mio : la définition de component_size=32 MiB génère 16 tranches par objet (4 × 16 = 64 tranches), ce qui utilise pleinement les 64 processus de nœud de calcul. En revanche, l'utilisation de component_size=128 MiB sur des objets de 512 Mio ne produit que quatre tranches par objet (16 tranches au total), ce qui laisse 48 processus de nœud de calcul inactifs.

Isolation de la carte d'interface réseau

Sur les machines Linux dotées de plus de 16 cœurs de processeur, vous pouvez activer l'isolation de la carte d'interface réseau (NIC) en définissant la propriété storage/use_nic_isolation sur True :

gcloud config set storage/use_nic_isolation True

Lorsque vous activez cette propriété, la gcloud CLI définit l'affinité du processeur (os.sched_setaffinity()). Cette configuration isole 10% des cœurs de processeur pour les requêtes d'interruption (IRQ) du matériel réseau et réserve les cœurs restants pour le traitement des données.