Crea sito

Come installare il server Java Wildfly sul Raspberry PI

image_pdfimage_print

In questo articolo vedremo come installare sul Raspberry PI il server Java Wildfly, un ottimo strumento per aumentare le funzionalità del nostro PC.

Wildfly_logo

Nello scorso articolo abbiamo spiegato come installare sul piccolo PC il server Apache con PHP, con i quali è possibile sviluppare progetti che richiedono l’invio di dati tra diversi nodi e il salvataggio di tali informazioni all’interno di un DB MySQL. Wildfly è “concorrente” di di PHP, in quanto è una tecnologia lato server, con la quale è possibile trasformare il Raspberry PI in un dispositivo in grado di ricevere ed effettuare richieste, salvare dati etc…

Grazie all’utilizzo di strumenti come Hibernate, JSON etc… sarà davvero semplice gestire grosse quantità di informazioni.

Rispetto al PHP, il server Wildfly è uno strumento più potente che richiede più risorse, in quanto dietro c’è sempre la Java Virtual Machine, mentre la prima tecnologia è spesso impiegata all’inizio di un progetto, in quanto richiede poco tempo sviluppare un prototipo.

Giusto per descrivere correttamente Widfly, ecco la definizione tratta da Wikipedia:

WildFly, precedentemente noto come JBoss AS o semplicemente JBoss, è un application server open source che implementa le specifiche Java EE. WildFly è un sistema multipiattaforma, interamente realizzato in Java.

Il sistema è stato originariamente creato dalla società “JBoss Inc.“; nel 2006 è stato acquistato da Red Hat per 420 milioni di dollari. Viene gestito come progetto open source ed è sostenuto da una enorme rete di sviluppatori.

A WildFly sono associati una quantità di altri prodotti, incluso Hibernate, Tomcat, JBoss ESB, jBPM, JBoss Rules (ex Drools), JBoss Cache, JGroups, JBoss Portal, SEAM, JBoss Transaction, e JBoss Messaging.

Nei prossimi articoli, verranno mostrati un po’ di progetti basati sulla tecnologia Wildfly, che metteranno in luce le enormi funzionalità di questo strumento. Uno tra tutti è la creazione di un server con REST API, pattern ormai famosissimo nel mondo dell’informatica.

Installazione

L’installazione del server Wildfly è un’operazione non semplicissima, che però verrà semplificata grazie all’utilizzo di un script, in quanto sarebbe richiesti diversi comandi, da inviare attraverso il terminale. Inoltre, grazie a questo script, Wildfly verrà impostato come servizio e questo significa che partirà all’invio del sistema operativo, proprio come Apache.

Il primo passaggio è quello di caricare sul Raspberry PI questo script:

#!/bin/bash
#title           :wildfly-install.sh
#description     :The script to install Wildfly 10.x
#more            :http://sukharevd.net/wildfly-8-installation.html
#author	         :Dmitriy Sukharev
#date            :2015-10-24T17:14-0700
#usage           :/bin/bash wildfly-install.sh
#tested-version  :10.0.0.CR3
#tested-distros  :Debian 7,8; Ubuntu 15.10; CentOS 7; Fedora 22 

WILDFLY_VERSION=10.0.4.Final
WILDFLY_FILENAME=wildfly-$WILDFLY_VERSION
WILDFLY_ARCHIVE_NAME=$WILDFLY_FILENAME.tar.gz
WILDFLY_DOWNLOAD_ADDRESS=http://download.jboss.org/wildfly/$WILDFLY_VERSION/$WILDFLY_ARCHIVE_NAME

INSTALL_DIR=/opt
WILDFLY_FULL_DIR=$INSTALL_DIR/$WILDFLY_FILENAME
WILDFLY_DIR=$INSTALL_DIR/wildfly

WILDFLY_USER="wildfly"
WILDFLY_SERVICE="wildfly"
WILDFLY_MODE="standalone"

WILDFLY_STARTUP_TIMEOUT=240
WILDFLY_SHUTDOWN_TIMEOUT=30

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

if [[ $EUID -ne 0 ]]; then
   echo "This script must be run as root."
   exit 1
fi

