Recherche de site Web

DebPostInstall : Script d'installation postérieure pour serveurs Debian et Ubuntu

Avez-vous déjà configuré un serveur Debian ou Ubuntu fraîchement installé, pour vous retrouver face à une longue liste de tâches essentielles à effectuer après l'installation ? Ne vous inquiétez plus ! Dans ce tutoriel, nous allons vous présenter un script Bash appelé DebPostInstall. Que vous soyez nouveau sur Linux ou un administrateur système expérimenté, le script DebPostInstall peut vous aider à automatiser les tâches essentielles après l'installation sur un serveur minimalement installé Debian ou Ubuntu.

À la fin de ce tutoriel, vous aurez une compréhension solide de la manière d'utiliser le script DebPostInstall pour configurer rapidement et efficacement un serveur basé sur Debian sûr et bien configuré. Commençons !

DebPostInstall : Script Bash post-installation pour Debian et Ubuntu

DebPostInstall est un simple script Bash pour automatiser les tâches importantes après l'installation sur un serveur Debian ou Ubuntu minimal nouvellement installé.

Le script DebPostInstall effectuera les tâches suivantes :

  1. Création d'un nouvel utilisateur avec des privilèges sudo.
  2. Ajout d'une clé SSH publique pour un accès sécurisé.
  3. Désactivation de l'authentification par mot de passe et de la connexion root pour une sécurité renforcée.
  4. Configurer le pare-feu simple (UFW) pour protéger votre serveur.
  5. Création d'un fichier d'échange pour optimiser les performances du système.
  6. Configurer le fuseau horaire et la synchronisation de l'heure pour un chronométrage précis.

Bien sûr, vous pourriez effectuer ces tâches manuellement une par une. Ce n'est pas un problème, mais pourquoi se donner cette peine ? Le script DebPostInstall vous aidera à automatiser ces tâches.

Voici le contenu du script :

#!/usr/bin/env bash
# ------------------------------------------------------------------
# Script Name:   DebPostInstall
# Description:   A Bash Script to automate essential
#                post-installation tasks on Debian and Ubuntu
# Website:       https://gist.github.com/ostechnix
# Version:       1.0
# Usage:         sudo ./debpostinstall.sh
# ------------------------------------------------------------------
# Update the system
echo "Updating the system..."
apt-get update && apt-get full-upgrade -y
apt-get autoremove -y && apt-get autoclean -y
# Install necessary packages
echo "Installing necessary packages..."
apt-get install -y sudo openssh-server ufw systemd-timesyncd vim htop net-tools curl wget git
# Prompt for username
read -p "Enter the username for the new user: " USERNAME
# Check if the user already exists
if id "$USERNAME" &>/dev/null; then
    echo "User $USERNAME already exists. Skipping user creation."
else
    # Prompt for password
    read -s -p "Enter the password for the new user: " PASSWORD
    echo
    read -s -p "Confirm the password for the new user: " PASSWORD_CONFIRM
    echo
    # Check if passwords match
    if [ "$PASSWORD" != "$PASSWORD_CONFIRM" ]; then
        echo "Passwords do not match. Exiting."
        exit 1
    fi
    # Add a new user account with sudo access and set the password
    echo "Adding new user account..."
    useradd -m -s /bin/bash -G sudo $USERNAME
    echo "$USERNAME:$PASSWORD" | chpasswd
fi
# Prompt for public SSH key
read -p "Enter the public SSH key for the new user: " SSH_KEY
# Add a public SSH key for the new user account, avoiding duplicates
echo "Adding public SSH key..."
mkdir -p /home/$USERNAME/.ssh
if ! grep -qFx "$SSH_KEY" /home/$USERNAME/.ssh/authorized_keys; then
    echo "$SSH_KEY" >> /home/$USERNAME/.ssh/authorized_keys
    echo "SSH key added successfully."
else
    echo "SSH key already exists in authorized_keys file."
fi
chmod 700 /home/$USERNAME/.ssh
chmod 600 /home/$USERNAME/.ssh/authorized_keys
chown -R $USERNAME:$USERNAME /home/$USERNAME/.ssh
# Disable password authentication to the server
echo "Disabling password authentication..."
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd
# Deny root login to the server
echo "Denying root login..."
sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config
systemctl restart sshd
# Setup Uncomplicated Firewall (UFW)
echo "Setting up Uncomplicated Firewall (UFW)..."
ufw allow OpenSSH
ufw --force enable
# Create Swap file based on machine's installed memory
echo "Creating Swap file..."
TOTAL_MEM=$(free -m | awk '/^Mem:/{print $2}')
if [ "$TOTAL_MEM" -le 2048 ]; then
    SWAP_SIZE=1024
