Syntaxe et exemples de connexion à distance SSH

Le protocole SSH sous Linux est utilisé pour gérer les systèmes distants. Normalement, il s’agirait d’un autre système Linux, mais il pourrait également s’agir d’un pare-feu, d’un routeur ou même d’un système d’exploitation entièrement différent. L’utilisation du protocole SSH pour vous connecter à distance à un autre système vous donnera un terminal en ligne de commande auquel vous pourrez accéder entièrement comme si vous étiez physiquement devant la machine.

Comme vous pouvez l’imaginer, être capable de gérer un nombre incalculable de systèmes distants sans se lever de votre chaise est un rêve pour les administrateurs Linux, ou même des utilisateurs ordinaires qui ont plusieurs systèmes à différents endroits. SSH peut également être utilisé pour créer des tunnels de redirection de port, en cryptant et en sécurisant efficacement les connexions établies via tout type d’application sur votre système Linux.

Dans ce tutoriel, vous allez apprendre à utiliser le protocole SSH sous Linux à travers des exemples. Suivez ci-dessous pour en savoir plus sur les différentes options que vous pouvez utiliser avec cette commande. Vous verrez également comment installer le package OpenSSH sur votre système et implémenter diverses configurations SSH sur votre serveur.

Dans ce tutoriel, vous allez apprendre :

Comment installer le package OpenSSH sur les principales distributions Linux
Comment autoriser la connexion SSH à distance pour le compte root
Comment exécuter une commande après une connexion à distance SSH
Comment utiliser la commande scp pour copier des fichiers vers et depuis un serveur distant
Comment utiliser la redirection de port SSH
Comment tarer sur SSH
Comment ajouter un alias SSH

Comment installer OpenSSH Server et Client sur les principales distributions Linux

Avant de commencer, vous devez avoir installé OpenSSH sur votre système. Le package OpenSSH Server doit être installé si vous souhaitez que votre ordinateur accepte les connexions SSH entrantes. Sinon, si vous souhaitez simplement initier des connexions sortantes avec la commande ssh, vous pouvez installer le package OpenSSH Clients. Bien sûr, vous pouvez également installer les deux.

Vous pouvez utiliser la commande appropriée ci-dessous pour installer OpenSSH avec le gestionnaire de paquets de votre système.

Pour installer OpenSSH sur Ubuntu, Debian et Linux Mint :


sudo apt install ssh

Pour installer OpenSSH sur Fedora, CentOS, AlmaLinux et Red Hat :


sudo dnf install openssh-server openssh-clients

Pour installer OpenSSH sur Arch Linux et Manjaro :


sudo pacman -S openssh

Comment se connecter à un système distant via le protocole SSH

Pour vous connecter à un système distant en utilisant SSH, vous utiliserez la commande ssh dans le terminal. La commande ssh est indispensable si vous souhaitez gérer des systèmes distants. Suivez nos exemples ci-dessous pour en savoir plus sur certaines des options les plus courantes et les plus utiles à utiliser avec la commande.

Pour vous connecter à un système distant avec ssh, spécifiez simplement le nom d’hôte ou l’adresse IP du système distant dans votre commande ssh. À titre d’exemple, nous allons montrer la commande SSH dans un serveur nommé linuxconfig.org qui a une adresse IP de 10.1.1.1.
```
ssh linuxconfig.org
OR
ssh 10.1.1.1
```
À moins que le nom d’utilisateur auquel vous êtes actuellement connecté ne soit le même que celui du système distant, vous devez spécifier le nom d’utilisateur et votre commande ssh. Il y a deux façons différentes de le faire, comme on le voit ci-dessous.
```
ssh user@linuxconfig.org
OR
ssh -l user linuxconfig.org
```
Le port par défaut pour l’écoute SSH est le 22. Si le système distant exécute le service SSH sur un port autre que celui par défaut, vous pouvez spécifier ce port avec l’option -p dans votre commande. L’exemple suivant montre comment vous pouvez vous connecter en SSH à un système distant qui exécute le service sur le port 2210.
```
ssh -p 2210 user@linuxconfig.org
```
L’option -v (verbeuse) vous donnera des détails sur le processus de connexion de SSH. Ceci est utile lors du dépannage d’une connexion problématique.
```
ssh -v user@linuxconfig.org
```
Pour augmenter encore plus le verbeux, vous pouvez utiliser l’option -vvv.
```
ssh -vvv user@linuxconfig.org
```

Comment autoriser la connexion SSH à distance pour le compte root

La connexion au compte racine via une connexion SSH est désactivée par défaut. Ceci est fait pour des raisons de sécurité. Si un compte est compromis, cela signifie que l’attaquant n’aura pas automatiquement les autorisations root.

