So installierst du den Koel Music Streaming Server mit Docker auf Rocky Linux 8

Koel ist ein webbasierter Audio-Streaming-Dienst, der im Laravel PHP Framework geschrieben wurde. Er ermöglicht es dir, deine persönliche Musiksammlung zu streamen und von überall auf der Welt darauf zuzugreifen. Er unterstützt mehrere Medienformate, darunter AAC, OGG, WMA, FLAC und APE.

In diesem Lernprogramm lernst du, wie du den Koel Music Streaming Server mit Docker auf einem Rocky Linux 8 Rechner installierst.

Voraussetzungen

  • Ein Server mit Rocky Linux 8.5.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Aktualisiere alles.
    $ sudo dnf update
    
  • Installiere die wichtigsten Pakete.
    $ sudo dnf install yum-utils nano curl
    
  • Ein benutzerdefinierter Domainname, der auf den Server zeigt, z. B. koel.example.com.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

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

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Lasse HTTP- und HTTPS-Ports zu.

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

Überprüfe erneut den Status der Firewall.

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

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Docker installieren

Rocky Linux wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, installierst du zuerst das offizielle Docker-Repository.

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

Installiere die neueste Version von Docker.

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

Aktiviere den Docker-Daemon und starte ihn.

$ sudo systemctl enable docker --now

Überprüfe, ob er läuft.

? docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
   Active: active (running) since Sat 2022-04-02 13:26:08 UTC; 2s ago
     Docs: https://docs.docker.com
 Main PID: 21152 (dockerd)
    Tasks: 7
   Memory: 30.9M
   CGroup: /system.slice/docker.service
           ??21152 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
...

Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden.

Schritt 3 – Installiere Docker Compose

Lade die neueste stabile Version von Docker Compose herunter.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Gib der Docker Compose Binärdatei die Berechtigung zum Ausführen.

$ sudo chmod +x /usr/local/bin/docker-compose

Teste die Installation.

$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

Installiere das Docker-Compose Bash Completion Script.

$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

Lade deine Profileinstellungen neu, damit die Bash-Vervollständigung funktioniert.

$ source ~/.bashrc

Schritt 4 – Koel App Key erstellen

Wir erzeugen den App-Schlüssel von Koel, indem wir den Container für einen kurzen Moment laufen lassen. Führe den folgenden Befehl aus, um den Container zu starten und auf seine Shell zuzugreifen.

$ docker run -it --rm phanan/koel bash

Sobald du im Container bist, führe den folgenden Befehl aus, um den Anwendungsschlüssel zu erzeugen.

$ php artisan key:generate --force

Gib die geänderte Umgebungsdatei mit dem neu erzeugten App-Schlüssel aus.

$ cat .env
APP_KEY=base64:fjtO7aVHHKWfk4DThKqf1nci6o2DuMkNd90TKX6Gj+4=

Kopiere den Schlüsselwert und verlasse die Container-Shell.

$ exit

Schritt 5 – Koel-Umgebungsdatei erstellen

Erstelle ein Verzeichnis für Koel.

$ mkdir ~/koel

Wechsle in das Verzeichnis.

$ cd ~/koel

Erstelle das Musikverzeichnis.

$ mkdir music

Erstelle und öffne die Datei .env.

$ nano .env

Füge den folgenden Code in die Datei ein.

APP_NAME=Koel

# A random 32-char string. You can leave this empty if use php artisan koel:init.
APP_KEY=base64:fjtO7aVHHKWfk4DThKqf1nci6o2DuMkNd90TKX6Gj+4=

# The ABSOLUTE path to your media. This value can always be changed later via the web interface.
MEDIA_PATH=/music

APP_ENV=production
APP_DEBUG=true
APP_URL=https://koel.example.com

# The maximum scan time, in seconds. Increase this if you have a huge library.
# Note: This setting doesn't have effect when scanning via koel:sync.
APP_MAX_SCAN_TIME=600

# The memory limit, in MB, used by the scanning process.
# For example, if you want to set a memory limit of 2048MB, enter "2048" (without
# quotes) here.
MEMORY_LIMIT=512

# The streaming method.
# Can be either 'php' (default), 'x-sendfile', or 'x-accel-redirect'
# See https://docs.koel.dev/#streaming-music for more information.
# Note: This setting doesn't have effect if the media needs transcoding (e.g. FLAC).
STREAMING_METHOD=x-sendfile

