¿Qué cabe en un VPS de menos de 2€?

Introducción 

Escribo este post para inaugurar el blog, y en este caso, va a ir dedicado a explicar a cualquier que quiera empezar en el mundillo del self-hosting como puedes conseguir alojar en un VPS de menos de 2€/mes el máximo de servicios posibles.

Me voy a centrar en una selección de servicios que pueden ser de utilidad para la mayoría de usuarios, sin entrar en soluciones especificas y/o más complejas de instalar, o que requieran más recursos. 

Esta es la selección:

  • Tailscale como servidor VPN
  • Vaultwarden como gestor de contraseñas
  • TriliumNext Notes como alternativa a Notion 
  • Downtify como alternativa a Spotify

Además de los servicios, vamos a colocar un script encargado de hacer copias de seguridad cifradas contra Mega.

Contratación del VPS con Racknerd 

https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/png/racknerd.png 

Para cumplir este objetivo, me he decidido por un VPS de Racknerd que cuenta solo con 512 MB de RAM, 1 vCPU y 30 GB de disco, además de este hardware tan pobre, el servidor cuenta con otra limitación importante que tenemos que conocer, solo permite transferir 500 GB al mes.

Como sistema operativo vamos a instalar Ubuntu 26.04, podríamos ir a algo más viejo, pero lo suyo es esta versión para tener más tiempo hasta que quede fuera de soporte.

En cuanto a la ubicación geográfica, podemos dejar Los Angeles que es la que viene por defecto, o cambiarla por alguna de las que nos proponen, esto a gusto de cada uno/a.

Optimización

Al tratarse de un servidor con muy pocos recursos, vamos a tener que exprimirlos al máximo, así que antes de nada, vamos a ejecutar el siguiente comando que se encarga de crear y ejecutar un script de optimización para deshabilitar algunos servicios que no usaremos y instalar y configurar el uso de ZRAM, esto lo que permite es que la información que se guarda en RAM esté comprimida para ocupar menos:

cat << 'EOF' > optimizar-vps.sh
#!/usr/bin/env bash
set -euo pipefail

if [ "$EUID" -ne 0 ]; then
  echo "Por favor, ejecuta este script como root (sudo bash $0)"
  exit 1
fi

echo "=== [1/6] Esperando a que terminen las actualizaciones en segundo plano ==="
while pgrep -f "unattended-upgrade|apt\.systemd\.daily|dpkg" | grep -qv "^$(pgrep -f 'shutdown --wait-for-signal' || echo 0)$"; do
  echo "  -> Procesos de apt/dpkg activos. Esperando 10 segundos..."
  sleep 10
done
echo "  -> Sistema libre de bloqueos."

echo "=== [2/6] Configurando ZRAM nativo sobre Swap existente (/dev/vda3) ==="
if dpkg-query -W -f='${Status}' zram-tools 2>/dev/null | grep -q "install ok installed"; then
  systemctl disable --now zramswap.service >/dev/null 2>&1 || true
  DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=-1 purge -y zram-tools >/dev/null
fi

DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=-1 update -qq
DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=-1 install -y systemd-zram-generator >/dev/null

echo "zram" > /etc/modules-load.d/zram.conf

cat <<INNER_EOF > /etc/systemd/zram-generator.conf
[zram0]
zram-size = ram / 2
compression-algorithm = zstd
swap-priority = 100
fs-type = swap
INNER_EOF

systemctl daemon-reload
systemctl start systemd-zram-setup@zram0.service

cat <<INNER_EOF > /etc/sysctl.d/99-low-ram.conf
vm.swappiness=100
vm.vfs_cache_pressure=50
INNER_EOF
sysctl -p /etc/sysctl.d/99-low-ram.conf >/dev/null
echo "  -> ZRAM activado (PRIO 100) + partición /dev/vda3 nativa (PRIO -1)."

