Creare un Home Server con Raspberry Pi e Laravel

0
1746

Introduzione

Crearsi un proprio ambiente, 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 model A. Per usarci, ovviamente, Laravel!

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 (la distribuzione Debian ritagliata per Raspberry) e una connessione ad internet.

Salto l’installazione del sistema operativo su Raspberry dato che la guida ufficiale, che trovate qui è semplice e ben fatta.

Pulizie di primavera

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 ‘mand’ |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!