# If you want Koel to integrate with Last.fm, set the API details here.
# See https://docs.koel.dev/3rd-party.html#last-fm for more information
LASTFM_API_KEY=
LASTFM_API_SECRET=

# If you want to use Amazon S3 with Koel, fill the info here and follow the
# installation guide at https://docs.koel.dev/aws-s3.html
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_REGION=

# If you want Koel to integrate with YouTube, set the API key here.
# See https://docs.koel.dev/3rd-party.html#youtube for more information.
YOUTUBE_API_KEY=

# You can also configure Koel to use a CDN to serve the media files.
# This url must be mapped to the home URL of your Koel's installation.
# No trailing slash, please.
CDN_URL=

# The bit rate of the output mp3 stream. Higher value results in better quality,
# but slower streaming and more bandwidth.
OUTPUT_BIT_RATE=128

# Whether to allow song downloading.
# Note that if you're downloading more than one song, Koel will zip them up
# using PHP's ZipArchive. So if the module isn't available in the current
# environment, such a download will (silently) fail.
ALLOW_DOWNLOAD=true

# If this is set to true, the query to get artist, album, and song information will be cached.
# This can give a boost to Koel's boot time, especially if your library is huge.
# However, the cache deserialization process can be memory sensitive, so if you encounter
# errors, try setting this to false.
CACHE_MEDIA=true

# Koel attempts to detect if your website use HTTPS and generates secure URLs accordingly.
# If this attempts for any reason, you can force it by setting this value to true.
FORCE_HTTPS=true

# The variables below are Laravel-specific.
# You can change them if you know what you're doing. Otherwise, just leave them as-is.
APP_LOG_LEVEL=debug
BROADCAST_DRIVER=log
CACHE_DRIVER=file
SESSION_DRIVER=file
QUEUE_DRIVER=sync

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Die meisten der oben genannten Einstellungen sind selbsterklärend. Die folgenden Einstellungen müssen konfiguriert werden, damit es funktioniert. Füge den im vorherigen Schritt erstellten App-Schlüssel in die Variable APP_KEY ein. Gib deinen Domainnamen unter APP_URL ein und lege das Speicherlimit in MB fest, je nach den Ressourcen deines Servers. Wir haben die Streaming-Methode aufx-sendfile gesetzt, da das Docker-Image von Koel Apache verwendet und damit vorkonfiguriert ist. Die Einstellung FORCE_HTTPS ist auf true gesetzt, weil wir Nginx als Load Balancer zusammen mit Let’s Encrypt SSL verwenden werden, um Koel im Web zu bedienen. Konfiguriere andere Dienste, wenn du sie zusammen mit Koel nutzen willst.

Schritt 6 – Koel Docker Compose Datei erstellen

Erstelle und öffne die Datei docker-compose.yml zum Bearbeiten.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

version: '3.3'

services:
  koel:
    image: phanan/koel
    container_name: koel
    depends_on:
      - koeldb
    restart: unless-stopped
    ports:
      - 8080:80
    environment:
      - DB_CONNECTION=mysql
      - DB_HOST=koeldb
      - DB_USERNAME=koel
      - DB_PASSWORD=koelpassword
      - DB_DATABASE=koel
    volumes:
      - ./music:/music
      - ./.env:/var/www/html/.env
      - covers:/var/www/html/public/img/covers
      - search_index:/var/www/html/storage/search-indexes

  koeldb:
    image: mysql/mysql-server:8.0
    restart: unless-stopped
    volumes:
      - db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=rootpassword
      - MYSQL_DATABASE=koel
      - MYSQL_USER=koel
      - MYSQL_PASSWORD=koelpassword

volumes:
  db:
    driver: local
  covers:
    driver: local
  search_index:
    driver: local

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Die obige Datei startet Container, die auf den Docker-Images von Koel und MySQL basieren. Sie stellt Koel auf Port 8080 auf deinem Rechner zur Verfügung. Die Musik- und die Umgebungsdatei werden an den entsprechenden Stellen des Containers eingehängt. Das Verzeichnis für die Musikcover und den Suchindex wird zusammen mit den MySQL-Daten als lokales Volume gemountet. Wähle ein sicheres Passwort für die Variablen MYSQL_ROOT_PASSWORD, MYSQL_PASSWORD und stimme diese Werte mit den Variablen für den Koel-Container in der obigen Datei ab. Um den Koel-Container mit dem Datenbank-Container zu verknüpfen, stelle sicher, dass die Variablen DB_HOST und depends_on nach dem Dienstnamen des Datenbank-Containers benannt sind.

