--- title: "Cómo instalar Apache NiFi 2 en Ubuntu 24.04" description: "Instala Apache NiFi 2 con Java 21 en Ubuntu 24.04, ejecútalo como servicio systemd, accede a su interfaz web por HTTPS y crea un primer flujo de datos." category: "Ingeniería de Datos" language: es source: https://cubepath.com/es/docs/ingeniería-de-datos/instalacion-de-apache-nifi-flujo-de-datos updated: 2026-09-25 --- # Cómo instalar Apache NiFi 2 en Ubuntu 24.04 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: ```bash sudo apt update sudo apt install -y openjdk-21-jre-headless unzip ``` Comprueba la versión de Java: ```bash java -version ``` ```output 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](https://nifi.apache.org/download/). 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: ```bash 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: ```bash echo "$(cat nifi-2.12.0-bin.zip.sha512) nifi-2.12.0-bin.zip" | sha512sum -c - ``` ```output nifi-2.12.0-bin.zip: OK ``` > Nota: cuando se publica una versión nueva, las anteriores desaparecen de `downloads.apache.org` y pasan a `https://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: ```bash 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: ```bash 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: ```bash 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: ```ini 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: ```bash grep -E '^nifi.web.https.(host|port)' /opt/nifi/conf/nifi.properties ``` ```output 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: ```bash 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: ```bash sudo nano /etc/systemd/system/nifi.service ``` ```ini [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: ```bash 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: ```bash sudo tail -f /opt/nifi/logs/nifi-app.log ``` Cuando veas un mensaje similar a este, pulsa `Ctrl+C`: ```output ... 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: ```bash systemctl status nifi --no-pager sudo ss -tlnp | grep 8443 ``` ```output 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: ```bash 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. > Nota: si necesitas acceso directo sin túnel, cambia `nifi.web.https.host` a `0.0.0.0`, añade `nifi.web.proxy.host=your_domain:8443` en `nifi.properties` (sin esa línea NiFi rechaza las peticiones con el error "Invalid host header"), permite el puerto con `sudo ufw allow 8443/tcp` y 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`: ```bash sudo mkdir -p /opt/nifi-data/entrada /opt/nifi-data/salida sudo chown -R nifi:nifi /opt/nifi-data ``` En la interfaz web: 1. Arrastra el icono **Processor** de la barra superior al lienzo, busca `GetFile` y pulsa **Add**. 2. Haz doble clic en el procesador y, en la pestaña **Properties**, establece **Input Directory** en `/opt/nifi-data/entrada`. Aplica los cambios. 3. Añade un segundo procesador de tipo `PutFile`. En **Properties**, establece **Directory** en `/opt/nifi-data/salida`. 4. En la pestaña **Relationships** de `PutFile`, marca **terminate** en `success` y `failure`. Así NiFi sabe que el flujo termina ahí. 5. Pasa el ratón sobre `GetFile`, arrastra la flecha que aparece hasta `PutFile` y crea la conexión para la relación `success`. 6. 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: ```bash 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: ```bash ls /opt/nifi-data/entrada /opt/nifi-data/salida ``` ```output /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: ```bash 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.