Si vous souhaitez renoncer à cette recommandation de sécurité et pouvoir vous connecter à SSH avec votre compte root, il existe un paramètre simple que vous pouvez modifier dans le fichier de configuration du serveur SSH pour activer la connexion root. Suivez les étapes ci-dessous pour configurer ce paramètre.

Ouvrez le fichier /etc/ssh/sshd_config avec des privilèges administratifs, en utilisant nano ou l’éditeur de texte de votre choix.
```
sudo nano /etc/ssh/sshd_config
```
Dans ce fichier, recherchez et modifiez la ligne suivante :
Changement de :
```
#PermitRootLogin prohibit-password
```
Changer pour :
```
PermitRootLogin yes
```
La façon la plus rapide de faire ce travail pourrait être d’utiliser simplement la commande sed comme indiqué ci-dessous :
```
sudo sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
```
Une fois que vous avez terminé d’effectuer cette modification, enregistrez le fichier, puis redémarrez le service SSH pour que les modifications prennent effet.
```
Debian based:
sudo systemctl restart ssh

Red Hat based:
sudo systemctl restart sshd
```
Gardez à l’esprit que le compte root n’a pas de mot de passe configuré sur certaines distributions Linux. Si c’est le cas pour votre système, vous devrez définir un mot de passe root avec la commande passwd avant de pouvoir vous connecter au compte root via SSH.
```
sudo passwd
[sudo] password for linuxconfig: 
Enter new UNIX password: 
Retype new UNIX password: 
passwd: password updated successfully
```
Enfin, vous êtes prêt à vous connecter à SSH avec le compte d’utilisateur root.
```
ssh root@linuxconfig.org
```

Comment exécuter une commande après une connexion à distance SSH

SSH est plus puissant que de simplement fournir à un utilisateur un accès shell à distance, car il peut également être utilisé pour automatiser l’exécution de commandes à distance, comme l’exécution de sauvegardes simples et le téléchargement du fichier de sauvegarde localement.

Utilisez certaines des commandes ci-dessous pour voir comment fonctionne l’exécution de commandes à distance via SSH et adaptez-les à vos propres besoins.

La commande SSH suivante peut être utilisée pour créer un fichier à distance.
```
ssh user@hostname '( cd /tmp/ && touch ssh_file.txt )'
```
Cet exemple permet d’effectuer une copie locale d’un fichier /etc/passwd distant dans /tmp/passwd :
```
ssh user@username '( cat /etc/passwd )' > /tmp/passwd
```
Cet exemple exécutera un script sur le serveur distant. Bien sûr, cela ne fonctionnera que si le script existe déjà et dispose des autorisations d’exécution appropriées.
```
ssh user@hostname '( cat ~/myscript.sh )'
```
Dans cet exemple, nous effectuons une copie locale bzip2 du fichier /var/log/auth.log du serveur distant dans un fichier local dans le répertoire /tmp/ :
```
ssh user@hostname '( cp /var/log/auth.log /tmp/; cd /tmp/ && tar -jcvf - auth.log )' > /tmp/auth.tar.bz2
```

Comment copier des fichiers et des répertoires d’un serveur distant vers un ordinateur local

La commande scp fonctionne via le protocole SSH et est utilisée pour copier des fichiers et des répertoires vers ou depuis un système distant. Il fonctionne de manière très similaire à la commande cp, sauf qu’il copie des fichiers vers ou depuis d’autres systèmes qui se trouvent soit sur votre réseau local, soit quelque part sur Internet.

Consultez certains des exemples ci-dessous pour voir comment vous pouvez utiliser scp pour copier des fichiers vers et depuis un système distant.

Prenons un exemple simple où nous utilisons la commande scp pour copier un fichier local nommé file.txt sur un serveur distant avec l’adresse IP 10.1.1.20.
```
scp file.txt linuxconfig@10.1.1.20:/home/linuxconfig
```
Dans cet exemple, nous nous authentifions avec le nom d’utilisateur linuxconfig sur le serveur 10.1.1.20. Après avoir fourni le mot de passe ou vous être authentifié avec des clés RSA, notre fichier file.txt sera copié du système local dans le répertoire distant /home/linuxconfig.
Si nous avions voulu que notre fichier d’origine adopte un nouveau nom de fichier sur le système distant, nous pouvons le spécifier dans notre commande.
```
scp file.txt linuxconfig@10.1.1.20:/home/linuxconfig/newname.txt
```
Pour copier un répertoire au lieu d’un fichier sur le système distant, vous devrez utiliser l’option -r dans votre commande scp.
```
scp -r Downloads linuxconfig@10.1.1.20:/home/linuxconfig/
```
Dans cet exemple, nous copions notre répertoire local Downloads dans le répertoire distant /home/linuxconfig/.
Jusqu’à présent, nous avons vu comment copier des fichiers et des répertoires de notre système local vers le système distant. Mais qu’en est-il de l’inverse ? Si nous voulons copier un fichier distant dans notre système local, tout ce que nous avons à faire est d’inverser l’ordre de la commande, comme indiqué ci-dessous.
```
scp linuxconfig@10.1.1.20:/home/linuxconfig/file.txt /path/to/destination
```
Dans cet exemple, nous copions le fichier distant /home/linuxconfig/file.txt dans notre répertoire local à l’adresse /path/to/destination.

