Come installare Supabase con Docker su Debian 11

Supabase è un'alternativa Firebase open source che ti fornisce tutti gli strumenti necessari per sviluppare le tue applicazioni. Supabase offre un database PostgreSQL, autenticazione utente, archiviazione e un'API in tempo reale e si integra con framework e strumenti popolari come Angular, Flutter, Next.js, React, Svelte e Vue.

Ci sono due modi per usare Supabase. La prima opzione è iscriversi alla loro app ospitata su cloud, che offre più funzionalità. La seconda opzione consiste nell'ospitare automaticamente il codice utilizzando Docker. Tuttavia, ci sono alcuni avvertimenti sull'hosting automatico. Non puoi creare o gestire progetti. Inoltre, l'intero progetto è in fase beta e dovresti usare la versione self-hosted solo per i test e lo sviluppo locale. Per tutti gli altri scopi, dovresti utilizzare la loro applicazione cloud.

In questo tutorial imparerai come installare Supabase su un server basato su Debian 11 e come proxy tramite il server Nginx.

Prerequisiti

• Un server che esegue Debian 11 con un minimo di 2 GB di RAM.

• Un utente non root con privilegi sudo.

• Un nome di dominio (supabase.example.com ) che punta al server.

• Tutto è aggiornato.

  $ sudo apt update && sudo apt upgrade
  

• Pochi pacchetti di cui il tuo sistema ha bisogno.

  $ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
  

  Alcuni di questi pacchetti potrebbero essere già installati sul tuo sistema.

Passaggio 1:configurazione del firewall

Il primo passo è configurare il firewall. Debian viene fornito con ufw (Uncomplicated Firewall).

Controlla se il firewall è in esecuzione.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti porta SSH in modo che il firewall non interrompa la connessione corrente quando lo si abilita.

$ sudo ufw allow OpenSSH

Consenti anche le porte HTTP e HTTPS.

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp

Abilita il Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Ricontrolla lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output simile.

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)

Passaggio 2:installa Git

Installa Git.

$ sudo apt install git

Conferma l'installazione.

$ git --version
git version 2.30.2

Passaggio 3 - Installa Docker

Per installare l'ultima versione di Docker, aggiungi la chiave GPG ufficiale di Docker.

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Installa il repository Docker ufficiale.

$ 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

Aggiorna i repository di sistema Debian.

$ sudo apt update

Installa l'ultima versione di Docker.

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

Verifica che Docker sia in esecuzione.

$ 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

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

$ sudo usermod -aG docker $(whoami)

Devi uscire dal server e riconnetterti come lo stesso utente per abilitare questa modifica.

Passaggio 4 - Installa Docker Compose

L'ultima versione disponibile di Docker Compose è la 2.0.x, ma per motivi di compatibilità installeremo la vecchia e stabile v1.29.2.

Esegui il comando seguente per scaricare la versione stabile di Docker Compose.

$ 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

Applica le autorizzazioni eseguibili al file binario.

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

Scarica e installa lo script di completamento bash di Docker Compose.

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

Esegui il comando seguente per applicare le modifiche.

$ source ~/.bashrc

Passaggio 5 - Scarica e configura Supabase

Clona il repository Supabase Github.

$ git clone --depth 1 https://github.com/supabase/supabase.git

Il --depth 1 il parametro esegue un clone superficiale del repository, ovvero estrae solo gli ultimi commit e non l'intera cronologia. Questo viene fatto per migliorare le prestazioni.

Passa alla directory della finestra mobile.

$ cd supabase/docker

Crea il file di ambiente dal file di esempio.

$ cp .env.example .env

Apri il file appena creato per la modifica.

$ nano .env

Modifica il valore della variabile POSTGRES_PASSWORD con una password univoca fortemente generata.

$ POSTGRES_PASSWORD=<yourpostgresqlpwd>

Genera un'altra password univoca con più di 32 caratteri senza caratteri speciali. Sostituisci il valore di JWT_SECRET con questa password.

JWT_SECRET=<your32pluscharacterspwd>

Puoi utilizzare un generatore di password online come Bitwarden o 1password per creare le password di cui sopra.

Apri il sito Web di Supabase e inserisci il tuo JWT_SECRET per generare un ANON_KEY . Incolla il tuo JWT_SECRET nella casella specificata, seleziona ANON_KEY dal Carico utile preconfigurato menu a discesa e fai clic su Genera JWT pulsante per generare il token.

Copia e incolla questo token come valore per ANON_KEY nel .env file.

Allo stesso modo, ripeti gli stessi passaggi per generare il SERVICE_KEY cambiando il Carico utile preconfigurato e premendo il pulsante Genera JWT pulsante.

Copia il token generato e incollalo come valore per il SERVICE_KEY nel .env file.

Configurare le impostazioni SMTP dell'e-mail configurando le seguenti variabili. Stiamo utilizzando il servizio SES di Amazon per il nostro tutorial.

[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

Configura l'URL del sito.

SITE_URL=https://supabase.example.com

Configura l'URL REST pubblico.

PUBLIC_REST_URL=https://supabase.example.com/rest/v1/

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

Le e-mail di autenticazione inviate tramite SMTP avranno collegamenti interrotti a causa di un bug prevalente in Supabase. Per risolvere questo problema, apri docker-compose.yml file.

$ nano docker-compose.yml

Aggiungi la variabile API_EXTERNAL_URL proprio sotto il GOTRUE_SITE_URL variabile in modo che assomigli alla seguente.

 GOTRUE_SITE_URL: ${SITE_URL}
 API_EXTERNAL_URL: ${SITE_URL}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Questo file verrà sovrascritto ogni volta che aggiorni l'installazione di Supabase. Si spera che il bug venga corretto la prossima volta. Dovrai aggiungere questa variabile manualmente per assicurarti che il bug dell'email non si ripeta.

Apri volumes/api/kong.yml file per la modifica.

$ nano volumes/api/kong.yml

Sotto i consumers sezione, sostituisci anon chiave dell'utente con il ANON_KEY generato prima.

consumers:
  - username: anon
    keyauth_credentials:
      - key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJhbm9uIiwKICAgICJpc3MiOiAic3VwYWJhc2UtZGVtbyIsCiAgICAiaWF0IjogMTY0MTc2OTIwMCwKICAgICJleHAiOiAxNzk5NTM1NjAwCn0.dc_X5iR_VP_qT0zsiyj_I_OZ2T9FtRU2BBNWN8Bu4GE

Inoltre, sostituisci il service_role 's con il SERVICE_KEY generato sopra.

- username: service_role
    keyauth_credentials:
      - key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyAgCiAgICAicm9sZSI6ICJzZXJ2aWNlX3JvbGUiLAogICAgImlzcyI6ICJzdXBhYmFzZS1kZW1vIiwKICAgICJpYXQiOiAxNjQxNzY5MjAwLAogICAgImV4cCI6IDE3OTk1MzU2MDAKfQ.DaYlNEoUrrEn2Ig7tqibS-PHK5vgusbcbo7X36XVt4Q

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

Passaggio 6 - Installa Supabase

Eseguire Supabase utilizzando il comando seguente. Questo processo richiederà del tempo.

$ docker-compose -f docker-compose.yml -f ./dev/docker-compose.dev.yml up -d

Controlla lo stato dei contenitori in esecuzione.

$ 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

Passaggio 7 - Installa SSL

Per installare un certificato SSL utilizzando Let's Encrypt, è necessario installare lo strumento Certbot.

Useremo il programma di installazione del pacchetto Snapd per questo. Poiché la maggior parte dei server Debian non viene fornita con esso, installa il programma di installazione Snapd.

$ sudo apt install snapd

Assicurati che la tua versione di Snapd sia aggiornata.

$ sudo snap install core && sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Utilizzare il comando seguente per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico al /usr/bin directory.

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

Verifica l'installazione.

$ certbot --version
certbot 1.25.0

Genera il certificato SSL.

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

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

Genera un gruppo Diffie-Hellman certificato.

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

Crea una directory webroot di sfida per il rinnovo automatico di Let's Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, prima crea il file /etc/cron.daily/certbot-renew e aprilo per la modifica.

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

Incolla il seguente codice.

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

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

Modifica le autorizzazioni sul file dell'attività per renderlo eseguibile.

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

Passaggio 8 - Installa e configura Nginx

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

Importa la chiave di firma Nginx ufficiale.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
	 | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginx.

$ 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

Aggiorna i repository Debian.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verificare l'installazione. Assicurati di utilizzare sudo ogni volta che esegui il comando Nginx su Debian. Altrimenti, non funzionerà.

$ sudo nginx -v
nginx version: nginx/1.20.2

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

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

Incolla il seguente codice al suo interno.

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;
  	}
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.

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

$ sudo nano /etc/nginx/nginx.conf

Aggiungi 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 inserendo Y quando richiesto.

Verifica 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

Avvia il servizio Nginx per abilitare la nuova configurazione.

$ sudo systemctl start nginx

Fase 9 - Accedi a Supabase

Ora puoi accedere a Supabase tramite l'URL https://supabase.example.com nel tuo browser web.

Non puoi creare nuovi progetti, ma puoi gestire quelli esistenti e configurare il database, l'archiviazione e l'autenticazione.

Passaggio 10 - Abilita l'autenticazione HTTP

Supabase non fornisce la gestione degli utenti, quindi è necessario proteggere l'installazione di Supabase. Il modo più semplice per farlo è abilitare l'autenticazione HTTP utilizzando il server Nginx.

Installa apache2-utils pacchetto per Nginx.

$ sudo apt install apache2-utils

Crea un file di password per l'utente supabase . Puoi scegliere qualsiasi nome utente desideri. Ti verrà richiesta una nuova password. Inserisci una password complessa per completare la configurazione del file.

$ sudo htpasswd -c /etc/nginx/.htpasswd supabase
New password:
Re-type new password:
Adding password for user supabase

Il -c flag dice all'utilità di creare un nuovo file. Se ometti il ​​file, devi specificare la posizione di un file esistente.

Apri il /etc/nginx/conf.d/supabase.conf per la modifica.

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

Apporta le modifiche nelle seguenti sezioni del file, come mostrato di seguito.

# 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;
  	}

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

Verifica la configurazione.

$ 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 servizio Nginx.

$ sudo systemctl restart nginx

La prossima volta che apri Supabase, verrai accolto con la seguente schermata di accesso.

Passaggio 11 - Aggiorna Supabase

Supabase è un prodotto in costante evoluzione e subirà continui cambiamenti. Se la utilizzi come istanza self-hosted, devi mantenere aggiornata l'installazione di Supabase.

Passa alla directory Supabase.

$ cd ~/supabase

Estrai l'ultimo repository Github.

$ git pull

Cerca eventuali modifiche nella docker/.env , docker/volumes/api/kong.yml file per tutto ciò che richiede una riconfigurazione.

Spegni e ripulisci i contenitori Docker esistenti.

$ docker-compose down --remove-orphans

Estrai le ultime immagini.

$ docker-compose pull

Riavvia i contenitori.

$ docker-compose -f docker-compose.yml -f ./dev/docker-compose.dev.yml up -d

Conclusione

Questo conclude il nostro tutorial sull'installazione di Supabase su un server basato su Debian 11 utilizzando il server Nginx come proxy inverso. Se hai domande, pubblicale nei commenti qui sotto.