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 le Google Cloud CLI lit des objets à partir de buckets zonaux dans Rapid Bucket, il applique automatiquement des configurations de simultanéité et de découpage par défaut en fonction des ressources système disponibles.

Cette page décrit ces configurations par défaut et explique comment utiliser gcloud CLI pour affiner la simultanéité, le scaling des processus et les fonctionnalités d'activation (telles que l'isolation de la carte d'interface réseau) afin d'améliorer les performances de charges de travail spécifiques. Pour régler les performances lors de l'installation de buckets zonaux en tant que système de fichiers, consultez Performances de Cloud Storage FUSE pour Rapid Bucket.

Avant de configurer les paramètres de performances, assurez-vous de créer un bucket zonal. Si vous prévoyez de télécharger des objets sur un volume de stockage associé (tel que Hyperdisk ou SSD local), assurez-vous de formater et d'installer le volume dans votre environnement. Pour obtenir des informations générales sur les concepts de découpage, consultez Téléchargements d'objets en plusieurs parties.

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

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

Pour les buckets zonaux, gcloud CLI définit automatiquement les paramètres de simultanéité et de découpage par défaut en fonction du nombre de cœurs de processeur virtuel (vCPU) disponibles et du fait que vous téléchargez un ou plusieurs objets. Les tableaux suivants mappent les valeurs par défaut de ces propriétés :

Nombre de processus : storage/process_count
Nombre de threads : storage/thread_count
Seuil de découpage : storage/sliced_object_download_threshold
Nombre maximal de composants : storage/sliced_object_download_max_components
Taille des composants : storage/sliced_object_download_component_size

Téléchargements d'objets uniques

Lors du téléchargement d'un seul objet, gcloud CLI applique les valeurs par défaut suivantes :

Processeurs virtuels disponibles	Nombre de processus	Nombre de threads	Seuil de découpage	Nombre maximal de composants	Taille des composants
`≥ 8`	`8`	`2`	`50 MiB`	`16`	`5 MiB`
`< 8`	`4`	`2`	`50 MiB`	`8`	`5 MiB`

Téléchargements de plusieurs objets

Lors du téléchargement simultané de plusieurs objets, gcloud CLI applique les valeurs par défaut suivantes :

Processeurs virtuels disponibles	Nombre de processus	Nombre de threads	Seuil de découpage	Nombre maximal de composants	Taille des composants
`≥ 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`

Ajuster les configurations de simultanéité et de découpage

Cette section explique comment configurer les paramètres de simultanéité et de découpage à l'aide de gcloud CLI, et fournit des valeurs recommandées pour les environnements matériels courants.

Appliquer une configuration

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

Installez ou mettez à jour Google Cloud CLI vers la version 583.0.0 ou ultérieure.
Dans votre environnement de développement, exécutez la gcloud config configurations create commande 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 découpage :
```
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 espaces réservés par des valeurs adaptées à votre charge de travail :
- THREAD_COUNT: nombre de threads par processus de nœud de calcul, par exemple 1.
- PROCESS_COUNT: nombre de processus de nœud de calcul, par exemple 64.
- THRESHOLD_SIZE: seuil minimal de taille d'objet pour déclencher le découpage, par exemple 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 découpage par objet, par exemple 16.
Pour en savoir plus sur ces propriétés, consultez Recommandations de réglage.
Téléchargez des objets vers votre chemin de stockage local en exécutant la gcloud storage cp commande :
```
gcloud storage cp -r gs://BUCKET_NAME/SOURCE_PATH/ /DESTINATION_PATH/
```
Remplacez les éléments suivants :
- BUCKET_NAME : nom de votre bucket zonal.
- SOURCE_PATH: chemin d'accès au répertoire source ou à l'objet dans votre bucket.
- DESTINATION_PATH: chemin d'accès à votre répertoire local, tel que ./data/, ou point d'installation de votre volume de stockage local, tel que /mnt/hyperdisk/data/.

Recommandations de réglage

Pour choisir des valeurs appropriées pour les espaces réservés des étapes précédentes, consultez les consignes suivantes :

Nombre de processus

Définissez la storage/process_countpropriété pour mettre à l'échelle les processus de nœud 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 sous Linux).

Par exemple, si votre cible est de 64 processus de nœud de calcul, les machines comportant 80 processeurs virtuels ou plus peuvent définir storage/process_count sur 64. Pour les machines comportant moins de 80 processeurs virtuels, définissez storage/process_count sur 80% des cœurs 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 à nombre élevé de cœurs permet de réduire la contention des threads Python Global Interpreter Lock (GIL) et gRPC.

Seuil de découpage

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

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

Parties 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 parties parallèles générées par objet. gcloud CLI calcule les parties 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, gcloud CLI ignore la valeur component_size et divise l'objet de manière égale en parties max_components. Par exemple, le téléchargement d'un objet de 100 Gio avec component_size=128 MiB et max_components=16 génère 16 parties de 6,25 Gio chacune.

Chaque partie est téléchargée indépendamment et en parallèle en fonction de votre capacité totale de nœud 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, ajustez le nombre de processus, le nombre de threads, la taille des composants et le nombre maximal de composants afin que vos transferts types génèrent suffisamment de parties totales pour égaler ou dépasser votre capacité totale de nœud de calcul :

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

Par exemple, imaginons que vous téléchargez 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 parties par objet (4 × 16 = 64 parties), 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 parties par objet (4 × 16 = 64 parties). En revanche, l'utilisation de component_size=128 MiB sur des objets de 512 Mio ne produit que 4 parties par objet (16 parties 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 comportant plus de 16 cœurs de processeur, vous pouvez activer l'isolation de la carte d'interface réseau en définissant la storage/use_nic_isolationpropriété sur True :

gcloud config set storage/use_nic_isolation True

Lorsque vous activez cette propriété, 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 matérielle du réseau (IRQ) et réserve les cœurs restants pour le traitement des données.