Guide essentiel pour l'administration des distributions Linux

Publié le : 01/03/24
Modifié le : 27/11/24 à 11h55

emoji_objects

Ce document est une ressource informative, mais il est sage de consulter différentes sources pour confirmer les informations fournies, car des erreurs peuvent toujours se glisser.

UBUNTU


Configuration Réseau


Le but de cette partie est de configurer une adresse IP statique, et de configurer les serveurs DNS.

Configuration moderne
Autre méthode
1-Identifier l'interface réseau

Avant de commencer on doit identifier notre interface réseau. Pour ce faire il existe plusieurs commandes système :

  • ip addr
  • ip a (simplificiation de addr)
  • ip route show
                                            
                                            ubuntu@sys:~$ ip addr
                                                1: lo: 
                                                2: eth0@if948: 
                                            
                                            

Notre interface réseau est donc eth0

2-Localiser le fichier de configuration Netplan

Ensuite, je cherche les fichiers de configuration de Netplan dans le répertoire /etc/netplan/. Par défaut, Ubuntu crée un fichier YAML pour la configuration réseau. La commande suivante me permet de voir les fichiers disponibles :

                                            
                                            ubuntu@sys:~$ ls /etc/netplan
                                                10-lxc.yaml
                                            
                                            
3-Modifier le fichier de configuration Netplan

Dans le fichier de configuration, je configure l'interface réseau avec une adresse IP statique et spécifie les serveurs DNS de Google. Voici un exemple de configuration pour l'interface eth0 :

                                            
                                            network:
                                                version: 2
                                                renderer: networkd
            
                                                ethernets:
                                                    eth0:
                                                        dhcp4: no
                                                        addresses: [x.x.x.x/X]
                                                        routes:
                                                          - to: 0.0.0.0/0
                                                            via: x.x.x.x
            
                                                        nameservers:
                                                            addresses: [8.8.8.8, 8.8.4.4]
                                            
                                            
content_copy
4-Appliquer la configuration réseau

Après avoir enregistré mes modifications dans le fichier de configuration, on applique les changements avec la commande suivante :

                                            
                                            sudo netplan apply
                                            
                                            
content_copy
Autre manière de faire la configuration réseau

On peut configurer une adresse IP statique et les serveurs DNS en ligne de commande de manière persistante sans modifier directement le fichier de configuration.

Configurer l'adresse IP statique pour l'interface réseau eth0 :
                                            
                                            sudo ip address add x.x.x.x/x dev <interface>
                                            
                                            
content_copy
Définir la passerelle par défaut :
                                            
                                            sudo ip route add default via x.x.x.x
                                            
                                            
content_copy
Configurer les DNS :

On Configure les serveurs DNS en ajoutant les adresses IP des serveurs DNS à notre fichier de configuration /etc/resolv.conf.

                                            
                                            sudo bash -c 'echo "nameserver 8.8.8.8" >> /etc/resolv.conf'
                                            sudo bash -c 'echo "nameserver 8.8.4.4" >> /etc/resolv.conf'
                                            
                                            
content_copy

Ou sinon on peut modifier manuellement le fichier :

                                            
                                            sudo vim /etc/resolv.conf
                                                nameserver <adresse_ip_dns_1>
                                                nameserver <adresse_ip_dns_2>
                                            
                                            
Vérifier la configuration réseau

On vérifie que la configuration est appliquée correctement en utilisant la commande suivante :

                                
                                ip addr show <interface>
                                
                                
content_copy

Pour vérifier le bon fonctionnement on commence par ping notre gateway, ainsi que le site de google par exemple.

Commandes

1. Ajouter un utilisateur

Je peux créer un nouvel utilisateur en utilisant la commande adduser.

                                
                                sudo adduser mahmoud
                                    Adding user `mahmoud' ...
                                    Adding new group `mahmoud' (1002) ...
                                    Adding new user `mahmoud' (1002) with group `mahmoud' ...
                                    Creating home directory `/home/mahmoud' ...
                                    Copying files from `/etc/skel' ...
                                    New password:
                                    Retype new password:
                                    passwd: password updated successfully
                                    Changing the user information for mahmoud
                                    Enter the new value, or press ENTER for the default
                                            Full Name []:
                                            Room Number []:
                                            Work Phone []:
                                            Home Phone []:
                                            Other []:
                                    Is the information correct? [Y/n] Y
                                
                                
2. Configuration de sudo pour le nouveau utilisateur

