spla

de vegades escric

En la primera part vam veure els primers passos. En aquesta entrada veurem els finals:

  • instal·lar nginx
  • obtenir un certificat SSL
  • clonar Pleroma
  • instal·lar el gestor de versions Elixir/Erlang asdf

Instal·lar nginx

No té cap misteri, com a root:

apt install nginx

Activem la unitat systemd per a assegurar que quan engeguem la nostre Raspberry (si és que la parem mai) també s'iniciï nginx i iniciem nginx ara mateix:

systemctl enable nginx && systemctl start nginx

Confirmem que tenim nginx en marxa:

systemctl status nginx

En una de les línies hem de veure que diu “active”.

Obtenir certificat SSL

Si volem federar amb tot el fedivers, el domini de l'instància Pleroma que estem muntant ha de ser accessible sí o sí de manera segura amb el protocol https. Ens cal obtenir un certificat. Si no tenim instal·lat el paquet certbot fem-ho ara:

apt install certbot

Com a root, obtenim el certificat per a nginx així:

certbot certonly -d aarch.ddns.net —standalone

Es queixarà d'aquest problema perquè tenim nginx en marxa:

Problem binding to port 80: Could not bind to IPv4 or IPv6.

Parem nginx i tornem a provar-ho:

systemctl stop nginx
certbot certonly -d aarch.ddns.net —standalone

Si certbot ens dona l'error Timeout during connect (likely firewall problem) és perquè tenim el firewall amb els ports 80 i 443 tancats. Si el firewall és ufw els obrim així de fàcil:

ufw allow 'Nginx Full'

Tornem a provar:

certbot certonly -d aarch.ddns.net —standalone

Si tot ha anat bé ho sabrem:

Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/aarch.ddns.net/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/aarch.ddns.net/privkey.pem

Ja podem configurar nginx per dir-li on tenim el certificat. La configuració per a nginx de Pleroma hauria de ser a /etc/nginx/sites-available/pleroma.conf. Doncs la editem i assegurem tenir aquestes dues línies que diuen on trobar els certificat obtinguts:

sslcertificate /etc/letsencrypt/live/aarch.ddns.net/fullchain.pem; sslcertificate_key /etc/letsencrypt/live/aarch.ddns.net/privkey.pem;

Desem els canvis i enllaçament la configuració en el directori sites-enabled per a que nginx la tingui en compte:

ln -s /etc/nginx/sites-available/pleroma.conf /etc/nginx/sites-enabled/pleroma.conf

Ara assegurem que a nginx li agrada:

nginx -t

Si respon test is succesful ja podem reiniciar nginx per a que la carregui:

systemctl restart nginx

Clonar Pleroma

Encara no hem creat l'usuari pleroma:

useradd -r -s /bin/false -m -d /var/lib/pleroma -U pleroma

Creem el directori on clonarem Pleroma i fem propietari al usuari pleroma:

mkdir -p /opt/pleroma
chown -R pleroma:pleroma /opt/pleroma

I com a usuari pleroma clonem la darrera versió estable des d'el repositori:

sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma

instal·lar asdf i compilar Pleroma

Un problema potencial quan instal·lem els paquets Elixir i Erlang amb el gestor de paquets del sistema operatiu és que una actualització d'aquests paquets pot provocar que la nostra flamant instància Pleroma deixi de funcionar (ha passat amb diverses instàncies del fedivers). Per evitar això és una bona idea instal·lar el gestor de versions asdf.

Canviem al directori i al usuari pleroma:

cd /opt/pleroma
sudo -Hu pleroma bash

Ara hem de crear un nou fitxer anomenat .tool-versions, on posarem les versions d'Elixir i Erlang que volem per al nostra Pleroma:

elixir 1.11 erlang 23.3.4

Desem els canvis i clonem asdf des de la font. La darrera versió estable en el moment d'escriure aquesta entrada és la v0.10.2:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf —branch v0.10.2

Ara afegim a .bashrc les rutes adients:

echo “. $HOME/.asdf/asdf.sh” >> ~/.bashrc echo “. $HOME/.asdf/completions/asdf.bash” >> ~/.bashrc

I les carreguem amb:

exec bash

El següent pas és carregar els dos plugins, tant de Elixir com de Erlang:

asdf plugin-add erlang
asdf plugin-add elixir

Instal·lem i compilem tot plegat (trigarà uns quants minuts, paciència):

asdf install

Pot donar algun error xxxx is missing... no passa res, calma. Si et diu Erlang/OTP 23.3.4 (asdf_23.3.4) has been successfully built vol dir que tot ha anat bé i podem continuar.

Executem línia a línia els passos següents per a compilar Pleroma:

mix local.hex —force mix local.rebar —force mix deps.get MIX_ENV=prod mix compile

Quan hagi acabat veurem Generated pleroma app. Ara cal que generem la configuració de l'instància:

MIX_ENV=prod mix pleroma.instance gen

Anem responem a totes les preguntes que ens fa, la primera i més important és el domini, en aquest cas és aarch.ddns.net. Quan acabi haurà generat la configuració a config/generated_config.exs. L'hem de moure a config/prod.secret.exs:

mv config/{generated_config.exs,prod.secret.exs}

Ara toca crear la base de dades Postgresql. Sortim del usuari pleroma i encara dins de /opt/pleroma, com a root fem:

sudo -Hu postgres psql -f config/setup_db.psql

Tornem al usuari pleroma i executem ecto.migrate per a crear totes les taules de la base de dade:

MIX_ENV=prod mix ecto.migrate

Altre cop com a root, copiem l'unitat systemd al lloc adient:

cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service

Editem l'unitat systemd, comentant la línia que diu ExecStart=/usr/bin/mix phx.serveri afegint a sota les dues línies que veiem a continuació:

;ExecStart=/usr/bin/mix phx.server Environment=“PATH=/var/lib/pleroma/.asdf/shims:/var/lib/pleroma/.asdf/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin” ExecStart=/var/lib/pleroma/.asdf/shims/mix phx.server

Recarreguem els canvis amb systemctl daemon-reload i ja podem posar en marxa la nostra flamant instància Pleroma:

systemctl enable pleroma && systemctl start pleroma

Amb el navegador ja podem visitar l'instància Pleroma!

Ep! un moment! voldràs fer-te admin suposo!

sudo -Hu pleroma bash MIXENV=prod mix pleroma.user new <nomusuari> —admin

La segona línia et genera un enllaç per a establir la contrasenya del usuari admin que has creat.

Ja està! A gaudir de la teva sobirania digital!

Hi ha diversos proveïdors de serveis #DDNS que ens permeten poder accedir remotament a la nostre Raspberry on hi podem tenir instal·lats serveis com ara Nextcloud, Akkoma (servidor social fork de Pleroma) etc. Això és possible gràcies a que aquests proveïdors de DDNS apunten a la IP pública de la Raspberry quan escrivim en el navegador el domini que hi hem escollit. Sempre és millor no dependre de tercers així que aquest és el motiu per el que escric aquesta entrada.

requisits

Ens cal tenir registrat un domini propi i que el registrador del domini ens permeti fer delegació de DNS. També ens cal tenir el nostre propi servidor DNS (Bind9), que gràcies a la delegació passarà a ser el servidor autoritari per el nostre domini.
Suposem que el nostre domini registrat és elnostredomini.cat i el subdomini que apuntarà a la Raspberry és raspberry.elnostredomini.cat.

dnssec

El més segur és que a casa tinguem IP dinàmica (si no és així aquest article no té sentit) per tant ens caldrà enviar-la periòdicament al nostre servidor #DNS Bind9. Entra en joc #dnssec. dnssec farà una connexió segura al nostre Bind9 i actualitzarà el registre del domini o subdomini que li diguem. El primer pas és crear la dnssec key:

ddns-confgen -s raspberry.elnostredomini.cat