Comment utiliser la redirection de port SSH

La redirection de port SSH peut être utilisée pour chiffrer le trafic entre deux systèmes pour à peu près n’importe quel protocole. Pour ce faire, il faut créer un tunnel sécurisé, puis acheminer le trafic d’un autre protocole à travers ce tunnel. Par principe, il fonctionne de manière très similaire à un VPN.

À titre d’exemple, nous allons créer une redirection de port pour le protocole telnet, qui est généralement évitée en raison de la façon dont il transfère les données en texte clair. Cela sécurisera le protocole et le rendra sûr à utiliser. Pour cet exemple, nous allons rediriger le port 4500 de notre système local vers le port 23 (telnet) d’un système distant.


ssh -L 4500:127.0.0.1:23 user@linuxconfig.org

Disséquons ce qui se passe dans cette commande.

-L – Cette option indique à SSH que nous voulons créer un tunnel via la redirection de port.
4500 – Le port de notre système local par lequel nous enverrons le trafic.
127.0.0.1 – Il s’agit de l’adresse de bouclage de notre système local.
23 – Le port distant auquel nous essayons de nous connecter.
user – Le nom d’utilisateur pour se connecter à SSH sur le serveur distant.
linuxconfig.org : adresse IP ou nom de domaine du serveur distant.

À ce stade, chaque connexion qui utilise le port 4500 sur l’hôte local sera redirigée vers le port distant 23.

Maintenant, sur notre système local, nous pouvons accéder au service telnet du système distant en acheminant le trafic via le port 4500.


telnet 127.0.0.1 4500

C’est tout ce qu’il y a à faire. Vous pouvez utiliser des tunnels SSH pour tout type de trafic. Ce qu’il faut retenir, c’est que vous devez pointer votre application vers votre adresse localhost (127.0.0.1) et le numéro de port que vous configurez pour le tunnel SSH.

Comment se connecter à SSH sans mot de passe

Si jamais vous en avez assez de taper votre mot de passe SSH, il est possible de configurer l’authentification par clé publique, qui vous permet de vous connecter à un serveur via SSH, sans utiliser de mot de passe.

La meilleure partie est que l’utilisation de l’authentification par clé est en fait plus sûre que la saisie d’un mot de passe à chaque fois. C’est en plus d’être beaucoup plus pratique. Il vous permet également d’automatiser certaines tâches, telles que les scripts rsync ou d’autres scripts Bash qui utilisent SSH, SCP, etc.

Suivez les instructions étape par étape ci-dessous pour configurer cette configuration.

Commencez par ouvrir un terminal et générez des clés RSA sur le système à partir duquel vous allez vous connecter. Exécutez la commande suivante, puis appuyez trois fois sur Entrée.
```
ssh-keygen
```
Ensuite, nous copions notre clé sur le système distant à l’aide de la commande ssh-copy-id. Nous spécifierons également notre utilisateur SSH et le nom d’hôte ou l’adresse IP du système distant. Ensuite, vous serez invité à entrer le mot de passe de connexion SSH.
```
ssh-copy-id user@hostname
```
Maintenant que la clé a été copiée sur le système distant, vous pourrez vous connecter comme d’habitude, mais sans avoir besoin de donner le mot de passe.
```
ssh user@hostname
```

C’est tout ce qu’il y a à faire. Vous n’aurez pas besoin de spécifier à nouveau un mot de passe. Cependant, si les clés RSA sont supprimées ou remplacées, vous devrez supprimer l’ancienne paire et les générer à nouveau en suivant ce même ensemble d’instructions.

Comment tarer sur SSH

Comme vu précédemment dans ce tutoriel, il est possible d’utiliser la redirection de sortie SSH pour exécuter des commandes sur un système distant. L’une des commandes les plus courantes que les administrateurs Linux exécutent à distance est la commande tar. Cela leur permet de regrouper et éventuellement de compresser des fichiers distants, généralement pour un transfert facile par la suite.

Consultez certains des exemples ci-dessous pour voir comment utiliser la redirection de sortie SSH afin d’utiliser tar sur SSH.

