So installierst du Supabase mit Docker unter Debian 11
Supabase ist eine Open-Source-Alternative zu Firebase, die dir alle Tools bietet, die du für die Entwicklung deiner Anwendungen brauchst. Supabase bietet eine PostgreSQL-Datenbank, Benutzerauthentifizierung, Speicherplatz und eine Echtzeit-API und lässt sich mit gängigen Frameworks und Tools wie Angular, Flutter, Next.js, React, Svelte und Vue integrieren.
Es gibt zwei Möglichkeiten, Supabase zu nutzen. Die erste Möglichkeit ist, sich für die Cloud-gehostete App anzumelden, die mehr Funktionen bietet. Die zweite Möglichkeit ist, den Code mithilfe von Docker selbst zu hosten. Beim Selbsthosten gibt es allerdings ein paar Einschränkungen. Du kannst keine Projekte erstellen oder verwalten. Außerdem befindet sich das gesamte Projekt in der Beta-Phase und du solltest die selbst gehostete Version nur zum Testen und für die lokale Entwicklung verwenden. Für alle anderen Zwecke solltest du die Cloud-Anwendung nutzen.
In diesem Lernprogramm erfährst du, wie du Supabase auf einem Debian 11 basierten Server installierst und über den Nginx Server proxy verwendest.
Voraussetzungen
- Ein Server mit Debian 11 und mindestens 2 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Domainname (
supabase.example.com), der auf den Server zeigt. - Alles ist auf dem neuesten Stand.
$ sudo apt update && sudo apt upgrade
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall läuft.
$ sudo ufw status
Du solltest die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow 80/tcp $ sudo ufw allow 443/tcp
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443/tcp ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443/tcp (v6) ALLOW Anywhere (v6)
Schritt 2 – Git installieren
Installiere Git.
$ sudo apt install git
Bestätige die Installation.
$ git --version git version 2.30.2
Schritt 3 – Docker installieren
Um die neueste Version von Docker zu installieren, füge den offiziellen GPG-Schlüssel von Docker hinzu.
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
Installiere das offizielle Docker-Repository.
$ echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere die Debian-Systemrepositorien.
$ sudo apt update
Installiere die neuste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io
Überprüfe, ob Docker läuft.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2022-03-21 03:19:09 UTC; 9s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 15816 (dockerd)
Tasks: 7
Memory: 27.9M
CPU: 566ms
CGroup: /system.slice/docker.service
??15816 /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 4 – Docker Compose installieren
Die neueste verfügbare Version von Docker Compose ist 2.0.x, aber aus Kompatibilitätsgründen werden wir die ältere und stabile Version v1.29.2 installieren.
Führe den folgenden Befehl aus, um die stabile Version von Docker Compose herunterzuladen.
$ 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 Binärdatei die Berechtigung zum Ausführen.
$ sudo chmod +x /usr/local/bin/docker-compose
Lade das Bash-Completion-Skript von Docker Compose herunter und installiere es.
$ sudo curl \
-L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
-o /etc/bash_completion.d/docker-compose
Führe den folgenden Befehl aus, um die Änderungen zu übernehmen.
$ source ~/.bashrc
Schritt 5 – Supabase herunterladen und konfigurieren
Klone das Github-Repository von Supabase.
$ git clone --depth 1 https://github.com/supabase/supabase.git
Mit dem Parameter --depth 1 wird ein oberflächlicher Klon des Repositorys erstellt, d.h. es werden nur die letzten Commits und nicht der gesamte Verlauf gezogen. Dies dient der Verbesserung der Leistung.
Wechsle in das Docker-Verzeichnis.
$ cd supabase/docker
Erstelle die Umgebungsdatei aus der Beispieldatei.
$ cp .env.example .env
Öffne die neu erstellte Datei zum Bearbeiten.
$ nano .env
Ändere den Wert der Variable POSTGRES_PASSWORD mit einem stark generierten eindeutigen Passwort.
$ POSTGRES_PASSWORD=<yourpostgresqlpwd>
Erstelle ein weiteres eindeutiges Passwort mit mehr als 32 Zeichen und ohne Sonderzeichen. Ersetze den Wert von JWT_SECRET durch dieses Passwort.
JWT_SECRET=<your32pluscharacterspwd>
Du kannst einen Online-Passwortgenerator wie Bitwarden oder 1password verwenden, um die oben genannten Passwörter zu erstellen.
Öffne die Supabase-Website und gib dein JWT_SECRET ein, um ein ANON_KEY zu generieren. Füge dein JWT_SECRET in das angegebene Feld ein, wähle ANON_KEY aus dem Dropdown-Menü Preconfigured Payload und klicke auf die Schaltfläche Generate JWT, um das Token zu erzeugen.
Kopiere dieses Token und füge es als Wert für ANON_KEY in die Datei .env ein.
Wiederhole die gleichen Schritte für die Erstellung von SERVICE_KEY, indem du die vorkonfigurierte Nutzlast umschaltest und auf die Schaltfläche JWT gener ieren klickst.
Kopiere das generierte Token und füge es als Wert für SERVICE_KEY in die Datei .env ein.
Konfiguriere die E-Mail-SMTP-Einstellungen, indem du die folgenden Variablen einstellst. Für unser Tutorial verwenden wir den SES-Dienst von Amazon.
SMTP_ADMIN_EMAIL=admin@example.com SMTP_HOST=email-smtp.us-west-2.amazonaws.com SMTP_PORT=587 SMTP_USER=<your_amazon_ses_user> SMTP_PASS=<your_amazon_ses_password> SMTP_SENDER_NAME=SupabaseAdmin
Konfiguriere die URL der Website.
SITE_URL=https://supabase.example.com
Konfiguriere die öffentliche REST-URL.
PUBLIC_REST_URL=https://supabase.example.com/rest/v1/
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Die Authentifizierungsmails, die über SMTP verschickt werden, enthalten aufgrund eines Fehlers in Supabase fehlerhafte Links. Um dieses Problem zu beheben, öffne die Datei docker-compose.yml.
$ nano docker-compose.yml
Füge die Variable API_EXTERNAL_URL direkt unter der Variable GOTRUE_SITE_URL ein, so dass sie wie folgt aussieht.
GOTRUE_SITE_URL: ${SITE_URL}
API_EXTERNAL_URL: ${SITE_URL}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Diese Datei wird jedes Mal überschrieben, wenn du deine Supabase-Installation aktualisierst. Hoffentlich wird der Fehler beim nächsten Mal behoben. Du musst diese Variable manuell hinzufügen, damit der E-Mail-Fehler nicht erneut auftritt.
Öffne die Datei volumes/api/kong.yml zum Bearbeiten.
$ nano volumes/api/kong.yml
Ersetze im Abschnitt consumers den Schlüssel des Benutzers anon durch den zuvor erstellten Schlüssel ANON_KEY.
consumers:
- username: anon
keyauth_credentials:
- key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJhbm9uIiwKICAgICJpc3MiOiAic3VwYWJhc2UtZGVtbyIsCiAgICAiaWF0IjogMTY0MTc2OTIwMCwKICAgICJleHAiOiAxNzk5NTM1NjAwCn0.dc_X5iR_VP_qT0zsiyj_I_OZ2T9FtRU2BBNWN8Bu4GE
Ersetze auch den Schlüssel von service_role durch den oben generierten SERVICE_KEY.
- username: service_role
keyauth_credentials:
- key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 6 – Supabase installieren
Starte Supabase mit dem folgenden Befehl. Dieser Vorgang wird einige Zeit in Anspruch nehmen.
$ docker-compose -f docker-compose.yml -f ./dev/docker-compose.dev.yml up -d
Überprüfe den Status der laufenden Container.
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d25393873731 supabase/storage-api:v0.10.0 "/bin/sh -c \"./stora…" About a minute ago Up About a minute 5000/tcp supabase-storage
e6df7dcdd45b supabase/gotrue:v2.5.21 "gotrue" About a minute ago Up About a minute supabase-auth
b3a758592d10 supabase/postgres-meta:v0.29.0 "postgres-meta" About a minute ago Up About a minute 0.0.0.0:5555->8080/tcp, :::5555->8080/tcp supabase-meta
cdb18c248f79 supabase/realtime:v0.21.0 "bash -c './prod/rel…" About a minute ago Up About a minute supabase-realtime
71417337efae postgrest/postgrest:v9.0.0 "/bin/postgrest" About a minute ago Up About a minute 3000/tcp supabase-rest
2d51af16bd1f kong:2.1 "/docker-entrypoint.…" 2 minutes ago Up About a minute 0.0.0.0:8000->8000/tcp, :::8000->8000/tcp, 8001/tcp, 0.0.0.0:8443->8443/tcp, :::8443->8443/tcp, 8444/tcp supabase-kong
d6490380e4e8 supabase/postgres:14.1.0 "docker-entrypoint.s…" 2 minutes ago Up About a minute 0.0.0.0:5432->5432/tcp, :::5432->5432/tcp
supabase-db
40a49d1482fa supabase/studio:latest "docker-entrypoint.s…" 2 minutes ago Up About a minute 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp supabase-studio
3cce50db9782 inbucket/inbucket:stable "/start-inbucket.sh …" 2 minutes ago Up About a minute (healthy) 0.0.0.0:1100->1100/tcp, :::1100->1100/tcp, 0.0.0.0:2500->2500/tcp, :::2500->2500/tcp, 0.0.0.0:9000->9000/tcp, :::9000->9000/tcp supabase-mail
Schritt 7 – SSL installieren
Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.
Dazu verwenden wir den Snapd-Paketinstaller. Da die meisten Debian-Server nicht mit diesem Paket ausgeliefert werden, installiere den Snapd-Installer.
$ sudo apt install snapd
Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Installation.
$ certbot --version certbot 1.25.0
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d supabase.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/supabase.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
Erstelle ein Challenge-Webroot-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 supabase.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 8 – Nginx installieren und konfigurieren
Debian wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.
Importiere den offiziellen Nginx-Signierschlüssel.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die Debian-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Achte darauf, dass du jedes Mal sudo verwendest, wenn du den Nginx-Befehl unter Debian ausführst. Sonst wird es nicht funktionieren.
$ sudo nginx -v nginx version: nginx/1.20.2
Erstelle und öffne die Datei /etc/nginx/conf.d/supabase.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/supabase.conf
Füge den folgenden Code in die Datei ein.
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
upstream supabase {
server localhost:3000;
}
upstream kong {
server localhost:8000;
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name supabase.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name supabase.example.com;
access_log /var/log/nginx/supabase.access.log;
error_log /var/log/nginx/supabase.error.log;
gzip on;
# SSL
ssl_certificate /etc/letsencrypt/live/supabase.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/supabase.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/supabase.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
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;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 8.8.8.8;
client_max_body_size 100m;
# REST API
location ~ ^/rest/v1/(.*)$ {
proxy_set_header Host $host;
proxy_pass http://kong;
proxy_redirect off;
}
# Authentication
location ~ ^/auth/v1/(.*)$ {
proxy_set_header Host $host;
proxy_pass http://kong;
proxy_redirect off;
}
# Realtime
location ~ ^/realtime/v1/(.*)$ {
proxy_redirect off;
proxy_pass http://kong;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
proxy_set_header Host $host;
}
# Studio
location / {
proxy_set_header Host $host;
proxy_pass http://supabase;
proxy_redirect off;
proxy_set_header Upgrade $http_upgrade;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du danach gefragt wirst.
Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ 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, um die neue Konfiguration zu aktivieren.
$ sudo systemctl start nginx
Schritt 9 – Zugriff auf Supabase
Du kannst jetzt über die URL https://supabase.example.com in deinem Webbrowser auf Supabase zugreifen.
Du kannst keine neuen Projekte erstellen, aber du kannst die bestehenden Projekte verwalten und die Datenbank, den Speicher und die Authentifizierung konfigurieren.
Schritt 10 – Aktiviere die HTTP-Authentifizierung
Supabase bietet keine Benutzerverwaltung, deshalb musst du deine Supabase-Installation absichern. Das geht am einfachsten, indem du die HTTP-Authentifizierung über den Nginx-Server aktivierst.
Installiere das Paket apache2-utils für Nginx.
$ sudo apt install apache2-utils
Erstelle eine Passwortdatei für den Benutzer supabase. Du kannst jeden beliebigen Benutzernamen wählen. Du wirst zur Eingabe eines neuen Passworts aufgefordert. Gib ein sicheres Passwort ein, um die Einrichtung der Datei abzuschließen.
$ sudo htpasswd -c /etc/nginx/.htpasswd supabase New password: Re-type new password: Adding password for user supabase
Das Flag -c weist das Dienstprogramm an, eine neue Datei zu erstellen. Wenn du die Datei nicht angibst, musst du den Speicherort einer bestehenden Datei angeben.
Öffne die /etc/nginx/conf.d/supabase.conf zur Bearbeitung.
$ sudo nano /etc/nginx/conf.d/supabase.conf
Nimm die Änderungen in den folgenden Abschnitten der Datei vor, wie unten gezeigt.
# REST API
location ~ ^/rest/v1/(.*)$ {
auth_basic off;
proxy_set_header Host $host;
proxy_pass http://kong;
proxy_redirect off;
}
# Authentication
location ~ ^/auth/v1/(.*)$ {
auth_basic off;
proxy_set_header Host $host;
proxy_pass http://kong;
proxy_redirect off;
}
# Realtime
location ~ ^/realtime/v1/(.*)$ {
auth_basic off;
proxy_redirect off;
proxy_pass http://kong;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
proxy_set_header Host $host;
}
# Studio
location / {
auth_basic “Supabase Studio Login”;
auth_basic_user_file /etc/nginx/.htpasswd;
proxy_set_header Host $host;
proxy_pass http://supabase;
proxy_redirect off;
proxy_set_header Upgrade $http_upgrade;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Konfiguration.
$ 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.
$ sudo systemctl restart nginx
Wenn du Supabase das nächste Mal öffnest, wirst du mit dem folgenden Anmeldebildschirm begrüßt.
Schritt 11 – Supabase aktualisieren
Supabase ist ein Produkt, an dem ständig gearbeitet wird und das ständigen Änderungen unterworfen ist. Wenn du es als selbst gehostete Instanz verwendest, musst du deine Supabase-Installation auf dem neuesten Stand halten.
Wechsle in das Supabase-Verzeichnis.
$ cd ~/supabase
Ziehe das neueste Github-Repository.
$ git pull
Suche in den Dateien docker/.env, docker/volumes/api/kong.yml nach Änderungen, die eine Neukonfiguration erfordern.
Schließe die vorhandenen Docker-Container und bereinige sie.
$ docker-compose down --remove-orphans
Ziehe die neuesten Images.
$ docker-compose pull
Starten Sie die Container erneut.
$ docker-compose -f docker-compose.yml -f ./dev/docker-compose.dev.yml up -d
Fazit
Damit ist unsere Anleitung zur Installation von Supabase auf einem Debian 11 basierten Server mit dem Nginx-Server als Reverse-Proxy abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.