Esta página foi traduzida pela API Cloud Translation.

Conectar a partir do Compute Engine

Este guia fornece instruções sobre como criar um único cliente do Compute Engine e conectá-lo à sua instância do Parallelstore.

Para criar e se conectar a vários clientes do Compute Engine, siga as instruções em Conectar-se do Compute Engine: vários clientes.

Para ter um melhor desempenho, as VMs do Compute Engine do cliente precisam ser criadas na mesma zona que a instância do Parallelstore.

Permissões necessárias

Você precisa ter o seguinte papel do IAM para criar uma VM do Compute Engine:

Administrador de instâncias do Compute (v1) (roles/compute.instanceAdmin.v1). Para mais informações, consulte a documentação do Compute Engine.

Criar uma VM do Compute Engine

Siga as instruções para criar uma VM do Compute Engine usando uma das imagens a seguir:

É possível escolher qualquer tipo de máquina e disco de inicialização. Recomendamos pelo menos um tipo de máquina c2-standard-4. Para melhorar o desempenho do cliente, aumente o número de vCPUs para aumentar a taxa de transferência de rede. Por exemplo, uma c3-standard-176 com rede Nível 1 oferece 200 Gbps de largura de banda de saída.

Console do Google Cloud

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
Selecione o projeto e clique em Continuar.
Clique em Criar instância.
Insira um nome para sua VM em Nome. Saiba mais em Convenção de nomenclatura de recursos.
Selecione a Região e a Zona nos menus suspensos para a VM. A VM precisa estar na mesma zona que a instância do Parallelstore.
Selecione uma Configuração de máquina para sua VM na lista.
Na seção Disco de inicialização, clique em Alterar.
Selecione a guia Imagens públicas.
No menu suspenso Sistema operacional, selecione uma das seguintes opções: Imagem de VM de HPC, Ubuntu ou Debian.
No menu suspenso Versão, selecione uma das opções: HPC Rocky Linux 8, Ubuntu 22.04 LTS ou Debian GNU/Linux 12 (bookworm). Selecione a versão x86/64 ou Arm64 para corresponder ao tipo de máquina.
Para confirmar as opções do disco de inicialização, clique em Selecionar.
Expanda a seção Opções avançadas e depois Rede.
Em Interfaces de rede, selecione a rede VPC criada em Configurar uma rede VPC.
Para criar e iniciar a VM, clique em Criar.

gcloud

Use a ferramenta de linha de comando gcloud para criar uma 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 otimizado

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 mais informações sobre as opções disponíveis, consulte a documentação do Compute Engine.

SSH para a VM do cliente

Console do Google Cloud

Para usar SSH na VM do Compute Engine, primeiro crie uma regra de firewall que permita o SSH.

No Console do Google Cloud, acesse a página políticas de Firewall.

Acesse as políticas de firewall
Clique em Criar regra de firewall.
Digite um Nome para a regra.
Em Rede, selecione a rede VPC criada anteriormente.
Selecione Entrada como Direção do tráfego e Permitir como Ação se houver correspondência.
No menu suspenso Destinos, selecione Todas as instâncias na rede.
No campo Intervalos IPv4 de origem, insira 0.0.0.0/0.
Em Protocolos e portas, selecione Protocolos e portas especificados.
Selecione TCP e insira 22 no campo Portas.
Clique em Criar.

Em seguida, use o SSH na VM:

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
Na tabela de instâncias, encontre a linha da sua instância e clique em SSH na coluna Conectar.
Se for solicitado, clique em Autorizar para permitir a conexão.

gcloud

Para usar SSH na VM do Compute Engine, primeiro crie uma regra de firewall que permita o 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

Em seguida, conecte usando gcloud compute ssh:

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

Instalar a biblioteca de cliente do DAOS

A biblioteca de cliente DAOS fornece uma interface semelhante à POSIX para a camada de dados do Parallelstore. O software é executado como um agente nas máquinas clientes e precisa ser instalado e executado antes que você possa acessar seus dados.

HPC Rocky Linux 8

Os comandos a seguir precisam ser executados em cada VM do Compute Engine.

Adicione o repositório de pacotes do 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

Atualize o cache de metadados local:
```
sudo dnf makecache
```

Instale daos-client:

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

Upgrade de libfabric:
```
sudo dnf upgrade -y libfabric
```

Rocky Linux 9 otimizado

Os comandos a seguir precisam ser executados em cada VM do Compute Engine.

Adicione o repositório de pacotes do 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

Atualize o cache de metadados local:
```
sudo dnf makecache
```

Instale daos-client:

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

Upgrade de libfabric:
```
sudo dnf upgrade -y libfabric
```

RHEL 9

Os comandos a seguir precisam ser executados em cada VM do Compute Engine.

Adicione o repositório de pacotes do 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