elif [ "$TOTAL_MEM" -le 8192 ]; then
    SWAP_SIZE=2048
else
    SWAP_SIZE=4096
fi
dd if=/dev/zero of=/swapfile bs=1M count=$SWAP_SIZE
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' | tee -a /etc/fstab
# Setup the timezone for the server (Default value is "Asia/Kolkata")
echo "Setting up timezone..."
read -p "Enter the timezone for the server (default is Asia/Kolkata): " TIMEZONE
TIMEZONE=${TIMEZONE:-"Asia/Kolkata"}
timedatectl set-timezone $TIMEZONE
# Set up time synchronization with systemd-timesyncd
echo "Setting up time synchronization with systemd-timesyncd..."
systemctl enable systemd-timesyncd
systemctl start systemd-timesyncd
echo "Post-installation tasks completed successfully!"

Ce script est en cours de développement. Nous pouvons le mettre à jour avec plus de fonctionnalités de temps en temps. Veuillez revenir pour voir les mises à jour. Il est également gratuit à utiliser, modifier et distribuer. Vous pouvez personnaliser ce script comme vous le souhaitez.

Explication du script

Décomposons le script et voyons ce que fait chaque partie.

1. Shebang (#!/usr/bin/env bash) :

  • Spécifie l'interpréteur de script comme bash.

2. Mettre à jour le système :

  • apt-get update && apt-get full-upgrade -y : Met à jour la liste des paquets et met à niveau tous les paquets installés.

3. Installer les packages nécessaires:

  • apt-get install -y sudo openssh-server ufw systemd-timesyncd vim htop net-tools curl wget git : Installe sudo, openssh-server, ufw (pare-feu simple), systemd-timesyncd, vim, htop, net-tools, curl, wget et git. Vous pouvez ajouter ici d'autres paquets de votre choix.

4. Invite à saisir le nom d'utilisateur:

  • read -p "Entrez le nom d'utilisateur pour le nouvel utilisateur : " USERNAME : Invite l'utilisateur à entrer un nom d'utilisateur.

5. Vérifier si l'utilisateur existe:

  • if id "$USERNAME" &>/dev/null; then ... else ... fi : Vérifie si l'utilisateur existe déjà. Si l'utilisateur existe, il saute la création de l'utilisateur.

6. Invite à saisir le mot de passe:

  • read -s -p "Entrez le mot de passe pour le nouvel utilisateur : " PASSWORD : Invite l'utilisateur à entrer un mot de passe sans l'afficher dans le terminal.
  • read -s -p "Confirmez le mot de passe pour le nouvel utilisateur : " PASSWORD_CONFIRM : Invite l'utilisateur à confirmer le mot de passe.

7. Vérifiez si les mots de passe correspondent:

  • if [ "$PASSWORD" != "$PASSWORD_CONFIRM" ]; then ... fi : Vérifie si les mots de passe saisis correspondent. S'ils ne correspondent pas, le script se termine.

8. Ajouter un nouveau compte utilisateur avec accès Sudo et définir le mot de passe:

  • useradd -m -s /bin/bash -G sudo $USERNAME : Crée un nouvel utilisateur avec un répertoire personnel, /bin/bash comme shell, et ajoute l'utilisateur au groupe sudo.
  • echo "$USERNAME:$PASSWORD" | chpasswd : Définit le mot de passe pour le nouvel utilisateur.

9. Invite à saisir la clé SSH publique:

  • read -p "Entrez la clé SSH publique pour le nouvel utilisateur : " SSH_KEY : Invite l'utilisateur à entrer une clé SSH publique.

10. Ajouter une clé SSH publique pour le nouveau compte utilisateur, en évitant les doublons:

  • mkdir -p /home/$USERNAME/.ssh : Crée le répertoire .ssh s'il n'existe pas.
  • if ! grep -qFx "$SSH_KEY" /home/$USERNAME/.ssh/authorized_keys; then ... fi : Vérifie si la clé SSH existe déjà dans le fichier authorized_keys. Si ce n'est pas le cas, elle ajoute la clé.
  • chmod 700 /home/$USERNAME/.ssh : Définit les permissions du répertoire .ssh sur 700 (lecture, écriture, exécution uniquement pour le propriétaire).
  • chmod 600 /home/$USERNAME/.ssh/authorized_keys : Définit les permissions du fichier authorized_keys à 600 (lecture et écriture uniquement pour le propriétaire).
  • chown -R $USERNAME:$USERNAME /home/$USERNAME/.ssh : Définit le propriétaire et le groupe du répertoire .ssh et de son contenu pour le nouvel utilisateur.

11. Désactiver l'authentification par mot de passe sur le serveur:

  • sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config : Désactive l'authentification par mot de passe dans la configuration SSH.
  • systemctl restart sshd : Redémarre le service SSH pour appliquer les modifications.

12. Refuser la connexion root au serveur:

  • sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config : Désactive la connexion root dans la configuration SSH.
  • systemctl restart sshd : Redémarre le service SSH pour appliquer les modifications.

13. Configurer le pare-feu simple (UFW):

  • ufw allow OpenSSH : Autorise le trafic SSH à travers le pare-feu.
  • ufw --force enable : Active le pare-feu.

14. Créer un fichier d'échange basé sur la mémoire installée de la machine:

  • TOTAL_MEM=$ (free -m | awk '/^Mem:/{print $2}/') : Obtient la mémoire totale installée.
  • if [ "$TOTAL_MEM" -le 2048 ]; then ... elif [ "$TOTAL_MEM" -le 8192 ]; then ... else ... fi : Détermine la taille du fichier d'échange en fonction de la mémoire installée.
  • dd if=/dev/zero of=/swapfile bs=1M count=$SWAP_SIZE : Crée le fichier d'échange.
  • chmod 600 /swapfile : Définit les permissions du fichier d'échange à 600.
  • mkswap /swapfile : Initialise le fichier d'échange.
  • swapon /swapfile : Active le fichier d’échange.
  • echo '/swapfile none swap sw 0 0' | tee -a /etc/fstab : Ajoute le fichier d'échange à /etc/fstab pour le rendre persistant lors des redémarrages.

15. Configurez le fuseau horaire du serveur (la valeur par défaut est "Asia/Kolkata"):

  • read -p "Entrez le fuseau horaire pour le serveur (par défaut : Asia/Kolkata) : " TIMEZONE : Invite l'utilisateur à saisir un fuseau horaire.
  • TIMEZONE=$ {TIMEZONE:-"Asia/Kolkata"} : Définit le fuseau horaire par défaut sur « Asia/Kolkata » si aucun fuseau horaire n'est fourni.
  • timedatectl set-timezone $TIMEZONE : Définit le fuseau horaire du système.

16. Configurer la synchronisation de l'heure avec systemd-timesyncd:

  • systemctl enable systemd-timesyncd : Active systemd-timesyncd pour qu'il démarre au démarrage.
  • systemctl start systemd-timesyncd : Démarre systemd-timesyncd.

17. Message de fin:

  • echo "Tâches post-installation terminées avec succès !" : Affiche un message indiquant que les tâches post-installation sont terminées.

En comprenant chaque partie du script, vous pouvez voir comment il automatise la configuration d'un nouvel utilisateur, la configuration SSH, le pare-feu, le fichier d'échange, le fuseau horaire et la synchronisation de l'heure sur un système basé sur Debian.

Automatiser les tâches essentielles après l'installation sur Debian ou Ubuntu en utilisant le script DebPostInstall

Avant d'utiliser ce script, vous devez créer une clé SSH sur votre machine locale. Pour ce faire, exécutez :

ssh-keygen -t ed25519 -a 200 -C "mail@example.com" -f ~/.ssh/id_ed25519

Remplacez l'adresse mail par la vôtre.

Une fois la clé générée, exécutez la commande suivante pour afficher le contenu du fichier de clé publique :

cat ~/.ssh/id_ed25519.pub

Sélectionnez et copiez la clé affichée. Vous en aurez besoin plus tard.

Ensuite, connectez-vous à votre serveur Debian ou Ubuntu.

Copiez le contenu du script DebPostInstall et enregistrez-le dans un fichier nommé debpostinstall.sh (ou tout autre nom de votre choix) et rendez-le exécutable :

chmod +x debpostinstall.sh

Ensuite, vous pouvez exécuter le script en utilisant la commande :

sudo ./debpostinstall.sh

Le script commencera à effectuer les tâches post-installation sur votre système basé sur Debian. Gardez un œil sur l'écran.

Lorsque cela vous demande de saisir le nom d'utilisateur, veuillez le faire.

Enter the username for the new user:

Ensuite, saisissez la phrase-clé que vous avez copiée précédemment depuis votre machine locale.

Enter the public SSH key for the new user:

Entrez votre fuseau horaire. La valeur par défaut est Asia/Kolkata.

Enter the timezone for the server (default is Asia/Kolkata):

C'est tout. Le script fera le reste. Asseyez-vous et détendez-vous !

Une fois le script terminé, REDÉMARREZ votre système.

Vérifier les étapes post-installation

Pour vérifier si le script fonctionne correctement, vous pouvez effectuer plusieurs contrôles pour vous assurer que chaque tâche a été accomplie avec succès.

Connectez-vous à votre serveur Debian/Ubuntu et effectuez les tâches suivantes une par une.

1. Vérifier la création d'un nouvel utilisateur

getent passwd $USERNAME

Cette commande devrait retourner les détails de l'utilisateur nouvellement créé.

2. Vérifier l'accès Sudo:

groups $USERNAME

Cette commande devrait montrer que l'utilisateur est membre du groupe sudo.

3. Vérifier la configuration de la clé SSH

ls -ld ~/.ssh/
ls -l ~/.ssh/authorized_keys

Assurez-vous que le répertoire .ssh et le fichier authorized_keys ont les permissions correctes (700 pour le répertoire et 600 pour le fichier).

4. Vérifiez que l'authentification par mot de passe est désactivée

grep "PasswordAuthentication no" /etc/ssh/sshd_config

Cette commande devrait renvoyer la ligne indiquant que l'authentification par mot de passe est désactivée.

5. Vérifiez que la connexion root est désactivée

grep "PermitRootLogin no" /etc/ssh/sshd_config

Cette commande devrait renvoyer la ligne indiquant que la connexion root est désactivée.

6. Vérifier la configuration de UFW

sudo ufw status

Cette commande devrait montrer que le pare-feu est actif et que SSH est autorisé.

7. Vérifier la création du fichier d'échange

sudo swapon --show

Cette commande devrait lister le fichier d'échange créé par le script.

8. Vérifiez /etc/fstab :

grep "/swapfile" /etc/fstab

Cette commande devrait renvoyer la ligne indiquant que le fichier d'échange est configuré pour être monté au démarrage.

9. Vérifier la configuration du fuseau horaire

timedatectl | grep "Time zone"

Cette commande devrait afficher le fuseau horaire correct défini par le script.

10. Vérifier la synchronisation de l'heure avec systemd-timesyncd

sudo systemctl status systemd-timesyncd

Cette commande devrait montrer que le service est actif et en cours d'exécution.

11. Vérifier la synchronisation de l'heure:

timedatectl status | grep "System clock synchronized"
timedatectl status | grep "NTP service"

Ces commandes devraient afficher « oui » et « actif » respectivement.

Sinon, vous pourriez simplement exécuter la commande suivante :

timedatectl

Cela affichera les détails de la date et de l'heure du système ainsi que les détails de la synchronisation de l'heure.

En exécutant ces commandes, vous pouvez vérifier que chaque étape du script a été exécutée correctement et que le système est configuré comme prévu.

Si l'une de ces vérifications échoue, vous devrez peut-être revoir le script et la configuration du système pour identifier et résoudre tout problème.

Conclusion

Félicitations ! Vous avez configuré avec succès votre serveur Debian en utilisant le script DebPostInstall. Grâce à ce script, vous avez automatisé plusieurs tâches critiques après l'installation, garantissant que votre serveur est sécurisé et prêt à l'emploi.

Le script DebPostInstall est un outil utile qui peut vous faire gagner du temps et des efforts lors de la configuration de nouveaux serveurs. N'hésitez pas à personnaliser le script pour mieux répondre à vos besoins et à votre environnement spécifiques.

Si vous avez des questions ou avez besoin d'une assistance supplémentaire, n'hésitez pas à nous contacter.

Lecture Connexe:

  • Configuration du serveur Debian 12 : étapes essentielles après l'installation