echo "=== [3/6] Acotando logs del sistema (journald) ==="
mkdir -p /etc/systemd/journald.conf.d
cat <<INNER_EOF > /etc/systemd/journald.conf.d/size.conf
[Journal]
SystemMaxUse=50M
RuntimeMaxUse=15M
INNER_EOF
systemctl restart systemd-journald
echo "  -> Límite de logs establecido (50M disco / 15M RAM)."

echo "=== [4/6] Desactivando servicios innecesarios y bloqueos de arranque ==="
SERVICIOS_BLOQUEAR=(
  "rsyslog.service"
  "ModemManager.service"
  "multipathd.service"
  "multipathd.socket"
  "iscsid.service"
  "iscsid.socket"
  "open-iscsi.service"
  "systemd-networkd-wait-online.service"
  "unattended-upgrades.service"
)

for svc in "${SERVICIOS_BLOQUEAR[@]}"; do
  if systemctl list-unit-files "$svc" 2>/dev/null | grep -q "$svc"; then
    systemctl disable --now "$svc" >/dev/null 2>&1 || true
    systemctl mask "$svc" >/dev/null 2>&1 || true
    echo "  -> Deshabilitado y enmascarado: $svc"
  fi
done

echo "=== [5/6] Eliminando paquetes pesados opcionales ==="
PAQUETES_CANDIDATOS=(fwupd udisks2 packagekit snapd appstream)
PAQUETES_INSTALADOS=()

for pkg in "${PAQUETES_CANDIDATOS[@]}"; do
  if dpkg-query -W -f='${Status}' "$pkg" 2>/dev/null | grep -q "install ok installed"; then
    PAQUETES_INSTALADOS+=("$pkg")
  fi
done

