Installation et premiers pas

Suivre ce cours nécessite un environnement de travail opérationnel. Nous allons installer ici les outils nécessaires :

  • Docker Desktop pour disposer d’un environnement de travail reproductible ;

  • Visual Studio Code pour éditer les fichiers sources et les compiler/exécuter depuis le terminal intégré ;

  • Git pour la synchronisation dans le cloud.

Puis créer l’environnement de travail dans lequel nous allons écrire/exécuter nos programmes.

Docker

Docker est une technologie qui fournit un environnement de travail reproductible quelle que soit l’architecture de la machine hôte.

Note

La machine hôte est la machine physique sur laquelle on travaille. Cette machine fonctionne avec son propre système d’exploitation (Windows, Linux, macOS, etc.).

Un container Docker est une unité logicielle légère et portable qui fonctionne de manière identique quelle que soit la machine hôte sur laquelle il est déployé (Windows, Linux, macOS, cloud, etc.). Pour ce qui nous concerne, cette unité logicielle est un système d’exploitation Ubuntu sur lequel sont installés les outils nécessaires à l’apprentissage de l’informatique.

Les avantages de l’utilisation de containers sont nombreux :

  • isolation : chaque container s’exécute de manière isolée sans interférer avec le système hôte ;

  • portabilité : un container Docker peut être déployé sur n’importe quel système d’exploitation prenant en charge Docker ;

  • légereté : contrairement aux machines virtuelles, les containers partagent le noyau du système d’exploitation de l’hôte, ce qui les rend plus rapides et moins gourmands en ressources.

L’utilisation de containers Docker nécessite l’installation de Docker Desktop, l’application de gestion de Docker.

Installation de Docker Desktop

Installer Docker Desktop sur votre machine hôte en suivant les instructions de la documentation officielle :

Note

Pour les machines hôte Windows, activer le sous-système Windows pour Linux (WSL2) en suivant les instructions de Comment installer Linux sur Windows avec WSL.

Ensuite :

Docker Desktop fonctionne sur une architecture client-serveur :

  • le client Docker, qui est l’interface en ligne de commande permettant d’interagir avec Docker dans un terminal et l’interface graphique ;

  • le daemon Docker, qui est le service responsable de la création et de l’exécution des containers ;

Note

Docker nécessite une distribution Linux pour fonctionner :

  • sur une machine hôte Windows, Docker Desktop fonctionne une distribution Linux (docker-destop) installée dans l’environnement WSL2 ;

  • sur macOS, Docker Desktop fonctionne également avec une machine virtuelle Linux ;

  • sur une machine hôte Linux, Docker Desktop fonctionne directement avec le noyau Linux.

../_images/misc-04-docker-fig-01.drawio.png

Important

Quelle que soit l’architecture, Docker Desktop fournit une couche d’abstraction qui fonctionne de façon identique quelque soit le système d’exploitation.

Vérification de l’installation

Note

Pour les machines hôte Windows, il est nécessaire de vérifier que WSL est installé et que la distribution docker-desktop est bien présente et en mode « Running »

$ wsl -l -v
NAME              STATE           VERSION
* Ubuntu          Running         2
docker-desktop    Running         2

Si ce n’est pas le cas, quitter l’application Docker Desktop et redémarrer. On peut également démarrer la distribution docker-desktop avec la commande suivante

$ wsl --d docker-desktop

Pour vérifier que Docker Desktop est correctement installé, dans un terminal de la machine hôte

$ docker --version
Docker version 29.6.1, build 8900f1d

$ docker info
Client:
Version:    29.6.1
Context:    desktop-linux
Debug Mode: false
...

Lorsque les deux tests précédents sont concluants, on peut vérifier que Docker est capable de télécharger et d’exécuter un conteneur. Dans un terminal

$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
4f55086f7dd0: Pull complete
d5e71e642bf5: Download complete
Digest: sha256:5e23090353324d887c48ad5e5c56d294eab81588df9605b07d1afe895f9cc8f8
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/

For more examples and ideas, visit:
https://docs.docker.com/get-started/

Utiliser Docker

