montar un relay nostr

Montar un relay no es muy difícil. Necesitarás algo de soltura en la terminal y conocimientos básicos de Docker, pero debería ser asequible para la mayoría.

En esta guía te enseño cómo montar tu propio relay con strfry (un relay de Nostr moderno y rápido, escrito en C++) y Caddy delante para darte HTTPS automático.

pre-requisitos

• Un dominio. Puedes comprar uno en Njalla, que acepta criptomonedas y cuida la privacidad. Namecheap también acepta Bitcoin. Porkbun es otra buena opción.
• Un servidor. Puedes alquilar un VPS pequeño por unos pocos euros al mes en Netcup, Hetzner o DigitalOcean. Para opciones centradas en la privacidad, mira kycnot.me.

requisitos

• Hardware: nada especial. Los eventos son solo texto, así que el almacenamiento crece despacio. Un VPS con 1GB de RAM es más que suficiente para un relay personal o de comunidad pequeña.
• Sistema: recomiendo una versión reciente de Debian o Ubuntu si no tienes preferencia.
• Software: git, docker y docker compose.

Una vez tengas eso, ya puedes empezar.

dns

Antes de tocar Caddy, asegúrate de haber añadido un registro A (y/o AAAA) en tu dominio apuntando a la IP del servidor. Algo como relay.example.com está bien. Caddy lo usará para obtener el certificado TLS de Let's Encrypt.

configuración

preparación base

1. Conéctate a tu servidor por SSH y crea una carpeta para el relay: mkdir -p ~/nostr-relay && cd ~/nostr-relay
2. Crea las carpetas de datos y config: mkdir -p data strfry

Ahora crea strfry/strfry.conf con este contenido. Edita los campos name, description, pubkey y contact para que el relay se identifique bien (el pubkey debe ser tu clave pública en hex, no tu npub):

# strfry.conf, config mínima
db = "/app/strfry-db/"

relay {
    bind = "0.0.0.0"
    port = 7777

    info {
        name        = "mi relay nostr"
        description = "un relay personal"
        pubkey      = "TU_PUBKEY_HEX"
        contact     = "tu@example.com"
    }

    maxWebsocketPayloadSize = 131072
    autoPingSeconds         = 55
    enableTcpKeepalive      = true

    writePolicy {
        plugin = ""   # apunta a un script si quieres filtrar a medida
    }

    compression {
        enabled       = true
        slidingWindow = true
    }
}

Si quieres ver todas las opciones, el ejemplo completo de configuración vive en el repo de strfry.

Después crea un docker-compose.yml en ~/nostr-relay. Las etiquetas caddy.* le dicen a nuestro proxy inverso que descubra este servicio automáticamente (configuramos el proxy en el siguiente paso):

services:
  strfry:
    image: dockurr/strfry:latest
    container_name: strfry
    restart: unless-stopped
    volumes:
      - ./data:/app/strfry-db
      - ./strfry/strfry.conf:/app/strfry.conf:ro
    networks:
      - caddy
    labels:
      caddy: relay.example.com
      caddy.reverse_proxy: "{{upstreams 7777}}"

networks:
  caddy:
    external: true

Reemplaza relay.example.com por tu dominio. Los clientes se conectarán con wss://relay.example.com.

Levántalo:

1. Crea la red Docker compartida: docker network create caddy
2. Arranca el relay: docker compose up -d
3. Mira los logs: docker compose logs -f. Deberías ver strfry escuchando en 0.0.0.0:7777.

El relay está corriendo dentro de la red Docker, pero todavía no es accesible desde fuera. Ahora le ponemos un proxy delante para HTTPS.

proxy (caddy-docker-proxy)

Usamos caddy-docker-proxy, una build de Caddy que lee etiquetas de los contenedores en marcha y se autoconfigura. Sin Caddyfile que mantener. Añadir más servicios después es solo cosa de ponerles etiquetas.

Si ya tienes tu propio proxy inverso (nginx, Caddy a secas, Nginx Proxy Manager, etc.), solo ponlo en la misma red Docker caddy y reenvía a strfry:7777. Si no, sigue aquí.

1. Crea una carpeta nueva al mismo nivel que nostr-relay: mkdir ~/caddy && cd ~/caddy
2. Crea un docker-compose.yml:

services:
  caddy:
    image: lucaslorentz/caddy-docker-proxy:ci-alpine
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      - CADDY_INGRESS_NETWORKS=caddy
      - CADDY_DOCKER_CADDYFILE_PATH=/config/Caddyfile
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - caddy

volumes:
  caddy_data:
  caddy_config:

networks:
  caddy:
    external: true

Levántalo:

1. docker compose up -d
2. docker compose logs -f caddy, y mira cómo recoge las etiquetas de strfry y obtiene el certificado de Let's Encrypt.

comprobar que funciona

1. Abre https://relay.example.com en el navegador. Deberías ver un JSON pequeño con la información de tu relay (eso es NIP-11).
2. Desde cualquier cliente Nostr, añade wss://relay.example.com a tu lista de relays y publica una nota.
3. Para algunas estadísticas: docker exec strfry strfry info

Y ya está. Tienes tu propio relay. Anúncialo en Nostr para que otra gente lo use, o guárdatelo como archivo personal.

siguientes pasos

• Copias de seguridad. Lo importante está en ~/nostr-relay/data/. Haz snapshots.
• Filtrado de spam. strfry admite scripts de política de escritura que puedes usar para listas blancas o filtrado por web of trust. Mira los docs de plugins.
• Sincronizar con otros relays. strfry soporta negentropy, una forma eficiente de que dos relays averigüen qué eventos tienen en común. Ejecuta strfry sync wss://otro-relay para replicar o rellenar.
• Aparecer en listados. Registra tu relay en nostr.watch para que la gente lo encuentre.