El siguiente post me tomó un buen tiempo de configuración, más por desconocimiento que por lo complejo, así que decidí documentar cada paso con la idea del día de mañana esto sea útil para alguien.

Lo primero fue encontrar que la versión que está en los repositorios de debian 12 es una versión de OBS Studio bastante vieja. Así que probé crear el paquete y otras yerbas que solamente me condujeron a dolores de cabeza, tras lo cual, opté por probar flatpak, el cual me dejó gratamente sorprendido.

Instalando flatpak y el repositorio de flatpak:

sudo apt install flatpak plasma-discover-backend-flatpak -y
flatpak remote-add --if-not-exists flathub \
  https://dl.flathub.org/repo/flathub.flatpakrepo

Una vez instalado eso se procede a instalar OBS Studio

flatpak install com.obsproject.Studio \
                com.obsproject.Studio.Plugin.NDI \
                com.obsproject.Studio.Plugin.DroidCam \
                com.obsproject.Studio.Plugin.MoveTransition

Habilitando virtual cam o cámara virtual:

sudo apt install -y v4l2loopback-dkms
sudo modprobe v4l2loopback video_nr=9 card_label="cam_obs"
sudo cat > /etc/modules-load.d/v4l2loopback.conf << EOFload
v4l2loopback
EOFload
sudo cat > /etc/modprobe/v4l2loopback.conf << EOFprobe
options v4l2loopback video_nr=9 card_label="cam_obs"
EOFprobe

Para probar la configuración anterior, se puede abrir OBS Studio, activar la "camara virtual" e ir a VLC a probar que se esté transmitiendo.

Hay muchos procesos dentro de la informática que parecen magia, por ejemplo, conectarse a Internet. "Mágicamente" al seleccionar una red y poner su clave, puedes navegar, ver un video o escuchar música desde algún "rincón" de Internet.

Para que estos procesos sean así de simples, hubo gente que se quebró la cabeza pensando y creando servicios y configuraciones para que el "usuario final" solamente vea que el mundo se abre frente a sus ojos.

Uno de estos servicios es el DHCP, que es capaz de asignar IP a una maquina que se conecta a la red. Con una configuración muy simple de DHCP podemos asignar IP a todos quienes lleguen a conectarse, pero, que pasa si quiero tener siempre las mismas IP dentro de casa, por ejemplo, para controlar el acceso de los notebook/computador de los niños a Internet en algunos horarios. Con DHCP puedo configurar personalizadamente la IP, los servidores de dominio y algunos otros detalles de cada equipo si lo deseo, de esta forma agregar filtros de contenido, entre otras cosas.

Instalando el servicio DHCP

Lo primero es como de costumbre en debian, actualizar la fuente de datos de los programas que se pueden instalar.

sudo apt update

Sugiero que si existen actualizaciones las apliquen sudo apt dist-upgrade -y, no es algo obligatorio, pero si sugerido fuertemente para asegurarse de estar con los últimos parches de seguridad.

Instalar el servidor de DHCP:

sudo apt install isc-dhcp-server -y

Instalar es solo la primer parte, de ahí hay que configurar el servicio para hacer lo que se desea, recomiendo no activar el servicio hasta tener hecha al menos la primer parte de la configuración.

Configurando lo básico

Lo primero es ir a revisar el archivo que nos crea de forma predeterminada la instalación. Este se encuentra en /etc/dhcp/dhcpd.conf. Se puede apreciar que trae muchas lineas comentadas, pero otras no, cuales son esas lineas:

option domain-name "example.org";
option domain-name-servers ns1.example.org, ns2.example.org;

default-lease-time 600;
max-lease-time 7200;

ddns-update-style none;

La primera es el "nombre de domino" de mi red local, en este caso es "example.org"". La segunda, los servidores de nombre (es decir, quien me dice a cual IP corresponde un nombre como "google.com"). La tercer linea indica el tiempo predeterminado que dura esta configuración entregada al equipo cliente(10 minutos), la siguiente el tiempo máximo de la concesión de la configuración (2 horas). La última linea nos indica el estilo en que se actualizará el servidor DNS Dinámico de nuestro cliente, en esta configuración, no lo utiliza.

Toquemos la configuración, a mi red le quiero dar el dominio ficticio o local de "alvear.home", quiero entregarle de forma predeterminada que resuelva con "filtro" de contenidos, por lo que usaré los DNS "Family protection servers AdGuard" (94.140.14.15 y 94.140.15.16 más detalles en: https://adguard-dns.io). Además deseo configurar la "red" en que vivirán mis equipos y cuál será el rango dinámico de las IP.

Mi red será 192.168.0.0/23, es decir, tendré 510 IP disponibles para asignar. Mi router (de movistar) tiene la IP estática 192.168.1.1, lo dejaré tal cual, solo debo tener el cuidado de decirle que él ya no entregará las IP y cambiar la "mascara de la subred" a 255.255.254.0 que es la mascara que corresponde a la red 192.168.0.0/23.

El rango de asignación dinámica de equipos de red, lo dejaré de 125 IP usando el último segmento de la red. No se si algún día habrán tantas visitas en mi departamento de 50 m², pero mejor que sobre a que falte.

Como he instalado en mi pequeño "servidor" la impresora, lo dejaré como servidor predeterminado de impresión. Agregaré también servidores de tiempo porque me agrada que mis equipos estén a la hora. Existen muchas opciones de configuración y quizás en tu red necesites alguna otra y alguna que yo tengo no, te dejo el link por si quieres revisar (https://kb.isc.org/docs/isc-dhcp-41-manual-pages-dhcp-options)

# nombre de mi red interna
option domain-name "alvear.home";

# servidores de Family protection servers AdGuard,
# en teoría filtran sitios de adultos y publicidad
option domain-name-servers 94.140.14.15, 94.140.15.16;

# bajo los tiempos de entrega del servicio, eso hará que
# busquen la configuración cada minuto, ideal si quiero cambiarla
# para que no puedan navegar en algún momento.
default-lease-time 60;
max-lease-time 90;

# Usando el estandar de dns dinámico
ddns-update-style standard;

# con el modo authoritative le indico que este servidor de DHCP es
# el que resuelve las direcciones IP, por lo que debe anunciarse como
# tal en la red enviando mensajes "DHCPNAK"
authoritative;

# indicando que usaremos los nombres declarativos de host
use-host-decl-names on;

# definición de mi red o "subred" 192.168.0.0/23
subnet 192.168.0.0 netmask 255.255.254.0 {

  # IP que repartirá entre las maquinas no conocidas
  range dynamic-bootp 192.168.1.129 192.168.1.254;
  
  # puerta de enlace o salida de la red
  option routers 192.168.1.1;
  
  # dirección del broadcast o ultima IP de la red
  option broadcast-address 192.168.1.255;
  
  # Servidores de tiempo
  option ntp-servers 1.cl.pool.ntp.org, ntp.shoa.cl, debian.pool.ntp.org;
  
  # Servidor de impresión
  option lpr-servers 192.168.0.1;
}

Finalmente, y algo no menor, hay que configurar la red del "servidor", sino, tendremos un lindo caos.

Primero, editamos /etc/default/isc-dhcp-server, en donde su contenido será en mi caso:

INTERFACESv4="enp3s0"

Porqué en mi caso, porque "enp3s0" es mi interfaz de red, en tu caso puede ser eth1 u otro dispositivo.

Siguiendo la misma lógica hay que editar el archivo /etc/network/interfaces para dejar nuestro servidor con una configuración estática. En mi caso el archivo es el siguiente:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug enp3s0
#iface enp3s0 inet dhcp
#

iface enp3s0 inet static
        address 192.168.0.1/23
        gateway 192.168.1.1
        dns-nameservers 8.8.4.4 8.8.8.8
        dns-search alvear.home

Ahora sí, estamos listos para activar el servicio.

sudo systemctl enable isc-dhcp-server.service
sudo systemctl start isc-dhcp-server.service
sudo systemctl status isc-dhcp-server.service

Si todo les salio bien, la salida debería ser similar a este:

● isc-dhcp-server.service - LSB: DHCP server
     Loaded: loaded (/etc/init.d/isc-dhcp-server; generated)
     Active: active (running) since Wed 2024-03-20 20:23:27 -03; 47min ago
       Docs: man:systemd-sysv-generator(8)
    Process: 1395233 ExecStart=/etc/init.d/isc-dhcp-server start (code=exited, status=0/SUCCESS)
      Tasks: 1 (limit: 9339)
     Memory: 13.1M
        CPU: 2.191s
     CGroup: /system.slice/isc-dhcp-server.service
             └─1395246 /usr/sbin/dhcpd -4 -q -cf /etc/dhcp/dhcpd.conf enp3s0

mar 20 21:10:52 nuc dhcpd[1395246]: DHCPREQUEST for 192.168.0.255 from 78:2b:46:e8:9a:4f via enp3s0
mar 20 21:10:52 nuc dhcpd[1395246]: DHCPACK on 192.168.0.255 to 78:2b:46:e8:9a:4f via enp3s0
mar 20 21:10:54 nuc dhcpd[1395246]: DHCPREQUEST for 192.168.1.131 from e0:62:67:36:92:07 via enp3s0
mar 20 21:10:54 nuc dhcpd[1395246]: DHCPACK on 192.168.1.131 to e0:62:67:36:92:07 via enp3s0
mar 20 21:10:54 nuc dhcpd[1395246]: DHCPREQUEST for 192.168.1.129 from 00:e9:3a:db:6c:a5 via enp3s0
mar 20 21:10:54 nuc dhcpd[1395246]: DHCPACK on 192.168.1.129 to 00:e9:3a:db:6c:a5 via enp3s0

¿Y cómo les doy siempre la misma IP a mis equipos?

Este segundo paso no es menor y puede a la verdad ser bastante tedioso si tienes muchos equipos en casa, pues hay que ir tomando la mac-address de cada uno de ellos. La mac-address es como la huella digital única de cada dispositivo de red. (Se que se puede clonar y cambiar por software, pero en teoría es única).

En nuestro archivo /etc/dhcp/dhcpd.conf se pueden agregar al final de lo que hicimos, los host para cada máquina de una forma similar a:

host movistar { # hogar-net
  hardware ethernet e4:ab:89:ab:84:4e;
  fixed-address 192.168.1.1;
  option host-name "movistar";
  option dhcp-client-identifier "movistar";
}

y con eso van configurando equipo a equipo... pero, como les comenté en la entrada anterior, me gustan los script y pensé, la configuración es idéntica para cada equipo, con excepción de los valores, podría hacer una planilla csv y luego crear un archivo de configuración, entonces, en vez de agregar host a host, mejor creo un archivo de host y solamente lo incluyo dentro de /etc/dhcp/dhcpd.conf, así mi última linea es:

include "/etc/dhcp/host-home.conf";

el script "net-host-config.sh" que me crea el archivo de host es el siguiente:

#!/bin/bash

rm -f host-home.conf

for i in $(cat net.csv); do
  IP=$(echo $i|awk -F";" '{print $1}')
  ID=$(echo $i|awk -F";" '{print $2}')
  HW=$(echo $i|awk -F";" '{print $3}')
  HN=$(echo $i|awk -F";" '{print $4}')
  KIND=$(echo $i|awk -F";" '{print $5}')
  if [ "$IP" = 'IP' ]; then 
    echo "writing..."; 
  else
    echo -n "host $ID { # $KIND\n  hardware ethernet $HW;\n  fixed-address $IP;\n  option host-name \"$HN\";\n  option dhcp-client-identifier \"$ID\";\n}\n\n" >> host-home.conf
  fi
done

echo "restarting..."
systemctl restart isc-dhcp-server.service

echo "done."

La estructura del archivo "net.csv" que es la planilla de los dispositivos es esta, lo importante es el orden de las columnas y que esté bien escrito

IP;ID;HARDWARE;HOSTNAME;TIPO
192.168.0.120;lenovo-lan;b4:a9:fc:55:b6:73;laptop-Roy;laptop
192.168.0.121;lenovo-wifi;28:39:26:a9:59:81;laptop-Roy;laptop
192.168.0.122;hp-caro-lan;50:81:40:4a:93:53;laptop-Caro;laptop
192.168.0.123;hp-caro-wifi;00:e9:3a:db:6c:25;laptop-Caro;laptop
192.168.0.124;hp-jairo-lan;a0:d3:c1:ca:42:20;laptop-Jairo;laptop
192.168.0.125;hp-jairo-wifi;a4:db:30:aa:57:4a;laptop-Jairo;laptop
192.168.0.126;hp-vasti-lan;a0:1d:48:fc:30:d6;laptop-Vasti;laptop
192.168.0.127;hp-vasti-wifi;fc:f8:ae:5c:2d:39;laptop-Vasti;laptop
192.168.1.1;movistar;e4:ab:89:ab:84:4e;movistar;hogar-net
192.168.1.2;tenda;c8:3a:35:16:e3:71;tenda;hogar-net
192.168.1.3;MiWiFi-RC04;a4:a9:30:12:f0:f8;xiaomi-wifi;hogar-net
192.168.1.4;ESP_B6EBE3;a4:cf:12:ba:eb:e3;enchufe-1;hogar-enchufe
192.168.1.5;lumi-gateway-mgl03;54:ef:44:c8:45:d2;mi-gateway;hogar
192.168.1.6;google-home;00:f6:20:cb:2b:43;nest-home;hogar
192.168.1.7;chrome-cast;14:c1:4e:9b:cf:7a;tele;hogar
192.168.1.8;yeelink-vasti;44:23:7c:89:bf:33;luz-vasti;hogar-luz
192.168.1.9;yeelink-jairo;5c:e5:0c:82:1b:c5;luz-jairo;hogar-luz
192.168.1.10;philips-light-bulb_miio237741054;44:23:7c:b1:ea:fe;luz-puerta-1;hogar-luz
192.168.1.11;philips-light-bulb_miio237741345;44:23:7c:b1:fa:21;luz-puerta-2;hogar-luz
192.168.1.12;luz-papas1;d0:27:02:15:ad:de;luz-papas-1;hogar-luz
192.168.1.13;luz-papas2;d0:27:02:15:e7:d8;luz-papas-2;hogar-luz
192.168.1.14;lampara-caro;04:cf:8c:3c:a5:df;lampara-caro;hogar-luz

Obviamente acá deberían ir tus dispositivos.

Finalmente, aplicamos los comandos:

sudo su -
cd /etc/dhcp/
chmod +x net-host-config.sh
./net-host-config.sh
exit

Con eso, al cavo de un minuto ya deberían estar tus dispositivos con sus nuevas IP.

¿Cómo limito el trafico en alguna hora a algunos equipos?

Eso aun no lo he implementado, pero mi idea es simple. Dado a que le entregué "nombre" y "tipo" a las maquinas, modificar el archivo net-host-config.sh para que cree host "fuera del estandar", asignando por ejemplo, una puerta de enlace que no sea tal, algo así como:

#!/bin/bash

rm -f host-home.conf

for i in $(cat net.csv); do
  IP=$(echo $i|awk -F";" '{print $1}')
  ID=$(echo $i|awk -F";" '{print $2}')
  HW=$(echo $i|awk -F";" '{print $3}')
  HN=$(echo $i|awk -F";" '{print $4}')
  KIND=$(echo $i|awk -F";" '{print $5}')
  if [ "$IP" = 'IP' ]; then 
    echo "writing..."; 
  else
    TIPO=$(echo $KIND | cut -c1-6)
    if [ "${TIPO}" = 'laptop' ]; then
      echo -n "host $ID { # $KIND\n  hardware ethernet $HW;\n  fixed-address $IP;\n  option host-name \"$HN\";\n  option dhcp-client-identifier \"$ID\";\n  option routers 192.168.0.2;\n  }\n\n" >> host-home.conf
    else
      echo -n "host $ID { # $KIND\n  hardware ethernet $HW;\n  fixed-address $IP;\n  option host-name \"$HN\";\n  option dhcp-client-identifier \"$ID\";\n}\n\n" >> host-home.conf
    fi
  fi
done

echo "restarting..."
systemctl restart isc-dhcp-server.service

echo "done."

Para que todos los laptop tenga una puerta de enlace diferente. Claro está, es solo un bosquejo de la idea, pues aun eso no tiene un horario sino que es siempre.

Probablemente lo implemente en estos días, ya que comenzaron las clases, cuando lo tenga se los comparto.

Finalmente, por la configuración de firewall que hicimos en el post anterior (https://r.qo-op.cl/servidor-en-casa/), no necesitamos modificar nada, pues dimos una confianza total en nuestra red.

Éxito!

Sí, en este momento estas navegando y leyendo esto desde un pequeño computador en mi casa. El costo, menos de 20 mil pesos chilenos (por el nombre de dominio), más el plan de Internet de la casa. ¿Quieres saber qué es lo que hice?

La historia del nombre del dominio

Primero que todo, un nombre de dominio es el "nombre base" de un sitio web, por ejemplo, el de este blog es qo-op.cl, y tomando en cuenta el subdominio "r" es r.qo-op.cl.

El nombre de dominio nace de una forma anecdótica conversando con mis hijos (de 15 y 12 años).

Como informático, con la idea de montar "algo" con mis hijos en casa, que les permita acceder desde cualquier lado donde estén, pensé en poner a la "casa" un dominio corto de dos caracteres, algo así como una letra y un número, en este momento encontré disponible"y4", algo fácil de recordar para ellos y que no coincidiera alguna marca.

Al presentar mi "brillante" propuesta, mi primogénita respondió: -¿Podría el nombre ser una carita?-, mi reacción interna fue "Qué?!", pero dije -Solamente se pueden usar letras y números-. El resultado "qo-op" que es como una franja horizontal de una cara con lentes y orejas.

¿Qué tecnología hay detrás?

El dominio lo adquirí en nic.cl por un poco menos de 20 mil (que se paga cada dos años), lo demás es la conexión a Internet de mi casa y un NUC (Celeron®  N2830, con 8GB en RAM y un SDD de 2TB), equipo que le cambié la memoria y el disco para poder "jugar" con esto (inicialmente 4GB en RAM y disco Hdd de 420GB).

No explicaré cómo instalar Debian, pues hay muchos lugares y videos que lo explican, yo hice una netinstall y no instalé escritorio gráfico, pues la idea es que sea un servidor y no un PC de escritorio, así que no quiero que se "pierda" RAM sirviendo la interfaz gráfica. La instalación de Docker y CasaOS es cortar y pegar (quizás haga un escrito breve después), así que me detendré un poco más en cómo dejé un dominio .cl apuntando a mi casa. Y luego en cómo es la instalación de los servicios en CasaOS.

Llegando a casa con un nombre de dominio

Este nuevo nombre, qo-oq.cl, en el servidor de nombre, le creé un alias en un servicio externo, sin embargo, bajo bind9 sería "qo-op.cl IN CNAME subdominio.duckdns.org.", estoy pensando en hacer un servidor interno/externo dns en casa, pero aún no lo he hecho. Si lo hago, escribiré la experiencia.

Con un cron se invoca la URL de duckdns para ir actualizando la IP, por ejemplo, creamos el archivo duck.sh en el directorio duckdns dentro del home y lo llamamos en el cron cada 5 minutos. En ese archivo habría que reemplazar "token" por el token entregado tras el registro.

vim ~/duckdns/duck.sh

#!/bin/bash
TOK="token"; 
echo url="https://www.duckdns.org/update?domains=subdominio&token=$TOK&ip=" | curl -k -o ~/duckdns/duck.log -K -

crontab -e

*/5 * * * * sh ~/duckdns/duck.sh > /dev/null

Ahora, los que me conocen y saben que me gustan los archivos bash, y como en un principio no tenía un dominio apuntando a casa, había pedido los 5 subdominios que ofrece duckdns. por lo que hice un script distinto. Además, pensando en no hacer gastar de más a duckdns con peticiones innecesarias, reviso localmente si mi ip ha cambiado, cosa de solicitar solo cuando cambie. Ahora, al llevar ese registro, además se qué tan seguido cambia mi IP.

Cree en /etc el directorio duckdns y allí el duck.sh, es decir

sudo mkdir /etc/duckdns
sudo vim /etc/duckdns/duck.sh

El contenido del script es:

#!/bin/bash

#set -e

# Los siguienets dos parametros cambian de usuario a usuario
TOKEN="mi_token_debo_ingresar_aca"
SUBDOM="subdominio1 subdominio2 subdominio3 subdominio4 subdominio5"

# directorio base de duckdns
DR="/etc/duckdns"

FECHA=$(date +"%Y-%m-%d %H:%M:%S UTC:%Z")
cd $DR

# crea un archivo si es que no existe
create_if_not_exist_file() {
        TestFile=$1
        if [ ! -f $TestFile ]; then
                touch $TestFile
        fi
}

# se asegura que existan los archivos necesarios
init() {
        create_if_not_exist_file $DR/duckdns.log
        create_if_not_exist_file $DR/mi-ip-actual.txt 
        create_if_not_exist_file $DR/mi-ip.txt
        for sub in $(echo $SUBDOM); do
                create_if_not_exist_file $DR/duck-${sub}.log
        done
}

# actualiza la ip en duckdns
actualizaDns() {
        httping -c 1 www.duckdns.org 2>&1 > /dev/null
        if [ $? -eq 0 ]; then 
                for dom in $(echo $SUBDOM); do
                        echo url="https://www.duckdns.org/update?domains=$dom&token=$TOKEN&ip=" | curl -s -k -o $DR/duck-${dom}.log -K -
                done
                return 0
        else
                return 1
        fi
}

# proceso principal
init
ping -q -c 1 -W 1 ip.9a.cl 2>&1 > /dev/null
if [ $? -ne 0 ]; then
        echo "$FECHA ERROR: Falló encontrando ip.9a.cl" >> $DR/duckdns.log
        exit 1
else
        curl -s https://ip.9a.cl > $DR/mi-ip.txt
        IP=$(cat $DR/mi-ip.txt)
        diff -N -q $DR/mi-ip-actual.txt $DR/mi-ip.txt > /dev/null
        if [ $? -ne 0 ]; then
                actualizaDns
                if [ $? -eq 0 ]; then
                        echo "$FECHA INFO: Actualizando IP a $IP" >> $DR/duckdns.log
                        cp -au $DR/mi-ip.txt $DR/mi-ip-actual.txt
                else
                        echo "$FECHA ERROR: Falló encontrando duckdns.org" >> $DR/duckdns.log
                        exit 1
                fi
        fi
fi
exit 0

Para que el script anterior funcione bien debe estar instalado curl y httping es decir, hay que hacer un: sudo apt install -y curl httping

La llamada por cron también cambia por:

sudo cat > /var/spool/cron/crontabs/root <<EOF
# m h  dom mon dow   command
*/5 *  *   *   *     sh /etc/duckdns/duck.sh 2>&1 /dev/null
EOF

Con eso cuando cambia la dirección IP de mi casa, actualiza mi subdominio de duckdns, y por el CNAME, indirectamente, mi dominio "qo-op.cl"

Finalmente el log (/etc/duckdns/duckdns.log) sera similar a:

2024-02-20 09:55:01 UTC:-03 INFO: Actualizando IP a 201.246.63.98
2024-02-28 20:50:01 UTC:-03 ERROR: Falló encontrando ip.9a.cl
2024-02-29 07:20:01 UTC:-03 ERROR: Falló encontrando duckdns.org
2024-03-02 12:55:01 UTC:-03 INFO: Actualizando IP a 201.189.202.223
2024-03-05 15:55:01 UTC:-03 INFO: Actualizando IP a 201.189.198.124
2024-03-08 18:05:01 UTC:-03 ERROR: Falló encontrando ip.9a.cl
2024-03-08 18:10:01 UTC:-03 INFO: Actualizando IP a 201.189.198.110
2024-03-09 02:15:01 UTC:-03 ERROR: Falló encontrando ip.9a.cl
2024-03-15 00:10:01 UTC:-03 INFO: Actualizando IP a 201.189.223.154

Si quieres modificar el log para que quede en /var/log/duckdns, adelante, siempre hay cosas que mejorar, pero a mi me dio flojera porque vi que los cambios son lejanos, al menos en mi caso, por lo que no agregué un logrotate ni nada de eso.

Llego a casa, ¿ahora qué?

Lo primero que debes tener en cuenta es la configuración de "tu router" o el router que instala en casa la compañía proveedora de Internet, dado a que debes dirigir puertos o la navegación completa al equipo que dejarás de servidor. Lo segundo, dado a que vas a abrir tu servidor al mundo, debes tener protección.

[Lo importante de este párrafo, mi red interna es 192.168.0.0/23] Cambié la configuración del DHCP de 192.168.1.0/24 a 192.168.0.0/23, ¿porqué? porque en casa tengo muchas IP y las quería dejar ordenadas, no tengo tanto dispositivo como para llenar las 510 IP, pero quería dividir los fonos, tablet y notebook de los "smart home", no dejan de ser 9 luces, un enchufe, una lavadora, 2 puntos de acceso wifi, 3 cámaras, una central de monitoreo de dispositivos bluetooth (temperatura, humedad, humo), un google nest y un google chromecast, más el router, es la suficiente cantidad como para tenerlos por aparte de los otros equipos que se conectan a Internet a "navegar". Como el equipo de movistar (el router) no era capaz de manejar tanto dispositivo, terminé instalando un DHCP propio. Así lograr asignar IP fija por sus mac address. Prometo que lo documentaré en otro post.

¿Porqué tanto bla bla?, para que entiendas mejor algunas reglas de mi firewall, pues dado a que estas abriendo tu equipo al mundo, le debes colocar protección. Particularmente, usé el firewall predeterminado de Debian 12 "nftables", que se plantea como el sucesor de "iptables". Debo reconocer que iptables tras tantos años lo entendía bien, el cambio no me fue fácil. Mi dispositivo de red es "enp3s0", pero puede cambiar en el tuyo.

Qué puertos estoy abriendo al mundo, el 22, el 80 y el 443. De los cuales el 80 y 443 los estoy dejando abiertos desde los servicios prestados por docker. Esto es muy importante de tener en cuenta, pues cualquier cosa que instales allí queda abierta al mundo, por ejemplo, tu impresora, tu cámara o tus respaldos. En la tabla "filter" chain INPUT está permitido todo el tráfico propio, el de mi red (192.168.0.0/23) y el de la red docker (172.16.0.0/12). En el chain FORWARD, envío el trafico al chain DOCKER-USER, en donde filtro prohibiendo todo trafico que venga desde fuera de mi red que llegue a mi tarjeta de red "enp3s0" (la que está conectada al router), aceptando previamente solo el trafico establecido y los puertos 80 y 443, que los manejo desde CasaOS.

cat /etc/nftables.conf

#!/usr/sbin/nft -f
 
flush ruleset

table ip filter {
        chain INPUT {
                type filter hook input priority filter; policy drop;
                ct state established,related accept
                iifname "lo" accept
                icmp type echo-request accept
                ip saddr 192.168.0.0/23 accept
                ip saddr 172.16.0.0/12 accept
                tcp dport { 22, 80, 443 } accept
        }

        chain FORWARD {
                type filter hook forward priority filter; policy accept;
                counter packets 187799153 bytes 64671916463 jump DOCKER-USER
        }

        chain OUTPUT {
                type filter hook output priority filter; policy accept;
        }

        chain DOCKER {
        }

        chain DOCKER-ISOLATION-STAGE-1 {
        }

        chain DOCKER-ISOLATION-STAGE-2 {
        }

        chain DOCKER-USER {
                tcp dport { 80, 443 } accept
                ct state established,related accept
                iifname "enp3s0" ip saddr != 192.168.0.0/23 drop
        }
}

table ip nat {
        chain POSTROUTING {
                type nat hook postrouting priority srcnat; policy accept;
        }

        chain PREROUTING {
                type nat hook prerouting priority dstnat; policy accept;
        }

        chain OUTPUT {
                type nat hook output priority -100; policy accept;
        }
}

Otra cosa, si bien, nft quedó instalado junto con la instalación inicial de mi Debian, debí dejarlo activo, esto se hace así:

sudo systemctl enabled nftables.service

Al revisar el archivo del servicio /lib/systemd/system/nftables.service, se puede observar que el lugar desde donde carga sus reglas es /etc/nftables.conf que es el archivo que creamos allí arriba.

Servicios en CasaOS

Básicamente en CasaOS, lo primero que hice fue sacar CasaOS del puerto 80, así liberarlo para el proxy reverso. para eso fui a los ajustes (el que tiene el icono como un ecualizador), y cambié el "Language" a Español, el "Puerto de la WebUI" a 180... puede ser realmente cualquiera menos el 80 y 443 que queremos dejar libres.

Luego, instalé un "Nginx proxy manager". Para eso hice click en la "App Store" y en el buscador puse "proxy".

Luego puse "instalar" en el botón de "Nginx proxy manager" (en el mio dice Abrir porque ya está instalado). Desde allí, se puede dirigir la configuración de cualquier servicio web que se instale desde el interior de nuestro "servidor" hacia Internet, por ejemplo, yo instalé ghost, que es este blog, el cual desde "Nginx proxy manager" lo apunto así:

Importante, la dirección r.qo-op.cl la agregué también en el servidor de nombres con un CNAME a qo-op.cl.

Una de las grandes ventajas de "Nginx proxy manager" es que está integrado con "Let's Encrypt" para tener Certificados SSL y así tu página este cifrada y con acceso https.

Algo que me encantó de CasaOS es que no está cerrado solamente a instalar aplicaciones desde el "App Store", sino que mediante el botón "+" puedes hacer una instalación de cualquier docker-compose, por ejemplo, para mi ghost, instalé desde el "App Store" la base de datos MariaDB y mediante el docker-compose ghost.

name: ghost
services:
  ghost:
    cpu_shares: 90
    command: []
    container_name: ghost
    deploy:
      resources:
        limits:
          memory: 512M
    environment:
      - database__client=mysql
      - database__connection__database=ghost
      - database__connection__host=192.168.0.255
      - database__connection__password=**********
      - database__connection__user=********
      - mail__options__auth__pass=******
      - mail__options__auth__user=******
      - mail__options__host=******
      - mail__options__port=***
      - mail__options__service=*******
      - mail__transport=SMTP
      - url=https://r.qo-op.cl
      - admin__url=http://192.168.0.255:2368
    hostname: ghost
    image: ghost:latest
    ports:
      - target: 2368
        published: "2368"
        protocol: tcp
    restart: unless-stopped
    volumes:
      - type: bind
        source: /DATA/AppData/ghost/content
        target: /var/lib/ghost/content
    devices: []
    cap_add: []
    network_mode: bridge
    privileged: false
x-casaos:
  author: Roy
  category: Blog
  hostname: ""
  icon: https://portainer-io-assets.sfo2.digitaloceanspaces.com/logos/ghost.png
  index: /
  port_map: 2368
  scheme: http
  store_app_id: ghost
  title:
    custom: Ghost

Mi archivo es este, pero en vez de los ***** tiene los valores de configuración. Mi Host o servidor, tiene la IP 192.168.0.255, y sí, en una red /23, esa dirección es válida.

Éxito en su implementación.