Pixelfed dans une jail

Nous avons vu comment installer peertube dans une jail, mastodon dans une jail tout deux bénéficiant de l’installation de PostgreSQL dans une jail. Nous allons continuer avec ActiviyPub en installant Pixelfed dans une jail.

 Le logiciel est encore en phase béta et il est possible que notre installation soit un peu exotique (nous allons essayer de tirer parti de notre jail postgreSQL).

 Nous allons, cette fois-ci, pouvoir utiliser notre poudriere.

 Nous partons d’une jail fonctionnelle avec accès au réseau et ssh disponible.

Configuration de pkg

C’est l’outil pkg qui nous permet de gérer l’installation ou la désinstallation des paquets logiciels tout prêt. Par défaut celui va les chercher sur les serveurs de FreeBSD.

Or, nous avons à notre disposition une poudriere. C’est-à-dire un dépôt local des logiciels dont nous avons besoin, spécialement compilés par nous et pour nous.

Nous devons indiquer à pkg comment l’utiliser.

nous supposons ici que votre poudriere fonctionne et qu’elle est servie en https depuis l’hôte, ou depuis une autre jail.

Nous allons créer le répertoire /usr/local/etc/pkg/repos :

$ mkdir -p /usr/local/etc/pkg/repos
$ cd /usr/local/etc/pkg/repos


Dans ce répertoire nous allons créer deux fichiers. Le premier indiquera comment accéder à la poudriere, nous le nommons poudriere.conf :
1
2
3
4
5
6
poudriere: {
    url: "pkg+https://poudriere.example.com/packages/11Ramd64-default",
    mirror_type : "srv",
    enabled: yes,
    priority: 100
}

le second sert à désactiver l’accès aux dépôts FreeBSD :

FreeBSD {enable: no}

Et nous allons demander à pkg de prendre en compte sa nouvelle configuration :

$ pkg update

  En cas de problème de communication entre la jail et la poudrière pour des raisons liées à TLS :

Certificate verification failed for /C=US/O=Let's Encrypt/CN=Let's
Encrypt Authority X3
34405332376:error:14090086:SSL
routines:ssl3_get_server_certificate:certificate verify
failed:/usr/src/crypto/openssl/ssl/s3_clnt.c:1264:
Certificate verification failed for /C=US/O=Let's Encrypt/CN=Let's
Encrypt Authority X3
Il est nécessaire d’installer ca_root_nss avec la commande :
cd /usr/ports/security/ca_root_nss ; make install

Installation des prérequis

La documentation officielle indique quels sont les prérequis et nous allons nous en servir pour faire sur notre poudriere une liste spécifique. Ainsi nous serons sûrs d’avoir les bons paquets, dans les bonnes versions.

Un fichier pour la poudriere

Voici le fichier en question, que j’ai appellé pixelfedjail-list.txt :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
lang/php72
databases/postgresql95-client
databases/redis
databases/php72-pdo_pgsql
devel/php-composer@php72
devel/phpunit7@php72
devel/php72-pcntl
graphics/php72-gd
security/php72-openssl
converters/php72-mbstring
devel/php72-tokenizer
textproc/php72-xml
textproc/php72-ctype
textproc/php72-xmlwriter
sysutils/php72-fileinfo
sysutils/php72-posix
devel/php72-json
graphics/jpegoptim
graphics/optipng
graphics/pngquant
graphics/gifsicle
graphics/php72-exif
math/php72-bcmath
www/php72-session
ftp/php72-curl
devel/aws-sdk-php@php72

Nous n’avons besoin que de postgreSQL-client, nous utiliseront le serveur PostgreSQL de notre jail du même nom.

Le paquet SVGO est utilisé pour optimiser les fichiers de type svg et nécessite l’utilisation de NodeJS. Ce dernier n’étant pas nécessaire pour Pixelfed et le paquet étant optionnel. Nous nous en passerons.

Le paquet graphics/php72-exif n’est pas dans la liste des prérequis, mais il semble que son absence gène beaucoup le reste de l’installation.

Compilation de nos paquets avec la poudriere

Ceci n’est qu’un rappel, si vous utilisez votre poudriere régulièrement, vous devriez savoir comment faire.

Ces manipulations sont bien sûr à faire sur l’hôte (ou la jail) qui fait tourner votre poudriere.

Pendant que la poudriere fait son travail, vous pouvez créer les enregistrements ‘DNS’ qui correspondent à votre instance. Il est important de le faire rapidement, let's encrypt en aura rapidement besoin.