On lance un container Docker avec la commande docker run avec les options -it et le nom de l’image à exécuter. Par exemple, pour lancer un conteneur Ubuntu en mode interactif, on peut utiliser la commande suivante dans un terminal de la machine hôte

$ docker run -it --name myubuntu ubuntu:latest

Ce que fait cette commande :

  • docker run : crée et démarre un conteneur.

  • -it : active le mode interactif avec un terminal (i = interactif, t = terminal).

  • --name myubuntu : donne un nom au conteneur (optionnel)

  • ubuntu:latest : télécharge l’image officielle d’Ubuntu depuis le Docker Hub (si elle n’est pas déjà présente sur le disque) et la lance.

Comme c’est une image Ubuntu minimale, les outils habituels comme Python ou Git ne sont pas installés de base. Vous devez utiliser apt pour les installer.

root@8fcb78d39a0e:/# apt update                          # mettre à jour le gestionnaire de paquets
root@8fcb78d39a0e:/# apt install -y python3              # installer Python 3

On peut ensuite vérifier que Python fonctionne correctement dans le conteneur.

root@8fcb78d39a0e:/# python3 --version

Pour sortir du conteneur et retourner dans le terminal de la machine hôte.

root@8fcb78d39a0e:/# exit

Pour vérifier que le conteneur existe toujours (à l’arrêt)

$ docker ps -a

Pour supprimer le conteneur et nettoyer votre machine

$ docker rm myubuntu

Tout ce qui a été installé est effacé avec le conteneur, laissant votre machine hôte parfaitement propre.

Pour le cours

Pour les exercices et les labs de ce cours, vous utiliserez le conteneur Docker préconfiguré dancou/esiee-e3-programmation:1.0 avec tous les outils nécessaires. Vous n’aurez donc pas besoin d’installer quoi que ce soit dans le conteneur.

Important

Ce qui suit permet de vérifier l’installation du conteneur Docker préconfiguré et de vérifier que les outils nécessaires sont bien présents.

POUR LES EXERCICES ET LES LABS, LE CONTAINER SERA LANCE AUTOMATIQUEMENT SI LES INSTRUCTIONS SONT CORRECTEMENT SUIVIES.

Lancer le conteneur Docker préconfiguré avec la commande suivante dans un terminal de la machine hôte

~  $ docker run -it "dancou/esiee-e3-programmation:1.0"
root@cf8d958d6dde:/workspace# whoami
root

  • la première ligne s’exécute dans le terminal de la machine hôte, avec le prompt ~ $ ;

  • la deuxième ligne s’exécute dans le terminal du conteneur Docker, avec le prompt root@cf8d958d6dde:/workspace# (la chaine hexadécimale est l’identifiant du conteneur et peut varier d’une exécution à l’autre) ;

  • on est administrateur du container, avec tous les droits sur le système de fichiers du container.

Le conteneur est préconfiguré avec les outils suivants

root@cf8d958d6dde:/workspace# git --version
git version 2.47.3

root@cf8d958d6dde:/workspace# gcc --version
gcc (Debian 14.2.0-19) 14.2.0
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

root@cf8d958d6dde:/workspace# python --version
Python 3.13.5

root@cf8d958d6dde:/workspace# uv --version
uv 0.11.26 (x86_64-unknown-linux-gnu)

root@cf8d958d6dde:/workspace# pytest --version
pytest 9.1.1

root@cf8d958d6dde:/workspace# ruff --version
ruff 0.15.20

Le container est préconfiguré avec un répertoire de travail /workspace qui est monté sur le répertoire de travail de la machine hôte. Ainsi, tout fichier créé ou modifié dans le conteneur sera également présent sur la machine hôte.

root@cf8d958d6dde:/workspace#

Test de connaissances

  • Un container Docker est une unité logicielle et portable.

  • Contrairement aux machines virtuelles, les containers partagent le de l’hôte.

  • Les trois avantages principaux des containers Docker sont l’isolation, la et la légereté.

  • La commande pour vérifier que Docker est correctement installé est .

  • La commande pour vérifier que Docker fonctionne est .

VS Code

VS Code est un environnement de développement intégré (IDE) qui permet d’éditer, compiler et exécuter du code source dans de nombreux langages de programmation. Il est disponible pour Windows, Linux et macOS.