Schritt 7 – Koel Container starten

Starte den Koel-Container mit dem folgenden Befehl.

$ docker-compose up -d

Koel zum ersten Mal initialisieren

Melde dich in der Shell des Koel Containers an. koel im folgenden Befehl bezieht sich auf den Namen des Containers, der über die Variable container_name in der obigen Docker Compose-Datei festgelegt wurde. Wenn du keinen Containernamen festgelegt hast, musst du zuerst den Namen des Containers herausfinden und ihn im folgenden Befehl verwenden.

$ docker exec --user www-data -it koel bash

Führe den folgenden Befehl aus, um ein Administratorkonto zu erstellen und die Datenbank zu initialisieren.

$ php artisan koel:init --no-assets

Administrator-Passwort ändern

Koel erstellt ein Standard-Administratorkonto mit den folgenden Anmeldedaten.

email: [email protected]
password: KoelIsCool

Du kannst das Passwort für das Administratorkonto mit folgendem Befehl innerhalb der Container-Shell ändern.

$ php artisan koel:admin:change-password

Verlasse die Container-Shell.

$ exit

Schritt 8 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d koel.example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/koel.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.daily/certbot-renew

Füge den folgenden Code ein.

#!/bin/sh
certbot renew --cert-name koel.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Schritt 9 – Nginx installieren

Wir werden die neueste Version von Nginx installieren. Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

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

Füge die folgenden Zeilen in die Datei ein.

[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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere Nginx.

$ sudo dnf install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.2

Aktiviere und starte den Nginx-Dienst.

$ sudo systemctl enable nginx --now

Erstelle und öffne die Datei /etc/nginx/conf.d/koel.conf zur Bearbeitung.

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

Füge den folgenden Code in die Datei ein.

# Redirect all non-encrypted to encrypted
server {
    listen 80;
    listen [::]:80;
    server_name koel.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    
    server_name koel.example.com;

    ssl_certificate     /etc/letsencrypt/live/koel.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/koel.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/koel.example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;

    access_log /var/log/nginx/koel.example.com.access.log main;
    error_log  /var/log/nginx/koel.example.com.error.log;

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Port $server_port;
        proxy_set_header X-Forwarded-Host $host;
        client_max_body_size 400M;
    	proxy_pass  http://localhost:8080;
    	proxy_http_version 1.1;
        proxy_set_header Host $host;
    }
}

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Mit der obigen Konfiguration kann Nginx als Proxy-Server fungieren und sich an den Port 8080 auf localhost binden.

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

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

Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.

$ sudo systemctl restart nginx

Schritt 10 – Zugriff auf Koel

Du kannst auf Koel zugreifen, indem du die URL https://koel.example.com in deinem Browser aufrufst. Du wirst mit dem folgenden Anmeldebildschirm begrüßt.

Cooler Anmeldebildschirm

Gib [email protected] als Benutzernamen und das Passwort ein, das du vor dem Einloggen festgelegt hast. Nach erfolgreicher Anmeldung wird das folgende Dashboard angezeigt.

Koel Dashboard

Schritt 11 – Musik importieren

Kopiere die Musikdateien, die du importieren möchtest, in den Ordner ~/koel/music deines Systems. Du kannst den Befehl scp verwenden, um die Dateien von deinem lokalen PC auf den Server zu importieren.

$ scp test.mp3 [email protected]<yourserverIP>:/home/user/koel/music

Sobald du die Dateien in den Ordner ~/koel/music kopiert hast, führe den folgenden Befehl aus, um die Musik in Koel zu importieren.

$ docker exec --user www-data koel php artisan koel:sync

Die Musik wird in der Weboberfläche von Koel angezeigt, und du kannst sie abspielen.

Über die Weboberfläche von Koel kannst du auch direkt Lieder hochladen.

Schritt 12 – Koel aktualisieren

Wechsle in das Koel-Verzeichnis.

$ cd ~/koel

Ziehe das neueste Koel-Docker-Image.

$ docker-compose pull

Schalte den Container aus.

$ docker-compose down --remove-orphans

Starte den Container mit den aktualisierten Images.

$ docker-compose up -d

Überprüfe die Docker-Container.

$ docker ps

Fazit

Damit ist die Anleitung zur Installation von Koel Music Streaming Service mit Docker auf einem Rocky Linux Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …