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 die Google Cloud CLI Objekte aus zonalen Buckets in Rapid Bucket liest, werden automatisch Standardkonfigurationen für Parallelität und Segmentierung basierend auf den verfügbaren Systemressourcen angewendet.

Auf dieser Seite werden diese Standardkonfigurationen beschrieben und erklärt, wie Sie mit der gcloud CLI die Nebenläufigkeit, die Verarbeitungsskalierung und Opt-in-Funktionen (z. B. NIC-Isolation) weiter optimieren können, um die Leistung für bestimmte Arbeitslasten zu verbessern. Informationen zum Optimieren der Leistung beim Bereitstellen von zonalen Buckets als Dateisystem, siehe Leistung von Cloud Storage FUSE für Rapid Bucket.

Bevor Sie Leistungseinstellungen konfigurieren, müssen Sie sicherstellen, dass Sie einen zonalen Bucket erstellen. Wenn Sie Objekte in ein angehängtes Speichervolume (z. B. Hyperdisk oder lokale SSD) herunterladen möchten, müssen Sie sicherstellen, dass Sie das Volume in Ihrer Umgebung formatieren und bereitstellen. Allgemeine Informationen zur Segmentierung finden Sie unter Segmentierte Objektdownloads.

Standardkonfigurationen für Parallelität und Segmentierung

Die Standardkonfigurationen in diesem Abschnitt gelten speziell für das Lesen von Objekten aus zonalen Buckets in Rapid Bucket mit der gcloud CLI Version 583.0.0 oder höher. Für Standard-Cloud Storage-Buckets wendet die gcloud CLI eigene Standardeinstellungen für die Parallelität an.

Für zonale Buckets legt die gcloud CLI automatisch Standardparameter für Nebenläufigkeit und Segmentierung basierend auf der Anzahl der verfügbaren virtuellen CPU-Kerne (vCPU) und darauf fest, ob Sie ein einzelnes oder mehrere Objekte herunterladen. In den folgenden Tabellen sind die Standardwerte für diese Attribute aufgeführt:

Anzahl der Prozesse: storage/process_count
Anzahl der Threads: storage/thread_count
Segmentierungsgrenzwert: storage/sliced_object_download_threshold
Maximale Anzahl von Komponenten: storage/sliced_object_download_max_components
Komponentengröße: storage/sliced_object_download_component_size

Downloads einzelner Objekte

Beim Herunterladen eines einzelnen Objekts wendet die gcloud CLI die folgenden Standardwerte an:

Verfügbare vCPUs	Anzahl der Prozesse	Anzahl der Threads	Segmentierungsgrenzwert	Maximale Anzahl von Komponenten	Komponentengröße
`≥ 8`	`8`	`2`	`50 MiB`	`16`	`5 MiB`
`< 8`	`4`	`2`	`50 MiB`	`8`	`5 MiB`

Downloads mehrerer Objekte

Beim Herunterladen mehrerer Objekte gleichzeitig wendet die gcloud CLI die folgenden Standardwerte an:

