Diese Seite wurde von der Cloud Translation API übersetzt.

Von Compute Engine aus verbinden

In dieser Anleitung wird beschrieben, wie Sie einen einzelnen Compute Engine-Client erstellen und mit Ihrer Parallelstore-Instanz verbinden.

Wenn Sie eine Verbindung über mehrere Compute Engine-Clients herstellen möchten, folgen Sie der Anleitung unter Verbindung von der Compute Engine herstellen: mehrere Clients.

Für eine bessere Leistung sollten Client-Compute Engine-VMs in derselben Zone wie die Parallelstore-Instanz erstellt werden.

Erforderliche Berechtigungen

Sie benötigen die folgende IAM-Rolle, um eine Compute Engine-VM zu erstellen:

„Compute-Instanzadministrator“ (v1) (roles/compute.instanceAdmin.v1). Weitere Informationen finden Sie in der Compute Engine-Dokumentation.

Compute Engine-VM erstellen

Folgen Sie der Anleitung, um eine Compute Engine-VM mit einem der folgenden Images zu erstellen:

Sie können einen beliebigen Maschinentyp und ein beliebiges Bootlaufwerk auswählen. Wir empfehlen mindestens den Maschinentyp c2-standard-4. Für eine höhere Clientleistung erhöhen Sie die Anzahl der vCPUs, um den Netzwerkdurchsatz zu steigern. Beispiel: Eine c3-standard-176 mit Tier 1-Netzwerk bietet eine ausgehende Bandbreite von 200 Gbit/s.

Google Cloud Console

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Zu „VM-Instanzen“
Wählen Sie Ihr Projekt aus und klicken Sie auf Weiter.
Klicken Sie auf Instanz erstellen.
Geben Sie unter Name einen Namen für Ihre VM ein. Weitere Informationen finden Sie unter Namenskonvention für Ressourcen.
Wählen Sie in den Drop-down-Menüs die Region und die Zone für die VM aus. Ihre VM sollte sich in derselben Zone wie Ihre Parallelstore-Instanz befinden.
Wählen Sie in der Liste eine Maschinenkonfiguration für Ihre VM aus.
Klicken Sie im Abschnitt Bootlaufwerk auf Ändern.
Wählen Sie den Tab Öffentliche Images aus.
Wählen Sie im Drop-down-Menü Betriebssystem eine der folgenden Optionen aus: HPC-VM-Image, Ubuntu oder Debian.
Wählen Sie im Drop-down-Menü Version eine der folgenden Optionen aus: HPC Rocky Linux 8, Ubuntu 22.04 LTS oder Debian GNU/Linux 12 (Bookworm). Wählen Sie entweder die x86/64-Version oder die Arm64-Version aus, die Ihrem Maschinentyp entspricht.
Klicken Sie auf Auswählen, um die Bootlaufwerksoptionen zu bestätigen.
Maximieren Sie den Abschnitt Erweiterte Optionen und dann Netzwerk.
Wählen Sie unter Netzwerkschnittstellen das VPC-Netzwerk aus, das Sie unter VPC-Netzwerk konfigurieren erstellt haben.
Klicken Sie zum Erstellen und Starten der VM auf Erstellen.

gcloud

Verwenden Sie das gcloud-Befehlszeilentool, um eine VM zu erstellen:

HPC Rocky Linux 8

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=LOCATION \
  --machine-type=c2d-standard-112 \
  --network-interface=stack-type=IPV4_ONLY,subnet=NETWORK_NAME,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=VM_NAME,\
image=projects/cloud-hpc-image-public/global/images/hpc-rocky-linux-8-v20240126,\
mode=rw,size=100,type=pd-balanced

Rocky Linux 9 optimiert

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=LOCATION \
  --machine-type=c2d-standard-112 \
  --network-interface=stack-type=IPV4_ONLY,subnet=NETWORK_NAME,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=VM_NAME,\
image=projects/rocky-linux-cloud/global/images/rocky-linux-9-optimized-gcp-v20241112,\
mode=rw,size=100,type=pd-balanced

RHEL 9

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=LOCATION \
  --machine-type=c2d-standard-112 \
  --network-interface=stack-type=IPV4_ONLY,subnet=NETWORK_NAME,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=VM_NAME,\
image=projects/rhel-cloud/global/images/rhel-9-v20241112,\
mode=rw,size=100,type=pd-balanced

Ubuntu 22.04

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=LOCATION \
  --machine-type=c2d-standard-112 \
  --network-interface=stack-type=IPV4_ONLY,subnet=NETWORK_NAME,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=VM_NAME,\
