User Guide

Table Of Contents

 

1. Accesso alla federazione di cluster

La federazione di cluster comprende il cluster centrale di Indaco e i cluster satelliti dei dipartimenti abbonati ed afferenti alla piattaforma.

L’accesso ai cluster avviene utilizzando l’account ricevuto in fase di registrazione o quello d’Ateneo se interni all Universita’ degli Studi di Milano.

I programmi utilizzabili per la connessione telematica sono principalmente di due tipi:

  1. accesso interattivo mediante ssh (Linux, MAC),   putty  o winssh  (Microsoft Windows). Sono inoltre disponibili diverse App per dispositivi mobili
  2. accesso in modalita’ grafica mediante il programma accesso remoto di Windows, disponibile in varie versioni anche per Linux, Mac, Ios, Chrome, Android

E’ possibile accedere a qualunque ora salvo periodi di manutenzione o guasti. La presenza di tali eventi e’ pubblicizzata sulla pagina principale del sito.

Per l’accesso ssh al cluster di INDACO digitare

ssh login.indaco.unimi.it

oppure utilizzare il programma accesso remoto di Windows indicando il server login.indaco.unimi.it

2. Sistemi di storage disponibili

Sono disponibili per l’utente tre tipologie di aree di storage

  •  Area scratch   utilizzabile come area temporanea. Su richiesta possiamo eliminarne il contenuto periodicamente.
  • Archive progetto         Area di mantenimento dei dati
  • Backup         Area che custodisce una replica dei dati gia’  presenti in altri sistemi esterni ad Indaco.

Alla sottoscrizione del progetto di ricerca, lo spazio richiesto viene ripartito in parti uguali tra area progetto ed area scratch. Tale valore puo’ essere modificato su richiesta.

3. Come copiare il proprio dataset

E’ possibile copiare il proprio data set sul cluster utilizzando i seguenti  programmi di copia sicura di file e cartelle.

Windows winscp
Linux scp
Mac scp

 

All’ utente  viene assegnata una cartella disco (Home directory) dove potra’ trasferire i file costituenti il proprio data set.

4. Moduli Load/Unload

Indaco fornisce una serie di moduli per consentire all’utente di preparare l’ambiente di calcolo in funzione dell’applicazione, libreria o tool di sviluppo che intende utilizzare.

Il comando    module avail     fornisce l’elenco dei moduli resi disponibili.

Il comando module load   nome_modulo    consente di caricare il modulo   nome_modulo.

Esempio:

module avail

[pippo@login0 ~]$ module avail

-------------------------------------------
fftw3/3.2.2    gotoblas2/1.08 hdf5/1.8.4      openmpi/1.0
----------------- /opt/apps/modulefiles -----------
gnuplot/4.2.6       intel/11.1(default) papi/3.7.2
intel/10.1          lua/5.1.4           pgi/10.2

module list    per conoscere i moduli caricati

[pippo@login0 ~]$ module list
Currently Loaded Modulefiles:
  1) Linux            3) mvapich2/1.4     5) gotoblas2/1.08
  2) intel/12.1       4) sge/6.2u3

module load  per caricare un modulo specifico e settare correttamente le variabili di ambiente

module load   intel/12.1

module purge   per scaricare tutti i moduli

 

5. Compilatori

Sono disponibili i seguenti compilatori:

  • clang LLVM compiler
  • GCC, the GNU Compiler Collection
  • Intel parallel studio XE cluster edition

6. Utilizzo del sistema batch

I cluster utilizzano un sistema di code batch per la sottomissione di job non interattivi. Gli schedulatori e gestori di risorse utilizzati sono SLURM e CONDOR. I cluster resi disponibili dal Dipartimento di Fisica utilizzano CONDOR, il cluster di Matematica ed il cluster centrale di Indaco SLURM. Rendiamo disponibile una guida per consentire all’utente di modificare i propri script di lancio a seconda del cluster che si intende utilizzare.

SLURM

E’ necessario creare uno script di lancio  myjob.slurm con l’indicazione del programma che si vuole eseguire, con quali parametri, variabili di ambiente e sottometterlo con il comando sbatch.

Esempio di script batch slurm per applicazione seriale

Le righe seguenti costituiscono lo script myjob.slurm che dovra’ essere creato dall’utente:

#!/bin/bash
#SBATCH -o /gpfs/home/users/<user>/myjob.%j.%N.out
(Placeholder) standard output and error. La directory in cui viene inserito il file di output deve esistere prima dell’avvio del job e deve essere specificato il nome completo del percorso (non utilizzare variabili di ambiente!). Il% j codifica l’ID del lavoro nel file di output. Il% N codifica il nodo master del lavoro e deve essere aggiunto poiché gli ID lavoro di diversi cluster SLURM potrebbero essere uguali.
#SBATCH -D /gpfs/home/users/<user>/mydir working directory del job
#SBATCH -J <job_name> (Placeholder) nome del job max 10 caratteri
#SBATCH -p light Utilizza la coda standard per job (equivalente a  –partition)
#SBATCH –get-user-env Setup dell’ambiente dell’utente
#SBATCH –mail-type=end Invia un email al completamento del job (BEGIN,END,FAIL,ALL)
#SBATCH –mem=800mb quantita’ di memoria che il job puo’ utilizzare.
#SBATCH –mail-user=<email_address>@<domain> (Placeholder) e-mail address (Indicare un indirizzo email valido)
#SBATCH –time=08:00:00  massimo tempo di esecuzione 8 hours 0 minutes 0 seconds; il valore puo’ essere incrementato fino al massimo valore consentito per la coda seriale
#SBATCH –account=progetto-nome oppure

#SBATCH –account=dipartimento

Campo obbligatorio (nella fase gratuita indicare il dipartimento di afferenza abbreviato)

equivale a  -A projectname

module load sss_example per caricare i moduli di ambiente richiesti dall’esecuzione del programma esempi: matlab, mpi, openmp, etc
./my_prog_seriale il programma da eseguire.

Esempio:

#!/bin/bash
#SBATCH -o /gpfs/home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /gpfs/home/users/nome.cognome
#SBATCH -J Prova
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=1
#SBATCH -c 1                    # Number of cores per task
#SBATCH --mem-per-cpu 1000       #  Mem for each core
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=0:1:00
#SBATCH --account=nomeprogetto

cd /gpfs/home/users/nome.cognome/test
./my_prog_seriale

 

Comandi principali

Per sottomettere il job utilizza il comando sbatch

esempio:

sbatch   myjob.slurm

Il comando squeue puo’ essere utilizzato per verificare lo stato del job

squeue   –clusters=all

Lista di tutti i job per un utente:

squeue -u <username>

Lista di tutti i job in esecuzione per un utente:

squeue -u <username> -t RUNNING

Lista di tutti i job in stato di pending per un utente:

squeue -u <username> -t PENDING

Per cancellare job:

scancel <jobid>

Per cancellare  tutti i job for un utente:

scancel -u <username>

Per cancellare tutti i job in stato pendin per un utente:

scancel -t PENDING -u <username>

Per cancellare un job individuato dal nome:

scancel –name myJobName

Per mettere in pausa un particolare job:

scontrol hold <jobid>

Per la riattivazione  di un job particolare:

scontrol resume <jobid>

Per riaccodare  (cancel and rerun) un particolare job:

scontrol requeue <jobid>

 

Per una descrizione approfondita  dei comandi segui il  Filmato dimostrativo

 

Esempio di script batch slurm per applicazione multi thread

#!/bin/bash
#SBATCH -o /gpfs/home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /gpfs/home/users/nome.cognome
#SBATCH -J Prova
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=1
#SBATCH -c 32                    # Number of cores per task
#SBATCH --mem-per-cpu 1000       #  Mem for each core
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=0:1:00
#SBATCH --account=nomeprogetto
module load Mlnx/hpcx

cd /gpfs/home/users/nome.cognome/test

export OMP_NUM_THREADS=32
srun ./hello
seff $SLURM_JOBID

Esempio di script batch slurm per applicazione MPI

#!/bin/bash
#SBATCH -o /home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome
#SBATCH -J Prova
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=12
#SBATCH --ntasks-per-node=31
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=0:1:00
#SBATCH --account=nomeprogetto
#SBATCH --mem=100000
module load Mlnx/hpcx
cd /home/users/nome.cognome/test
mpirun --bind-to hwthread --display-map --map-by node -x MXM_RDMA_PORTS=mlx4_0:1 -mca btl_openib_if_include mlx4_0:1 mpi_hello

seff $SLURM_JOBID

Esempio di script batch slurm ibrido OPENMP +MPI

#!/bin/bash
# Example with 8 nodes x 8 MPI tasks per node x 10 threads  per task   for MPI+OpenMP.
#
# Project/Account
#SBATCH -A progetto-nome
#SBATCH -p light
#SBATCH -o /home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome
#
#SBATCH --nodes=8
#SBATCH --ntasks-per-node=8

#
# Runtime of this jobs is less then 12 hours.
#SBATCH --time=0:2:00
#

cd /gpfs/home/users/nome.cognome/test

export OMP_NUM_THREADS=10


mpirun --bind-to hwthread --display-map --map-by node -x MXM_RDMA_PORTS=mlx4_0:1 -mca btl_openib_if_include mlx4_0:1 ./omp-mpi-hello


seff $SLURM_JOBID


Esempio di script per utilizzo GPU K40

#!/bin/bash
#SBATCH -o /home/users/nome.cognome/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome
#SBATCH -J Prova
#SBATCH --gres=gpu:1
#SBATCH --get-user-env
#SBATCH -p gpu
#SBATCH --account=progetto-nome
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1   
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=08:00:00

module load CUDA/9.0.176
cd /home/users/nome.cognome/cartella


./program.cuda  args

  seff $SLURM_JOBID                    

Per utilizzare entrambe le gpu impostare

#SBATCH –gres=gpu:2

Esempio di script per utilizzo dei nodi Big Memory

#!/bin/bash
#SBATCH -o /gpfs/home/users/nome.cognome/myjob.%j.%N.out
#SBATCH -D /gpfs/home/users/nome.cognome
#SBATCH -J Prova

#SBATCH --get-user-env
#SBATCH -p bigmem
#SBATCH --account=progetto-nome
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1   
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=08:00:00
cd /gpfs/home/users/nome.cognome/cartella
module load R/3.4.3
R CMD BATCH --silent --no-save test.R test.out
seff $SLURM_JOBID

Esempio di script batch slurm per high throughput

Uso array in SLURM

6.1 Dipendenze logiche e pipeline

L’esempio mostra come sottomettere due job distinti ma il secondo partira’ solo se il primo termina con successo.

sbatch assemble_apricot.sh

Submitted batch job 1234

sbatch –dependency=afterok:1234 annotate_apricot.sh

6.2 Come cambiare l’account corrente per addebitare le ore di calcolo del job

E' possibile utilizzare l'opzione  

  --account=2NDGROUPNAME del comando  sbatch or srun  per addebitare le ore di calcolo al secondo gruppo di ricerca di cui l’utente fa parte.

Inoltre per garantire una corretta attribuzione dei diritti sui file su disco occorre dare il comando

newgrp   2NDGROUPNAME

6.3 Controllo utilizzo account

Per avere un’indicazione  dell’utilizzo in termini di tempo  di calcolo del cluster da parte dell’utente digitare   il comando   useraccounting

useraccounting date-start date-end [account] [partition]

es:
useraccounting   2018-01-01 2018-03-01 

useraccounting 2018-01-01 2018-03-01 "" light

useraccounting 2018-01-01 2018-03-01 ""  bigmem

useraccounting 2018-01-01 2018-03-01 "" gpu

Per conoscere i limiti di utilizzo in minuti

sacctmgr show assoc where user=nome.cognome

7. Tabella di conversione  PBS – Slurm

CONFRONTO

PBS

SLURM

Sottomettere un job

qsub jobscript

sbatch jobscript

Cancellare un job

qdel job_id

scancel job_id

Cancellare tutti i job di un utente

qdel `qselect -u user`

scancel -u user

Stato del Job

qstat -u user

squeue -u user

Mostra tutti i job

qstat -a

showq

Node list pbsnodes -a scontrol show nodes
Hold a job

qhold <job ID>

scontrol hold <job ID>

Release a job

qrls <job ID>

scontrol release <job ID>

Specificare una coda -q queuename -p queuename
Cambiare account per addebito -A accountname -A accountname
Numero di nodi/ cores richiesti -l

nodes=Numbernodes:corespernode

-N Numbernodes -n numbercores
Wallclock limit -l walltime=Timelimit -t Timelimit
Memory requirements -l mem=MEMORY –mem=MEMORY
-l pmem=MEMORYmb –mem-per-cpu=MEMORY
Stdout file -o FILENAME -o FILENAME
Stderr file -e FILENAME -e FILENAME
Riunire stdout/stderr -j oe -o OUTFILE
Email address -M Emailaddr –mail-user=Emailaddr
Job name -N Name –job-name=Name
Mostra tutti i job

qstat -a

showq

squeue

Variabili di ambiente
Job ID

$PBS_JOBID

$SLURM_JOBID

Working Directory

$PBS_O_WORKDIR

$SLURM_SUBMIT_DIR

Jib array index

$PBS_ARRAY_INDEX

$SLURM_ARRAY_TASK_ID

7.1  Tabella di conversione  Condor – Slurm

CONFRONTO

CONDOR

SLURM

Sottomettere un job

condor_submit jobscript

sbatch jobscript

Cancellare un job

condor_rm job_id

scancel job_id

Cancellare tutti i job di un utente

condor_rm user

scancel -u user

Stato del Job

condor_status

squeue -u user

Mostra tutti i job

condor_q

squeue

Queue list

scontrol show partition [queue]

Node list

scontrol show nodes

Hold a job

condor_hold

scontrol hold <job ID>

Release a job

condor_release

scontrol release <job ID>

Specificare una coda

universe=

-p queuename

Cambiare account per addebito

-A accountname

Numero di nodi/ cores richiesti

request_cpus =n

-N Numbernodes -n numbercores

Wallclock limit

-t Timelimit

Memory requirements

request_memory =Memory

–mem=Memory

–mem-per-cpu=Memory

Stdout file

Output = job.$(cluster).$(process).out

-o FILENAME

 Stderr file

Error = job.$(cluster).$(process).err

 -e FILENAME

 Email address

 –mail-user=Emailaddr

 Job name

 –job-name=Name

Condor

L’esempio mostra un semplice script Condor per la sottomissione di un job.

$ cat program.condor

L’ output del comando visualizza il contenuto del file program.condor:

########################################################
#
# Esempio di sottomissione di job su standard universe
#
########################################################

Universe = standard
Executable = hello

input = /dev/null
output = hello_world.out
error = hello_world.error
log = hello_world.log

Initialdir = /tmp/
Queue

Lo script viene lanciato con il comando

 condor_submit program.condor

