https Archivi - Petar Karan

21 Novembre 2020 Nessun commento

[owncloud] Installare ownCloud su Ubuntu Server 20.04.1, configurazione VirtualHost, certificato HTTPS e disco dati con LVM

Vediamo come installare ownCloud su un Ubuntu Server 20.04.1. In aggiunta configureremo anche un VirtualHost con un certificato autofirmato, aggiungendo infine un disco in LVM che ospiti i dati di ownCloud.

1. Configurazione server LAMP

Anzitutto configuriamo il server LAMP installando Apache, MariaDB e il PHP 7.4.

Eseguiamo il seguente comando:

sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

1	sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

A questo punto configuriamo il database eseguendo:

sudo mysql_secure_installation

1	sudo mysql_secure_installation

ATTENZIONE! Se si esegue il commando senza sudo verrà chiesta la password dell’utente root e non ci sarà modo di cambiarla, generando l’errore: ERROR 1698 (28000): Access denied for user 'root'@'localhost'

Digitare in sequenza, per le singole domande:

Change the root password? [Y/n] Y

Remove anonymous users? [Y/n] Y

Disallow root login remotely? [Y/n] Y

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

Reload privilege tables now? [Y/n] Y

Una volta completata la configurazione di MariaDB il server LAMP e pronto è possiamo procedere con le specifiche configurazioni.

2. Creiamo il certificato di crittografia

Se non lo abbiamo già fatto installiamo openssl. Questo ci servirà per creare un certificato autofirmato, nel caso in cui si disponga già del certificato si può passare al punto successivo.

sudo apt-get install openssl

1	sudo apt-get install openssl

Creiamo la chiave privata e il certificato:

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

1	sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

Nel caso specifico stiamo dicendo ad openssl:

req sottocomando col quale specifichiamo che vogliamo usare l’X.509 CSR (certificate signing request), un’infrastruttura standard per le chiavi pubbliche utilizzata tipicamente con SSL e TSL
nodes indica ad OpenSSL di non cifrare il certificato con una password, dal momento che verrà utilizzato su Apache che deve potervi accedere liberamente
days specifica la durata di validità del certificato, nel nostro caso 365 giorni
newkey specifica il tipo di chiave privata (RSA 2048) che si vuole generare e il fatto che la si voglia generare assieme al certificato
keyout indica la posizione dove creare la chiave
out indica la posizione dove creare il certificato

Rispondiamo ai quesiti posti da OpenSSL per la configurazione del certificato. Nel mio caso procederò così:

Country Name (2 letter code) [AU]:IT
State or Province Name (full name) [Some-State]:Firenze
Locality Name (eg, city) []:Firenze
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Torregatti Spa
Organizational Unit Name (eg, section) []:Servizi Cloud
Common Name (e.g. server FQDN or YOUR name) []:cloud.local
Email Address []:scrivi@petarkaran.it

I valori sono per lo più arbitrari, l’unica cosa importante è il Common Name, che può essere l’indirizzo IP del server, oppure il dominio a cui sarà associato il certificato.

Configuriamo Apache affinché utilizzi correttamente i certificati SSL:

sudo nano /etc/apache2/conf-available/certificati.conf

1	sudo nano /etc/apache2/conf-available/certificati.conf

Nel file digitiamo:

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
SSLHonorCipherOrder On
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
SSLCompression off
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
SSLSessionTickets Off

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH

SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

SSLHonorCipherOrder On

Header always set X-Frame-Options DENY

Header always set X-Content-Type-Options nosniff

SSLCompression off

SSLUseStapling on

SSLStaplingCache "shmcb:logs/stapling-cache(150000)"

SSLSessionTickets Off

Affinché la configurazione funzioni dobbiamo attivare il modulo SSL e il modulo Headers in Apache.

sudo a2enmod ssl
sudo a2enmod headers

1 2	sudo a2enmod ssl sudo a2enmod headers

A questo punto attiviamo la configurazione digitando:

sudo a2enconf certificati

1	sudo a2enconf certificati

Affinché la configurazione sia corretta bisogna riavviare Apache, anche se non è necessario farlo adesso, lo possiamo fare anche dopo.

sudo service apache2 reload

1	sudo service apache2 reload

3. Configuriamo il VirtualHost