Sur Ubuntu, les utilisateurs qui doivent exécuter des commandes en tant que root sont généralement ajoutés au groupe sudo. Pour ajouter mahmoud à ce groupe, j'utilise la commande suivante :

                                
                                sudo usermod -aG sudo <nom_utilisateur>
                                
                                
content_copy
3. Lister les utilisateurs
                                
                                cat /etc/passwd
                                
                                
content_copy
4. Configurer vim comme éditeur par défaut
                                
                                echo "export EDITOR=vim" >> ~/.bashrc
                                source ~/.bashrc
                                
                                

Ou si je souhaite utilser vim pour une opération particulière :

                                
                                sudo EDITOR=vim visudo
                                
                                
content_copy
5. Autoriser un utilisateur de redémarrer la machine

Je peux spécifiquement autoriser mahmoud à redémarrer la machine sans saisir de mot de passe en éditant le fichier sudoers.

                                
                                sudo EDITOR=vim visudo
                                // J'ajoute la ligne
                                mahmoud ALL=NOPASSWD: /sbin/reboot, /bin/systemctl reboot, /bin/systemctl poweroff
                                
                                

Maintenant je peux reboot sans mot de passe :

                                
                                su - mahmoud
                                sudo /sbin/reboot
                                
                                

Serveur SSH


Installation du paquet SSH
                                
                                sudo apt install openssh-server
                                
                                
content_copy
Démarrage du service SSH
Démmarer le service SSH
Vérifier l'état
Démmarer le service
                                                
                                                sudo systemctl start ssh
                                                
                                                
content_copy
Rendu
                                                
                                                sudo systemctl status ssh
                                                
                                                
content_copy
                                                
                                                ● ssh.service - OpenBSD Secure Shell server
                                                    Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enab
                                                    Active: active (running) since Thu 2024-03-07 12:37:30 CET; 2min 46s ago
                                                    Main PID: 582 (sshd)
                                                    Tasks: 1 (limit: 514)
                                                    CGroup: /system.slice/ssh.service
                                                            └─582 /usr/sbin/sshd -D
                                                
                                                
Activation du service SSH au démarrage
                                
                                sudo systemctl enable ssh
                                
                                
content_copy
Configuration du pare-feu (firewalld)

Si on utilise firewalld, on doit ouvrir le port 22 pour autoriser les connexions SSH.

                                
                                sudo ufw allow 22
                                
                                
content_copy
Configuration des connexions SSH avec une clé RSA
Générer une paire de clés RSA
                                
                                ssh-keygen -t rsa -b 4096
                                
                                
content_copy
Copier la clé publique sur le serveur distant
                                
                                ssh-copy-id user@remote_server
                                
                                
content_copy
Configurer le serveur SSH pour autoriser l'authentification par clé
                                
                                sudo echo "PermitRootLogin without-password" >> /etc/ssh/sshd_config
                                
                                
content_copy
Extraire la clé publique depuis la clé privée
Git Bash
WSL/Linux
Windows
Sous Git Bash
                                                
                                                ssh-keygen -y -f ~/.ssh/id_rsa > ~/.ssh/id_rsa.pub
                                                
                                                
content_copy
Sous WSL/Linux
Sous PowerShell ou Cmd
                                                
                                                ssh-keygen -y -f C:\Users\VotreNomUtilisateur\.ssh\id_rsa > C:\Users\VotreNomUtilisateur\.ssh\id_rsa.pub
                                                
                                                
content_copy
Modifier la passphrase d'une clé SSH
                                
                                ssh-keygen -p -f <nom_fihier_cle_prive>
                                
                                
content_copy
Présence de clés
Linux
                                
                                ls ~/.ssh/
                                
                                
content_copy

Windows
                                
                                C:\CHEMIN_VERS\.ssh> cat .\id_rsa.pub
                                
                                
content_copy

Informations sur les disques


Liste des périphériques de blocks

Cette commande affiche la liste des périphériques de blocs (disques et partitions) sur votre système.

                                
                                lsblk
                                
                                
content_copy
L'utilisation de l'espace disque de tous les systèmes