Dans ce premier exemple, nous allons créer un simple fichier tar non compressé du répertoire personnel de l’utilisateur linuxconfig.
```
ssh user@hostname '( tar -cf /tmp/home.tar /home/linuxconfig )'
```
Et si nous voulions également transférer ce fichier tar vers notre système local ? Dans ce cas, nous ajoutons l’opérateur > à la fin.
```
ssh user@hostname '( tar -cf - /home/linuxconfig )' > /tmp/home.tar
```
Ajoutons un peu de compression au fichier tar (gzip) et ajoutons l’option de verbosité à tar.
```
ssh user@hostname '( tar -czvf - /home/linuxconfig )' > /tmp/home.tar.gz
```

Comme vous pouvez le voir, SSH devient assez puissant lorsqu’il peut nous fournir un moyen de compresser et de transférer des répertoires distants vers notre système local.

Comment ajouter un alias SSH

Comme vous pouvez le voir dans certains des exemples de commandes plus tôt dans notre tutoriel, la commande SSH n’est pas difficile à utiliser, mais peut devenir assez longue dans certaines circonstances. Les administrateurs Linux qui ont besoin d’exécuter ces commandes plusieurs fois par jour peuvent trouver cela particulièrement ennuyeux, il est donc préférable de créer un alias pour ces longues commandes. Nous couvrirons ci-dessous deux méthodes pour cela.

Créez un alias en modifiant le fichier .bashrc

Créons un alias ssh qui nous permet de nous connecter ssh au serveur distant (exemple : linuxconfig.org sur le port 2222) avec une seule commande.

Tout d’abord, ouvrez le fichier .bashrc avec votre éditeur de texte préféré.
```
nano ~/.bashrc
```

Ensuite, ajoutez la ligne suivante au fichier.


alias lconfig='ssh -p 2222 linuxconfig.org'

Enregistrez vos modifications et quittez le fichier une fois que vous avez terminé. Votre nouvel alias sera activé lorsque vous créerez une nouvelle session shell. Par conséquent, ouvrez un nouveau terminal (ou déconnectez-vous et connectez-vous) et entrez la commande lconfig pour vous connecter à votre serveur distant. Si vous avez réussi à échanger vos clés publiques avec un serveur distant, vous devriez pouvoir vous connecter à votre serveur distant en un rien de temps.
```
lconfig
```

Créer un lien symbolique vers un script ssh personnalisé ssh

La deuxième option est un peu plus délicate, mais en même temps, elle nous permet également d’exécuter n’importe quelle commande sur un serveur distant directement à partir du shell local.

Tout d’abord, créez un script bash avec les deux lignes suivantes :
```
#/bin/bash
ssh `basename $0` $*
```
Connectez-vous en tant que root, rendez ce script exécutable et copiez ce script dans le répertoire /usr/local/bin :
```
chmod +x /tmp/ssh-autologin.sh
cp /tmp/ssh-autologin.sh /usr/local/bin/
```
Maintenant, créez un lien symbolique vers votre script où le nom de votre nouveau lien symbolique sera une adresse IP ou un nom d’hôte de votre serveur distant :
```
ln -s /usr/local/bin/ssh-autologin.sh /usr/local/bin/linuxconfig.org
```
ou créez un lien symbolique d’adresse IP :
```
ln -s /usr/local/bin/ssh-autologin.sh /usr/local/bin/8.8.8.8
```
Assurez-vous que le répertoire /usr/local/bin se trouve dans votre PATH en :
```
echo $PATH
```
Si vous avez besoin d’ajouter le répertoire /usr/local/bin à votre chemin, suivez ce simple CHEMIN ENV. Tout est prêt et prêt. Pour vous connecter à votre serveur distant, entrez simplement la commande :
```
linuxconfig.org
```
Pour voir qui est en ligne sur votre serveur distant avec une IP 8.8.8.8 sans connexion ssh réelle, entrez :
```
8.8.8.8 who
```
La commande ci-dessus créera une connexion ssh, exécutera la commande who sur le serveur distant, imprimera la sortie sur votre terminal local et se déconnectera.

Réflexions finales

Dans ce tutoriel, nous avons appris comment installer OpenSSH sur les principales distributions Linux, ainsi que toutes les bases pour commencer à utiliser le service. Le protocole SSH est de loin le moyen le plus répandu et le plus couramment pris en charge pour gérer des systèmes distants en ligne de commande. Nous avons couvert toutes les options les plus basiques et les plus avancées que vous devrez connaître avec la commande, bien qu’il en existe encore plus. SSH est un moyen très sûr et pratique de gérer des systèmes Linux distants ainsi que d’autres périphériques réseau.