Gestion Manuelle des Processus Java

Avant d'automatiser le déploiement, il est utile de comprandre les commandes natives pour interagir avec les applications Java sur un système Linux.

Lancement d'une application :

nohup java -jar mon-application.jar > /dev/null 2>&1 &

Identification du PID :

# Utilisation de jps (inclus dans le JDK)
jps -l

# Ou utilisation de pgrep
pgrep -f mon-application.jar

Arrêt du processus :

# Arrêt propre
kill $(pgrep -f mon-application.jar)

# Arrêt forcé si nécessaire
kill -9 $(pgrep -f mon-application.jar)

Bien que ces commandes soient fonctionnelles, leur exécution répétitive est fastidieuse. L'utilisation d'un script d'initialisation permet de standardiser et de simplifier ces opérations.

Automatisation via un Script Shell

Le script ci-dessous encapsule la logique de démarrage, d'arrêt, de redémarrage et de vérification de l'état d'un service Java. Il gère également les paramètres de la JVM et la redirection des journaux.

Créez un fichier nommé service-manager.sh et accordez-lui les permissions d'exécution (chmod +x service-manager.sh).

#!/bin/bash
# Script de gestion du cycle de vie d'une application Java

# --- Configuration du Service ---
SERVICE_NAME="api-backend"
APP_PORT=8080
DEPLOY_DIR="/opt/java-apps"
ARTIFACT_NAME="backend-service-1.0.0.jar"
PID_FILE="${DEPLOY_DIR}/${ARTIFACT_NAME}.pid"
LOG_DIR="${DEPLOY_DIR}/logs"

# Paramètres de la JVM
JVM_ARGS="-Xms256m -Xmx512m -XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8"

# --- Fonctions Utilitaires ---

# Vérifie si le processus est actif
check_status() {
    if [[ -f "$PID_FILE" ]]; then
        CURRENT_PID=$(cat "$PID_FILE")
        if ps -p "$CURRENT_PID" > /dev/null 2>&1; then
            return 0 # En cours d'exécution
        fi
    fi
    return 1 # Arrêté
}

# Démarrage du service
do_start() {
    check_status
    if [[ $? -eq 0 ]]; then
        echo "Le service $SERVICE_NAME est déjà actif (PID: $CURRENT_PID)."
        return
    fi

    mkdir -p "$LOG_DIR/gc"
    echo "Démarrage de $SERVICE_NAME..."
    
    nohup java $JVM_ARGS \
        -Xlog:gc*:file="$LOG_DIR/gc/gc.log":time,uptime,level,tags:filecount=5,filesize=10M \
        -jar "${DEPLOY_DIR}/${ARTIFACT_NAME}" \
        > "${LOG_DIR}/application.log" 2>&1 &
        
    echo $! > "$PID_FILE"
    echo "Service $SERVICE_NAME démarré avec succès (PID: $!)."
}

# Arrêt du service
do_stop() {
    check_status
    if [[ $? -ne 0 ]]; then
        echo "Le service $SERVICE_NAME n'est pas en cours d'exécution."
        return
    fi

    echo "Arrêt du service $SERVICE_NAME (PID: $CURRENT_PID)..."
    kill "$CURRENT_PID"
    
    # Attente de l'arrêt gracieux
    for i in {1..10}; do
        if ! ps -p "$CURRENT_PID" > /dev/null 2>&1; then
            break
        fi
        sleep 1
    done

    # Forcer l'arrêt si le processus résiste
    if ps -p "$CURRENT_PID" > /dev/null 2>&1; then
        echo "Arrêt forcé du processus..."
        kill -9 "$CURRENT_PID"
    fi

    rm -f "$PID_FILE"
    echo "Service $SERVICE_NAME arrêté."
}

# Redémarrage du service
do_restart() {
    do_stop
    sleep 2
    do_start
}

# Affichage de l'état
do_status() {
    check_status
    if [[ $? -eq 0 ]]; then
        echo "$SERVICE_NAME est en cours d'exécution (PID: $CURRENT_PID)."
    else
        echo "$SERVICE_NAME est arrêté."
    fi
}

# Menu d'aide
show_usage() {
    echo "Usage: $0 {start|stop|restart|status}"
    exit 1
}

# --- Exécution ---
case "$1" in
    start)   do_start ;;
    stop)    do_stop ;;
    restart) do_restart ;;
    status)  do_status ;;
    *)       show_usage ;;
esac
exit 0

Note sur les répertoires : Ce script génère des fichiers de journaux dans le dossier défini par LOG_DIR. Assurez-vous que l'utilisateur exécutant le script dispose des droits d'écriture sur ce répertoire.

Utilisation du Script

Une fois le script configuré, vous pouvez contrôler l'application via les commandes suivantes :

• Démarrer : ./service-manager.sh start
• Arrêter : ./service-manager.sh stop
• Redémarrer : ./service-manager.sh restart
• Vérifier l'état : ./service-manager.sh status

Optimisation du Temps de Démarrage de la JVM

Si le démarrage de votre application Java semble anormalement lent sous Linux, cela est souvent dû à une résolution DNS bloquante lors de l'initialisation de la machine virtuelle, en particulier avec la génération d'entropie pour SecureRandom.

Pour résoudre ce problème, mappez le nom d'hôte de votre serveur à l'adresse de bouclage local dans le fichier /etc/hosts.

1. Identifiez le nom d'hôte actuel :

hostname

2. Modifiez le fichier de configuration :

sudo nano /etc/hosts

3. Ajoutez la ligne suivante (en remplaçant par votre nom d'hôte réel) :

127.0.0.1   localhost mon-serveur-local

Cet ajustement permet à la JVM de résoudre instantanément le nom de la machine, réduisant ainsi considérablement le temps d'initialisation.