A questo punto configuriamo il nostro VirtualHost, immaginiamo che il nostro ownCloud debba trovarsi all’indirizzo cloud.local. (nel caso specifico da http://cloud.local e https://cloud.local)

Creiamo anzitutto due cartelle in /var/www, una per i file, una per i dati ed una per i log, entrambe sottocartelle di cloud.local, nella maniera seguente.

sudo mkdir -p /var/www/cloud.local/httpdocs
sudo mkdir -p /var/www/cloud.local/logs
sudo mkdir -p /var/www/cloud.local/dati

sudo mkdir -p /var/www/cloud.local/httpdocs

sudo mkdir -p /var/www/cloud.local/logs

sudo mkdir -p /var/www/cloud.local/dati

Grazie all’argomento -p creiamo l’intero percorso anche se non esiste.

A questo punto procediamo con la creazione del file del VirtualHost vero e proprio.

sudo nano /etc/apache2/sites-available/cloud.local.conf

1	sudo nano /etc/apache2/sites-available/cloud.local.conf

Nel file inseriamo le seguenti istruzioni.

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks -Indexes
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

</VirtualHost>

</IfModule>

Options +FollowSymlinks -Indexes

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

In questo modo forziamo il redirect sul HTTPS e abilitiamo il certificato creato in precedenza.

A questo punto riavviamo apache:

sudo service apache2 restart

1	sudo service apache2 restart

4. Creazione partizione per i dati con LVM

Aggiungiamo al nostro server un disco aggiuntivo a creiamo un nuovo disco logico con LVM. Per ulteriori approfondimenti sulla procedura rimando all’articolo LVM, gestore logico dei volumi su Ubuntu [per pinguini alle prime armi]

Anzitutto vediamo i dischi dei quali disponiamo con:

sudo fdisk -l

1	sudo fdisk -l

Nel mio caso (sto utilizzando VirtualBox per l’esempio con 2 dischi da 10GB ciascuno):

Il disco che utilizzerò è /dev/sdb. Procediamo quindi a preparare il disco:

sudo fdisk /dev/sdb

1	sudo fdisk /dev/sdb

Su fdisk digitiamo in ordine:

n per creare una nuova partizione
p per una partizione primaria
1 numero di partizione
INVIO per confermare il primo settore di default 2048
INVIO per confermare l’ultimo settore
t per modificare la partizione
8e per impostare Linux LVM
w per scrivere e salvare il tutto

Utilizzando sudo fdisk -l dovremmo vedere qualcosa di simile:

Creiamo un volume fisico digitando:

sudo pvcreate /dev/sdb1

1	sudo pvcreate /dev/sdb1

Creiamo un gruppo di volumi chiamato dati-cloud digitando:

sudo vgcreate dati-cloud /dev/sdb1

1	sudo vgcreate dati-cloud /dev/sdb1

Creiamo sopra il volume logico dati:

sudo lvcreate -l 100%FREE -n dati dati-cloud

1	sudo lvcreate -l 100%FREE -n dati dati-cloud

Formattiamo il volume in ext4.

sudo mkfs -t ext4 /dev/dati-cloud/dati

1	sudo mkfs -t ext4 /dev/dati-cloud/dati

A questo punto montiamo il nuovo volume logico sulla cartella /var/www/cloud.local/dati

sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

1	sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

Siccome vogliamo che il disco sia montato in modo permanente, modifichiamo /etc/fstab.

sudo nano /etc/fstab

1	sudo nano /etc/fstab

In fondo al file aggiungiamo la seguente riga:

/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

1	/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

In questo modo al riavvio del server il volume logico verrà caricato automaticamente.

5. Creiamo un database per ownCloud

ownCloud necessita di un database per funzionare, pertanto creiamone uno nuovo all’interno di MariaDB.

Entriamo in MariaDB/MySQL:

sudo mysql -u root

1	sudo mysql -u root

Una volta dentro creiamo un nuovo database chiamato cloud_db:

CREATE DATABASE cloud_db;

1	CREATE DATABASE cloud_db;

Creiamo anche un utente per il database appena creato, che potrà accedere esclusivamente da locale (agli scopi dell’esercizio metterò una password banale):

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';
GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';
FLUSH PRIVILEGES;

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';

GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';

FLUSH PRIVILEGES;

6. Installazione ownCloud

Scarichiamo ownCloud nella cartella httpdocs. Da qui possiamo scegliere da dove scaricarlo.

sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

1	sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

Se non abbiamo installato unzip facciamolo:

sudo apt-get install unzip

1	sudo apt-get install unzip

A questo punto estraiamo il file zip.

sudo unzip owncloud-complete-20200731.zip

1	sudo unzip owncloud-complete-20200731.zip

Spostiamo i file dalla cartella owncloud creata dall’unzip, nella radice del virtualhost.

sudo rm owncloud-complete-20200731.zip
sudo mv owncloud/* .
sudo mv owncloud/.* .
sudo rm -r owncloud/

sudo rm owncloud-complete-20200731.zip

sudo mv owncloud/* .

sudo mv owncloud/.* .

sudo rm -r owncloud/

In questo modo rimuoviamo anche la cartella aggiuntiva ed il file zip.

Assegniamo adesso l’utente apache a tutta la cartella ed i file creati.

sudo chown -R www-data:www-data /var/www/cloud.local/

1	sudo chown -R www-data:www-data /var/www/cloud.local/

Infine abilitiamo la configurazione e riavviamo apache:

sudo a2ensite cloud.local
sudo service apache2 restart

1 2	sudo a2ensite cloud.local sudo service apache2 restart

Se tutto è andato bene potremo aprire ownCloud all’indirizzo https://cloud.local/

Inseriamo i parametri nella maniera seguente (utilizzando quelli creati):

Scegliamo un utente ed una password
Per la cartella dati impostiamo la cartella creata all’inizio
Inseriamo i dati del database configurati in precedenza:

Una volta fatto tutto possiamo premere su TERMINA CONFIGURAZIONE.

Se tutto è andato bene vedremo una schermata come la seguente:

Fatto tutto questo possiamo accedere al sistema. Spostandoci su Impostazioni > Generali, potremmo notare delle notifiche come le seguenti:

Apportiamo quindi ancora un paio di modifiche per aggiustare il tutto correttamente.

Anzitutto configuriamo correttamente il crontab affinché esegua gli script di ownCloud.

Digitiamo:

sudo crontab -u www-data -e

1	sudo crontab -u www-data -e

Se è la prima volta che lo apriamo ci chiederà quale editor preferiamo utilizzare, io scelgo 1 per nano.

Aggiungiamo la seguente riga:

*/15  *  *  *  * /var/www/cloud.local/httpdocs/occ system:cron

1	/15 * * * /var/www/cloud.local/httpdocs/occ system:cron

Salviamo con CTRL+O e usciamo.

Nelle suddette impostazioni di ownCloud selezioniamo come meccanismo di aggiornamento Cron.

Spostiamoci nella nostra cartella di installazione con:

cd /var/www/cloud.local/httpdocs/

1	cd /var/www/cloud.local/httpdocs/

Eseguiamo i seguenti comandi:

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'
sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'
sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'

sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'

sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

L’utilizzo di sudo -u www-data è necessario perché l’esecuzione deve essere effettuata da Apache. Eseguendolo senza sudo lo faremmo usando il nostro utente, con sudo come root. In entrambi i casi non andrebbe bene.

Per risolvere l’avviso di HTTP "Strict-Transport-Security" dobbiamo aggiungere a <VirtualHost *:443> le seguenti tre righe:

<IfModule mod_headers.c>
        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
</IfModule>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

Il file definitivo del virtualhost sarà come il seguente:

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

                <IfModule mod_headers.c>
                        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
                </IfModule>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

</VirtualHost>

</IfModule>

Options +FollowSymlinks

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

Riavviamo ancora una volta apache.

sudo service apache2 restart

1	sudo service apache2 restart

A questo punto è tutto pronto e possiamo cominciare ad usare ownCloud.

Vedi articolo

20 Ottobre 2020 Nessun commento

[ubuntu] Load balancer su Ubuntu Server 20.04.1 con Apache e Pound

In questa guida vedremo come configurare un load balancer utilizzando Pound su Ubuntu Server 20.04.1.

Pound è un software opensource sviluppato principalmente come reverse proxy e application firewall, utilizzato spesso per realizzare load balancer. Tra le caratteristiche salienti ci sono la capacità di rilevare lo stato di un server di backend, la possibilità di tradurre richieste in HTTPS su HTTP e un forte accento sulla sicurezza. Quando un server di backend non è raggiungibile Pound è in grado di rilevarlo, scegliendo tra gli altri server accessibili secondo criteri predefiniti a distribuzione casuale. Il tutto avviene tenendo traccia delle sessioni attive, che tipicamente permangono verso il medesimo server di backend di partenza.

La struttura che andremo a realizzare assomiglierà alla seguente:

Detto questo installiamo Ubuntu Server su tutte e tre le macchine e configuriamo opportunamente gli indirizzi di rete.

1. Configurazione rete

Questa operazione dovrà essere ripetuta in modo uguale su tutte le macchine. Procediamo con la prima. Prima di andare avanti vediamo la configurazione che vogliamo avere.

Creeremo una rete 192.168.0.0/24 nella quale le tre macchine saranno configurate nella maniera seguente:

load-balancer-server            192.168.0.5
webserver-1                     192.168.0.6
webserver-2                     192.168.0.7

load-balancer-server 192.168.0.5

webserver-1 192.168.0.6

webserver-2 192.168.0.7

Per visualizzare la configurazione di rete corrente (comincio dalla prima macchina) digitiamo

ip a

ip a

Comparirà qualcosa di simile:

Nel mio caso sto utilizzando una macchina virtuale con VirtualBox e la scheda di rete è enp0s3. Tipicamente al suo posto si trova eth1. L’indirizzo configurato dal DHCP è il 192.168.0.4.

La configurazione di rete si trova in /etc/netplan

Per vedere tutti i file di configurazione presenti digitiamo:

ls /etc/netplan

1	ls /etc/netplan

dovremmo vedere un file tipo 00-installer-config.yaml

Creiamone un backup del file digitando:

sudo cp /etc/netplan/00-installer-config.yaml /etc/netplan/00-installer-config.yaml.bck

1	sudo cp /etc/netplan/00-installer-config.yaml /etc/netplan/00-installer-config.yaml.bck

Adesso andiamo a modificare il file, bisogna fare attenzione all’identazione, che prevede 2 spazi vuoti per ciascuna sottosezione. Digitiamo:

sudo nano /etc/netplan/00-installer-config.yaml

1	sudo nano /etc/netplan/00-installer-config.yaml

Il file originale dovrebbe contenere qualcosa di simile:

# This is the network config written by 'subiquity'
network:
  ethernets:
    enp0s3:
      dhcp4: true
  version: 2

# This is the network config written by 'subiquity'

network:

ethernets:

enp0s3:

dhcp4: true

version: 2

Modifichiamolo nella maniera seguente:

# This is the network config written by 'subiquity'
network:
  ethernets:
    enp0s3:
      dhcp4: no
      addresses: [192.168.0.5/24]
      gateway4: 192.168.0.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]
  version: 2

