In questa guida vedremo come creare dei client multipli su una distribuzione GNU/Linux tramite l’utilizzo dei container Docker. E come gestirli tramite Portainer.
Perché mi servono altri client Boinc?
Alcuni progetti hanno dei limiti di wu (work unit) scaricabili. Questi limiti possono impedire la creazione dei cosiddetti “bunker”.
Altro limite nella creazione di un “bunker” è il dover negare la connessione internet al client. Se si finiscono le wu prima del previsto, non potremo più scaricarne altre. Poiché una volta sbloccata la connessione, oltre che scaricarne di nuove…caricherà quelle che avevamo precedentemente elaborato. Vanificando il nostro “bunker”.
Un altro modo per utilizzare più client Boinc è quello di separare progetti cpu da quelli gpu. In modo da avere un controllo maggiore.
Utilizzando dei container si possono gestire molti altri aspetti come:
• quantità di core/thread da dedicare
• quantità di ram da dedicare
• possibilità di rendere disponibile la gpu (in caso di sistemi con più gpu, si può decidere quale)
• gestione da remoto normale, tramite il manager o BoincTask
• possibilità di crearli quando si vuole, anche con altri client attivi
• creazione quasi del tutto "automatizzata" grazie a docker-compose
Cosa sono i container? Cos’è Docker?
Al contrario delle Virtual Machine (VM), un container Docker non ha bisogno di eseguire un sistema operativo intero per far funzionare un programma.
Questo si traduce in una maggiore efficienza dell’uso delle risorse, poiché si ha un “livello” in meno.
Nella figura a sinistra è rappresentato il funzionamento tramite container, mentre in quella di desta vengono usate delle VM.
Nel caso dei container avremo: pc/server -> sistema operativo -> software Docker -> container A/B/C
Nel caso delle VM avremo: pc/server -> sistema operativo (principale) -> sistema operativo (VM) -> software A/B/C
Virtualizzare un intero sistema operativo richiede di “sacrificare” delle risorse a causa della sua natura. Mentre un container non ha bisogno di tutto ciò che compone un sistema operativo. Infatti, esso è composto solamente dallo stretto necessario per eseguire quella specifica applicazione.
Docker è la principale piattaforma di sviluppo dei container, un altro punto a suo favore è il suo essere open-source
Che cos’è Portainer? A cosa serve?
Portainer è un programma che ci permette di gestire i nostri container tramite una comoda interfaccia grafica.
Le sue funzioni spaziano dalle operazioni “base”, come avviare/fermare un container. Permette anche di controllare il suo stato (avviato/fermo).
Grazie all’integrazione con docker-compose, per creare un container non ci sarà bisogno di utilizzare la linea di comando o di districarsi nelle sue mille impostazioni.
Ci basterà usare un “template” facilmente modificabile secondo le nostre esigenze. Tutto il resto…lo farà lui (o quasi)
Portainer permette anche di creare più container contemporaneamente. Ciò si traduce in un solo “comando” per creare più client Boinc.
È anche possibile accedere alla sua interfaccia…da remoto. Potete benissimo installare tutto sul pc, levare mouse/tastiera/monitor e nasconderlo in un angolo. Finché rimarrà connesso alla rete internet di casa, potremo gestire i container da qualsiasi altro computer casalingo (per utenti un po’ più…smanettoni)
Per chi dispone di più computer, può gestire in un’unica schermata di Portainer tutti i container installati.
Che cos’è docker-compose? A cosa serve?
Docker-compose è uno strumento che permette la creazione di container senza dover scrivere un lungo comando sul terminale.
Utilizza un file YAML strutturato in modo da rendere più facile la creazione/modifica di un container. È possibile “convertire” un classico comando da terminale ad un file per docker-compose (e viceversa). Ma è anche possibile crearne uno senza un comando da cui partire.
1 - Installare Docker
Prima di fare copia-incolla dei seguenti comandi, controllate che non sia cambiato qualcosa. Fate riferimento alla guida ufficiale.
Mi raccomando, prima di eseguire qualsiasi comando controllate che sia stato copiato correttamente e per intero.
• Apriamo un terminale andando sul menu applicazioni e digitando “terminale” e controlliamo che non ci siano aggiornamenti con:
sudo apt update && sudo apt upgrade
Se richiesta la conferma di voler aggiornare, premere invio
• A questo punto installiamo il necessario con:
sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
• Aggiungiamo la chiave GPG:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
• Impostare la repository:
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
Per i sistemi x86_64 / amd64 usare-> [arch=amd64]
Per i sistemi armhf usare -> [arch=armhf]
Per i sistemi arm64 usare -> [arch=arm64]
• Installare Docker Engine
sudo apt update && sudo apt install docker-ce docker-ce-cli containerd.io
2 - Installare Docker Composer
Grazie a docker-compose non dobbiamo impazzire con comandi lunghi chilometri e difficilmente modificabili. Scaricare da GitHub il software:
sudo curl -L "https://github.com/docker/compose/releases/download/1.25.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
N.B. per installare una versione differente, sostituire 1.25.5 con quella desiderata. Rendiamo eseguibile quanto appena scaricato
sudo chmod +x /usr/local/bin/docker-compose
3 - Installare Portainer
Creiamo un volume dove poter salvare i dati di Portainer
sudo docker volume create data-portainer
Creiamo una cartella denominata Docker-Compose con al suo interno un'altra chiamata Portainer
mkdir ~/Docker-Compose && mkdir ~/Docker-Compose/Portainer
Creiamo un file chiamato docker-compose.yml nella cartella "Portainer"
gedit ~/Docker-Compose/Portainer/docker-compose.yml
Al cui interno copiamo (presente negli allegati)
version: '3.3'
services:
portainer:
image: portainer/portainer
ports:
- '8000:8000'
- '9000:9000'
container_name: portainer
restart: always
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- type: volume
source: data-portainer
target: /data
volumes:
data-portainer:
Eseguiamo quanto appena creato tramite compose
cd ~/Docker-Compose/Portainer && sudo docker-compose up -d
L'interfaccia sarà raggiungibile da browser, tramite
Al primo avvio ci verrà chiesto di impostare una password principale. Selezionare "Local" nella schermata successiva. Ora Portainer è configurato, per il momento lo lasciamo da parte.
4 - Installare il client di Boinc
Come esempio userò tre container pressoché uguali come base. Creiamo una cartella chiamata "Boinc" all'interno di "Docker-Compose".
Fatto questo, creiamo altre 2 cartelle chiamate "Client_1", "Client_2". In questo modo possiamo facilmente recuperare/modificare il file compose per rispecchiare la tipologia corretta: solo cpu, supporto gpu nvidia/intel/amd, supporto virtualbox. (tutto presente negli allegati)
P.S. è possibile creare più docker contemporaneamente tramite il file "docker-compose.yml", concatenando il tutto. Fate riferimento a "Installare docker tramite Portainer".
CLIENT SOLO CPU (metodo 1 - tramite docker-compose)
All'interno della cartella "Client_1" creiamo il suo file docker-compose.yml
version: '2'
services:
boinc:
image: boinc/client:latest
container_name: boinc_1
hostname: client-1
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_1:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
Per creare altri docker "base" (solo cpu) basta modificare i campi appena scritti. Facendo diventare il docker-compose.yml
version: '2'
services:
boinc:
image: boinc/client:latest
container_name: boinc_2
hostname: client-2
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_2:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
Per creare i due docker diamo
cd ~/Docker-Compose/Boinc/Client_1 && sudo docker-compose up -d
cd ~/Docker-Compose/Boinc/Client_2 && sudo docker-compose up -d
Ora i due docker sono stati creati e sono attivi. Tutti e due possono usare il 100% delle risorse disponibili. Per limitare le risorse bisogna passare da Portainer. (leggi sezione successiva).
INSTALLARE I DOCKER CON PORTAINER (metodo 2 - tramite la sua gui)
Nel menu a sinistra, selezioniamo la voce “Stacks”. Nella schermata che ci appare, selezioniamo “+ Add stack”
Nel primo campo, in alto, diamo un nome (es. cpuboinc) Ora possiamo scegliere se fare copia-incolla del contenuto del file docker-compose.yml (web editor), oppure caricare direttamente il file dal pc. Per creare più docker contemporaneamente possiamo concatenarli all’interno del file docker-compose.yml
Vanno comunque modificati i parametri come: nome docker, host, cartella di lavoro, ecc.
version: '2'
services:
client-1:
image: boinc/client:latest
container_name: boinc_1
hostname: client-1
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_1:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123 - BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
client-2:
image: boinc/client:latest
container_name: boinc_2
hostname: client-2
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_2:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
Controlliamo che sia abilitato il controllo da parte degli amministratori (noi) e premiamo sul pulsante “Deploy the stack” Attendiamo che la pagina si aggiorni in automatico e che compaia in alto a destra la conferma della creazione.
CLIENT CON SUPPORTO ALLE GPU
Per abilitare il supporto alle gpu AMD / Nvidia / Intel, basta modificare il nome dell’immagine da “boinc/client:latest” al corrispondente della nostra gpu.
NVIDIA
Controlliamo di avere installati i driver, nel caso fate riferimento alla pagina ufficiale.
Installiamo NVIDIA-Docker v2: per prima cosa scarichiamo ed aggiungiamo la chiave GPG
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
Ora copiamo questi due comandi in sequenza:
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
Aggiorniamo la lista dei pacchetti ed installiamo nvidia-container-toolkit
sudo apt update && sudo apt install nvidia-container-toolkit
Riavviamo Docker
sudo systemctl restart docker
Ora basterà aggiungere una riga all’interno del file docker-compose e modificare l’immagine da usare in: boinc/client:nvidia
runtime: nvidia
Il risultato è questo
version: '2'
services:
client-3:
image: boinc/client:nvidia
runtime: nvidia
container_name: boinc_3
hostname: client-3
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_3:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
INTEL
Controlliamo di avere installati i driver, nel caso fate riferimento alla pagina ufficiale.
Aggiungiamo una riga all’interno del file docker-compose e modificare l’immagine da usare in: boinc/client:intel
devices:
- /dev/dri:/dev/dri
Il risultato è questo:
version: '2'
services: client-4:
image: boinc/client:intel
container_name: boinc_4
devices: - /dev/dri:/dev/dri
hostname: client-4
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_4:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
AMD
Installiamo I driver ROCm:
Per prima cosa installiamo il necessario. (è consigliato un riavvio del pc dopo questa installazione)
sudo apt update && sudo apt install libnuma-dev
Aggiungiamo la chiave GPG
wget -q -O - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add -
Aggiungiamo la repository
echo 'deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main' | sudo tee /etc/apt/sources.list.d/rocm.list
Installiamo ROCm
sudo apt update && sudo apt install rocm-dkms
Aggiungiamo il nostro utente al gruppo video (è consigliato un riavvio al termine dell’operazione)
sudo usermod -a -G video $LOGNAME
Aggiungiamo tre righe all’interno del file docker-compose e modificare l’immagine da usare in: boinc/client:amd
devices:
- /dev/dri:/dev/dri
- /dev/kfd:/dev/kfd
group_add:
- video
Il risultato è questo:
version: '2'
services:
client-5:
image: boinc/client:amd
container_name: boinc_5
devices:
- /dev/dri:/dev/dri
- /dev/kfd:/dev/kfd
group_add:
- video
hostname: client-5
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_5:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
MULTI-GPU
Per abilitare il supporto al multi-gpu vanno aggiunte quasi tutte le cose viste in precedenza. Portando il file docker-compose a questo:
version: '2'
services: client-6:
image: boinc/client:multi-gpu
runtime: nvidia
container_name: boinc_6
devices: - /dev/dri:/dev/dri
hostname: client-6
restart: unless-stopped
pid: host
volumes: - /opt/appdata/boinc_6:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
Virtualbox
Installiamo virtualbox-dkms
sudo apt update && sudo apt install virtualbox-dkms
Il risultato è questo:
version: '2'
services: client-7:
image: boinc/client:virtualbox
container_name: boinc_7
devices:
- /dev/vboxdrv:/dev/vboxdrv
hostname: client-7
restart: unless-stopped
pid: host
volumes:
- /opt/appdata/boinc_7:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc
Parte 5 - Avviare / fermare i container
Una volta creati i container, abbiamo due modi per avviarli / fermarli: tramite linea di comando oppure tramite la gui di Portainer.
Tramite linea di comando (CLI)
Apriamo il terminale e digitiamo il comando, che ha nella parte finale il nome del container (boinc_1, boinc_2, ecc).
sudo docker container run -d boinc_1
Per fermare un container basta usare questo comando, che ha nella parte finale il nome del container (boinc_1, boinc_2, ecc).
sudo docker container stop boinc_1
Tramite Portainer (GUI)
Nel menu a sinistra, selezioniamo la voce “Containers”.
Nella schermata che ci appare, selezioniamo il container che ci interessa tramite la “spunta” a sinistra del nome. Una volta selezionato il container (o più di uno), premiamo “Start” / “Stop” rispettivamente per avviare o fermare.
Attendiamo che la pagina si aggiorni in automatico e che compaia in alto a destra la conferma della modifica. Inoltre cambierà anche lo stato del container: “running” / “stopped”
Parte 6 - Gestione base tramite Portainer
Ora che abbiamo creato i container, vediamo come trovare / modificare i loro indirizzi ip e controllare che sia tutto a posto.
Dettagli / informazioni
Nel menu a sinistra, selezioniamo la voce “Containers”.
Nella schermata che ci appare, abbiamo una lista dei container installati. Sia attivi che fermi.
Da qui possiamo recuperare l’indirizzo ip necessario per collegarci a boinc tramite il manager o boinctask.
Per avere maggiori informazioni su un singolo container, basta premere sul suo nome. Nella pagina appena aperta abbiamo un riepilogo del container.
• La voce “Status” ci indica da quanto tempo è avviato / fermo.
• La voce “Logs” comprende i log di Boinc, utile in caso di problemi.
• La voce “Stats” ci mostra una panoramica dell’utilizzo da parte del container delle risorse: ram, cpu, internet e che processi sono attivi (le wu di boinc rientrano fra questi)
• La voce “Console” ci permette di avere un terminale all’interno del container tramite il browser.
Modificare indirizzo ip
Nel menu a sinistra, selezioniamo la voce “Containers”.
Nella schermata che ci appare, abbiamo una lista dei container installati. Sia attivi che fermi.
Da qui possiamo recuperare l’indirizzo ip necessario per collegarci a boinc tramite il manager o boinctask.
L’indirizzo ip di default non permette di controllare il client boinc da un computer diverso da quello su cui sono presenti i docker.
Per risolvere questo problema, basta assegnare un ip “classico” ai container (es. 192.168.1.2)
Per modificarlo, bisogna aprire la pagina delle informazioni del container premendo sul suo nome e premere sul pulsante “Duplicate / Edit”.
Nella seconda sezione (Network ports configuration), premiamo su “+ publish a new network port”.
Nel campo “host” mettiamo l’indirizzo ip del computer su cui sono installati i container, nel mio caso 192.168.1.54 seguito dalla porta che vogliamo usare. es. 192.168.1.54:36001
Se non conosciamo l’indirizzo ip del computer, basterà aprire un terminale e digitare:
ip addr show | grep 192
l numero che ci interessa è quello subito dopo “inet”. (il /24 non ci interessa) Nel mio caso ho sottolineato la parte che ci interessa:
inet 192.168.1.54/24 brd 192.168.1.255 scope global dynamic noprefixroute enp0s3
Mentre nel campo “container” mettiamo la porta di default di boinc, che è 31416.
Controlliamo infine che sia selezionata la voce “TCP”.
Una volta fatto questo basterà premere su “Deploy the container”.
In caso di più container risulta più comodo modificare il file docker-compose usato nella creazione dello stack.
Per fare questo dobbiamo andare nel menu a sinistra ed aprire la sezione Stacks.
Selezioniamo quello che desideriamo modificare, nel mio caso “cpuboinc”, premendo sul suo nome.
Nella pagina che si apre, selezioniamo la voce “Editor” (in alto) ed aggiungiamo dopo il valore “pid” quanto segue:
ports:
- '192.168.1.54:36001:31416'
l significato di questi numeri è lo stesso di quello detto poco sopra, modificate ip e porta secondo le esigenze.
Ecco come compare intero:
version: '2'
services:
client-1:
image: boinc/client:latest
container_name: boinc_1
hostname: client-1
restart: unless-stopped
pid: host
ports:
- '192.168.1.54:36001:31416'
volumes:
- /opt/appdata/boinc_1:/var/lib/boinc
environment:
- BOINC_GUI_RPC_PASSWORD=123
- BOINC_CMD_LINE_OPTIONS=--allow_remote_gui_rpc