Transfert de fichiers sous Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique dans la gestion et le transfert de fichiers de manière efficace et sécurisée sur un système RHEL. Vous apprendrez à créer, lister et extraire des fichiers à partir d'archives tar, y compris les archives compressées, essentielles pour le packaging et la sauvegarde des données.

De plus, ce laboratoire vous guidera dans le transfert sécurisé de fichiers à l'aide de sftp pour les transferts de fichiers interactifs et de rsync pour une synchronisation de fichiers robuste et efficace, garantissant l'intégrité et la sécurité des données lors des opérations réseau.

Créer et lister des archives tar

Dans cette étape, vous apprendrez à créer et à lister des archives tar. L'utilitaire tar est un outil puissant de ligne de commande utilisé pour archiver des fichiers et des répertoires. Il est couramment utilisé pour les sauvegardes et les transferts de fichiers.

La commande tar nécessite une option d'action pour spécifier l'opération à effectuer. Les options d'action courantes incluent :

-c ou --create : Crée une nouvelle archive.
-t ou --list : Liste le contenu d'une archive.
-x ou --extract : Extrait les fichiers d'une archive.

De plus, tar utilise souvent des options générales pour modifier son comportement :

-v ou --verbose : Affiche les fichiers traités lors de l'archivage ou de l'extraction.
-f ou --file : Spécifie le nom du fichier d'archive. Cette option doit être suivie du nom du fichier d'archive.

Commençons par créer des fichiers d'exemple que nous allons archiver. Naviguez vers votre répertoire ~/project, qui est votre répertoire de travail par défaut.

cd ~/project

Maintenant, créez un nouveau répertoire nommé my_files et quelques fichiers texte d'exemple à l'intérieur.

mkdir my_files
echo "Ceci est le contenu du fichier1." > my_files/file1.txt
echo "Ceci est le contenu du fichier2." > my_files/file2.txt
echo "Ceci est le contenu du fichier3." > my_files/file3.txt
ls my_files

Vous devriez voir les trois fichiers listés :

file1.txt  file2.txt  file3.txt

Maintenant, créons une archive tar du répertoire my_files. Nous nommerons l'archive my_archive.tar.

tar -cvf my_archive.tar my_files

La sortie affichera les fichiers ajoutés à l'archive :

my_files/
my_files/file1.txt
my_files/file2.txt
my_files/file3.txt

Vous pouvez vérifier que le fichier d'archive my_archive.tar a été créé dans votre répertoire courant :

ls

Vous devriez voir my_archive.tar listé avec my_files :

my_archive.tar  my_files

Ensuite, listons le contenu du fichier my_archive.tar en utilisant les options -t (liste) et -f (fichier).

tar -tf my_archive.tar

La sortie affichera le contenu de l'archive :

my_files/
my_files/file1.txt
my_files/file2.txt
my_files/file3.txt

Si vous souhaitez afficher des informations plus détaillées, telles que les permissions, la propriété et la taille des fichiers, vous pouvez ajouter l'option -v (verbose) :

tar -tvf my_archive.tar

La sortie sera similaire à ceci, fournissant plus de détails sur chaque élément archivé :

drwxr-xr-x labex/labex        0 2023-10-27 10:00 my_files/
-rw-r--r-- labex/labex       22 2023-10-27 10:00 my_files/file1.txt
-rw-r--r-- labex/labex       22 2023-10-27 10:00 my_files/file2.txt
-rw-r--r-- labex/labex       22 2023-10-27 10:00 my_files/file3.txt

Notez que tar supprime par défaut le préfixe / des chemins absolus lors de l'archivage. Il s'agit d'une mesure de sécurité pour éviter l'écrasement accidentel de fichiers système lors de l'extraction d'archives. Par exemple, si vous archiver /etc/hosts, il sera stocké sous la forme etc/hosts dans le fichier tar. Cela vous permet de l'extraire dans un nouvel emplacement sans affecter le fichier /etc/hosts d'origine.

