Come installare Ampache Music Streaming Server su Fedora 33

Su questa pagina

Prerequisiti
Configura firewall
Installa Git
Installa MariaDB
Configura MariaDB per Ampache
Installa PHP
1. Installa le estensioni PHP
2. Configura PHP-FPM
Ampache è un'applicazione di streaming audio personale basata sul Web open source scritta in PHP. Ti consente di ospitare e gestire la tua raccolta di musica digitale sul tuo server e di trasmetterla in streaming al tuo computer, smartphone, tablet o smart TV. Puoi utilizzare varie applicazioni iOS per trasmettere la tua musica dal tuo server musicale Ampache ai tuoi dispositivi personali.
Questo tutorial spiegherà come installare l'applicazione Ampache su un server basato su Fedora 33 e come caricare musica su di esso per lo streaming.
Prerequisiti
- A server running Fedora 33.
- A non-root sudo user.
- Make sure everything is updated.
```
$ sudo dnf upgrade
```
- Few packages that your system needs.
```
$ sudo dnf install wget curl nano zip -y
```
- Disable SELinux.
```
$ sudo setenforce 0
```
Configura firewall
Il primo passo è configurare il firewall. Il server Fedora viene fornito con Firewalld preinstallato.
Controlla se il firewall è in esecuzione.
```
$ sudo firewall-cmd --state
```
Dovresti ottenere il seguente output.
```
running
```
Imposta la zona predefinita del firewall su pubblica.
```
$ sudo firewall-cmd --set-default-zone=public
```
Controlla gli attuali servizi/porte consentiti.
```
$ sudo firewall-cmd --zone=public --permanent --list-services
```
Dovrebbe mostrare il seguente output.
```
dhcpv6-client mdns ssh
```
Consenti porte HTTP e HTTPS.
```
$ sudo firewall-cmd --zone=public --permanent --add-service=http
$ sudo firewall-cmd --zone=public --permanent --add-service=https
```
Controlla di nuovo lo stato del firewall.
```
$ sudo firewall-cmd --zone=public --permanent --list-services
```
Dovresti vedere un output simile.
```
dhcpv6-client http https mdns ssh
```
Ricarica il firewall.
```
$ sudo systemctl reload firewalld
```
Installa Git
Prima di procedere, dobbiamo installare Git.
```
$ sudo dnf install git
```
Successivamente, configura Git con i tuoi dati personali.
```
$ git config --global user.name "Your Name"
$ git config --global user.email ""
```
Installa MariaDB
MariaDB è un sostituto immediato di MySQL, il che significa che i comandi per eseguire e far funzionare MariaDB sono gli stessi di MySQL.
Fedora 33 per impostazione predefinita viene fornito con MariaDB 10.4 bur poiché MariaDB 10.5 è l'ultima versione stabile, per questo utilizzeremo il repository MariaDB ufficiale.
Crea il file /etc/yum.repos.d/MariaDB.repo e aprilo per modificarlo.
```
$ sudo nano /etc/yum.repos.d/MariaDB.repo
```
Incolla il seguente codice al suo interno.
```
# MariaDB 10.5 Fedora repository list
# http://downloads.mariadb.org/mariadb/repositories/
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.5/fedora33-amd64
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1
```
Salva e chiudi il file premendo Ctrl + X e immettendo Y quando richiesto.

Per installare MariaDB, immetti il seguente comando.
```
$ sudo dnf install MariaDB-server -y
```
Assicurati di digitare MariaDB-server nel comando precedente e non mariadb-server poiché il primo lo installerà dal repository ufficiale mentre il secondo comando installerà la versione precedente da Repository Fedora.
Controlla se MariaDB è installato correttamente.
```
$ mysql --version
```
Dovresti vedere il seguente output.
```
mysql  Ver 15.1 Distrib 10.5.9-MariaDB, for Linux (x86_64) using  EditLine wrapper
```
Abilita e avvia il servizio MariaDB.
```
$ sudo systemctl enable mariadb
$ sudo systemctl start mariadb
```
Eseguire il seguente comando per eseguire la configurazione predefinita, ad esempio fornire una password root, rimuovere utenti anonimi, impedire l'accesso root in remoto e eliminare le tabelle di test.
```
$ sudo mysql_secure_installation
```
Con MariaDB 10.4, ora ti verrà chiesto se usare la password di root o il plugin unix_socket. Il plug-in ti consente di accedere a MariaDB con le tue credenziali utente Linux. È considerato più sicuro anche se avrai bisogno di un nome utente/password tradizionale per utilizzare app di terze parti come phpMyAdmin. Continueremo a utilizzare il plug-in per questo tutorial. Puoi ancora utilizzare phpMyAdmin tramite qualsiasi utente specifico che crei per i tuoi database.
Premendo Invio si sceglie l'opzione predefinita (quella in maiuscolo, Y in questo caso).
```
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!

In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.

Enter current password for root (enter for none): [PRESS ENTER]
OK, successfully used password, moving on...

Setting the root password or using the unix_socket ensures that nobody
can log into the MariaDB root user without the proper authorisation.

You already have your root account protected, so you can safely answer 'n'.

Switch to unix_socket authentication [Y/n] [PRESS ENTER]
Enabled successfully!
Reloading privilege tables..
 ... Success!

You already have your root account protected, so you can safely answer 'n'.

Change the root password? [Y/n] [ANSWER n]
... skipping.

By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

Remove anonymous users? [Y/n] [PRESS ENTER]
 ... Success!

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] [PRESS ENTER]
 ... Success!

By default, MariaDB comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] [PRESS ENTER]
 \- Dropping test database...
 ... Success!
 \- Removing privileges on test database...
 ... Success!

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] [PRESS ENTER]
 ... Success!

Cleaning up...

All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.

Thanks for using MariaDB!
```
Questo è tutto. La prossima volta che vuoi accedere a MySQL, usa il seguente comando
```
$ sudo mysql
```
Inserisci la tua password di root quando richiesto.
Configura MariaDB per Ampache
Ora dobbiamo impostare un database da utilizzare per l'applicazione Ampache. Per farlo, accedi al prompt di MySQL.
```
$ sudo mysql
```
Una volta al prompt, immetti i seguenti comandi che imposteranno un database denominato ampache e un utente del database denominato ampuser e gli concederanno l'accesso al database.
```
mysql> CREATE DATABASE ampache;
mysql> CREATE USER 'ampuser'@'localhost' IDENTIFIED BY 'yourpassword';
mysql> GRANT ALL PRIVILEGES ON ampache.* TO 'ampuser'@'localhost';
mysql> exit
```
Installa PHP
Fedora 33 per impostazione predefinita viene fornito con PHP 7.4 ma per avere un repository PHP aggiornato, aggiungeremo il repository REMI.
Installa il repository REMI che è il repository ufficiale di Fedora per l'installazione dei pacchetti PHP.
```
$ sudo dnf -y install https://rpms.remirepo.net/fedora/remi-release-33.rpm
```
Installa PHP 7.4 come modulo.
```
$ sudo dnf module install php:remi-7.4
```
Controlla se PHP funziona correttamente.
```
$ php --version
```
Dovresti vedere un output simile.
```
PHP 7.4.16 (cli) (built: Mar  2 2021 10:35:17) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
```
Installa le estensioni PHP
Ampache ha bisogno di poche estensioni PHP. Utilizzare il seguente comando per installarli.
```
sudo dnf install php-curl php-gd php-intl php-mysql
```
Configura PHP-FPM
Apri il file /etc/php-fpm.d/www.conf.
```
$ sudo nano /etc/php-fpm.d/www.conf
```
Dobbiamo impostare l'utente/gruppo Unix di processi PHP su nginx. Trova le righe user=apache e group=apache nel file e modificale in nginx.
```
...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
...
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Successivamente, dobbiamo aumentare la dimensione del file per i caricamenti di musica nel file /etc/php.ini. Apri il file per la modifica.
```
$ sudo nano /etc/php.ini
```
Modifica le seguenti righe
```
. . .
post_max_size = 8M
. . .
upload_max_filesize = 2M
```
a
```
. . .
post_max_size = 110M
. . .
upload_max_filesize = 100M
. . .
```
Ora puoi caricare file di dimensioni fino a 100 MB. Puoi cambiare il valore in qualsiasi cosa tu voglia. Assicurati solo che post_max_size sia maggiore della variabile upload_max_filesize.
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Riavvia il processo PHP-fpm.
```
$ sudo systemctl restart php-fpm
```
Installa Nginx
Fedora 33 per impostazione predefinita viene fornito con l'ultima versione stabile di Nginx. (1.18.0).
Installa Nginx.
```
$ sudo dnf install nginx -y
```
Controlla se funziona correttamente.
```
$ nginx -v
```
Dovresti vedere il seguente output a seconda della versione di Nginx che hai scelto di installare.
```
nginx version: nginx/1.18.0
```
Avvia e abilita Nginx.
```
$ sudo systemctl start nginx
$ sudo systemctl enable nginx
```
Apri l'indirizzo IP del tuo server in un browser per vedere la pagina seguente. Significa che Nginx funziona correttamente.
Configura Nginx
Imposta le directory in cui risiederanno i blocchi del server.
```
$ sudo mkdir /etc/nginx/sites-available
$ sudo mkdir /etc/nginx/sites-enabled
```
Apri il file /etc/nginx/nginx.conf per la modifica.
```
$ sudo nano /etc/nginx/nginx.conf	
```
Incolla le seguenti righe dopo la riga include /etc/nginx/conf.d/*.conf
```
include /etc/nginx/sites-enabled/*.conf;
server_names_hash_bucket_size 64;
```
Premi Ctrl + X per chiudere l'editor e premi Y quando ti viene chiesto di salvare il file.
Eseguire il seguente comando per aggiungere un file di configurazione per Ampache.
```
$ sudo nano /etc/nginx/sites-available/ampache.conf
```
Incolla il seguente codice nell'editor.
```
server {

    # listen to
    listen  [::]:80;
    listen       80;

    server_name ampache.example.com;
    charset utf-8;

    # Logging, error_log mode [notice] is necessary for rewrite_log on,
    # (very usefull if rewrite rules do not work as expected)

    error_log       /var/log/nginx/ampache.error.log; # notice;
    access_log      /var/log/nginx/ampache.access.log;
    # rewrite_log     on;

    # Use secure headers to avoid XSS and many other things
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Robots-Tag none;
    add_header X-Download-Options noopen;
    add_header X-Permitted-Cross-Domain-Policies none;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header Referrer-Policy "no-referrer";
    add_header Content-Security-Policy "script-src 'self' 'unsafe-inline' 'unsafe-eval'; frame-src 'self'; object-src 'self'";

    # Avoid information leak
    server_tokens off;
    fastcgi_hide_header X-Powered-By;

    root /var/www/html/ampache;
    index index.php;
    client_max_body_size 100m;

    # Somebody said this helps, in my setup it doesn't prevent temporary saving in files
    proxy_max_temp_file_size 0;

    # Rewrite rule for Subsonic backend
    if ( !-d $request_filename ) {
        rewrite ^/rest/(.*).view$ /rest/index.php?action=$1 last;
        rewrite ^/rest/fake/(.+)$ /play/$1 last;
    }

    # Rewrite rule for Channels
    if (!-d $request_filename){
      rewrite ^/channel/([0-9]+)/(.*)$ /channel/index.php?channel=$1&target=$2 last;
    }

    # Beautiful URL Rewriting
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&name=$5 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&name=$6 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&player=$6&name=$7 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/bitrate/([0-9]+)/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&bitrate=$6player=$7&name=$8 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/transcode_to/(w+)/bitrate/([0-9]+)/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&transcode_to=$6&bitrate=$7&player=$8&name=$9 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/noscrobble/([0-1])/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&noscrobble=$6&name=$7 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/noscrobble/([0-1])/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&noscrobble=$6&player=$7&name=$8 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/noscrobble/([0-1])/bitrate/([0-9]+)/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&noscrobble=$6&bitrate=$7player=$8&name=$9 last;
    rewrite ^/play/ssid/(\w+)/type/(\w+)/oid/([0-9]+)/uid/([0-9]+)/client/(.*)/noscrobble/([0-1])/transcode_to/(w+)/bitrate/([0-9]+)/player/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4&client=$5&noscrobble=$6&transcode_to=$7&bitrate=$8&player=$9&name=$10 last;

    # the following line was needed for me to get downloads of single songs to work
    rewrite ^/play/ssid/(.*)/type/(.*)/oid/([0-9]+)/uid/([0-9]+)/action/(.*)/name/(.*)$ /play/index.php?ssid=$1&type=$2&oid=$3&uid=$4action=$5&name=$6 last;
    location /play {
        if (!-e $request_filename) {
			rewrite ^/play/art/([^/]+)/([^/]+)/([0-9]+)/thumb([0-9]*)\.([a-z]+)$ /image.php?object_type=$2&object_id=$3&auth=$1 last;
        }

		rewrite ^/([^/]+)/([^/]+)(/.*)?$ /play/$3?$1=$2;
		rewrite ^/(/[^/]+|[^/]+/|/?)$ /play/index.php last;
		break;
    }

   location /rest {
      limit_except GET POST {
         deny all;
      }
   }

   location ^~ /bin/ {
      deny all;
      return 403;
   }

   location ^~ /config/ {
      deny all;
      return 403;
   }

   location / {
      limit_except GET POST HEAD{
         deny all;
      }
   }

   location ~ ^/.*.php {
        fastcgi_index index.php;

        # sets the timeout for requests in [s] , 60s are normally enough
        fastcgi_read_timeout 600s;

        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

        # Mitigate HTTPOXY https://httpoxy.org/
        fastcgi_param HTTP_PROXY "";

        # has to be set to on if encryption (https) is used:
        fastcgi_param HTTPS on;

        fastcgi_split_path_info ^(.+?\.php)(/.*)$;

        # chose as your php-fpm is configured to listen on
        fastcgi_pass unix:/run/php-fpm/www.sock;
   }

   # Rewrite rule for WebSocket
   location /ws {
        rewrite ^/ws/(.*) /$1 break;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:8100/;
   }
}
```
Questo file presuppone che installeremo Ampache nel dominio ampache.example.com e nella directory /var/www/html/ampache. Premi Ctrl + X per chiudere l'editor e premi Y quando ti viene chiesto di salvare il file.
Attiva questo file di configurazione collegandolo alla directory sites-enabled.
```
$ sudo ln -s /etc/nginx/sites-available/ampache.conf /etc/nginx/sites-enabled/
```
Testare la configurazione di Nginx.
```
$ sudo nginx -t
```
Dovresti vedere il seguente output che indica che la tua configurazione è corretta.
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
Ricarica il servizio Nginx.
```
$ sudo systemctl reload nginx
```
Configurazione di HTTPS tramite Lets Encrypt
Per utilizzare Lets encrypt, è necessario installare il pacchetto Certbot.
Installa Cerbot.
```
$ sudo dnf install certbot certbot-nginx -y
```
Installa il certificato.
```
$ sudo certbot --nginx -d ampache.example.com
```
Se è la prima volta che usi lo strumento su questo server, devi accettare i termini e inserire il tuo indirizzo email. Di' di no quando ti viene chiesto se vuoi condividere la tua email con la fondazione EFF.
In caso di successo, certbot ti chiederà come desideri configurare le tue impostazioni HTTPS.
```
Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
-------------------------------------------------------------------------------
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel):
```
Seleziona 2 e poi premi INVIO. Il certificato è ora installato e attivato.
Eseguire il seguente comando per configurare il rinnovo automatico.
```
$ echo "0 0,12 * * * root python -c 'import random; import time; time.sleep(random.random() * 3600)' && certbot renew" | sudo tee -a /etc/crontab > /dev/null
```
Installa Ampache
Crea una cartella root del documento vuota per Ampache.
```
$ sudo mkdir -p /var/www/html/ampache
```
L'argomento -p assicura che le directory padre var e www vengano create automaticamente se non esistono.
Successivamente, scarica l'archivio ZIP dell'ultima versione di Ampache. Puoi trovare il link all'ultima versione dalla sua pagina delle versioni di Github. Al momento della stesura di questo tutorial, 4.4.1 è l'ultima versione, quindi la scaricheremo.
```
$ wget https://github.com/ampache/ampache/releases/download/4.4.1/ampache-4.4.1_all.zip
```
Successivamente, decomprimi il file ZIP nella directory che abbiamo creato in precedenza.
```
$ sudo unzip ampache-4.4.1_all.zip -d /var/www/html/ampache/
```
Successivamente, imposta le autorizzazioni nella directory /var/www/html/ampache per il server web Nginx.
```
$ sudo chown --recursive  nginx:nginx /var/www/html/ampache/
```
Crea un'altra directory per archiviare la tua musica. Non abbiamo bisogno di sudo qui perché stiamo creando nella nostra directory utente.
```
$ sudo mkdir -p /data/Music
```
Cambia la proprietà di /home/user/music in nginx in modo che il server possa scrivere e leggere dalla directory in cui archivierai la musica.
```
$ sudo chown -R nginx:nginx /data/Music
```
Per completare la configurazione di Ampache, installa FFmpeg, un'utilità per convertire file audio e video da un formato all'altro. Ampache utilizza FFmpeg per convertire al volo i file audio dal formato in cui sono stati caricati in un formato riproducibile dal dispositivo di ascolto.
Fedora non viene fornito con FFmpeg per impostazione predefinita, quindi è necessario aggiungere prima il repository RPMFusion.
```
$ sudo dnf install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
```
Successivamente, installa FFmpeg.
```
$ sudo dnf install ffmpeg
```
Utilizzando il programma di installazione di Ampache
Il tuo sito Ampache è pronto per l'uso ed è possibile accedervi tramite https://example.com nel tuo browser. La prima volta che lo apri, verrai accolto dal programma di installazione web di Ampache.
Seleziona la tua lingua e continua alla pagina successiva dove ti verrà mostrato se il tuo server soddisfa i requisiti per Ampache.
Se hai seguito correttamente il tutorial, dovresti essere in grado di passare alla pagina successiva in cui ti verrà chiesto di inserire i dettagli del database. Poiché abbiamo già creato il database, possiamo lasciare la casella di controllo deselezionata. Lo stesso vale per l'utente del database. Inserisci il nome del database, l'utente e la password che abbiamo creato e procedi alla pagina successiva.
Successivamente, ti verranno mostrate le opzioni di configurazione per Ampache. La maggior parte delle informazioni è precompilata e non richiede alcuna modifica.
Per qualche motivo, il programma di installazione Web di Ampache non rileva il binario FFmpeg installato su Fedora. Lo abiliteremo in seguito modificando manualmente il file di configurazione.
Quindi, inserisci i dettagli per l'account amministratore per Ampache.
Ora verrai reindirizzato alla pagina di accesso per Ampache.
Inserisci i tuoi dati utente e ora puoi accedere al lettore Ampache.
Prima che tu possa iniziare a usarlo, dobbiamo abilitare FFmpeg per scopi di transcodifica. Per abilitarlo, devi aprire il file /var/www/html/ampache/config/ampache.cfg.php per la modifica.
```
$ sudo nano /var/www/html/ampache/config/ampache.cfg.php
```
Sostituisci la riga seguente
```
;transcode_cmd = "ffmpeg"
```
con la riga successiva rimuovendo il segno e commerciale davanti ad essa.
```
transcode_cmd = "ffmpeg"
```
Premi Ctrl + X per chiudere l'editor e premi Y quando ti viene chiesto di salvare il file. Puoi apportare molte più modifiche che desideri tramite questo file. L'installazione di Ampache è pronta, ma affinché funzioni, dobbiamo prima aggiungere un po' di musica.
Aggiunta di musica
Per aggiungere musica ad Ampache, dobbiamo creare un catalogo nel lettore e quindi caricare i file dall'interfaccia web.
Innanzitutto, utilizza l'opzione Aggiungi catalogo sulla home page.
Seleziona locale come tipo di catalogo e inserisci il percorso /home/user/music. Se desideri importare playlist, puoi selezionare l'opzione Crea playlist da file di playlist. Assegna un nome al tuo catalogo e fai clic su Aggiungi catalogo per procedere.
Ora che il nostro catalogo è stato creato, dobbiamo abilitare l'opzione per poter caricare file musicali. Per farlo, fai clic sul quarto pulsante di navigazione nella barra degli strumenti in alto a sinistra per accedere alle impostazioni di amministrazione.
Scorri verso il basso fino alla sezione Configurazione server e fai clic su Sistema.
Trova la riga Consenti caricamenti utente e seleziona On dal menu a discesa. È inoltre possibile selezionare il tipo di utente a cui è consentito aggiungere i file. Nel nostro caso, è il responsabile del catalogo che è anche l'amministratore.
È inoltre necessario impostare la destinazione per i file caricati dall'utente. È possibile impostarlo utilizzando la riga del catalogo di destinazione. Seleziona il catalogo che abbiamo appena creato dal menu a tendina.
Fai clic su Aggiorna preferenze quando hai finito. Ora puoi aggiungere musica alla tua installazione di Ampache. Per questo, fai clic sull'icona della cuffia nel menu di navigazione in alto a sinistra.
Quindi, fai clic sul link Carica nella sezione Musica.
Nella pagina Carica, sfoglia e seleziona i tuoi file musicali dal tuo PC locale e caricali. Se lasci vuoti i campi Artista e Album, Ampache cercherà automaticamente di identificare utilizzando i tag ID3 dai file stessi.
Una volta che hai finito, ora puoi trovare i tuoi file su una qualsiasi delle sezioni dal riquadro di sinistra e ora puoi riprodurre in streaming la tua musica.
Conclusione
Questo conclude il nostro tutorial su come installare e utilizzare il server di streaming Ampache Music alimentato da Fedora 33. Se hai domande o feedback, pubblicalo nei commenti qui sotto.

Come installare Ampache Music Streaming Server su Fedora 33

Su questa pagina

Prerequisiti

Configura firewall

Installa Git

Installa MariaDB

Configura MariaDB per Ampache

Installa PHP

Installa le estensioni PHP

Configura PHP-FPM

Installa Nginx

Configura Nginx

Configurazione di HTTPS tramite Lets Encrypt

Installa Ampache

Utilizzando il programma di installazione di Ampache

Aggiunta di musica

Conclusione