World Wide Web

1. DNS

Hasta ahora estábamos accediendo a nuestros servicios únicamente desde nuestra red local usando direcciones IP privadas. El objetivo es poder acceder a nuestro servidor utilizando un dominio. Para ello deberemos utilizar un servicio de DNS. Una alternativa gratuita y muy práctica es duckdns.

Una vez que creamos nuestro dominio seguimos los pasos para instalar alguna de las opciones para mantener actualizada nuestra IP. Para linux la recomendada es utilizar cron.

Aclaración: Al trabajar en la facultad no podremos utilizar los puertos 80 y 443 ya que los mismos se utilizan para los servicios web de la propia facultad. Es por ello que vamos a encaminar todo nuestro tráfico web por un puerto asignado por la gente de sistemas (mayor a 10000)

2. nginx + Let'sEncrypt

Nginx

Hasta ahora solo accedimos a contenido web generado por aplicaciones de terceros. Nginx es un servidor web que nos permite alojar nuestro propio contenido.

Nginx además es un proxy-reverso. Redirige el tráfico a otros servicios/servidores según una serie de criterios: subdominio, subdirectorio, puerto, etc

Let'sEncrypt

Para que nuestros servicios utilicen comunicación cifrada necesitaremos una serie de claves y un certificado que las avale. Si generamos nosotros mismos esos certificados tendremos una comunicación cifrada pero los navegadores detectan estos certificados como riesgosos y lanzan una advertencia al momento de acceder al sitio.

La compañía Let'sEncrypt ofrece certificados válidos de manera gratuita. Estos certificados tienen una validez de 90 días. Para validar los certificados Let'sEncrypt genera una conexión al puerto 80 pero recordemos que, estando en la facultad, no podemos usar ese puerto.

Por suerte Let'sEncrypt permite validar el dominio utilizando resolución vía DNS con duckdns.

swag

$ git clone https://github.com/GermanXander/docker_iot.git

# branch WWWa

IP WAN: 200.45.145.146

NAME    MAC                IP              DNS                                PORT      TCP/UDP
Rasp0   E4:5F:01:C2:A1:36  192.168.25.210  fabricck.duckdns.org               10060,10160,10860
Rasp1   E4:5F:01:C2:A2:89  192.168.25.211  fernandokle.duckdns.org            10061,10161,10861
Rasp2   E4:5F:01:C2:8B:10  192.168.25.212  hectoriot2024.duckdns.org          10062,10162,10862
Rasp3   E4:5F:01:C2:8B:BB  192.168.25.213  alaniot.duckdns.org                10063,10163,10863
Rasp4   E4:5F:01:48:D0:D3  192.168.25.214  iotsandro.duckdns.org              10064,10164,10864
Rasp5   E4:5F:01:C2:8A:AA  192.168.25.215  alanb525.duckdns.org               10065,10165,10865
Rasp6   E4:5F:01:C2:07:F1  192.168.25.216  marianodr.duckdns.org              10066,10166,10866
Rasp7   B8:27:EB:6F:34:10  192.168.25.217  stackberry.duckdns.org             10067,10167,10867
Rasp8   B8:27:EB:C7:8B:DA  192.168.25.218  raspi-angelo.duckdns.org           10068,10168,10868
Rasp9   E4:5F:01:C2:A2:95  192.168.25.219  kisielpi.duckdns.org               10069,10169,10869
Net01   B4:D5:BD:67:A9:3A  192.168.25.220  monomxt.duckdns.org                10059,10159,10859
Net02   88:B1:11:04:C1:67  192.168.25.46   fiounam.duckdns.org                10058,10158,10858

3. phpmyadmin + TLS

Para acceder a phpmyadmin utilizando TLS vamos a configurar nginx para que direccione la comunicación cifrada a nuestro servicio de phpmyadmin. Para ello se debe editar/agregar un archivo en ~/docker/swag/nginx/proxy-confs/. Swag ya trae plantillas de ejemplo para una variedad de servicios. Basta renombrarlos (quitar la extensión .sample). En algunos casos habrá que hacer cambios mínimos a la configuración. Optamos por utilizar subdirectorios para cada servicio.

