Cómo instalar Supabase con Docker en Debian 11

Generador de claves ANON de Supabase

Supabase es una alternativa de código abierto a Firebase que te proporciona todas las herramientas necesarias para desarrollar tus aplicaciones. Supabase ofrece una base de datos PostgreSQL, autenticación de usuarios, almacenamiento y una API en tiempo real y se integra con marcos y herramientas populares como Angular, Flutter, Next.js, React, Svelte y Vue.

Hay dos formas de utilizar Supabase. La primera opción es inscribirse en su aplicación alojada en la nube, que ofrece más funciones. La segunda opción es autoalojar el código usando Docker. Sin embargo, hay algunas advertencias en el autoalojamiento. No se pueden crear ni gestionar proyectos. Además, todo el proyecto está en fase beta, y deberías utilizar la versión autoalojada sólo para pruebas y desarrollo local. Para todos los demás propósitos, debes usar su aplicación en la nube.

En este tutorial, usted aprenderá cómo instalar Supabase en un servidor basado en Debian 11 y proxy a través del servidor Nginx.

Requisitos previos

  • Un servidor con Debian 11 con un mínimo de 2GB de RAM.
  • Un usuario no root con privilegios sudo.
  • Un nombre de dominio (supabase.example.com) que apunte al servidor.
  • Todo está actualizado.
    $ sudo apt update && sudo apt upgrade
    
  • Pocos paquetes que su sistema necesita.
    $ sudo apt install nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring -y
    

    Algunos de estos paquetes pueden estar ya instalados en su sistema.

Paso 1 – Configurar el Firewall

El primer paso es configurar el cortafuegos. Debian viene con ufw (Uncomplicated Firewall).

Compruebe si el cortafuegos está funcionando.

$ sudo ufw status

Debería obtener la siguiente salida.

Status: inactive

Permita el puerto SSH para que el firewall no rompa la conexión actual al habilitarlo.

$ sudo ufw allow OpenSSH

Permita los puertos HTTP y HTTPS también.

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

Habilitar el Firewall

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

Compruebe de nuevo el estado del cortafuegos.

$ sudo ufw status

Debería ver una salida similar.

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)

Paso 2 – Instalar Git

Instale Git.

$ sudo apt install git

Confirme la instalación.

$ git --version
git version 2.30.2

Paso 3 – Instalar Docker

Para instalar la última versión de Docker, añada la clave GPG oficial de Docker.

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

Instala el repositorio oficial de Docker.

$ 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

Actualice los repositorios del sistema Debian.

$ sudo apt update

Instale la última versión de Docker.

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

Verifique que Docker se está ejecutando.

$ 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

Por defecto, Docker requiere privilegios de root. Si quieres evitar usar sudo cada vez que ejecutes el comando docker, añade tu nombre de usuario al grupo docker.

$ sudo usermod -aG docker $(whoami)

Es necesario salir del servidor y volver a entrar como el mismo usuario para activar este cambio.Anuncio

Paso 4 – Instalar Docker Compose

La última versión disponible de Docker Compose es la 2.0.x, pero por razones de compatibilidad, instalaremos la v1.29.2, más antigua y estable.

Ejecute el siguiente comando para descargar la versión estable de 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

Aplique los permisos de ejecución al archivo binario.

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

Descargue e instale el script de finalización bash de 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

Ejecute el siguiente comando para aplicar los cambios.

$ source ~/.bashrc

Paso 5 – Descargar y configurar Supabase

Clone el Supabase repositorio Github.

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

El parámetro –depth 1 realiza un clon superficial del repositorio, es decir, sólo extrae los últimos commits y no todo el historial. Esto se hace para mejorar el rendimiento.

Cambia al directorio docker.

$ cd supabase/docker

Cree el archivo de entorno a partir del archivo de ejemplo.

$ cp .env.example .env

Abra el archivo recién creado para editarlo.

$ nano .env

Cambie el valor de la variable POSTGRES_PASSWORD con una contraseña única generada fuertemente.

$ POSTGRES_PASSWORD=<yourpostgresqlpwd>

Genere otra contraseña única con más de 32 caracteres sin caracteres especiales. Sustituya el valor de JWT_SECRET por esta contraseña.

JWT_SECRET=<your32pluscharacterspwd>

Puede utilizar un generador de contraseñas online como Bitwarden o 1password para crear las contraseñas anteriores.

Abra el Sitio web de Supabase e introduzca su JWT_SECRET para generar una ANON_KEY. Pegue su JWT_SECRET en la casilla indicada, seleccione ANON_KEY en el Carga útil preconfigurada y haga clic en el menú desplegable Generar JWT para generar el token.

Generador de claves ANON de Supabase

Copie y pegue este token como valor de ANON_KEY en el archivo .env.

Del mismo modo, repita los mismos pasos para generar la SERVICE_KEY cambiando el Carga útil preconfigurada y pulsando la tecla Generar JWT botón.

Generador de Llaves de Servicio Supabase

Copie el token generado y péguelo como valor de SERVICE_KEY en el archivo .env.

Configure los ajustes de SMTP del correo electrónico configurando las siguientes variables. Estamos utilizando el servicio SES de Amazon para nuestro 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

Configurar la URL del sitio.

SITE_URL=https://supabase.example.com

Configurar la URL REST pública.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Los correos de autenticación enviados vía SMTP tendrán enlaces rotos debido a un error que prevalece en Supabase. Para solucionar este problema, abra el archivo docker-compose.yml.

$ nano docker-compose.yml