Extraction de fichiers à partir d'archives tar

Dans cette étape, vous apprendrez à extraire des fichiers à partir d'une archive tar. L'extraction de fichiers consiste à récupérer le contenu archivé et à le replacer dans le système de fichiers.

L'option principale pour extraire des fichiers est -x ou --extract. Vous utiliserez généralement également -f pour spécifier le fichier d'archive et -v pour une sortie détaillée afin de voir quels fichiers sont extraits.

Avant l'extraction, il est conseillé d'extraire les archives dans un répertoire vide pour éviter d'écraser des fichiers existants ou de les mélanger avec d'autres contenus. Créons un nouveau répertoire appelé extracted_files dans votre répertoire ~/project.

cd ~/project
mkdir extracted_files

Maintenant, accédez au répertoire extracted_files. Cela garantit que le contenu de l'archive sera extrait ici.

cd extracted_files

Maintenant, extrayons le contenu de my_archive.tar (situé dans le répertoire parent, ~/project) dans le répertoire extracted_files actuel.

tar -xvf ../my_archive.tar

La sortie affichera les fichiers extraits :

my_files/
my_files/file1.txt
my_files/file2.txt
my_files/file3.txt

Après l'extraction, vous pouvez lister le contenu du répertoire courant (~/project/extracted_files) pour vérifier que le répertoire my_files et son contenu ont bien été extraits.

ls

Vous devriez voir le répertoire my_files :

my_files

Maintenant, vérifions le contenu du répertoire my_files à l'intérieur de extracted_files :

ls my_files

Vous devriez voir les fichiers originaux :

file1.txt  file2.txt  file3.txt

Vous pouvez également afficher le contenu d'un des fichiers extraits pour confirmer son intégrité :

cat my_files/file1.txt

La sortie devrait être :

This is file1 content.

Lors de l'extraction de fichiers, la commande tar utilise le umask actuel pour définir les permissions des fichiers extraits. Toutefois, si vous souhaitez préserver les permissions originales des fichiers tels qu'ils étaient dans l'archive, vous pouvez utiliser l'option -p ou --preserve-permissions. Ceci est particulièrement utile pour les scripts exécutables ou les fichiers de configuration où des permissions spécifiques sont cruciales. Pour l'utilisateur root, cette option est souvent activée par défaut. Pour les utilisateurs ordinaires, il est conseillé de l'inclure si la préservation des permissions est importante.

Pour ce laboratoire, nous ne démontrerons pas explicitement l'option -p, car le comportement par défaut est suffisant pour nos fichiers texte. Cependant, gardez cette option à l'esprit pour les cas d'utilisation futurs.

Créer des archives tar compressées

Dans cette étape, vous apprendrez à créer des archives tar compressées. Alors que tar lui-même ne fait que regrouper des fichiers, il peut s'intégrer à des utilitaires de compression comme gzip, bzip2 et xz pour créer des fichiers d'archive plus petits. Ceci est crucial pour économiser de l'espace disque et réduire les temps de transfert.

La commande tar propose des options spécifiques pour différents algorithmes de compression :

-z ou --gzip : Utilise la compression gzip, ce qui donne une extension .tar.gz ou .tgz. C'est la méthode de compression la plus courante et la plus rapide.
-j ou --bzip2 : Utilise la compression bzip2, ce qui donne une extension .tar.bz2 ou .tbz. Généralement, elle offre une meilleure compression que gzip mais est plus lente.
-J ou --xz : Utilise la compression xz, ce qui donne une extension .tar.xz ou .txz. Elle offre le meilleur rapport de compression parmi les trois mais est la plus lente.
-a ou --auto-compress : Permet à tar de déterminer automatiquement l'algorithme de compression en fonction de l'extension de l'archive (par exemple, .tar.gz implique gzip). C'est une option pratique.

Commençons par vous assurer que vous êtes dans votre répertoire ~/project.

cd ~/project