echo "Downloading: $WILDFLY_DOWNLOAD_ADDRESS..."
[ -e "$WILDFLY_ARCHIVE_NAME" ] && echo 'Wildfly archive already exists.'
if [ ! -e "$WILDFLY_ARCHIVE_NAME" ]; then
  wget -q $WILDFLY_DOWNLOAD_ADDRESS
  if [ $? -ne 0 ]; then
    echo "Not possible to download Wildfly."
    exit 1
  fi
fi

echo "Cleaning up..."
rm -f "$WILDFLY_DIR"
rm -rf "$WILDFLY_FULL_DIR"
rm -rf "/var/run/$WILDFLY_SERVICE/"
rm -f "/etc/init.d/$WILDFLY_SERVICE"

echo "Installation..."
mkdir $WILDFLY_FULL_DIR
tar -xzf $WILDFLY_ARCHIVE_NAME -C $INSTALL_DIR
ln -s $WILDFLY_FULL_DIR/ $WILDFLY_DIR
useradd -s /sbin/nologin $WILDFLY_USER
chown -R $WILDFLY_USER:$WILDFLY_USER $WILDFLY_DIR
chown -R $WILDFLY_USER:$WILDFLY_USER $WILDFLY_DIR/

#mkdir -p /var/log/$WILDFLY_SERVICE

echo "Registrating Wildfly as service..."
# if should use systemd
if [ -x /bin/systemctl ]; then
    # Script from $WILDFLY_DIR/docs/contrib/scripts/systemd/launch.sh didn't work for me
    cat > $WILDFLY_DIR/bin/launch.sh << "EOF"
#!/bin/sh

if [ "x$WILDFLY_HOME" = "x" ]; then
    WILDFLY_HOME="/opt/wildfly"
fi

if [ "x$1" = "xdomain" ]; then
    echo 'Starting Wildfly in domain mode.'
    $WILDFLY_HOME/bin/domain.sh -c $2 -b $3
    #>> /var/log/$WILDFLY_SERVICE/server-`date +%Y-%m-%d`.log
else
    echo 'Starting Wildfly in standalone mode.'
    $WILDFLY_HOME/bin/standalone.sh -c $2 -b $3
    #>> /var/log/$WILDFLY_SERVICE/server-`date +%Y-%m-%d`.log
fi
EOF
    # $WILDFLY_HOME is not visible here
    sed -i -e 's,WILDFLY_HOME=.*,WILDFLY_HOME='$WILDFLY_DIR',g' $WILDFLY_DIR/bin/launch.sh
    #sed -i -e 's,$WILDFLY_SERVICE,'$WILDFLY_SERVICE',g' $WILDFLY_DIR/bin/launch.sh
    chmod +x $WILDFLY_DIR/bin/launch.sh
    
    cp $WILDFLY_DIR/docs/contrib/scripts/systemd/wildfly.service /etc/systemd/system/$WILDFLY_SERVICE.service
    WILDFLY_SERVICE_CONF=/etc/default/$WILDFLY_SERVICE
    # To install multiple instances of Wildfly replace all hardcoding in systemd file
    sed -i -e 's,EnvironmentFile=.*,EnvironmentFile='$WILDFLY_SERVICE_CONF',g' /etc/systemd/system/$WILDFLY_SERVICE.service
    sed -i -e 's,User=.*,User='$WILDFLY_USER',g' /etc/systemd/system/$WILDFLY_SERVICE.service
    sed -i -e 's,PIDFile=.*,PIDFile=/var/run/wildfly/'$WILDFLY_SERVICE'.pid,g' /etc/systemd/system/$WILDFLY_SERVICE.service
    sed -i -e 's,ExecStart=.*,ExecStart='$WILDFLY_DIR'/bin/launch.sh $WILDFLY_MODE $WILDFLY_CONFIG $WILDFLY_BIND,g' /etc/systemd/system/$WILDFLY_SERVICE.service
    systemctl daemon-reload
    #systemctl enable $WILDFLY_SERVICE.service
fi

# if non-systemd Debian-like distribution
if [ ! -x /bin/systemctl -a -r /lib/lsb/init-functions ]; then
    cp $WILDFLY_DIR/docs/contrib/scripts/init.d/wildfly-init-debian.sh /etc/init.d/$WILDFLY_SERVICE
    sed -i -e 's,NAME=wildfly,NAME='$WILDFLY_SERVICE',g' /etc/init.d/$WILDFLY_SERVICE
    WILDFLY_SERVICE_CONF=/etc/default/$WILDFLY_SERVICE
