Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Connetti da Compute Engine

Questa guida fornisce istruzioni per creare un singolo client Compute Engine e connetterlo all'istanza Parallelstore.

Per creare e connetterti da più client Compute Engine, puoi seguire le istruzioni riportate in Connettersi da Compute Engine: più client.

Per prestazioni migliori, le VM Compute Engine client devono essere create nella stessa zona dell'istanza Parallelstore.

Autorizzazioni obbligatorie

Per creare una VM Compute Engine, devi disporre del seguente ruolo IAM:

Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1). Per ulteriori informazioni, consulta la documentazione di Compute Engine.

Crea una VM di Compute Engine

Segui le istruzioni per creare una VM Compute Engine utilizzando una delle seguenti immagini:

Puoi scegliere qualsiasi tipo di macchina e disco di avvio. Ti consigliamo di utilizzare almeno un tipo di macchina c2-standard-4; per prestazioni client migliori, aumenta il numero di vCPU per aumentare il throughput di rete. Ad esempio, un c3-standard-176 con rete di livello 1 fornisce 200 Gbps di larghezza di banda in uscita.

Google Cloud Console

Nella Google Cloud console, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Inserisci un nome per la VM in Nome. Per ulteriori informazioni, consulta le convenzioni per la denominazione delle risorse.
Seleziona la Regione e la Zona dai menu a discesa per questa VM. La VM deve trovarsi nella stessa zona dell'istanza Parallelstore.
Seleziona una Configurazione macchina per la VM dall'elenco.
Nella sezione Disco di avvio, fai clic su Cambia.
Seleziona la scheda Immagini pubbliche.
Dal menu a discesa Sistema operativo , seleziona una delle seguenti opzioni: Immagine VM HPC, Ubuntu o Debian.
Dal menu a discesa Versione , seleziona una delle seguenti opzioni: HPC Rocky Linux 8, Ubuntu 22.04 LTS o Debian GNU/Linux 12 (bookworm). Seleziona la versione x86/64 o la versione Arm64 in base al tipo di macchina.
Per confermare le opzioni relative al disco di avvio, fai clic su Seleziona.
Espandi la sezione Opzioni avanzate, quindi espandi Networking.
In Interfacce di rete, seleziona la rete VPC che hai creato in Configurare una rete VPC.
Per creare e avviare la VM, fai clic su Crea.

gcloud

Utilizza lo strumento a riga di comando gcloud per creare una VM:

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 ottimizzato

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

Per ulteriori informazioni sulle opzioni disponibili, consulta la documentazione di Compute Engine.

Accedi alla VM client tramite SSH

Google Cloud Console

Per accedere alla VM Compute Engine tramite SSH, devi prima creare una regola firewall che consenta SSH.

Nella Google Cloud console, vai alla pagina Policy firewall.

Vai a Policy firewall
Fai clic su Crea regola firewall.
Inserisci un Nome per la regola.
In Rete, seleziona la rete VPC che hai creato in precedenza.
Seleziona In entrata come Direzione del traffico e Consenti come Azione in caso di corrispondenza.
Dal menu a discesa Destinazioni, seleziona Tutte le istanze nella rete.
Nel campo Intervalli IPv4 di origine, inserisci 0.0.0.0/0.
In Protocolli e porte, seleziona Protocolli e porte specificati.
Seleziona TCP e inserisci 22 nel campo Porte.
Fai clic su Crea.

Poi, accedi alla VM tramite SSH:

Nella Google Cloud console, vai alla pagina Istanze VM.

Vai a Istanze VM
Nella tabella delle istanze, individua la riga dell'istanza e fai clic su SSH nella colonna intitolata Connetti.
Se ti viene richiesto, fai clic su Autorizza per consentire la connessione.

gcloud

Per accedere alla VM Compute Engine tramite SSH, devi prima creare una regola firewall che consenta SSH.

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

Poi, connettiti utilizzando gcloud compute ssh:

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

Installa la libreria client DAOS

La libreria client DAOS fornisce un'interfaccia di tipo POSIX per il livello dati di Parallelstore. Il software viene eseguito come agente sulle macchine client e deve essere installato ed eseguito prima di poter accedere ai dati.

HPC Rocky Linux 8

I seguenti comandi devono essere eseguiti su ogni VM Compute Engine.

Aggiungi il repository di pacchetti Parallelstore:

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

Aggiorna la cache dei metadati locali:
```
sudo dnf makecache
```

Installa daos-client:

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

Esegui l'upgrade di libfabric:
```
sudo dnf upgrade -y libfabric
```

Rocky Linux 9 ottimizzato

I seguenti comandi devono essere eseguiti su ogni VM Compute Engine.

Aggiungi il repository di pacchetti Parallelstore:

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

Aggiorna la cache dei metadati locali:
```
sudo dnf makecache
```

Installa daos-client:

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

Esegui l'upgrade di libfabric:
```
sudo dnf upgrade -y libfabric
```

RHEL 9

I seguenti comandi devono essere eseguiti su ogni VM Compute Engine.

Aggiungi il repository di pacchetti Parallelstore:

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

Aggiorna la cache dei metadati locali:
```
sudo dnf makecache
```

Installa 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

Esegui l'upgrade di libfabric:
```
sudo dnf upgrade -y libfabric
```

Ubuntu 22.04

I seguenti comandi devono essere eseguiti su ogni VM Compute Engine.

Aggiungi il repository di pacchetti Parallelstore:

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

Aggiorna l'indice dei pacchetti:
```
sudo apt update
```
Installa daos-client:
```
sudo apt install -y daos-client
```

Debian 12

I seguenti comandi devono essere eseguiti su ogni VM Compute Engine.

