NyL

¿RSS? ¿Pero éso no está muerto? Pues sí... y no. Sin duda tienen mucha menos relevancia de lo que lo tuvieron con el glorioso advenimiento de las omnípodas y ubícuas redes sociales, pero por lo menos para mí, volver a los RSS, amén del viaje por Villa Nostalgia me trajeron jugosos beneficios.

¿Bueno, pero ésto de qué va?

Un agregador de rss en nuestro server, ¿por qué habríamos de hacerlo si hay apps ya específicas para éso? Porque lo podemos tener sincronizado entre todos nuestros dispositivos. Porque configuro una única vez y si borro la app del móvil me da igual porque la configuración sigue en el server y... y porque podemos, qué leche.

Como muchísima otra gente, tuve mi época de entrar en Twitter para enterarme de lo que estaba pasando y creo que como muchísima otra gente hice el viaje (hace unos añitos ya) de enterarme de lo que estaba pasando a que me embutieran propaganda garganta abajo. Aparte, se me iba el tiempo miserablemente. Cada vez que cerraba la app tenía la sensación que por cada tres minutos de información útil se habían ido quince de comer mierda digital y más o menos por ésa época fue cuando empecé a acordarme otra vez de los RSS.

Noticias de portada, vídeos de Youtube de canales específicos (sí, puedes seguir un canal de YouTube a través de RSS sin login ni historias), información de conciertos, ofertas laborales, feed de eventos... tengo un poquito de todo lo que me interesa y cada vez que abro la app que se conecta a mi server me pongo al día. Leo los titulares de lo que hay y entro en lo que me interesa. Si no tengo tiempo, lo guardo para más tarde en el móvil, por ejemplo y al llegar a mi casa, lo leo tranquilamente en mi ordenador.

Para mí, un lujo. Y para mi paz mental, un disfrute.

¿Qué vamos a montar?

Cómo decíamos, un servidor de RSS. He decidido dejar de poner los docker-compose porque primero, son redudantes y segundo, se encuentran bien facil así que os digo lo que uso y y por qué a ver si os vale. Uso FressRSS.

