Instalar WildFly en RHEL 9: Java 17 + Maven + Git (Guía con CLI)

Si vas a desplegar aplicaciones Java (Jakarta EE) en un servidor empresarial, WildFly es una opción sólida: ligero, potente y con administración por CLI (ideal para automatizar).
En esta guía instalamos Java 17, Maven, Git, descargamos WildFly 39, lo arrancamos, lo probamos con curl y verificamos estado con jboss-cli.

Requisitos

• RHEL 9 con acceso a internet
• Usuario con permisos sudo
• Acceso por terminal (SSH)

1) Actualizar el sistema

sudo dnf -y update

¿Qué hace este comando?

• dnf es el gestor de paquetes en RHEL 9.
• update actualiza paquetes instalados a sus versiones más recientes disponibles en repositorios.
• sudo ejecuta con permisos de administrador.
• -y acepta automáticamente todas las confirmaciones (evita preguntas).

2) Instalar Java 17 + Maven + Git

sudo dnf -y install java-17-openjdk java-17-openjdk-devel maven git

Detalle de cada parte

• install: instala paquetes.
• java-17-openjdk: el runtime de Java 17 (para ejecutar aplicaciones).
• java-17-openjdk-devel: herramientas de desarrollo (incluye javac).
• maven: gestor de dependencias y builds para proyectos Java.
• git: control de versiones para clonar repositorios y administrar código.
• -y: confirma automáticamente.

3) Verificar que quedó instalado correctamente

java -version
javac -version
mvn -version
git --version

¿Qué valida cada comando?

• java -version: confirma que el runtime Java existe y muestra versión.
• javac -version: confirma que está el compilador (JDK, no solo JRE).
• mvn -version: confirma Maven y muestra también qué Java usa Maven.
• git --version: confirma Git.

Nota: en tu guía aparece git –version con un guion distinto (–). En terminal debe ser: git --version (dos guiones normales).

4) (Recomendado) Exportar JAVA_HOME

Muchas herramientas (Maven, servidores, scripts) trabajan mejor si JAVA_HOME está definido.

4.1 Encontrar la ruta real del javac

readlink -f $(which javac)

¿Qué hace este comando?

• which javac: devuelve la ruta “encontrada” del binario javac en tu PATH.
• $(...): sustituye la salida de which javac dentro del comando.
• readlink -f: resuelve enlaces simbólicos y devuelve la ruta real absoluta.

Ejemplo típico de salida:
/usr/lib/jvm/java-17-openjdk-.../bin/javac

4.2 Definir JAVA_HOME en tu sesión (persistente)

Ajusta la ruta a tu caso. En RHEL suele funcionar /usr/lib/jvm/java-17-openjdk.

echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

Detalle comando por comando

• echo '...': imprime un texto literal.
• >> ~/.bashrc: lo agrega al final del archivo .bashrc (persistirá para futuras sesiones).
• export JAVA_HOME=...: crea variable de entorno.
• export PATH=$JAVA_HOME/bin:$PATH: antepone el binario de Java al PATH.
• source ~/.bashrc: recarga el archivo en la sesión actual (sin cerrar sesión).

4.3 Verificar variables

echo $JAVA_HOME
java -version

• echo $JAVA_HOME: muestra el valor actual.
• java -version: asegura que Java está disponible y coherente.

5) Descargar y preparar WildFly en /opt (CLI)

5.1 Crear carpeta y permisos

cd /opt
sudo mkdir -p wildfly
sudo chown $USER:$USER wildfly
cd wildfly

Explicación

• cd /opt: entra al directorio típico para software adicional.
• sudo mkdir -p wildfly:
  • mkdir: crea directorio.
  • -p: crea toda la ruta si falta (y no falla si ya existe).
• sudo chown $USER:$USER wildfly:
  • Cambia dueño/grupo del directorio a tu usuario actual.
  • $USER es la variable con tu usuario logueado.
• cd wildfly: entras a la carpeta para trabajar ahí.

5.2 Descargar el release oficial

curl -LO https://github.com/wildfly/wildfly/releases/download/39.0.0.Final/wildfly-39.0.0.Final.tar.gz

¿Qué hace?

• curl: descarga contenido desde una URL.
• -L: sigue redirecciones (GitHub a veces redirige).
• -O: guarda el archivo con el mismo nombre que trae el servidor (wildfly-39.0.0.Final.tar.gz).

5.3 Descomprimir el tarball

tar -xzf wildfly-39.0.0.Final.tar.gz

Detalle

• tar: herramienta de empaquetado.
• -x: extraer.
• -z: indica que viene comprimido con gzip (.gz).
• -f: especifica el archivo a operar.

