Esta página se ha traducido con Cloud Translation API.

Conectarse desde Compute Engine

En esta guía se explica cómo crear un cliente de Compute Engine y conectarlo a tu instancia de Parallelstore.

Para crear y conectarte desde varios clientes de Compute Engine, puedes seguir las instrucciones que se indican en el artículo Conectarse desde Compute Engine: varios clientes.

Para mejorar el rendimiento, las VMs de Compute Engine del cliente deben crearse en la misma zona que la instancia de Parallelstore.

Permisos obligatorios

Para crear una VM de Compute Engine, debes tener el siguiente rol de gestión de identidades y accesos:

Administrador de instancias de Compute (v. 1) (roles/compute.instanceAdmin.v1). Para obtener más información, consulta la documentación de Compute Engine.

Crear una VM de Compute Engine

Sigue las instrucciones para crear una VM de Compute Engine con una de las siguientes imágenes:

Puedes elegir cualquier tipo de máquina y disco de arranque. Recomendamos usar al menos un tipo de máquina c2-standard-4. Para mejorar el rendimiento del cliente, aumenta el número de vCPUs para incrementar el rendimiento de la red. Por ejemplo, un c3-standard-176 con redes de nivel 1 proporciona 200 Gbps de ancho de banda de salida.

Google Cloud consola

En la consola de Google Cloud , ve a la página Instancias de VM.

Ir a instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Introduce un nombre para la VM en Nombre. Para obtener más información, consulta el artículo sobre las convenciones para asignar nombres de recursos.
Selecciona la región y la zona de esta VM en los menús desplegables. Tu VM debe estar en la misma zona que tu instancia de Parallelstore.
Selecciona una configuración de máquina para tu VM en la lista.
En la sección Disco de arranque, haz clic en Cambiar.
Selecciona la pestaña Imágenes públicas.
En el menú desplegable Sistema operativo, selecciona una de las siguientes opciones: Imagen de máquina virtual de HPC, Ubuntu o Debian.
En el menú desplegable Versión, selecciona una de las siguientes opciones: HPC Rocky Linux 8, Ubuntu 22.04 LTS o Debian GNU/Linux 12 (bookworm). Selecciona la versión x86/64 o la versión Arm64 según el tipo de máquina.
Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
Despliega la sección Opciones avanzadas y, a continuación, Redes.
En Interfaces de red, selecciona la red de VPC que has creado en Configurar una red de VPC.
Para crear e iniciar la VM, haz clic en Crear.

gcloud

Usa la herramienta de línea de comandos gcloud para crear 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 optimizado

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

Para obtener más información sobre las opciones disponibles, consulta la documentación de Compute Engine.

Acceder a la VM cliente mediante SSH

Google Cloud consola

Para conectarte a tu VM de Compute Engine mediante SSH, primero debes crear una regla de cortafuegos que permita SSH.

En la Google Cloud consola, ve a la página Políticas de cortafuegos.

Ir a Políticas de cortafuegos
Haz clic en Crear regla de cortafuegos.
Introduce un nombre para la regla.
En Red, selecciona la red de VPC que has creado antes.
Selecciona Entrada como Dirección del tráfico y Permitir como Acción tras coincidencia.
En el menú desplegable Destinos, elige Todas las instancias de la red.
En el campo Source IPv4 ranges (Intervalos de IPv4 de origen), introduce 0.0.0.0/0.
En Protocolos y puertos, selecciona Protocolos y puertos especificados.
Selecciona TCP e introduce 22 en el campo Puertos.
Haz clic en Crear.

A continuación, conéctate a tu VM mediante SSH:

En la consola de Google Cloud , ve a la página Instancias de VM.

Ir a instancias de VM
En la tabla de instancias, busca la fila de tu instancia y haz clic en SSH en la columna Conectar.
Si se te pide que lo hagas, haz clic en Autorizar para permitir la conexión.

gcloud

Para conectarte a tu VM de Compute Engine mediante SSH, primero debes crear una regla de cortafuegos que permita 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

A continuación, conéctate mediante gcloud compute ssh:

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

Instalar la biblioteca de cliente de DAOS

La biblioteca de cliente de DAOS proporciona una interfaz similar a POSIX para la capa de datos de Parallelstore. El software se ejecuta como un agente en tus máquinas cliente y debe instalarse y ejecutarse para que puedas acceder a tus datos.

HPC Rocky Linux 8

Los siguientes comandos deben ejecutarse en cada máquina virtual de Compute Engine.

Añade el repositorio de paquetes 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

Actualiza la caché de metadatos local:
```
sudo dnf makecache
```

Instalar daos-client:

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

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

Rocky Linux 9 optimizado

Los siguientes comandos deben ejecutarse en cada máquina virtual de Compute Engine.

Añade el repositorio de paquetes 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

Actualiza la caché de metadatos local:
```
sudo dnf makecache
```

Instalar daos-client:

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

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

RHEL 9

Los siguientes comandos deben ejecutarse en cada máquina virtual de Compute Engine.

Añade el repositorio de paquetes 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

Actualiza la caché de metadatos local:
```
sudo dnf makecache
```

Instalar 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

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

Ubuntu 22.04

Los siguientes comandos deben ejecutarse en cada máquina virtual de Compute Engine.

Añade el repositorio de paquetes 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

Actualiza el índice de paquetes:
```
sudo apt update
```
Instalar daos-client:
```
sudo apt install -y daos-client
```

Debian 12

Los siguientes comandos deben ejecutarse en cada máquina virtual de Compute Engine.

Añade el repositorio de paquetes 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