La buena gente de LinuxServer [mantiene una imagen muy actualizadita y muy bien en lo general] (https://docs.linuxserver.io/images/docker-freshrss/)

Y podemos ver qué pinta tiene si os enlazo por aquí una imagen desde la página de [FreshRSS] (https://freshrss.org/)

FreshRSS

Es sencillo, limpio, ligero, facil de configurar, en general me ha dado muchísimos menos problemas que otras opciones y tiene algunas capacidades que son la leche. Por ejemplo, puedo enchufarlo a autores de Medium y que me salgan en el feed o hacer Webscraping de páginas que no tienen RSS configurado.

Es mi sitio al que ir a leer qué está pasando en el mundo. Es relativamente sencillo encontrar el RSS de las portadas o secciones de periódicos que os interesen o se puede agregar también el feed de portada de otro agregador.

Entro en casa a menudo desde la web del server o utilizando RSS Guard Lite en Linux. En Android utilizo Readrops. En iOS, mi mujer usa Readkit y no le da problemas de ninguna clase.

Adiós redes sociales, hola noticias

Entre que andaba de las redes sociales hasta la taba y que aquello se iba engorrinando por días, pensaba entonces en qué iba a echar de menos cuando las cerrase e indudablemente eran las noticias.

Fue volver a abrazar el mundo de las RSS y cerrar las redes sociales eventos casi continuados.

De repente para mí ya no tenía ningún sentido recibir el enlace de una fuente con algún comentario a menudo torticero sobre el cuerpo de la noticia. Al tener la fuente configurada podía decidir por mí mismo qué leer, cómo, cuando y donde y sin todo el ruido alrededor de la información.

Si lo conocísteis y lo abandonasteis, como yo, merece la pena reconsiderarlo. Si nunca lo habéis usado, os invito a probarlo con paciencia.

Estoy seguro que os va a gustar.

La frase es de 1939, la película, caballero sin espada. Cualquiera pensaría que hoy en día hay dos maneras de consumir (y digo consumir) contenido audivisual: Ver la tele, que la sigue viendo mucha gente y algunos suspiramos porque la tele evolucione a otros sitios más sanos o el vídeo bajo demanda en streaming (Netflix, HBO, Disney+, Hulu... qué se yo). Y ya.

O no.

¿Bueno, pero ésto de qué va?

Hay otra opción. Para mi, la versión digital de lo que hemos hecho toda la vida, meter una cinta en el vídeo o un DVD en el reproductor. Ésa manera de acercanos a la cultura exige un cierto foco y sobre todo demanda una elección previa: Voy a ver ésto

¿Sabéis la cosa ésta típica de que vas a ver algo en Netflix, tienes hora y media e inviertes cincuenta minutos en buscar qué ver? Pues a la segunda vez que me pasó dejé de hacerlo.

No me gusta acercarme a la cultura así y por otro lado tiene una deriva más filosófica que comprende si veo lo que quiero o lo que me dicen que quiero ver, pero éso es otro tema.

De lo que va ésto es de, como ya hemos explorado cómo enchufar un server, y cómo usar docker para desplegar cosas, poder montar en nuestro cacharro un servidor de streaming de vídeo al que podamos acceder con apps y ver nuestras películas y series (y fotos y música si queremos) desde cualquier parte del mundo accediendo a nuestro propio contenido del que somos dueños.

Para éso, podemos desplegar Jellyfin, por ejemplo, que es mi solución favorita aunque podemos tirar por otras opciones como Plex o Emby. Hoy vamos a explorar juntos un formato nuevo de post que consiste en que me voy a hacer unas preguntas y respuestas a mí mismo, a ver si así aligero un poco el texto. Vamos allá.

¿Qué vamos a montar?

Cómo decíamos, un servidor de streaming de vídeo open source para acceder a nuestro contenido cultural desde cualquier parte del mundo respetuoso con nuestra privacidad. En éste caso, Jellyfin.

¿Hay otras opciones?

Sí, claro, hay otros proyectos como Plex o Emby.

¿Y por qué Jellyfin?

Jellyfin es un fork (un derivado) de lo que fue Emby. El proyecto inicial fue Emby pero en algún momento decidieron dejar de ser open source (que está bien) y de ahí surgió Jellyfin. Su foco hoy por hoy consiste en permanecer open source y la privacidad de los usuarios de su software.

Plex surge mucho antes y ofrece otras cosas, como una integración con servicios más cuidada y un interfaz más apañao, como con Emby, muchas opciones son de pago.

Vamos que no usas Plex porque hay que pagar

Pues no, la verdad. He sido cliente de Plex desde 2010. La cosa es que la cantidad de información que recogen sobre mí (todo el metadato de mi colección de elementos culturales) me hace sentir incómodo y no quiero hostear éso en mi casa.

Vale, que estás girado vamos ¿Y con el Jellyfin ése cuando esté montado cómo lo uso?

Tú despliegas el server (la configuración es elemental), le dices dónde está tu carpeta con películas, dónde está tu carpeta con series y el server hace lo suyo. Cuando esté todo montado, te bajas tu app de móvil, de tablet, tu plugin de Kodi para tu mediacenter o tu app para tu SmarTV (que imagino que tendrá) o entras a través de un navegador desde donde te da la gana que para éso es tu server.

¿Y cómo se despliega éso que dices

Pues fácil. De igual manera que montamos en su momento un servidor de streaming de música y lo metimos detrás de un proxy inverso para no hacer el canelo con la red de casa y no abrir puertos en el router, nos hacemos un docker-compose de ésos, lo levantamos y a gozar. Os dejo aquí el mío:

version: '3'
services:
  jellyfin:
    image: jellyfin/jellyfin
    container_name: jellyfin
    volumes:
      - *ruta_a_vuestro_directorio_para_almacenar_la_configuración*:/config
      - *ruta_a_vuestro_directorio_para_almacenar_la_cache*:/cache
      - *ruta_a_la_carpeta_donde_tengais_las_series*:/tv
      - *ruta_a_la_carpeta_donde_tengais_las_peliculas*:/movies
    environment:
      - JELLYFIN_PublishedServerUrl=*la_url_que_vayais_a_configurar*
    devices:
      - /dev/dri:/dev/dri
    network_mode: host
    restart: always

Como siempre, varios comentarios aquí:

  • Aparece algo que no hemos usado antes una entrada devices que tiene /dev/dri. Es una entrada para que el contenedor pueda usar la aceleración de hardware, viene explicado al final de ésta página
  • ¿En la red host? Sí. Simplifica bastante el acceso desde fuera de casa
  • ¿Hay que hacer algo especial en el proxy inverso? Nada, hacéis la entrada y a funcionar
  • Si tenéis varias carpetas, cada una va en una línea distinta de la configuración de volumes.

Oye, mira, lo que tú quieras pero puestos a meterme en éste berenjenal, me convence más Plex ¿No hay un docker-compose de ésos para Plex?

Pues claro, aquí tenemos de todo. La gente de LinuxServer mantiene un contenedor muy apañao como éste:

version: "3.1"
services:
  plex:
    image: 'lscr.io/linuxserver/plex:latest'
    container_name: plex
    environment:
      - TZ=Europe/Madrid
      - VERSION=docker
      - PLEX_CLAIM='vuestro_claim_de_Plex_(ver página de Plex)'
    volumes:
      - *ruta_a_vuestro_directorio_para_almacenar_la_configuración*:/config
      - *ruta_a_la_carpeta_donde_tengais_las_series*:/tv
      - *ruta_a_la_carpeta_donde_tengais_las_peliculas*:/movies
    devices:
      - /dev/dri:/dev/dri
    network_mode: host
    restart: always

Bueno, todo bien. Mi interesa lo de la privacidad y lo de tener mi propio Netflix por así decir, pero la cosa es que yo no tengo contenido que poner en mi server

Ya, ya lo sé. Y éso debería inquietarnos a todos un poco. Todo lo que no exista en un servicio que alquilas mensualmente, no existe y éso lo miremos por donde lo miremos no está bien

Ya joder, pero es que me toca pagar por él y ahora pago poco

Lo de que pagas poco es bastante discutible si uno suma la pasta a tres años, por ejemplo, pero vamos, sí. No veo mal pagar por la cultura, la verdad. Y ojalá existieran maneras de acceder a obras audiovisuales por otros canales, ¿verdad?

¿Verdad?

¡Ah! Aún recuerdo la primera vez que un compañero de trabajo me mostró Evernote. La arrogancia del inicio de mi madurez no me dejaba ver que no siempre iba a tener la misma memoria y aparte incluso en aquellos años, más de una década ya, no me sentía yo nada cómodo con la idea de poner aquellas cosas que yo considero más importantes en el servidor de una empresa americana que a saber qué hace con ése contenido.

¿Qué ha pasado hoy con Evernote? Pues más o menos lo mismo que con casi todas éstas empresas de servicio cloud barato que viene a cambiarte la vida, despidos de plantilla, adquisiciones, subidas de precios... en fin, a lo que ya debería uno estar acostumbrado.

Tomar notas es bueno. Y a veces hay tareas que hacer que requieren listas, como por ejemplo... la compra. Es más, es probable que quieras compartir tu lista de tareas con otra persona. Todo ésto es bueno y agradable.

Si bien éstas iniciativas de desplegar software en tu propio entorno pueden ser tomadas a veces como una suerte de neoludismo, lo cierto es que en la mayoría de los casos no es tanto el conflicto con la tecnología si no con quién es el propietario de ésta, pero... ¿y si pudiéramos montarnos nuestro propio Evernote? Con su aplicación de ordenador, de móvil. Con su lenguaje Markdown, con sus tags para clasificar sus notas, sus libretas para agrupar notas del mismo tipo, su capacidad de guardar texto e imágenes...

Pues podemos.

Hay, como siempre, muchas opciones, en éste humilde espacio llevamos años usando Joplin. De lo que hemos probado nos parece lo más apañao.

Como hemos tratado ya con cariño y detenimiento cómo montar cosas en contenedores y cómo acceder a ésas cosas desde fuera de casa sin recordar nombres raros ni abrir puertos en el router, vamos directamente a por el docker-compose.

version: '3'
services:
  app:
    image: joplin/server:latest
    container_name: joplin
    depends_on:
      - db
    ports:
      - "22300:22300"
    environment:
      - APP_PORT=22300
      - APP_BASE_URL=*https://tunombreparajoplin.tudominio.com*
      - DB_CLIENT=pg
      - POSTGRES_PASSWORD=*tu_password_de_base_de_datos*
      - POSTGRES_DATABASE=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PORT=5432
      - POSTGRES_HOST=db
      - MAILER_ENABLED=1
      - MAILER_HOST=*tu_dominio_de_envio_de_mail*
      - MAILER_PORT=*con_su_puerto*
      - MAILER_SECURE=1
      - MAILER_AUTH_USER=*el_usuario_que_envia_mails*
      - MAILER_AUTH_PASSWORD=*con_su_password*
      - MAILER_NOREPLY_NAME=*el_nombre_de_remitente*
      - MAILER_NOREPLY_EMAIL=*la_direccion_del_remitente*
    restart: always

  db:
    image: postgres:15.4
    container_name: joplin_db
    ports:
      - "5442:5432"
    volumes:
      - *tu_ruta_para_almacenar_la_base_de_datos*:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=*tu_password_de_base_de_datos*
      - POSTGRES_USER=joplin
      - POSTGRES_DB=joplin
    restart: always

Varios comentarios aquí, vamos a por ello:

  • Existe versión de docker tanto para cpu intel como para arm (en una Raspberry por ejemplo)
  • Las opciones de envío de mails son opcionales, si no queréis enviar mails las quitáis todas
  • Ésto de poner passwords en los docker-compose está feísimo, ya llegaremos a éso
  • Como véis, Joplin no requiere almacenamiento propio porque guarda todo en una base de datos. Podéis escoger entre SQLite o un Postgre. En mi caso, habiendo PostgreSQL que se quite todo lo demás

Y no hay que hacer nada más, ya lo tenéis chutando. Ahora os vais a vuestro proxy inverso que montamos hace un tiempo y le decís que todo lo que llegue al puerto 443 con nombre https://tunombreparajoplin.tudominio.com os lo redirija a la máquina donde esté el docker al puerto 22300 y a disfrutar de vuestro propio servidor de notas.

El servidor en realidad hace de correveidile entre las distintas apps que existen. Como decíamos, hay app para iOS, para Android, para Windows, Mac y Linux. Cuando creáis una nota (o borráis) en cualquiera de los clientes, el servidor lo sincroniza con el resto de los clientes.

¿Qué pinta tiene Joplin? Pues ésta (sacada de la página de Joplin):

Joplin

¿Qué podéis hacer con Joplin? Vamos a hacer una lista

  • Tomar notas (ja)
  • Listas de tareas
  • Guardar en las notas imágenes, vídeos, audios, expresiones matemáticas, diagrámas o integrarlo con la cámara de vuestro móvil
  • Compartir y publicar notas
  • Guardar páginas enteras desde el navegador

El servidor, que es open source os proporciona:

  • Soporte a Markdown y emojis (que es una cosa muy importante)
  • Gestión de usuarios
  • Sincronización entre todos los dispositivos
  • Cifrado extremo a extremo (E2EE)
  • Poner iconos cuquis en las notas
  • Búsqueda en las notas
  • Posibilidad de cambiar la pinta que tiene incluyendo estilado oscuro
  • Sincroniza a toda leche

Como véis es de lo más completo. Además se puede ampliar con plugins, pero no os lo cuento porque no me he metido yo con ése tema, la verdad.

Si lo probáis y os convence, os invito a pasaros por el github del desarrollador y darle un poco de cariño, que éstas cosas las hace la gente por amor a la tecnología.

https://github.com/laurent22/joplin

Ha sido a drede.

Desde Abril no escribo yo nada porque uno necesita tiempo para reposar, ampliar su espacio, leer, digerir. Éso o que no voy a contar a 2023 entre uno de mis mejores años, la verdad.

Pero lo auténticamente importante es que ya pasamos el trago de que si el servidor, que si el docker, que si la URL… todo lo de conectar cacharros y ahora podemos empezar a explorar cosas que podemos montar rápidamente.

No sabía por dónde empezar y estaba revisando qué tenía yo desplegado y viendo la lista de contenedores lo cierto es que al llegar a uno pensé: «Evidentemente, por aquí»

Empecemos por SearxNG.

¿Qué es SearxNG?

Pues un metabuscador. Ésto es y aterrizándolo al román paladino, una página web con forma de buscador en el que tú vas a poner lo que quieres buscar, pero el invento va a coger lo que tú has escrito, le va a quitar tu información personal, le manda la consulta a un montón de buscadores distintos (Google, Bing, DuckDuckGo… luego vemos más) y va a quitar los rastreadores de los resultados de la búsqueda.

Vamos, si queremos simplificarlo, es una capa de acceso a muchos buscadores a la vez orientado a la privacidad.

Nace de Searx, pero algunos desarroladores se montan su propio rollo con SearxNG. El proyecto original, más lento, más estable, con menos actualizaciones está más aún más orientado a la privacidad, pero carece de algunas de las funcionalidades.

Llevo tiempo pensando en dejar de usar Google, pero no quiero dejar de usar Google. Uso DuckDuckGo, pero al final estoy cambiando una empresa que me rastrea por otra Mogollón de gente

Ai fil llu, mai frien

La cosa es que no tienes por qué, a falta de proyectos interesantísimos que ya trataremos, SearxNG me parece una alternativa fiable, útil y elegante para ésas cuitas que te acucian.

Podemos registrarnos en cualquiera de las instancias que ya están en producción o lo que es muchísimo más interesante, montarnos la nuestra propia con docker en nuestro server. Vamos a echarle un vistazo a ése docker-compose bueno que nos abre la puerta a dejar de usar Google.

version: '3'
services:
  app:
    image: 'searxng/searxng:latest'
    container_name: searxng
    environment:
      - IMAGE_PROXY=yes
      - REDIS_URL=redis://redis:6379/0
      - BASE_URL=https://eldominio.detugüguel.com
      - NAME=TuGugüel  
    depends_on:
      - redis
    ports:
      - '8080:8080'
      - '22300:22300'
    restart: always

  redis:
    image: redis:6-alpine
    container_name: searxng_redis
    volumes:
      - ./redis:/data
    restart: "always"

Con lo que hemos visto anteriormente, nos hacemos una carpeta que se llamen searxng, así, por ejemplo, hacemos dentro nuestro docker-compose.yml y cascamos ése chorizo de ahí arriba,

Como veis no tiene nada que no hayamos comentado antes. Hay dos servicios en éste docker-compose éso, sí. Lo comentamos cuando deplegamos navidrome, en el mismo docker-compose podemos desplegar varias cosas a la vez y SearxNG utiliza Redis, que es una base de datos en memoria para…. bueno, da un poco igual para qué, incluso puede que sea opcional si no recuerdo mal.

Lo importante es que no tiene mucha historia el despliegue, tenemos un volumen para almacenar la información del redis en local y no perderla, al información de puertos de rigor y unas pocas variables para decirle a nuestra instancia cómo se llama y a qué debe atender cuando se haga mayor y esté en producción en nuestro servidor.

Tras guardar el fichero y hacer un docker-compose up -d si os vais a la dirección de vuestro servidor al puerto 8080, deberías ver algo la pantalla de búsqueda, fijaos que arriba a la derecha hay un menú de preferencias, vamos a darle a ver qué hay.

En las preferencias, tenéis varias opciones, creo que la mayoría autoexplicativas, pero quizás la parte más interesante son los engines. Ahí vamos a seleccionar qué servicios privados queremos que SearXNG use cuando nosotros hacemos una búsqueda.

¿A que está muy guay?

Probadlo un rato. Es más que probable que aunque vaya un poco más lento que un motor de búsqueda tradicional (porque estás usando varios) los resultados de tus búsquedas ofrezcan mejores respuestas y lo que es más interesante, como quita tus datos personales tanto del envío como de la respuesta, nos quitamos de un plumazo aquello en lo que parece que se han convertido algunos buscadores, un escaparate de tiendas o de servicios propios en su primera página.

SearXNG tiene motores para búsquedas de texto, imágenes, vídeos, noticias, música, artículos, redes sociales y ficheros.

Sí.

Torrents también.

La semana pasada no hubo fiesta, porque… porque no todos los días, pueden ser fiesta, pero vamos a darle un empujoncito a nuestro ecosistema casero servidoril.

De momento, nos habíamos hecho con un server de cualquier pelo, zambullido en docker y docker-compose, de paso, montado un server de streaming musical para escuchar toda nuestra música digital y habíamos solucionado lo de que dentro y fuera de la red de nuestra casa pudiéramos usar la misma URL, que no sólo venía bien para las cosas de la usación si no que además, nos quitaba de nuestra navegación por Internet las publicidades molestas que nosotros escogiésemos.

Nos queda una cosa por gestionar. Si habíamos dado un nombre a nuestro servidor musical y aquello iba bien, lo que no habíamos gestionado es lo del tema del puerto. Si quieren recordar ustedes, gentes de bien del Internet, usábamos la URL https://navimegatron.quieroserpropietario.com para acceder a nuestro servidor musical, peeeeeeeeeeeeeeeeeeeero, teníamos que poner un nombre de puerto. En concreto el 666 porque todos los días hay que escuchar a Black Sabbath.

Lo de poner un número de puerto para acceder a nuestras cosas self-hosted está feo, pero lo que está más feo que hacer mociones de censura a tontas y a locas es tener que abrir ése puerto en el router.

Porque claro, de momento nos hemos montado una única cosa, pero el plan aquí es montar mogollón de divertidos cachivaches, ¿Qué vamos a hacer?, ¿Abrir tantos puertos en nuestro router como cachivaches montemos?, ¿Invitamos a la gente a que se nos cuele en nuestra red casera con un letrero luminoso también?

No.

Está feo.

Está muy feo.

Como que te dejen en visto

La manera pro de solucionar ésto es ser una persona de provecho y montarte un Apache o un NGINX como Dio manda e ir por la vida con la frente bien alta. Pero la vida es demasiado breve como para hacer las cosas bien y no tener problemas así que vamos a apuntar más bajo, les presento, gentes de la gleba a Nginx Proxy Manager: https://nginxproxymanager.com/

Nginx Proxy Manager (en adelante NPM) es una versión canija y ligera de algo que se llama un proxy inverso.

¿Qué es un proxy inverso?

Pues en el punto en el que estamos se entiende bien. Nosotros tenemos un cachivache con una IP (la del server) y un puerto (el 666) y lo que queremos que pase es que la gente y nosotros mismos, que también somos bastante gente, ponga en su navegador o app https://navimegatron.quieroserpropietario.com y… «taca, a comer». Ni puertos, ni puertas ni historias. Y sobre todo no tener que ir abriendo agujeros en nuestro router.

Un proxy inverso, simplificando mucho burdamente pero yendo con ello, hace exáctamente éso, recibe una petición de una URL a un puerto (como es https, es el puerto 443) y lo traduce a una IP de nuestra red al puerto que nosotros le digamos. Y además es tan apañado que nos pide y renueva el certificado SSL necesario para que se pueda acceder por httpS:// en lugar de http://. Que hoy en día no se puede ir a ninguna parte sin certificado. Ni de navegación, ni de vacunación, ni de nada… hay que certificarse para no ser un tolili.

Visto lo que es, para lo que vale y por qué queremos una carretilla de proxys inversos, veamos como se monta.

Tiene poco misterio, lo de siempre, vamos a ver nuestro docker-compose de turno, aupa ahí:

version: "3"
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: npm
    ports:
      - '80:80' # Public HTTP Port
      - '443:443' # Public HTTPS Port
      - '81:81' # Admin Web Port
    environment:
      TZ: 'Europe/Madrid'
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "su_usuario_de_base_de_datos"
      DB_MYSQL_PASSWORD: "su_password_de_base_de_datos"
      DB_MYSQL_NAME: "su_nombre_de_base_de_datos"
      DISABLE_IPV6: 'true' #Dependiendo de lo que tengais
    volumes:
      - ruta_a_la_carpeta_de_npm/data:/data
      - ruta_a_la_carpeta_de_npm/letsencrypt:/etc/letsencrypt
      # - ruta_a_la_carpeta_de_npm/snippets:/config/nginx/snippets
      # - ruta_a_la_carpeta_de_npm/site-confs:/config/nginx/site-confs:ro
    depends_on:
      - db
    restart: always

  db:
    image: 'jc21/mariadb-aria:latest'
    container_name: npm_db
    environment:
      TZ: 'Europe/Madrid'
      MYSQL_ROOT_PASSWORD: 'su_password_de_base_de_datos para el root'
      MYSQL_DATABASE: 'su_nombre_de_base_de_datos'
      MYSQL_USER: 'su_usuario_de_base_de_datos'
      MYSQL_PASSWORD: 'su_password_de_base_de_datos'
    volumes:
      - ruta_a_la_carpeta_de_npm/db:/var/lib/mysql
    restart: always

Como véis, hay poca mandanga. Dos contenedores, uno de servicio y otro de base de datos. Las credenciales tienen que ser las mismas, claramente, porque si no, aquello no chufla y éste será el único contenedor que expondremos en el puerto 80 y 443. ¿Por qué?

Porque nos va a gestionar el acceso seguro al resto de cachivaches que montemos en nuestra red.

Cuando lo desplegueis si os vais a la IP del servidor en el puerto 81 os encontraréis una pantalla de login en la que podéis crear un usuario de administración.

Dentro de la administración, vamos a ver un ejemplo, que es el de nuestro servidor musical.

Nos vamos a ir a Proxy Hosts, que no tendremos ninguno (la caja verde) y le damos al botoncito de arriba a la derecha que pone Add Proxy Host.

Éste es el paso común que seguiremos para cada proxy, en éste caso que nos ocupa teníamos un nombre de dominio que queremos usar, un puerto en el que está y una IP de servidor, pues ésto es lo que vamos a hacer. Vamos a indicarle a NPM que todas las peticiones que lleguen a navimegatron.quieroserpropietario.com las mande a la IP del server al puerto 666, tal que así:

Que es algo muy hermoso.

NPM nos permite cachear objetos, bloquear algunos exploits y activart el soporte a Websockets. Ya sólo nos queda una cosa, que es gestionar el certificado SSL, para éso nos vamos a la tercera pestañita empezando por la izquierda:

Y le pedimos que nos pida (inception) un certificado SSL chachi pistachi.

No sólo lo va a pedir, también lo va a renovar cuando toque. Un gozo y una maravilla, oigan ustedes.

Y ya está. Le damos a guardar y a funcionar.

De ésta manera sólo tenemos un puerto abierto en el router (el 443), no tenemos que exponer el 666 de nuestro servidor musical y nos va a solucionar toda la mandanga de andar pidiendo certificados.

Con ésto ya podemos dar por cerrado el tema de redes, peticiones, cacharros, dominios, nombres y demás historias. Al menos de momento.

A partir de aquí, la fiesta del cachivache auto-desplegado electropositrónico.

Tenga ustedes buena semana, gentes de la gleba.

Bienaventurados seáis, gentes de Internet.

La semana pasada nos metimos un empacho magnífico explorando docker y docker-compose y de remate y aprovechando el tirón febril de abrazar tecnologías nuevas, nos montamos un servidor de música casero para nuestra propia música que aquello da gloria verlo, usarlo y gozarlo.

La cosa nos quedó muy bien y podíamos escuchar nuestra propia música en una web nuestra, en apps de móvil… en todas partes. Un gozo casi pecaminoso, ¿qué tal os ha ido?, ¿lo disfrutáis? Seguro que sí.

La cuestión es que funcionar, funciona fetén, pero desde el punto de vista de practicidad, nos quedó un poco regulinchi. Desplegamos un docker que exponía un puerto y nos tenemos que conectar a: http://la.ip.de.nuestroservidor:el_puerto_en_cuestión y ahí encontrábamos nuestro cacharro.

Ésto, es hermoso y está bien, pero introduce no pocos problemas.

Primero, que es un pestiño escribirlo en el navegador. Nos tenemos que acordar de la IP y del puerto. Eso no está bien. Lo segundo, que si queremos acceder desde fuera de la red de nuestra casa es exponencialmente peor.

Para empezar tenemos que abrir un puerto en el router al mundo, cosa que siempre nos debe dar yuyu. Y segundo y casí peor, si estamos fuera de casa, tenemos que poner nuestra IP pública, que claro, vuestro proveedor de Internet favorito tiene la costumbre de cambiarla. Además, si usáis una app móvil, tenéis que cambiar la dirección del servidor dependiendo de si estáis en casa o no.

Una puta mierda, vamos, resumiendo.

Vamos a ponerle solución. En éste post vamos a tratar el segundo y último tema que va a requerir que nos gastemos un dinerete. Que en realidad puede ser prácticamente grátis, pero es probable que haya que hacer algún dispendio. A demás va a requerir que investiguéis un poquitín qué opción os seduce más.

Lo primero que vamos a necesitar es un nombre de dominio. Digamos que os mola el dominio soberaniadigital.digital para entrar a las cosas de vuestro server. Pues nada, tendréis que mirar si el dominio está libre y pagarlo. Lo podéis comprar por un año, tres… un poco como veáis. Y huelga decir que para los nombres de dominio os podéis ir a un sitio carérrimo o a sitios como NameCheap que por pocos Eurillos os hacéis con vuestro nombre de dominio favorito. Por otro lado, el tema de la IP.

Si os habéis agenciado un server en la nube (Linode, CloudOcean, cosas así…) igual os dan una IP fija y ya no tenéis que hacer nada más. En ése caso os invito a investigar el registro de vuestro cacharro con CloudFlare que os dará muchas alegrías y bienaventuranzas.

Pero si os lo habéis montado en casa, tenemos que solucionar el tema de la IP cambiante. Hay servicios para ésto, que además son más viejos que el hilo negro, algunos clasicazos son No-IP o DuckDNS. DuckDNS, por ejemplo, es gratis, así que en realidad, dispendio, dispendio, os podéis montar ésto por muy poco dinero.

Yo personalmente, uso no-ip por una cuestión que veremos cuando os cuente lo del servidor de correo, pero como veáis.

Bueno. Pues digamos que ya lo tenemos. Tenéis un nombre de dominio y usando un servicio de actualización de IP dinámica, apunta a vuestra máquina.

Excelente.

Vamos a por el tema que nos ocupa, ¿cómo pasamos de acceder a nuestro contenedor a través de http://ip.de.tu.server:tupuerto a acceder a él a través de http://soberaniadigital.digital:tupuerto?

Es decir, cómo le ponemos un nombre de dominio a una IP. De éso se vienen encargando los servidores de DNS. Todos los server tienen una IP pero tú entras a todas las páginas usando un nombre que puedes recordar. Un servido de DNS (Domain Name System) hace exáctamente éso, traduce los números de una IP a un texto. Por cierto, el dueño del servidor, tiene toda la información de todas las veces que tú le has pedido a su servidor traducir números a letras y sabe, por tanto, todos los sitios a los que has entrado. Es algo precioso.

Cuando registréis el nombre de dominio, ésa traducción se va a hacer sóla y desde fuera de la red de vuestra casa váis a poder entrar con vuestro nuevo y flamante nombre, pero ¿dentro de casa?. Porque dentro de casa no tenéis (aún) un servidor de DNS que os traduzca cosas.

Pues vamos a montar uno.

Yo he escogido AdGuard. ¿Por qué AdGuard? Pues porque hace varias cosas muy bien todas en el mismo software. Con el mismo contenedor, vamos a poder:

  • Resolver el tema éste cochino de las IPs
  • Bloquear publicidad para todos los dispositivos de nuestra red
  • Hacer de servidor DHCP (os cuento al final)
  • Incluso establecer políticas de control parental por si habéis decidido reproduciros y hay sitios a los que no se debería entrar

Muy completo todo.

Vamos a por ello con lo que aprendimos la semana pasada, le echamos un vistazo al dockercito. En la documentación de AdGuard vienen cosas muy interesantes, pero un docker-compose.yml ya hecho como el que vimos la semana pasada, no viene. Ahora bien, como ya sabemos qué hace cada parte, no tenemos problema en escribir el nuestro propio.

Éste es el mío, por ejemplo:

version: "3"
services:
  app:
    image: 'adguard/adguardhome:latest'
    container_name: adguard
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "67:67/udp"
      - "68:68/udp"
      - "89:80/tcp"
      - "4043:443/tcp"
      - "4043:443/udp"
      - "3000:3000/tcp"
      - "853:853/tcp"
      - "853:853/udp"
      - "8853:8853/udp"
      - "784:784/udp"
      - "5443:5443/tcp"
      - "5443:5443/udp"
    volumes:
      - /la_ruta_que_hayas_decidido/adguard/data:/opt/adguardhome/work
      - /la_ruta_que_hayas_decidido/adguard/config:/opt/adguardhome/conf
    network_mode: "host"
    restart: always

La cosa es bien de sencilla. Una imagen, un nombre de contenedor, que se reinicie siempre que se pare, los puertos que va a usar para sus cosas de DNS, dos carpetas para guardar sus ficherines y una cosa nueva: network_mode: «host». La semana pasada vimos que al arrancar un docker-compose, si no definíamos una red en específico creaba una nueva para ése o ésos contenedores. Bueno, ésto está bien y es hermoso, pero también podemos decidir nosotros dónde queremos desplegar un contenedor. Le podemos poner un nombre de red que ya exista o en mi caso, éste contenedor en concreto, quiero que esté en la misma red que el propio server. La red del host. Así que así se lo hago saber.

Leed la documentación bien. Si estáis desplegando ésto en una RaspberryPi (o cualquier otro entorno con resolved) os va a fallar, porque os va a decir que no puede usar el puerto 53. Al final de la documentación os viene un paso a paso de cómo arreglarlo.

¡Albricias!, ¡Jolgorios!, ¡Ya tenemos un servidor casero de DNS que nos bloquea publicidad!

Gentes de la gleba: Pero a ver, mameluco, levantado está, pero ésto no hace nada. Mi IP sigue sin traducirse a un nombre y veo publicidad igual

A veeeeeeeeeer, joder, qué panda. Vamos a ver. Levantado está, pero aún no le hemos dicho lo que tiene que hacer.

Le tenemos que decir a nuestros dispositivos que utilicen la ip de la máquina dónde hemos levantado el contenedor de AdGuard como servidor DNS. Ésto es, si lo habéis levantado en una RaspberryPi que tiene de IP: 10.9.10.100, tenéis que indicarle a vuestro ordenador que use ésa IP como servidor DNS para que ésto empiece a funcionar. Me apuesto dinero a que si buscáis que IP tenéis en el servidor DNS de vuestro ordenador viene la del router. Echádle un vistazo

Gentes de la gleba: ¡Pero no me jodas!, ¿y así cacharro por cacharro?

Pues… es una manera.

Hay otras. Si vuestro proveedor de Internet no os ha jodido la vida, podéis ir a la configuración del router y en los parámetros de DHCP poner vuestra propia IP para vuestro servidor DNS. Ahora bien, vuestro proveedor de Internet, siempre pendiente de vuestra seguridad y bienestar es muy probable que no os deje hacerlo y os tengáis que comer sus IPs porque sí. Porque os ama. Porque se preocupa.

De ser así, yo sólo he encontrado dos soluciones.

O cambiar los DNS a mano cacharro por cacharro, que para equipos fijos no me molesta tanto, pero para dispositivos móviles o portátiles, me molesta un huevo, porque cuando salgo de casa me deja de funcionar el DNS o…

U os compráis un extensor de rango de WiFi que ahí sí que le podéis poner la configuración que os dé la gana.

Claro. Para el extensor de rango de WiFi le tenemos que decir al router que no haga nada con el DHCP, pero hete aquí que AdGuard también hace de servidor DHCP si se lo pedimos. Podéis desactivar el DHCP del router, activar el de AdGuard (los dos a la vez no) y en vuestro extensor de WiFi ponéis el DNS que os de la gana.

Es complicadete, pero pensad que sólo lo tenéis que hacer una vez.

Hecho todo ésto, lo hayáis hecho como lo hayáis hecho, si renováis vuestra IP veréis que navegáis sin publicidad. Yo tengo reglas en AdGuard. De las páginas web que me simpatizan, me como la publicidad, de las que no… pues no. Y éso no sólo es hermoso, es que de repente todo va varios órdenes de magnitud más rápido al navegar al no tener que cargar tanto banner indeseable, pero aún no hemos solucionado lo de la IP y el nombre de nuestro servidor de música.

En el menú de Adguard hay una opción que pone Filters => Custom Filters. Aquí vamos a poner reglas de DNS que no son las que vienen por defecto. Para lo que queremos hacer es muy sencillo. Si ponemos algo como:

10.9.10.100 (la ip del server) musicote.soberaniadigital.digital

Y le dáis a guardar. Cuando pongáis http://musicote.soberaniadigital.digital:666 (que es el puerto en el que montamos Navidrome) en vuestro navegador, éste le va a pedir a su servidor DNS de confianza que le traduzca éso a una IP. Como resulta que hemos configurado todo para que ése servidor de DNS sea nuestro cacharro y en nuestro cacharro hay un AdGuard, le va a devolver que se tiene que ir a 10.9.10.100 que resulta ser nuestro propio servidor.

POR LO TANTO con todo ésto montado, cuando usemos el dominio soberaniadigital.digital dentro de casa, AdGuard nos los traduce y fuera de casa, nos lo traduce nuestro proveedor de IP dinámica.

¿Es bello o no es bello?

Hay dos cosas que no hemos solucionado. Por un lado lo del puerto. Éso de andar poniendo el número del puerto no sólo no mola, si no que seguimos teniendo un puerto abierto a Internet en nuestro router y claramente no deberíamos.

Por otro lado, estamos entrando a sitios con http:// sin certificado ni nada. A pijo sacao y tampoco deberíamos.

Ésto lo vamos a solucionar todo con un servicio más y de manera sencilla, pero será ya la semana que viene. Así nos da tiempo a jugar un poco con AdGuard, dejarlo bien configuradito, disfrutar de navegar sin publicidad salvo que decidamos lo contrario y de cómo poco a poco nos estamos montando un ecosistema de lo más pintón.

La semana que viene tratamos el segundo y último tema de cómo apañar nuestra conectividad casera con lo del puerto y los certificados y a partir de ahí, el festival del despliegue del contenedor.

Hasta más ver.

Bueno, gentes de Internet, vamos con el primer post de verdad de éste, su humilde vlog de cosas de tecnología mal explicadas pero que funcionan.

Hoy vamos a… montarnos un servidor de streaming de música. Para todos ésos empetreses que seguramente aún tengáis. Y si no tenéis os recomiendo reflexionar sobre qué carallo vais a escuchar como mañana, por el motivo que sea, un banco que quiebra, por ejemplo, chape Spotify o lo que sea que uséis.

Asumo que:

Habéis montado un servidor de alguna clase Ver una consola de Linux no os produce parálisis cerebral

Lo primero que vamos a hacer es instalar docker, luego instalamos docker-compose (ahora vamos) y luego vamos a usar docker-compose para desplegar un servidor de streaming musical.

¡Cómo nos lo vamos a pasar!

Instalación de Docker:

Tres mil guías online hay para hacerlo. Os facilito el tema, si teneis una RaspberryPi podéis leerlo aquí. En un servidor x86, aquí un ejemplo para Debian, si no para la distribución que hayamos decidido instalar.

Ya está. A partir de aquí vamos a seguir usando la consola, pero para las cosas de los contenedores. Más adelante usaremos una herramienta de administración con entorno gráfico, pero de momento no necesitamos más. Lo que si que podemos ir haciendo es una carpeta para meter todos los archivos de configuración de nuestros contenedores. La podéis hacer donde os de la gana. Yo voy a suponer que os habéis hecho una carpeta con nombre /docker y dentro vamos a hacer una carpeta con nombre /data que contendrá una carpeta con nombre /navidrome (que es lo que vamos a instalar en éste ejemplo. Así que os vais a donde sea que queráis tener la carpeta y escribís cinco mandatos de Unix con su enter al final de cada uno para que todo se ejecute guapamente:

mkdir docker
cd docker
mkdir data
cd data
mkdir navidrome

Hala, ya nos hemos hecho las carpetas iniciales. Vamos a mirar lo de usar un contenedor.

A la búsqueda de contenedores

Gentes de Internet, os presento Docker Hub. Docker Hub es una página que funciona como un repositorio de contenedores. Muchos de los contenedores que vamos a usar, cuando el desarrollador acaba de montarlos los pone disponibles desde ahí, lo cual no quiere decir que no los podamos descargar desde otro sitio, pero es un sitio habitual donde buscar contenedores.

Más que nada porque tiene un buscador y nos facilita la vida. Así que vamos a buscar nuestro objeto de deseo de streaming: Navidrome.

Yo he escogido Navidrome porque es lo que uso, pero hay un montón de software de streaming de audio que podéis probar. Subsonic, que es el padre de toda ésta fiesta, sus forks libres LibreSonic y Airsonic (y otros)… hay muchos, luego os enlazo una cosa guay, pero centrándonos en Navidrome, si lo busco en Docker Hub, me encuentro ésto:

Mira, ahí nos sale, en todo lo alto. Si pinchamos en él a ver qué tiene, podemos leer una descripción de qué hace éste software empaquetado y hacia la mitad de la descripción nos encontramos ésto:

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    ports:
      - "4533:4533"
    environment:
      # Optional: put your config options customization here. Examples:
      ND_SCANSCHEDULE: 1h
      ND_LOGLEVEL: info  
      ND_BASEURL: ""
    volumes:
      - "./data:/data"
      - "/path/to/your/music/folder:/music:ro"
    restart: always

Que ya nos dice el desarrollador que para lo que viene siendo personalizarlo (Navidrome tiene muchas opciones) que toqueteemos el ficherito. En cualquier caso, vamos a empezar por diseccionar lo que nos está diciendo éste fichero.

Éste fichero es un .yaml (un formato) para docker-compose. ¿Qué es docker-compose? Docker-compose es una herramienta con la que desplegar contenedores de Docker (fascinante, epatante, terrible, apocalíptico). En éste fichero de arriba, tenemos sólo un contenedor (Navidrome) pero imaginad que quisiéramos desplegar a la vez un servicio, una base de datos, una base de datos en memoria y un Jesucristo bailongo en formato .gif. Bueno, pues en el mismo fichero podríamos meter los cuatro contenedores que queremos desplegar en vez de ir uno por uno. Una cosa muy guay, vamos.

Leamos línea a línea la movida ésta:

# This is just an example. Customize it to your needs.

version: "3"
services:

De momento, le decimos a docker-compose la versión de docker-compose que queremos usar (la 3) y en la siguiente línea los contenedores que éste fichero de configuración va a lanzar

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest

En el caso de éste docker-compose, sólo tenemos un servicio. El propio Navidrome. Para poder tener nuestro servidor de streaming musical, no necesitamos nada más, pero podría haber más cosas en el mismo fichero.

Dejando dos espacios en la tercera línea, ponemos el nombre del servicio (navidrome:) y a continuación el nombre de la imagen del contenedor que queremos descargar (deluan/navidrome:latest). Lo que hay detrás de los dos puntos es una etiqueta que nos permite, por ejemplo, descargar una versión en concreto o descargar una rama específica de desarrollo. Con «latest» le estamos diciendo que se baje la última versión que tenga disponible.

Si alguien está muy atento a ésta movida igual está pensando que dónde se le dice que se baje algo que ejecute con procesadores ARM si tiene una RaspberryPi o con procesadores x86 si tiene ésa arquitectura. Bueno, como el desarrollador de Navidrome ofrece su contenedor en todas ésas arquitecturas, docker, que es muy listo, va a mirar primero cuál se tiene que bajar y se baja la que toque.

A mi, en los docker-compose, como no uso Kubernetes y no clusterizo servicios (ya hablaremos de ésto) me gusta darle un nombre a los contenedores. Si no le doy ninguno va a coger uno por defecto, pero cosas del TOC, oigan. Puedo usar una entrada más en mi docker-compose de ésta manera:

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron

Evidentemente, para el nombre del contenedor, ponéis lo que os de la gana. Vamos a una parte importante, los puertos.

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "4533:4533"

Lo que le estamos diciendo aquí a docker-compose es qué puertos de red usar. El desarrollador ha decidido que el puerto por el que su cacharro se va a comunicar es el 4533. Ése es el puerto de funcionamiento del contenedor. Tal y como está escrito el docker-compose le estamos diciendo que use el puerto de nuestra red 4533 («4533:) para comunicarse con el puerto interno 4533 (4533″). Si por ejemplo ése puerto no nos gusta, le tenemos manía o queremos hacer el imbécil podríamos cambiarlo dejando el docker-compose tal que:

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "666:4533"

Escribiéndo ésa idiotez, el contenedor, evidentemente va a seguir usando su mismo puerto interno ya que se desarrolló así, pero nosotros nos vamos a comunicar con el servicio a través del puerto 666 de nuestra red. Porque sí. Porque escuchamos metal. Porque adoramos la música del mal. O algo.

Bueno, dejemos atrás éste momento bochornoso. Sigamos. Vamos con las variables de entorno.

# This is just an example. Customize it to your needs.

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "666:4533"
    environment:
      # Optional: put your config options customization here. Examples:
      ND_SCANSCHEDULE: 1h
      ND_LOGLEVEL: info  
      ND_BASEURL: ""

Todo lo que haya indentado dentro de environment: son variables que vamos a usar para configurar el contenedor. Éstas las define el desarrollador. Deluan, que es muy cuco y diligente ya nos avisa de que podemos configurar ésto como queramos, así que vamos a echarle un vistazo a su página de documentación.

Todas las opciones que véis ahí se pueden meter como variable de entorno. En lo que llevamos de configuración estamos desplegando un Navidrome que busca cambios en nuestra carpeta de discos cada hora, nos escribe logs con poco nivel de detalle y no hemos definido la url que usaremos para acceder. Digamos que yo quiero que escanee mi colección cada 6 horas, que me cierre la sesión automáticamente a las 24 horas de haber entrado, escriba un log como para quedarme dormido leyéndolo y tengo una url para acceder con nombre https://navimegatron.quieroserpropietario.com y además, quiero que el mensaje de bienvenida que aparezca en mi server de música sea: «Bienvenidos, hijos del rock ‘n roll», bueno, pues modifico mi docker-compose tal que:

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "666:4533"
    environment:
      TZ: Europe/Madrid
      ND_SCANSCHEDULE: 6h
      ND_LOGLEVEL: debug  
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: "navimegatron.quieroserpropietario.com"
      ND_UIWELCOMEMESSAGE: "Bienvenidos, hijos del rock 'n roll"

He añadido una variable más que es la franja horaria, para que luego, si tengo que leer logs no me explote la cabeza. Lo hago en todos mis contenedores y es tan sencillo como poner TZ: Europe/Madrid si estáis en Españita o vuestra zona geográfica que más os seduzca y os plazca

Ya no nos queda casi nada, vamos a por un téma crítico, los volúmenes.

Si se han leído la entrada anterior habíamos quedado en que como nos dé por parar un contenedor, se borra todo lo que hubiése dentro. Excepto aquellas cosas que nosotros le indiquemos que queremos que se guarden en el disco. Éso lo podemos hacer definiendo los volúmenes. Vamos a por ello:

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "666:4533"
    environment:
      TZ: Europe/Madrid
      ND_SCANSCHEDULE: 6h
      ND_LOGLEVEL: debug  
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: "navimegatron.quieroserpropietario.com"
      ND_UIWELCOMEMESSAGE: "Bienvenidos, hijos del rock 'n roll"
    volumes:
      - "./data:/data"
      - "/path/to/your/music/folder:/music:ro"
    restart: always

Los volúmenes me los tiene que decir el desarrollador. Yo puedo mapear lo que me de la gana en un contenedor pero es el propio desarrollador el que nos dice qué carpetas debemos persistir en el disco duro. Funciona como lo de los puertos. Lo que está antes de los dos puntos es una carpeta en nuestra máquina, lo que está detrás, una carpeta en el contenedor. Importante. Tenemos que crear en nuestra máquina las carpetas antes de lanzar el docker-compose o le da un parraque y se queda tonto (crea ficheros vacíos en lugar de mapear carpetas). Pero leámoslo detenídamente.

El desarrollador nos dice que su contenedor usa dos carpetas. Una que se llama /data. Donde va a guardar los ficheros de configuración y otra que se llama /music (y que además nos indica que es :ro, es decir que es read only, es decir que es de sólo lectura). Si nos vamos a su página de documentación nos explica que en data escribe el contenedor todas sus cosas para configurarse y en /music echamos dentro nuestros discos.

Nosotros ya teníamos carpetas. Más en concreto en el path /algoentu_maquina/docker/data/navidrome, ¿os acordáis? Bueno, pues vamos a hacer dos más dentro de la carpeta navidrome:

cd /algo_en_tu_maquina/docker/data/navidrome
mkdir data
mkdir music

Y ésas van a ser las carpetas que usemos en docker-compose. Voy a suponer que tu usuario tiene de nombre pepinillo y te has creado ésas carpetas en tu carpeta de home. Aunque se pueden poner rutas relativas, voy a poner en el docker-compose las completas para que quede claro, me queda tal que así:

version: "3"
services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navimegatron
    ports:
      - "666:4533"
    environment:
      TZ: Europe/Madrid
      ND_SCANSCHEDULE: 6h
      ND_LOGLEVEL: debug  
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: "navimegatron.quieroserpropietario.com"
      ND_UIWELCOMEMESSAGE: "Bienvenidos, hijos del rock 'n roll"
    volumes:
      - "/home/pepinillo/docker/data/navidrome/data:/data"
      - "/home/pepinillo/docker/data/navidrome/music:/music:ro"
    restart: always

¡Oeeeeeeeeeeeeeee oeeeeeeeeeeeeeeeeeee ya hemos acabado!

Vale, pero antes de fliparnos, ¿qué hemos hecho? Hemos definido las carpetas donde el contenedor va a guardar algunos ficheros. Lo cual quiere decir que aunque borre el contenedor, los ficheros se quedan ahí. Lo cual quiere decir que si me copio ésas carpetas a cualquier otra máquina, la que sea, donde sea que esté y ejecuto el mismo docker-compose, vuelvo a tener mi servidor de música tal y como lo tenía antes de borrarlo. Y como me lo puedo descargar de Internet, todo ésto quiere decir que con hacer copia de unas carpetitas de nada, puedo migrar ésto a donde me dé la gana de una manera muy sencilla.

Al final del todo está la política de reinicio. He puesto always. Éso quiere decir que salvo que yo lo pare o borre a mano, siempre que el contenedor se pare, se va a reiniciar sólo (se nos va la luz, por ejemplo). Algo muy práctico y muy apañado.

Bueno, al lío, que ésto es larguísimo, menos mal que sólo va a ser así el primero. Ya tenemos definido conceptualmente nuestro docker-compose lo único que necesitamos hacer es meterlo todo en un fichero y ejecutarlo así que copiamos todo el texto de la caja de arriba y escribimos en la consola:

nano docker-compose.yml

(A ver, yo uso vi, otra gente usa vim, los hay que usan emacs porque tienen problemas con el tema de vivir bien, otros pico, tu usa lo que te de la gana para editar ficheros en la consola)

La cuestión es que copiamos el texto de la caja de arriba, el docker-compose, lo pegamos en nuestro nuevo fichero y si has usado nano para editarlo pulsas Ctrl+X y cuando te pregunte si quieres salvar el fichero le dices que sí.

Ya está. Ahora sí que sí. Qué emoción, oigan.

Ahora en tu carpeta de navidrome tiene que haber tres cosas. Un fichero llamado docker-compose.yml y dos carpetas (data y music) vacías. Desde ésa misma carpeta escribimos:

docker-compose up -d

Y veréis que automágicamente pasan cosas maravillosas.

Lo que va a suceder es que se va a bajar el contenedor de Internet, lo va a ejecutar y va a leer de las carpetas que le hemos dicho que lea. Hay dos cosas que no hemos indicado, con qué usuario tiene que ejecutar el contenedor (ya lo haremos, es importante) y en qué red desplegar el contenedor (y como no lo hemos hecho, va a crear una subred nueva con nombre navidrome_network y lo va a poner ahí, ya tocaremos éso).

La cuestión es que si la máquina de tu server tiene la ip 10.5.1.130, por ejemplo, cuando pongas en el navegador:

http://10.5.1.130:666

Vas a ver tu nuevo y delicioso servidor de música en streaming. Si metes discos en la carpeta /music te aparecerán ahí y podrás escuchar tu propia música desde cualquier lugar del mundo en una página web o en cualquier móvil con cualquier app que haga uso de la api Subsonic (yo uso una que se llama substreamer que está disponible para iOS y para Android y me va muy bien)

Gentes de la gleba: A ver, pazguato, ¿cómo que desde cualquier lugar del mundo? Dentro de mi casa si, pero desde Internet o abro ése puerto a Internet o me como los mocos. Y me tengo que saber mi IP pública que además cambia y no me mola abrir ése puerto y ésto es una mierda y ahora mismo cancelo mi pago en Patreon a tu mierda de blog

A ver.

Vamos a relajarnos.

Lo primero es que no tengo Patreon. Ni tengo intención de tenerlo.

En todo lo demás, tenéis razón.

Pero es que tenía que hacer un post muy, muy largo para poder explicar ésto. A partir de aquí es coser y cantar, porque todos los docker-compose funcionan igual así que podemos empezar a desplegar cosas a toda leche y sin complicaciones.

Podemos usar nuestro propio servidor de DNS para resolver el nombre de la URL tanto dentro como fuera de casa y podemos montar un proxy inverso para no tener que abrir puertos raros en el router.

La cantidad de cosas que podemos hacer a partir de aquí es inmensa y veremos muchas, pero por hoy y por ahora, con tener el servidor en ejecución y funcionando vamos que nos matamos.

Como curiosidad final, les dejo un enlace de reddit a un listado enorme de cosas que nos podemos montar en nuestro propio server, casi todas con docker.

Ésto ya es bastante largo. Estoy cansado y hay mucha tarea para empezar. La semana que viene resolvemos las cuitas del acceso desde Internet (vamos a tener que comprar un nombre de dominio baratito, éso sí, pero pensad que os habéis montado vuestro propio Spotify en un ratito para poder disfrutar de vuestra música a calidad máxima y no con la mierda de compresión que le meten y es vuestro, es vuestro servicio, no os lo pueden quitar, ni cerrar, ni os pueden censurar un artista.

Sois los dueños de vuestra propia cultura.

Es todo muy bello.

Vergüenza. Que la vergüenza caiga sobre tí por hacer un chiste tan malo. ¿Y sabes por qué soy tan soberbio? Porque yo he dicho la misma idiotez múltiples veces.

Vamos a ver, que la cosa ésta de los contenedores (sí, contenedores), da mucho miedito y en realidad el asunto tiene la complejidad de un botijo (que se usa fácil pero tiene mucha tecnología en su interior, no te creas).

Vamos primero con un disclaimer. Estoy lejísimos de ser un experto en el tema. Sé usarlos, hacer alguna cosita con ellos y poco más. Si quieres formarte de verdad en contenedores hay recursos incontables y gratuitos en Internet. Pero en éste blog vamos a por los conceptos básicos porque confío en que si te interesa, te buscarás tus cosas por la red y tal.

Al principio, todo ésto era campo. Y hardware.

Si retrocedemos en el tiempo y probablemente en el espacio muchos años atrás, los despliegues en servidores tenían mogollón de encanto. Digamos, por decir algo, que tú querías montarte unas bases de datos, digamos dos, un servidor de correo, un servidor web y un sistema de almacenamiento de ficheros compartido.

No vamos a entrar en detalle, pero lo primero que te venía a la cabeza era cuántas máquinas necesito para que no me quiten el sueño por las noches. Porque puedes meterlo todo en una sóla máquina y currártelo para que todo se comunique adecuadamente sin que se pegue de bofetones una cosa con la otra, pero es que ésto introduce un montón de problemas. Entre otros muchísimos más allá de cómo conviven unas cosas con otras, como perdieras la máquina ahí va todo en el mismo paquete (cosa que no vamos a solucionar en nuestra aproximación a los contenedores en éste blog, ésto es un capítulo bastante más avanzado). Pero a lo que voy, sistemas operativos, compatibilidad… un dolor de cabeza estupendérrimo.

Y llegaron las máquinas virtuales

Y vieron los sysadmin que aquello era bueno. En un mismo cacharro, en un servidor, en un hierro, podías tener un Linux, o diez Linux, un Windows o seis Windows y cada uno con sus cosas instaladas dentro. Claramente hemos mejorado. Las cosas se dan menos de bofetones, podemos ser más quirúrgicos a la hora de decidir dónde instalamos qué, solventamos razonablemente el tema de depender del mismo sistema operativo para todo… la cosa está bastante bien.

Ahora bien, yendo a la custión más fundamental (de otras muchísimas), échale una pensada. Joder, ¿Instalar un sistema operativo entero para una triste base de datos no te parece una solución un poco bestia? Porque lo es, la verdad

Los contenedores, ése mundo

Bueno, pues hete aquí que aparece el concepto de contenedor hace ya bastantes años. ¿Qué es un contenedor? Pues Javier Garzas lo explica magníficamente en su blog Por favor, ve a leerlo allí, el texto que hay a continuación no es ni de lejos una explicación razonable, más bien algo de andar por casa.

Pero pensemos que un contenedor es una caja. Una caja de software. Docker es una empresa que proporciona el entorno adecuado para hacer cajas de software. Hay otros entornos, Podman, LXC, Amazon tiene su propio cacharro (claro)… bueno, que hay un montón, nosotros en éste vloj nos vamos a quedar con Docker por cuestiones que no vienen al caso pero que igual vemos más adelante.

El asunto. Una caja. Una caja de software. Yo instalo Docker y lo que instalo es el entorno para poder usar cajas de software. Y en ése entorno puedo meter una caja, dos, diez, cien… para lo que dé mi máquina. Ésa caja trae lo mínimo necesario e imprescindible para que un trozo de código funcione. Así, si por ejemplo, necesito una base de datos, en lugar de instalar un sistema operativo entero y en ése sistema operativo la base de datos, lo que hago es instalar mi entorno para usar cajas (contenedores) y empiezo a meter ahí lo que yo quiera. Una caja puede tener una base de datos, otra un servidor web, otra un blog (como éste), otra una instancia de Mastodon, otra un sistema de navegador de ficheros y lo mejor de todo, entre ellas no se dan de bofetones. Comparado con cualquier otro sistema, son ligeras, pequeñas, rápidas y entre ellas, ni siquiera se ven (salvo que yo se lo diga).

Si eres un desarrollador, todo ésto ya lo sabes, pero si lo que quieres es auto-alojarte tres o cuatro cositas, todo ésto quiere decir que puedes ir a Internet, coger una caja que ya haya hecho alguien y meterla en tu habitación de guardar cajas (Docker). Así de fácil es todo ésto.

Es decir.

Si quiero desplegar en mi servidor una base de datos y un programa para emitir música en streaming, me bajo la caja de las bases de datos y la caja del servidor de música, las arranco y a funcionar.

Ahora bien. Éstas cajas, por diversos motivos (portabilidad, ligereza) tienen una particularidad que al principio te va a parecer la mierda pero luego te darás cuenta que es maravillosa.

Si paras la caja, si la borras, todo lo que contiene desaparece.

Si levanto mi servidor de música y echo dentro mis discos y mañana se me ocurre borrar la caja… también borro los discos.

Tengo que decirle a la caja qué cosas quiero que se escriban en el disco duro y que lea ésos ficheros de ahí, porque si no llevo el tema crudo.

Echa la introducción al sistema de contenedores, voy a asumir que ya tienes un server. Que te has hecho con una máquina en un proveedor de cloud (tú sabrás), que te has montado un server con tus discos o que te has hecho con una Raspberry Pi (o similar… mejor similar, de hecho) y tiene un disco duro conectado (muy recomendable, no imprescindible). Si tienes una Raspberry Pi, te has montado un Linux en ella salvo que hayas hecho cosas muy raras y usas un procesador ARM (no es importante, pero las cosas que funcionan con ARM no funcionan en máquinas tradicionales). Si estás usando una Raspberry no te hace falta el entorno gráfico para nada, te va a consumir recursos y no lo vamos a usar. Si te has montado tu propio server, asumo que has instalado Linux. Si no lo has hecho para de leer.

Vuelve al servidor.

Instala Linux.

Seguimos.

¿Por qué éste proselitismo pingüinudo? Pues por cosas de uno, pero aparte de mi opinión personal es que el ecosistema de contenedores que hay en Linux, como en muchas otras cosas, no tiene color comparado con el de cualquier otro sistema operativo.

En el siguiente paso, vamos a por nuestro primer contenedor… un servidor de música en streaming. Va a estar muy bien.

Nos vamos a divertir ya por fin.

Ya veréis cómo mola.

Begin the beguine era el nombre de un bar en el que he pasado muchas horas en mi vida. Algo decadente sin duda ya entonces y hace muchos años ya.

No por el sitio. El sitio era magnífico. Pero ya entonces había una evidente decadencia cultura. En el sitio no había cócteles de moda, no había música del momento, no había gente guapa y la mano del diseño IKEA ni estaba ni se la esperaba. Ésa suerte de pseudominimalismo que consiste en que todo sea blanco y poner alguna mierda de algún color aislada, descontextualizada y todo bien de luces led.

Creo que ya no existe. Y sé que si no existe durante todo el tiempo al que fuí no supe exáctamente cómo se llamaba. Ni que era una canción de Cole Porter. La ignorancia tiene hijos detestables.

¡Nah!, nada de éso, de hecho exáctamente lo opuesto, pero dejemos mis recuerdos sobre un bar y empecemos por el principio.

Vamos a hablar de cómo alojarnos nuestras propias cosas.

Quizás en el futuro merezca la pena hablar de lo que es más importante, ¿por qué? Pero si estás aquí, tú no lo necesitas y a mi no me apetece.

Si empezamos por el principio, que es cómo nos montamos cosas en un servidor propio tendremos que empezar por el tema del cacharro. El hierro. El dispositivo que tantas satisfacciones y disgustos nos va a dar. La máquina.

Tenemos multitud de opciones de todos los tipos, colores y presupuestos, naveguemos por algunas de ellas.

Si queremos ir con el signo de los tiempos, lo suyo es pagarse (hagamos lo que hagamos, algún dinero nos va a costar la broma ésta) una máquina virtual en algún proveedor de infraestructura. Aquí un poco lo que más nos guste. Sé que si me estás leyendo estás pensando en Amazon y Amazon es una opción, claro. Yo, sinceramente, me inclino más por un proveedor como Linode, pero a poco que busques encontrarás una pléyade de proveedores de cacharros en cloud que estarán encantados de alquilarte una máquina por unas cuantas perras al mes.

A mi me convence regular, la verdad. No dejo de tener la sensación que no soy el propietario del cacharro y que me lo pueden quitar en cualquier momento, así que la alternativa, si eres como yo es ponerte un servidor en casa.

Puestos a transitar por ése camino, hay dos cosas fundamentales a tener en cuenta. El coste recurrente (la luz) y el coste de inversión (el cacharro y sus discos).

Te diría que no te volvieras loco y pensaras en qué quieres montar. Si aún no lo sabes, que es lo más normal, yo la verdad que probablemente iría a por una Raspberry Pi (incluso tras su debacle de su CM en el Fediverso) sencillamente por la cantidad de documentación que hay, el tamaño de su comunidad y sobre todo si ésta es tu primera vez por la sencillez para instalar el sistema operativo.

Si Linux no te da miedo ni vergüenza, cualquier servidor del estilo de la Raspberry nos vale (y en algún momento hablaremos de la sinofobia) pero ten en cuenta que vamos a levantar servicios que le van a arrear duro al almacenamiento, así que nada de tarjetas SD, por el amor de Cthulhu (bueno o sí, pero tú sabrás) así que un SSD enchufadito a tu mini-ordenador y a empezar a funcionar.

Si quieres ir más a lo grande puedes ir a por una NAS comercial (QNAP, Synology… algo del estilo) y si quieres que en la otra vida te metan en la habitación de los frikis puedes lanzarte a montarte tu propio mini-servidor con una CPU algo más potente, aún venden placas con el chip j5040 (Asrock) que son de lo más apañadas, pero ten en cuenta que va a estar encendido 24 horas al día. No es que te vaya a pegar un patadón a la factura de la luz pero sí que lo vas a ver mensualmente; es crítico poder balancear la potencia del servidor de acuerda a las necesidades que tenemos y el consumo energético.

Gentes de la gleba: «Oye, oye, que si me voy a por un SSD y una Raspberry o similar que es lo más barato que veo, ésto es un desembolso de dinero y ahora mismo no seré molón auto-alojando mis cosas pero no me gasto dinero«

Calma, calma, guardad aún las horcas y las antorchas.

Sí. Ya os lo avisé en el post anterior. Ésto cuesta dinero. Ahora, que ahora mismo no gastes dinero es lisa y llanamente mentira ¿O los 120€ al año de Spotify son gratis?, ¿y el dinero que te gastas en Dropbox/Drive/similar?, ¿y el de Netflix/HBO/lo-que-sea-que-uses?

Te propongo un ejercicio. Siéntate en tu mesa más comfortable y suma, pero con el detalle adecuado la pasta anual que te gastas en servicios de éste tipo (tecnológicos). Ahora mira la suma total.

Pues con todo ése dinero gastado, cuando llegue el 31 de Diciembre, no serás propietario de nada. Es, literalmente, dinero quemado.

No parece barato, ¿verdad?

Desde luego, gratis no es.

En el siguiente paso… ¿Qué es Docker?, ¿por qué deberían dispararte en las rodillas si haces chistes con la marca de pantalones?, ¿necesito saber mucho de Linux para usarlo?, ¿por qué éste blog me lleva por el amargo camino de la consola en negro y por qué no le puedo dar a un botón y ya? y otras temáticas igualmente epatantes.

Creo que alguien está abriendo una ventana

Creo que hay un pequeño hueco. Hay un hueco en el que sé que muchos desplegaríais vuestros propios servicios. Sé que muchos sentimos interés por destetarnos de tódos ésos tentáculos tecnológicos que parecen ubícuos y de los que no parece haber salida.

Vamos a hablar de montarnos un pequeño (o gran) server en casa y que no lo notemos mucho en la factura de la luz. Vamos a hablar de qué carallo es éso de los contenedores y por qué mola más que las peleas entre partidos de derecha, descubrir qué pasa con el sistema operativo ése de frikardos, vamos a hablar de un poquito de seguridad (MUY) básica y luego ya nos liamos a desplegar cosas chachi pistachi para poder fardar delante de… de nadie, a nadie le interesa ésto.

Es más, si eres buen ciudadano, a tí tampoco debería interesarte mucho.