image=projects/ubuntu-os-cloud/global/images/ubuntu-2204-jammy-v20240927,\
mode=rw,size=100,type=pd-balanced

Debian 12

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=LOCATION \
  --machine-type=c2d-standard-112 \
  --network-interface=stack-type=IPV4_ONLY,subnet=NETWORK_NAME,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=VM_NAME,\
image=projects/debian-cloud/global/images/debian-12-bookworm-v20240415,\
mode=rw,size=100,type=pd-balanced

Weitere Informationen zu den verfügbaren Optionen finden Sie in der Compute Engine-Dokumentation.

SSH-Verbindung zur Client-VM herstellen

Google Cloud Console

Wenn Sie eine SSH-Verbindung zu Ihrer Compute Engine-VM herstellen möchten, müssen Sie zuerst eine Firewallregel erstellen, die SSH zulässt.

Rufen Sie in der Google Cloud Console die Seite der Firewall-Richtlinien auf.

Zu den Firewall-Richtlinien
Klicken Sie auf Firewallregel erstellen.
Geben Sie einen Namen für die Regel ein.
Wählen Sie unter Netzwerk das zuvor erstellte VPC-Netzwerk aus.
Wählen Sie Eingehend als Traffic-Richtung und Zulassen als Aktion bei Übereinstimmung aus.
Wählen Sie im Drop-down-Menü Ziele die Option Alle Instanzen im Netzwerk aus.
Geben Sie im Feld IPv4-Quellbereiche den Wert 0.0.0.0/0 ein.
Wählen Sie unter Protokolle und Ports die Option Angegebene Protokolle und Ports aus.
Wählen Sie TCP aus und geben Sie 22 in das Feld Ports ein.
Klicken Sie auf Erstellen.

Stellen Sie dann eine SSH-Verbindung zur VM her:

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Zu "VM-Instanzen"
Suchen Sie in der Instanztabelle nach der Zeile mit Ihrer Instanz und klicken Sie in der Spalte Verbinden auf SSH.
Wenn Sie dazu aufgefordert werden, klicken Sie auf Autorisieren, um die Verbindung zuzulassen.

gcloud

Wenn Sie eine SSH-Verbindung zu Ihrer Compute Engine-VM herstellen möchten, müssen Sie zuerst eine Firewallregel erstellen, die SSH zulässt.

gcloud compute firewall-rules create FIREWALL_RULE_NAME \
  --allow=tcp:22 \
  --network=NETWORK_NAME \
  --source-ranges=0.0.0.0/0 \
  --project=PROJECT_ID

Verbinden Sie sich dann mit gcloud compute ssh:

gcloud compute ssh VM_NAME --zone=ZONE --project=PROJECT_ID

DAOS-Clientbibliothek installieren

Die DAOS-Clientbibliothek bietet eine POSIX-ähnliche Schnittstelle zur Parallelstore-Datenebene. Die Software wird als Agent auf Ihren Clientcomputern ausgeführt und muss installiert und ausgeführt werden, bevor Sie auf Ihre Daten zugreifen können.

HPC Rocky Linux 8

Die folgenden Befehle müssen auf jeder Compute Engine-VM ausgeführt werden.

Fügen Sie das Parallelstore-Paket-Repository hinzu:

sudo tee /etc/yum.repos.d/parallelstore-v2-6-el8.repo << EOF
[parallelstore-v2-6-el8]
name=Parallelstore EL8 v2.6
baseurl=https://us-central1-yum.pkg.dev/projects/parallelstore-packages/v2-6-el8
enabled=1
repo_gpgcheck=0
gpgcheck=0
EOF

Aktualisieren Sie den lokalen Metadaten-Cache:
```
sudo dnf makecache
```

Installieren Sie daos-client:

sudo dnf install -y epel-release && \
sudo dnf install -y daos-client

libfabric upgraden:
```
sudo dnf upgrade -y libfabric
```

Rocky Linux 9 optimiert

Die folgenden Befehle müssen auf jeder Compute Engine-VM ausgeführt werden.

Fügen Sie das Parallelstore-Paket-Repository hinzu:

sudo tee /etc/yum.repos.d/parallelstore-v2-6-el9.repo << EOF
[parallelstore-v2-6-el9]
name=Parallelstore EL9 v2.6
baseurl=https://us-central1-yum.pkg.dev/projects/parallelstore-packages/v2-6-el9
enabled=1
repo_gpgcheck=0
gpgcheck=0
EOF