Installation de VS Code

Installer VS Code sur votre machine hôte en suivant les instructions de la documentation officielle Download Visual Studio Code

Installer les extensions suivantes :

Vérifier que VS Code est correctement installé en lançant la commande code --version dans un terminal de la machine hôte. La version de VS Code doit s’afficher.

Pour profiter de la puissance de Visual Studio Code, consulter la documentation, et en particulier:

  • VS Code est un environnement de développement intégré ou .

  • L’extension permet d’éditer et déboguer du code Python dans VS Code.

  • L’extension fournit un analyseur statique avancé pour Python.

  • La commande pour vérifier que VS Code est installé est .

Git

Git est un système de contrôle de version distribué qui permet d’enregistrer l’historique des modifications d’un projet. Son utilisation conjointe avec GitHub/Gitlab permet de disposer d’un espace de stockage dans le cloud. Cet environnement sera utilisé pour évaluer les travaux pratiques.

Installation de Git

Installer Git sur votre machine hôte en suivant les instructions de la documentation officielle :

Vérifier que Git est correctement installé en lançant la commande git --version dans un terminal de la machine hôte. La version de Git doit s’afficher.

Synchronisation des repos local et distant

L’intérêt de Git est de pouvoir synchroniser un repo local avec un repo distant. Le repo local est celui qui est sur la machine hôte, le repo distant est celui qui est dans le cloud (GitLab). La synchronisation permet de disposer d’une sauvegarde dans le cloud.

Les principales commandes Git utilisées dans ce cours sont :

  • git add . pour ajouter tous les fichiers du répertoire courant à l’index Git ;

  • git commit -m "message" pour enregistrer les modifications dans le repo local ;

  • git push pour mettre à jour le repo distant avec les modifications locales.

  • Git est un système de contrôle de version .

  • GitHub et GitLab permettent de stocker les projets Git dans le .

  • La commande pour ajouter des fichiers à l’index Git est .

  • Un repository Git est un espace de stockage pour les modifications d’un projet.

Les labs

Ce cours est accompagné de labs qui permettent de mettre en pratique les concepts abordés. Ces labs sont disponibles dans un repo hébergé sur le serveur GitLab de l’ESIEE.

Forker le repo des labs

Forker un repo c’est copier un repo existant sur Gitlab pour en créer une copie parfaite dans son espace GitLab personnel. Il s’agit ici de créer une copie du repo commun dans votre espace GitLab personnel pour pouvoir travailler dessus sans interférer avec les travaux des autres étudiants, ni avec le repo commun.

Connectez vous sur https://git.esiee.fr/ avec vos identifiants ESIEE

Ouvrez le repo https://git.esiee.fr/esiee-cs/e3-programmation-labs-student, faites un fork en renseignant les champs suivants :

  • Project name : e3-programmation-labs-student

  • Project URL : https://git.esiee.fr/<STUDENT-LOGIN>/e3-programmation-labs-student

  • Branches to include : All branches

  • Visibility level : Public

  • Fork project

Astuce

<STUDENT-LOGIN> représente ici le login ESIEE. Par exemple, l’élève Adam Labrosse a pour login labrossa et son repo est disponible à l’URL https://git.esiee.fr/labrossa/e3-programmation-labs-student

Vous disposez maintenant de votre propre repo GitLab dans votre espace personnel. C’est dans cet espace que vous allez travailler

SSH