Atualize o cache de metadados local:
```
sudo dnf makecache
```

Instale 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 de libfabric:
```
sudo dnf upgrade -y libfabric
```

Ubuntu 22.04

Os comandos a seguir precisam ser executados em cada VM do Compute Engine.

Adicione o repositório de pacotes do 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

Atualize o índice do pacote:
```
sudo apt update
```
Instale daos-client:
```
sudo apt install -y daos-client
```

Debian 12

Os comandos a seguir precisam ser executados em cada VM do Compute Engine.

Adicione o repositório de pacotes do 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

Atualize o índice do pacote:
```
sudo apt update
```
Instale daos-client:
```
sudo apt install -y daos-client
```

Aumentar o limite de arquivos abertos (somente Ubuntu)

Para VMs com o Ubuntu 22.04, é necessário aumentar o limite de arquivos abertos para 131072 para oferecer suporte ao dfuse e à biblioteca de interceptação.

Se você optar por não usar a biblioteca de intercepção, execute ulimit -n 131072 imediatamente antes de iniciar o dfuse.

Para aumentar o limite de arquivos abertos de 1.024, execute os seguintes comandos em cada VM.

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

Em seguida, reinicie:

sudo reboot

Faça SSH para a VM cliente novamente depois que ela terminar de reiniciar.

Atualizar a configuração do agente DAOS

Atualize o /etc/daos/daos_agent.yml desta maneira:

Remova o comentário e atualize access_points com os endereços IP accessPoints das propriedades da instância do Parallelstore. Por exemplo, access_points: ['172.21.95.2', '172.21.95.4', '172.21.95.5'].

Para imprimir os pontos de acesso no formato correto para copiar e colar, execute o seguinte comando:
```
echo access_points\: $(gcloud beta parallelstore instances describe \
  INSTANCE_ID --location LOCATION --project PROJECT_ID \
  --format "value[delimiter=', '](format("{0}", accessPoints))")
```
Remova os comentários das duas linhas a seguir. A recuo é importante, então mantenha os espaços na frente de allow_insecure:
```
# transport_config:
#   allow_insecure: false
```
Mude o valor de allow_insecure para true, já que não há suporte para certificados.
```
 transport_config:
   allow_insecure: true
```

Especifique a interface de rede que fornece conectividade à instância do Parallelstore. A interface geralmente é eth0, ens4 ou enp0s3, mas pode ser diferente dependendo da configuração da rede. É possível usar o comando route para mostrar o gateway padrão da VM. A interface a ser especificada geralmente é aquela que compartilha uma sub-rede com o gateway.

Primeiro, liste todas as interfaces de rede disponíveis:

ip a

O resultado será assim:

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

Execute route para mostrar a tabela de roteamento:

route

O resultado será assim:

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

No exemplo, o gateway padrão é 10.88.0.1 e é compartilhado por eth0. Portanto, especifique eth0 como a interface a ser usada.

Editar /etc/daos/daos_agent.yml. Remova a marca de comentário include_fabric_ifaces e atualize o valor:

include_fabric_ifaces: ["eth0"]

Salve e feche o arquivo.

Iniciar o agente DAOS

HPC Rocky Linux 8

sudo systemctl start daos_agent.service

É possível verificar o status para garantir que o agente esteja em execução:

systemctl status daos_agent.service

Rocky Linux 9 otimizado

sudo systemctl start daos_agent.service

É possível verificar o status para garantir que o agente esteja em execução:

systemctl status daos_agent.service

RHEL 9

sudo systemctl start daos_agent.service

É possível verificar o status para garantir que o agente esteja em execução:

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 a geração de registros

Configure a geração de registros local para ajudar na depuração do lado do cliente, se necessário:

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 a instância usando o dfuse

Monte a instância do Parallelstore usando o dfuse (DAOS FUSE).

Edite /etc/fuse.conf para adicionar user_allow_other.

Especifique a opção --multi-user com 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 otimizar os valores de --thread-count e --eq-count, consulte a seção Contagem de linhas de execução e contagem de filas de eventos da página Considerações sobre desempenho.

Acessar sua instância do Parallelstore

A instância do Parallelstore agora é montada na VM do Compute Engine no caminho especificado pela flag -m e é legível/gravável usando a sintaxe POSIX padrão, com algumas exceções.

Se você executar df na instância, o valor de SIZE será 1,5 vezes o valor especificado com --capacity-gib. A quantidade de espaço utilizável ainda é --capacity-gib devido à natureza da codificação de apagamento usada pelo Parallelstore. A cada 2 bytes gravados, são usados 3 bytes da perspectiva de df.

Desmontar a instância

A instância do Parallelstore pode ser desmontada usando o seguinte comando:

sudo umount /tmp/parallelstore/

A seguir

Transferir dados do Cloud Storage para o Parallelstore