Lo stato del job puo’ essere verificato con il comando

 condor_q

Per cancellare tutti i job in coda dell’utente  username utilizzare il comando

   condor_rm username

Altro esempio di script   nbody.condor e relativa sottomissione

        universe = vanilla
        executable = nbody
        arguments =
        input =
        requirements = ( OpSYS="LINUX" && Arch=="X86_64 )
        should_transfer_files = yes
        when_to_transfer_files = on_exit
        notification = never
        output = nbody_output.txt
        log = nbody_log.txt
        queue
 condor_submit nbody.condor

8. Accesso in modo interattivo ai cluster

Esempio di allocazione in modo interattivo di un nodo light

          ssh    login.indaco.unimi.it

           salloc -p light -N 1 --mem=10000  -t 10:0

           srun   ./mio_program.exe

I precedenti due comandi eseguono il binario “mio_programma.exe”  utilizzando  fino a 10 GByte di memoria (indicati in MByte). Possono essere specificati ulteriori paramentri e variabili di ambiente prima di eseguire il comando srun.

Esempio:

export OMP_NUM_THREADS=32

module load mpi/openmpi-x86_64

Esempio di allocazione in modo interattivo di un nodo con GPU

salloc -N 1 -p gpu -t 1:1:1  --mem=10000 --gres=gpu:1 --account=dipartimento 

Esempio di allocazione in modo interattivo di un nodo FAT (1 Tb di memoria RAM)

salloc  -N 1 -p bigmem -t 1:1:1 --mem=500000  --account=dipartimento 
Indicare l'account di addebito delle ore

--account=dipartimento 

--account=nomeprogetto

9. Accesso in modalità grafica

Per accedere in  modalita’ grafica al server centrale Indaco dall’ Europa e’ sufficiente

utilizzare il programma REMOTE DESKTOP di WINDOWS ( impostando le opzioni NO SOUND) .

Per casi specifici da concordare con lo staff tecnico di INDACO e’ possibile utilizzare anche il programma VNCVIEWER seguendo le seguenti istruzioni:

  • scaricare il programma  Real VNCViewer  dal sito    https://www.realvnc.com/en/connect/download/viewer/    per la piattaforma Linux,Windows e Mac
  • eseguire il programma viewer indicando come server  login.indaco.unimi.it
  • inserire le proprie credenziali  ed attendere la comparsa del Desktop come  mostrato in figura

 

Per accesso da fuori Europa utilizzare la VPN di Ateneo.

 

 

Desktop di Indaco

Parametri di connessione

10. Come utilizzare i container singularity

Riferimenti:
http://www.admin-magazine.com/HPC/Articles/Singularity-A-Container-for-HPC

  Container disponibili sul cluster di INDACO

  • falcon_unzip
  • H2020Kit.img
  • jbrowse
  • openFOAM
  • qiime2-2017-12
  • Ubuntu16.04.3LTS-gpuk40m-384-111
  • yupiter-master.img
  • siesta-2018-05-28-5c434cdd12c6.img  ver. 4.1-b2
  • Biocontainers (abyss,  bcftools, bedtools, blast, bowtie2, bwa, comet, gatk, fastqc, picard, samtools, tpp, peptideprophet, proteinprophet)

Per esaminare un container singularity

singularity shell /gpfs/software/Container/nome_container.img

Per eseguire un container in modalita’ batch occorre inserire nello script slurm

module load singularity/2.4

singularity exec /gpfs/software/Container/nome_container.img    PATH/script_di_lancio.sh

 

e preparare uno script bash contentente il programma da avviare e gli argomenti.

es:  script_di_lancio.sh

#!/bin/bash
export MYHOME=/gpfs/home/users/nome.cognome/project1
path/programma     $MYHOME/arg1

 

10.1 Istruzioni per lanciare in modalità batch il container singularity

Creare lo script di lancio

BATCH.slurm



#!/bin/bash
#SBATCH  --account  nomeprogetto
#SBATCH  -p  light
#SBATCH  -o  /gpfs/home/users/nome.cognome/output.txt
#SBATCH  -e  /gpfs/home/users/nome.cognome/error
#SBATCH  -D  /gpfs/home/users/nome.cognome
#SBATCH  -J   JOB_SINGULARITY
#SBATCH  -get-user-env
#SBATCH  ~nodes=1
#SBATCH  -ntasks=32

#SBATCH  --hint=multithread
#SBATCH  -mail-type=ALL
#SBATCH  --mail-user=nome.cognome@unimi.it

#SBATCH  -time=16:00:00
###########################
unset  PYTHONPATH

module  load  singularity/2.4
## modificare la riga sottostante specificando il percorso alla cartella progetto in modo da renderla visibile all’interno del contenitore
singularity  exec  -B    /PATH/PROJECT:/mnt       /gpfs/software/Container/ubuntu.img      /gpfs/home/users/nome.cognome/start.sh

## /gpfs/software/Container/ubuntu.img     è il contenitore contenente l’appicazione da eseguire
## /gpfs/home/users/nome.cognome/start.sh  è lo script per lanciare l’applicazione all’interno del contenitore
 ##fine script batch	

Script start.sh
Il  file  start.sh  è  fatto  così

#!/bin/bash

export  LD_LIBRARY_PATH=PATH/mia_applicazion/lib:$LD_LIBRARY_PATH
export  PYTHONUSERBASE=/percorso/fc_env
export  PATH=/PATH/mia_applicazione/bin:$PATH

cd  /gpfs/home/users/nome.cognome/
mia_applicazione       /mnt/DATA/args  > ./output

#---------------------------------------------------------------

Lancio del job
sbatch BATCH.slurm

Verifica se il job è in esecuzione e su quale nodo
squeue

10.2 Creazione del proprio contenitore

Nel caso in cui il contenitore singularity con l’ applicazione di interesse non sia disponibile sul cluster INDACO, l’utente puo crearlo sul portatile. Uno dei modi per farlo e scaricare da Internet il file Docker.spec  relativo al docker contenente l’ applicazione di interesse  e lanciare sul portatile il comando

$sudo singularity build   Contenitoresingularity.img    Docker.spec

Docker.spec  contiene le specifiche del contenitore che si vuole creare.

Una volta creato il Container singularity occorre copiarlo su INDACO nella propria cartella.

Singularity ed MPI

Per gli utenti che desiderano utilizzare MPI con i container singularity in modalita’ multi-nodo riportiamo una descrizione dei passi da fare nel documento al link seguente  PDF

 

11. Come lanciare la prima virtual machine Linux

Template di macchine virtuali disponibili all’utente

ubuntu-artful-cloud Cloud enabled Ubuntu 17.10
ubuntu-cosmic-cloud Cloud enabled Ubuntu 18.10
ci-centos Cloud enabled CentOS 7
windows 7 custom image Windows
windows 10 custom image Windows (richiesta attivazione)

Per il neofita, e’ possibile ricorrere alla procedura guidata digitando i seguenti comandi:

module load omics/1

vmhd

Comparira’ una finestra grafica che accompagnerà  l’ utente  nelle fasi di lancio delle VM.

L’ utente potra’  contattare lo staff di Indaco per delucidazioni in merito.

Dopo il lancio l’ accesso alle VM Linux   avverrà  con il comando

pcocc  ssh  -l demo  vm-i 

mentre l’ accesso  in modalita’  grafica con il comando  pcocc  display vm-i

Per utenti esperti digitare vmhdexpert

Filmato dimostrativo

La lista dei template e’ disponibile con il comando

pcocc template list

Ulteriori template saranno resi disponibili su richiesta.

L’utente   puo’ utilizzare il  template per modificare la macchina virtuale ed adattarla alle proprie esigenze.

E” possibile accedere alle macchine virtuali mediante ssh (con chiave dell’utente)  o tramite interfaccia grafica ( protocollo spice).

Lancio di una macchina virtuale predefinita (da template)

pcocc alloc -p light –account=dipartimento –mem 8192 -c 6 -t 1:1:1  ci-centos
( si noti che sono presenti 2 segni meno davanti ad account e davanti a mem,
uno solo davanti a c e davanti a t)
Accesso alla macchina virtuale

L’accesso alla macchina virtuale richiede la configurazione del file ~/my-cloud-config

#my-cloud-config
users:
   - name: demo
     sudo: ['ALL=(ALL) NOPASSWD:ALL']
     ssh-authorized-keys:
      - <your ssh public key>
packages:
 - qemu-guest-agent
runcmd:
 # Make sure that the service is up on all distros
 - systemctl start qemu-guest-agent
Il file crea l'utente demo in grado di  fare sudo senza password ed accedere via ssh con chiave dell'utente.

Creiamo il file   ~/.pcocc/templates.yaml

mycentos:
    inherits: centos7-cloud
    user-data: ~/my-cloud-config
    description: "Custom CentOS 7"

myubuntu:
    inherits: ubuntu-artful-cloud
    user-data: ~/my-cloud-config
    description: "Custom Ubuntu"

in modo da utilizzare i template di default e configurarli con la chiave ssh dell’utente.

Per lanciare diamo il comando

pcocc alloc -p light –account=dipartimento –mem 8192 -c 6 -t 1:10:1  mycentos:1

La macchina virtuale verra’ lanciata con 6 core e 8GB di memoria  per un tempo di 1 ora 10 minuto 1 secondo

 

Per accedere digitare

pcocc ssh -l demo vm0

 

Lancio di diverse macchine virtuali

Lancio di 4 macchine virtuali  identificate con

ID Type
vm0 CentOS (1)
vm1 CentOS (2)
vm2 CentOS (3)
vm3 Ubuntu (1)
pcocc -vv alloc  -p light --account=dipartimento --mem 8192  -c2 mycentos:3,myubuntu:1 
pcocc ssh vm0 -l demo
....
pcocc ssh vm3  -l demo

 

Istruzioni  per avviare macchine virtuali Linux

12. Come attivare un cluster di virtual machine Linux

Istruzioni  per avviare un cluster di macchine virtuali Linux

13. Come lanciare la macchina virtuale Windows in meno di 30 secondi

Utilizzare il programma Accesso Remoto di Windows per connettersi a login.indaco.unimi.it oppure utilizzare  ssh -X login.indaco.unimi.it

Eseguire i seguenti   3 comandi da una shell per avere una VM Windows 7 con MathWorks Matlab R2018a

/gpfs/software/Pcocc/configure/configuravm.sh

pcocc alloc -p light --account=dipartimento --mem 24GB -c 3 -t 1:1:1 matlab:1

--account=    dipartimento o progetto  (sono presenti due -)

--mem  GB di RAM della VM   (sono presenti due -)

-t   ore:minuti:secondi       (singolo -)

-c    n. di core della VM      (singolo -)

pcocc display vm0

ed inserire la password ricevuta dallo staff di Indaco. 
Le VM dell'utente sono indicizzate vm0, vm1, vm2 ..

Le macchine virtuali vengono distrutte alla fine della sessione. Occorre salvare su share remota i propri dati. Allo scopo utilizzare il programma sftp per trasferire i file su INDACO o utilizzare l’ambiente cloud preferito.

Qualora il comando pcocc display vm0   dovesse segnalare un messaggio di errore disabilitare il suono tra le opzioni del programma accesso remoto di windows.

Istruzioni  per avviare macchine virtuali Windows 7

Aggiungere applicazioni alla vm

14. Applicazioni

Annovar

module load genetics/Annovar

COMSOL

La licenza è fornita dal Dipartimento di Scienze Agrarie e Ambientali – Produzione, Territorio, Agroenergia

Occorre concordarne l’utilizzo con il docente di riferimento.

Inviare email di richiesta a  indaco-tech@liste.unimi.it

 

module load Comsol/51

Per una esecuzione interattiva eseguire

comsolindaco

Att.ne

La prima volta che si lancia comsolindaco  il programma crea dei file di configurazione e chiede all’utente di uscire.  Occorre ripetere il lancio.

Utilizzo in modalità batch su singolo nodo

#!/bin/bash
#SBATCH --time=24:00:00
#SBATCH --mem=48GB
#SBATCH --ntasks-per-node=12

#SBATCH --job-name=comsol_runex
#SBATCH --nodes=1
#SBATCH --partition=light       # For big  nodes, change to "bigmem"
#SBATCH --mail-type=ALL         # Notify me at start and finish
#SBATCH --mail-user=nome.cognome@unimi.it

#SBATCH --account=evaluation  
module load comsol/51



cd /gpfs/home/users/nome.cognome/comsolwork

comsol batch -inputfile comsol_smalltest.mph -study st04 -outputfile mymodelresu
lt.mph \
-batchlog mybatch.log -j b1 -np 12 -mpmode owner

Il lancio avverrà  come di consueto

sbatch    mioscript.sh

Avvio in modalità cluster multinode utilizzando lo script seguente:

slurmsubmit.sh

#!/bin/bash -l

#SBATCH -o /gpfs/home/users/nome.cognome/NOMEPROGETTO/Modelli/logs/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome/NOMEPROGETTO/Modelli 

# 
# 
#####################################
#SBATCH --job-name=comsol_run
#SBATCH --nodes=4
#SBATCH --cpus-per-task=16                     # Indaco nodes have 16 cores for each socket
#SBATCH --mem-per-cpu=7500MB                   # Leave some memory for the system to work
#SBATCH --time=3:10:00                         # Syntax is DD-HH:MM:SS
#SBATCH --partition=light                      # For big  nodes, change to "bigmem"
#SBATCH --mail-type=ALL                        # Notify me at start and finish
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --exclusive                            # Not necessary, implied by the specs above
#SBATCH --account=disaa                        # Change to your account 
#####################################

export MODELTOCOMPUTE="prova_per_indaco.mph"
export INPUTFILE="${HOME}/NOMEPROGETTO/Modelli/input/${MODELTOCOMPUTE}"
export OUTPUTFILE="${HOME}/NOMEPROGETTO/Modelli/output/${MODELTOCOMPUTE}"
export BATCHLOG="${HOME}/NOMEPROGETTO/Modelli/logs/${MODELTOCOMPUTE}.log"

# define input
inp=$INPUTFILE  # First input argument: Name of input



# define directories
submitdir=${SLURM_SUBMIT_DIR}
workdir=/gpfs/home/users/${USER}/${SLURM_JOBID}

# create work directory
mkdir -p ${workdir}

# move input to workdir
cp ${inp} ${workdir}

# load necessary modules
module purge --quiet
module load Comsol/51
module load intel/parallel_2018   

# run calculation in workdir
cd ${workdir}
time comsol -nn 8\
            -np ${SLURM_CPUS_PER_TASK}\
            -mpirsh /usr/bin/ssh\
            -mpiroot $I_MPI_ROOT\
            -mpi intel batch\
            -inputfile ${inp}\
            -outputfile ${OUTPUTFILE}\
            -mlroot /gpfs/software/Matlab/R2018a/





##################################################
oppure

#!/bin/bash

# For general partition
#SBATCH -p light
#SBATCH --nodes 8
#SBATCH --cpus-per-task 12
#SBATCH --ntasks-per-node 1
#SBATCH --output comsol.log
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=10:1:00
#SBATCH --account=disaa

# input and output files. 
INPUTFILE=/path/to/input_model.mph 
OUTPUTFILE=/path/to/output_model.mph 

# Load  comsol module.
 module purge  
module load intel/parallel_2018 
module load comsol/5.1

export TMPDIR="/path/to/temp/dir"

# Run comsol
comsol batch \
    -clustersimple \
    -np $SLURM_CPUS_PER_TASK \
    -mpifabrics shm:ofa \
    -inputfile $INPUTFILE \
    -outputfile $OUTPUTFILE \
    -tmpdir temp

Il lancio avverrà digitando

sbatch  slurmsubmit.sh

Prima del primo lancio si consiglia di eseguire lo script
/gpfs/software/Comsol/pre-comsol.sh
digitando il tasto invio per confermare tutte le richieste. Il comando crea le chiavi RSA per l’accesso ai nodi di calcolo.

Ultertiori informazioni possono essere reperite sul sito Comsol

Breve riepilogo direttive:

–cpus-per-task=CPUs number of CPUs required per task
–ntasks-per-node=ntasks number of tasks to invoke on each node
–ntasks-per-socket=ntasks number of tasks to invoke on each socket
–ntasks-per-core=ntasks number of tasks to invoke on each core

 

Nodename

light1

light2

light3

light12

Number of Sockets

2

2

2

2

Number of Cores per Socket

16

16

16

16

Total Number of Cores

32

32

32

32

Number of Threads (CPUs) per Core

1

1

1

1

Total Number of CPUs

32

32

32

32

 

Il numero massimo di core fisici su ogni nodo e’ 32.

Il numero massimo di nodi nella partizione light e’   12.

 

#SBATCH –nodes=12     ( comsol  option  num processi MPI  -nn= 12*32)

#SBATCH –num-tasks-per-node=32    (comsol option num processi per host -nnhost )

L’hyperthreading sui nodi di calcolo e’ disabilitato.

Falcon e Falcon Unzip

Istruzioni per Falcon

 

Gromacs

OpenFoam

The open source CFD toolbox
Un container openfoam e’ reso disponibile agli utenti dopo la fase di test.

Matlab

  1. Accesso in modalità batch
  2. Accesso in modo grafico interattivo
  3. Accesso a Matlab attraverso la macchina virtuale Windows

Sono presenti 2 versioni di matlab caricabili con i moduli

module load matlab/R2017b

module load matlab/R2018a

Accesso in modalità batch

in modalità batch richiede uno script

#!/bin/bash

#SBATCH -o /home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome
#SBATCH -J Programma-calcolo-matlab
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=1
#SBATCH -c 15
#SBATCH --mem-per-cpu 8000
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --account=nome-progetto
#SBATCH --time=0:1:00
cd /home/users/nome.cognome/test


module load matlab/R2017b

matlab  -nodisplay < matlab_parfor.m

seff $SLURM_JOBID
##############################################

#Se si e' aperto un progetto e' possibile aggiungere
export SCRATCH="/scratch/projects/NOME_PROGETTO"

# Create a temporary directory on scratch
mkdir -p $SCRATCH/$SLURM_JOB_ID
cd   $SCRATCH/$SLURM_JOB_ID

# Kick off matlab
matlab -nodesktop -nodisplay -nosplash < PATH_NOME_SCRIPT_DA_ESEGUIRE.m

Accesso in modalità grafica ed interattiva

Da una shell in ambiente grafico (ssh -X per Linux, ssh -Y per Mac OS X, accessso remoto per Windows ) eseguire i due comandi sottostanti

bash-4.2$ module load matlab/R2018a
bash-4.2$ matlabindaco

utilizzo: matlabindaco account/progetto n.ore n.core memoria (default MB)
esempio: matlabindaco matematica 3 4 16GB
——————————–
bash-4.2$ matlabindaco   h2020    3    4   16GB

L’istruzione precedente richiede 3 ore di calcolo in ambiente grafico allocando   4 core e 16GB da addebitare sul progetto h2020 utilizzando la partizione light.

Per esigenze specifiche in cui si richiede l’uso dei nodi bigmem o gpu digitare

module matlab/R2018a
salloc -p gpu  –account=dipartimento/progetto  –mem 16GB    -c 4  –gres=gpu:1   -t 4:1:1 slurm-ssh.sh

oppure

salloc -p bigmem  –account=dipartimento/progetto  –mem 16GB    -c 4   -t 4:1:1 slurm-ssh.sh

All’utente puo’ essere richiesto di digitare la  propria password.

Accesso a Matlab attraverso la macchina virtuale Windows

Per tale accesso si veda la sezione macchine virtuali windows.

 

Istruzioni complete per i cluster satelliti sono reperibili al link
Istruzioni per Matlab

MaxQuant   quantitative proteomics software package

All’interno della macchina virtuale OMICS è disponibile il software.

I tagli di default delle VM sono:

omics    per 6 cpu,      12 GB RAM,           disco  di sistema 80 GB

omics16  per 16 cpu,  128 GB RAM,        disco di sistema  80GB

omics32  per 32 cpu,  220 GB RAM,      disco di sistema  80GB

Sono rese disponibili VM con capacità disco maggiori. Occorre lanciare omicshd.

Si ricorda che allo spegnimento della macchina virtuale tutti i dati salvati su disco C:  verranno cancellati. Pertanto e’ compito dell’ utente salvarli su Indaco o altro sistema remoto prima della chiusura della sessione di lavoro ed arresto di  Windows 10.

E’ possibile utilizzare gli strumenti disponibili all’ interno della VM come sftp, winscp o utilizzare Google Chrome per accedere ad UNIMIBOX o altro sistema cloud.

Copia da PC Docente su INDACO

Sul proprio DESKTOP di INDACO e’ presente l’ icona

 

 

 

Quando il programma accesso remoto di Windows e’ configurato correttamente come descritto in questa guida, facendo click  sull’ icona si aprira’ la finestra  dei file del PC dell’utente  da cui e’ possibile fare copia-incolla per trasferirli su INDACO.

E’ stato rilevato un malfunzionamento con i valori di default di Windows 10 e MaxQuant.

Il problema viene risolto cambiando il separatore decimale da , (virgola) a . (punto)  su Windows 10.

Windows 10

Cambio impostazioni:

  • vai su  Start >  Panello di controllo  > Lingua 
  • Cambia data ora o formato dei numeri
  • Impostazioni aggiuntive
  • Per separatore decimale, inserisci un punto:.
  • For separatore di elenco, inserisci una virgola:,

MaxQuant e’presente anche nel container singularity

/gpfs/software/Container/Ubuntu16.04.3LTS-gpuk40m-384-111

all’ interno della cartella /opt

Se si dispone del file mqpar.xml e’ possibile eseguire singularity

singularity exec  -B /gpfs    /gpfs/software/Container/Ubuntu16.04.3LTS-gpuk40m-384-111 /usr/bin/mono /opt/MaxQuant/bin/MaxQuantCmd.exe  PATH/mqpar.xml

 

MultiQuant piattaforma OMICS

Seguendo le istruzioni del video sottostante, l’utente apprende come accedere ad Indaco, come preparare i dati forniti dagli esperti di  OMICS per l’analisi, come lanciare la macchina virtuale ed attivare il programma MultiQuant sui dati presenti nell’unità D:

Per la configurazione del programma accesso remoto di Windows si rimanda al PDF  relativo.

Video dimostrativo

Sintesi del video dimostrativo
 1 L'utente riceve da Omics il percorso relativo alla cartella 
   contenente i dati del campionamento (mediante e-mail)
 2 L'utente accede mediante Desktop Remoto ad Indaco
 3 L'utente digita il comando omics  per generare il CDROM
   virtuale e renderlo visibile alla macchina virtuale
 4 L'utente  avvia la macchina virtuale ed utilizza il 
   software MultiQuant
 5 L'utente termina il lavoro spegnendo la macchina 
   virtuale e cancellando i dati non piu' richiesti.




Da Linux
ssh -X nome.cognome@login.indaco.unimi.it



1. eseguire la prima volta in una shell testuale
/gpfs/software/Pcocc/configure/configurapcocc.sh


poi lanciare la macchina virtuale 

 pcocc alloc -p light   --account=dipartimento  --mem 8192 -c 6 -t 1:1:1  omics:1

oppure
 pcocc alloc -p light --account=nomeprogetto  --mem 8192 -c 6 -t 1:1:1  omics:1

--mem quantita' di memoria della macchina virtuale   
 (aumentare all'occorrenza)
-c  numero di core (valore consigliato 6)

-t  tempo macchina in ore:minuti:secondi 
  (obbligatorio inserirlo altrimenti dopo 10 minuti la macchina va giu')

Compare qualche messaggio a video.

salloc: Granted job allocation 1815
salloc: Waiting for resource configuration
salloc: Nodes light1 are ready for job
Configuring hosts... (done)                     
(pcocc/1815) bash-4.2$ 
GLib-WARNING **: gmem.c:483:custom memory allocation vtable


Dopo qualche secondo  premere invio per avere il controllo della shell
e digitare

pcocc display vm0   e dare invio

password da inserire:   richiedere allo staff di INDACO
  Fase di boot del SO  (avviare normalmente)


Per vedere i propri file occorre montare la cartella con il programma SFTP    
(inserire username nome.cognome e password  posta elettronica).
Dopo qualche secondo compare  la finestra con i dati personali 

 Non attivare ibernazione ne' la modalita'  sleep.


Accesso da Windows

I modalita'
Avviare accesso remoto   server:  login.indaco.unimi.it

aprire una shell

seguire le indicazioni Linux dal punto 1

II Modalita'
  se si dispone di X server per windows (Mobaxterm, cygnus o altro software)
avviare X server e proseguire con istruzioni LINUX 


Accesso da MAC

Installare il programma Accesso remoto di Microsoft  e 
seguire indicazioni Windows o seguire istruzioni per Linux


TABELLA RIASSUNTIVA MACCHINE VIRTUALI 

module load omics/1        per caricare il modulo omics
digitare omics, omics16, omics32, omicshd per le seguenti funzioni:
omics 6 cpu 12   GB    no HD persistente
omics16 16 cpu 128 GB    no HD persistente
omics32 32 cpu 128 GB    no HD persistente
omicshd 6 cpu

16 cpu

30 cpu

32 cpu

16    GB

32   GB

64   GB

128 GB

256 GB

HD 150 GB

HD 300 GB

HD 500 GB

HD 1000 GB

omicshd fornisce all'utente un disco
persistente da 150 GB, 300 GB ,500 GB o 1TB per le analisi dei dati.
Il disco puo' essere riutilizzato nelle sessioni successive.
Al momento della registrazione del progetto occorre prevedere 
lo spazio disco necessario per le elaborazioni.

NAMD

Esempio di utilizzo con 2 schede Nvidia K40

#!/bin/bash
#SBATCH  --account project_name 
#SBATCH -p gpu
#SBATCH -o /gpfs/home/users/nome.cognome/namd/output.txt
#SBATCH -e /gpfs/home/users/nome.cognome/namd/error
#SBATCH -D /gpfs/home/users/nome.cognome/namd
#SBATCH -J NAMD_A
#SBATCH --get-user-env
#SBATCH --gres=gpu:2
#SBATCH --nodes=1
#SBATCH --ntasks=32
#SBATCH --ntasks-per-core=2
#SBATCH --hint=multithread
#SBATCH --mail-type=ALL
#SBATCH --mail-user nome.cognome@unimi.it
#SBATCH --time=01:20:00 
module load intel/parallel_2018
cd /gpfs/home/users/nome.cognome/namd
module load CUDA/9.1.85  
#export  PATH=/gpfs/software/Namd/NAMD_Git-2018-03-08_Linux-x86_64-multicore-CUDA/:$PATH
module load namd/2018-cuda
charmrun namd2 +idlepoll +p31 +isomalloc_sync dimero_dyn.namd > dimero_dyn.out

Per la versione multicore caricare il modulo

  • module load namd/2018-multicore

per uilizzare la versione cuda  caricare il modulo

  • module load namd/2018-cuda

per avviare sul nodo di Login il programma VMD 1.9.3

eseguire   vmd   dopo aver caricato uno dei due moduli sopra indicati .

 

Neuron

Un semplice script e’ proposto di seguito. Prevede di caricare i due moduli seguenti:

module load  neuron/7.5-noiv

module load intel/parallel_2018

 

#!/bin/bash
#SBATCH -o /home/users/nome.cognome/test/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome
#SBATCH -J Prova
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=8
#SBATCH --ntasks-per-node=8
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=0:1:00
#SBATCH --account=nome_progetto

module load intel/parallel_2018

cd /gpfs/home/users/nome.cognome/mpi

module load neuron/7.5-noiv
 
export I_MPI_OFA_NUM_ADAPTERS=1

mpirun -genv I_MPI_FABRICS shm:ofa   -n 64  nrniv -mpi  test0.hoc 

Pari/GP

module load pari/2.11.0

per avviare il programma digitare

gpindaco account/progetto n.ore n.core memoria (default MB)

max n. di core  32

max mem 256GB

time max 48 ore

 

esempio:

gpindaco    evaluation   3       4    16GB

oppure

gpindaco     matematica  3    4        16GB

Il sistema richiederà la password dell’utente per controllo.

 

R

module load  R/3.4.3

Per installare packages aggiuntivi creare una cartella

mkdir R_MYPACKAGES

eseguire

export R_LIBS=R_MYPACKAGES

Poi installare i pacchetti di R come di consueto.

 

RStudio

module load R/studio-3.4.3

rstudioindaco account ore cpu memoria

esempio:

 

bash-4.2$ module purge
bash-4.2$ module load R/studio-3.4.3
bash-4.2$ rstudioindaco evaluation  3  4  16G
password:
 digitare la propria password e dare invio


 

Relion

module load relion/v2

relion &

All’ interno del programma richiamare  uno script batch per il lancio sui nodi.

Siesta

 

#!/bin/bash
#SBATCH -o /gpfs/home/users/nome.cognome/myjob.%j.%N.out
#SBATCH -D /gpfs/home/users/nome.cognome/siesta-4.1-b2/Tests/graphite_c6_full/ 
#SBATCH -J Siesta 
#SBATCH --partition light 
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=2
#SBATCH --mail-type=all
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=2:00:00
#SBATCH --account=fisica

cd /gpfs/home/users/nome.cognome/siesta-4.1-b2/Tests/graphite_c6_full/
echo $SLURM_JOB_NODELIST


module load singularity/2.4
singularity exec  -B /gpfs/home/projects/nomeprogetto:/projects /gpfs/software/Container/siesta-2018-05-28-5c434cdd12c6.img  /gpfs/home/users/nome.cognome/siesta-4.1-b2/Tests/graphite_c6_full/start.sh

La cartella nomeprogetto sara’visibile all’ interno del contenitore  in /projects. Modificare i percorsi degli script in accordo.

 

Il file start.sh

#!/bin/bash
cd /gpfs/home/users/nome.cognome/siesta-4.1-b2/Tests/graphite_c6_full
make

SMRT

SoWatch project

L’avvio della macchina virtuale predefinita del progetto SoWatch  puo’ essere effettuata digitando:

  1.  SoWatch
  2.  SoWatch16
  3.  SoWatch32

per richiedere rispettivamente

6 core e 8GB , 16 core e 128GB  , 32 core e 255GB.

 

 

SPAdes

module load genetics/SPAdes

Spark

Sono disponibili i seguenti moduli:

spark/rdma-spark-0.9.5
spark/1.6.0
spark/2.2.1
spark/2.3.0
spark/2.3.1-self-compiled
spark/2.3.1

 

Esempio di script utilizzato sul cluster satellite Horizon:

Esempio interattivo  che utilizza 1 nodo

sbatch  -N1  -p light   --mem=20000   -t 0:3:1

salloc: Granted job allocation 2183
salloc: Waiting for resource configuration
salloc: Nodes light1 are ready for job

bash-4.2$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2183 light bash     user  . R 0:07 1 light1

ssh light1 

module load spark/2.3.0

module load R/3.4.3

$SPARK_HOME/bin/spark-submit      ./examples/src/main/r/dataframe.R

 

seff  2183

 

Cores: 1 CPU Utilized: 00:02:14 CPU Efficiency: 74.44% of 00:03:00 core-walltime Job Wall-clock time: 00:03:00 Memory Utilized: 420.50 MB Memory Efficiency: 2.10% of 19.53 GB

 

Stata

Come usare Stata

15. Librerie

Atlas, Blas, Lapack

Le librerie fanno parte dell’istallazione standard del sistema operativo

lapack-3.4.2-8.el7.x86_64

blas-3.4.2-8.el7.x86_64

atlas-3.10.1-12.el7.x86_64

Il loro percorso e’

/usr/lib64/atlas

/usr/lib64/    per lapack e blas

Per l’implementazione Intel (MKL) occorre caricare il modulo

intel/parallel_2018

 

Cuda

module load CUDA/9.0.176
module load CUDA/9.1.85

FFTW

Le librerie fanno parte dell’istallazione standard del sistema operativo

Il percorso e’

/usr/lib64

 

Petsc

module load petsc/3.8.3

Mellanox MPI

module load Mlnx/hpcx

Intel MPI

Per la versione Intel 2018

module load intel/impi

 

Per la versione Intel 2019

module load intel/impi2019upd1

esempio:

mpirun -genv I_MPI_FABRICS shm:ofi -ppn 20   ./testintel

 

16. Compilatori

GNU 5.4.0

module load gnu/5.4.0

GNU 7 7.2.0

module load gnu7/7.2.0

LLVM 5

module load llvm5/5.0.0

Intel Parallel Studio 2018

ssh  nome.cognome@login2.indaco.unimi.it

module load intel/parallel_2018

esempio di file sbatch

 

#!/bin/bash
#SBATCH -o /home/users/nome.cognome//myjob.%j.%N.out
##SBATCH -o /tmp/myjob.%j.%N.out
#SBATCH -D /home/users/nome.cognome 
#SBATCH -J Programma
#SBATCH --get-user-env
#SBATCH -p light
#SBATCH --nodes=1
#SBATCH --ntasks=20
#SBATCH --threads-per-core=1
#SBATCH --mail-type=end
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=00:04:30
#SBATCH --account=evaluation

#export SLURM_CPU_BIND=none

module load intel/parallel_2018
cd /home/users/nome.cognome/folder
module load petsc/3.8.3
export I_MPI_OFA_NUM_ADAPTERS=1

mpirun -genv I_MPI_FABRICS shm:ofa  -ppn 20      ./bido_mecc

seff $SLURM_JOBID

Intel Parallel Studio 2019

 

module load intel/parallel_2019upd1

mpirun -genv I_MPI_FABRICS shm:ofi -ppn 20 ./testintel


17 Dati personali e dati sensibili

La normativa europea (EU General Data Protection Regulation, GDPR) in vigore dal 25 Maggio 2018 richiede di adottare requisiti tecnici ed organizzativi di rilievo per poter trattare dati personali in sicurezza per garantire la privacy degli utenti e/o di terzi a cui tali dati si riferiscono.

Vengono di seguito richiamate alcune definizioni fondamentali

«trattamento»: qualsiasi operazione o insieme di operazioni, compiute con o senza l’ausilio di processi automatizzati e applicate a dati personali o insiemi di dati personali, come la raccolta, la
registrazione, l’organizzazione, la strutturazione, la conservazione, l’adattamento o la modifica, l’estrazione, la consultazione, l’uso, la comunicazione mediante trasmissione, diffusione o qualsiasi
altra forma di messa a disposizione, il raffronto o l’interconnessione, la limitazione, la cancellazione o la distruzione;

«dato personale»: qualsiasi informazione riguardante una persona fisica identificata o identificabile;

«interessato»: si considera identificabile la persona fisica che può essere identificata, direttamente o indirettamente, con particolare riferimento a un identificativo come il nome, un numero di
identificazione (anche IP), dati relativi all’ubicazione, un identificativo online o ad uno o più elementi caratteristici della sua identità fisica, fisiologica, genetica, psichica, economica, culturale o sociale;

CATEGORIE PARTICOLARI DI DATI PERSONALI
Per categorie particolari di dati personali si intendono dati che rivelino l’origine razziale o etnica, le opinioni politiche, le convinzioni religiose o filosofiche, o l’appartenenza sindacale, nonché trattare dati genetici, dati biometrici intesi a identificare in modo univoco una persona fisica, dati relativi alla salute o alla vita sessuale o all’orientamento sessuale della persona.
In particolare
«dati genetici»: i dati personali relativi alle caratteristiche genetiche ereditarie o acquisite di una persona fisica che forniscono informazioni univoche sulla fisiologia o sulla salute di detta persona, e che risultano in particolare dall’analisi di un campione biologico dell’individuo in questione;
«dati biometrici»: i dati personali ottenuti da un trattamento tecnico specifico relativi alle caratteristiche fisiche, fisiologiche o comportamentali di una persona che ne consentono o confermano l’identificazione univoca, quali l’immagine facciale o i dati
dattiloscopici;
«dati relativi alla salute»: i dati personali attinenti alla salute fisica o mentale di una persona, compresa la prestazione di servizi di assistenza sanitaria, che rivelano informazioni relative al suo stato di salute;
«dati giudiziari»: quelli che possono rivelare l’esistenza di determinati provvedimenti giudiziari soggetti ad iscrizione nel casellario giudiziale (ad esempio, i provvedimenti penali di condanna definitivi, la liberazione condizionale, il divieto od obbligo di soggiorno, le misure alternative alla detenzione) o la qualità di imputato o di indagato.

Per poter trattare i dati in modo sicuro INDACO fornisce alcune indicazioni e rende disponibili software crittografici all’interno della piattaforma.

Un trattamento dei dati non conforme alla normativa (GDPR) ha delle serie ricadute sull’Universita’ degli Studi di Milano. I ricercatori sono invitati a contattare gli uffici di Ateneo competenti e a dichiarare preliminarmente la tipologia dei dati trattati e le tecnologie di protezione adottate per garantire la loro salvaguardia.

17.1 Sicurezza dei dati personali e sensibili

Indaco mette a disposizione dell’utente il software EncFS che consente di tenere crittografati i propri dati all’interno di una cartella. Solo i dati vengono crittografati. I meta-dati rimangono visibili a chiunque abbia accesso ai file crittografati (si applicano le autorizzazioni UNIX).

Utilizzo di EncFS

Creare una directory dove i file criptati saranno memorizzati

mkdir ~/encrypted

Creare un mountpoint

mkdir ~/decrypted

Creare il sistema cifrato e montarlo

encfs /gpfs/home/users/nome.cognome/encrypted   /gpfs/home/users/nome.cognome/decrypted

La prima volta che si esegue il comando, il sistema si configura richiedendo all’utente alcuni parametri in particolare la parola chiave

Creating new encrypted volume.
Please choose from one of the following options:
 enter "x" for expert configuration mode,
 enter "p" for pre-configured paranoia mode,
 anything else, or an empty line will select standard mode.
?> x

Manual configuration mode selected.
The fwing cipher algorithms are available:
1. AES : 16 byte block cipher
-- Supports key lengths of 128 to 256 bits
-- Supports block sizes of 64 to 4096 bytes
2. Blowfish : 8 byte block cipher
-- Supports key lengths of 128 to 256 bits
-- Supports block sizes of 64 to 4096 bytes
3. CAMELLIA : 16 byte block cipher
-- Supports key lengths of 128 to 256 bits
-- Supports block sizes of 64 to 4096 bytes

Enter the number corresponding to your choice: 1

Selected algorithm "AES"

Please select a key size in bits. The cipher you have chosen
supports sizes from 128 to 256 bits in increments of 64 bits.
For example:
128, 192, 256
Selected key size:256

ATTENZIONE !

La parola chiave crittografica deve essere tenuta dall’utente riservata e custodita in un luogo sicuro.  Lo staff di Indaco non e’ a conoscenza della chiave simmetrica per cifrare e decifrare e non  puo’ recuperare i dati se l’utente dimentica o perde la parola chiave.

Superata la fase precedente l’utente puo’ copiare  i file nella directory ~/decrypted  e guardare il contenuto cifrato nella cartella ~/encrypted.

I file in questa seconda cartella risulteranno cifrati.

Disattivazione della vista sui dati

Il comando seguente disattiva  la vista del file system cifrato

fusermount -u  /gpfs/home/users/nome.cognome/decrypted

Sara’ sempre possibile entrare nella cartella cifrata  encrypted ed il contenuto apparira’

bash-4.2$ cd encrypted
bash-4.2$ ls
7FO86m14BFz4aXat3uF5msNw
BpicBJ3,z24BckFdEpyJOIe6-5vK2bRN7Jvc1NbOarSW11
cnTljzV2y1n8dxyq45hErLJcz0-Ql9dE-F1fML9Eo2i,J,
d2UjsYkUWzYIIfE4vir84e7-
dKFu7cvqE7ZM8psdmXLaHaJSX9stF1WZs8cG1Jb9yIf46-
DT15jfrkW0oTXcv-yXiMJ69J
E54ai4qJc2m9B24Zvj6gqAPk
fpGPwUPL-O4xHgpGxOLz4OFD
noKT4enuvSKjA5XLj7x18GbN98Nt7TJ7jnBqqqHcaU,Da1
NVIZyVAw8GUtU61hEYtwATB2
Re5fJY6nD6XwJdFXlzQ2KYvA
s6gEjxiOxh6-sXH0ndRzitP1
z4n4tNEB1YgBR-ZP-KIAnMjE

Il comando di mount  encfs   folder-encrypted  folder-decrypted  deve essere eseguito sul nodo di calcolo assegnato all’utente  per consentire all’applicazione di utilizzare il dato in chiaro.

INDACO si riserva di fornire agli utenti altre tecnologie oltre Encfs per rendere sicuro l’utilizzo di dati personali e sensibili.

18 Preprocessing dei dati

Per un utilizzo ottimale dello spazio disco, preliminarmente alle attivita’ di elaborazione,  gli utenti che richiedono di operare su grandi quantita’ di dati organizzati in file di piccole dimensioni possono ricorrere a squashfs un file system libero compresso e di sola lettura.

Lo script sbatch conterra’ alcune righe  prima di lanciare l’elaborazione per montare correttamente i dati

cd /gpfs/home/users/nome.cognome

/usr/bin/squashfuse     squashfs.img     /gpfs/home/users/nome.cognome/directory

myprogram  --input /gpfs/home/users/nome.cognome/directory

/usr/bin/fusermount -u /gpfs/home/users/nome.cognome/directory

dove squashfs.img e’ il file system creato appositamente e che contiene i dati dell’utente;
directory e’ la cartella vuota dove viene montato il file system;
fusermount -u directory per smontare il file system

 

Creazione del file system compresso

mksquashfs /HardDisk/data squashfs.img -comp xz
dove /HardDisk/data e’ la cartella contenente i dati da comprimere

Esempio

L’utente vuole eseguire il programma albacore presente nel container genoma.img con dati di input presenti in un file sytem compresso.
Lo script sbatch

#!/bin/bash
#SBATCH -o /scratch/myjob.%j.%N.out
#SBATCH -D /gpfs/home/usenome.cognome 
#SBATCH -J Albacore
#SBATCH --partition light 
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=5
#SBATCH --mail-type=all
#SBATCH --mail-user=nome.cognome@unimi.it
#SBATCH --time=48:00:00
#SBATCH --account=Projectname

cd  /gpfs/home/users/nome.cognome
echo $SLURM_JOB_NODELIST

/usr/bin/squashfuse  squashfs.img /gpfs/home/users/nome.cognome/empty


module load singularity/2.4
singularity exec -B /gpfs/home/users/nome.cognome/:/gpfs -B /scratch:/mnt /gpf
s/software/Container/genoma.img  /gpfs/script.sh
/usr/bin/fusermount -u ./empty

Lo script.sh

 
#!/bin/bash

/usr/bin/read_fast5_basecaller.py --flowcell FLO-MIN106 --kit SQK-LSK108  --output_format fastq  -r
 -q 0 --input /gpfs/empty/  --save_path /gpfs/results  --worker_threads  5

Le cartelle
empty
results
devono esistere nella home dell’utente.

19. Backup dei dati

In generale i dati presenti sulla piattaforma INDACO sono considerati una copia dei dati posseduti dall’utente, pertanto di tali dati non viene effettuato il backup. E’ cura dell’utente tenere il dato originale in luogo sicuro. INDACO utilizza un file system distribuito basato su IBM GPFS e tecnologia RAID affidabile ma che non puo’ garantire una completa sicurezza dei dati. Per tale motivo  INDACO, solo su richiesta esplicita dell’utente, puo’ provvedere ad effettuare una copia dei dati degli utenti presso un sito  remoto sempre all’interno dell’Universita’ degli Studi di Milano.

In questa eventualita’ i dati verranno trasferiti sul file system remoto nelle stessa forma in cui si trovano sul file system di INDACO (crittografati se erano presenti in tale formato). INDACO non detiene chiavi crittografiche dell’utente e non puo’ risalire alla versione non cifrata degli stessi. E’ pertanto cura dell’utente custodire le chiavi crittografiche dato che il personale di INDACO non ne e’ a conoscenza.

Le modalita’ del backup devono essere concordate con lo staff di INDACO.