Recherche sur le site Web

Installer et configurer un serveur d'applications sur Ubuntu 24.04

Introduction

Configurer et paramétrer un serveur d'applications sur Ubuntu 24.04 est essentiel pour déployer des applications web en environnement de production. Que vous hébergiez des applications Node.js, des services web Python ou des sites basés sur PHP, un serveur d'applications correctement configuré constitue la base pour des déploiements fiables, sécuritaires et évolutifs.

Ce tutoriel vous guide à travers l'installation d'un serveur d'applications prêt pour la production sur un Droplet Linux-Console.net exécutant Ubuntu 24.04. Vous apprendrez à installer et configurer les composants essentiels, à mettre en place un proxy inverse avec Nginx, à sécuriser votre serveur avec des certificats SSL et à déployer des applications en utilisant systemd pour la gestion des processus. La configuration suit les meilleures pratiques de production, garantissant que votre serveur est prêt à gérer des charges de travail réelles.

Points clés

  • Configurer un serveur d'application prêt pour la production sur Ubuntu 24.04 en utilisant un Droplet de Linux-Console.net.
  • Configurez Nginx comme proxy inverse pour gérer les requêtes entrantes et diriger le trafic vers vos applications
  • Implémentez le chiffrement SSL/TLS en utilisant Let’s Encrypt pour des connexions sécurisées.
  • Déployez et gérez des applications en utilisant systemd pour une gestion des processus fiable.
  • Appliquer des mesures de renforcement de la sécurité, y compris la configuration du pare-feu et les permissions des utilisateurs.
  • Prend en charge plusieurs types d’applications, y compris les applications Node.js, Python et PHP.

Prérequis

Avant de commencer, assurez-vous d’avoir ce qui suit :

  • Un Droplet Linux-Console.net fonctionnant sous Ubuntu 24.04. Si vous devez en créer un, suivez notre guide sur la configuration initiale d’un serveur avec Ubuntu, qui inclut la création d’un utilisateur non root avec des privilèges sudo et la configuration d’un pare-feu.
  • Un nom de domaine a été dirigé vers l’adresse IP de votre Droplet. Vous pouvez configurer cela en suivant notre guide sur Comment Configurer un Nom d’Hôte avec Linux-Console.net.
  • Connaissance de base de la ligne de commande Linux et accès SSH à votre serveur.

Étape 1 — Mise à jour des paquets du système

Commencez par mettre à jour l’index des paquets de votre système et à améliorer les paquets existants pour vous assurer que vous disposez des derniers correctifs de sécurité et des dernières versions des logiciels :

sudo apt update
sudo apt upgrade -y

Cela garantit que votre serveur Ubuntu 24.04 dispose des informations sur les paquets les plus récentes et des mises à jour de sécurité. Ubuntu 24.04 inclut des versions de paquets mises à jour par rapport à Ubuntu 22.04, y compris des versions plus récentes de systemd, Nginx et d'autres composants principaux.

Étape 2 — Installer Nginx en tant que proxy inverse

Nginx sert de proxy inverse, gérant les requêtes HTTP et HTTPS entrantes et les transmettant à votre serveur d'application. Cette configuration offre plusieurs avantages : terminaison SSL, capacités d'équilibrage de charge et sécurité améliorée en gardant votre serveur d'application derrière le proxy.

Installer Nginx en utilisant apt :

sudo apt install nginx -y

Après l'installation, démarrez Nginx et configurez-le pour qu'il s'exécute automatiquement au démarrage :

sudo systemctl start nginx
sudo systemctl enable nginx

Vérifiez que Nginx est en cours d'exécution :

sudo systemctl status nginx

Vous devriez voir une sortie indiquant que Nginx est actif et en cours d'exécution.

● nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-12-18 07:03:01 UTC; 32s ago
       Docs: man:nginx(8)
   Main PID: 46284 (nginx)
      Tasks: 3 (limit: 4656)
     Memory: 2.4M (peak: 5.3M)
        CPU: 46ms
     CGroup: /system.slice/nginx.service
             ├─46284 "nginx: master process /usr/sbin/nginx -g daemon on; master_process on;"
             ├─46286 "nginx: worker process"
             └─46287 "nginx: worker process"

Dec 18 07:03:01 Anish-Ubuntu-24 systemd[1]: Starting nginx.service - A high performance web server and a reverse proxy server...
Dec 18 07:03:01 Anish-Ubuntu-24 systemd[1]: Started nginx.service - A high performance web server and a reverse proxy server.