Mise à jour des ports

Pour nous assurer d’avoir la dernière version des ports, nous allons mettre à jour ces derniers :

# poudriere ports -u

Une fois cette mise à jour effectué nous allons lancer la compilation des paquets requis pour pixelfed.

# tmux
# poudriere bulk -j 11Ramd64 -f /usr/local/etc/poudriere.d/pixelfedjail-list.txt 

Je lance la compilation dans un tmux pour pouvoir le détacher si la compilation prend trop de temps.

Utilisation de nos paquets

De retour sur la jail pixelfed, nous pouvons utiliser et installer nos paquets.

Nous devons tout d’abord mettre à jour le cache des paquets disponibles :

# pkg update

Et ensuite procéder à l’installation elle-même :

# pkg install php72 postgresql96-client php72-composer php72-gd php72-openssl \
php72-mbstring php72-tokenizer php72-xml php72-ctype php72-json jpegoptim \
optipng pngquant gifsicle php72-exif php72-fileinfo php72-pdo_pgsql php72-dom \
php72-posix php72-xmlwriter php72-bcmath php72-session

D’autres dépendances seront installées.

Installation d’autres paquets important

Nous avons besoin d’autres paquets, nginx pour servir le site, git pour récupérer les sources de pixelfed. Normalement vous n’avez pas besoin de moi pour faire ces installations.

Installation et configuration de pixelfed

Tout est en place, nous sommes prêts à nous lancer dans l’installation de pixelfed.

Nous devons tout d’abord créer le répertoire www qui appartiendra à l’utilisateur www et au groupe de même nom :

# mkdir /usr/local/www
# chown www:www /usr/local/www
# cd /usr/local/www

Nous allons avoir besoin de la base de données redis qui elle, va rester sur la jail. Nous devons aussi faire en sorte qu’elle soit lancée au démarrage de la jail et puis nous la démarrons.

# pkg install redis
…
# sysrc redis_enable="YES"
# service redis start

Installation de pixelfed par clonage des sources

La suite se fait en suivant la documentation officielle, en clonant le dépôt des sources :

# git clone https://github.com/dansup/pixelfed.git

Paramétrage de pixelfed

Le paramètrage de pixelfed se fait à l’aide de commandes simples décrites dans la documentation officielle.

# cd /usr/local/www/pixelfed
# composer install

Ensuite, nous allons commencer le paramètrage de pixelfed en copiant le fichier de configuration donné en exemple :

# cp .env.example .env

Dans ce fichier on trouve la définition de l’accès à la base de données. Souvenez-vous, j’ai décidé d’utiliser postgreSQL et l’installation que j’en ai fait sur une jail séparée.

Il va donc falloir préparer le terrain sur cette jail.

Configuration sur la jail postgres

Nous avons besoin de configurer la base postgreSQL pour notre instance pixelfed.

Création de l’utilisateur pixelfed

Nous allons devoir créer un utilisateur :

# pw useradd -n pixelfed -c "Pixelfed user" -s /bin/csh -m -w random
Password for 'pixelfed' is: <random generated password>
Pensez à conserver le mot de passe généré dans votre gestionnaire de mot de passe.
Si la commande pw vous rebute vous pouvez utiliser la commande interactive adduser. Vous pouvez également modifier directement le fichier /etc/passwd avec la commande vipw.

Création du rôle pixelfed dans postgres

Nous allons créer un rôle dans postgreSQL pour pixelfeed :

root@postgres:~ # sudo -u postgres createuser -P pixelfed
Enter password for new role: 
Enter it again: 
$ sudo -u postgres createdb -O pixelfed pixelfed

Tout comme pour le mot de passe de l’utilisateur, pensez à sauvegarder celui-ci dans votre gestionnaire de mot de passe.

Configuration de l’accès distant

Comme nous l’avions fait pour mastodon et pour peertube, nous allons modifier le fichier /var/db/postgres/data96/pg_hba.conf pour autoriser les connexions réseau à la base :

host    pixelfed                pixelfed        192.168.12.0/24 md5

Nous pouvons maintenant retourner dans notre jail pixelfed pour compléter correctement notre fichier de configuration.

Le fichier de configuration .env

Ce fichier est assez simple à comprendre. La seule difficulté pour nous est la connexion à la base pixelfed sur une autre jail.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
APP_NAME="PixelFed Test Instance"
APP_ENV=local
APP_KEY=
APP_DEBUG=true
APP_URL=https://pixelfed.example.com

