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.

Supabase ANON KEY Generator

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.

Supabase SERVICE KEY Generator

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.

[email protected]
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 [email protected] -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.

Supabase Studio

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.

Supabase Nginx HTTP-Authentifizierung

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.

Das könnte dich auch interessieren …