Tout d'abord, nous allons créer une archive compressée gzip du répertoire my_files. Nous l'appellerons my_archive.tar.gz.

tar -czvf my_archive.tar.gz my_files

La sortie affichera les fichiers ajoutés et compressés :

my_files/
my_files/file1.txt
my_files/file2.txt
my_files/file3.txt

Vous pouvez vérifier la création de l'archive compressée :

ls -lh my_archive.tar.gz

Les options -lh pour ls fournissent une taille lisible par l'homme. Vous verrez une sortie similaire à ceci, affichant la taille du fichier :

-rw-r--r-- 1 labex labex 180 Oct 27 10:00 my_archive.tar.gz

(Remarque : la taille exacte peut varier légèrement en fonction du système et du contenu, mais elle sera petite pour ces petits fichiers texte.)

Maintenant, essayons de créer une archive compressée xz, qui offre généralement un meilleur rapport de compression. Nous l'appellerons my_archive.tar.xz.

tar -cJvf my_archive.tar.xz my_files

Encore une fois, la sortie affichera les fichiers en cours de traitement :

my_files/
my_files/file1.txt
my_files/file2.txt
my_files/file3.txt

Vérifiez la taille de l'archive xz :

ls -lh my_archive.tar.xz

Vous remarquerez peut-être que my_archive.tar.xz est légèrement plus petite que my_archive.tar.gz, ce qui démontre le meilleur rapport de compression d'xz.

-rw-r--r-- 1 labex labex 168 Oct 27 10:00 my_archive.tar.xz

Pour extraire une archive tar compressée, tar est suffisamment intelligent pour détecter souvent automatiquement le type de compression lors de l'utilisation de l'option -x. Cependant, il est conseillé d'utiliser explicitement l'option de décompression correspondante (-z, -j ou -J) ou l'option -a (auto-compression).

Essayons d'extraire my_archive.tar.gz dans un nouveau répertoire appelé extracted_gz.

mkdir extracted_gz
tar -xzvf my_archive.tar.gz -C extracted_gz

L'option -C (changer de répertoire) indique à tar d'extraire les fichiers dans le répertoire spécifié. C'est une option très utile pour éviter d'encombrer votre répertoire actuel.

Vérifiez le contenu de extracted_gz :

ls extracted_gz/my_files

Vous devriez voir :

file1.txt  file2.txt  file3.txt

Transférer des fichiers en toute sécurité avec sftp

Dans cette étape, vous apprendrez à transférer des fichiers en toute sécurité entre des systèmes à l'aide de sftp (Secure File Transfer Program). sftp est un programme de transfert de fichiers interactif qui utilise SSH (Secure Shell) pour une communication sécurisée, offrant chiffrement et authentification. Il fait partie de la suite OpenSSH.

Pour ce laboratoire, nous allons simuler un système distant en utilisant l'utilisateur labex sur le même hôte qu'un utilisateur « distant ». Cela nous permet de pratiquer les commandes sftp sans avoir besoin d'une machine virtuelle séparée.

Tout d'abord, assurez-vous que vous êtes dans votre répertoire ~/project.

cd ~/project

Créons un fichier que nous allons « téléverser » dans le répertoire personnel de l'utilisateur distant simulé.

echo "Ce fichier sera téléchargé via sftp." > local_file.txt

Maintenant, initialisons une session sftp vers l'utilisateur labex sur localhost.

sftp labex@localhost

Vous serez invité à saisir le mot de passe pour labex@localhost. Entrez labex.

L'authenticité de l'hôte 'localhost (127.0.0.1)' ne peut pas être établie.
L'empreinte de la clé ED25519 est SHA256:....
Êtes-vous sûr de vouloir continuer la connexion (oui/non/[empreinte])? oui
Avertissement : 'localhost' (ED25519) a été ajouté de manière permanente à la liste des hôtes connus.
Mot de passe de 'labex@localhost' : labex
Connecté à localhost.
sftp>