ADMIN_DOMAIN="pixelfed.example.com"
APP_DOMAIN="pixelfed.example.com"

LOG_CHANNEL=stack

DB_CONNECTION=pgsql
DB_HOST=<ip de la jail Postgresql>
DB_PORT=5432
DB_DATABASE=pixelfed
DB_USERNAME=pixelfed
DB_PASSWORD=<mot de passe>

BROADCAST_DRIVER=log
CACHE_DRIVER=redis
SESSION_DRIVER=redis
SESSION_LIFETIME=120
QUEUE_DRIVER=redis

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

MAIL_DRIVER=log
MAIL_HOST=smtp.example.com
MAIL_PORT=25
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="pixelfed@example.com"
MAIL_FROM_NAME="Pixelfed"

SESSION_DOMAIN="${APP_DOMAIN}"
SESSION_SECURE_COOKIE=true
API_BASE="/api/1/"
API_SEARCH="/api/search"

OPEN_REGISTRATION=true
RECAPTCHA_ENABLED=false
ENFORCE_EMAIL_VERIFICATION=true

MAX_PHOTO_SIZE=15000
MAX_CAPTION_LENGTH=150
MAX_ALBUM_LENGTH=4

MIX_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
MIX_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"
MIX_APP_URL="${APP_URL}"
MIX_API_BASE="${API_BASE}"
MIX_API_SEARCH="${API_SEARCH}"

Une fois le fichier de configuration complété, nous allons lancer les quelques commandes qui font nous permettre de générer une clef unique, de faire les liens symboliques nécessaires à l’application et la création des tables dans la base de données.

# php artisan key:generate
# php artisan storage:link
# php artisan migrate

Avant d’aller plus loin, il est nécessaire d’ajouter une extension à PostgreSQL et d’instancier celle-ci dans la base de données pixelfed que nous venons de créer.

Nous devons donc retourner sur notre jail postgreSQL.

Ajout et activation d’une extension postgres

 Les manipulations suivantes sont à faire sur le jail ‘PostgreSQL’

Sur notre jail postgreSQL nous ajoutons cette extension et nous allons l’utiliser dans les tables qui ont été créées précédement :

# sudo -U postgres psql
postgres=# \connect pixelfed
You are now connected to database "pixelfed" as user "postgres".
postgres=# CREATE EXTENSION citext;
pixelfed=# ALTER TABLE users ALTER COLUMN username TYPE citext;
ALTER TABLE
pixelfed=# ALTER TABLE profiles ALTER COLUMN name TYPE citext;
ALTER TABLE
pixelfed=# ALTER TABLE profiles ALTER COLUMN username TYPE citext;
ALTER TABLE
pixelfed=#\q

La configuration de nginx

Comme pour peertube et mastodon, notre configuration de nginx est éclaté sur deux machines. La première partie, sur l’hôte, va gérer la connexion https, et la seconde, sur la jail, va servir les pages.

 La documentation de pixelfed sur ce sujet étant plus que légère, je remercie Nono et Valère de m’avoir soufller leurs configurations.

Configuration de nginx sur l’hôte

 Ces manupilations sont à faire sur l’hôte.

Mon fichier de configuration se nomme /usr/local/etc/nginx/sites-available/pixelfed-jail.conf.

Il est relativement simple. Il reçoit les requêtes sur les ports 80 et 443. Celles reçus sur le port 80 sont redirigés sur le port 443 exceptées celles qui concernent let's encrypt qui sont envoyées vers le répertoire vide bidon, comme pour les autres configurations déjà vues.

Dans la partie sur le port 443/ssl/http 2 on vérifie utilise le certificat et sa clef afin de sécuriser la connexion, on positionne les entêtes de redirection avant d’envoyer le tout à la jail.

Voici le fichier dans son intégralité :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 server {

    listen 80;
    listen [::]:80;
    server_name pixelfed.exemple.com ;

    access_log /var/log/nginx/pixelfed_access.log;
    error_log /var/log/nginx/pixelfed_error.log;

    location / {
        return 301 https://$host$request_uri;
    }

    location /.well-known/acme-challenge {
        root /usr/local/www/bidon;
    }

}