Aktualisieren Sie den lokalen Metadaten-Cache:
```
sudo dnf makecache
```

Installieren Sie daos-client:

sudo dnf install -y epel-release && \
sudo dnf install -y daos-client

libfabric upgraden:
```
sudo dnf upgrade -y libfabric
```

RHEL 9

Die folgenden Befehle müssen auf jeder Compute Engine-VM ausgeführt werden.

Fügen Sie das Parallelstore-Paket-Repository hinzu:

sudo tee /etc/yum.repos.d/parallelstore-v2-6-el9.repo << EOF
[parallelstore-v2-6-el9]
name=Parallelstore EL9 v2.6
baseurl=https://us-central1-yum.pkg.dev/projects/parallelstore-packages/v2-6-el9
enabled=1
repo_gpgcheck=0
gpgcheck=0
EOF

Aktualisieren Sie den lokalen Metadaten-Cache:
```
sudo dnf makecache
```

Installieren Sie daos-client:

sudo dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm

sudo dnf install -y epel-release && \
sudo dnf install -y daos-client

libfabric upgraden:
```
sudo dnf upgrade -y libfabric
```

Ubuntu 22.04

Die folgenden Befehle müssen auf jeder Compute Engine-VM ausgeführt werden.

Fügen Sie das Parallelstore-Paket-Repository hinzu:

curl https://us-central1-apt.pkg.dev/doc/repo-signing-key.gpg | sudo apt-key add -
echo "deb https://us-central1-apt.pkg.dev/projects/parallelstore-packages v2-6-deb main" | sudo tee -a /etc/apt/sources.list.d/artifact-registry.list

Aktualisieren Sie den Paketindex:
```
sudo apt update
```
Installieren Sie daos-client:
```
sudo apt install -y daos-client
```

Debian 12

Die folgenden Befehle müssen auf jeder Compute Engine-VM ausgeführt werden.

Fügen Sie das Parallelstore-Paket-Repository hinzu:

curl https://us-central1-apt.pkg.dev/doc/repo-signing-key.gpg | sudo apt-key add -
echo "deb https://us-central1-apt.pkg.dev/projects/parallelstore-packages v2-6-deb main" | sudo tee -a /etc/apt/sources.list.d/artifact-registry.list

Aktualisieren Sie den Paketindex:
```
sudo apt update
```
Installieren Sie daos-client:
```
sudo apt install -y daos-client
```

Limit für geöffnete Dateien erhöhen (nur Ubuntu)

Bei VMs mit Ubuntu 22.04 müssen Sie das Limit für geöffnete Dateien auf 131072 erhöhen, um dfuse und die Interception-Bibliothek zu unterstützen.

Wenn Sie die Interception Library nicht verwenden möchten, können Sie alternativ ulimit -n 131072 direkt vor dem Starten von dfuse ausführen.

Wenn Sie das Limit für geöffnete Dateien von 1.024 erhöhen möchten, führen Sie die folgenden Befehle auf jeder VM aus.

sudo tee -a /etc/security/limits.conf <<EOF
* soft nofile 131072
* hard nofile 131072
EOF

Führen Sie dann einen Neustart aus:

sudo reboot

Stellen Sie nach dem Neustart wieder eine SSH-Verbindung zur Client-VM her.

DAOS-Agent-Konfiguration aktualisieren

Aktualisieren Sie /etc/daos/daos_agent.yml so:

Entfernen Sie den Kommentar und aktualisieren Sie access_points mit den accessPoints-IP-Adressen aus den Parallelstore-Instanzeigenschaften. Beispiel: access_points: ['172.21.95.2', '172.21.95.4', '172.21.95.5'].

Führen Sie den folgenden Befehl aus, um die Zugangspunkte im richtigen Format für das Kopieren und Einfügen auszudrucken:
```
echo access_points\: $(gcloud beta parallelstore instances describe \
  INSTANCE_ID --location LOCATION --project PROJECT_ID \
  --format "value[delimiter=', '](format("{0}", accessPoints))")
```
Entfernen Sie die Kommentarzeichen bei den folgenden beiden Zeilen. Die Einzüge sind wichtig. Achten Sie darauf, dass vor allow_insecure Leerzeichen stehen:
```
# transport_config:
#   allow_insecure: false
```
Ändern Sie den Wert von allow_insecure in true, da Zertifikate nicht unterstützt werden.
```
 transport_config:
   allow_insecure: true
```

Geben Sie die Netzwerkschnittstelle an, die die Verbindung zur Parallelstore-Instanz herstellt. Die Schnittstelle ist häufig eth0, ens4 oder enp0s3, kann aber je nach Netzwerkkonfiguration auch anders sein. Mit dem Befehl route können Sie das Standard-Gateway Ihrer VM anzeigen. Die zu spezifizierende Schnittstelle ist in der Regel diejenige, die ein Subnetz mit dem Gateway teilt.

Listen Sie zuerst alle verfügbaren Netzwerkschnittstellen auf:

ip a

Die Ausgabe sieht in etwa so aus:

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue state UP group default
    link/ether e4:9x:3f:x7:dx:f7 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 10.88.0.3/16 brd 10.88.255.255 scope global eth0
       valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1460 qdisc noqueue state DOWN group default
    link/ether 02:4x:6y:1z:84:45 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever

Führen Sie route aus, um die Routingtabelle aufzurufen:

route

Die Ausgabe sieht in etwa so aus:

Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         10.88.0.1       0.0.0.0         UG    0      0        0 eth0
10.88.0.0       0.0.0.0         255.255.0.0     U     0      0        0 eth0
172.17.0.0      0.0.0.0         255.255.0.0     U     0      0        0 docker0

Im Beispiel ist 10.88.0.1 das Standardgateway und wird von eth0 gemeinsam genutzt. Geben Sie daher eth0 als zu verwendende Schnittstelle an.

/etc/daos/daos_agent.yml bearbeiten Entfernen Sie die Kommentarzeichen bei include_fabric_ifaces und aktualisieren Sie den Wert:

include_fabric_ifaces: ["eth0"]

Speichern und schließen Sie die Datei.

DAOS-Agent starten

HPC Rocky Linux 8

sudo systemctl start daos_agent.service

Sie können den Status prüfen, um sicherzustellen, dass der Agent ausgeführt wird:

systemctl status daos_agent.service

Rocky Linux 9 optimiert

sudo systemctl start daos_agent.service

Sie können den Status prüfen, um sicherzustellen, dass der Agent ausgeführt wird:

systemctl status daos_agent.service

RHEL 9

sudo systemctl start daos_agent.service

Sie können den Status prüfen, um sicherzustellen, dass der Agent ausgeführt wird:

systemctl status daos_agent.service

Ubuntu 22.04

sudo mkdir /var/run/daos_agent && \
sudo daos_agent -o /etc/daos/daos_agent.yml &

Debian 12

sudo mkdir /var/run/daos_agent && \
sudo daos_agent -o /etc/daos/daos_agent.yml &

Logging einrichten

Richten Sie gegebenenfalls lokales Logging ein, um die clientseitige Fehlerbehebung zu unterstützen:

export D_LOG_MASK=INFO
export D_LOG_FILE_APPEND_PID=1
rm -f /tmp/client.log.*
export D_LOG_FILE=/tmp/client.log

Instanz mit dfuse bereitstellen

Stellen Sie die Parallelstore-Instanz mit dfuse (DAOS FUSE) bereit.

Bearbeiten Sie /etc/fuse.conf, um user_allow_other hinzuzufügen.

Geben Sie die Option --multi-user mit dfuse an:

mkdir -p /tmp/parallelstore
dfuse -m /tmp/parallelstore \
  --pool default-pool \
  --container default-container \
  --disable-wb-cache \
  --thread-count=20 \
  --eq-count=10 \
  --multi-user

Informationen zur Optimierung der Werte für --thread-count und --eq-count finden Sie auf der Seite Leistungsaspekte im Abschnitt Anzahl der Threads und der Ereigniswarteschlange.

Auf Ihre Parallelstore-Instanz zugreifen

Ihre Parallelstore-Instanz ist jetzt über den Pfad, der mit dem Flag -m angegeben wurde, auf Ihrer Compute Engine-VM bereitgestellt und kann mit der standardmäßigen POSIX-Syntax gelesen und beschrieben werden, mit einigen Ausnahmen.

Wenn Sie df auf der Instanz ausführen, ist der Wert für SIZE 1,5-mal so hoch wie der mit --capacity-gib angegebene Wert. Aufgrund der Art der von Parallelstore verwendeten Löschcodierung beträgt der nutzbare Speicherplatz weiterhin --capacity-gib. Für alle 2 geschriebenen Byte werden aus Sicht von df 3 Byte benötigt.

Instanz trennen

Die Parallelstore-Instanz kann mit dem folgenden Befehl getrennt werden:

sudo umount /tmp/parallelstore/

Nächste Schritte

Daten aus Cloud Storage in Parallelstore übertragen