if [ ${#PAQUETES_INSTALADOS[@]} -gt 0 ]; then
  echo "  -> Purgando: ${PAQUETES_INSTALADOS[*]}"
  DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=-1 purge -y "${PAQUETES_INSTALADOS[@]}" >/dev/null
fi

DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=-1 autoremove -y >/dev/null
apt-get clean
echo "  -> Limpieza de paquetes completada."

echo "=== [6/6] Asegurando arranque estable y consola VNC en GRUB ==="
if [ -f /etc/default/grub ]; then
  sed -i 's/^GRUB_CMDLINE_LINUX_DEFAULT=.*/GRUB_CMDLINE_LINUX_DEFAULT="nomodeset"/' /etc/default/grub
  update-grub >/dev/null 2>&1
  echo "  -> GRUB actualizado con nomodeset."
fi

echo ""
echo "=========================================================="
echo " OPTIMIZACIÓN COMPLETADA"
echo "=========================================================="
free -h
echo ""
swapon --show
echo ""
echo "Reinicia el servidor ahora con: reboot"
EOF
chmod +x optimizar-vps.sh && ./optimizar-vps.sh

Una vez acabe de ejecutarse, reiniciamos el servidor tal y como nos pide y pasados unos 30 segundos volvemos a conectarnos.

Instalación de Docker 

https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/png/docker-engine.png 

Ahora ya podemos instalar Docker tal y como se indica en su documentación oficial:

 https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository

Instalación de la VPN de Tailscale

https://cdn.jsdelivr.net/gh/selfhst/icons/png/tailscale.png 

También vamos a dejar instalado Tailscale como VPN

sudo curl -fsSL https://tailscale.com/install.sh | sh 

Ponemos tailscale up y seguimos las instrucciones para hacer login en nuestra cuenta

Solo con esto ya tendrías una VPN para navegar de forma segura si estás en una red no segura como la WI-FI de un hotel, universidad, bar... pero recuerda, 500 GB de transferencía, así que se puede usar para navegar por internet, pero si nos ponemos a ver videos va a durar poco...

Instalación y configuración de Vaultwarden como gestor de contraseñas 

 https://cdn.jsdelivr.net/gh/selfhst/icons/png/vaultwarden.png

Llegados a este punto, aun siendo un servidor tan pequeño, todavía tiene capacidad para correr algunos servicios más, así que vamos a poner un gestor de contraseñas como es vaultwarden, para ello, si no quieres gastar un euro más en registrar dominios, te recomendaría ir a https://duckdns.org y registrar un subdominio gratuito, algo como tu-vault.duckdns.org, ten en cuenta que al hacer el registro desde tu PC, automáticamente quedará asociado a tu IP pública, tienes que cambiarla por la IP del VPS. 

Preparación del certificado SSL 

Lo siguiente será crear una carpeta llamada vaultwarden, ir a su interior y crear una nueva carpeta llamada "ssl" donde irá el certificado SSL que usará vaultwarden. Hecho esto nos pondrmeos a crear algunos scripts y archivos de configuración, pero para ello ten en cuenta que como estás usando una versión minimzada de ubuntu, tendrás que instalar un editor, por defecto no viene, así que podemos por ejemplo instalar nano con este comando: sudo apt install nano

Puestos a instalar, también vamos a necesitar socat y cron ya que el script que tendremos para obtener y renovar el certificado usa estas herramientas, así que ejecutamos:

sudo apt install socat

sudo apt install cron 

Ahora ya sí, vamos a por los scripts, el primero podemos descargarlo con este comando:

curl https://get.acme.sh | sh -s email=tu_direccion@gmail.com source ~/.bashrc

Ejecutamos el script para obtener el certificado:

~/.acme.sh/acme.sh --issue --standalone -d tuvault.duckdns.org --server letsencrypt 

 Lo instalamos en la ruta que usará vaultwarden, con esto ya se renovará cuando corresponda automáticamente:

~/.acme.sh/acme.sh --install-cert -d tuvault.duckdns.org --cert-file ~/vaultwarden/ssl/cert.pem --key-file ~/vaultwarden/ssl/key.pem --fullchain-file ~/vaultwarden/ssl/fullchain.pem --reloadcmd "docker restart vaultwarden" 

Dará un error, pero es normal, es porqué todavía no tenemos el contenedor de vaultwarden, podemos ignorarlo.

Contraseña de aplicación en Gmail

Vaultwarden permite (y yo te recomiendo) configurar SMTP, esto nos permite recibir en primer lugar el correo de verificación al registrarnos, y en segundo lugar, recibir notificaciones para ciertos eventos que ocurran.

Para poder aplicar la configuración SMTP de gmail que verás más adelante es necesario que crees lo que se conoce como una "contraseña de aplicación", esto lo puedes hacer desde el siguiente enlace: https://myaccount.google.com/apppasswords es posible que para hacerlo te pida activar el doble factor de autenticación (cosa que por otro lado, te recomiendo tener hecha).

Nota: la contraseña que generes puedes ponerla sin espacios 

Instalación del contenedor 

 Ahora creamos con el editor nano el archivo "compose.yml" con el sigueinte contenido:

services:
  vaultwarden:
    image: vaultwarden/server:latest-alpine
    container_name: vaultwarden
    restart: unless-stopped
    mem_limit: 96m
    cpus: 0.75
    ports:
      - "443:80"
    environment:
      - DOMAIN=https://tuvault.duckdns.org
      - SIGNUPS_ALLOWED=true
      - WEBSOCKET_ENABLED=true
      - ROCKET_TLS={certs="/ssl/fullchain.pem",key="/ssl/key.pem"}
      - SMTP_HOST=smtp.gmail.com
      - SMTP_FROM=tu@gmail.com
      - SMTP_FROM_NAME=Vaultwarden
      - SMTP_SECURITY=starttls
      - SMTP_PORT=587
      - SMTP_USERNAME=tu@gmail.com
      - SMTP_PASSWORD=tu_contraseña_app
      - SMTP_TIMEOUT=15
    volumes:
      - ./vw-data:/data
      - ./ssl:/ssl:ro

Ahora, desde /root/vaultwarden, levantamos el contenedor con docker compose up -d

Pasados unos segundos podmeos acceder vía web y registrarnos

Cuando estemos registrados, modificamos en el compose.yml la variable SIGNUPS_ALLOWED poniendo su valor a false para evitar que otra persona pueda registrarse sin permiso y reiniciamos con esl siguiente comando:

docker compose down && docker compose up -d

Instalación de  Trilium

https://cdn.jsdelivr.net/gh/selfhst/icons/png/trilium-notes.png 

Para instalar Trilium volvemos a entrar a nuestra cuenta de DuckDNS, creamos otro subodminio (por ejemplo mitrilium.duckdns.org) y apuntamos a la IP del VPS. Luego vamos a crear su carpeta (/root/trilium), y dentro de esta una nueva carpeta "ssl" para guardar el certificado correspondiente.

Ejecutamos el siguiente comando para obtener el certificado:

~/.acme.sh/acme.sh --issue --standalone -d mitrilium.duckdns.org && ~/.acme.sh/acme.sh --install-cert -d mitrilium.duckdns.org --cert-file /root/trilium/ssl/cert.pem --key-file /root/trilium/ssl/key.pem --fullchain-file /root/trilium/ssl/fullchain.pem --reloadcmd "chown -R 1000:1000 /root/trilium/ssl && docker restart trilium" 

Volveremos a ver un error que podemos ignorar, es por lo mismo que antes, el contenedor todavía no está levantado. 

Ahora creamos el compose.yml con este contenido:

services:
  trilium:
    image: triliumnext/notes:latest
    container_name: trilium
    restart: unless-stopped
    mem_limit: 165m
    cpus: 0.60
    ports:
      - "8443:8080"
    environment:
      - TRILIUM_DATA_DIR=/home/node/trilium-data
    volumes:
      - ./data:/home/node/trilium-data
      - ./ssl:/ssl:ro 

La primera vez que se ponga el contenedor en marcha no será todavía accesible por https, esto es porqué en el caso de trilium a diferencia de vaultwarden, las variables de entorno no permiten configurar el certificado, aquí se tiene que hacer desde su archivo de configuración, así que una vez levante, vamos a ello.

Editamos con nano el archivo config.ini que estará en el volumen data y en el bloque [Network]:

  • Ponemos https a true
  • Ponemos en certPath=/ssl/fullchain.pem
  • Ponemos en keyPath=/ssl/key.pem 

 Reinicimamos el contenedor: docker restart trilium

 En cuanto vuelva a arrancar ya podremos entrar vía web para hacer la configuración inicial: https://tutrilium.duckdns.org:8443/

Por defecto, Trilium solo pide una contraseña para entrar, yo te recomendaría que añadas TOTP o si eres un usuario/a más avanzado un proveedor de identidad como Google. 

Instalación de Downtify

 https://cdn.jsdelivr.net/gh/selfhst/icons/png/downtify.png

Vamos con este último servicio, asi que volvemos a DuckDNS y creamos un tercer registro apuntando a la misma IP del VPS, algo como midowntify.duckdns.org.

Luego en el VPS creamos su correspondiente carpeta (/root/downtify) y en su interior creamos el compose.yml con este contenido:

services:
  downtify:
    image: ghcr.io/henriquesebastiao/downtify:latest
    container_name: downtify
    restart: unless-stopped
    mem_limit: 145m
    cpus: 0.70
    ports:
      - "8000:8000"
    environment:
      - TZ=Europe/Madrid
    volumes:
      - ./downloads:/app/downloads

Lo levantamos con docker compose up -d y una vez levante ya podremos entrar vía web por http://midowntify.duckdns.org:5000 con las credenciales: admin / downtify

Aplicaciones móviles

Android & IOS App – M MR Software 

Una  vez tengamo los 3 contenedores en marcha, ya solo nos queda configurarlo en nuestros dispositivos.

  • En el caso de tailscale tienes que instalar la aplicación (está tanto para Windows, Mac y Linux como para iOS y Android)
  • En el caso de vaultwarden, hay que usar la aplicación o extensión de Bitwarden (está para todos los navegadores y sistemas operativos)
  • En el caso de Trilium y Downtify desde PC, Linux y MacOS lo usaremos vía web, y desde Android y iOS podemos bajar la aplicación correspondiente. 

Copias de seguridad contra Mega

 

Comentarios

Entradas populares de este blog

136. El blog del podcast

129. Smart Launcher 6