Vous êtes maintenant dans l'invite interactive sftp.

Dans l'invite sftp, vous pouvez utiliser diverses commandes similaires à une shell régulière.

pwd : Affiche le répertoire de travail actuel sur le système distant.
lpwd : Affiche le répertoire de travail actuel sur votre système local.
ls : Liste les fichiers sur le système distant.
lls : Liste les fichiers sur le système local.

Essayons-les :

sftp> pwd
Répertoire de travail distant : /home/labex
sftp> lpwd
Répertoire de travail local : /home/labex/project
sftp> ls

(La commande ls affichera le contenu de /home/labex côté distant, qui est votre propre répertoire personnel.)

Maintenant, téléchargons local_file.txt depuis votre répertoire local ~/project vers le répertoire personnel de l'utilisateur distant labex (/home/labex). Utilisez la commande put.

sftp> put local_file.txt
Téléchargement de local_file.txt vers /home/labex/local_file.txt
local_file.txt                               100%   32     0.0KB/s   00:00
sftp>

Vous pouvez vérifier que le fichier a été téléchargé en listant le répertoire distant :

sftp> ls

Vous devriez voir local_file.txt répertorié parmi les fichiers dans /home/labex.

Ensuite, téléchargeons un fichier depuis le système distant. Nous allons télécharger le fichier .bashrc du répertoire personnel de l'utilisateur distant labex vers votre répertoire local ~/project. Utilisez la commande get.

sftp> get .bashrc
Récupération de /home/labex/.bashrc vers .bashrc
/home/labex/.bashrc                          100%  193     0.2KB/s   00:00
sftp>

Vous pouvez vérifier le téléchargement en listant votre répertoire local :

sftp> lls

Vous devriez voir .bashrc répertorié dans votre répertoire local ~/project.

Pour quitter la session sftp, utilisez la commande exit ou bye.

sftp> exit

Vous retournerez à votre invite de shell habituelle.

Synchroniser des fichiers en toute sécurité avec rsync

Dans cette étape, vous apprendrez à synchroniser des fichiers entre des systèmes à l'aide de la commande rsync. rsync est un outil puissant et polyvalent pour copier et synchroniser des fichiers et des répertoires, localement et à distance. Son principal avantage est sa capacité à transférer uniquement les différences entre les fichiers, ce qui le rend très efficace pour les mises à jour. Comme sftp, rsync peut utiliser SSH pour des transferts sécurisés et chiffrés.

Les options les plus courantes pour rsync incluent :

-a ou --archive : Il s'agit d'une combinaison de plusieurs options (-rlptgoD) qui préservent la plupart des attributs des fichiers (récursif, liens, permissions, horodatages, groupe, propriétaire, fichiers de périphériques). Il est souvent appelé « mode archive » et est fortement recommandé pour la plupart des tâches de synchronisation.
-v ou --verbose : Augmente la verbosité, affichant plus de détails sur le transfert.
-z ou --compress : Compresse les données des fichiers pendant le transfert, ce qui peut accélérer les transferts sur des liens lents.
-h ou --human-readable : Affiche les nombres dans un format lisible par l'homme.
-n ou --dry-run : Effectue une exécution d'essai sans apporter de modifications. Ceci est extrêmement utile pour vérifier ce que rsync fera avant d'exécuter réellement la commande.

Commençons par vous assurer que vous êtes dans votre répertoire ~/project.

cd ~/project

Nous allons simuler un scénario de synchronisation en créant un répertoire source et un répertoire de destination.

Créez un répertoire source source_dir avec quelques fichiers :

mkdir source_dir
echo "Contenu du fichierA" > source_dir/fileA.txt
echo "Contenu du fichierB" > source_dir/fileB.txt
mkdir source_dir/subdir
echo "Contenu du fichier subfile1" > source_dir/subdir/subfile1.txt

Créez un répertoire de destination vide dest_dir :

mkdir dest_dir