Le workflow va nécessiter des échanges entre votre machine hôte et votre repo GitLab personnel. Pour cela, il est nécessaire de configurer un accès sécurisé entre les deux. C’est le rôle du protocole SSH (Secure SHell) qui permet d’authentifier les machines et de protéger les communications grâce au chiffrement.

  • Quel est le rôle du protocole SSH dans les échanges entre votre machine hôte et GitLab ?

      1. Compresser les fichiers avant leur transfert

      1. Authentifier les machines et protéger les communications grâce au chiffrement

      1. Accélérer la connexion Internet

      1. Remplacer le protocole HTTP

  • Lorsqu’un utilisateur génère une paire de clés SSH, quel fichier doit-il copier sur le serveur ou dans son compte GitLab ?

      1. La clé privée

      1. La clé publique

      1. Les deux clés

      1. Aucun des deux

  • Pourquoi la clé privée ne doit-elle jamais être transmise au serveur lors d’une authentification SSH ?

      1. Parce qu’elle est trop volumineuse

      1. Parce que seule la clé publique est utilisée pour vérifier que le client possède bien la clé privée correspondante

      1. Parce que le serveur la possède déjà

      1. Parce qu’elle est recréée à chaque connexion

  • Que se passe-t-il si un utilisateur accepte sans vérification la clé publique d’un serveur inconnu lors de la première connexion ?

      1. Rien de particulier

      1. La connexion devient plus rapide

      1. Il risque de faire confiance à un attaquant qui se fait passer pour le serveur légitime

      1. Sa clé privée est automatiquement envoyée au serveur

  • Dans une authentification par clé publique, laquelle des affirmations suivantes est correcte ?

      1. La clé privée est envoyée au serveur pour être comparée.

      1. Le serveur vérifie que le client possède la clé privée correspondant à la clé publique enregistrée.

      1. Le serveur génère une nouvelle paire de clés à chaque connexion.

      1. Les clés publique et privée doivent être stockées sur le serveur.

  • Quel est l’avantage principal d’une authentification SSH par paire de clés par rapport à une authentification uniquement par mot de passe ?

      1. Elle permet de se connecter automatiquement sans saisir de mot de passe à chaque fois (si la clé est acceptée).

      1. Elle supprime le chiffrement des communications.

      1. Elle ne nécessite plus de compte utilisateur sur le serveur.

      1. Elle permet à plusieurs utilisateurs de partager la même clé privée.

Pour bénéficier d’une connexion sécurisée entre votre machine hôte et votre repo GitLab personnel, il est nécessaire de générer une paire de clés SSH sur votre machine hôte et d’ajouter la clé publique dans votre compte GitLab.

Générer une paire de clés SSH sur votre machine hôte

Consulter Use SSH keys with GitLab dont un résumé est donné ci dessous.

Ouvrir un terminal Git Bash (Windows) ou bash (Linux) sur votre machine hôte et suivre les instructions ci dessous.

SSH keys

Astuce

Voilà un résumé des commandes à exécuter et leur signification. Le caractère ~ représente le répertoire racine de l’utilisateur

ls ~/.ssh                     # lister le contenu du répertoire ~/.ssh
mkdir -p ~/.ssh               # créer le répertoire ~/.ssh s'il n'existe pas
cat ~/.ssh/id_ed25519.pub     # afficher la clé publique si elle existe
ssh-keygen -t ed25519         # générer une nouvelle paire de clés SSH

Copier la clé publique dans votre compte GitLab

Il existe maintenant une paire de clés SSH sur votre machine hôte. L’étape suivante consiste à copier la clé publique dans votre compte GitLab. Un résumé de la procédure décrite dans Use SSH keys with GitLab est donné ci dessous.

  • Sign in to GitLab.

  • In the upper-right corner, select your avatar.

  • Select Edit profile.

  • In the left sidebar, select Access > SSH keys.

  • Select Add new key.

  • In the Key box, paste the contents of your public key

  • In the Title box, type a description, like Work Laptop or Home Workstation.

Vérifier la connexion SSH avec le serveur

Exécuter la commande suivante dans un terminal de votre machine hôte pour vérifier que la connexion SSH avec le serveur GitLab est opérationnelle

ssh -T git@git.esiee.fr

Lors de la première connexion, votre machine hôte ne connait pas le serveur et vous devez manuellement accepter la clé publique du serveur. Le message affiché dans le terminal est semblable à celui ci (le hostname, l’adresse IP et la clé seront ceux du serveur GitLab de l’ESIEE)

The authenticity of host 'git.esiee.fr (xxx.xxx.xxx.xxx)' can't be established.
ECDSA key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no)?
You should receive a welcome message.

Si la connexion SSH est opérationnelle, vous devez recevoir un message de bienvenue du serveur semblable à celui ci

Welcome to GitLab, @<STUDENT-LOGIN>!

Cloner le repo des labs dans votre espace personnel

Vous disposez à cette étape de votre propre repo dans votre espace personnel GitLab et d’une connexion SSH active. Il est maintenant nécessaire de le cloner sur votre machine hôte pour pouvoir travailler dessus. Pour cela, ouvrir un terminal sur la machine hôte, se placer dans le répertoire e3-programmation créé précédemment, puis exécuter la commande suivante

git clone git@git.esiee.fr:<STUDENT-LOGIN>/e3-programmation-labs-student.git .

Astuce

Si vous rencontrez des problèmes pour établir la connexion SSH avec le serveur GitLab, vous pouver utiliser le protocole HTTPS. Une authentification par mot de passe sera alors nécessaire.

git clone https://git.esiee.fr/<STUDENT-LOGIN>/e3-programmation-labs-student.git

L’environnement de travail est résumé dans le schéma ci dessous.

Cloner le repo

Mettre à jour le repo local avec les modifications du prof

Ce repo est susceptible d’être modifié par l’enseignant (ajout ou modification de labs) au cours du semestre. Vous en serez averti par un message sur la page d’accueil du cours. Il faut établir la connexion entre le repo local et le repo « prof » (upstream). Cette opération n’est à faire qu’une seule fois.

Se placer à la racine du repo local

$ cd e3-programmation-labs-student

Etablir le lien avec le repo « prof » (upstream) en exécutant la commande suivante

$ git remote add upstream https://git.esiee.fr/esiee-cs/e3-programmation-labs-student.git

Après l’ajout

$ git remote -v
origin    git@git.esiee.fr:<login>/e3-programmation-labs-student.git (fetch)
origin    git@git.esiee.fr:<login>/e3-programmation-labs-student.git (push)
upstream  git@git.esiee.fr:esiee-cs/e3-programmation-labs-student.git (fetch)
upstream  git@git.esiee.fr:esiee-cs/e3-programmation-labs-student.git (push)

La figure ci dessous résume l’environnement de travail après l’ajout du repo « prof » (upstream).

architecture des repos

Note

La procédure pour récupérer les modifications vous serez détaillée chaque fois qu’une mise à jour sera disponible.

Validation de l’environnement

Pour vérifier que l’environnement de travail est opérationnel sur la machine hôte, nous allons écrire un premier programme simple dans les deux langages que nous allons utiliser dans ce cours.

Ouvrir VS Code sur la machine hôte :

  • File > Open Folder... puis sélectionner le répertoire de travail e3-programmation-labs-student ;

  • Sélectionner Reopen in Container pour lancer le container Docker. Cette opération peut prendre quelques minutes la première fois que le container est lancé, car il faut télécharger l’image Docker et installer les outils nécessaires. Les accès suivants sont plus rapides.

L’environnement de travail est prêt.

Premier programme C (sans IA)

Il est nécessaire que VS Code soit démarré sur la machine hôte, pointe vers le répertoire e3-programmation-labs-student et que le container Docker soit lancé.

Créer un fichier exercices/hello.c et y placer le code source du programme C ci dessous.

1#include <stdio.h>
2
3int main(){
4    printf("Hello World !\n");
5    return 0;
6}

Dans un terminal, compiler et exécuter le programme pour vérifier que l’environnement de travail est opérationnel

$ gcc -std=c99 -Wall -Wextra hello.c -o hello
$ ./hello
Hello World !
Premier programme Python (sans IA)

Il est nécessaire que VS Code soit démarré sur la machine hôte, pointe vers le répertoire e3-programmation-labs-student et que le container Docker soit lancé.

Créer un fichier exercices/hello.py et y placer le code source du programme Python ci dessous.

1print("Hello World !")

Dans un terminal, exécuter le programme pour vérifier que l’environnement de travail est opérationnel

$ python3 hello.py
Hello World !
Synchronisation avec le repo distant

Il est nécessaire que VS Code soit démarré sur la machine hôte, pointe vers le répertoire e3-programmation-labs-student et que le container Docker soit lancé.

Les fichiers hello.c et hello.py ont été créés dans le repo local qui est donc « en avance » sur le repo distant (il contient des modifications qui ne sont pas sur le repo distant). Il est donc nécessaire de synchroniser ces deux repos.