fi

# if non-systemd RHEL-like distribution
if [ ! -x /bin/systemctl -a -r /etc/init.d/functions ]; then
    cp $WILDFLY_DIR/docs/contrib/scripts/init.d/wildfly-init-redhat.sh /etc/init.d/$WILDFLY_SERVICE
    WILDFLY_SERVICE_CONF=/etc/default/wildfly.conf
    chmod 755 /etc/init.d/$WILDFLY_SERVICE
fi

# if neither Debian nor RHEL like distribution
if [ ! -x /bin/systemctl -a ! -r /lib/lsb/init-functions -a ! -r /etc/init.d/functions ]; then
cat > /etc/init.d/$WILDFLY_SERVICE << "EOF"
#!/bin/sh
### BEGIN INIT INFO
# Provides:          ${WILDFLY_SERVICE}
# Required-Start:    $local_fs $remote_fs $network $syslog
# Required-Stop:     $local_fs $remote_fs $network $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start/Stop ${WILDFLY_FILENAME}
### END INIT INFO

WILDFLY_USER=${WILDFLY_USER}
WILDFLY_DIR=${WILDFLY_DIR}

case "$1" in
start)
echo "Starting ${WILDFLY_FILENAME}..."
start-stop-daemon --start --background --chuid $WILDFLY_USER --exec $WILDFLY_DIR/bin/standalone.sh
exit $?
;;
stop)
echo "Stopping ${WILDFLY_FILENAME}..."

start-stop-daemon --start --quiet --background --chuid $WILDFLY_USER --exec $WILDFLY_DIR/bin/jboss-cli.sh -- --connect command=:shutdown
exit $?
;;
log)
echo "Showing server.log..."
tail -500f $WILDFLY_DIR/standalone/log/server.log
;;
*)
echo "Usage: /etc/init.d/wildfly {start|stop}"
exit 1
;;
esac
exit 0
EOF
sed -i -e 's,${WILDFLY_USER},'$WILDFLY_USER',g; s,${WILDFLY_FILENAME},'$WILDFLY_FILENAME',g; s,${WILDFLY_SERVICE},'$WILDFLY_SERVICE',g; s,${WILDFLY_DIR},'$WILDFLY_DIR',g' /etc/init.d/$WILDFLY_SERVICE
chmod 755 /etc/init.d/$WILDFLY_SERVICE
fi

if [ ! -z "$WILDFLY_SERVICE_CONF" ]; then
    echo "Configuring service..."
    echo JBOSS_HOME=\"$WILDFLY_DIR\" > $WILDFLY_SERVICE_CONF
    echo JBOSS_USER=$WILDFLY_USER >> $WILDFLY_SERVICE_CONF
    echo WILDFLY_HOME=\"$WILDFLY_DIR\" > $WILDFLY_SERVICE_CONF
    echo WILDFLY_USER=\"$WILDFLY_USER\" > $WILDFLY_SERVICE_CONF
    echo STARTUP_WAIT=$WILDFLY_STARTUP_TIMEOUT >> $WILDFLY_SERVICE_CONF
    echo SHUTDOWN_WAIT=$WILDFLY_SHUTDOWN_TIMEOUT >> $WILDFLY_SERVICE_CONF   
    echo WILDFLY_CONFIG=$WILDFLY_MODE.xml >> $WILDFLY_SERVICE_CONF
    echo WILDFLY_MODE=$WILDFLY_MODE >> $WILDFLY_SERVICE_CONF
    echo WILDFLY_BIND=0.0.0.0 >> $WILDFLY_SERVICE_CONF
fi

echo "Configuring application server..."
sed -i -e 's,<deployment-scanner path="deployments" relative-to="jboss.server.base.dir" scan-interval="5000",<deployment-scanner path="deployments" relative-to="jboss.server.base.dir" scan-interval="5000" deployment-timeout="'$WILDFLY_STARTUP_TIMEOUT'",g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<inet-address value="${jboss.bind.address:127.0.0.1}"/>,<any-address/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="ajp" port="${jboss.ajp.port:8009}"/>,<socket-binding name="ajp" port="${jboss.ajp.port:28009}"/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="http" port="${jboss.http.port:8080}"/>,<socket-binding name="http" port="${jboss.http.port:28080}"/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="https" port="${jboss.https.port:8443}"/>,<socket-binding name="https" port="${jboss.https.port:28443}"/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="osgi-http" interface="management" port="8090"/>,<socket-binding name="osgi-http" interface="management" port="28090"/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml

[ -x /bin/systemctl ] && systemctl start $WILDFLY_SERVICE || service $WILDFLY_SERVICE start

echo "Done."

Una volta completata tale operazione, apriamo il terminale e ci spostiamo nella cartella dove è stato caricato tale file, che è stato chiamato wildfly-install.sh. Successivamente digitiamo:

bash wildfly-install.sh

L’operazione richiederà qualche minuto, in quanto verranno scaricate diversi pacchetti dalla rete.

Una volta completata la proceduta d’installazione, per verificare se tutto è stato installato correttamente digitiamo i seguenti comandi:

sudo systemctl enable wildfly

sudo systemctl status wildfly


Se tutto è andato bene, dovremmo ottenere una risposta del genere:

Wildfly

Qualora ci fosse qualche scritta in rossa, che è dovuto ad un problema esistente con la versione di Java; per poter sistemare tale situazione dovremmo procedere nel seguente modo. Apriamo il terminale e digitiamo il seguente comando, che permette di aprire un file di configurazione:

nano /opt/wildfly/bin/standalone.sh

Una volta inviato tale comando, comparirà una schermata simile alla seguente:

Wildfly

Per poter sistemare il problema è necessario cancellare le seguenti due righe, presente in tale file:

else
       PREPEND_JAVA_OPTS=“$PREPEND_JAVA_OPTS -server”

Ora premiamo CTRL+X e successivamente Y, per confermare le modifiche e salvarle.

Ora digitando i seguenti i comandi da terminale, dovremmo aver risolto il problema relativo alla Java Virtual Machine:

sudo systemctl enable wildfly

sudo systemctl status wildfly

Ora rimangono ancora due operazioni da fare, che permettono di poter utilizzare correttamente il server Wildfly; la prima operazione è quella di autorizzare altri PC a collegarsi alla pagina di controllo, poter gestire correttamente il server e la seconda riguarda la creazione di credenziali d’accesso al server.

Accesso da esterno alla pagina di controllo

Per poter autorizzare PC ad accedere alla pagina di controllo da remoto, è necessario modificare il file standalone.xml, che si trova nella cartella /opt/wildfly/standalone/configuration/ ; tale file è molto importante, in quanto contiene diverse impostazioni che permettono al server di girare correttamente sul Raspberry PI. Quindi apriamo il terminale e digitiamo il seguente comando:

sudo nano /opt/wildfly/standalone/configuration/standalone.xml

Le righe da modificar sono:

 <interfaces>
        <interface name="management">
            <loopback-address value="${env.OPENSHIFT_WILDFLY_IP}"/>
        </interface>
        <interface name="public">
            <any-address/>
        </interface>

che diventano:

<interfaces>
        <interface name="management">
            <any-address/>
        </interface>
        <interface name="public">
            <any-address/>
        </interface>
</interfaces>

Aggiunta utente

L’ultimo passaggio è la creazione delle credenziali d’accesso per poter accedere alla pagina di controllo del server Wildfly. Esiste uno script molto semplice e guidato, che permette di effettuare tale operazione. Per avviare la procedura è necessario digitare da terminale:

sudo bash /opt/wildfly/bin/add-user.sh

La procedura è guidata,  sarà necessario inserire il nome utente, la password e altre informazioni riguardo al tipo di account.

WIldfly

Ora che abbiamo completato questa procedura, riavviamo il nostro Raspberry PI e apriamo il browser da remoto, digitando l’indirizzo IP del dispositivo e come porta la 9990:

http://$IP_RASPBERRY:9990

Wildfly

Conclusione

L’installazione richiede diverse procedura che permettono di aver un server completamente funzionante anche da remoto. Wildfly è uno strumento molto potente, che permette di sfruttare al massimo le funzionalità di JavaEE per lo sviluppo di progetti non sono IoT. Nei prossimi articoli vedremo un po’ d’esempi di utilizzo di tale tecnologia.

 

long1

Author: ismanettoneblog

Share This Post On