Aggiungi il repository di pacchetti Parallelstore:

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

Aggiorna l'indice dei pacchetti:
```
sudo apt update
```
Installa daos-client:
```
sudo apt install -y daos-client
```

Aumenta il limite dei file aperti (solo Ubuntu)

Per le VM che eseguono Ubuntu 22.04, devi aumentare il limite dei file aperti a 131072 per supportare dfuse e la libreria di intercettazione.

Se scegli di non utilizzare la libreria di intercettazione, puoi anche eseguire ulimit -n 131072 immediatamente prima di avviare dfuse.

Per aumentare il limite dei file aperti da 1024, esegui i seguenti comandi su ogni VM.

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

Poi, riavvia:

sudo reboot

Accedi di nuovo alla VM client tramite SSH al termine del riavvio.

Aggiorna la configurazione dell'agente DAOS

Aggiorna /etc/daos/daos_agent.yml come indicato di seguito:

Rimuovi il commento e aggiorna access_points con gli indirizzi IP accessPoints delle proprietà dell'istanza Parallelstore. Ad esempio: access_points: ['172.21.95.2', '172.21.95.4', '172.21.95.5'].

Per stampare i punti di accesso nel formato corretto per copiarli e incollarli, esegui il seguente comando:
```
echo access_points\: $(gcloud beta parallelstore instances describe \
  INSTANCE_ID --location LOCATION --project PROJECT_ID \
  --format "value[delimiter=', '](format("{0}", accessPoints))")
```
Rimuovi il commento dalle due righe seguenti. L'indentazione è importante, quindi assicurati di mantenere gli spazi davanti a allow_insecure:
```
# transport_config:
#   allow_insecure: false
```
Modifica il valore di allow_insecure in true perché i certificati non sono supportati.
```
 transport_config:
   allow_insecure: true
```

Specifica l'interfaccia di rete che fornisce la connettività all'istanza Parallelstore. L'interfaccia è spesso eth0, ens4 o enp0s3, ma potrebbe essere diversa a seconda della configurazione di rete. Puoi utilizzare il comando route per visualizzare il gateway predefinito della VM; l'interfaccia da specificare è in genere quella che condivide una subnet con il gateway.

Innanzitutto, elenca tutte le interfacce di rete disponibili:

ip a

L'output è simile al seguente:

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

Esegui route per visualizzare la tabella di routing:

route

L'output è simile al seguente:

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

Nell'esempio, il gateway predefinito è 10.88.0.1 ed è condiviso da eth0, quindi specifica eth0 come interfaccia da utilizzare.

Modifica /etc/daos/daos_agent.yml. Rimuovi il commento da include_fabric_ifaces e aggiorna il valore:

include_fabric_ifaces: ["eth0"]

Salva e chiudi il file.

Avvia l'agente DAOS

HPC Rocky Linux 8

sudo systemctl start daos_agent.service

Puoi controllare lo stato per assicurarti che l'agente sia in esecuzione:

systemctl status daos_agent.service

Rocky Linux 9 ottimizzato

sudo systemctl start daos_agent.service

Puoi controllare lo stato per assicurarti che l'agente sia in esecuzione:

systemctl status daos_agent.service

RHEL 9

sudo systemctl start daos_agent.service

Puoi controllare lo stato per assicurarti che l'agente sia in esecuzione:

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 &

Configura il logging

Se necessario, configura il logging locale per facilitare il debug lato client:

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

Monta l'istanza utilizzando dfuse

Monta l'istanza Parallelstore utilizzando dfuse (DAOS FUSE).

Modifica /etc/fuse.conf per aggiungere user_allow_other.

Specifica l'opzione --multi-user con dfuse:

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

Per assistenza nell'ottimizzazione dei valori di --thread-count e --eq-count, consulta la sezione Conteggio thread e conteggio code di eventi della pagina Considerazioni sul rendimento.

Accedi all'istanza Parallelstore

L'istanza Parallelstore è ora montata sulla VM Compute Engine nel percorso specificato dal flag -m ed è leggibile/scrivibile utilizzando la sintassi POSIX standard, con alcune eccezioni.

Se esegui df sull'istanza, il valore SIZE è 1,5 volte il valore specificato con --capacity-gib. La quantità di spazio utilizzabile è ancora --capacity-gib a causa della natura della codifica di cancellazione utilizzata da Parallelstore. Ogni 2 byte scritti utilizza 3 byte dal punto di vista di df.

Smonta l'istanza

L'istanza Parallelstore può essere smontata utilizzando il seguente comando:

sudo umount /tmp/parallelstore/

Passaggi successivi

Trasferisci dati da Cloud Storage a Parallelstore

Connetti da Compute Engine Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Autorizzazioni obbligatorie

Crea una VM di Compute Engine

Google Cloud Console

gcloud

HPC Rocky Linux 8

Rocky Linux 9 ottimizzato

RHEL 9

Ubuntu 22.04

Debian 12

Accedi alla VM client tramite SSH

Google Cloud Console

gcloud

Installa la libreria client DAOS

HPC Rocky Linux 8

Rocky Linux 9 ottimizzato

RHEL 9

Ubuntu 22.04

Debian 12

Aumenta il limite dei file aperti (solo Ubuntu)

Aggiorna la configurazione dell'agente DAOS

Avvia l'agente DAOS

HPC Rocky Linux 8

Rocky Linux 9 ottimizzato

RHEL 9

Ubuntu 22.04

Debian 12

Configura il logging

Monta l'istanza utilizzando dfuse

Accedi all'istanza Parallelstore

Smonta l'istanza

Passaggi successivi

Connetti da Compute Engine