Actualiza el índice de paquetes:
```
sudo apt update
```
Instalar daos-client:
```
sudo apt install -y daos-client
```

Aumentar el límite de archivos abiertos (solo en Ubuntu)

En las VMs que ejecutan Ubuntu 22.04, debes aumentar el límite de archivos abiertos a 131072 para admitir dfuse y la biblioteca de intercepción.

Si decides no usar la biblioteca de intercepción, puedes ejecutar ulimit -n 131072 inmediatamente antes de iniciar dfuse.

Para aumentar el límite de archivos abiertos de 1024, ejecuta los siguientes comandos en cada máquina virtual.

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

A continuación, reinicia:

sudo reboot

Vuelve a conectarte a la VM cliente por SSH cuando termine de reiniciarse.

Actualizar la configuración del agente de DAOS

Actualiza /etc/daos/daos_agent.yml de la siguiente manera:

Descomenta y actualiza access_points con las direcciones IP accessPoints de las propiedades de la instancia de ParallelStore. Por ejemplo: access_points: ['172.21.95.2', '172.21.95.4', '172.21.95.5'].

Para imprimir los puntos de acceso en el formato correcto para copiarlos y pegarlos, ejecuta el siguiente comando:
```
echo access_points\: $(gcloud beta parallelstore instances describe \
  INSTANCE_ID --location LOCATION --project PROJECT_ID \
  --format "value[delimiter=', '](format("{0}", accessPoints))")
```
Descomenta las dos líneas siguientes. La sangría es importante, así que asegúrate de mantener los espacios delante de allow_insecure:
```
# transport_config:
#   allow_insecure: false
```
Cambia el valor de allow_insecure por true, ya que los certificados no se admiten.
```
 transport_config:
   allow_insecure: true
```

Especifica la interfaz de red que proporciona conectividad a la instancia de Parallelstore. La interfaz suele ser eth0, ens4 o enp0s3, pero puede ser diferente en función de la configuración de tu red. Puedes usar el comando route para mostrar la puerta de enlace predeterminada de tu VM. La interfaz que se debe especificar suele ser la que comparte una subred con la puerta de enlace.

Primero, enumera todas las interfaces de red disponibles:

ip a

El resultado debería ser similar al siguiente:

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

Ejecuta route para mostrar la tabla de enrutamiento:

route

El resultado debería ser similar al siguiente:

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

En el ejemplo, la pasarela predeterminada es 10.88.0.1 y la comparte eth0, por lo que debes especificar eth0 como interfaz que se va a usar.

Editar /etc/daos/daos_agent.yml. Quita el comentario de include_fabric_ifaces y actualiza el valor:

include_fabric_ifaces: ["eth0"]

Guarda y cierra el archivo.

Iniciar el agente de DAOS

HPC Rocky Linux 8

sudo systemctl start daos_agent.service

Puedes comprobar el estado para asegurarte de que el agente se está ejecutando:

systemctl status daos_agent.service

Rocky Linux 9 optimizado

sudo systemctl start daos_agent.service

Puedes comprobar el estado para asegurarte de que el agente se está ejecutando:

systemctl status daos_agent.service

RHEL 9

sudo systemctl start daos_agent.service

Puedes comprobar el estado para asegurarte de que el agente se está ejecutando:

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 &

Configurar los registros

Configura el registro local para facilitar la depuración del lado del cliente, si es necesario:

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

Montar la instancia con dfuse

Monta la instancia de Parallelstore con dfuse (DAOS FUSE).

Edita /etc/fuse.conf para añadir user_allow_other.

Especifica la opción --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

Para obtener ayuda sobre cómo optimizar los valores de --thread-count y --eq-count, consulta la sección Número de subprocesos y número de colas de eventos de la página Consideraciones sobre el rendimiento.

Acceder a tu instancia de Parallelstore

Tu instancia de Parallelstore ahora está montada en tu máquina virtual de Compute Engine en la ruta especificada por la marca -m y se puede leer y escribir con la sintaxis POSIX estándar, con algunas excepciones.

Si ejecutas df en la instancia, el valor de SIZE será 1,5 veces el valor especificado con --capacity-gib. La cantidad de espacio utilizable sigue siendo --capacity-gib debido a la naturaleza de la codificación de borrado que usa Parallelstore. Cada 2 bytes escritos usan 3 bytes desde la perspectiva de df.

Desmontar la instancia

La instancia de Parallelstore se puede desmontar con el siguiente comando:

sudo umount /tmp/parallelstore/

Siguientes pasos

Transferir datos de Cloud Storage a Parallelstore

Conectarse desde Compute Engine Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Permisos obligatorios

Crear una VM de Compute Engine

Google Cloud consola

gcloud

HPC Rocky Linux 8

Rocky Linux 9 optimizado

RHEL 9

Ubuntu 22.04

Debian 12

Acceder a la VM cliente mediante SSH

Google Cloud consola

gcloud

Instalar la biblioteca de cliente de DAOS

HPC Rocky Linux 8

Rocky Linux 9 optimizado

RHEL 9

Ubuntu 22.04

Debian 12

Aumentar el límite de archivos abiertos (solo en Ubuntu)

Actualizar la configuración del agente de DAOS

Iniciar el agente de DAOS

HPC Rocky Linux 8

Rocky Linux 9 optimizado

RHEL 9

Ubuntu 22.04

Debian 12

Configurar los registros

Montar la instancia con dfuse

Acceder a tu instancia de Parallelstore

Desmontar la instancia

Siguientes pasos

Conectarse desde Compute Engine