~/docker/swag/nginx/proxy-confs/phpmyadmin.subfolder.conf

# branch WWWb

4. Grafana + TLS

Con grafana procedemos de manera similar a phpmyadmin:
Renombramos el archivo ~/docker/swag/nginx/proxy-confs/grafana.subfolder.conf.sample y agregamos los parámetros que nos indica ese archivo a compose.yaml

# branch WWWc

5. Portainer +TLS

Para acceder a Portainer utilizando dominio +TLS no hace falta cambiar nada en compose.yaml, pero si en el archivo correspondiente de configuración en nginx.

~/docker/swag/nginx/proxy-confs/portainer.subfolder.conf

location /portainer {
    return 301 $scheme://$host:10000/portainer/;  # <-- editar
}

location ^~ /portainer/ {
    include /config/nginx/proxy.conf;
    include /config/nginx/resolver.conf;
    set $upstream_app portainer;
    set $upstream_port 9443;  # <-- editar
    set $upstream_proto https;  # <-- editar
    proxy_pass $upstream_proto://$upstream_app:$upstream_port;

    rewrite /portainer(.*) $1 break;
    proxy_hide_header X-Frame-Options; # Possibly not needed after Portainer 1.20.0
}

location ^~ /portainer/api {
    include /config/nginx/proxy.conf;
    include /config/nginx/resolver.conf;
    set $upstream_app portainer;
    set $upstream_port 9443;  # <-- editar
    set $upstream_proto https;  # <-- editar
    proxy_pass $upstream_proto://$upstream_app:$upstream_port;

    rewrite /portainer(.*) $1 break;
    proxy_hide_header X-Frame-Options; # Possibly not needed after Portainer 1.20.0
}

6. mosquitto + TLS (mqtts)

Mqtt no es un protocolo manejado por nginx por lo que no tendremos que configurar nada ahí. Pero vamos a utilizar los certificados de Let'sEncrypt de nuestro dominio. Recordemos que estos certificados los maneja swag. Mediante docker-compose compartimos los mismos con el contenedor de mosquitto.

Aprovechamos para exponer la carpeta log y data de mosquitto

# branch BEe

# compose.yaml

Deberemos agregar un "listener" en el archivo mosquitto.conf que atienda en el puerto 8883. También bloqueamos el acceso sin usuario y contraseña.

# mosquitto.conf

listener 1883 
protocol mqtt
#allow_anonymous true

listener 8883
protocol mqtt
cafile /var/tmp/live/iotunam.duckdns.org/chain.pem    # <-- reemplazar dominio
certfile /var/tmp/live/iotunam.duckdns.org/cert.pem   # <-- reemplazar dominio
keyfile /var/tmp/live/iotunam.duckdns.org/privkey.pem # <-- reemplazar dominio
password_file /mosquitto/config/passwd
#allow_anonymous true

Para generar los usuarios y contraseñas debemos ejecutar el shell del contenedor mosquitto

~/docker $ docker exec -ti mosquitto /bin/sh

una vez adentro utilizamos el comando

$ mosquitto_passwd -c /mosquitto/config/passwd <usuario>

el modificador -c se utiliza solo con el primer usuario. Es para crear el archivo de contraseñas. Para seguir agregando usuarios no se debe agregar -c.

$ mosquitto_passwd /mosquitto/config/passwd <usuario>

Para que nuestro clientemqtt vuelva a funcionar deberemos asignarle un usuario y contraseña válidos ya que nuestro broker ahora exije identificación

# clienteMqtt.py

Antes de poder usar nuestro cliente deberemos volver a compilar la imagen docker (build). También deberemos pasarle el usuario y contraseña vía variables de entorno en docker-compose.

# compose.yaml

6.1. nodo remoto

También deberemos modificar el script del esp32 para incluir usuario y contraseña. Esto lo hacemos en el archivo mqtt_local.py

$ git clone https://github.com/GermanXander/esp32.git
# branch BEb

Recuerde que las variables las guardamos en settings.py