Come installare la piattaforma di social network Pleroma su Ubuntu 20.04

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa PostgreSQL
Passaggio 3 - Installa Nginx
Passaggio 4 - Installa Pleroma
Passaggio 5 - Configura Pleroma
Passaggio 6 - Installa SSL utilizzando Lets Encrypt
Passaggio 7 - Configura Nginx
Passaggio 8 - Configura Pleroma
1. Crea un utente amministratore
2. Modifica delle impostazioni
3. Aggiornamento Pleroma
4. Backup del Pleroma
5. Ripristino del Pleroma
Pleroma è una piattaforma di social networking federata open source, compatibile con Mastodon e altre piattaforme ActivityPub. Fa parte del Fediverse, una rete federata di istanze in grado di comunicare utilizzando un protocollo comune. Un singolo account su un'istanza può comunicare con l'intera rete Fediverse.
Questa guida ti mostrerà come creare la tua istanza Pleroma installandola su un server basato su Ubuntu 20.04.
Prerequisiti
- A server running Ubuntu 20.04.
- A non-root sudo user.
- Make sure everything is updated.
```
$ sudo apt update
$ sudo apt upgrade
```
- Few packages and dependencies that you need before installing Pleroma.
```
$ sudo apt install wget curl gnupg2 ca-certificates lsb-release gnupg zip libncurses5 libmagic-dev -y
```
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.
Controlla se il firewall è in esecuzione.
```
$ sudo ufw status
```
Dovresti ottenere il seguente output.
```
Status: inactive
```
Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.
```
$ sudo ufw allow OpenSSH
```
Consenti anche porte HTTP e HTTPS.
```
$ sudo ufw allow 80
$ sudo ufw allow 443
```
Abilita il firewall
```
$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
```
Controlla di nuovo lo stato del firewall.
```
$ sudo ufw status
```
Dovresti vedere un output simile.
```
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80                         ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80 (v6)                    ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)
```
Passaggio 2: installa PostgreSQL

Aggiungi il repository PostgreSQL ufficiale all'elenco delle fonti di Ubuntu.
```
$ sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
```
Aggiungi la chiave GPG del repository.
```
$ wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```
Aggiorna l'elenco dei pacchetti di sistema.
```
$ sudo apt update
```
Passaggio 3: installa Nginx
Ubuntu 20.04 viene fornito con la versione stabile di Nginx 18 per impostazione predefinita.
```
$ sudo apt install nginx
```
Passaggio 4: installare Pleroma
Questa guida installa Pleroma da una versione OTP. Il primo passo è creare un utente Pleroma senza capacità di accesso. Creerà anche la sua home directory in /opt/pleroma.
```
$ sudo adduser --system --shell  /bin/false --home /opt/pleroma pleroma
```
Passa all'utente Pleroma. Ma prima dobbiamo passare all'utente root.
```
$ sudo su
$ su pleroma -s $SHELL -l
```
Scarica Pleroma in una posizione temporanea.
```
$ curl "https://git.pleroma.social/api/v4/projects/2/jobs/artifacts/stable/download?job=amd64" -o /tmp/pleroma_amd64.zip
```
Decomprimere l'archivio.
```
$ unzip /tmp/pleroma_amd64.zip -d /tmp/
```
Installa Pleroma.
```
$ mv /tmp/release/* /opt/pleroma
```
Elimina i file temporanei.
```
$ rm -rf /tmp/pleroma_amd64.zip /tmp/release
```
Passa all'utente root.
```
$ exit
```
Crea directory per i caricamenti e i file pubblici.
```
$ mkdir -p /var/lib/pleroma/{uploads,static}
```
Crea la directory per la configurazione di Pleroma.
```
$ mkdir -p /etc/pleroma
```
Cambia la proprietà delle directory Pleroma all'utente Pleroma.
```
$ chown -R pleroma /var/lib/pleroma /etc/pleroma
```
Passaggio 5: configurare Pleroma
Torna all'utente Pleroma.
```
$ su pleroma -s /bin/bash -l
```
Eseguire il comando seguente per generare il file di configurazione per l'istanza Pleroma.
```
$ ./bin/pleroma_ctl instance gen --output /etc/pleroma/config.exs --output-psql /tmp/setup_db.psql
```
Ti verranno poste diverse domande sulla configurazione di Pleroma. Se ricevi un avviso che indica che non è stato possibile trovare il file di configurazione, ignoralo.
```
:~$ ./bin/pleroma_ctl instance gen --output /etc/pleroma/config.exs --output-psql /tmp/setup_db.psql
!!! /etc/pleroma/config.exs not found! Please ensure it exists and that PLEROMA_CONFIG_PATH is unset or points to an existing file

What domain will your instance use? (e.g pleroma.soykaf.com) [] example.com

What is the name of your instance? (e.g. The Corndog Emporium) [nspeaks.com] Howtoforge Pleroma
What is your admin email address? [] 
What email address do you want to use for sending email notifications? [] <Press Enter>
Do you want search engines to index your site? (y/n) [y] y
Do you want to store the configuration in the database (allows controlling it from admin-fe)? (y/n) [n] n
What is the hostname of your database? [localhost] localhost
What is the name of your database? [pleroma] pleroma
What is the user used to connect to your database? [pleroma] pleroma
What is the password used to connect to your database? [autogenerated] yourpassword
Would you like to use RUM indices? [n] n
What port will the app listen to (leave it if you are using the default setup with nginx)? [4000] <Press Enter>
What ip will the app listen to (leave it if you are using the default setup with nginx)? [127.0.0.1] <Press Enter>
What directory should media uploads go in (when using the local uploader)? [/var/lib/pleroma/uploads] <Press Enter>
What directory should custom public files be read from (custom emojis, frontend bundle overrides, robots.txt, etc.)? [/var/lib/pleroma/static] <Press Enter>
Do you want to strip location (GPS) data from uploaded images? This requires exiftool, it was detected as not installed, please install it if you answer yes. (y/n) [n] n
Do you want to anonymize the filenames of uploads? (y/n) [n] n
Do you want to deduplicate uploaded files? (y/n) [n] y
Writing config to /etc/pleroma/config.exs.
Writing the postgres script to /tmp/setup_db.psql.
Writing /var/lib/pleroma/static/robots.txt.

 All files successfully written! Refer to the installation instructions for your platform for next steps.
```
È possibile scegliere un diverso set di opzioni a seconda delle proprie esigenze. Scegli una password sicura per il tuo database. Se desideri configurare la tua istanza dal Pannello di amministrazione, seleziona y per la domanda sull'archiviazione della configurazione nel database.
Passa all'utente PostgreSQL predefinito che è stato creato durante l'installazione di PostgreSQL.
```
$ exit
$ su postgres -s /bin/bash -l
```
Creare il database utilizzando il file SQL fornito da Pleroma.
```
$ psql -f /tmp/setup_db.psql
```
Torna all'utente Pleroma.
```
$ exit
$ su pleroma -s /bin/bash -l
```
Inizializza il database che abbiamo appena creato.
```
$ ./bin/pleroma_ctl migrate
```
Esci all'utente root.
```
$ exit
```
Passaggio 6: installa SSL utilizzando Lets Encrypt
Per installare un certificato SSL utilizzando Lets Encrypt, dobbiamo scaricare lo strumento Certbot.
Per installare Certbot, utilizzeremo il programma di installazione del pacchetto Snapd. Il repository ufficiale di Certbots è stato deprecato e il pacchetto Ubuntus Certbot ha più di un anno. Snapd porta sempre con sé l'ultima versione stabile di Certbot e dovresti usarla. Fortunatamente, Ubuntu 20.04 viene fornito con Snapd preinstallato.
Assicurati che la tua versione di Snapd sia aggiornata.
```
$ snap install core 
$ snap refresh core
```
Rimuovi tutte le vecchie versioni di Certbot.
```
$ apt remove certbot
```
Installa Cerbot.
```
$ snap install --classic certbot
```
Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
```
$ ln -s /snap/bin/certbot /usr/bin/certbot
```
Arresta il servizio Nginx.
```
$ systemctl stop nginx
```
Genera un certificato SSL.
```
$ certbot certonly --standalone --preferred-challenges http -d example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.
Crea una directory radice Web di verifica per il rinnovo automatico di Lets Encrypt.
```
$ mkdir -p /var/lib/letsencrypt
```
Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, per prima cosa, crea il file /etc/cron.daily/certbot-renew e aprilo per modificarlo.
```
$ nano /etc/cron.daily/certbot-renew
```
Incolla il seguente codice.
```
#!/bin/sh
certbot renew --cert-name example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Modificare le autorizzazioni sul file dell'attività per renderlo eseguibile.
```
$ chmod +x /etc/cron.daily/certbot-renew
```
Passaggio 7: configurare Nginx
Pleroma viene fornito con un file di configurazione Nginx predefinito. Installalo spostandolo nella directory /etc/nginx/sites-available.
```
$ mv /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.conf
```
Sostituisci tutte le occorrenze di example.tld con il tuo dominio.
```
$ sed -i 's/example\.tld/example.com/g' /etc/nginx/sites-available/pleroma.conf
```
Apri il file di configurazione per la modifica.
```
$ nano /etc/nginx/sites-available/pleroma.conf
```
Rimuovere il commento dal blocco location ~ /\.well-known/acme-challenge. Il blocco server del tuo file di configurazione dovrebbe essere simile al seguente.
```
server {
    server_name    example.com;

    listen         80;
    listen         [::]:80;

    location ~ /\.well-known/acme-challenge {
        root /var/lib/letsencrypt/;
    }

    location / {
        return         301 https://$server_name$request_uri;
    }
}
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Abilita la configurazione di Pleroma Nginx creando un collegamento simbolico.
```
$ ln -s /etc/nginx/sites-available/pleroma.conf /etc/nginx/sites-enabled/pleroma.conf
```
Abilita il server Nginx per avviarlo all'avvio.
```
$ systemctl enable nginx.
```
Avvia il server Nginx.
```
$ systemctl start nginx
```
Installa il file dell'unità di servizio Pleroma systemd fornito nella distribuzione.
```
$ mv /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service
```
Abilitare e avviare il servizio Pleroma.
```
$ systemctl enable pleroma
$ systemctl start pleroma
```
Potrebbero essere necessari circa 30 secondi prima che il sito Pleroma diventi disponibile. Ora puoi aprire https://example.com nel tuo browser web per visitare Pleroma. Dovrebbe essere simile al seguente.
Passaggio 8: configurare Pleroma
Crea un utente amministratore
È possibile creare un utente amministrativo tramite la riga di comando. Passa prima all'utente Pleroma.
```
$ su pleroma -s /bin/bash -l
```
Crea un utente amministratore. Sostituisci example con il tuo nome utente, [email con il tuo indirizzo email e password123 con una password sicura.
```
$ ./bin/pleroma_ctl user new example  --password password123 --admin
```
Torna all'utente root una volta che hai finito.
```
$ exit
```
Modifica delle impostazioni
Se hai selezionato no come risposta per l'archiviazione della configurazione nel database, significa che non puoi modificare le impostazioni dal pannello Amministrazione di Pleroma. Per cambiare le impostazioni, dovrai modificare il file /etc/pleroma/config.exs.
```
$ nano /etc/pleroma/config.exs
```
Una volta terminata la modifica del file, sarà necessario riavviare anche il servizio Pleroma. Potrebbe essere necessario attendere un po' di tempo prima che il servizio venga ripristinato.
```
$ systemctl restart pleroma
```
Aggiornamento Pleroma
Per aggiornare Pleroma, il primo passo è scaricare la nuova versione. Eseguire il seguente comando per scaricare la nuova versione di Pleroma.
```
$ su pleroma -s $SHELL -lc "./bin/pleroma_ctl update"
```
Arresta l'istanza di Pleroma.
```
$ systemctl stop pleroma
```
Il passaggio successivo consiste nel migrare il database.
```
$ su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate"
```
Avvia l'istanza Pleroma.
```
$ systemctl start pleroma
```
Sostenere Pleroma
Fermare il servizio Pleroma.
```
$ systemctl stop pleroma
```
Passa alla directory Pleromas.
```
$ cd /opt/pleroma
```
Eseguire il seguente comando per eseguire il backup del database.
```
$ sudo -Hu postgres pg_dump -d <pleroma_db> --format=custom -f </path/to/backup_location/pleroma.pgdump>
```
Copia i file pleroma.pgdump, config/prod.secret.exs, config/setup_db.sql e i upload cartella nella destinazione di backup.
Ricomincia il servizio Pleroma.
```
$ systemctl start pleroma
```
Ripristino del pleroma
Per ripristinare Pleroma, devi reinstallare Pleroma e assicurarti che il servizio Pleroma non funzioni.
Quindi copiare i file di cui è stato eseguito il backup nella posizione originale.
Eliminare il database e l'utente esistenti utilizzando il seguente comando.
```
$ sudo -Hu postgres psql -c 'DROP DATABASE <pleroma_db>;';` `sudo -Hu postgres psql -c 'DROP USER <pleroma_db>;'
```
Ripristina lo schema del database e il ruolo Pleroma Postgres con il file setup_db.sql di cui è stato eseguito il backup.
```
$ sudo -Hu postgres psql -f config/setup_db.psql
```
Successivamente, ripristina i dati delle istanze Pleroma.
```
$ sudo -Hu postgres pg_restore -d <pleroma_db> -v -1 </path/to/backup_location/pleroma.pgdump>
```
Migrare il database se sono rimaste migrazioni da eseguire nel caso in cui si stia passando a una versione più recente.
```
$ su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate"
```
Riavvia il servizio Pleroma.
```
$ systemctl restart pleroma
```
Genera le statistiche in modo che Postgres possa pianificare correttamente le query.
```
$ sudo -Hu postgres vacuumdb --all --analyze-in-stages
```
Conclusione
Questo conclude il nostro tutorial sull'installazione della piattaforma di social network Pleroma su un server basato su Ubuntu 20.04. Se hai domande o feedback, pubblicali nei commenti qui sotto.

Come installare la piattaforma di social network Pleroma su Ubuntu 20.04

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa PostgreSQL

Passaggio 3: installa Nginx

Passaggio 4: installare Pleroma

Passaggio 5: configurare Pleroma

Passaggio 6: installa SSL utilizzando Lets Encrypt

Passaggio 7: configurare Nginx

Passaggio 8: configurare Pleroma

Crea un utente amministratore

Modifica delle impostazioni

Aggiornamento Pleroma

Sostenere Pleroma

Ripristino del pleroma

Conclusione