Home Server con Raspberry PI

9c1af9d3f79d630c85694fec6cc737f14b1460b144f179c708

Crearsi un proprio server, raggiungibile ovunque e comunque è una situazione ideale per ogni sviluppatore. In questa piccola guida ti illustrerò come ottenere un Home Server con un  Raspberry PI

Strumenti necessari

Il necessario per ottenere il nostro obiettivo è costituito sostanzialmente da un dispositivo Raspberry PI model A (o superiore) con installato sulla scheda SD l'OS Raspian e una connessione ad internet.

Pulizie dei file inutili

Raspberry ha limitate prestazioni, quindi dobbiamo ridurre al minimo gli sprechi.
Visto che lo usi come server, puoi eliminare tutti i file inerenti all'interfaccia grafica in modo da liberare circa 700mb:
sudo apt-get purge xserver.* x11.* xarchiver xauth xkb-data console-setup xinit lightdm lxde.* python-tk python3-tk scratch gtk.* libgtk.* openbox libxt.* lxpanel gnome.* libqt.* libxcb.* libxfont.* lxmenu.* gvfs.* xdg-.* desktop.* tcl.* shared-mime-info penguinspuzzle omxplayer gsfonts
sudo apt-get --yes autoremove
sudo apt-get upgrade
Per non parlare dei file inutilizzati, come i giochi e altri:
sudo rm -rf /usr/share/doc/* /opt/vc/src/hello_pi/hello_video/test.h264 /home/pi/python_games
find /usr/share/locale/* -maxdepth 0 -type d |grep -v en |xargs sudo rm -rf
find /usr/share/man/* -maxdepth 0 -type d |grep -Pv 'man\d' |xargs sudo rm -rf
Per avere un sistema leggero e veloce è preferibile installare Nginx come webserver, tuttavia Raspbian, ha già preinstallato Apache.
Nota: Non è intenzione di questo progetto l'uso di un database quindi rimuoveremo anche MySql, in caso di necessità è meglio affidarsi a SQLite, che è molto leggero.
Eliminiamo quindi il superfluo ove possibile.

Rimuovere MySQL

$ sudo apt-get remove mysql-server mysql-client mysql-common
$ sudo apt-get purge mysql-server mysql-client mysql-common
$ sudo apt-get autoremove

Rimuovere Apache

$ sudo service apache2 stop
$ sudo apt-get purge apache2 apache2-utils apache2.2-bin apache2-common
$ sudo apt-get autoremove
Apache potrebbe non rimuovere i file di configurazione. Verifichiamolo attraverso il comando seguente:
$ whereis apache2
se la risposta è qualcosa di simile a
apache2: /etc/apache2
allora si possono rimuovere i file con il comando
$ sudo rm -rf /etc/apache2

Si Può Fare!

Prepariamo la scatola e vediamo di cosa è capace:

Installiamo Nginx

sudo apt-get install nginx php5-fpm php5-cgi php5-cli php5-common php5-mcrypt git
Crea quindi un utente che verrà utilizzato da Nginx per accedere ai file web
sudo useradd www-data
sudo groupadd www-data 
sudo usermod -g www-data www-data 
sudo mkdir /var/www 
sudo chmod 775 /var/www -R 
sudo chown www-data:www-data /var/www 
sudo nano /etc/nginx/sites-enabled/default
Se non hai una connessione ipv6 commenta la riga seguente (aggiungendo il carattere cancelletto '#' all'inizio della riga).
listen [::]:80 default_server ipv6only=on;
Sostituisci quindi, la linea seguente:
root /usr/share/nginx/www;
con
root /var/www;
Giunto a questo punto abbiamo completato le configurazioni necessarie al server per funzionare.
Adesso creiamo il nostro file di configurazioni: 
$ sudo nano /etc/nginx/sites-available/MIOSITO
Incolla quanto segue (ma sostituisci prima "MIOSITO" con il nome che desideri)
 server {
     listen   80; ## in ascolto per l'ipv4
     server_name  MIOSITO.com www.MIOSITO.com *.MIOSITO.com;

     access_log  /var/log/nginx/MIOSITO.access.log;
     error_log   /var/log/nginx/MIOSITO.error.log;

     root   /var/www/CARTELLA/AL/MIOSITO/public;

     location / {
             root   /var/www/CARTELLA/AL/MIOSITO/public;
             index  index.php index.html index.htm;
             try_files $uri $uri/ /index.php$is_args$args;
 }
Analizziamo tutti i file con estensione .php nella cartella /var/www/CARTELLA/AL/MIOSITO/public 
location ~ \.php$ {
    fastcgi_split_path_info ^(.+\.php)(.*)$;
    fastcgi_pass   127.0.0.1:9000;
    fastcgi_index  index.php;
    fastcgi_param  SCRIPT_FILENAME /var/www/laravel/1/public$fastcgi_script_name;
    include fastcgi_params;
    fastcgi_param  QUERY_STRING     $query_string;
    fastcgi_param  REQUEST_METHOD   $request_method;
    fastcgi_param  CONTENT_TYPE     $content_type;
    fastcgi_param  CONTENT_LENGTH   $content_length;
    fastcgi_intercept_errors        on;
    fastcgi_ignore_client_abort     off;
    fastcgi_connect_timeout 60; 
    fastcgi_send_timeout 180;
    fastcgi_read_timeout 180;
    fastcgi_buffer_size 128k;
    fastcgi_buffers 4 256k;
    fastcgi_busy_buffers_size 256k;
    fastcgi_temp_file_write_size 256k;
 }
Disabilitiamo accesso e visualizzazione ai file .htaccess & .htpassword
location ~ /\.ht {
     deny  all;
}
Ora devi creare il link simbolico a questo file nella cartella dei siti Abilitati:
$ sudo ln -s /etc/nginx/sites-available/MIOSITO /etc/nginx/sites-enabled/MIOSITO
Modifica il file delle configurazioni di Nginx per abilitare l'FPM:
$ sudo nano /etc/php5/fpm/pool.d/www.conf 
Sostituendo la linea 
listen = /var/run/php5-fpm.sock
con:
listen = 127.0.0.1:9000
quindi riavviamo php-fpm & nginx :
$ sudo service php5-fpm restart 
$ sudo service nginx restart
Ok, ancora un piccolo sforzo, dobbiamo modificare il parametro cgi.fix_pathinfo nel php.ini :
$ sudo nano /etc/php5/fpm/php.ini
Cerca "cgi.fix_pathinfo" e cancella il ";" all'inizio della righa (che è il commento) e al sostituiamo "=1" con "=0".
cgi.fix_pathinfo=0
Salva e chiudi. Ora specifichiamo l'abilitazione di MCrypt che serve a Laravel:
$ sudo php5enmod mcrypt
ed infine riavviamo il servizio php5-fpm per confermare i cambiamenti:
$ sudo service php5-fpm restart
Ci siamo! La "scatola" è pronta!

Installiamo Composer

In una directory dove hai il permesso di scrivere e leggere senza problemi, per esempio la Home, scarica e avvia l'installer di Composer:
$ cd ~
$ curl -sS https://getcomposer.org/installer | php
Questi comandi creano un file denominato composer.phar, un archivio PHP che può essere avviato da linea di comando.
Per installare Composer in modo che sia globalmente accessibile nel sistema con il comando "composer" esegui:
$ sudo mv composer.phar /usr/local/bin/composer
Finalmente possiamo procedere con...

Laravel!

Creiamo subito un nuovo progetto:
$ cd /var/www/MIOSITO
$ sudo composer create-project laravel/laravel /var/www/MIOSITO
Assegna i vari permessi necessari:
$ sudo chown -R :www-data /var/www/MIOSITO
$ sudo chmod -R 775 /var/www/MIOSITO/app/storage
Puntiamo il browser verso l'indirizzo scelto e... "you have arrived"!
Nota: se otteni un errore nell'exception handler, prova ri-sottomittendo i comandi per i permessi d'accesso:
sudo chmod 775 /var/www -R 
sudo chown www-data:www-data /var/www 

GIT

Per svolgere al meglio il tuo lavoro probabilmente hai un repository GIT. Per avere tutto a portata di mano aggiungi subito l'origin:
$ cd /path/to/your/project
$ git init
$ git remote add origin LA TUA ORIGINE DATI 
La tua origine dati, per esempio su Bitbucket, potrebbe essere: https://NOMEUTENTE@bitbucket.org/NOMEUTENTE/REPOSITORY.
Crea il tuo primo file, commita, ed esegui il comando di push:
echo "Questo file dimostra che non ho preso una papera..." >> contributors.txt
git add contributors.txt
git commit -m 'Initial commit with contributors'
git push -u origin master

FTP SERVER

Uno dei server FTP più leggeri è vsftp quindi ricade su di lui la scelta
$ sudo chown -R pi /var/www 
$ sudo apt-get install vsftpd
$ sudo nano /etc/vsftpd.conf
Nell'editor, cambia la seguente linea:
anonymous_enable=YES
in
anonymous_enable=NO
Rimuovi il commento (cancelletto) alle righe:
local_enable=YES 
write_enable=YES
per finire aggiungi quanto segue alla fine del file:
force_dot_files=YES
Salva ed chiudi l'editor. Ora riavvia il servizio FTP: 
$ sudo servce vsftpd restart
Direi che come risultato con 20€, una connessione ADSL e una giornata hai tutto pronto.

Approfondimenti

Lunga vita e prosperità

Questa configurazione non è utilizzabile per un ambiente di produzione perché l'SD inserita nel raspberry, potrebbe avere vita breve.
Per ovviare a questo problema, sarebbe il caso di installando un hard disk esterno.
Come caratteristica principale l'HD esterno deve essere alimentato (e funzionerà anche come alimentatore del vostro raspberry!) e USB 2.0.
Personalmente ho riciclato una vecchio case per HD 2.5" esterno USB 2.0, alimentato esternamente e con un HD da 40gb.
Raspberry è una microboard studiata per partire da SD, quindi non è possibile eliminare totalmente questa ma è possibile utilizzarla solo come partizione di avvio, effettuando quindi i successivi accessi alla memoria, sul'HD esterno.
Prima di collegare l'HD, aggiorna il sistema (solo mera precauzione):
$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo rpi-update
$ sudo reboot
e controlla il file system:
pi@raspberrypi ~ $ df -h
Filesystem      Size  Used Avail Use% Mounted on
rootfs          1.8G  1.4G  247M  86% /
/dev/root       1.8G  1.4G  247M  86% /
devtmpfs        235M     0  235M   0% /dev
tmpfs            49M  248K   49M   1% /run
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs            98M     0   98M   0% /run/shm
/dev/mmcblk0p1   56M   19M   38M  34% /boot
pi@raspberrypi ~ $
Ottimo: nell'esempio mostrato sto utilizzando una SD da 8GB, la dimensione standard è 1.8G, perché non ho usato l'opzione "expand_rootfs". La righa /dev/mmcblk0p1 è la partizione di boot (p1) sul device mmcblk0, cioè la SD card.
Come detto precedentemente, la partizione di boot è l'unica che deve restare sulla SD, raspberry non può avviarsi da altri dispositivi se non la SD.
Ora connetti l'HD esterno e controlla che sia correttamente caricato: 
pi@raspberrypi ~ $ lsusb
Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.
Bus 001 Device 004: ID 7392:7811 Edimax Technology Co., Ltd EW-7811Un 802.11n Wireless Adapter [Realtek RTL8188CUS]
Bus 001 Device 006: ID 8644:800b
pi@raspberrypi ~ $
Il dispositivo 006 di questo esempio è l'adapter USB.

Troviamo il dispositivo

Ora è necessario controllare che il sistema operativo abbia correttamente riconosciuto il device: (puoi usare anche il comando 'dmesg')
pi@raspberrypi ~ $ tail /var/log/messages
May 18 11:44:31 raspberrypi kernel: [   64.093866] usb 1-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
May 18 11:44:31 raspberrypi kernel: [   64.093883] usb 1-1.3: Product: Intenso Micro Line
May 18 11:44:31 raspberrypi kernel: [   64.093898] usb 1-1.3: Manufacturer: Intenso
May 18 11:44:31 raspberrypi kernel: [   64.093912] usb 1-1.3: SerialNumber: 12390000000004E2
May 18 11:44:31 raspberrypi kernel: [   64.112228] scsi1 : usb-storage 1-1.3:1.0
May 18 11:44:32 raspberrypi kernel: [   65.113335] scsi 1:0:0:0: Direct-Access     Intenso  Micro Line       1.01 PQ: 0 ANSI: 2
May 18 11:44:32 raspberrypi kernel: [   65.114862] sd 1:0:0:0: [sda] 15669248 512-byte logical blocks: (8.02 GB/7.47 GiB)
May 18 11:44:32 raspberrypi kernel: [   65.115607] sd 1:0:0:0: [sda] Write Protect is off
May 18 11:44:32 raspberrypi kernel: [   65.126062]  sda: sda1
May 18 11:44:32 raspberrypi kernel: [   65.129907] sd 1:0:0:0: [sda] Attached SCSI removable disk
pi@raspberrypi ~ $
Ok, è vivo e si trova su /dev/sda
Nota: se il dispositivo esterno non viene trovato, assicurati che sia alimentato correttamente, eventualmente puoi inserirlo in un HUB USB alimentato e poi collegarlo al raspberry.

Prepariamo l'hard disk

Crea un filesystem sull'HD, usando il comando "p" in Fdisk:
pi@raspberrypi ~ $ sudo fdisk /dev/sda
Command (m for help): p
Disk /dev/sda: 8022 MB, 8022654976 bytes
94 heads, 14 sectors/track, 11906 cylinders, total 15669248 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000
   Device Boot      Start         End      Blocks   Id  System
/dev/sda1              32    15669247     7834608    b  W95 FAT32
Command (m for help):
C'è una partizione creata per Windows. Riformattala per Linux: scrivi "d" per cancellare le partizioni.
Poi "n" per crearne una nuova primaria. Utilizza tutto lo spazio disponibile premendo invio alle successive domande:
Command (m for help): d
Selected partition 1
Command (m for help): n
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-15669247, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-15669247, default 15669247):
Using default value 15669247
Command (m for help):
Ora premi "w" per scrivere le informazioni sulla nuova partizione:
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
Syncing disks.
pi@raspberrypi ~ $
Fatto, ora puoi formattare la partizione:
pi@raspberrypi ~ $ sudo mke2fs -t ext4 -L rootfs /dev/sda1
mke2fs 1.42.5 (29-Jul-2012)
Filesystem label=rootfs
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
490560 inodes, 1958652 blocks
97932 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=2009071616
60 block groups
32768 blocks per group, 32768 fragments per group
8176 inodes per group
Superblock backups stored on blocks:
        32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocating group tables: done
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
pi@raspberrypi ~ $
Ed ora "montala" per usarla:
pi@raspberrypi ~ $ sudo mount /dev/sda1 /mnt
Controlla il risultato:
pi@raspberrypi ~ $ df -h
Filesystem      Size  Used Avail Use% Mounted on
rootfs          1.8G  1.4G  247M  86% /
/dev/root       1.8G  1.4G  247M  86% /
devtmpfs        235M     0  235M   0% /dev
tmpfs            49M  248K   49M   1% /run
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs            98M     0   98M   0% /run/shm
/dev/mmcblk0p1   56M   19M   38M  34% /boot
/dev/sda1       7.4G  145M  6.9G   3% /mnt
pi@raspberrypi ~ $
OTTIMO, l'HD è ora disponibile nel percorso /dev/sda1 avviabile anche come /mnt per linux.

Copiamo i dati necessari sull'HD

Ora dovrai trasferire i dati in /dev/root sul nuovo percorso che punta all'hard disk USB. Puoi usare dd, è un buon programma ma è veramente lentissimo, copia bit-to-bit. Meglio usare rsync:
pi@raspberrypi ~ $ sudo apt-get install rsync
...
pi@raspberrypi ~ $
Avvialo. Anche se più veloce di dd comunque questa operazione è piuttosto lenta: Copia tutto il contenuto da "/" in /mnt (che sarebbe /dev/sda1)
pi@raspberrypi ~ $ sudo rsync -axv / /mnt
Nel mio caso ci ha messo più di 15 minuti.

Modifica del percorso di boot

Ora devi specificare al Raspy, dove trovare i nuovi file del sistema quando si avvia. Il file che devi modificare è /boot/cmdline.txt 
Ma prima, meglio fare una copia:
sudo cp /boot/cmdline.txt /boot/cmdline.orig
Il contenuto di questo file è una stringa molto lunga, che devi modificare per dirgli dov'è ora la directory di root ( da root=/dev/mmcblk0p2 a root=/dev/sda1)
Questa è la mia copia originale del file:
pi@raspberrypi ~ $ cat /boot/cmdline.txt
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
Per essere sicuri che venga trovato, visto che l'HD potrebbe metterci qualche istante in più per avviarsi, devi anche aggiungere un piccolo delay (rootdelay=5).
Utilizza il tuo editor preferito per effettuare i cambiamenti necessari
sudo nano /boot/cmdline.txt
alla fine deve essere una cosa simile a questa:
pi@raspberrypi ~ $ cat /boot/cmdline.txt
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/sda1 rootfstype=ext4 elevator=deadline rootwait rootdelay=5
Ora modifica il file /etc/fstab sull'HD:
sudo nano /mnt/etc/fstab
aggiungendo la linea seguente:
/dev/sda1    /   ext4    defaults,noatime  0       1
e commentando la righa
#/dev/mmcblk0p2  /               ext4    defaults,noatime       0       1
alla fine il file deve assomigliare a questo:
proc            /proc           proc    defaults          0       0
/dev/sda1       /               ext4    defaults,noatime  0       1
/dev/mmcblk0p1  /boot           vfat    defaults          0       2
#/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1
# a swapfile is not a swap partition, so no using swapon|off from here on, use  dphys-swapfile swap[on|off]  for that
Riavvia il sistema
$ sudo reboot

Controlliamo il risultato

Dopo che il Pi si è avviato nuovamente, controlla il nuovo filesystem:
pi@raspberrypi ~ $ df -h
Filesystem      Size  Used Avail Use% Mounted on
rootfs          7.4G  1.6G  5.5G  22% /
/dev/root       7.4G  1.6G  5.5G  22% /
devtmpfs        235M     0  235M   0% /dev
tmpfs            49M  248K   49M   1% /run
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs            98M     0   98M   0% /run/shm
/dev/mmcblk0p1   56M   19M   38M  34% /boot
pi@raspberrypi ~ $
Boom! il file di Root è ora sull'USB!

Swap file size

È ora di cambiare la dimensione del nostro file di swap.
In realtà non c'è nessuna necessità di cambiare la partizione di swap, infatti il nel Raspberry è implementata differentemete rispetto agli altri sistemi Linux.
Raspbian usa dphys-swapfile, che è una tipologia basata sugli swap-file al posto della "standard" swap-partition. 
Ma visto che è facile da fare, se ne senti la necessità puoi agire come segue:
Controlla il file di Swap:
pi@raspberrypi ~ $ top
top - 13:28:20 up 3 min,  1 user,  load average: 0.18, 0.37, 0.18
Tasks:  66 total,   1 running,  65 sleeping,   0 stopped,   0 zombie
%Cpu(s):  1.0 us,  0.0 sy,  0.0 ni, 98.7 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
KiB Mem:    497544 total,    55700 used,   441844 free,     5432 buffers
KiB Swap:   102396 total,        0 used,   102396 free,    27592 cached

102396 is 100MB of swap space

The configuration file for the swap space is: /etc/dphys-swapfile 
Il contenuto è veramente semplice. Per default Raspbian ha 100MB di spazio di swap 
pi@raspberrypi ~ $ cat /etc/dphys-swapfile
CONF_SWAPSIZE=100
pi@raspberrypi ~ $
Se vuoi puoi modificare il numero direttamente in questo file
pi@raspberrypi ~ $ sudo nano /etc/dphys-swapfile
Puoi portarlo fino al massimo del tuo raspberry (512 per il modello A).
Elimina il vecchio file di swap:
pi@raspberrypi ~ $ sudo dphys-swapfile setup
want /var/swap=512MByte, checking existing: deleting wrong size file (104857600), generating  swapfile ... of 512MBytes
Per caricare la nuova dimensione devi fermare il processo di swap:
pi@raspberrypi ~ $ sudo /etc/init.d/dphys-swapfile stop
Stopping dphys-swapfile swapfile setup ..., done.
... e riavviarlo...
pi@raspberrypi ~ $ sudo /etc/init.d/dphys-swapfile start
Starting dphys-swapfile swapfile setup ...
want /var/swap=512MByte, checking existing: keeping it
done.
Ora controlla il risultato tramite il comando "top"
top - 13:37:22 up 12 min,  1 user,  load average: 0.01, 0.08, 0.12
Tasks:  64 total,   1 running,  63 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.7 us,  0.3 sy,  0.0 ni, 99.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem:    497544 total,    57016 used,   440528 free,     5556 buffers
KiB Swap:   524284 total,        0 used,   524284 free,    28604 cached
Fatto!
Ora puoi procedere nuovamente con upgrade-update:
sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get autoremove
Ci siamo!
Il nostro ambiente è pronto ad accogliere nel migliore dei modi il nostro codice!
Fonte 

Commenti

Post popolari in questo blog

Samsung rilascerà i primi dispositivi con display flessibili nella prima metà del 2013

[Guida Esclusiva] Sbrandizzare Motorola Xoom 2 TIM

GooPhone realizza i5 e promette di citare in giudizio Apple se lancerà l’iPhone 5 in Cina