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 ihn mit Ihrer Parallelstore-Instanz verbinden.

Wenn Sie mehrere Compute Engine-Clients erstellen und eine Verbindung zu ihnen herstellen möchten, folgen Sie der Anleitung unter Über Compute Engine verbinden: 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. Wenn Sie eine höhere Clientleistung benötigen, erhöhen Sie die Anzahl der vCPUs, um den Netzwerkdurchsatz zu steigern. Eine c3-standard-176-Instanz mit Tier 1-Netzwerk bietet beispielsweise 200 Gbit/s Bandbreite für ausgehenden Traffic.

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 die Region und Zone für diese VM aus den Drop-down-Menüs aus. Ihre VM sollte sich in derselben Zone wie Ihre Parallelstore-Instanz befinden.
Wählen Sie aus der Liste eine Maschinenkonfiguration für Ihre VM aus.
Klicken Sie im Abschnitt Bootlaufwerk auf Ändern.
Wählen Sie den Tab Öffentliche Bilder 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 zu Ihrem Maschinentyp passt.
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 in VPC-Netzwerk konfigurieren erstellt haben.
Klicken Sie zum Erstellen und Starten der VM auf Erstellen.

gcloud

Verwenden Sie das Befehlszeilentool gcloud, 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 Optimized

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

Um eine SSH-Verbindung zu Ihrer Compute Engine-VM herzustellen, müssen Sie zuerst eine Firewallregel erstellen, die SSH zulässt.

Rufen Sie in der Google Cloud Console die Seite 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 VPC-Netzwerk aus, das Sie zuvor erstellt haben.
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 Quell-IPv4-Bereiche 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 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

Um eine SSH-Verbindung zu Ihrer Compute Engine-VM herzustellen, 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

Stellen Sie dann mit gcloud compute ssh eine Verbindung her:

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

DAOS-Clientbibliothek installieren

Die DAOS-Clientbibliothek bietet eine POSIX-ähnliche Schnittstelle für die 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

Upgrade für libfabric:
```
sudo dnf upgrade -y libfabric
```

Rocky Linux 9 Optimized

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

Upgrade für libfabric:
```
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

Upgrade für libfabric:
```
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 die Anzahl geöffneter Dateien erhöhen (nur Ubuntu)

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

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

Führen Sie auf jeder VM die folgenden Befehle aus, um das Limit für offene Dateien von 1.024 zu erhöhen.

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

Starten Sie dann neu:

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 die Auskommentierung von access_points und aktualisieren Sie die Variable mit den accessPoints-IP-Adressen aus den Eigenschaften der Parallelstore-Instanz. Beispiel: access_points: ['172.21.95.2', '172.21.95.4', '172.21.95.5'].

Führen Sie den folgenden Befehl aus, um die Zugriffspunkte im richtigen Format zum Kopieren und Einfügen auszugeben:
```
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 Einrückung ist wichtig. Achten Sie also darauf, dass die Leerzeichen vor allow_insecure beibehalten werden:
```
# 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 bereitstellt. Die Schnittstelle ist oft eth0, ens4 oder enp0s3, kann aber je nach Netzwerkkonfiguration auch anders sein. Mit dem Befehl route können Sie das Standardgateway Ihrer VM aufrufen. Die anzugebende Schnittstelle ist in der Regel die, die ein Subnetz mit dem Gateway gemeinsam nutzt.

Listen Sie zuerst alle verfügbaren Netzwerkschnittstellen auf:

ip a

Die Ausgabe sieht 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 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 das Standardgateway 10.88.0.1 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 in 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 sicherzugehen, dass der Agent ausgeführt wird:

systemctl status daos_agent.service

Rocky Linux 9 Optimized

sudo systemctl start daos_agent.service

Sie können den Status prüfen, um sicherzugehen, 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 sicherzugehen, 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 bei Bedarf die lokale Protokollierung ein, um die clientseitige Fehlerbehebung zu erleichtern:

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 zum Optimieren der Werte von --thread-count und --eq-count finden Sie auf der Seite Leistungsüberlegungen im Abschnitt Anzahl der Threads und Anzahl der Ereigniswarteschlangen.

Auf Ihre Parallelstore-Instanz zugreifen

Ihre Parallelstore-Instanz ist jetzt auf Ihrer Compute Engine-VM unter dem Pfad eingebunden, der durch das Flag -m angegeben wird. Sie kann mit der standardmäßigen POSIX-Syntax gelesen und geschrieben werden, mit einigen Ausnahmen.

Wenn Sie df auf der Instanz ausführen, ist der Wert von SIZE das 1,5-Fache des mit --capacity-gib angegebenen Werts. Die Menge des nutzbaren Speicherplatzes beträgt aufgrund der Art der von Parallelstore verwendeten Erasure-Codierung weiterhin --capacity-gib. Für alle 2 geschriebenen Byte werden aus Sicht von df 3 Byte verwendet.

Instanz unmounten

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

sudo umount /tmp/parallelstore/

Nächste Schritte

Daten aus Cloud Storage in Parallelstore übertragen