Configurazione ed installazione di PHALA PRB

Published in

Phala Italia

8 min readMar 9, 2023

Phala Network, che cos’è?

Trovate tutti i dettagli qui: https://medium.com/phala-italia/phala-un-cloud-computazionale-trasparente-privato-e-globale-d4c25eafacc

L’installazione è suddivisa in due parti principali, una relativa alla “nodo centrale” del PRB ed una seconda inerente ai worker.

Installazione del nodo PRB

Primo passaggio

Prima di effettuare l’installazione eseguire i comandi riportati sotto per aggiornare il sistema ed installare gli strumenti necessari:

sudo apt update && sudo apt upgrade -y && sudo apt autoremove -y
sudo apt install wget unzip

Procediamo con l’installazione delle componenti di docker:

sudo apt-get install docker docker-compose

Successivamente procediamo a recuperare uno snapshot di Kusama tramite il seguente link: https://snapshots.radiumblock.com/kusama_15605477_2022-12-04.tar.lz4

Si può utilizzare il link seguente per recuperare la versione più recente dell’archivio:

https://ksm-archive.radiumblock.com/providers-ksm-archive.php

Lo snapshot compresso ha una dimensione di circa 900 GB, regolarsi di conseguenza per il download e relativa decompressione.

Inoltre, è consigliabile chiedere sul Discord ufficiale di Phala Network l’eventuale presenza di uno snapshot aggiornato.

Tips:
Se si effettua il download tramite una sessione ssh è consigliabile incapsulare il download all’interno di screen.
Posizionarsi nella cartella dove scaricare il file e digitare:

screen -R download sudo wget https://snapshots.radiumblock.com/kusama_15605477_2022-12-04.tar.lz4

In questo modo si creerà una sessione screen chiamata download che eseguirà il comando evitando che un eventuale timeout della sessione interrompa il download.

Secondo passaggio

Posizionarsi all’interno di /opt e creare una cartella per il servizio con il comando:

sudo mkdir phala-node

Posizionarsi all’interno della cartella appena creata e creare il file docker-compose.yaml con un editor di test ed incollarci il contenuto seguente:

version: “3”
services:
 node:
  image: phalanetwork/khala-node:latest
  container_name: node
  hostname: node
  restart: always
  ports:
   - “8833:9933”
   - “8834:9934”
   - “8844:9944”
   - “8845:9945”
   - “20333:30333”
   - “20334:30334”
  environment:
   - NODE_NAME=NODE-NAME-YOU-WANT
   - NODE_ROLE=MINER
  volumes:
   - /mnt/nvme/nodo/node-data:/root/data

Punto di attenzione
Modificare le voci “NODE_NAME” e “volumes:” specificando il nome del nodo ed il binding del volume in base alla propria configurazione di dischi/partizioni.

Terminata la personalizzazione del file docker-compose.yaml possiamo avviare il nodo con il comando:

sudo docker-compose up -d

Aspettiamo che termini la fase di startup e procediamo a stopparlo con il comando:

sudo docker-compose down

Posizionarsi all’interno della sottocartella chains di polkadot per effettuare la copia dei dati dello snapshot precedentemente scaricato.

Si può procedere ad estrarre l’archivio direttamente nella cartella chains con il comando:

sudo unlz4 /mnt/workdir/kusama_15605477_2022–12–04.tar.lz4

Questa operazione ci permette di evitare una sincronizzazione completa di kusama facendoci risparmiare molto tempo.

Ora è possibile avviare nuovamente il node ed attendere che finisca il sync.

Posizionarsi all’interno della cartella /opt/phala-node ed avviare il nodo con il seguente comando:

sudo docker-compose up -d

Punto di attenzione
E’ necessario attendere che il node sia completamente in sync prima di procedere con i prossimi step.

Il sync può essere monitorato in modo semplice tramite https://telemetry.polkadot.io/ selezionando il tab khala e filtrando per il nome nodo impostato nel docker compose.

Scrivendo il nome del nodo nella pagina comparirà in automatico un campo di ricerca che inizierà a filtrare i nodi in base ai caratteri digitati.

In alternativa si può utilizzare il comando seguente per effettuare la verifica direttamente sul log:

sudo docker logs node — tail=100

Terzo passaggio

Una volta terminata la sincronizzazione del nodo si può procedere con la configurazione delle componenti mancanti di PRB.

Procedere con la creazione con di una cartella per i dati del PRB ed una per il lifecycle:

sudo mkdir /mnt/slow-data/prb-data
sudo mkdir /mnt/slow-data/lifecyle

Ovviamente i path vanno modificati in base alla vostra organizzazione delle partizioni.

Suggerimento
Nel momento della pubblicazione della guida la stima delle dimensioni dei dischi è la seguente (per i prossimi sei mesi):
Phala Node: 2.5–3 TB
PRB-data: 1.5–2 TB
Lifecycle: 10–20 GB

Posizionarsi all’interno della cartella prb-data e creare il file docker-compose.yaml con un editor di test copiando il seguente contenuto:

version: “3”
services:
 data_provider:
  image: phalanetwork/prb:next
  hostname: data_provider
  network_mode: host
  restart: always
  volumes:
   - /mnt/solido/prb-local/prb-data:/var/data
  logging:
  options:
  max-size: “1g”
  environment:
   - PHALA_MODULE=data_provider
   - NODE_ENV=development
   - PHALA_LOGGER_LEVEL=debug
   - PHALA_PARENT_CHAIN_ENDPOINT=ws://127.0.0.1:8845
   - PHALA_CHAIN_ENDPOINT=ws://127.0.0.1:8844
   - PHALA_WALKIE_LISTEN_ADDRESSES=/ip4/127.0.0.1/tcp/28888
   - PHALA_BRIDGE_IDENTITY=staging
   - PHALA_LIFECYCLE_BLOB_SERVER_SESSION_MAX_MEMORY=64
  entrypoint:
   - “node”
   - “ — trace-warnings”
   - “ — experimental-json-modules”
   - “ — es-module-specifier-resolution=node”
   - “ — harmony-top-level-await”
   - “dist/index”
 monitor:
  image: phalanetwork/prb-monitor:next
  hostname: monitor
  network_mode: host
  environment:
   - PTP_BOOT_NODES=/ip4/127.0.0.1/tcp/28888
  redis-q:
  network_mode: host
  image: redis:alpine
  hostname: redis-q
  restart: always
  logging:
  options:
  max-size: “1g”
  command: [“redis-server”, “ — port”, “63792”, “ — appendonly”, “no”, ‘ — save’, ‘’]
 lifecycle:
  network_mode: host
  image: phalanetwork/prb:next
  hostname: lifecycle
  restart: always
  depends_on:
   - redis-q
  volumes:
   - /mnt/solido/lifecycle/data:/var/data
  logging:
  options:
  max-size: “1g”
  environment:
   - PHALA_MODULE=lifecycle
   - PHALA_PARENT_CHAIN_ENDPOINT=ws://127.0.0.1:8845
   - PHALA_CHAIN_ENDPOINT=ws://127.0.0.1:8844
   - PHALA_Q_REDIS_ENDPOINT=redis://127.0.0.1:63792/
   - PHALA_LRU_CACHE_SIZE=50
   - PHALA_LRU_CACHE_MAX_AGE=90000
   - PHALA_RUNNER_MAX_WORKER_NUMBER=100
   - PHALA_PRPC_REQUEST_TIMEOUT=60000
   - PHALA_BRIDGE_IDENTITY=staging
   - PHALA_WALKIE_LISTEN_ADDRESSES=/ip4/127.0.0.1/tcp/29888
   - PHALA_WALKIE_BOOT_NODES=/ip4/127.0.0.1/tcp/28888/p2p/SOSTITUIRE-CON-IL-PEER-ID-DEL-DATA_PROVIDER
   - WORKER_KEEPALIVE_ENABLED=true
   - USE_BUILT_IN_TRADER=true
  entrypoint:
   - "node"
   - " - trace-warnings"
   - " - experimental-json-modules"
   - " - es-module-specifier-resolution=node"
   - " - harmony-top-level-await"
   - "dist/index"

Punto di attenzione
Modificare le voci relative ai volumes in base alla propria configurazione. Inoltre, modificare il PHALA_WALKIE_BOOT_NODES con il proprio ID del data_provider (peerId).
L’id può essere visualizzato al primo avvio del composer puntando l’indirizzo IP del PRB alla porta 3000 (es. http://IPv4:3000).

Quarto passaggio (configurazione del worker)

Quando tutte le componenti del PRB hanno terminato la fase di sincronizzazione si può procedere con la configurazione del worker.

Gli step seguenti sono da ripetere per ogni worker che si vuole aggiungere.

Procedere con l’esecuzione dei seguenti comandi per aggiornare il sistema ed installare i tool necessari:

sudo apt update && sudo apt upgrade -y && sudo apt autoremove -y
sudo apt install wget unzip

Effettuare il download del pacchetto del solo-miner per utilizzare alcuni script presenti al suo interno:

cd ~
wget https://github.com/Phala-Network/solo-mining-scripts/archive/refs/heads/main.zip
unzip main.zip

Posizionarsi all’interno della cartella tools e lanciare lo script per avviare l’SGX

cd ~/solo-mining-scripts-main/tools
sudo ./sgx_enable

Effettuare il riavvio e lanciare il tool di test per verificare la corretta attivazione dell’SGX ed il relativo confidence level:

sudo reboot

cd ~/solo-mining-scripts-main
sudo bash phala.sh sgx-test

Di seguito un output di esempio del comando:

✔ SGX instruction set
✔ CPU support
✔ CPU configuration
✔ Enclave attributes
✔ Enclave Page Cache
SGX features
✔ SGX2 ✔ EXINFO ✘ ENCLV ✘ OVERSUB ✘ KSS
Total EPC size: 94.0MiB
✔ Flexible launch control
✔ CPU support
？ CPU configuration
✔ Able to launch production mode enclave
✔ SGX system software
✔ SGX kernel device (/dev/sgx/enclave)
✔ libsgx_enclave_common
✔ AESM service
✔ Able to launch enclaves
✔ Debug mode
✔ Production mode
✔ Production mode (Intel whitelisted)
You're all set to start running SGX programs!
Generated machine id:
[253, 198, 191, 125, 19, 13, 119, 127, 45, 189, 92, 5, 63, 11, 247, 184]
CPU Cores:
4
Encoded runtime info:
[1, 0, 0, 0, 253, 198, 191, 125, 19, 13, 119, 127, 45, 189, 92, 5, 63, 11, 247, 184, 3, 238, 8, 100, 168, 7, 2, 114, 126, 205, 33, 43, 86, 54, 57, 77, 121, 110, 97, 206, 115, 197, 226, 4, 223, 37, 22, 39, 163, 134, 177, 177, 41, 8, 4, 0, 0, 0, 1, 0, 0, 0]
Testing RA…
aesm_service[15]: [ADMIN]EPID Provisioning initiated
aesm_service[15]: The Request ID is 996fedaea2744832aaa536b7f428d709
aesm_service[15]: The Request ID is 99a34b07a28d4b3bbc223c3d002c44d8
aesm_service[15]: The Request ID is 2f423196579e412e8cd69739efd184dd
aesm_service[15]: The Request ID is cd1453f1c7624123b7150cb2e1eb2dc1
aesm_service[15]: The Request ID is cfec621532e54f9596b93cbddad5e115
aesm_service[15]: [ADMIN]EPID Provisioning successful
isvEnclaveQuoteStatus = SW_HARDENING_NEEDED
advisoryURL = https://security-center.intel.com
advisoryIDs = "INTEL-SA-00657"
confidenceLevel = 4

Nell’esempio riportato sopra è presente un confidence level non ottimale e come è possibile vedere dall’advisoryIDs è presente una vulnerabilità che necessità l’applicazione di una patch di sicurezza.

Dopo l’installazione del driver SGX si può procedere con il finalizzare la configurazione del worker.

Posizionarsi nella cartella /opt e creare una cartella worker con il seguente comando:

sudo mkdir worker

Creare il file docker-compose.yaml con un editor di testo all’interno della cartella e copiarci quanto segue:

version: “3.6”
 services:
  pruntime:
  image: phalanetwork/phala-pruntime:latest
  hostname: runtime
  restart: always
  environment:
   - ROCKET_KEEP_ALIVE=60
   - ROCKET_READ_TIMEOUT=60
   - ROCKET_WRITE_TIMEOUT=60
  devices:
   - "/dev/sgx/enclave:/dev/sgx/enclave"
   - "/dev/sgx/provision:/dev/sgx/provision"
  ports:
   - "8000:8000"
  volumes:
   - "./pruntime-data:/root/data"

Avviare il worker con il seguente comando:

sudo docker-compose up -d

E’ possibile verificare che il servizio sia correttamente avviato dai log con il comando sudo docker-compose logs pruntime o con sudo docker logs idcontainer -f — tail 10 .

Ultimo passaggio

Terminata la fase di configurazione del nodo e dei work è necessario agganciare ogni worker al PRB.

Collegarsi tramite un qualsiasi browser web all’indirzzo del proprio nodo PRB sulla porta 300:0 http://IPv4_del_PRB:3000 .

Aprendo il menu Actions del Lifecycle è possibile selezionare la voce Manage Pools dove sarà possibile aggiungere la pool cliccando sul tasto verde Add..

Dopo la configurazione della pool, aprendo il menu Actions del Lifecycle è possibile selezionare la voce Manage Workers dove sarà possibile aggiungere i workers.

I dati necessari sono:

POOL ID
Nome del Worker
indirizzo del worker nella forma http://IPv4_worker:8000
Token da mettere in stake

Punto di Attenzione
La quantità di PHA da mettere in stake dovrà essere inserita con con 12 zeri (milioni di milioni), se si vogliono mettere in stake 19000 PHA la cifra da indicare sarà 19000000000000000

Potrebbe capitare che dopo aver aggiunto i worker al Lifecycle questi non risultino essere visibili, procedere con un riavvio del solo container del lifecycle.

Al termine della sincronizzazione dei worker saranno visibili e gestibili direttamente tramite l’app app.phala.network.

A proposito di Phala

Phala Network si prefigge di risolvere il problema della fiducia nel cloud computazionale.

Organizzando una rete mondiale decentralizzata di nodi per il calcolo, offre servizi performanti senza appoggiarsi su nessun grande cloud provider. I worker Phala fanno girare i programmi in un Secure Enclaves, una tecnologia votata alla privacy presente in alcuni moderni processori, rendendo possibile l’esecuzione confidenziale e versatile di codice. Insieme, questo crea l’infrastruttura per un cloud computing potente, sicuro e scalabile, senza riporre la propria fiducia in soggetti terzi.

🍽 — Subscribe | Website | Twitter | Github