# This is the network config written by 'subiquity'

network:

ethernets:

enp0s3:

dhcp4: no

addresses: [192.168.0.5/24]

gateway4: 192.168.0.1

nameservers:

addresses: [8.8.8.8, 8.8.4.4]

version: 2

Il mio gateway è il 192.168.0.1, per scoprirlo tramite DHCP possiamo digitare ip r

Una volta modificata la configurazione salviamo il file e testiamola digitando:

sudo netplan try

1	sudo netplan try

Se va tutto bene possiamo applicare la modifica, digitando:

sudo netplan apply

1	sudo netplan apply

Verifichiamo infine la configurazione con:

ip a

ip a

Se tutto è andato bene vedremo qualcosa del genere:

Se dovessimo cambiare il nome della macchina possiamo digitare:

sudo hostnamectl set-hostname webserver-1

1	sudo hostnamectl set-hostname webserver-1

Per assegnare alla macchina il nome webserver-1. Una volta modificato il nome sarà sufficiente riavviare.

2. Installazione di Pound

Adesso procediamo ad installare Pound su load-balancer-server. Per farlo digitiamo:

sudo apt-get install pound

1	sudo apt-get install pound

Per configurare Pound procediamo a modificare il file /etc/pound/pound.cfg. Digitiamo quindi:

sudo nano /etc/pound/pound.cfg

1	sudo nano /etc/pound/pound.cfg

Troveremo di default una struttura simile alla seguente nel file:

ListenHTTP
        Address 127.0.0.1
        Port    8080

        ## allow PUT and DELETE also (by default only GET, POST and HEAD)?:
        xHTTP           1

        Service
                BackEnd
                        Address 127.0.0.1
                        Port    80
                End
        End
End

ListenHTTP

Address 127.0.0.1

Port 8080

## allow PUT and DELETE also (by default only GET, POST and HEAD)?:

xHTTP 1

Service

BackEnd

Address 127.0.0.1

Port 80

End

Questo significa che Pound è in ascolto sulla porta 8080 e utilizza come servizio un server di backend sempre all’indirizzo locale (qui si suppone si sia installato apache sul medesimo server). Adesso i servizi possono essere definiti in modo globale oppure relativamente ad uno specifico listener. In questo caso sono definiti all’interno di un listener. Ogni servizio ha dentro i server di backend ai quali può essere data una priorità. La priorità di predefinito è impostata su 5, i valori possibili sono da 1 a 9.

Riorganizziamo il nostro file di configurazione per ottenere il seguente risultato:

## Minimal sample pound.cfg
##
## see pound(8) for details

######################################################################
## global options:

User            "www-data"
Group           "www-data"
#RootJail       "/chroot/pound"

## Logging: (goes to syslog by default)
##      0       no logging
##      1       normal
##      2       extended
##      3       Apache-style (common log format)
LogLevel        3 # <-- impostiamo il log level a 3

## check backend every X secs:
Alive           30

## use hardware-accelleration card supported by openssl(1):
#SSLEngine      "<hw>"

# poundctl control socket
Control "/var/run/pound/poundctl.socket"


######################################################################
## listen, redirect and ... to:

## redirect all requests on port 8080 ("ListenHTTP") to the local webserver (see "Service" below):
ListenHTTP
        Address 127.0.0.1
        Port    80 # <-- cambiamo la porta da 8080 su 80

        ## allow PUT and DELETE also (by default only GET, POST and HEAD)?:
        #xHTTP          1 # <-- commentiamo questa riga
End

# configuriamo anche l'ascolto sul HTTPs, lasciamo commentato se non abbiamo il certificato
#ListenHTTPS
#        Address 127.0.0.1
#        Port 443
#        Cert "/etc/ssl/pound.pem"
#End

Service
        BackEnd
                Address 192.168.0.6
                Port 80
        End

        BackEnd
                Address 192.168.0.7
                Port 80
                Priority 5
        End
End

## Minimal sample pound.cfg

## see pound(8) for details

######################################################################

## global options:

User "www-data"

Group "www-data"

#RootJail "/chroot/pound"

## Logging: (goes to syslog by default)

## 0 no logging

## 1 normal

## 2 extended

## 3 Apache-style (common log format)

LogLevel 3 # <-- impostiamo il log level a 3

## check backend every X secs:

Alive 30

## use hardware-accelleration card supported by openssl(1):

#SSLEngine "<hw>"

# poundctl control socket

Control "/var/run/pound/poundctl.socket"

######################################################################

## listen, redirect and ... to:

## redirect all requests on port 8080 ("ListenHTTP") to the local webserver (see "Service" below):

ListenHTTP

Address 127.0.0.1

Port 80 # <-- cambiamo la porta da 8080 su 80

## allow PUT and DELETE also (by default only GET, POST and HEAD)?:

#xHTTP 1 # <-- commentiamo questa riga

End

# configuriamo anche l'ascolto sul HTTPs, lasciamo commentato se non abbiamo il certificato

#ListenHTTPS

# Address 127.0.0.1

# Port 443

# Cert "/etc/ssl/pound.pem"

#End

Service

BackEnd

Address 192.168.0.6

Port 80

End

BackEnd

Address 192.168.0.7

Port 80

Priority 5

End

Se volessimo configurare dei servizi di emergenza, anziché usare il TAG BackEnd potremmo utilizzare Emergency. Tutto il resto rimarrebbe identico. Un server di emergenza interverrebbe solo qualora tutti gli altri backend fallissero.

Salviamo il file e modifichiamo il meccanismo di startup digitando:

sudo nano /etc/default/pound

1	sudo nano /etc/default/pound

Modifichiamo il file nella maniera seguente:

# Defaults for pound initscript
# sourced by /etc/init.d/pound
# installed at /etc/default/pound by the maintainer scripts

# prevent startup with default configuration
# set the below varible to 1 in order to allow pound to start
startup=1

# Defaults for pound initscript

# sourced by /etc/init.d/pound

