Recherche de site Web

Configurer et installer un serveur d'applications sur Ubuntu 24.04

Introduction

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

Ce tutoriel vous guide à travers la configuration d'un serveur d'application prêt pour la production sur un Droplet Linux-Console.net exécutant Ubuntu 24.04. Vous apprendrez à installer et configurer les composants essentiels, à configurer 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

  • Configurez un serveur d'application prêt pour la production sur Ubuntu 24.04 en utilisant un Droplet Linux-Console.net.
  • Configurer Nginx en tant que proxy inverse pour gérer les requêtes entrantes et acheminer 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 fiable des processus.
  • Appliquez 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 les éléments suivants :

  • Un Droplet Linux-Console.net exécutant Ubuntu 24.04. Si vous devez en créer un, suivez notre guide sur la configuration initiale d'un serveur sous 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 pointait 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 par mettre à niveau les paquets existants pour vous assurer de disposer des derniers correctifs de sécurité et des versions logicielles les plus récentes :

sudo apt update
sudo apt upgrade -y

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

É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 transférant à votre serveur d'application. Cette configuration offre plusieurs avantages : la terminaison SSL, les capacités d'équilibrage de charge et une sécurité améliorée en maintenant votre serveur d'application derrière le proxy.

Installez 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 autoriser 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 permettant 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 de 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 qui peuvent être renouvelés automatiquement.

Installez Certbot et le plugin 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 e-mail et vous questionnera sur le fait de rediriger le trafic HTTP vers HTTPS. Choisissez de rediriger pour une meilleure sécurité. Le certificat sera automatiquement renouvelé avant son expiration.

Testez 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 — Configurer Nginx en tant que proxy inverse

Créez une configuration de bloc serveur Nginx pour acheminer 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
  • Interrompt SSL au niveau de Nginx
  • Transmet les requêtes à votre application exécutée sur le port 3000 (à ajuster si nécessaire)
  • Prévient la conservation des adresses IP des clients et des informations de protocole

Activez la configuration en créant un lien symbolique :

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

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

sudo nginx -t

Si le test réussit, 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 afin d'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 d'environnement virtuel :

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 PHP-FPM

Pour les applications PHP, installez PHP et PHP-FPM (Gestionnaire de processus FastCGI) :

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

Vérifiez que PHP-FPM est en cours d'exécution :

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 garantissant qu'elle démarre automatiquement au démarrage et qu'elle 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éez 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 si nécessaire :

[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é
  • WorkingDirectory : Définit le répertoire de travail de l’application
  • Restart=on-failure : Redémarre automatiquement l'application en cas de plantage
  • RestartSec=10 : Attend 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éployer 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 de renforcement en production

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

Désactiver la connexion root via SSH

Modifiez la configuration SSH :

sudo nano /etc/ssh/sshd_config

Réglez 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 ne consomment 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

Mettez en place une surveillance pour vous alerter 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'application.

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 courants incluent :

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

Erreur 502 Bad Gateway Nginx

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 les certificats SSL ne se renouvellent pas :

  • 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 de :

  • Optimiser le 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 sous 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 traite les requêtes entrantes, exécute le code de l'application et retourne les réponses aux clients.

2. Comment 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 vouliez 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 qu'il reconnaisse le nouveau service :
sudo systemctl daemon-reload
  • Activez le service pour qu'il démarre au démarrage :
sudo systemctl enable my-app
  • Démarrez l'application :
sudo systemctl start my-app

Maintenant, votre application s'exécutera en arrière-plan, redémarrera en cas de panne 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 les ExecStart, User et WorkingDirectory selon les besoins de votre configuration.

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

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

Nginx excelle également dans la gestion du contenu statique et le proxy 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'application 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 paquets logiciels à jour et en appliquant 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 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 séparés pour chaque application, chacun écoutant sur des ports différents (par exemple, 3000, 3001, 8000). Mettez en place des blocs serveur Nginx (hôtes virtuels) pour chaque domaine ou sous-domaine, chaque bloc faisant office 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 puis-je vérifier si mon application fonctionne correctement ?

Vérifiez que votre application fonctionne en consultant l'état du service systemd avec sudo systemctl status your-app. Examinez les journaux de l'application en utilisant sudo journalctl -u your-app -f pour voir les logs 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 consultant les journaux d'accès et d'erreur de Nginx dans /var/log/nginx/access.log et /var/log/nginx/error.log. Surveillez l'utilisation des ressources avec htop ou free -h afin de vous assurer que votre application ne consomme pas de manière excessive le CPU ou la 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, du chiffrement SSL/TLS, de la gestion des services via 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 utilisateur appropriées. Votre serveur d'application est prêt à gérer des charges réelles et peut être mis à l'échelle en fonction de vos besoins.

Pour continuer à apprendre et découvrir des configurations avancées, explorez ces tutoriels connexes sur Linux-Console.net :

  • Comment installer et utiliser Docker sur Ubuntu - Apprenez la conteneurisation pour un déploiement et une gestion des applications plus faciles
  • Comment configurer Nginx en tant que proxy inverse sur Ubuntu - Plongée approfondie dans les configurations avancées de proxy inverse 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 telles que les sauvegardes automatiques, la surveillance et une tarification flexible, les Droplets de Linux-Console.net offrent la base nécessaire pour les déploiements en production.

Merci d'apprendre avec la communauté Linux-Console.net.