Étape 3 — Configuration du pare-feu

Ubuntu 24.04 utilise UFW (Uncomplicated Firewall) pour la gestion du pare-feu. Configurez-le pour permettre le trafic HTTP, HTTPS et SSH tout en bloquant les autres ports inutiles.

Tout d'abord, assurez-vous que UFW est installé et vérifiez son état :

sudo ufw status

Si UFW n'est pas actif, activez-le et configurez les règles nécessaires :

sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo ufw allow 'Nginx Full'
sudo ufw enable
Rules updated
Rules updated (v6)
Rules updated
Rules updated (v6)
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Le profil Nginx Full permet le trafic HTTP (port 80) et HTTPS (port 443). Vérifiez les règles du pare-feu :

sudo ufw status verbose

Vous devriez voir des règles autorisant le trafic OpenSSH et Nginx Full.

Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
22/tcp (OpenSSH)           ALLOW IN    Anywhere                  
80,443/tcp (Nginx Full)    ALLOW IN    Anywhere                  
22/tcp (OpenSSH (v6))      ALLOW IN    Anywhere (v6)             
80,443/tcp (Nginx Full (v6)) ALLOW IN    Anywhere (v6)

Étape 4 — Configuration du SSL avec Let’s Encrypt

Sécuriser votre serveur d'application avec le chiffrement SSL/TLS est essentiel pour les déploiements en production. Let’s Encrypt fournit des certificats SSL gratuits pouvant être renouvelés automatiquement.

Installez Certbot et le module Nginx :

sudo apt install certbot python3-certbot-nginx -y

Obtenez un certificat SSL pour votre domaine. Remplacez your_domain par le nom réel de votre domaine :

sudo certbot --nginx -d your_domain -d www.your_domain

Certbot vous demandera une adresse courriel et si vous souhaitez rediriger le trafic HTTP vers HTTPS. Choisissez de rediriger pour une meilleure sécurité. Le certificat sera automatiquement renouvelé avant son expiration.

Tester le processus de renouvellement automatique :

sudo certbot renew --dry-run

Si cette commande s'exécute sans erreurs, le renouvellement automatique est configuré correctement.

Étape 5 — Configuration de Nginx comme proxy inverse

Créez une configuration de bloc de serveur Nginx pour rediriger le trafic vers votre serveur d'application. Cet exemple montre une configuration générique que vous pouvez adapter à différents types d'applications.

Créez un nouveau fichier de configuration pour votre domaine :

sudo nano /etc/nginx/sites-available/your_domain

Ajoutez la configuration suivante, en remplaçant your_domain par votre domaine réel et en ajustant l’URL proxy_pass pour correspondre au port de votre application :

server {
    listen 80;
    listen [::]:80;
    server_name your_domain www.your_domain;

    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name your_domain www.your_domain;

    ssl_certificate /etc/letsencrypt/live/your_domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your_domain/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

Cette configuration :

  • Redirige le trafic HTTP vers HTTPS
  • Met fin au SSL au niveau de Nginx
  • Transmet les requêtes à votre application exécutée sur le port 3000 (à ajuster si nécessaire)
  • Conserve les adresses IP des clients et les informations sur le protocole

Activez la configuration en créant un lien symbolique :

sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

Tester la configuration de Nginx pour détecter les erreurs de syntaxe :

sudo nginx -t

Si le test est concluant, rechargez Nginx pour appliquer les modifications :

sudo systemctl reload nginx

Étape 6 — Installation des dépendances d'exécution de l'application

Les dépendances d'exécution dont vous avez besoin dépendent de votre type d'application. Cette section couvre la configuration pour les applications Node.js, Python et PHP.

Installation de Node.js

Pour les applications Node.js, installez Node.js en utilisant le dépôt de NodeSource pour obtenir la dernière version LTS :

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

Vérifiez l'installation :

node --version
npm --version
v20.19.6
10.8.2

Installer Python et pip

Ubuntu 24.04 inclut Python 3.12 par défaut. Installez pip et les outils pour les environnements virtuels :

sudo apt install python3-pip python3-venv -y

Vérifiez l'installation :

python3 --version
pip3 --version
pip3 --version
Python 3.12.3
pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12)

Installation de PHP et de PHP-FPM

Pour les applications PHP, installez PHP et PHP-FPM (FastCGI Process Manager) :

sudo apt install php-fpm php-mysql php-mbstring php-xml php-curl -y

Vérifiez que PHP-FPM fonctionne :