Añada la variable API_EXTERNAL_URL justo debajo de la variable GOTRUE_SITE_URL para que tenga el siguiente aspecto.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite. Este archivo se sobrescribirá cada vez que actualice su instalación de Supabase. Con suerte, el error se solucionará la próxima vez. Tendrás que añadir esta variable manualmente para asegurarte de que el error del correo electrónico no se repita.

Abra el archivo volumes/api/kong.yml para editarlo.

$ nano volumes/api/kong.yml

En la sección de consumidores, sustituya la clave del usuario anon por la ANON_KEY generada anteriormente.

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

Además, sustituya la clave del rol_de_servicio por la CLAVE_DE_SERVICIO generada anteriormente.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Paso 6 – Instalar Supabase

Ejecute Supabase utilizando el siguiente comando. Este proceso llevará algún tiempo.

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

Compruebe el estado de los contenedores en ejecución.

$ 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

Paso 7 – Instalar SSL

Para instalar un certificado SSL usando Let’s Encrypt, necesitamos instalar la herramienta Certbot.

Para ello utilizaremos el instalador de paquetes Snapd. Dado que la mayoría de los servidores de Debian no vienen con él, instale el instalador de Snapd.

$ sudo apt install snapd

Asegúrese de que su versión de Snapd está actualizada.

$ sudo snap install core && sudo snap refresh core

Instale Certbot.

$ sudo snap install --classic certbot

Utilice el siguiente comando para asegurarse de que el comando Certbot puede ser ejecutado creando un enlace simbólico al directorio /usr/bin.

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

Verifique la instalación.

$ certbot --version
certbot 1.25.0

Generar el certificado SSL.

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

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/supabase.example.com de su servidor.

Generar un Grupo Diffie-Hellman certificado.

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

Cree un directorio webroot de desafío para la renovación automática de Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Cree un Cron Job para renovar el SSL. Se ejecutará cada día para comprobar el certificado y renovarlo si es necesario. Para ello, primero cree el archivo /etc/cron.daily/certbot-renew y ábralo para editarlo.

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

Pegue el siguiente código.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Cambie los permisos del archivo de la tarea para que sea ejecutable.

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

Paso 8 – Instalar y configurar Nginx

Debian viene con una versión antigua de Nginx. Necesita descargar el repositorio oficial de Nginx para instalar la última versión.

Importe la clave de firma oficial de Nginx.

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

Añadir el repositorio de la versión estable de 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

Actualizar los repositorios de Debian.

$ sudo apt update

Instalar Nginx.

$ sudo apt install nginx

Verifique la instalación. Asegúrese de usar sudo cada vez que ejecute el comando Nginx en Debian. De lo contrario, no funcionará.

$ sudo nginx -v
nginx version: nginx/1.20.2

Cree y abra el archivo /etc/nginx/conf.d/supabase.conf para editarlo.

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

Pegue el siguiente código en él.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite una vez que haya terminado.

Abra el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Verifique la sintaxis del archivo de configuración de 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

Inicie el servicio Nginx para habilitar la nueva configuración.

$ sudo systemctl start nginx

Paso 9 – Acceso a Supabase

Ahora puede acceder a Supabase a través de la URL https://supabase.example.com en su navegador web.

Estudio Supabase

No se pueden crear nuevos proyectos, pero se pueden gestionar los existentes y configurar la base de datos, el almacenamiento y la autenticación.

Paso 10 – Habilitar la autenticación HTTP

Supabase no proporciona gestión de usuarios, por lo que necesita asegurar su instalación de Supabase. La forma más fácil de hacerlo es habilitar la autenticación HTTP usando el servidor Nginx.

Instale el paquete apache2-utils para Nginx.

$ sudo apt install apache2-utils

Cree un archivo de contraseñas para el usuario supabase. Puede elegir cualquier nombre de usuario que desee. Le pedirá una nueva contraseña. Introduzca una contraseña fuerte para terminar de configurar el archivo.

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

La bandera -c indica a la utilidad que cree un nuevo archivo. Si omite el archivo, deberá especificar la ubicación de un archivo existente.

Abra el archivo /etc/nginx/conf.d/supabase.conf para editarlo.

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

Realice los cambios en las siguientes secciones del archivo, como se muestra a continuación.

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

Guarde el archivo pulsando Ctrl + X e introduciendo Y cuando se le solicite.

Verifique la configuración.

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

Reinicie el servicio Nginx.

$ sudo systemctl restart nginx

La próxima vez que abra Supabase, será recibido con la siguiente pantalla de inicio de sesión.

Autenticación HTTP de Supabase Nginx

Paso 11 – Actualizar Supabase

Supabase es un producto en constante progreso y sufrirá constantes cambios. Si lo utiliza como una instancia auto-alojada, debe mantener su instalación de Supabase actualizada.

Cambie al directorio de Supabase.

$ cd ~/supabase

Extraiga el último repositorio de Github.

$ git pull

Busque cualquier cambio en los archivos docker/.env, docker/volumes/api/kong.yml para cualquier cosa que requiera reconfiguración.

Cierre y limpie los contenedores Docker existentes.

$ docker-compose down --remove-orphans

Saque las últimas imágenes.

$ docker-compose pull

Inicie los contenedores de nuevo.

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

Conclusión

Esto concluye nuestro tutorial sobre la instalación de Supabase en un servidor basado en Debian 11 utilizando el servidor Nginx como proxy inverso. Si tiene alguna pregunta, publíquela en los comentarios a continuación.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *