Ricerca nel sito web

Come installare Mastodon Social Network con Docker su Rocky Linux 9


Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa Docker e Docker Compose
  4. Passaggio 3 - Preparazione per l'installazione
  5. Passaggio 4 - Installa Mastodon
    1. Crea directory e imposta proprietà
    2. Crea l'ambiente e la finestra mobile compone i file
    3. Crea segreti dell'applicazione
    4. File ambiente Mastodon
    5. Prepara Mastodonte

    1. Strumento CLI Tootctl
    2. File di servizio Mastodonte
    3. Inizializza la ricerca
    4. Servizi di assistenza aggiuntivi
    5. Accedi a Mastodonte

    Mastodon è un social network gratuito, decentralizzato e open source. È stato creato come alternativa a Twitter. Proprio come su Twitter, le persone possono seguirsi a vicenda e pubblicare messaggi, immagini e video. Ma a differenza di Twitter, non esiste un archivio centrale o un'autorità per il contenuto.

    Invece, Mastodon opera su migliaia di server diversi, ciascuno gestito da vari membri della comunità. Gli utenti registrati su un server possono connettersi facilmente agli utenti sull'altra rete e seguirsi a vicenda attraverso le istanze.

    Chiunque può installare la propria istanza di un server Mastodon. Questo tutorial ti insegnerà come configurare la tua istanza di Mastodon su un server con Rocky Linux 9 utilizzando Docker. Docker semplifica l'installazione di Mastodon contenendo tutti i pacchetti e i servizi richiesti nei container.

    Prerequisiti

    • A server running Rocky Linux 9 with a minimum of 2 CPU cores and 2GB of memory. You will need to upgrade the server as per requirements.

    • A non-root user with sudo privileges.

    • A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use mastodon.example.com as the domain name.

    • Mastodon sends email notifications to users. We will recommend you use a 3rd party Transactional mail service like Mailgun, Sendgrid, Amazon SES, or Sparkpost. The instructions in the guide will be using Amazon SES.

    • Make sure everything is updated.

      $ sudo dnf update
      
    • Install basic utility packages. Some of them may already be installed.

      $ sudo dnf install wget curl nano unzip yum-utils -y
      

    Passaggio 1: configurare il firewall

    Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.

    $ sudo firewall-cmd --state
    running
    

    Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.

    $ sudo firewall-cmd --permanent --list-services
    

    Dovrebbe mostrare il seguente output.

    cockpit dhcpv6-client ssh
    

    Wiki.js ha bisogno delle porte HTTP e HTTPS per funzionare. Aprili.

    $ sudo firewall-cmd --permanent --add-service=http
    $ sudo firewall-cmd --permanent --add-service=https
    

    Aggiungi mascheramento, poiché l'applicazione contatterà altre istanze.

    $ sudo firewall-cmd --permanent --add-masquerade
    

    Ricarica il firewall per applicare le modifiche.

    $ sudo firewall-cmd --reload
    

    Passaggio 2: installa Docker e Docker Compose

    Rocky Linux viene fornito con una versione precedente di Docker. Per installare l'ultima versione, per prima cosa installa il repository Docker ufficiale.

    $ sudo yum-config-manager \
        --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
    

    Installa l'ultima versione di Docker.

    $ sudo dnf install docker-ce docker-ce-cli containerd.io
    

    È possibile che venga visualizzato il seguente errore durante il tentativo di installazione di Docker.

    ror: 
     Problem: problem with installed package buildah-1:1.26.2-1.el9_0.x86_64
      - package buildah-1:1.26.2-1.el9_0.x86_64 requires runc >= 1.0.0-26, but none of the providers can be installed
      - package containerd.io-1.6.9-3.1.el9.x86_64 conflicts with runc provided by runc-4:1.1.3-2.el9_0.x86_64
      - package containerd.io-1.6.9-3.1.el9.x86_64 obsoletes runc provided by runc-4:1.1.3-2.el9_0.x86_64
      - cannot install the best candidate for the job
    

    Utilizzare il seguente comando se si ottiene l'errore sopra.

    $ sudo dnf install docker-ce docker-ce-cli containerd.io docker-compose-plugin --allowerasing
    

    Abilita ed esegui il demone Docker.

    $ sudo systemctl enable docker --now
    

    Verificare che sia in esecuzione.

    ? docker.service - Docker Application Container Engine
         Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
         Active: active (running) since Sat 2022-11-12 00:19:44 UTC; 6s ago
    TriggeredBy: ? docker.socket
           Docs: https://docs.docker.com
       Main PID: 99263 (dockerd)
          Tasks: 8
         Memory: 28.1M
            CPU: 210ms
         CGroup: /system.slice/docker.service
                 ??99263 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
    

    Per impostazione predefinita, Docker richiede i privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente alla docker gruppo.

    $ sudo usermod -aG docker $(whoami)
    

    Sarà necessario disconnettersi dal server e riconnettersi come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.

    $ su - ${USER}
    

    Verifica che il tuo utente sia stato aggiunto al gruppo Docker.

    $ groups
    navjot wheel docker
    

    Passaggio 3: preparazione per l'installazione

    Il limite predefinito dei conteggi mmap è molto basso per Elasticsearch. Eseguire il comando seguente per verificare il valore predefinito.

    $ sysctl vm.max_map_count
    

    Otterrai il seguente output.

    vm.max_map_count = 65530
    

    Aumentare il valore utilizzando i seguenti comandi.

    $ echo "vm.max_map_count=262144" | sudo tee /etc/sysctl.d/90-max_map_count.conf
    $ sudo sysctl --load /etc/sysctl.d/90-max_map_count.conf
    

    Configura SELinux per consentire le connessioni di rete.

    $ sudo setsebool -P httpd_can_network_connect 1
    

    Passaggio 4: installa Mastodon

    Crea directory e imposta proprietà

    Crea directory per Mastodon e servizi correlati.

    $ sudo mkdir -p /opt/mastodon/database/{postgresql,pgbackups,redis,elasticsearch}
    $ sudo mkdir -p /opt/mastodon/web/{public,system}
    $ sudo mkdir -p /opt/mastodon/branding
    

    Imposta le proprietà appropriate per le directory Elasticsearch, Web e di backup.

    $ sudo chown 991:991 /opt/mastodon/web/{public,system}
    $ sudo chown 1000 /opt/mastodon/database/elasticsearch
    $ sudo chown 70:70 /opt/mastodon/database/pgbackups
    

    Passa alla directory Mastodon.

    $ cd /opt/mastodon
    

    Crea l'ambiente e la finestra mobile compone i file

    Creare file di ambiente per l'applicazione e il database.

    $ sudo touch application.env database.env
    

    Crea e apri il file di composizione Docker per la modifica.

    $ sudo nano docker-compose.yml
    

    Incolla il seguente codice al suo interno.

    version: '3'
    
    services:
      postgresql:
        image: postgres:15-alpine
        env_file: database.env
        restart: always
        shm_size: 512mb
        healthcheck:
          test: ['CMD', 'pg_isready', '-U', 'postgres']
        volumes:
          - postgresql:/var/lib/postgresql/data
          - pgbackups:/backups
        networks:
          - internal_network
    
      redis:
        image: redis:7-alpine
        restart: always
        healthcheck:
          test: ['CMD', 'redis-cli', 'ping']
        volumes:
          - redis:/data
        networks:
          - internal_network
    
      redis-volatile:
        image: redis:7-alpine
        restart: always
        healthcheck:
          test: ['CMD', 'redis-cli', 'ping']
        networks:
          - internal_network
    
      elasticsearch:
        image: docker.elastic.co/elasticsearch/elasticsearch:7.17.7
        restart: always
        env_file: database.env
        environment:
          - cluster.name=elasticsearch-mastodon
          - discovery.type=single-node
          - bootstrap.memory_lock=true
          - xpack.security.enabled=true
          - ingest.geoip.downloader.enabled=false
        ulimits:
          memlock:
            soft: -1
            hard: -1
        healthcheck:
          test: ["CMD-SHELL", "nc -z elasticsearch 9200"]
        volumes:
          - elasticsearch:/usr/share/elasticsearch/data
        networks:
          - internal_network
    
      website:
        image: tootsuite/mastodon:v4.0.2
        env_file:
          - application.env
          - database.env
        command: bash -c "bundle exec rails s -p 3000"
        restart: always
        depends_on:
          - postgresql
          - redis
          - redis-volatile
          - elasticsearch
        ports:
          - '127.0.0.1:3000:3000'
        networks:
          - internal_network
          - external_network
        healthcheck:
          test: ['CMD-SHELL', 'wget -q --spider --proxy=off localhost:3000/health || exit 1']
        volumes:
          - uploads:/mastodon/public/system
    
      shell:
        image: tootsuite/mastodon:v4.0.2
        env_file:
          - application.env
          - database.env
        command: /bin/bash
        restart: "no"
        networks:
          - internal_network
          - external_network
        volumes:
          - uploads:/mastodon/public/system
          - static:/static
    
      streaming:
        image: tootsuite/mastodon:v4.0.2
        env_file:
          - application.env
          - database.env
        command: node ./streaming
        restart: always
        depends_on:
          - postgresql
          - redis
          - redis-volatile
          - elasticsearch
        ports:
          - '127.0.0.1:4000:4000'
        networks:
          - internal_network
          - external_network
        healthcheck:
          test: ['CMD-SHELL', 'wget -q --spider --proxy=off localhost:4000/api/v1/streaming/health || exit 1']
    
      sidekiq:
        image: tootsuite/mastodon:v4.0.2
        env_file:
          - application.env
          - database.env
        command: bundle exec sidekiq
        restart: always
        depends_on:
          - postgresql
          - redis
          - redis-volatile
          - website
        networks:
          - internal_network
          - external_network
        healthcheck:
          test: ['CMD-SHELL', "ps aux | grep '[s]idekiq\ 6' || false"]
        volumes:
          - uploads:/mastodon/public/system
    
    networks:
      external_network:
      internal_network:
      	 #internal:true
    
    volumes:
      postgresql:
        driver_opts:
          type: none
          device: /opt/mastodon/database/postgresql
          o: bind
      pgbackups:
        driver_opts:
          type: none
          device: /opt/mastodon/database/pgbackups
          o: bind
      redis:
        driver_opts:
          type: none
          device: /opt/mastodon/database/redis
          o: bind
      elasticsearch:
        driver_opts:
          type: none
          device: /opt/mastodon/database/elasticsearch
          o: bind
      uploads:
        driver_opts:
          type: none
          device: /opt/mastodon/web/system
          o: bind
      static:
        driver_opts:
          type: none
          device: /opt/mastodon/web/public
          o: bind
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Al momento della stesura del tutorial, l'ultima versione disponibile di Mastodon è la v4.0.2. Controlla la pagina Mastodon GitHub Releases e regola la versione nel file di composizione Docker in modo appropriato. Utilizziamo anche le ultime versioni di PostgreSQL e Redis. Puoi regolarli secondo le tue esigenze. Al momento stiamo utilizzando Elasticsearch 7.x. Non esiste una versione principale di Elasticsearch che puoi seguire sulla pagina Docker Hub, quindi dovrai continuare ad aggiornarla manualmente per gli aggiornamenti di sicurezza relativi a Java.

    Quel internal: true non funziona con firewalld, motivo per cui è commentato nel file sopra. Se il problema viene risolto, potresti essere in grado di aggiungere nuovamente tale restrizione aggiuntiva.

    Creare segreti dell'applicazione

    Il passaggio successivo consiste nel creare i valori del segreto dell'applicazione.

    Genera i valori SECRET_KEY_BASE e OTP_SECRET eseguendo il seguente comando due volte. La prima volta ci vorrà del tempo perché tirerà le immagini.

    $ docker compose run --rm shell bundle exec rake secret
    

    Puoi anche usare l'utility openssl per lo stesso.

    $ openssl rand -hex 64
    

    Genera i valori VAPID_PRIVATE_KEY e VAPID_PUBLIC_KEY utilizzando il seguente comando.

    $ docker compose run --rm shell bundle exec rake mastodon:webpush:generate_vapid_key 
    

    Otterrai un risultato simile.

    VAPID_PRIVATE_KEY=u2qsCs5JdmdmMLnUuU0sgmFGvZedteJz-lFB_xF4_ac=
    VAPID_PUBLIC_KEY=BJXjE2hIXvFpo6dnHqyf1i-2PcP-cBoL95UCmhhxwlAgtFw_vnrYp4GBneR7_cmI9LZUYjHFh-TBAPSb9WTqH9A=
    

    Utilizza l'utility openssl per generare password PostgreSQL ed Elasticsearch.

    $ openssl rand -hex 15
    

    File di ambiente Mastodon

    Apri il file application.env per la modifica.

    $ sudo nano application.env
    

    Incolla le seguenti righe al suo interno.

    # environment
    RAILS_ENV=production
    NODE_ENV=production
    
    # domain
    LOCAL_DOMAIN=mastodon.example.com
    
    # redirect to the first profile
    SINGLE_USER_MODE=false
    
    # do not serve static files
    RAILS_SERVE_STATIC_FILES=false
    
    # concurrency
    WEB_CONCURRENCY=2
    MAX_THREADS=5
    
    # pgbouncer
    #PREPARED_STATEMENTS=false
    
    # locale
    DEFAULT_LOCALE=en
    
    # email, not used
    SMTP_SERVER=email-smtp.us-west-2.amazonaws.com
    SMTP_PORT=587
    SMTP_LOGIN=AKIA3FIG4NVFNSC3AHXE
    SMTP_PASSWORD=BHM4MVOjBmnGhSJ9lH3PAXKJ/9AiLWcUghG/kEN2kkFo
    
    
    # secrets
    SECRET_KEY_BASE=c09fa403575e0b431e54a2e228f20cd5a5fdfdbba0da80598959753b829a4e3c0266eedbac7e3cdf9f3345db36c56302c0e1bc5bfc8c5d516be59a2c41de7e37
    OTP_SECRET=febb7dbb0d3308094083733fc923a430e52ccec767d48d7d2e0c577bfcb6863dbdfc920b1004b1f8c2967b9866bd7a0b4a15460f9fc7687aa4a42acf54e5a3d4
    
    # Changing VAPID keys will break push notifications
    VAPID_PRIVATE_KEY=13RgrfOY2tkwuUycylDPOkoHennkJ0ZAPV_fUwDy7-g=
    VAPID_PUBLIC_KEY=BDAQuGwPbh1kbCV904adYXHvz9lLRaJHkiQkihRDPyBn3QmkAYbR21WHYoP8TkyG6dylG6IXpEVfLwdoW7fJVns=
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Apri il file database.env per la modifica.

    $ sudo nano database.env
    

    Incolla le seguenti righe al suo interno.

    # postgresql configuration
    POSTGRES_USER=mastodon
    POSTGRES_DB=mastodon
    POSTGRES_PASSWORD=15ff12dcb93aa60680d2aadb4032ee
    PGPASSWORD=15ff12dcb93aa60680d2aadb4032ee
    PGPORT=5432
    PGHOST=postgresql
    PGUSER=mastodon
    
    # pgbouncer configuration
    #POOL_MODE=transaction
    #ADMIN_USERS=postgres,mastodon
    #DATABASE_URL="postgres://mastodon::5432/mastodon"
    
    # elasticsearch
    ES_JAVA_OPTS=-Xms512m -Xmx512m
    ELASTIC_PASSWORD=13382e99f6b2d4dc7f3d66e4b9872d
    
    # mastodon database configuration
    #DB_HOST=pgbouncer
    DB_HOST=postgresql
    DB_USER=mastodon
    DB_NAME=mastodon
    DB_PASS=15ff12dcb93aa60680d2aadb4032ee
    DB_PORT=5432
    
    REDIS_HOST=redis
    REDIS_PORT=6379
    
    CACHE_REDIS_HOST=redis-volatile
    CACHE_REDIS_PORT=6379
    
    ES_ENABLED=true
    ES_HOST=elasticsearch
    ES_PORT=9200
    ES_USER=elastic
    ES_PASS=13382e99f6b2d4dc7f3d66e4b9872d
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Prepara il Mastodonte

    Prepara i file statici per essere serviti da Nginx.

    $ docker compose run --rm shell bash -c "cp -r /opt/mastodon/public/* /static/"
    

    Apri il livello dati.

    $ docker compose up -d postgresql redis redis-volatile
    

    Controlla lo stato dei contenitori.

    $ watch docker compose ps
    

    Attendi in esecuzione (integro), quindi premi Ctrl + C e inizializza il database utilizzando il seguente comando.

    $ docker compose run --rm shell bundle exec rake db:setup
    

    Passaggio 5: installa Nginx

    Rocky Linux viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.

    Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository Nginx ufficiale.

    $ sudo nano /etc/yum.repos.d/nginx.repo
    

    Incolla il seguente codice al suo interno.

    [nginx-stable]
    name=nginx stable repo
    baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
    gpgcheck=1
    enabled=1
    gpgkey=https://nginx.org/keys/nginx_signing.key
    module_hotfixes=true
    
    [nginx-mainline]
    name=nginx mainline repo
    baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
    gpgcheck=1
    enabled=0
    gpgkey=https://nginx.org/keys/nginx_signing.key
    module_hotfixes=true
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Installa il server Nginx.

    $ sudo dnf install nginx
    

    Verificare l'installazione.

    $ nginx -v
    nginx version: nginx/1.22.1
    

    Abilita e avvia il server Nginx.

    $ sudo systemctl enable nginx --now
    

    Controlla lo stato del server.

    $ sudo systemctl status nginx
    ? nginx.service - nginx - high performance web server
         Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
         Active: active (running) since Sun 2022-11-13 13:49:55 UTC; 1s ago
           Docs: http://nginx.org/en/docs/
        Process: 230797 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
       Main PID: 230798 (nginx)
          Tasks: 3 (limit: 12355)
         Memory: 2.8M
            CPU: 13ms
         CGroup: /system.slice/nginx.service
                 ??230798 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
                 ??230799 "nginx: worker process"
                 ??230800 "nginx: worker process"
    

    Passaggio 6: installa SSL

    Lo strumento Certbot genera certificati SSL utilizzando l'API Lets Encrypt. Richiede il repository EPEL per funzionare.

    $ sudo dnf install epel-release
    

    Useremo Snapd per installare Certbot. Installa Snapd.

    $ sudo dnf install snapd
    

    Abilita e avvia il servizio Snap.

    $ sudo systemctl enable snapd --now
    

    Installa il pacchetto principale di Snap.

    $ sudo snap install core
    $ sudo snap refresh core
    

    Crea i collegamenti necessari affinché Snapd funzioni.

    $ sudo ln -s /var/lib/snapd/snap /snap
    $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
    

    Immetti il seguente comando per installare Certbot.

    $ sudo snap install --classic certbot
    

    Abilita Certbot creando il link simbolico al suo eseguibile.

    $ sudo ln -s /snap/bin/certbot /usr/bin/certbot
    

    Genera il certificato SSL.

    $ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d mastodon.example.com
    

    Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/mastodon.example.com sul tuo server.

    Genera un certificato di gruppo Diffie-Hellman.

    $ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
    

    Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.

    $ sudo certbot renew --dry-run
    

    Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

    Passaggio 7: configurare Nginx

    Apri il file /etc/nginx/nginx.conf per la modifica.

    $ sudo nano /etc/nginx/nginx.conf
    

    Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

    server_names_hash_bucket_size  64;
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Crea e apri il file /etc/nginx/conf.d/mastodon.conf per la modifica.

    $ sudo nano /etc/nginx/conf.d/mastodon.conf
    

    Incolla il seguente codice al suo interno.

    map $http_upgrade $connection_upgrade {
      default upgrade;
      ''      close;
    }
    
    upstream backend {
        server 127.0.0.1:3000 fail_timeout=0;
    }
    
    upstream streaming {
        server 127.0.0.1:4000 fail_timeout=0;
    }
    
    proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=CACHE:10m inactive=7d max_size=1g;
    
    server {
      listen 80 default_server;
      server_name mastodon.example.com;
      location / { return 301 https://$host$request_uri; }
    }
    
    server {
       listen 443 ssl http2;
       server_name mastodon.example.com;
       
       access_log  /var/log/nginx/mastodon.access.log;
       error_log   /var/log/nginx/mastodon.error.log;
    
       http2_push_preload on; # Enable HTTP/2 Server Push
    
       ssl_certificate /etc/letsencrypt/live/mastodon.example.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/mastodon.example.com/privkey.pem;
       ssl_trusted_certificate /etc/letsencrypt/live/mastodon.example.com/chain.pem;
       ssl_session_timeout 1d;
    
       # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
       ssl_protocols TLSv1.2 TLSv1.3;
    
       # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
       # prevent replay attacks.
       #
       # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
       ssl_early_data on;
    
       ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
       ssl_prefer_server_ciphers on;
       ssl_session_cache shared:SSL:10m;
       ssl_session_tickets off;
       
       keepalive_timeout    70;
       sendfile             on;
       client_max_body_size 80m;
    
       # OCSP Stapling ---
       # fetch OCSP records from URL in ssl_certificate and cache them
       ssl_stapling on;
       ssl_stapling_verify on;
       ssl_dhparam /etc/ssl/certs/dhparam.pem;
    
       add_header X-Early-Data $tls1_3_early_data;
       
       root /opt/mastodon/web/public;
       
       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 image/svg+xml image/x-icon;
       
       add_header Strict-Transport-Security "max-age=31536000" always;
    
      location / {
        try_files $uri @proxy;
      }
    
      location ~ ^/(system/accounts/avatars|system/media_attachments/files) {
        add_header Cache-Control "public, max-age=31536000, immutable";
        add_header Strict-Transport-Security "max-age=31536000" always;
        root /opt/mastodon/;
        try_files $uri @proxy;
      }
    
      location ~ ^/(emoji|packs) {
        add_header Cache-Control "public, max-age=31536000, immutable";
        add_header Strict-Transport-Security "max-age=31536000" always;
        try_files $uri @proxy;
      }
    
      location /sw.js {
        add_header Cache-Control "public, max-age=0";
        add_header Strict-Transport-Security "max-age=31536000" always;
        try_files $uri @proxy;
      }
    
      location @proxy {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Proxy "";
        proxy_pass_header Server;
    
        proxy_pass http://backend;
        proxy_buffering on;
        proxy_redirect off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    
        proxy_cache CACHE;
        proxy_cache_valid 200 7d;
        proxy_cache_valid 410 24h;
        proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
        add_header X-Cached $upstream_cache_status;
        add_header Strict-Transport-Security "max-age=31536000" always;
    
        tcp_nodelay on;
      }
    
      location /api/v1/streaming {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Proxy "";
    
        proxy_pass http://streaming;
        proxy_buffering off;
        proxy_redirect off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    
        tcp_nodelay on;
      }
    
      error_page 500 501 502 503 504 /500.html;
    }
    
    # This block is useful for debugging TLS v1.3. Please feel free to remove this
    # and use the `$ssl_early_data` variable exposed by NGINX directly should you
    # wish to do so.
    map $ssl_early_data $tls1_3_early_data {
      "~." $ssl_early_data;
      default "";
    }
    

    Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.

    Verificare la sintassi del file di configurazione Nginx.

    $ sudo nginx -t
    nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
    nginx: configuration file /etc/nginx/nginx.conf test is successful
    

    Riavvia il server Nginx.

    $ sudo systemctl restart nginx
    

    Se ricevi il seguente errore, molto probabilmente è dovuto alle restrizioni di SELinux.

    nginx: [emerg] open() "/var/run/nginx.pid" failed (13: Permission denied)
    

    Per correggere l'errore, eseguire i seguenti comandi.

    $ sudo ausearch -c 'nginx' --raw | audit2allow -M my-nginx
    $ sudo semodule -X 300 -i my-nginx.pp
    

    Riavvia il servizio Nginx.

    $ sudo systemctl start nginx
    

    Passaggio 8: avviare Mastodon

    Strumento CLI Tootctl

    Lo strumento CLI Tootctl viene utilizzato per eseguire attività amministrative su Mastodon. Dobbiamo renderlo accessibile sulla shell host.

    Crea il file /usr/local/bin/tootctl e aprilo per modificarlo.

    $ sudo nano /usr/local/bin/tootctl
    

    Incolla il seguente codice al suo interno.

    #!/bin/bash
    docker compose -f /opt/mastodon/docker-compose.yml run --rm shell tootctl ""
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Concedi al file l'autorizzazione eseguibile.

    $ sudo chmod +x /usr/local/bin/tootctl
    

    File di servizio Mastodonte

    È possibile avviare i contenitori Mastodon utilizzando il comando Docker Compose, ma è più semplice da eseguire tramite un file unit systemd.

    Crea e apri il file di servizio Mastodon per la modifica.

    $ sudo nano /etc/systemd/system/mastodon.service
    

    Incolla il seguente codice al suo interno.

    [Unit]
    Description=Mastodon service
    After=docker.service
    
    [Service]
    Type=oneshot
    RemainAfterExit=yes
    
    WorkingDirectory=/opt/mastodon
    ExecStart=/usr/bin/docker compose -f /opt/mastodon/docker-compose.yml up -d
    ExecStop=/usr/bin/docker compose -f /opt/mastodon/docker-compose.yml down
    
    [Install]
    WantedBy=multi-user.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Ricarica il demone di sistema per avviare il file di servizio.

    $ sudo systemctl daemon-reload
    

    Abilita e avvia il servizio Mastodon.

    $ sudo systemctl enable --now mastodon.service
    

    Controlla lo stato dei container Docker.

    $ watch docker compose -f /opt/mastodon/docker-compose.yml ps
    

    Una volta che lo stato dei contenitori cambia in in esecuzione (integro), esci dalla schermata premendo Ctrl + C.

    Crea l'utente amministratore per Mastodon e annota la password fornita.

    $ tootctl accounts create navjot --email  --confirmed --role admin
    OK
    New password: 1338afbe1b4e06e823b6625da80cb537
    

    Se vuoi chiudere le registrazioni degli utenti, usa il seguente comando.

    $ tootctl settings registrations close
    

    Per aprire nuovamente le registrazioni, immetti il seguente comando.

    $ tootctl settings registrations open
    

    Inizializza ricerca

    Dovrai fare un toot prima di poter creare e popolare gli indici Elasticsearch. Una volta che hai fatto un toot, dai il seguente comando.

    $ tootctl search deploy
    

    Potresti ricevere il seguente errore.

    /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:76:in `total=': You can't set the item's total value to less than the current progress. (ProgressBar::InvalidProgressError)
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:178:in `block in update_progress'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:43:in `with_refresh'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:177:in `update_progress'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:101:in `total='
            from /opt/mastodon/lib/mastodon/search_cli.rb:67:in `deploy'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/command.rb:27:in `run'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/invocation.rb:127:in `invoke_command'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor.rb:392:in `dispatch'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/invocation.rb:116:in `invoke'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor.rb:243:in `block in subcommand'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/command.rb:27:in `run'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/invocation.rb:127:in `invoke_command'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor.rb:392:in `dispatch'
            from /opt/mastodon/vendor/bundle/ruby/3.0.0/gems/thor-1.2.1/lib/thor/base.rb:485:in `start'
            from /opt/mastodon/bin/tootctl:8:in `<main>'
    

    In questo caso, entra nella shell del contenitore del sito web.

    $ docker exec -it mastodon-web-1 /bin/bash
    

    Eseguire il seguente comando.

    $ sed -E 's/indices.sum.+/2000/g' -i lib/mastodon/search_cli.rb
    

    Uscire dalla shell del contenitore.

    $ exit
    

    Eseguire di nuovo il comando Elasticsearch deploy.

    $ tootctl search deploy
    

    Ulteriori servizi di supporto

    Creiamo un altro servizio per rimuovere i file multimediali scaricati.

    Crea e apri il servizio di rimozione dei media Mastodon per la modifica.

    $ sudo nano /etc/systemd/system/mastodon-media-remove.service
    

    Incolla il seguente codice al suo interno.

    [Unit]
    Description=Mastodon - media remove service
    Wants=mastodon-media-remove.timer
    
    [Service]
    Type=oneshot
    StandardError=null
    StandardOutput=null
    
    WorkingDirectory=/opt/mastodon
    ExecStart=/usr/bin/docker compose -f /opt/mastodon/docker-compose.yml run --rm shell tootctl media remove
    
    [Install]
    WantedBy=multi-user.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Se desideri programmare la rimozione del supporto, puoi impostare un servizio timer per esso.

    $ sudo nano /etc/systemd/system/mastodon-media-remove.timer
    

    Incolla il seguente codice.

    [Unit]
    Description=Schedule a media remove every week
    
    [Timer]
    Persistent=true
    OnCalendar=Sat *-*-* 00:00:00
    Unit=mastodon-media-remove.service
    
    [Install]
    WantedBy=timers.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Puoi configurare un altro servizio per rimuovere le schede Rich Preview generate utilizzando i tag OpenGraph.

    $ sudo nano /etc/systemd/system/mastodon-preview_cards-remove.service
    

    Incolla il seguente codice.

    [Unit]
    Description=Mastodon - preview cards remove service
    Wants=mastodon-preview_cards-remove.timer
    
    [Service]
    Type=oneshot
    StandardError=null
    StandardOutput=null
    
    WorkingDirectory=/opt/mastodon
    ExecStart=/usr/bin/docker compose -f /opt/mastodon/docker-compose.yml run --rm shell tootctl preview_cards remove
    
    [Install]
    WantedBy=multi-user.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Impostare il servizio timer corrispondente.

    $ sudo nano /etc/systemd/system/mastodon-preview_cards-remove.timer
    

    Incolla il seguente codice.

    [Unit]
    Description=Schedule a preview cards remove every week
    
    [Timer]
    Persistent=true
    OnCalendar=Sat *-*-* 00:00:00
    Unit=mastodon-preview_cards-remove.service
    
    [Install]
    WantedBy=timers.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Ricarica il demone di sistema.

    $ sudo systemctl daemon-reload
    

    Abilita e avvia i timer.

    $ sudo systemctl enable --now mastodon-preview_cards-remove.timer
    $ sudo systemctl enable --now mastodon-media-remove.timer
    

    Elenca tutti i timer per controllare il programma dei servizi Mastodon.

    $ systemctl list-timers
    

    Accedi a Mastodonte

    Visita l'URL https://mastodon.example.com per accedere alla tua istanza e vedrai una pagina simile.

    Nello screenshot sopra, puoi vedere che ci sono 2 utenti e 1 di loro (io) è impostato come amministratore. Questo di solito non è il caso. Anche se crei un account amministratore, non viene visualizzato nella pagina principale alla prima esecuzione. Per farlo, accedi alla tua istanza e verrai indirizzato alla pagina seguente.

    Fare clic sull'opzione Preferenze dalla barra laterale destra per accedere alle impostazioni. Da lì, fai clic sull'opzione Amministrazione dal menu a sinistra per accedere al pannello di amministrazione di Mastodons.

    Fai clic sull'opzione Impostazioni sito dalla barra laterale sinistra.

    Qui, inserisci il tuo nome utente di contatto e l'e-mail aziendale che ora si rifletterà sulla home page del tuo server. Inserisci anche varie altre informazioni tra cui la descrizione del server, il logo e le regole del server per personalizzare la tua istanza Mastodon.

    Passaggio 9: manutenzione del mastodonte

    Per visualizzare le prestazioni e i log della tua istanza Mastodon, vai su https://mastodon.example.com/sidekiq/.

    Qui puoi visualizzare un elenco di vari processi e attività pianificate relative alla tua istanza Mastodon. Puoi anche controllare le attività non riuscite nella sezione Dead or Retries. Ti dirà anche l'utilizzo della memoria della tua istanza.

    Puoi controllare l'integrità del database delle tue istanze da https://mastodon.example.com/pghero/.

    È possibile eseguire la manutenzione del database, eseguire query SQL e rimuovere gli indici inutilizzati. Per abilitare le statistiche sulle query, fai clic sul pulsante Abilita nella pagina sopra e otterrai le seguenti informazioni.

    Passa all'utente root.

    $ sudo -i su
    

    Passa alla directory /opt/mastodon/database/postgresql.

    $ cd /opt/mastodon/database/postgresql
    

    Apri il file postgresql.conf.

    $ nano postgresql.conf
    

    Trova la riga #shared_preload_libraries=# (la modifica richiede il riavvio) e sostituiscila con la seguente.

    shared_preload_libraries = 'pg_stat_statements'
    

    Aggiungere la riga seguente alla fine del file.

    pg_stat_statements.track = all
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Riavvia i contenitori Mastodon.

    $ systemctl restart mastodon.service
    

    Uscire dalla shell di root.

    $ exit
    

    Se controlli la pagina dello stato del database, puoi vedere se ci sono query lente ora.

    Nota: puoi anche avviare gli URL PgHero e Sidekiq dal menu Preferenze.

    Se il tuo sito non si carica per qualche motivo, puoi controllare i log generati da Docker.

    $ docker logs <container-name>
    

    Passaggio 10: eseguire il backup di Mastodonte

    Useremo uno strumento di terze parti chiamato Restic per il backup di Mastodon. Il primo passo per eseguire il backup utilizzando Restic è aggiungere tutti i file e le directory all'elenco dei repository.

    Creare e aprire il file dell'elenco dei repository per la modifica.

    $ sudo nano /opt/mastodon/backup-files
    

    Incolla le seguenti righe al suo interno.

    /etc/nginx
    /etc/letsencrypt
    /etc/systemd/system
    /root
    /opt/mastodon/database/pgbackups
    /opt/mastodon/*.env
    /opt/mastodon/docker-compose.yml
    /opt/mastodon/branding
    /opt/mastodon/database/redis
    /opt/mastodon/web/system
    /opt/mastodon/backup-files
    /opt/mastodon/mastodon-backup
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Installa Restico.

    $ sudo dnf install restic
    

    Crea un repository di backup e crea il backup iniziale. Stiamo eseguendo il backup dei nostri dati sul servizio S3.

    $ restic -r s3:https://$SERVER:$PORT/mybucket init
    $ restic -r s3:https://$SERVER:$PORT/mybucket backup $(cat /opt/mastodon/backup-files) --exclude  /opt/mastodon/database/postgresql
    

    Crea un timer del servizio di backup Mastodon e aprilo per la modifica.

    $ sudo nano /etc/systemd/system/mastodon-backup.timer
    

    Incolla il seguente codice al suo interno.

    [Unit]
    Description=Schedule a mastodon backup every hour
    
    [Timer]
    Persistent=true
    OnCalendar=*:00:00
    Unit=mastodon-backup.service
    
    [Install]
    WantedBy=timers.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Crea un file del servizio di backup Mastodon e aprilo per la modifica.

    $ sudo nano /etc/systemd/system/mastodon-backup.service
    

    Incolla il seguente codice al suo interno.

    [Unit]
    Description=Mastodon - backup service
    # Without this, they can run at the same time and race to docker compose,
    # double-creating networks and failing due to ambiguous network definition
    # requiring `docker network prune` and restarting
    After=mastodon.service
    
    [Service]
    Type=oneshot
    StandardError=file:/var/log/mastodon-backup.err
    StandardOutput=file:/var/log/mastodon-backup.log
    
    WorkingDirectory=/opt/mastodon
    ExecStart=/bin/bash /opt/mastodon/mastodon-backup
    
    [Install]
    WantedBy=multi-user.target
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Successivamente, crea e apri il file /opt/mastodon/mastodon-backup per la modifica. Questo contiene i comandi di backup effettivi.

    $ sudo nano /opt/mastodon/mastodon-backup
    

    Incolla il seguente codice al suo interno.

    #!/bin/bash
    
    set -e
    
    AWS_ACCESS_KEY_ID=
    AWS_SECRET_ACCESS_KEY=
    SERVER=
    PORT=
    RESTIC_PASSWORD_FILE=/root/restic-pasword
    
    docker compose -f /opt/mastodon/docker-compose.yml run --rm postgresql sh -c "pg_dump -Fp  mastodon | gzip > /backups/dump.sql.gz"
    restic -r s3:https://$SERVER:$PORT/mybucket --cache-dir=/root backup $(cat /opt/mastodon/backup-files) --exclude  /opt/mastodon/database/postgresql
    restic -r s3:https://$SERVER:$PORT/mybucket --cache-dir=/root forget --prune --keep-hourly 24 --keep-daily 7 --keep-monthly 3
    

    Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

    Concedere autorizzazioni eseguibili allo script di backup.

    $ sudo chmod +x /opt/mastodon/mastodon-backup
    

    Ricarica il demone del servizio e avvia il servizio di backup e il timer.

    $ sudo systemctl daemon-reload
    $ sudo systemctl enable --now mastodon-backup.service
    $ sudo systemctl enable --now mastodon-backup.timer
    

    Verificare che i backup orari siano in corso e accessibili utilizzando i seguenti comandi.

    $ restic -r s3:https://$SERVER:$PORT/mybucket snapshots
    $ restic -r s3:https://$SERVER:$PORT/mybucket mount /mnt
    

    Passaggio 11: aggiorna Mastodon

    L'aggiornamento di Mastodon richiede diversi passaggi. Innanzitutto, passa alla directory.

    $ cd /opt/mastodon
    

    Estrai le ultime immagini del container per Mastodon.

    $ docker compose pull
    

    Apporta eventuali modifiche in docker-compose.yml se lo desideri.

    Eseguire tutte le migrazioni del database.

    $ docker compose run --rm shell bundle exec rake db:migrate
    

    Aggiorna le tue copie dei file statici.

    $ docker compose run --rm shell bash -c "cp -r /opt/mastodon/public/* /static/"
    

    Riavvia i contenitori Mastodon.

    $ sudo systemctl restart mastodon.service
    

    Le istruzioni di cui sopra sono istruzioni di aggiornamento generiche. Controlla sempre la pagina delle versioni di GitHub di Mastodon per cercare attività e comandi di aggiornamento specifici tra le versioni per assicurarti che tutto vada liscio.

    Conclusione

    Questo conclude il nostro tutorial sull'installazione di Mastodon Social Network utilizzando Docker su un server Rocky Linux 9. Se hai domande, pubblicale nei commenti qui sotto.