Apache NiFi es una plataforma para mover y transformar datos entre sistemas mediante flujos que se diseñan de forma visual en el navegador: cada paso es un procesador (leer ficheros, llamar a una API, escribir en una base de datos) y las conexiones entre ellos actúan como colas con control de caudal. En este tutorial instalarás NiFi 2 con Java 21 en Ubuntu 24.04, lo ejecutarás como servicio systemd con un usuario dedicado, accederás a la interfaz web de forma segura y crearás un flujo que mueve ficheros de un directorio a otro.
Requisitos previos
Para seguir esta guía necesitas:
- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios
sudo. - Al menos 4 GB de RAM y 2 vCPU (8 GB para cargas reales) y unos 20 GB libres en disco para los repositorios de contenido y de provenance.
- Acceso SSH al servidor desde tu equipo, que usarás para abrir un túnel hasta la interfaz web.
Paso 1: Instalar Java 21
NiFi 2.x requiere Java 21. Ubuntu 24.04 lo incluye en sus repositorios. Instala también unzip, porque NiFi se distribuye como archivo ZIP:
sudo apt update
sudo apt install -y openjdk-21-jre-headless unzip
Comprueba la versión de Java:
java -version
openjdk version "21.0.8" 2025-07-15
OpenJDK Runtime Environment (build 21.0.8+9-Ubuntu-0ubuntu124.04.1)
OpenJDK 64-Bit Server VM (build 21.0.8+9-Ubuntu-0ubuntu124.04.1, mixed mode, sharing)
El número exacto de parche puede variar; lo importante es que empiece por 21.
Paso 2: Descargar y verificar NiFi
Consulta la versión estable actual en la página de descargas de NiFi. Esta guía usa la 2.12.0; si hay una más reciente, cambia el número en los comandos. Descarga el archivo y su suma de comprobación SHA-512:
cd /tmp
curl -fLO https://downloads.apache.org/nifi/2.12.0/nifi-2.12.0-bin.zip
curl -fLO https://downloads.apache.org/nifi/2.12.0/nifi-2.12.0-bin.zip.sha512
El fichero .sha512 contiene solo el hash, así que se compara de esta forma:
echo "$(cat nifi-2.12.0-bin.zip.sha512) nifi-2.12.0-bin.zip" | sha512sum -c -
nifi-2.12.0-bin.zip: OK
Notacuando se publica una versión nueva, las anteriores desaparecen de
downloads.apache.orgy pasan ahttps://archive.apache.org/dist/nifi/. Si la descarga devuelve un error 404, usa esa ruta o la versión actual.
Crea un usuario de sistema sin shell para ejecutar NiFi, extrae el archivo en /opt y crea un enlace simbólico /opt/nifi, que facilita las actualizaciones futuras:
sudo useradd --system --home-dir /opt/nifi --shell /usr/sbin/nologin nifi
sudo unzip -q nifi-2.12.0-bin.zip -d /opt
sudo ln -s /opt/nifi-2.12.0 /opt/nifi
sudo chown -R nifi:nifi /opt/nifi-2.12.0
Comprueba que el enlace apunta a la instalación y que el script de arranque existe:
ls -l /opt/nifi/bin/nifi.sh
La salida debe mostrar el fichero con permisos de ejecución (-rwxr-xr-x) y nifi como propietario.
Paso 3: Ajustar la memoria y revisar la configuración
La memoria de la JVM se define en /opt/nifi/conf/bootstrap.conf. Por defecto NiFi arranca con 1 GB de heap, que se queda corto en cuanto los flujos crecen. Abre el archivo:
sudo nano /opt/nifi/conf/bootstrap.conf
Localiza las líneas java.arg.2 y java.arg.3 y ajústalas. En un servidor de 4 GB, 2 GB de heap es un buen punto de partida; deja siempre memoria libre para el sistema y la caché de disco:
java.arg.2=-Xms2g
java.arg.3=-Xmx2g
La configuración principal está en /opt/nifi/conf/nifi.properties. Comprueba en qué dirección escucha la interfaz web:
grep -E '^nifi.web.https.(host|port)' /opt/nifi/conf/nifi.properties
nifi.web.https.host=127.0.0.1
nifi.web.https.port=8443
NiFi escucha solo en 127.0.0.1 con HTTPS y un certificado autofirmado que genera en el primer arranque. Es la opción más segura: accederás a través de un túnel SSH sin abrir el puerto 8443 a Internet.
Paso 4: Definir el usuario y la contraseña de acceso
NiFi 2 usa por defecto un único usuario con contraseña. Si no la defines, genera unas credenciales aleatorias y las escribe en el log. Es más cómodo fijarlas antes del primer arranque. Sustituye your_strong_password por una contraseña de al menos 12 caracteres:
sudo -u nifi /opt/nifi/bin/nifi.sh set-single-user-credentials admin 'your_strong_password'
El comando guarda la contraseña cifrada con bcrypt en /opt/nifi/conf/login-identity-providers.xml. Puedes ver un aviso JAVA_HOME not set, que es inofensivo aquí porque java está en el PATH.
Paso 5: Crear el servicio systemd
El comando nifi.sh run ejecuta NiFi en primer plano, que es justo lo que necesita systemd para supervisar el proceso y reiniciarlo si falla. Crea la unidad:
sudo nano /etc/systemd/system/nifi.service
[Unit]
Description=Apache NiFi
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=nifi
Group=nifi
Environment=JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
ExecStart=/opt/nifi/bin/nifi.sh run
SuccessExitStatus=143
TimeoutStopSec=60
Restart=on-failure
RestartSec=10
LimitNOFILE=50000
LimitNPROC=10000
[Install]
WantedBy=multi-user.target
LimitNOFILE sube el límite de ficheros abiertos, ya que NiFi mantiene muchos a la vez en sus repositorios. Si tu servidor es arm64, la ruta de Java es /usr/lib/jvm/java-21-openjdk-arm64.
Recarga systemd y arranca el servicio:
sudo systemctl daemon-reload
sudo systemctl enable --now nifi
El primer arranque tarda uno o dos minutos porque NiFi descomprime sus extensiones y genera el certificado. Sigue el progreso en el log de la aplicación:
sudo tail -f /opt/nifi/logs/nifi-app.log
Cuando veas un mensaje similar a este, pulsa Ctrl+C:
... INFO [main] org.apache.nifi.web.server.JettyServer Started Server on https://127.0.0.1:8443/nifi
Comprueba que el servicio está activo y que el puerto está a la escucha:
systemctl status nifi --no-pager
sudo ss -tlnp | grep 8443
LISTEN 0 50 127.0.0.1:8443 0.0.0.0:* users:(("java",pid=4211,fd=412))
Paso 6: Acceder a la interfaz web
Desde tu equipo local, abre un túnel SSH que redirija el puerto 8443 local al puerto 8443 del servidor. Sustituye your_user y your_server_ip por tus datos:
ssh -L 8443:127.0.0.1:8443 your_user@your_server_ip
Mientras la sesión SSH siga abierta, visita https://localhost:8443/nifi en el navegador. Acepta el aviso del certificado autofirmado e inicia sesión con el usuario admin y la contraseña del paso 4. Verás el lienzo vacío de NiFi.
Notasi necesitas acceso directo sin túnel, cambia
nifi.web.https.hosta0.0.0.0, añadenifi.web.proxy.host=your_domain:8443ennifi.properties(sin esa línea NiFi rechaza las peticiones con el error "Invalid host header"), permite el puerto consudo ufw allow 8443/tcpy limita el acceso a tus IP. Para producción es preferible un certificado válido y un proxy inverso delante.
Paso 7: Crear un primer flujo de datos
Vas a construir un flujo sencillo que recoge ficheros de un directorio de entrada y los escribe en uno de salida. Así verás cómo se configuran procesadores, conexiones y relaciones. Crea los directorios y asígnalos al usuario nifi:
sudo mkdir -p /opt/nifi-data/entrada /opt/nifi-data/salida
sudo chown -R nifi:nifi /opt/nifi-data
En la interfaz web:
- Arrastra el icono Processor de la barra superior al lienzo, busca
GetFiley pulsa Add. - Haz doble clic en el procesador y, en la pestaña Properties, establece Input Directory en
/opt/nifi-data/entrada. Aplica los cambios. - Añade un segundo procesador de tipo
PutFile. En Properties, establece Directory en/opt/nifi-data/salida. - En la pestaña Relationships de
PutFile, marca terminate ensuccessyfailure. Así NiFi sabe que el flujo termina ahí. - Pasa el ratón sobre
GetFile, arrastra la flecha que aparece hastaPutFiley crea la conexión para la relaciónsuccess. - Selecciona ambos procesadores (clic en el lienzo vacío y
Ctrl+A) y pulsa Start en la paleta de operación.
Los procesadores deben mostrar un icono verde de ejecución. Si alguno muestra un triángulo amarillo, pasa el ratón por encima para ver qué propiedad o relación falta.
Comprueba el flujo creando un fichero en el directorio de entrada:
echo "hola nifi" | sudo -u nifi tee /opt/nifi-data/entrada/prueba.txt
Tras unos segundos, GetFile recoge el fichero (y lo elimina del origen, que es su comportamiento por defecto) y PutFile lo escribe en la salida:
ls /opt/nifi-data/entrada /opt/nifi-data/salida
/opt/nifi-data/entrada:
/opt/nifi-data/salida:
prueba.txt
Para ver el recorrido completo del fichero, haz clic derecho en PutFile y elige View Data Provenance. Cada evento guarda los atributos y el contenido del FlowFile en cada paso, algo muy útil para depurar flujos reales.
Procesadores habituales
Una vez entendido el patrón, los flujos reales se construyen igual, cambiando los procesadores:
| Procesador | Uso |
|---|---|
ListFile + FetchFile | Leer ficheros sin borrarlos del origen y sin repetirlos |
InvokeHTTP | Llamar a APIs REST |
QueryDatabaseTableRecord | Leer de una base de datos de forma incremental |
ConvertRecord | Convertir entre formatos (CSV, JSON, Avro) |
JoltTransformJSON | Transformar la estructura de documentos JSON |
RouteOnAttribute | Enrutar FlowFiles según sus atributos |
PutDatabaseRecord | Insertar registros en una base de datos |
ConsumeKafka / PublishKafka | Leer y escribir en Kafka |
Solución de problemas
El servicio no arranca o se reinicia en bucle. Revisa el journal y el log de arranque:
sudo journalctl -u nifi -n 50 --no-pager
sudo grep -E 'ERROR|Exception' /opt/nifi/logs/nifi-app.log | tail -20
Las causas más comunes son permisos incorrectos (algún fichero de /opt/nifi-2.12.0 no pertenece a nifi) o una ruta de JAVA_HOME que no existe. Comprueba la ruta con ls /usr/lib/jvm/.
NiFi se detiene con OutOfMemoryError. El heap es insuficiente para los flujos que ejecutas. Aumenta java.arg.3 en bootstrap.conf sin superar el 50-60 % de la RAM y reinicia con sudo systemctl restart nifi.
Has olvidado la contraseña. Vuelve a ejecutar set-single-user-credentials como en el paso 4 y reinicia el servicio.
Las colas se ponen en rojo. La conexión ha alcanzado su límite de backpressure y NiFi frena al procesador anterior. Revisa por qué el procesador de destino es lento, aumenta sus Concurrent Tasks en la pestaña Scheduling o sube el umbral de la conexión.
Conclusión
Tienes Apache NiFi 2 funcionando como servicio en Ubuntu 24.04, accesible de forma segura por un túnel SSH, y un primer flujo que demuestra cómo encajan procesadores, conexiones y provenance. A partir de aquí puedes construir flujos ETL reales combinando lectura desde APIs o bases de datos con transformaciones de registros. Como siguientes pasos, agrupa los flujos en Process Groups, guarda sus versiones con NiFi Registry y sustituye el certificado autofirmado por uno válido antes de abrir el acceso a más usuarios.