Servidor NGINX en Raspberry Pi

Introducción

En esta publicación te muestro cómo desplegar una aplicación Flask detrás de un servidor NGINX en una Raspberry Pi Zero 2 W, utilizando Docker y Portainer para la gestión de contenedores.

¿Qué es la Raspberry Pi Zero 2 W?

Es una microcomputadora compacta y económica con arquitectura ARM, ideal para proyectos de bajo consumo como servidores caseros, IoT, automatización y aprendizaje.

Objetivo del proyecto

El proyecto consiste en desplegar una aplicación con HTML, CSS y JavaScript en el frontend, y Python con Flask en el backend. La base de datos utilizada es SQLite.

Se utiliza un servidor NGINX ejecutado dentro de un contenedor Docker, monitoreado mediante Portainer. Para exponer la aplicación a Internet, se configura un túnel de Cloudflare, evitando exponer directamente la red local.

Tecnologías utilizadas: Python, Docker, Docker Compose, Flask, SQLite, Bootstrap, JavaScript.

Preparación del entorno

Antes de comenzar, actualicé el sistema operativo de mi Raspberry Pi y eliminé cualquier versión anterior de Docker para evitar conflictos.

Configuración inicial (SSH, red, actualizaciones)

Me conecté por SSH a la Raspberry Pi, configuré la red local y apliqué todas las actualizaciones necesarias del sistema operativo.

Instalación de Docker y Portainer

Instalé Docker y Portainer siguiendo la guía oficial. En mi caso, usé los scripts automatizados para agilizar el proceso.

Montaje del stack Flask + SQLite

Para tener una base de datos persistente, primero creé un volumen en Docker:

sudo docker volume create flask_data

Verifiqué que el volumen fue creado:

sudo docker volume ls

Script de inicialización de la base de datos y Gunicorn

#!/bin/sh

echo "🛠 Verificando base de datos en volumen /data..."

mkdir -p /data

if [ ! -f /data/db_employee.db ]; then
    echo "📁 No se encontró /data/db_employee.db, copiando desde /app/data/"
    cp /app/data/db_employee.db /data/db_employee.db
else
    echo "✅ Base de datos ya existe en /data"
fi

echo "🚀 Iniciando Gunicorn..."
exec gunicorn -c /app/gunicorn.conf.py app:app

Creación de red Docker

sudo docker network create flask_net

Dockerfile para Flask

FROM python:3.11-alpine

RUN apk add --no-cache gcc musl-dev libffi-dev

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN chmod +x /app/entrypoint.sh && mkdir -p /data

EXPOSE 8000

ENTRYPOINT ["/app/entrypoint.sh"]

Construí la imagen y ejecuté el contenedor:

sudo docker build -t app-flask .
docker run -d \
  --name flask_app \
  --network flask_net \
  -v flask_data:/data \
  app-flask

Configuración del servidor NGINX

El contenedor NGINX actuó como proxy inverso apuntando a la app Flask:

server {
    listen 80;
    server_name localhost;

    location / {
        proxy_pass http://flask_app:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Dockerfile para NGINX

FROM nginx:alpine
COPY default.conf /etc/nginx/conf.d/default.conf

Construcción y ejecución del contenedor:

docker build -t nginx-proxy ./nginx

sudo docker run -d \
  --name nginx_server \
  --network flask_net \
  -v /home/josmacpac/nginx_server/default.conf:/etc/nginx/conf.d/default.conf \
  -p 80:80 \
  nginx

Conclusión

Este proyecto demuestra que es posible montar un entorno completo utilizando herramientas modernas como Docker, NGINX y Flask en hardware de bajo costo. Gracias al uso de contenedores y túneles seguros, se logra un entorno robusto y accesible desde cualquier lugar sin comprometer la seguridad.