6) Arrancar WildFly (escuchando en todas las interfaces)

cd wildfly-39.0.0.Final/bin
./standalone.sh -b 0.0.0.0 -bmanagement 0.0.0.0

¿Qué hace exactamente?

• cd .../bin: entras a los scripts ejecutables de WildFly.
• ./standalone.sh: inicia WildFly en modo standalone.
• -b 0.0.0.0: “bind” (escuchar) en todas las interfaces para el puerto de aplicación (HTTP 8080).
• -bmanagement 0.0.0.0: escucha en todas las interfaces para el puerto de administración (por defecto 9990).

Importante (seguridad): abrir 0.0.0.0 para management NO se recomienda en producción sin firewall/restricciones. Abajo verás la forma segura (localhost).

7) Probar que está vivo (desde el mismo servidor)

curl -I http://127.0.0.1:8080

Explicación

• curl -I: hace una petición HTTP y devuelve solo headers (rápido para comprobar).
• http://127.0.0.1:8080: apunta al propio servidor (localhost) puerto 8080.

¿Qué esperar?
Si ves headers con un status como 200, 302 o incluso 404, significa que el servidor está respondiendo (arrancó).

8) Primer prueba: arrancar WildFly solo en localhost (modo recomendado para iniciar)

Detén el proceso anterior (Ctrl + C) y arranca así:

cd /opt/wildfly/wildfly-39.0.0.Final/bin
./standalone.sh -b 127.0.0.1 -bmanagement 127.0.0.1

¿Por qué es mejor?

• Solo acepta conexiones desde el mismo servidor (más seguro mientras configuras).

Verifica de nuevo:

curl -I http://127.0.0.1:8080

---

9) Ver estado con la CLI (sin GUI)

cd /opt/wildfly/wildfly-39.0.0.Final/bin
./jboss-cli.sh --connect --command=":read-attribute(name=server-state)"

Desglose

• ./jboss-cli.sh: abre la herramienta CLI de administración de WildFly/JBoss.
• --connect: se conecta al controlador de management.
• --command="...": ejecuta un comando directo sin entrar al modo interactivo.
• :read-attribute(name=server-state): lee el atributo server-state del servidor.

Resultado esperado: normalmente verás running si todo está bien.

10) (Opcional) Crear usuario admin de management

Solo si luego quieres entrar a consola, usar scripts de management autenticados o conectarte remotamente:

cd /opt/wildfly/wildfly-39.0.0.Final/bin
./add-user.sh

¿Qué hace?

• Inicia el asistente para crear usuarios:
  • Usuarios de Management (administración)
  • O usuarios de Application (aplicación), según elijas

Al terminar, prueba conexión CLI interactiva:

./jboss-cli.sh --connect

¿Qué significa si funciona?

• Si te pide usuario/contraseña y luego ves un prompt tipo:
  • [standalone@localhost:9990 /]
• Entonces el canal de administración está correcto.

Errores típicos y solución rápida

• curl: (7) Failed to connect
  • WildFly no arrancó o el puerto no está escuchando donde crees.
  • Revisa la terminal donde corriste standalone.sh (logs).
• java: command not found
  • Java no está instalado o el PATH no se aplicó.
  • Repite: source ~/.bashrc y verifica echo $JAVA_HOME.
• CLI no conecta (--connect)
  • Asegúrate de arrancar con -bmanagement 127.0.0.1 (o la IP correcta si aplica).

Siguientes pasos recomendados (para producción)

• Crear un usuario del sistema wildfly y ejecutar como servicio systemd.
• Configurar firewalld (abrir solo lo necesario).
• Poner un reverse proxy (Nginx/Apache) con HTTPS.
• Mantener el puerto de management restringido (localhost o red privada).

Cierre

Con estos pasos ya tienes WildFly funcionando en RHEL 9, con Java 17, Maven y Git listos para compilar y desplegar aplicaciones, y administración por CLI para automatización.

¿Quieres que el siguiente post sea “WildFly como servicio systemd en RHEL 9 (seguro y con arranque automático)”?

Nota de la serie (para el blog)

Esta es la Parte 1 de una serie de guías sobre WildFly.
En esta primera entrega instalamos WildFly en RHEL 9 junto con Java 17, Maven y Git, y validamos el arranque y la administración vía CLI.

En las siguientes partes vamos a cubrir temas más avanzados como:

• Ejecutar WildFly como servicio systemd (arranque automático)
• Configuración de usuarios, seguridad y acceso remoto controlado
• Apertura de puertos con firewalld y buenas prácticas
• Despliegue de aplicaciones y ajustes de configuración por CLI