Cette commande montre l'utilisation de l'espace disque de tous les systèmes de fichiers montés.

                                
                                toto@srv:~/df -h
                                    Filesystem                         Size  Used Avail Use% Mounted on
                                    udev                               447M     0  447M   0% /dev
                                    tmpfs                               99M  1.2M   97M   2% /run
                                    /dev/mapper/ubuntu--vg-ubuntu--lv   17G  6.5G  9.5G  41% /
                                    tmpfs                              491M     0  491M   0% /dev/shm
                                    tmpfs                              5.0M     0  5.0M   0% /run/lock
                                    tmpfs                              491M     0  491M   0% /sys/fs/cgroup
                                    /dev/sda2                          976M  207M  703M  23% /boot
                                    /dev/loop0                          56M   56M     0 100% /snap/core18/2812
                                    /dev/loop1                          56M   56M     0 100% /snap/core18/2566
                                    /dev/loop2                          41M   41M     0 100% /snap/snapd/20671
                                    /dev/loop3                          64M   64M     0 100% /snap/core20/2182
                                    /dev/loop4                          64M   64M     0 100% /snap/core20/1623
                                    /dev/loop5                          92M   92M     0 100% /snap/lxd/24061
                                    /dev/loop6                          68M   68M     0 100% /snap/lxd/22753
                                    tmpfs                               99M     0   99M   0% /run/user/1000
                                
                                
Lister les partitions des disques
                                
                                sudo fdisk -l
                                
                                
content_copy
Installer/Supprimer un paquet

Installer un paquet
                                
                                sudo apt-get install LE_NOM_DU_PAQUET
                                
                                
content_copy
Supprimer un paquet
                                
                                sudo apt-get remove LE_NOM_DU_PAQUET
                                
                                
content_copy
Activer une interface réseau

Pour les système Linux qui dispoe de netplan on utilise :

                                
                                sudo ip link set nom_interface up
                                
                                
content_copy

Pour les système Linux un peu anciens qui utilise interfaces :

                                
                                sudo ifup nom_interface
                                
                                
content_copy
Obtenir la version de la distribution
                                
                                lsb_release -a
                                
                                
content_copy
Mettre à jour à une version supérieur d'Ubuntu
                                
                                sudo do-release-upgrade
                                
                                
content_copy
Vider le contenu d'un fichier
                                
                                sudo truncate -s 0 <nom_du_fichier>
                                
                                
content_copy
Ajouter un utilisateur au groupe sudoers
                                
                                sudo usermod -aG sudo <user>
                                
                                
content_copy
Identifier le processus associé à un port spécifique
                                
                                sudo lsof -i :<num_port>
                                
                                
content_copy

                                
                                sudo lsof -i :53
                                    COMMAND    PID            USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
                                    systemd-r  727 systemd-resolve   13u  IPv4  21682      0t0  UDP localhost:domain
                                    systemd-r  727 systemd-resolve   14u  IPv4  21683      0t0  TCP localhost:domain (LISTEN)
                                    dnsmasq   1081 libvirt-dnsmasq    5u  IPv4  22285      0t0  UDP xen:domain
                                    dnsmasq   1081 libvirt-dnsmasq    6u  IPv4  22286      0t0  TCP xen:domain (LISTEN)
                                
                                
Utilisation de wget

Wget est un utilitaire en ligne de commande qui permet de télécharger des fichiers depuis le Web. Il est largement utilisé pour automatiser le processus de téléchargement de fichiers à partir de serveurs Web, que ce soit pour récupérer des fichiers individuels, des sites web entiers, ou même pour effectuer des téléchargements récurrents ou planifiés.
Pour afficher toutes les options disponibles :

                                
                                wget --help
                                
                                
content_copy

                                
                                man wget
                                
                                
content_copy

                                
                                wget --user-agent="Mozilla/5.0" <mon_url_de_telechargement>
                                
                                
content_copy
Recherche d'un fichier/Rep

Pour que la fonction fonctionne, nous devons indiquer le répertoire à partir duquel nous souhaitons commencer la recherche de manière récursive :

                                
                                find <endroit_d_ou_commencer> -name "<nom_fic_rep>"
                                
                                
content_copy
Trier les fichiers par date de modification

Lister les fichiers par date de modification

                                
                                ls -t
                                
                                
content_copy

                                
                                ls -t fic1 fic2 fic3
                                
                                
content_copy
Conserver le plus récent