sudo systemctl status php8.3-fpm
 Loaded: loaded (/usr/lib/systemd/system/php8.3-fpm.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-12-18 08:02:36 UTC; 1min 56s ago
       Docs: man:php-fpm8.3(8)
    Process: 59077 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/8.3/fpm/pool.d/www.conf 83 (code=exited, >
   Main PID: 59074 (php-fpm8.3)
     Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec"
      Tasks: 3 (limit: 4656)
     Memory: 9.5M (peak: 10.4M)
        CPU: 97ms
     CGroup: /system.slice/php8.3-fpm.service
             ├─59074 "php-fpm: master process (/etc/php/8.3/fpm/php-fpm.conf)"
             ├─59075 "php-fpm: pool www"
             └─59076 "php-fpm: pool www"

Dec 18 08:02:36 Anish-Ubuntu-24 systemd[1]: Starting php8.3-fpm.service - The PHP 8.3 FastCGI Process Manager...

<$> Remarque : Ubuntu 24.04 inclut PHP 8.3. Ajustez les numéros de version si votre système utilise une version différente. <$>

Étape 7 — Création d'un service Systemd pour votre application

Systemd gère votre application en tant que service, en s'assurant qu'elle démarre automatiquement au démarrage et redémarre en cas de plantage. Cet exemple crée un service systemd pour une application Node.js, mais vous pouvez l'adapter à d'autres types d'applications.

Créer un fichier de service systemd :

sudo nano /etc/systemd/system/your-app.service

Ajoutez la configuration suivante, en ajustant les chemins et les variables d’environnement au besoin :

[Unit]
Description=Your Application Server
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/your-app
Environment="NODE_ENV=production"
Environment="PORT=3000"
ExecStart=/usr/bin/node /var/www/your-app/server.js
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Points clés de configuration :

  • Type=simple : Pour les applications qui s'exécutent au premier plan
  • User=www-data : Exécute l'application en tant qu'utilisateur non-root pour des raisons de sécurité
  • RépertoireDeTravail : Définit le répertoire de travail de l’application
  • Restart=on-failure : Redémarre automatiquement l'application si elle plante
  • RestartSec=10 : Attendre 10 secondes avant de redémarrer

Rechargez systemd et démarrez votre service :

sudo systemctl daemon-reload
sudo systemctl start your-app
sudo systemctl enable your-app

Vérifiez l'état du service :

sudo systemctl status your-app
● your-app.service
     Loaded: loaded (/etc/systemd/system/your-app.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-12-18 08:07:30 UTC; 4ms ago
   Main PID: 59408 ((node))
      Tasks: 1 (limit: 4656)
     Memory: 512.0K (peak: 512.0K)
        CPU: 936us
     CGroup: /system.slice/your-app.service
             └─59408 "(node)"

Dec 18 08:07:30 Anish-Ubuntu-24 systemd[1]: your-app.service: Scheduled restart job, restart counter is at 4.
Dec 18 08:07:30 Anish-Ubuntu-24 systemd[1]: Started your-app.service.

Exemple d'application Python

Pour une application Python utilisant Gunicorn, votre service systemd pourrait ressembler à ceci :

[Unit]
Description=Your Python Application
After=network.target

[Service]
Type=notify
User=www-data
WorkingDirectory=/var/www/your-app
Environment="PATH=/var/www/your-app/venv/bin"
ExecStart=/var/www/your-app/venv/bin/gunicorn --bind 127.0.0.1:8000 app:app
Restart=on-failure

[Install]
WantedBy=multi-user.target

Exemple d'application PHP

Pour les applications PHP, vous utilisez généralement PHP-FPM avec Nginx. Configurez Nginx pour transmettre les requêtes à PHP-FPM :

location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/var/run/php/php8.3-fpm.sock;
}

Étape 8 — Déploiement de votre application

Créez un répertoire pour votre application et définissez les permissions appropriées :

sudo mkdir -p /var/www/your-app
sudo chown -R www-data:www-data /var/www/your-app

Déployez vos fichiers d'application dans ce répertoire. Vous pouvez utiliser Git, SCP ou d'autres méthodes de déploiement :

cd /var/www/your-app
sudo -u www-data git clone https://github.com/your-username/your-repo.git .

Installez les dépendances et construisez votre application selon vos besoins. Pour Node.js :

sudo -u www-data npm install --production

Pour Python :

sudo -u www-data python3 -m venv venv
sudo -u www-data ./venv/bin/pip install -r requirements.txt

Après le déploiement, redémarrez votre service d'application :

sudo systemctl restart your-app

Étape 9 — Bonnes pratiques pour la consolidation en production

Appliquez ces mesures de sécurité pour renforcer votre serveur d'application en vue d'une utilisation en production.

Désactiver la connexion root via SSH

Modifiez la configuration SSH :

sudo nano /etc/ssh/sshd_config

Définissez ce qui suit :

PermitRootLogin no
PasswordAuthentication no

Redémarrer SSH :

sudo systemctl restart sshd

Configurer les mises à jour de sécurité automatiques

Activer les mises à jour de sécurité automatiques :

sudo apt install unattended-upgrades -y
sudo dpkg-reconfigure -plow unattended-upgrades

Configurer la rotation des journaux

Configurez la rotation des journaux pour éviter que les fichiers journaux n'occupent tout l'espace disque. Modifiez la configuration de logrotate :

sudo nano /etc/logrotate.d/your-app

Ajouter :

/var/www/your-app/logs/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data www-data
    sharedscripts
}

Surveiller l'espace disque

Configurez la surveillance pour être averti lorsque l'espace disque est faible. Installez et configurez des outils de surveillance :

sudo apt install htop iotop -y

Étape 10 — Dépannage des problèmes courants

Cette section traite des problèmes courants que vous pourriez rencontrer lors de la configuration de votre serveur d'applications.

L'application ne démarre pas

Vérifiez l'état du service et les journaux :

sudo systemctl status your-app
sudo journalctl -u your-app -n 50 --no-pager

Les problèmes fréquents incluent :

  • Chemins de fichiers incorrects dans le fichier de service systemd
  • Variables d'environnement manquantes
  • Erreurs d'autorisation (assurez-vous que l'utilisateur du service peut accéder aux fichiers de l'application)

Erreur Nginx 502 Bad Gateway

Cela signifie généralement que Nginx ne peut pas se connecter à votre application. Vérifiez :

  • Votre application est en cours d'exécution :
sudo systemctl status your-app
  • L'application écoute sur le bon port :
sudo netstat -tlnp | grep 3000
  • L'URL proxy_pass dans votre configuration Nginx correspond au port de votre application.

Problèmes de certificat SSL

Si le renouvellement des certificats SSL échoue :

  • Vérifiez les journaux de Certbot :
sudo tail -f /var/log/letsencrypt/letsencrypt.log
  • Vérifiez que les enregistrements DNS de votre domaine pointent vers votre serveur :
dig your_domain
  • Assurez-vous que les ports 80 et 443 sont ouverts dans votre pare-feu.

Utilisation élevée de la mémoire

Surveiller l'utilisation de la mémoire :

free -h
htop

Si votre application consomme trop de mémoire, envisagez :

  • Optimisation du code de votre application
  • Augmenter la RAM de votre Droplet
  • Mise en œuvre de la mise en cache au niveau de l'application

Questions fréquemment posées

1. Qu'est-ce qu'un serveur d'applications dans Ubuntu ?

Un serveur d'applications est un environnement serveur qui exécute et gère des applications web. Sur Ubuntu 24.04, cela implique généralement de configurer un environnement d'exécution (comme Node.js, Python ou PHP), de mettre en place un proxy inverse (comme Nginx) et d'utiliser systemd pour gérer les processus de l'application. Le serveur d'applications gère les requêtes entrantes, exécute le code de l'application et renvoie les réponses aux clients.

2. Comment puis-je configurer systemd pour mon application ?

Pour configurer systemd pour votre application, vous devrez créer un fichier de service. Voici un exemple étape par étape :

Supposons que votre application soit une application Node.js située à /home/ubuntu/my-app, et que vous souhaitez l'exécuter avec npm start en utilisant l'utilisateur ubuntu.

  • Créez le fichier de service systemd :
sudo nano /etc/systemd/system/my-app.service
  • Ajoutez le contenu suivant au fichier :
[Unit]
Description=My Node.js App
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/my-app
ExecStart=/usr/bin/npm start
Restart=on-failure
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target
  • Rechargez systemd pour reconnaître le nouveau service :
sudo systemctl daemon-reload
  • Activez le service pour qu'il démarre au démarrage :
sudo systemctl enable my-app
  • Lancer l'application :
sudo systemctl start my-app

Maintenant, votre application s'exécutera en arrière-plan, redémarrera en cas d'échec et démarrera automatiquement au démarrage. Vous pouvez vérifier son état avec :

sudo systemctl status my-app

Cette méthode fonctionne avec la plupart des applications. Il suffit d'ajuster ExecStart, User et WorkingDirectory selon les besoins de votre pile.

3. Devrais-je utiliser Nginx ou Apache pour mon proxy inverse ?

Nginx et Apache fonctionnent bien en tant que serveurs proxy inverses, mais Nginx est souvent préféré pour les serveurs d'applications modernes en raison de son empreinte mémoire plus faible, de ses meilleures performances sous forte concurrence et de sa configuration plus simple pour les scénarios de proxy inverse.

Nginx est également excellent pour gérer le contenu statique et faire le relais des requêtes vers les serveurs d'applications, ce qui le rend idéal pour les déploiements en production. Apache reste un choix solide, surtout si vous avez besoin de modules spécifiques ou si vous êtes plus à l'aise avec sa syntaxe de configuration.

4. Comment sécuriser mon serveur d'applications sur Ubuntu 24.04 ?

Sécurisez votre serveur d'application en : activant le pare-feu UFW et en n'autorisant que les ports nécessaires, en installant des certificats SSL avec Let’s Encrypt, en exécutant les applications en tant qu'utilisateurs non root, en désactivant la connexion SSH root, en configurant les mises à jour de sécurité automatiques, en maintenant les packages logiciels à jour et en mettant en place des permissions de fichiers appropriées. De plus, utilisez des mots de passe forts ou des clés SSH, configurez fail2ban pour prévenir les attaques par force brute et examinez régulièrement les journaux d'application et du système pour détecter toute activité suspecte.

5. Puis-je héberger plusieurs applications sur un seul serveur Ubuntu ?

Oui, vous pouvez héberger plusieurs applications sur un seul serveur Ubuntu 24.04. Configurez des services systemd distincts pour chaque application, chacun écoutant sur des ports différents (par exemple, 3000, 3001, 8000). Configurez des blocs de serveur Nginx (hôtes virtuels) pour chaque domaine ou sous-domaine, chaque bloc servant de proxy vers le port de l'application appropriée. Cette approche vous permet d'utiliser efficacement les ressources du serveur tout en maintenant l'isolation entre les applications.

6. Comment vérifier si mon application fonctionne correctement ?

Vérifiez que votre application fonctionne en vérifiant le statut du service systemd avec sudo systemctl status your-app. Consultez les journaux de l'application en utilisant sudo journalctl -u your-app -f pour voir les sorties en temps réel. Testez l'application en y accédant via votre domaine ou votre adresse IP. Vérifiez que Nginx redirige correctement les requêtes en examinant les journaux d'accès et d'erreurs de Nginx dans /var/log/nginx/access.log et /var/log/nginx/error.log. Surveillez l'utilisation des ressources avec htop ou free -h pour vous assurer que votre application ne consomme pas excessivement de CPU ou de mémoire.

Conclusion

Vous avez configuré avec succès un serveur d'application prêt pour la production sur Ubuntu 24.04. Votre Droplet Linux-Console.net est désormais équipé de Nginx en tant que proxy inverse, de l'encodage SSL/TLS, de la gestion des services systemd et de mesures de renforcement de la sécurité. Cette configuration permet de déployer des applications web Node.js, Python, PHP et autres dans un environnement sécurisé et évolutif.

La configuration suit les meilleures pratiques de production, y compris les redémarrages automatiques des services, le renouvellement des certificats SSL, la protection par pare-feu et les permissions appropriées pour les utilisateurs. Votre serveur d'application est prêt à gérer des charges de travail réelles et peut être mis à l'échelle à mesure que vos besoins augmentent.

Pour approfondir vos connaissances et explorer des configurations avancées, consultez ces tutoriels liés sur Linux-Console.net :

  • Comment installer et utiliser Docker sur Ubuntu - Apprenez la conteneurisation pour faciliter le déploiement et la gestion des applications
  • Comment configurer Nginx en tant que proxy inversé sur Ubuntu - Approfondissement des configurations avancées de proxy inversé Nginx
  • Mesures de sécurité recommandées pour protéger vos serveurs - Techniques supplémentaires de renforcement de la sécurité pour les serveurs de production

Prêt à déployer vos applications ? Commencez avec les Droplets de Linux-Console.net pour créer une infrastructure évolutive et fiable pour votre serveur d'applications. Avec des fonctionnalités comme les sauvegardes automatisées, la surveillance et des tarifs flexibles, les Droplets de Linux-Console.net offrent la base dont vous avez besoin pour des déploiements en production.

Merci de apprendre avec la communauté Linux-Console.net.