Dans un terminal, depuis la racine du répertoire de travail, exécuter les commandes suivantes

$ git add . # ajouter tous les fichiers modifiés à l'index Git
$ git commit -m "add hello.c and hello.py" # enregistrer les modifications dans le repo local
$ git push

Vérifier que le repo distant est bien à jour en vous connectant sur votre compte GitLab et en ouvrant le repo e3-programmation-labs-student. Les fichiers hello.c et hello.py doivent être présents.

✨ Si vous rencontrez des difficultés, soumettez les messages d’erreur à l’IA.

  • Pour exécuter le code Python enregistré dans le fichier program.py, on utilise la commande

  • Pour compiler le code C enregistré dans le fichier program.c, on utilise la commande

  • Pour exécuter le programme généré à l’étape précédente on utilise la commande pour exécuter le programme compilé.

  • Pour ajouter des fichiers à l’index Git, on utilise la commande

  • Pour enregistrer les modifications dans le repo local, on utilise la commande

  • L’option -m de la commande permet de spécifier un message explicatif

  • Pour mettre à jour le repo distant avec les modifications locales, on utilise la commande

  • Chaque modification importante doit être synchronisée avec le repo via

  • Sur Windows, pour disposer d’un vrai noyau Linux, il faut installer

  • Pour initialiser un répertoire de travail dans VS Code, on utilise

  • Pour afficher le terminal dans VS Code, on utilise

FAQ

  1. VS Code ne propose pas l’option Reopen in Container. Que faire ?

  2. Vérifier que l’extension « Dev Containers » est bien installée. Si ce n’est pas le cas, l’installer depuis le marketplace de VS Code comme indiqué dans le paragraphe VS Code.

  1. Il semble que WSL ne soit pas installé. Que faire ?

  2. Si votre machine tourne sous macOS, c’est normal, WSL n’est requis que sur Windows. Si votre machine tourne sous Windows, vérifier dans un terminal PowerShell que wsl --version fonctionne. Sinon, installer WSL avec wsl --install.

  1. docker run -it "dancou/esiee-e3-programmation:1.2" ne fonctionne pas. Que faire ?

  2. Sous Windows, vérifier dans les paramètres de l’application Docker Desktop que l’option « WSL 2 » activée. Vérifier ensuite que le service est bien démarré avec wsl --list --verbose. docker-desktop doit être démarré et en état Running. Si ce n’est pas le cas, redémarrer l’application Docker Desktop ou exécuter wsl -d docker-desktop dans un terminal PowerShell.

  1. J’obtiens l’erreur docker: Error response from daemon: timed out waiting for /mnt/wslg/runtime-dir/wayland-0 to be automounted. Que faire ?

  2. Dans les paramètres de VS Code (File > Preferences > Settings), « Dev Containers: Settings », décocher Dev > Containers: Mount Wayland Socket

  1. A la compilation d’un programme C, j’obtiens l’erreur fatal error: stdio.h: No such file or directory. Que faire ?

  2. Vérifier dans .devcontainers/devcontainer.json, que le container est bien basé sur l’image Docker dancou/esiee-e3-programmation:1.2. Si ce n’est pas le cas, modifier le fichier et relancer le container avec Reopen in Container.

  1. Je peux faire un git push depuis le terminal de la machine hôte, mais pas depuis le terminal du container. Que faire ?

  2. Il faut ajouter un agent SSH dans la machine hôte que VS Code partagera automatiquement avec le container. Pour cela, ouvrir un terminal PowerShell en mode administrateur sur la machine hôte Windows.

Installer et démarrer le service ssh-agent

> Get-Service ssh-agent | Set-Service -StartupType Automatic
> Start-Service ssh-agent

Vérifier que le service est bien démarré

> Get-Service ssh-agent

Status   Name               DisplayName
------   ----               -----------
Running  ssh-agent          OpenSSH Authentication Agent

Ajouter la clé privée SSH à l’agent

> ssh-add $env:USERPROFILE\.ssh\id_ed25519
Identity added: <$env:USERPROFILE>\.ssh.\id_ed25519 (<nom.prenom>@esiee.fr)