On peut vouloir supprimer les autres fichiers et conserver uniquement le plus récent :

                                
                                # Supposons que les trois fichiers sont fichier1, fichier2, et fichier3
                                # La commande `ls -t` affichera les fichiers dans l'ordre : plus récent en premier
                                ls -t fichier1 fichier2 fichier3 > tmp_file_list.txt

                                # Lisez le fichier temporaire et extrayez le fichier le plus récent
                                read most_recent_file < tmp_file_list.txt

                                # Supprimez les autres fichiers
                                for file in fichier1 fichier2 fichier3; do
                                    if [ "$file" != "$most_recent_file" ]; then
                                        rm "$file"
                                    fi
                                done
                                exit 0
                                
                                
content_copy
Personnalisations
Message affiché lors de l'invite de connexion

Sous Ubuntu Server, il est possible de personnaliser le message qui s'affiche lors de l'invite de connexion (où l'on entre nos identifiants) en modifiant le fichier /etc/issue.

                                    
                                    sudo vim /etc/issue
                                    
                                    
content_copy

Dans cet exemple on affiche l'Ip de la machine :

                                    
                                    # /etc/issue
                                    IP: \4{eth0}
                                    
                                    
content_copy
Message affiché lors d'une connexion

On peut modifier le message affiché lorsque l'on est connecté à un système Ubuntu Server en modifiant le fichier /etc/motd.

                                    
                                    sudo vim /etc/motd
                                    
                                    
content_copy
Commande Curl

Installation
                                
                                sudo apt-get install curl
                                
                                
content_copy
Syntaxe de base

Les options permettent de configurer les requêtes, comme spécifier une méthode HTTP, ajouter des en-têtes, etc.

                                
                                curl [options] [URL]
                                
                                
content_copy
Faire une Requête GET (par défaut)

Cela fait une requête GET sur l'URL indiquée et renvoie le contenu de la page.

                                
                                curl http://example.com
                                
                                
content_copy
Options de requêtes HTTP
POST
PUT
DELETE
POST
                                            
                                            curl -X POST http://example.com -d "key=value"
                                            
                                            
content_copy
PUT
                                            
                                            curl -X PUT http://example.com/resource -d "key=value"
                                            
                                            
content_copy
DELETE
                                            
                                            curl -X DELETE http://example.com/resource
                                            
                                            
content_copy
Envoyer des Données en JSON

-H : Ajoute des en-têtes HTTP, ici Content-Type: application/json.
-d : Envoie des données dans le corps de la requête.

                                
                                curl -X POST http://example.com/resource -H "Content-Type: application/json" -d '{"key1":"value1", "key2":"value2"}'
                                
                                
content_copy
Ajouter des En-têtes Personnalisés

Plusieurs en-têtes peuvent être ajoutés en répétant l’option -H.

                                
                                curl -H "Authorization: Bearer YOUR_TOKEN" -H "Content-Type: application/json" http://example.com
                                
                                
content_copy
Télécharger un Fichier

-O (majuscule) enregistre le fichier sous son nom d'origine.

                                
                                curl -O http://example.com/file.zip
                                
                                
content_copy

Pour un nom personnalisé :

                                
                                curl -o custom_name.zip http://example.com/file.zip
                                
                                
content_copy
Sauvegarder le Résultat dans un Fichier
                                
                                curl http://example.com -o output.txt
                                
                                
content_copy
Voir les En-têtes HTTP de la Réponse

-I (majuscule) retourne uniquement les en-têtes de la réponse.

                                
                                curl -I http://example.com
                                
                                
content_copy
Suivre les Redirections

-L indique à curl de suivre les redirections HTTP (301, 302, etc.).

                                
                                curl -L http://example.com
                                
                                
content_copy
Affichage des Détails de la Requête

-v (verbose) affiche des informations détaillées sur la requête (en-têtes envoyés, réponse, etc.).

                                
                                curl -v http://example.com
                                
                                
content_copy
Authentification HTTP (Basique)

-u indique les informations d'identification sous la forme username:password.

                                
                                curl -u username:password http://example.com
                                
                                
content_copy
Téléverser un Fichier avec la Requête POST

-F envoie le fichier dans un formulaire de type multipart/form-data, souvent utilisé pour l’upload.

                                
                                curl -X POST http://example.com/upload -F "file=@/path/to/file"
                                
                                
content_copy
Tester une API RESTful

Pour tester des API REST, curl permet d’envoyer facilement des données, d’ajouter des en-têtes, et de visualiser les réponses JSON, parfait pour vérifier les points de terminaison d’une API :

                                
                                curl -X POST http://api.example.com/data \
                                -H "Content-Type: application/json" \
                                -H "Authorization: Bearer your_token_here" \
                                -d '{"name":"example", "age":26}'
                                
                                
content_copy
Utiliser curl avec des Certificats

Pour accéder aux serveurs sécurisés par SSL.
--cacert permet de spécifier un certificat CA pour vérifier la connexion.

                                
                                curl --cacert /path/to/certificate.pem https://secure.example.com
                                
                                
content_copy
Utiliser curl avec des Variables d’Environnement

curl peut récupérer des variables définies dans le shell pour personnaliser les requêtes.

                                
                                export API_KEY="your_api_key"
                                curl -H "Authorization: Bearer $API_KEY" http://example.com
                                
                                
content_copy
Utilisation Avancée
Charger des Données depuis un Fichier

Lorsque les données JSON sont volumineuses, il est souvent plus pratique de les placer dans un fichier.

                                    
                                    curl -X POST http://example.com -d @data.json
                                    
                                    
content_copy

Exemples Pratiques

Tester une requête GET basique avec paramètres
                                    
                                    curl "http://api.example.com/users?name=Mahmoud&age=25"
                                    
                                    
content_copy
Appel à une API nécessitant des tokens d’authentification et des données en JSON :
                                    
                                    curl -X POST http://api.example.com/create \
                                    -H "Authorization: Bearer your_token" \
                                    -H "Content-Type: application/json" \
                                    -d '{"username":"new_user", "email":"user@example.com"}'
                                    
                                    
content_copy
Protocole SFTP

Cette partie sert à introduire le protocole SFTP. Le protocole SFTP est un protocole utilisé pour transférer des fichiers de manière sécurisée entre un ordinateur local et un serveur distant via une connexion SSH (Secure Shell).

Installation

Le protocole SFTP se base sur le protocole SSH, il suffit donc d'installer SSH sur la machine pour pouvoir utiliser SFTP.

emoji_objects

Pour utiliser des scripts automatisés, il faut installer le paquet sshpass.

Ouvrir une connexion SFTP

Sur une machine on peut établir une connexion SFTP au client, on utilise la commande sftp dans le terminal. On spécifie l'utilisateur et l'adresse IP ou le nom d'hôte du client.

                                
                                sftp <utilisateur>@<adresse_IP_ou_nom_hote>
                                
                                
content_copy
Navigation

Une fois connecté, on peut naviguer dans les répertoires du client en utilisant les commandes de navigation SFTP : (par exemple, cd pour changer de répertoire, ls pour lister les fichiers et les répertoires).

  • cd : pour changer de répertoire
  • ls : pour lister les fichiers et les répertoires

Commandes SFTP

Récupérer un fichier
                                
                                    get <nom_du_fichier>
                                
                                
content_copy

On peut également modifier le nom du fichier récupéré si l'on souhaite.

                                
                                    get <nom_du_fichier> <nouveau_nom>
                                
                                
content_copy
emoji_objects

Pour récupérer plusieurs fichiers, on peut utiliser des caractères génériques (*) ou spécifier plusieurs fichiers à récupérer.

Récupération de fichiers

En utilisant scp, on peut récupérer des fichiers depuis un client avec une seule commande :

                                
                                    scp utilisateur@adresse_ip:/chemin/vers/fichiers/nom_du_fichier /chemin/vers/destination/
                                
                                
content_copy
Déposer un fichier

Pour déposer un fichier depuis la machine source vers un client :

                                
                                    put <fichier_local> <nouveau_nom_facultatif>
                                
                                
content_copy
Se déconnecter

Pour se déconnecter de la session SFTP, tapez :

                                
                                    exit // ou bye
                                
                                
content_copy
Obtenir le répertoire local

Lorsqu'on se connecte à un client, on peut vouloir connaître le répertoire dans lequel les fichiers récupérés seront déposés. Pour ce faire, on peut utiliser la commande suivante pour déterminer où l'on se trouve :


Pour obtenir le répertoire distant où l'on se trouve :

Configurer le répertoire de réception

Pour configurer le répertoire où les fichiers téléchargés avec la commande `get` seront déposés, on peut changer le répertoire de travail local avec la commande `lcd` (local change directory).

                                    
                                        lcd <répertoire_cible>
                                    
                                    
content_copy
Répertoire de travail local (sur notre machine)

On peut lister les fichiers dans le répertoire de travail local (sur notre machine). Cela permet de visualiser les fichiers que l'on a récupérés.

Renommer un fichier

On peut renommer un fichier avec la commande :

                                    
                                        rename <ancien_nom> <nouveau_nom>
                                    
                                    
content_copy
Supprimer un fichier

On peut supprimer un fichier avec la commande :

                                    
                                        rm <nom_du_fichier>
                                    
                                    
content_copy
Supprimer un répertoire

On peut supprimer un répertoire avec la commande :

                                    
                                        rmdir <nom_du_repertoire>
                                    
                                    
content_copy
Créer un répertoire sur le serveur distant

On peut créer un répertoire sur le serveur distant avec la commande :

                                    
                                        mkdir <nom_du_repertoire>
                                    
                                    
content_copy
Rsync

Rsync est un utilitaire de synchronisation de fichiers et de répertoires très puissant et largement utilisé. Il est souvent utilisé pour copier, synchroniser et sauvegarder des fichiers localement ou via le réseau. Rsync se distingue par sa capacité à transférer uniquement les parties de fichiers qui ont changé entre la source et la destination, ce qui le rend très efficace pour les transferts de données.

Installation
                                
                                sudo apt install rsync
                                
                                
content_copy
Les options

Quelques options disponilbes

rsync -..

  • -a : Archive. Copie récursive des répertoires et préservation des propriétés des fichiers (permissions, timestamps, etc.).
  • -v : Verbeux. Affiche des informations détaillées pendant la synchronisation.
  • -z : Compression. Compresse les données pendant le transfert pour réduire la bande passante utilisée.
  • -r : Récursif. Copie récursive des répertoires et de leur contenu.
  • -u : Update. Ne met à jour que les fichiers sur la destination si leur version sur la source est plus récente.
  • -s : Simulation. Effectue une simulation de la synchronisation sans effectuer réellement de copie.
  • -P : Progress. Affiche une barre de progression pendant le transfert et permet de reprendre les transferts interrompus.
  • -q : Quiet. Supprime la plupart des messages sauf en cas d'erreur.
  • -l : Liens symboliques. Copie les liens symboliques en tant que liens symboliques.
  • -t : Timestamps. Préserve les horodatages des fichiers lors de la copie.
  • -n : Dry-run. Effectue une simulation de la synchronisation sans effectuer réellement de copie.
Utilisations

Copier des fichiers localement
                                
                                rsync -av /chemin/source /chemin/destination
                                
                                
content_copy
Copier des fichiers via SSH

Cette commande copie les fichiers et répertoires depuis un hôte distant un hôte distant via SSH.

                                
                                rsync -avz -e ssh utilisateur@hote:/chemin/source /chemin/destination
                                
                                
content_copy

Cette commande copie les fichiers et répertoires vers un hôte distant via SSH.

                                
                                rsync -avz -e ssh /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
Exclure des fichiers ou répertoires

Cette commande exclut tous les fichiers avec l'extension .csv lors de la synchronisation.

                                
                                rsync -av --exclude='*.csv' /chemin/source /chemin/destination
                                
                                
content_copy
                                
                                rsync -avz -e ssh --exclude='*.csv' /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
Exclure les fichiers existants dans la destination

Cette commande ignore les fichiers qui existent déjà dans la destination lors de la synchronisation.

                                
                                rsync -av --ignore-existing /chemin/source /chemin/destination
                                
                                
content_copy
                                
                                rsync -avz -e ssh --ignore-existing /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
Synchroniser récursivement

Cette commande synchronise récursivement le chemin source avec le chemin destination et supprime les fichiers dans le chemin destination qui ne sont pas présents dans le chemin source.

                                
                                rsync -avz -e ssh --delete /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
Utilisations d'un fichier

Utiliser un fichier pour spécifier les fichiers à copier

Cette commande lit la liste des fichiers à copier à partir du fichier file_list.txt.

                                
                                rsync -av --files-from=file_list.txt /chemin/source /chemin/destination
                                
                                
content_copy
                                
                                rsync -avz -e ssh --files-from=file_list.txt /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
Synchronisation

Synchroniser des fichiers entre un dossier source et un dossier de destination

Cette commande synchronisera le contenu du dossier source vers le dossier de destination. Seuls les fichiers qui sont plus récents dans le dossier source que dans le dossier de destination seront copiés.

                                
                                rsync -av --update /dossier/source/ /dossier/destination/
                                
                                
content_copy
                                
                                rsync -avz -e ssh --update /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy
                                
                                rsync -avz -e ssh --update --files-from=file_list.txt /chemin/source utilisateur@hote:/chemin/destination
                                
                                
content_copy