Maintenant, effectuons une exécution d'essai pour voir ce que rsync ferait lors de la synchronisation de source_dir vers dest_dir. Nous utiliserons les options -avh pour le mode archive, la sortie détaillée et les tailles lisibles par l'homme, ainsi que -n pour l'exécution d'essai.

rsync -avhn source_dir/ dest_dir/

Remarque importante sur les barres obliques inversées :

source_dir/ : La barre oblique inverse signifie « copier le contenu de source_dir ».
source_dir : Sans barre oblique inverse, cela signifie « copier source_dir lui-même dans la destination ».

La sortie de l'exécution d'essai vous montrera les fichiers qui seraient transférés :

envoi de la liste des fichiers incrémentaux
./
fileA.txt
fileB.txt
subdir/
subdir/subfile1.txt

envoyé 186 octets  reçu 12 octets  396,00 octets/sec
taille totale est 66  accélération est 0,33 (EXÉCUTION D'ESSAI)

Notez (EXÉCUTION D'ESSAI) à la fin, indiquant qu'aucune modification réelle n'a été apportée.

Maintenant, effectuons la synchronisation réelle. Supprimez l'option -n.

rsync -avh source_dir/ dest_dir/

La sortie sera similaire à l'exécution d'essai, mais sans la balise (EXÉCUTION D'ESSAI) :

envoi de la liste des fichiers incrémentaux
./
fileA.txt
fileB.txt
subdir/
subdir/subfile1.txt

envoyé 186 octets  reçu 12 octets  396,00 octets/sec
taille totale est 66  accélération est 0,33

Vérifiez que les fichiers ont été copiés dans dest_dir :

ls -R dest_dir

Vous devriez voir :

dest_dir:
fileA.txt  fileB.txt  subdir

dest_dir/subdir:
subfile1.txt

Maintenant, modifions un fichier dans source_dir et ajoutons un nouveau fichier pour voir l'efficacité de rsync.

echo "Contenu mis à jour pour le fichierA" > source_dir/fileA.txt
echo "Contenu du nouveau fichier" > source_dir/new_file.txt

Effectuons une autre exécution d'essai pour voir ce que rsync transférera cette fois :

rsync -avhn source_dir/ dest_dir/

La sortie ne montrera que les fichiers modifiés et les nouveaux fichiers :

envoi de la liste des fichiers incrémentaux
./
fileA.txt
new_file.txt

envoyé 128 octets  reçu 12 octets  280,00 octets/sec
taille totale est 100  accélération est 0,71 (EXÉCUTION D'ESSAI)

Ceci démontre la capacité de rsync à ne transférer que les différences.

Maintenant, effectuons à nouveau la synchronisation réelle :

rsync -avh source_dir/ dest_dir/

Vérifiez à nouveau le contenu de dest_dir :

ls -R dest_dir
cat dest_dir/fileA.txt
cat dest_dir/new_file.txt

Vous devriez voir new_file.txt dans dest_dir et fileA.txt devrait contenir "Contenu mis à jour pour le fichierA".

Résumé

Dans ce laboratoire, nous avons acquis une expérience pratique de la gestion et du transfert de fichiers sur les systèmes RHEL à l'aide d'outils essentiels de ligne de commande. Nous avons commencé par maîtriser l'utilitaire tar, en apprenant à créer, lister et extraire des fichiers à partir d'archives, y compris la création d'archives compressées tar.gz pour un stockage et un transfert efficaces.

Ensuite, nous avons exploré les méthodes de transfert de fichiers sécurisées. Nous avons utilisé sftp pour les transferts de fichiers interactifs et sécurisés entre les systèmes, en comprenant ses capacités de téléchargement et de téléchargement de fichiers. Enfin, nous nous sommes penchés sur rsync, un outil puissant pour synchroniser des fichiers et des répertoires, en mettant en évidence son efficacité dans la gestion des mises à jour incrémentielles et le maintien de la cohérence des données entre différents emplacements.