Ens respondrà això:

To activate this key, place the following in named.conf, and in a separate keyfile on the system or systems from which nsupdate will be run: key “ddns-key.raspberry.elnostredomini.cat” { algorithm hmac-sha256; secret “lLeySmmWp2TrF0qSlSyblQOp7wTTNxWoDkFYUaTyGtk=”; };

Then, in the “zone” statement for the zone containing the name “raspberry.elnostredomini.cat”, place an “update-policy” statement like this one, adjusted as needed for your preferred permissions: update-policy { grant ddns-key.raspberry.elnostredomini.cat name raspberry.elnostredomini.cat ANY; };

After the keyfile has been placed, the following command will execute nsupdate using this key: nsupdate -k

Editem /etc/bind/named.conf.local i hi afegim la key:

... key “ddns-key.raspberry.elnostredomini.cat” { algorithm hmac-sha256; secret “lLeySmmWp2TrF0qSlSyblQOp7wTTNxWoDkFYUaTyGtk=”; };

zone “elnostredomini.cat” { type master; file “/var/lib/bind/db.elnostredomini.cat”; update-policy { grant ddns-key.elnostredomini.cat name elnostredomini.cat. ANY; }; }; ...

Reiniciem el servidor Bind9:

systemctl restart bind9

configurar el client

Ara hem de crear el fitxer que contingui la key generada, per exemple a /etc/ddnsupdate.key, on la hi posem:

key “ddns-key.raspberry.elnostredomini.cat” { algorithm hmac-sha256; secret “lLeySmmWp2TrF0qSlSyblQOp7wTTNxWoDkFYUaTyGtk=”; };

I també hem de crear el bash script que s'executarà periòdicament, enviant la IP pública al nostre servidor DNS Bind9, actualitzant si cal el registre del subdomini raspberry.elnostredomini.cat. Per exemple /usr/local/bin/ddnsupdate:

#!/bin/bash

MYIP=$(dig +short myip.opendns.com @resolver1.opendns.com)

KEY=/etc/ddnsupdate.key NS=ns1.elnostredomini.cat DOMAIN=raspberry.elnostredomini.cat. ZONE=elnostredomini.cat.

nsupdate -k $KEY -v << EOF server $NS zone $ZONE update delete $DOMAIN A update add $DOMAIN 30 A $MYIP send EOF

El fem executable:

chmod +x /usr/local/bin/ddnsupdate

Afegim una tasca cron perquè volem que l'script bash s'executi periòdicament:

crontab -e

i afegim la tasca en qüestió:

... */5 * * * * /usr/local/bin/ddnsupdate > /dev/null 2>&1 ...

Ja estem.

El sistema operatiu de la meva Raspberry és Ubuntu 20.04 LTS (GNU/Linux 5.4.0-1065-raspi aarch64). Aquests passos funcionen perfectament en totes les Raspberrys que corrin el mateix sistema operatiu però haurien de servir també per a les que utilitzin Raspbian.

Els passos resumits son aquests:

  • configurar un hostname en un servei DDNS
  • instal·lar el programa DUC en la Raspberry per a informar al servei DDNS de la seva IP pública
  • Fer un “Port Forwarding” en el router de casa dels ports 80 i 443, per a que apuntin a la IP local de la Raspberry
  • Instal·lar nginx
  • Obtenir certificat SSL per el hostname obtingut del servei DDNS
  • Instal·lar Pleroma

Configurar un hostname en el servei DDNS.

Abans de tot ens cal un servei #DDNS (Dynamic DNS) per a crear el hostname del nostre servidor Pleroma. Ho necessitem perquè volem que la nostra instància Pleroma sigui accessible des d'internet. Configurarem un hostname en el nostre servei DDNS, per exemple a noip però n'hi ha d'altres, i aquest servei DDNS serà qui resoldrà aquest hostname a la IP pública de la Raspberry.
noip ens permet obtenir gratuïtament un sol hostname (suficient!), on només podem escriure el nom de subdomini per a un dels quatre dominis disponibles. En el meu cas vaig escollir el domini “ddns.net” amb el subdomini, escrit per mi, “aarch”: aarch.ddns.net

Instal·lar el Dynamic Update Client (DUC) en la Raspi.

Com que el més segur és que a casa tinguem IP dinàmica, la Raspberry haurà de informar al servei DDNS de quina IP pública té. Per a fer tal cosa haurem de seguir les instruccions necessàries per a instal·lar el programa DUC.
Descarreguem el client DUC a la nostre PI, en el directori /usr/local/src/

Com a root:

cd /usr/local/src/

descarreguem DUC:

wget http://www.noip.com/client/linux/noip-duc-linux.tar.gz

el descomprimim:

tar xf noip-duc-linux.tar.gz

entrem en el directori creat al descomprimir:

cd noip-2.1.9-1/

i executem:

make install

Ens demanarà iniciar sessió en el nostre compte de noip, doncs li donem usuari i contrasenya. Seguint com a usuari root, crearem la configuració per defecte de DUC:

/usr/local/bin/noip2 -C

Ens demanarà altre cop l'usuari i contrasenya del compte a noip. Si ara executem

/usr/local/bin/noip2

ja hauria d'enviar la IP pública al servei DDNS de noip. Evidentment no és bona idea haver d'executar-ho manualment per tant ens anirà d'allò més bé un servei systemd que ho executi automàticament al engegar la Raspberry o desprès d'un reinici pel motiu que sigui.
Creem el servei noip2.service:

vim /etc/systemd/system/noip2.service

amb el següent contingut:

[Unit] Description=noip2 service

[Service] Type=forking ExecStart=/usr/local/bin/noip2 Restart=always

[Install] WantedBy=default.target

Desem els canvis. Com que volem que s'activi al engegar o reiniciar-se la Raspberry, activem el servei:

systemctl enable noip2.service

i l'iniciem ara mateix:

systemctl start noip2.service.

Podem saber si tot va bé consultant l'estat:

systemctl status noip2.service

Port Forwarding

Per a que Pleroma funcioni perfectament ens cal que totes les peticions d'altres servidors del #fedivers que vagin cap el nostre node es dirigeixin a la Raspberry. Aquestes peticions es fan a dos ports TCP, el 80 (http) i el 443 (https). La sol·lució a això es diu Port Forwarding. Hauriem de poder accedir al router principal de casa (el que ens dona o lloga el nostre proveïdor d'internet). Normalment la IP del router és 192.168.1.1, des d'el navegador visitem aquesta IP. Si ens demana usuari i contrasenya el més probable és que les tinguem escrites en una etiqueta enganxada en la part inferior del router. Un cop dins del router cerquem l'opció “Port Forwarding” o “Redireccionar puertos”. I afegim dues redireccions, una per el port 80 i la segona per el port 443. Tots els routers son pràcticament iguals, per a fer un “Port Forwarding” acostumen a demanar-nos:

Service name < hi posem http Port Range < 80 Local IP < la IP local de la Raspberry (ha de ser IP fixa, no serveix que la obtingui via DHCP des d'el router), per exemple 192.168.1.3 Local Port < 80 Protocol < TCP

Apliquem/desem la primera redirecció i afegim la segona:

Service name < hi posem https Port Range < 443 Local IP < la IP local de la Raspberry (ha de ser IP fixa, no serveix que la obtingui via DHCP des d'el router), per exemple 192.168.1.3 Local Port < 443 Protocol < TCP

Apliquem/desem el canvis i ja podem tancar sessió del router. Ja tenim preparats tant la Raspberry com el nostre router. En la segona part veurem com instal·lar nginx, obtenir un certificat SSL per el nostre flamant nom de domini que apuntarà a la nostra instància #Pleroma i, a la fi, instal·lar Pleroma.

En la primera entrada deia com van anar les proves en un servidor dedicat i disc dur convencional, amb una conclusió clara: no es pot renderitzar tessel·les amb disc dur mecànic. Doncs el primer intent d'importació del mapa del planeta sencer en un servidor VPS i disc dur SSD no ha funcionat. M'he trobat el procés parat amb un “killed”. Mirant el log syslog del sistema trobo el motiu, un “Out of memory”:

kernel: [392548.151678] Out of memory: Killed process 968 (osm2pgsql) total-vm:35032344kB, anon-rss:33595356kB, file-rss:0kB, shmem-rss:0kB, UID:109 pgtables:66244kB oomscoreadj:0

Cercant informació, en aquesta pàgina diuen clarament que la millor manera d'evitar quedar-te sense memòria és importar el mapa fent servir el paràmetre “—flat-nodes”.
Provem-ho. He esborrat la base de dades gis i la he creat de nou per a iniciar l'importació fent servir “—flat-nodes”. Veurem si tindré per fí èxit però per ara va molt més ràpid, amb un ritme deu vegades millor:

Reading in file: /home/osm/planet-latest.osm.pbf Using PBF parser. Processing: Node(4667810k 915.4k/s) Way(0k 0.00k/s) Relation(0 0.00/s)

Veurem...

Altre cop el mateix error, un “killed” degut a “Out of memory”. Ho torno a provar, ara sense el paràmetre “-C 32000”, o sigui, no li defineixo la memòria cau per a que agafi la que necessiti.

Veurem...

Èxit!

Osm2pgsql took 188133s overall Mid: removing persistent node cache at /home/osm/nodes.cache node cache: stored: 100039713(1.31%), storage efficiency: 95.40% (dense blocks: 11631, sparse nodes: 4790528), hit rate: 1.32%

Sense definir la memòria cau ha funcionat! 52 hores, 15 minuts i 32 segons és el temps total necessari, en un disc dur SSD i amb '—flat-nodes'. Següent pas.

Un cop tot muntat segueixo patint errors de renderd quan faig zoom. Torno a començar de zero però seguint les instruccions d'un altre pàgina. Veurem...

L'importació planetària a la base de dades #gis ha acabat. La vaig iniciar amb aquest paràmetres:

osm2pgsql -d gis —create —slim -G —hstore —tag-transform-script ~/src/openstreetmap-carto/openstreetmap-carto.lua —number-processes 10 -S ~/src/openstreetmap-carto/openstreetmap-carto.style ~/data/planet-latest.osm.pbf.

Ha acabat aquesta matinada amb aquests resultats, ocupant 1,7 dels 2TB de disc dur SSD disponibles:

node cache: stored: 100039713(1.31%), storage efficiency: 95.40% (dense blocks: 11631, sparse nodes: 4790528), hit rate: 1.32%. osm2pgsql took 886292s (246h 11m 32s) overall.

#WriteFreely és un programari que permet crear i publicar blogs amb #Markdown. No es queda aquí, si es configura per a permetre la federació, totes les entrades que hi publiquem seran enviades a tots els comptes del #fedivers que segueixin el nostre compte WriteFreely. I encara més, es poden esmentar usuaris del fedivers de la mateixa manera que ho fem a Mastodon o Pleroma.
Per a instal·lar aquest programari que, com veiem, promet molt, descarreguem la darrera versió, en el meu cas la v0.13.1:

export WFVER=0.13.1 wget https://github.com/writeas/writefreely/releases/download/v$WFVER/writefreely_${WFVER}_linux_amd64.tar.gz

Ara descomprimim el fitxer tar.gz en el directori writefreely del usuari local que vulguem, habitualment l'usuari és 'writefreely', si és el nostre cas, substituïm $USER per writefreely:

adduser $USER

tar -C /home/$USER/ -xzf writefreely${WFVER}linux_amd64.tar.gz

Abans de canviar al usuari writefreely i configurar el programari cal crear la base de dades necessària:

mysql -u root

CREATE DATABASE writefreely CHARACTER SET latin1 COLLATE latin1swedishci;

Si no hem creat ja l'usuari de mysql ara és el moment:

MariaDB [(none)]> create user 'writefreely'@'localhost' identified by 'contrasenya';
MariaDB [(none)]> grant all privileges on writefreely.* to 'writefreely'@'localhost';
MariaDB [(none)]> flush privileges;
MariaDB [(none)]> exit;

Canviem al usuari 'writefreely' amb 'su – writefreely' i entrem al directori on hem descomprimit abans el fitxer.:

cd writefreely

Configurem la nostra flamant instància WriteFreely, donant-li les dades que ens demana:

~/writefreely$ ./writefreely config start ~/writefreely$ ./writefreely keys generate

Si executem writefreely ja hauria de funcionar:

~/writefreely$ ./writefreely

El ideal és servir el nostre blog darrera d'un proxy com #nginx. En la pàgina oficial tenim un exemple de com configurar-lo. També ens cal afegir el servei systemd per a que l'engegui. En la mateix pàgina amb l'exemple de la configuració de nginx tenim un exemple del writefreely.service per a systemd.

A escriure!

En teoria es poden esmentar usuaris del #fedivers des de #WriteFreely. @spla@mastodont.cat

Després de temps pensant que havia de fer-ho, el passat 19 de març del 2019 vaig començar el procés. La màquina escollida corre Ubuntu 20.04 i les instruccions a seguir les d'aquesta pàgina. La idea és tenir una replica del servidor de OpenStreetMap, pàgina que inclou un servidor de tessel·les i un servidor Nominatim que permet fer cerques de ciutats, pobles etc per el seu nom. La part més feixuga del procés és el de l'importació de les dades del planeta sencer a la base de dades Gis. En un disc dur convencional (és l'autèntic coll d'ampolla d'aquest projecte, més avall dic perquè) ha trigat 3.611.989 segons, o sigui, 41 dies, 19 minuts i 19 segons, i la base de dades Gis ocupa (alerta) més de 1,5 Terabytes dels 2TB que té. Seguint els passos següents arribo al punt de màxima excitació, el de veure el mapa global i fer-hi zoom. Primer problema i insalvable, el dimoni renderd dona errors... D'acord, lliçó apresa. No es poden renderitzar tessel·les en temps real si la base de dades #gis del planeta sencer la tens en un disc dur convencional, és massa lent i només fa que donar errors:

renderd process Failed to send render cmd on fd x renderd send error: Inappropriate ioctl for device

Aquí he entés perquè recomanen un SSD en la pàgina d'instruccions. Cal, sí o sí, un disc dur SSD de 2TB com a mínim. El meu projecte de tenir un servidor de tessel·les de #OpenStreetMap queda en suspens degut aquest problema tècnic. Però sóc tossut, ho torno a provar des de zero, esborro la base de dades (més de 41 dies de feina esborrats en pocs segons) i començo l'importació però “només” de Europa, pensant que amb menys tessel·les sí que podré fer zoom sense errors de renderd.

osm2pgsql took 831506s (230h 58m 26s) overall

9 dies, 14 hores, 58m i 26 segons ha trigat en importar les dades del mapa d'Europa a la base de dades gis. I em dona els mateixos errors de renderd. Ja toca deixar-ho estar. No havia après la lliçó? Torno a començar de zero, aquest cop amb un disc dur SSD de 2TB! A veure quan trigarà però en un dia ja ha acabat d'importar els “nodes” i ja està important els “Way”. Seguiré en una propera entrada...

He instal·lat Writefreely seguint les instruccions d'aquest enllaç. La impressió inicial és millor que la de Plume (per exemple, té mode fosc) i he confirmat que federa a la primera. Qualsevol programari que no federi avui en dia no és res. He configurat el registre inicialment tancat però si veig que la seva funcionalitat és bona l'obriré. En el fedivers hi ha ja 426 servidors i més de 59.000 usuaris en nodes Writefreely, cosa que demostra que té bona acceptació. No he vist que es pugui configurar en català, no sé si és possible, he d'investigar.