Bloccare Ip da Stati non desiderati tramite nginx

Chi gestisce un server remoto nei log trova spesso tentativi di intrusione da parte di hacker o comunque persone che “smanettando” cercano accessi a funzionalità quali

  • phpmyadmin
  • sqlite
  • wp-admin
  • etc… etc…

Di solito utilizzano degli script che scansionano, indirizzi e porte e trovando accesso eseguono una serie di operazioni ripetute…
Questo non vuol dire che abbiano accesso ai nostri servizi… ma oltre ad essere fastidiosi, occupano banda effettuando accessi e richieste ripetute.
In genere tali tentativi provengono da stati quali Cina, Russia, India, Singapore etc…

Se i nostri servizi, non sono rivolti a tali stati è possibile bloccare l’accesso a indirizzi provenienti da un SET di stati indicati come non amici. Vediamo come.

Per prima cosa, dovremmo installare un database contenente la lista di indirizzi associati a stati (Country):

sudo apt-get install geoip-database-contrib -y

Fatto questo, all’interno del file di configurazione di nginx dovremmo aggiungere alcune regole. apriamo il file:

nano /etc/nginx/nginx.conf

ed aggiungiamo all’interno di http {… il codice presente dopo il commento ESCLUSIONE IP:

http {
        # Basic Settings
        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
        keepalive_timeout 65;
        types_hash_max_size 2048;
        # server_tokens off;
        include /etc/nginx/mime.types;
        default_type application/octet-stream;

        ### ESCLUSIONE IP #######################################
        geoip_country /usr/share/GeoIP/GeoIP.dat;
        map $geoip_country_code $allowed_country {
                    default no;
                    IT yes;
                    DE yes;
        }

In questo caso indichiamo l’esclusione di tutti gli indirizzi ad eccezione di quelli provenienti dall’Italia e dalla Germania. Abbiamo dato accesso solo ad alcuni Paesi desiderati.

Se invece volessimo escludere manualmente alcuni paesi dovremmo scrivere:

### ESCLUSIONE IP #######################################
        geoip_country /usr/share/GeoIP/GeoIP.dat;
        map $geoip_country_code $allowed_country {
                    default yes;
                    CN no;
                    RU no;
        }

In questo caso, abbiamo definito che tutte le richieste possono essere accolte (default yes) ad eccezione di quelle provenienti dalla Cina e dalla Russia.

Ora nel nostro file server di nginx dovremmo inserire le righe con la condizione if:

server {
    listen      80;
    server_name x.xxx.xxx.xxx;
    charset     utf-8;
    
    [...]
    if ($allowed_country = yes) {
        set $exclusions 1;
    }
    if ($allowed_country = no) {
        return 444;
    }

Riavviamo nginx con

systemctl restart nginx

A questo punto dovremmo essere pronti.

Escludendo ad esempio indirizzi provenienti dagli USA potrebbe capitare di trovare nei log una stringa di questo tipo:

66.249.93.6 - - [29/Jun/2018:10:46:13 +0200] "GET /manuale/ HTTP/1.1" 444 0 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36 Google Favicon"

Questo è il googlebot che ha tentato di accedere al manuale di un applicativo, ma si è visto ritornare un 444 dal server.

 

Installare Firebird3.0 – open source database relazionale management system

Oggi spiegheremo come installare Firebird3.0 su di una macchina Debian.

Per prima cosa dovremmo aggiungere i repository:

deb http://ftp.de.debian.org/debian/ testing main
deb-src http://ftp.de.debian.org/debian/ testing main
apt-get update

Quindi successivamente installare il Database Firebird3.0

apt-get install firebird3.0-server

Fermiamo il servizio con questo comando:

service firebird3.0 stop

E creiamo, se non già presente l’utente di default:

isql-fb -user sysdba /var/lib/firebird/3.0/system/security3.fdb
create or alter user SYSDBA password 'masterkey';
commit;
quit;

Per rendere il database raggiungibile da una connessione esterna dovremmo modificare il file databases.conf presente al seguente indirizzo:

nano /etc/firebird/3.0/firebird.conf

A questo punto dovremmo commentare la riga:

#RemoteBindAddress = localhost

Ed aggiungere alla fine del file le seguenti righe:

WireCrypt = Disabled 
AuthServer = Legacy_Auth, Srp, Win_Sspi 
AuthClient = Legacy_Auth, Srp, Win_Sspi

Ora riavviamo il servizio:

service firebird3.0 start

Ora creeremo un nuovo utente ed un nuovo database. Per prima cosa dovremmo accedere alla console di firebird con l’utente “master”:

isql-fb -user sysdba

La password sarà masterkey di default.

Quindi creare un utente con permessi di amministratore:

create user {vostro_user} password '{vostra_pwd}' grant admin role;
commit;
quit;

Ora dovremmo uscire dall’utente master per accedere come utente {vostro_utente}:

isql-fb -user {vostro_user}

Ora creiamo il database con una tabella di test:

CREATE DATABASE '/home/{vostro_user}/test.fdb';
CREATE TABLE drinks (ID INTEGER PRIMARY KEY,NAME VARCHAR(100) NOT NULL);
INSERT INTO drinks(NAME) VALUES(1, 'Beer');
INSERT INTO drinks(ID, NAME) VALUES(2,'Wine');
INSERT INTO drinks(ID, NAME) VALUES(3,'Water');
INSERT INTO drinks(ID, NAME) VALUES(4,'Orange juice');

Proviamo a leggere il contenuto:

select * from drinks;

Perfetto, non ci resta che iniziare a lavorare con questo database open source!

 

 

Installazione PGADMIN4 – gestore database PostgreSql

Nella guida precedente abbiamo parlato di come installare e configurare PostgreSql su Debian e derivate (Ubuntu, Linux Mint, DeepIn).
Oggi parleremo di un tool GUI (Graphical User Interface), molto comodo per la gestione dei propri database PostgreSql.

La nuova versione (PGADMIN4) è molto più semplice e funzionale rispetto alla versione precedente (PGADMIN3), oltre ad offrire delle novità molto comode ed importanti (dal mio punto di vista).

L’installazione a differenza della versione precedente però non è così immediata e dovremmo “giocare” un pochino con la console per poter installare correttamente questo nuovo software. Niente di complicato però 🙂

Iniziamo con l’installazione dei pacchetti necessari affinchè il software giri correttamente:

apt-get install python-setuptools virtualenv python-pip libpq-dev python-dev

Installazioni basilari presenti anche nelle guide precedenti.

Ora dovremmo creare una directory in virtualenv nella quale installare il software. Generalmente utilizzo la directory: /home/{vostro_user}/Software/nome_software/ ma voi sentitevi liberi di utilizzare un directory a vostro piacimento. Ovviamente {vostro_user} dovrà essere modificato con il nome del vostro utente.

virtualenv /home/{vostro_user}/Software/pgadmin4

Quindi attiviamo la virtualenv: (se non avete molta dimestichezza con le virtualenv vi consiglio di leggere prima questa guida: https://regololab.com/python-opencv-virtualenv/)

source  /home/{vostro_user}/Software/pgadmin4/bin/activate

Perfetto, ora proseguiamo con l’installazione del software:

pip install https://ftp.postgresql.org/pub/pgadmin/pgadmin4/v3.2/pip/pgadmin4-3.2-py2.py3-none-any.whl

Se l’installazione dovesse andare male, provare prima con l’installazione come root, oppure verificare che il percorso del file nel tempo non sia stato modificato. Basta effettuare una ricerca oppure verificare al seguente indirizzo per installare una versione più aggiornata: https://www.postgresql.org/ftp/pgadmin/pgadmin4/

Ora dovremmo creare un file all’interno del nostro site-packages della virtualenv.

nano /home/{vostro_user}/Software/pgadmin4/lib/python2.7/site-packages/pgadmin4/config_local.py

ed inseriamo il seguente codice:

import os
SERVER_MODE = False
DATA_DIR = os.path.realpath(os.path.expanduser(u'~/.pgadmin/'))
LOG_FILE = os.path.join(DATA_DIR, 'pgadmin4.log')
SQLITE_PATH = os.path.join(DATA_DIR, 'pgadmin4.db')
SESSION_DB_PATH = os.path.join(DATA_DIR, 'sessions')
STORAGE_DIR = os.path.join(DATA_DIR, 'storage')

È python, quindi fate molta attenzione all’Indentazione.

Ora lanciamo il setup del software:

python /home/{vostro_user}/Software/pgadmin4/lib/python2.7/site-packages/pgadmin4/setup.py

Terminata l’installazione non ci resta che provare il software:

(pgadmin4) root@vostro_user: python /home/{vostro_user}/Software/pgadmin4/lib/python2.7/site-packages/pgadmin4/pgAdmin4.py

Dovrebbe apparire qualcosa di simile:

Starting pgAdmin 4. Please navigate to http://127.0.0.1:5050 in your browser.

Dove 127.0.0.1… è l’indirizzo tramite il quale il browser lavorerà con i database postgresql. Dovremmo visualizzare una schermata simile all’immagine seguente.

screenshot PGADMIN4 - home page
screenshot PGADMIN4 – home page

Vediamo ora come creare un piccolo programmino scritto in bash che avvii PGADMIN4 in modo semplice, senza dover attivare ogni volta la virtualenv e successivamente richiedere l’apertura del software:

Creiamo sulla scrivania il seguente file pgadmin4.sh, rendiamolo eseguibile  e scriviamo il seguente codice:

#!/usr/bin/env bash
source /home/{vostro_user}/Software/pgadmin4/bin/activate
python /home/{vostro_user}/Software/pgadmin4/lib/python2.7/site-packages/pgadmin4/pgAdmin4.py

Ora ricordiamoci di salvare nei preferiti del nostro browser l’indirizzo: http://127.0.0.1:5050 così da non digitarlo manualmente ogni volta.

Ora, se non conosciamo lo strumento dovremmo dedicarci un “attimo” al suo studio per poterlo utilizzare al meglio. Chi invece ha già esperienza con la versione precedente, non potrà trovare che piacevoli benefici da questo aggiornamento.

** Aggiornamento alla versione di python3 **

mkdir /opt/pgadmin4/
cd /opt/pgadmin4/
sudo apt-get install virtualenv python3-pip libpq-dev python3-dev
virtualenv -p python3 pgadmin4
cd pgadmin4
source bin/activate
pip3 install https://ftp.postgresql.org/pub/pgadmin/pgadmin4/v3.2/pip/pgadmin4-3.2-py2.py3-none-any.whl

----
nano lib/python3.6/site-packages/pgadmin4/config_local.py

import os
DATA_DIR = os.path.realpath(os.path.expanduser(u'~/.pgadmin/'))
LOG_FILE = os.path.join(DATA_DIR, 'pgadmin4.log')
SQLITE_PATH = os.path.join(DATA_DIR, 'pgadmin4.db')
SESSION_DB_PATH = os.path.join(DATA_DIR, 'sessions')
STORAGE_DIR = os.path.join(DATA_DIR, 'storage')
SERVER_MODE = False

---
python3 /opt/pgadmin4/pgadmin4/lib/python3.6/site-packages/pgadmin4/pgAdmin4.py

----
#!/usr/bin/env bash
source /opt/pgadmin4/pgadmin4/bin/activate
python3 /opt/pgadmin4/pgadmin4/lib/python3.6/site-packages/pgadmin4/pgAdmin4.py

 

Spero che questa guida vi sia stata utile.

Installazione PostgreSql su Debian e Derivate (Ubuntu, Linux Mint, DeepIn etc…)

Oggi spiegheremo come installare e configurare (livello base) un database relazionale Open source veramente potente e versatile PostgreSql.

Questo database completo, potente e veloce offre innumerevoli funzionalità ed offre funzionalità che database più blasonati come ad esempio MySql o MSSQL non possiedono… ma queste “affermazioni” lasciamole per un altro momento!

Oggi ci occuperemo solo di come installare in modo semplice e veloce questo bellissimo e potente Database Relazionale (e per alcuni aspetti anche NOSQL – Not Only SQL).

Per prima cosa lanciamo il comando:

apt-get install postgresql postgresql-contrib

Terminata l’installazione, verifichiamo che tutto sia andato per il verso giusto. Lanciamo i seguenti comandi:

su - postgres

Dovremmo accedere all’utente postgres (postgres@xxxxxxxx:~$)

Ora entriamo all’interno della console di Postgres digitando il seguente comando:

psql

Dovrebbe indicarci la versione (psql (9.6.6) – nel mio caso) e quindi  dovremmo accedere direttamente alla console postgres=#

Digitiamo

help

così da visualizzare alcuni comandi utili per la gestione:

  • Type: \copyright for distribution terms
  • \h for help with SQL commands
  • \? for help with psql commands
  • \g or terminate with semicolon to execute query
  • \q to quit

Ora per verificare quale utente sia presente per la gestione dei database digitiamo il seguente comando:

SELECT * from pg_user;

Apparirà la lista degli utenti presenti, che in questo caso dovrebbe essere  (o qualcosa di similare):

usename  | usesysid | usecreatedb | usesuper | userepl | usebypassrls |  passwd  | valuntil | useconfig 
----------+----------+-------------+----------+---------+--------------+----------+----------+-----------
postgres |       10 | t           | t        | t       | t            | ******** |          | 

Perfetto, ora aggiungiamo un nuovo utente e creiamo ed assegniamo un database.
Per prima cosa creiamo un nuovo utente:

CREATE USER nome_utente WITH password 'password_utente';

Dove nome_utentepassword_utente dovranno essere modificati con i vostri dati.
Quindi creiamo un ruolo che l’utente coprirà; nel caso specifico gli abbiamo indicato lo status di supeuser:

CREATE ROLE nome_utente WITH SUPERUSER LOGIN PASSWORD 'password_utente';

Ora creeremo un database test per poter iniziare a “giocarci”. Il comando è molto semplice ed assegniamo la proprietà al nostro utente:

CREATE DATABASE test WITH OWNER nome_utente;

Ora dovremmo dire a postgres di voler utilizzare questo database. Niente di più semplice lanciamo il comando:

\c test

Questo comando ci permette di passare da postgres  test. Ora creiamo una tabella:

CREATE TABLE "test" (name character varying(20) NOT NULL) WITH (OIDS=FALSE);
ALTER TABLE "test" OWNER TO nome_utente;

Ora inseriremo un valore e ne leggeremo il contenuto:

INSERT INTO test(name) VALUES('mio nome');

SELECT * FROM test;

Perfetto… il database è pronto 🙂

Ora lo configureremo per poterlo utilizzare tramite connessione esterna, altrimenti sarebbe raggiungibile solo tramite localhost.

Spostiamo all’interno della directory:

cd /etc/postgresql/{versione}/main/

Quindi modifichiamo il file pg_hba.conf  aggiungendo i seguenti parametri in fondo al file:

# aggiunta nostra configurazione
host all all 0.0.0.0/0 trust

Successivamente dovremmo modificare il file postgresql.conf 

 listen_addresses = '*'

Ora non ci resta che riavviare il servizio:

systemctl restart postgresql

Nella prossima guida, spiegheremo come installare la bellissima ed utilissima applicazione PGadmin4 che è notevolmente migliorata rispetto alla versione 3 che oltre ad integrare le nuove e più moderne versioni di PGsql gestisce in modo semplice ed intuitivo i nostri database.

 

Python – opencv in Virtual Env per Raspberry Pi

Si trovano molto spesso guide relative all’installazione di Opencv (Libreria per la gestione di video ed immagini in tempo reale – computer vision), più o meno semplici; ma se volessimo installare OpenCV in una VirtualEnv? Beh le cose si fanno un pochino più complicate… non da un punto di vista tecnico, ma di documentazione.

Nello scorso articolo abbiamo parlato di come creare e gestire un progetto in VirtualEnv e di come PIP gestisca i pacchetti.

Mi è capitato, sul Raspberri Pi di avere problemi con l’installazione di OpenCV tramite PIP e quindi vorrei lasciare la mia esperienza a qualcuno a cui possa servire.

Ma arriviamo subito al dunque… verifichiamo che non sia già installata una versione di opencv sulla nostra virtualenv .

(image) user@user ~/Virtual $ python3
>>> import cv2 as cv

Se genera errore, siamo certi che la libreria non è presente.

Ora dobbiamo installarla:

apt-get install python-opencv

Come seconda operazione dovremmo trovare i file cv2.so e cv2.py
Questi file, cambiano nome a seconda della distribuzione e della macchina… trovare i file cv2.so e cv2.py potrebbe risultare impossibile. Per facilitare l’operazione spostiamo all’interno della root di sistema e lanciamo il seguente comando:

find . -name "cv*"

Potrebbero apparire i seguenti file (o con nomi che richiamano al CV):

  • ./cv2.arm-linux-gnueabihf.so
  • ./cv.py

Perfetto abbiamo quasi terminato. Ora non ci resta che creare un collegamento virtuale tra i file e la virtualenv. Vediamo come procedere:

ln -s /usr/lib/python2.7/dist-packages/cv2.arm-linux-gnueabihf.so /home/pi/Virtual/image/lib/python2.7/site-packages/cv2.so
ln -s /usr/lib/python2.7/dist-packages/cv.py /home/pi/Virtual/image/lib/python2.7/site-packages/cv2.py

Rinominando i collegamenti in cv2.so e cv2.py ed inserendo il percorso all’interno della nostra VirtualEnv (in questo caso image).

Ora proviamo nuovamente ad eseguire l’importazione:

(image) user@user ~/Virtual $ python3
>>> import cv2 as cv

Ora dovrebbe essere tutto Ok!!!

Buon Lavoro.

 

 

Python installazione Virtualenv

Oggi parliamo di Python e l’installazione di una virtualenv (virtual environment);

Cosa è una virtualenv?
Virtual Env è uno strumento in grado di creare diversi ambienti di sviluppo. Anzichè “riempire” il sistema principale di librerie che potrebbero risultare inutilizzate per la maggior parte del tempo, utilizzando una o più virtual env  potremmo creare diversi ambienti con librerie differenti in base alle nostre esigenze.

Facciamo un esempio pratico… immaginiamo di dover sviluppare due applicativi, uno di manipolazione delle immagini, l’altro di “calcoli matematici”. Sarebbe inutile avere librerie grafiche per un applicativo matematico e viceversa. Virtual Env, viene in nostro aiuto.

Per prima cosa verifichiamo quale versione di python viene utilizzata di default (non è fondamentale, ma potrebbe essere utile). Lanciamo da terminale il comando:

python -V

In questa guida vedremo come lavorare in Python3.x, ma la procedura sarà identica per Python 2.x, fatta eccezione per le versioni richiesta.

Ora procediamo ad installare alcune librerie utili.

apt-get install python3-dev python3-setuptools

Note: Se la nostra versione di default è Python 2.x allora dovremmo specificare che le installazioni dovranno avvenire per la verione 3 (per questo scriviamo python3-[nome-libreria]). Al contrario se la versione di default sarà python 3.x allora basterà scrivere semplicemente python-[nome-libreria]

Ora installiamo PIP (Python Pacage Index) ed è uno strumento indispensabile, perchè ci permette di scaricare quasi tutti i pacchetti dal repository di cui si ha bisogno. Il comando per l’installazione di PIP è molto semplice:

apt-get install python3-pip

Terminata l’installazione provvederemo ad installare finalmente Virtualenv tramite il seguente comando:

pip3 install virtualenv

Ora procediamo con la creazione di due ambienti di sviluppo in virtualenv, il primo per la manipolazione delle immagini, il secondo per svolgere operazioni matematiche.

Note: personalmente credo una cartella in /home/Virtual/* dove creare i progetti e nella guida utilizzerò questo principio, ma sappiate che potrete installare la virtualenv anche all’interno di un progetto o in un altra directory… python è molto flessibile 🙂

Ora creiamo una directory che conterrà le diverse virtual environment e spostiamoci al suo interno:

mkdir ~/VirtualEnv
cd ~/VirtualEnv

Ora lanciamo il comandi:

virtualenv image
virtualenv number

I nomi, image e number sono di pura fantasia, potrete utilizzare i nomi che più vi piacciono.

Per ogni comando lanciato vedremmo apparire alcune righe ad esmepio:

Running virtualenv with interpreter /usr/bin/python3.5
New python executable in /home/xxx/Virtual/img/bin/python3.5
Also creating executable in /home/xxx/Virtual/img/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

Queste righe non sono molto importanti, ma ci spiegano che la virtualenv è stata creata ed i percorsi utilizzati.

Ora capiremo come lavorare in virtualenv. Per prima cosa dovremmo entrare nell’ambiente di sviluppo. Utilizzeromo l’ambiente image. Da console scriviamo il seguente codice:

source ~/Virtual/image/bin/activate

all’interno della console dovrebbe apparire qualcosa di simile:
(image) user@user ~/Virtual $

Per uscire dalla virtualenv basterà digitare:

deactivate

Questo ci indica che siamo all’interno di dell’ambiente image. Ora vediamo come sfruttarlo.

Se il nostro applicativo dovrà gestire le immagini potrebbe servirci la libreria PILLOW, installiamola:

(image) user@user ~/Virtual $ pip3 install PILLOW

Note: Per poter installa la libreria PILLOW il sistema dovrà possedere la libreira libjpeg-dev altrimenti l’installazione restituirà un errore.

Al termine dell’installazione facciamo una prova. Da terminale digitiamo:

python3
>>> import pillow

Cosa accade? Nulla… questo perchè il modulo è stato installato correttamente e siamo pronti ad utilizzare la libreria.

Ora passiamo alla seconda virtualenv. “Scolleghiamoci” utilizzando il comando deactivate per collegarci alla seconda virtualenv:

source ~/Virtual/number/bin/activate

Ora installiamo la libreria numpy:

pip3 install numpy

Ora diamo questo comando:

python3
>>> import numpy
>>> import pillow

Verrà restituito un errore (ImportError: No module named ‘pillow’), perchè la libreria Pillow è presente solo nella prima virtualenv. Questo in realtà accade anche all’interno dell’ambiente principale.
Se uscissimo dalla virtualenv (deactivate) e digitassimo

python3
>>> import pillow

Il sistema restituirebbe comunque errore, perchè abbiamo utilizzato un sistema “virtuale” per conservare le librerie.

Cosa succede se un progetto ha bisogno di molte librerie ed ho necessità di riprodurlo su di una nuova macchina?

PIP ci viene in soccorso… all’interno della virtualenv potremmo creare un file che ci indichi tutte le librerie installate e successivamente installarle con due semplici comandi.

Creare la lista delle librerie installate all’interno del progetto (nome_mio_progetto):

~$/nome_mio_progetto/ pip3 freeze > requirements.txt

Il file potrebbe contenere qualcosa di similare:

...
bitstring==3.1.5
certifi==2017.7.27.1
chardet==3.0.4
dropbox==8.0.0
fdb==1.8
idna==2.6
matlab==0.1
Naked==0.1.31
netifaces==0.10.6
numpy==1.13.1
...

Per poter utilizzare il file requirements basterà eseguire il comando all’interno di una virtualenv “pulita”:

pip3 install -r requirements.txt

Grazie ed alla prossima guida.

 

Installazione MariaDB – MySql

Nella guida precedente abbiamo visto come installare PHP su macchine Debian e derivate. Per completare e rifinire un sistema LAMP, vedremo come installare e configurare un database MariaDB.

Note: abbiamo scelto di installare MariaDB perchè essendo un fork Open Source di Mysql Oracle risulta estremamente compatibile, ma senza costi di licenza ad uso commerciale.

Apriamo il terminale e digitiamo:

~$ apt install mariadb-client mariadb-server

A differenza di Mysql, MariaDB non ha un configuratore grafico, ma dovremmo procedere tramite terminale… niente paura è estremamente semplice.

Per prima cosa lanciamo il comando:

~$ mysql_secure_installation

Questo ci permetterà di effettuare alcune configurazioni di base.
Inizialmente ci verrà chiesto di modificare la password di root del database e noi ovviamente la modificheremo con una nuova 😉

Change the root password? [Y/n] Y

Quindi inseriremo la nuova password.
Successivamente ci verrà richiesto di cancellare l’user anonimo ed anche in questo caso, per ragioni di sicurezza diremo di si

Remove anonymous users? [Y/n] y

Generalmente MariaDB si connette tramite localhost, questo non ci consentirebbe di connetterci da un’altro indirizzo ip. Nel caso volessimo raggiungere il database da una macchina differente diremo di si altrimenti indicheremo no. Noi acconsentiremo l’accesso da una macchina remota.

Disallow root login remotely? [Y/n] y

Successivamente ci chiederà se cancellare il database di test ed in generale noi acconsentiremo in quanto non ci servirà.

Remove test database and access to it? [Y/n] y

Quindi ci chiederà di riavviare i privilegi assegnati ai database ed anche in questo caso acconsentiremo.

Reload privilege tables now? [Y/n] y

A questo punto la prima parte della configurazione è pronta!

Ora passiamo alla creazione di un nuovo database che chiameremo nostro_test. Da riga di comando digitiamo ed inseriamo la password modificata in precedenza.

mysql -u root -p

Entreremo della console di Mysql/MariaDB.

Creazione di un nuovo DB (le voci {nostro_utente} e {nostra_password} andranno sostituite con un nome utente ed una password 😉 ):

> CREATE DATABASE nostro_test;
> CREATE USER '{nostro_utente}'@'%' IDENTIFIED BY '{nostra_password}';
> GRANT ALL PRIVILEGES ON nostro_test.* to '{nostro_utente}'@'%' WITH GRANT OPTION;
> FLUSH PRIVILEGES;
> quit

Analizziamo cosa abbiamo fatto?

  1. Abbiamo creato un nuovo database di nome nostro_test;
  2. Abbiamo creato un nuovo utente e la password;
    Il simbolo % indica che il Database creato è raggiungibile da qualsiasi indirizzo esterno; se volessimo assegnare un indirizzo locale dovremmo inserire ‘{nostro_utente}’@’localhost‘;
  3. Abbiamo assegnato i privilegi al database associato all’utente l’utente e l’indirizzo da cui sarà raggiungibile (% = tutti gli indirizzi);
  4. Abbiamo assegnato i privilegi;
  5. Siamo usciti dalla console di mysql/MariaDB;

Per rendere i database raggiungibili dall’esterno dovremmo modificare il file 50-server.cnf

nano /etc/mysql/mariadb.conf.d/50-server.cnf

cercare la riga bind-address e se commentata, decommentarla ed assegnargli come indirizzo ip 0.0.0.0

bind-address = 0.0.0.0

Potremmo effettuare un test di accesso al database ad esempio utilizzando MySQL Workbench.

Ora vedremo come abilitare il php alla connessione di MariaDB e come installare PHPMyadmin (che però sconsiglio in produzione 🙂 )

Per prima cosa abilitiamo il php alla connessione del Database.

All’interno del file php.ini generalmente presente in /etc/php/7.0/apache2/php.ini deselezionare la riga ;extension=msql.so semplicemente togliendo il punto e virgola.

extension=msql.so

Quindi riavviare apache:

systemctl restart apache2

Ok, Il php è abilitato alla connessione del database MariaDB/MySql; ora passiamo all’installazione di Phpmyadmin (applicativo web per la gestione dei database Mysql e MariaDB).

Per prima cosa installiamo PhpMyadmin con il seguente comando:

apt-get install phpmyadmin

Generalmente durante l’installazione appare una schermata dove verrà richiesto:

  1.  di scegliere il web server di configurazione e noi sceglieremo ovviamente apache2;
  2.  di configurare i database tramite dbconfig-common (Configure database for phpmyadmin with dbconfig-common?) e sceglieremo Yes;
  3.  ci verrà chiesto di inserire una password;

A questo punto siamo pronti. Digitiamo nella barra degli indirizzi del nostro browser preferito la seguente riga:

http://localhost/phpmyadmin/

Inseriamo come utente root e la password inserita durante la fase di installazione. Ora dovremmo vedere il database nostro_test.

Personalmente sconsiglio Phpmyadmin in produzione, per ragioni di sicurezza, ma lo trovo veramente utile come software in locale.

Alla prossima guida.

Installazione Php7.x su macchina Debian e derivate

In questo articolo illustreremo come installare facilmente PHP 7.x su di una macchine debian o derivate per creare il classico ambiente LAMP (Linux, Apache, Mysql/MariaDb, PHP o Python).

Nel caso volessimo installare PHP 7.2 ed i repository non contengono questo pacchetto dovremmo aggiungerlo semplicemente scrivendo queste righe all’interno del terminale (ovviamente come amministratori):

~$ apt-get install apt-transport-https lsb-release ca-certificates
~$ wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg
~$ echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/php.list
~$ apt-get update

Ora dovremmo installare Apache Server (per maggiori informazioni)

~$ apt-get install apache2

Proviamo a digitare nella barra degli indirizzi del nostro browser preferito il seguente url:

http://localhost/

Dovrebbero apparire la informazioni riguardanti apache.

Perfetto, ora passiamo all’installazione di PHP.
Nota: di seguito inserirò i comandi per l’installazione di PHP 7.0, se abbiamo deciso di installare la versione 7.2, basterà modificare i richiami da 7.0 a 7.2.

~$ apt-get install php7.0
~$ apt-get install libapache2-mod-php7.0
~$ systemctl restart apache2

Ora provvederemo ad installare alcuni moduli utili per un corretto funzionamento del php che in genere sono presenti di default nei servizi hosting più diffusi:

apt-get install php7.0-cli php7.0-common libapache2-mod-php7.0 php7.0-mysql php7.0-fpm php7.0-curl php7.0-gd php7.0-bz2 php-mbstring php-gettext php7.0-xml php7.0-sqlite 

Per quanto riguarda l’installazione di phpmyadmin rimanderemo l’installazione e la configurazione nella guida di installazione di MariaDb/Mysql.

Terminata l’installazione dei moduli del php, si passa alla sua configurazione ed all’abilitazione dell’.htaccess di apache.

Lanciamo il comando per abilitare il mod_rewrite di apache

~$ a2enmod rewrite

Quindi da terminale lanciamo:

~$ nano  /etc/apache2/sites-available/000-default.conf

ed inseriamo al di sotto della riga DocumentRoot /var/www/html:

<Directory />
   	Options Indexes FollowSymLinks MultiViews
    	AllowOverride All
</Directory>
<Directory /var/www/html>
   	 Options Indexes FollowSymLinks MultiViews
   	 AllowOverride All
   	 Order allow,deny
   	 allow from all
</Directory>

Non ci resta che riavviare i servizi di apache e l’installazione è completa.

~$ systemctl restart apache2

Nella prossima guida tratteremo l’installazione di MariaDB/MySql, l’abilitazione del DB in PHP e l’installazione di PHPMyadmin.
Buona Lettura.