Verfügbare vCPUs	Anzahl der Prozesse	Anzahl der Threads	Segmentierungsgrenzwert	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`

Konfigurationen für Parallelität und Segmentierung optimieren

In diesem Abschnitt wird beschrieben, wie Sie die Einstellungen für Nebenläufigkeit und Segmentierung mit der gcloud CLI konfigurieren. Außerdem werden empfohlene Werte für gängige Hardwareumgebungen angegeben.

Konfiguration anwenden

So konfigurieren und wenden Sie benutzerdefinierte Optimierungseinstellungen an:

Installieren oder aktualisieren Sie die Google Cloud CLI auf Version 583.0.0 oder höher.
Führen Sie in Ihrer Entwicklungsumgebung den gcloud config configurations create Befehl 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 Attribute für Nebenläufigkeit und Segmentierung 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 die Platzhalter durch Werte, die für Ihre Arbeitslast geeignet sind:
- 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 Mindestgrenzwert für die Objektgröße, um die Segmentierung auszulösen, z. B. 128 MiB für Arbeitslasten mit mehreren Gigabyte (oder 32 MiB für kleinere Objekte).
- COMPONENT_SIZE: die Zielgröße jedes Download-Segments, z. B. 128 MiB für Arbeitslasten mit mehreren Gigabyte (oder 32 MiB für kleinere Objekte).
- MAX_COMPONENTS: die maximale Anzahl von Segmentkomponenten pro Objekt, z. B. 16.
Weitere Informationen zu diesen Attributen finden Sie unter Empfehlungen: Feinabstimmung.
Laden Sie Objekte in Ihren lokalen Speicherpfad herunter, indem Sie den gcloud storage cp Befehl ausführen:
```
gcloud storage cp -r gs://BUCKET_NAME/SOURCE_PATH/ /DESTINATION_PATH/
```
Ersetzen Sie Folgendes:
- BUCKET_NAME: der Name Ihres zonalen Buckets.
- SOURCE_PATH: das Quellverzeichnis oder der Objektpfad in Ihrem Bucket.
- DESTINATION_PATH: Ihr lokaler Verzeichnispfad, z. B. ./data/, oder der Bereitstellungspunkt Ihres lokalen Speichervolumes, z. B. /mnt/hyperdisk/data/.

Empfehlungen: Feinabstimmung

Beachten Sie die folgenden Richtlinien, um geeignete Werte für die Platzhalter in den vorherigen Schritten auszuwählen:

Anzahl der Prozesse

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

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 virtuellen CPUs (vCPUs), die auf Ihrer Maschine verfügbar sind (z. B. durch Ausführen von nproc unter Linux).

Wenn Ihr Ziel beispielsweise 64 Worker-Prozesse sind, können Sie für Maschinen mit 80 oder mehr vCPUs storage/process_count auf 64 festlegen. Für Maschinen mit weniger als 80 vCPUs legen Sie storage/process_count auf 80% der verfügbaren Kerne fest (z. B. 51 auf einer VM mit 64 vCPUs).

Anzahl der Threads

Legen Sie das Attribut 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 Sie jeden Worker-Prozess auf Maschinen mit vielen Kernen auf einen einzelnen Thread beschränken, können Sie die Python Global Interpreter Lock (GIL) und die Thread-Konkurrenz von gRPC reduzieren.

Segmentierungsgrenzwert

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

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

Segmente pro Objekt

Legen Sie die Attribute storage/sliced_object_download_component_size und storage/sliced_object_download_max_components fest, um die Anzahl der parallel generierten Segmente pro Objekt zu steuern. Die gcloud CLI berechnet die Segmente pro Objekt mit der folgenden Formel:

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

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

Jedes Segment wird unabhängig und parallel basierend auf Ihrer gesamten Worker-Kapazität (storage/process_count × storage/thread_count) heruntergeladen.

Worker-Auslastung

Um eine hohe Worker-Auslastung während der gesamten Übertragung aufrechtzuerhalten, passen Sie die Anzahl der Prozesse, die Anzahl der Threads, die Komponentengröße und die maximale Anzahl von Komponenten so an, dass bei Ihren typischen Übertragungen genügend Segmente generiert werden, um Ihre gesamte Worker-Kapazität zu erreichen oder zu übertreffen:

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 2-GiB-Objekte: Wenn Sie component_size=128 MiB festlegen, werden 16 Segmente pro Objekt generiert (4 × 16 = 64 Segmente), wodurch alle 64 Worker-Prozesse vollständig genutzt werden.
Vier 512-MiB-Objekte: Wenn Sie component_size=32 MiB festlegen, werden 16 Segmente pro Objekt generiert (4 × 16 = 64 Segmente). Wenn Sie dagegen component_size=128 MiB für 512-MiB-Objekte verwenden, werden nur 4 Segmente pro Objekt (insgesamt 16 Segmente) erstellt, sodass 48 Worker-Prozesse im Leerlauf sind.

NIC-Isolation

Auf Linux-Maschinen mit mehr als 16 CPU-Kernen können Sie die Isolation der Netzwerkschnittstellen karte (NIC) aktivieren, indem Sie das storage/use_nic_isolation Attribut auf True setzen:

gcloud config set storage/use_nic_isolation True

Wenn Sie dieses Attribut aktivieren, legt die gcloud CLI die CPU-Affinität fest (os.sched_setaffinity()). Mit dieser Konfiguration werden 10% der CPU-Kerne für Hardware-Interruptanfragen (IRQs) reserviert und die restlichen Kerne für die Datenverarbeitung.