Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

gcloud CLI-Leistung für zonale Buckets optimieren

Wenn Sie Objekte aus zonalen Buckets in Rapid Bucket mit der Google Cloud CLI lesen, wendet die CLI automatisch Standardkonfigurationen für Nebenläufigkeit und Aufteilung basierend auf den verfügbaren Systemressourcen an.

In diesem Dokument werden diese Standardkonfigurationen beschrieben und es wird erläutert, wie Sie die Leistung der gcloud CLI für bestimmte Arbeitslasten optimieren können, indem Sie die Parallelität, die Prozessskalierung und Opt-in-Funktionen wie die NIC-Isolation konfigurieren.

Bevor Sie Leistungseinstellungen optimieren, müssen Sie einen zonalen Bucket erstellen. Wenn Sie Objekte auf ein angehängtes Speichervolume wie Hyperdisk oder Local SSD herunterladen, müssen Sie das Volume in Ihrer Umgebung formatieren und bereitstellen. Wenn Sie zonale Buckets als Dateisystem bereitstellen möchten, anstatt die gcloud CLI zu verwenden, lesen Sie den Abschnitt Cloud Storage FUSE-Leistung für Rapid Bucket. Allgemeine Informationen zum Aufteilen von Objekten finden Sie unter Downloads von aufgeteilten Objekten.

Standardkonfigurationen für Parallelität und Aufteilung

Die in diesem Abschnitt beschriebenen Standardkonfigurationen gelten speziell, wenn Sie Objekte aus zonalen Buckets in Rapid Bucket mit der gcloud CLI-Version 583.0.0 oder höher lesen. Für Standard-Cloud Storage-Buckets wendet die gcloud CLI eigene Standardeinstellungen für die Parallelität an.

Bei zonalen Buckets werden in der gcloud CLI automatisch Standardparameter für Parallelität und Aufteilung festgelegt, die auf der Anzahl der verfügbaren virtuellen CPU-Kerne (vCPU) und darauf basieren, ob Sie ein einzelnes oder mehrere Objekte herunterladen. Mit diesen Standardeinstellungen werden die folgenden Eigenschaften konfiguriert:

Anzahl der Prozesse: storage/process_count
Anzahl der Threads: storage/thread_count
Grenzwert für Segmentierung: storage/sliced_object_download_threshold
Maximale Anzahl von Komponenten: storage/sliced_object_download_max_components
Komponentengröße: storage/sliced_object_download_component_size

In den folgenden Abschnitten sind die Standardwerte für Downloads einzelner und mehrerer Objekte aufgeführt.

Downloads einzelner Objekte

Wenn Sie ein einzelnes Objekt herunterladen, wendet die gcloud CLI die folgenden Standardwerte an:

Verfügbare vCPUs	Anzahl der Prozesse	Threadanzahl	Schwellenwert für die Segmentierung	Maximale Anzahl von Komponenten	Komponentengröße
`≥ 8`	`8`	`2`	`50 MiB`	`16`	`5 MiB`
`< 8`	`4`	`2`	`50 MiB`	`8`	`5 MiB`

Mehrere Objekte herunterladen

Wenn Sie mehrere Objekte gleichzeitig herunterladen, werden in der gcloud CLI die folgenden Standardwerte angewendet:

Verfügbare vCPUs	Anzahl der Prozesse	Threadanzahl	Schwellenwert für die Segmentierung	Maximale Anzahl von Komponenten	Komponentengröße
`≥ 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`

Attribute für Parallelität und Aufteilung konfigurieren

So konfigurieren und wenden Sie benutzerdefinierte Einstellungen für die Optimierung an:

Installieren oder aktualisieren Sie die Google Cloud CLI auf Version 583.0.0 oder höher.
Führen Sie in Ihrer Entwicklungsumgebung den Befehl gcloud config configurations create aus, um ein Konfigurationsprofil zu erstellen und zu aktivieren:
```
gcloud config configurations create CONFIGURATION_NAME
```
Ersetzen Sie CONFIGURATION_NAME durch einen Namen für Ihr Konfigurationsprofil, z. B. rapid-perf.
Führen Sie den Befehl gcloud config set aus, um die Eigenschaften für Nebenläufigkeit und Aufteilung zu konfigurieren:
```
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
```
Ersetzen Sie Folgendes:
- THREAD_COUNT: Die Anzahl der Threads pro Worker-Prozess, z. B. 1.
- PROCESS_COUNT: die Anzahl der Worker-Prozesse, z. B. 64.
- THRESHOLD_SIZE: Der Mindestschwellenwert für die Objektgröße, der das Aufteilen auslöst, z. B. 128 MiB für Workloads mit mehreren Gigabyte oder 32 MiB für kleinere Objekte.
- COMPONENT_SIZE: Die Zielgröße für jedes Download-Segment, z. B. 128 MiB für Workloads mit mehreren Gigabyte oder 32 MiB für kleinere Objekte.
- MAX_COMPONENTS: Die maximale Anzahl von Slice-Komponenten pro Objekt, z. B. 16.
Weitere Informationen zu diesen Attributen finden Sie unter Empfehlungen optimieren.
Führen Sie den Befehl gcloud storage cp aus, um Objekte in Ihren lokalen Speicherpfad herunterzuladen:
```
gcloud storage cp -r gs://BUCKET_NAME/SOURCE_PATH LOCAL_DESTINATION_PATH
```
Ersetzen Sie Folgendes:
- BUCKET_NAME: Der Name Ihres zonalen Buckets.
- SOURCE_PATH: Das Quellverzeichnis oder der Objektpfad in Ihrem Bucket.
- LOCAL_DESTINATION_PATH: Ihr lokaler Verzeichnispfad (z. B. ./data/) oder der Bereitstellungspunkt Ihres lokalen Speichervolumes (z. B. /mnt/hyperdisk/data/).