server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name pixelfed.example.com ;

    access_log /var/log/nginx/pixelfed_access.log;
    error_log /var/log/nginx/pixelfed_error.log;

    ssl_certificate /usr/local/letsencrypt/live/pixelfed.exemple.com/fullchain;
    ssl_certificate_key /usr/local/letsencrypt/live/pixelfed.exemple.com/privkey;

    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto https;
        proxy_hide_header Strict-Transport-Security;
        proxy_pass http://<ip de la jail>/;
    }

}

Il faut faire le lien symbolique vers /usr/local/etc/nginx/sites-enabled :

# cd /usr/local/etc/nginx/sites-enabled
# ln -s /usr/local/etc/nginx/sites-available/pixefed-jail.conf

Nous pouvons tester notre configuration :

# nginx -t
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful

Et en cas de succès, redémarrer le service :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# service nginx restart
Performing sanity check on nginx configuration:
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
Stopping nginx.
Waiting for PIDS: 57781.
Performing sanity check on nginx configuration:
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
Starting nginx.

 Pensez à la configuration de let's encrypt. Voyez pour cela les autres installations déjà décrites sur ce blog.

Configuration de nginx sur la jail

Pixelfed étant écrit en php, nginx a besoin de php-pfm pour fonctionner. Nous devons configurer ce dernier avant de nous attaquer à nginx.

 Ces manipulations sont à faire dans la jail

Configuration de php-pfm

La configuration se fait dans un fichier spécifique /usr/local/etc/php-fpm.d/pixelfed.conf

Nous devons décrire le socket Unix qui sera utilisée. L’utilisateur et le groupe propriétaire, les droits de ce socket. Ainsi quelques paramètres du serveur.

Voici le fichier en intégralité :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
[pixelfed]
user = www
group = www
listen = /var/run/php-fpm-pixelfed.sock
listen.owner = www
listen.group = www
listen.mode = 0666

pm = dynamic
pm.max_children = 5
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3
pm.max_requests = 500

Une fois créé, il est nécessaire de s’assurer que php-fpm est lancé au démarrage de la jail et de démarrer le processus qui créera le socket.

1
2
3
4
5
# sysrc php-fpm_enable="YES"
php-fpm_enable: -> fpm_enable
# service php-fpm start
# ls -al /var/run/php-fpm-pixelfed.sock
srw-rw-rw-  1 www  www  0 Sep 26 10:43 /var/run/php-fpm-pixelfed.sock

Configuration de nginx

 Ces manipulations sont à faire sur la jail

Comme nous l’avons déjà dit, la configuration de nginx est éclatée en deux parties. Nous avons déjà vu la configuration sur l’hôte, il nous reste à voir celle sur la jail, qui utilise le socket php-fpm.

Nous allons écouter sur le port 80, la gestion de https ayant été faite sur l’hôte. Nous allons faire en sorte que les flux soient compressés et nous allons servir les fichiers au travers de le socket déjà décrite.

Voici le fichier dans son intégralité :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
server {
        listen 80 default_server;
        #listen [::]:80 default_server;
        server_name pixelfed.exameple.com;

        keepalive_timeout    70;
        sendfile             on;

        gzip on;
        gzip_disable "msie6";
        gzip_vary on;
        gzip_proxied any;
        gzip_comp_level 6;
        gzip_buffers 16 8k;
        gzip_http_version 1.1;
        gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

        index index.php index.html;
        root /usr/local/www/pixelfed/public;

        location / {
                try_files $uri $uri/ /$is_args$args;
        }

        location ~ \.php$ {
                try_files $uri =404;
                #fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass unix:/var/run/php-fpm-pixelfed.sock;
                fastcgi_index index.php;
                include /usr/local/etc/nginx/fastcgi_params;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                #fastcgi_param PATH_INFO $fastcgi_path_info;
                #fastcgi_param HTTPS on;
        }
}

N’oublions pas le lien symbolique :

# cd /usr/local/etc/nginx/sites-enabled
# ln -s /usr/local/etc/nginx/sites-available/pixefed.conf

Nous pouvons, comme nous l’avons fait sur l’hôte, tester notre configuration et redémarrer (ou démarrer) nginx.

Ici le process nginx n’est utilisé que pour envoyer les fichiers .php vers le socket php-fpm que nous avons lancé plutôt.

Conclusion

Normalement en pointant votre navigateur sur l’url que vous avez choisie (https://pixelfed.example.com), vous devriez arriver sur la page principale de votre instance. Il est temps d’en apprendre plus, mais ça, je vous laisse le découvrir.