# installed at /etc/default/pound by the maintainer scripts

# prevent startup with default configuration

# set the below varible to 1 in order to allow pound to start

startup=1

A questo punto riavviamo Pound. Digitiamo:

sudo service pound restart

1	sudo service pound restart

3. Installazione di Apache sui backend

Sui server di backend sarà sufficiente installare Apache, senza ulteriori configurazioni. Ricordiamoci che Pound, anche se interrogato in HTTPS si connetterà ai server di backend in HTTP.

Per farlo digitiamo semplicemente:

sudo apt-get install apache2

1	sudo apt-get install apache2

Una volta installato Apache modifichiamo l’output predefinito del webserver. Per farlo cancelliamo il file originale e creiamone uno nuovo.

sudo rm /var/www/html/index.html
sudo nano /var/www/html/index.html

1 2	sudo rm /var/www/html/index.html sudo nano /var/www/html/index.html

In questo caso ci scriverò dentro il nome del WebServer, per esempio:

Ciao dal WebServer1

1	Ciao dal WebServer1

Configuriamo ora il backend affinché effettui il log per le richieste X-Forwarded-For.

Anzitutto abilitiamo l’estensione remoteip di apache.

sudo a2enmod remoteip

1	sudo a2enmod remoteip

Modifichiamo il file di configurazione digitando:

sudo nano /etc/apache2/apache2.conf

1	sudo nano /etc/apache2/apache2.conf

Modifichiamo il seguente paragrafo del file:

#
# The following directives define some format nicknames for use with
# a CustomLog directive.
#
# These deviate from the Common Log Format definitions in that they use %O
# (the actual bytes sent including headers) instead of %b (the size of the
# requested file), because the latter makes it impossible to detect partial
# requests.
#
# Note that the use of %{X-Forwarded-For}i instead of %h is not recommended.
# Use mod_remoteip instead.
#
RemoteIPHeader X-Forwarded-For
RemoteIPInternalProxy 192.168.0.5
LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined
LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %O" common
LogFormat "%{Referer}i -> %U" referer
LogFormat "%{User-agent}i" agent

# The following directives define some format nicknames for use with

# a CustomLog directive.

# These deviate from the Common Log Format definitions in that they use %O

# (the actual bytes sent including headers) instead of %b (the size of the

# requested file), because the latter makes it impossible to detect partial

# requests.

# Note that the use of %{X-Forwarded-For}i instead of %h is not recommended.

# Use mod_remoteip instead.

RemoteIPHeader X-Forwarded-For

RemoteIPInternalProxy 192.168.0.5

LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined

LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined

LogFormat "%h %l %u %t \"%r\" %>s %O" common

LogFormat "%{Referer}i -> %U" referer

LogFormat "%{User-agent}i" agent

Faccio notare che l’IP 192.168.0.5 è quello della macchina col Pound.

Riavviamo Apache:

sudo service apache2 restart

1	sudo service apache2 restart

Ripetiamo questa procedura su ogni backend.

4. Prova di funzionamento

A questo punto colleghiamoci al nostro server con Pound, nel mio caso si trova all’indirizzo http://192.168.56.1/

Aggiornando più volte la pagina vedremo comparire, in modo casuale, la risposta del webserver-1 oppure del webserver-2

Oppure:

Vedi articolo

18 Dicembre 2017 Nessun commento

Mixed Content: The page at ‘https://’ was loaded over HTTPS, but requested an insecure script ‘http://’

Soluzione: Se utilizzate WordPress potete utilizzare un plugin come Really Simple SSL, altrimenti assicuratevi che tutti gli indirizzi nella pagina incriminata siano del tipo HTTPS

Se il browser (in questo caso Chrome) vi segnala il seguente errore

Mixed Content: The page at 'https://' was loaded over HTTPS, but requested an insecure script 'http://'. This request has been blocked; the content must be served over HTTPS.

1	Mixed Content: The page at 'https://' was loaded over HTTPS, but requested an insecure script 'http://'. This request has been blocked; the content must be served over HTTPS.

Significa che la pagina che state visitando sta cercando di caricare del contenuto da una connessione non protetta (HTTP) su una connessione protetta (HTTPS). Il problema si risolve semplicemente cambiando il protocollo sugli indirizzi incriminati, oppure forzando un redirect completo della pagina su HTTPS.

Vedi articolo