Empfehlungen: Feinabstimmung

Mit den folgenden Empfehlungen können Sie die Nebenläufigkeit, das Aufteilen und die Systemressourcen für Ihre Arbeitslasten optimieren.

Anzahl der Prozesse

Legen Sie die storage/process_count-Eigenschaft fest, um parallele Worker-Prozesse basierend auf den verfügbaren CPU-Kernen zu skalieren. Die Anzahl der Prozesse auf maximal 80% der verfügbaren CPU-Kerne beschränken:

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

Wobei:

target_cores: Die Anzahl der CPU-Kerne oder Worker-Prozesse, die Sie für die Übertragung zuweisen möchten (z. B. 64).
available_cores: die Gesamtzahl der auf Ihrem Computer verfügbaren virtuellen CPUs (vCPUs), z. B. durch Ausführen von nproc unter Linux.

Wenn Sie beispielsweise 64 Worker-Prozesse auf einer Maschine mit 80 oder mehr vCPUs als Ziel haben, legen Sie storage/process_count auf 64 fest. Legen Sie auf einer Maschine mit weniger als 80 vCPUs storage/process_count auf 80% der verfügbaren vCPUs fest (z. B. 51 auf einer VM mit 64 vCPUs).

Threadanzahl

Legen Sie die Eigenschaft storage/thread_count fest, um die Anzahl der Threads pro Worker-Prozess zu steuern. Legen Sie auf Maschinen mit 48 oder mehr vCPUs storage/thread_count auf 1 fest.

Wenn jeder Worker-Prozess auf Maschinen mit 48 oder mehr vCPUs auf einen einzelnen Thread beschränkt wird, werden Konflikte zwischen dem Python Global Interpreter Lock (GIL) und gRPC-Threads reduziert.

Schwellenwert für die Segmentierung

Legen Sie die storage/sliced_object_download_threshold-Property fest, um die Mindestobjektgröße anzugeben, die erforderlich ist, um segmentierte Downloads auszulösen.

Wir empfehlen, storage/sliced_object_download_threshold auf einen Wert zu setzen, der größer oder gleich storage/sliced_object_download_component_size ist.

Sektoren pro Objekt

Legen Sie die Attribute storage/sliced_object_download_component_size und storage/sliced_object_download_max_components fest, um die Anzahl der parallelen Slices zu steuern, die pro Objekt generiert werden. In der gcloud CLI werden Slices pro Objekt mit der folgenden Formel berechnet:

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

Wenn ein Objekt so groß ist, dass das Aufteilen nach dem component_size-Wert den max_components-Wert überschreiten würde, ignoriert die gcloud CLI den component_size-Wert und teilt das Objekt gleichmäßig in max_components Scheiben auf. Wenn Sie beispielsweise ein 100 GiB großes Objekt mit component_size=128 MiB und max_components=16 herunterladen, werden 16 Slices mit jeweils 6,25 GiB erstellt.

Die gcloud CLI lädt die einzelnen Slices unabhängig und parallel basierend auf Ihrer gesamten Worker-Kapazität (storage/process_count × storage/thread_count) herunter.

Worker-Sättigung

Damit die Worker-Auslastung während einer Übertragung hoch bleibt, müssen Sie die Anzahl der Prozesse, die Anzahl der Threads, die Komponentengröße und die maximale Anzahl der Komponenten anpassen. Durch diese Anpassungen wird dafür gesorgt, dass bei typischen Übertragungen genügend Slices generiert werden, um die Gesamtkapazität Ihrer Worker zu erreichen oder zu überschreiten:

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

Angenommen, Sie laden vier Objekte mit 64 Worker-Prozessen herunter (process_count=64 und thread_count=1):

Vier Objekte mit je 2 GiB: Wenn Sie component_size=128 MiB festlegen, werden 16 Slices pro Objekt generiert (4 × 16 = 64 Slices). Dadurch werden alle 64 Worker-Prozesse vollständig genutzt.
Vier Objekte mit 512 MiB: Wenn Sie component_size=32 MiB festlegen, werden 16 Slices pro Objekt generiert (4 × 16 = 64 Slices), wodurch alle 64 Workerprozesse vollständig genutzt werden. Wenn Sie component_size=128 MiB für 512 MiB-Objekte verwenden, werden dagegen nur 4 Slices pro Objekt (insgesamt 16 Slices) erstellt, sodass 48 Workerprozesse im Leerlauf sind.

NIC-Isolation

Auf Linux-Computern mit mehr als 16 CPU-Kernen können Sie die Isolierung von Netzwerkkarten (NICs) aktivieren, indem Sie die Eigenschaft storage/use_nic_isolation auf True setzen:

gcloud config set storage/use_nic_isolation True

Wenn Sie diese Eigenschaft aktivieren, legt die gcloud CLI die CPU-Affinität (os.sched_setaffinity()) fest. Mit dieser Konfiguration werden 10% der CPU-Kerne für Interruptanfragen (IRQs) der Netzwerkhardware isoliert und die verbleibenden Kerne für die Datenverarbeitung reserviert.