diff --git a/0 - git/01-pratique01-git.md b/0 - git/01-pratique01-git.md new file mode 100644 index 0000000..2c708f0 --- /dev/null +++ b/0 - git/01-pratique01-git.md @@ -0,0 +1,231 @@ +# pratique 01 - Guide de démarrage rapide avec Git + +# Objectif + +- Ce guide fournit une série de commandes Git de base pour initialiser un dépôt, ajouter des fichiers, configurer les informations d'utilisateur, et pousser les changements vers un dépôt distant. + +# Étapes + +# 1. Initialiser un dépôt Git + +Commencez par initialiser un nouveau dépôt Git dans votre répertoire de projet : + +```bash +git init +``` + +# 2. Vérifier l'état du dépôt + +Vous pouvez vérifier l'état de votre dépôt à tout moment avec : + +```bash +git status +``` + +# 3. Créer des fichiers + +Créez trois fichiers nommés `page1.txt`, `page2.txt`, et `page3.txt` : + +```bash +touch page1.txt page2.txt page3.txt +``` + +# 4. Vérifier à nouveau l'état + +Après avoir créé les fichiers, vérifiez l'état du dépôt : + +```bash +git status +``` + +# 5. Ajouter les fichiers à l'index + +Ajoutez tous les fichiers créés à l'index (staging area) : + +```bash +git add . +``` + +# 6. Vérifier l'état après ajout + +Vérifiez l'état du dépôt après avoir ajouté les fichiers : + +```bash +git status +``` + +# 7. Configurer les informations utilisateur globales + +Configurez votre nom et email utilisateur globalement : + +```bash +git config --global user.name "hrhouma" +git config --global user.email "rehoumahaythem@gmail.com" +``` + +## Remarque : +- Vous pouvez remplacer "hrhouma" et "rehoumahaythem@gmail.com" par votre utilisateur global à vous + +# 8. Configurer les informations utilisateur locales + +Configurez des informations utilisateur spécifiques à ce dépôt : + +```bash +git config --local user.name "dev" +git config --local user.email "dev_alex@gmail.com" +``` +- Vous pouvez remplacer "dev" et "dev_alex@gmail.com" par votre utilisateur local à vous + +# 9. Commit des fichiers + +Enregistrez les modifications avec un message de commit : + +```bash +git commit -m "Ajout des pages page1.txt page2.txt page3.txt" +``` + +# 10. Vérifier l'état après le commit + +Vérifiez l'état de votre dépôt après avoir effectué le commit : + +```bash +git status +``` + +# 11. Ajouter un dépôt distant + +Ajoutez un dépôt distant nommé `origin` : + +```bash +git remote add origin https://github.com/hrhouma/monsupersite.git +``` +- Vous pouvez remplacer "https://github.com/hrhouma/monsupersite.git" par votre URL à vous + +# 12. Renommer la branche principale + +Renommez la branche principale en `master` : + +```bash +git branch -M master +``` + +# 13. Pousser les changements vers le dépôt distant + +Poussez vos changements vers la branche `master` sur le dépôt distant : + +```bash +git push -u origin master +``` + +# 14. Vérifier la configuration Git + +Pour voir la configuration actuelle de votre dépôt, utilisez : + +```bash +cat .git/config +``` + + + +# point de vulgarisation: + + +- Ajouter des fichiers à l'index dans Git (git add . ou ce que nous appelons le staging area), c'est un peu comme préparer une valise avant un voyage. +- Imaginons que tu prépares un voyage (le commit) et que tu as plusieurs objets (les fichiers) éparpillés dans ta chambre. Avant de partir, tu veux t'assurer que tous les objets que tu veux emporter sont bien dans ta valise. +- Ajouter des fichiers à l'index avec `git add`, c'est comme mettre ces objets dans la valise. Cela signifie que tu es prêt à les emporter avec toi lors de ton voyage, c'est-à-dire lors du commit. +- Donc, l'index (ou "staging area") est comme ta valise de préparation : tu y mets tout ce que tu veux emporter dans ton prochain voyage, et une fois que tout est prêt, tu fermes la valise et tu pars, c'est-à-dire que tu fais le commit. + +En résumé : +- **Git add** = Mettre des fichiers dans la valise (index). +- **Git commit** = Fermer la valise et partir en voyage (enregistrer les changements). + +- Cela permet d'avoir un contrôle sur ce que tu veux vraiment inclure ou non dans le commit final, exactement comme tu choisirais soigneusement ce que tu veux emporter pour ton voyage. + + +- Le `git push`, c'est comme envoyer ta valise à la maison de vacances (le dépôt distant). +- Continuons avec l'analogie du voyage. Après avoir fermé ta valise (fait le commit), tu dois l'envoyer à ta destination finale, par exemple, une maison de vacances (ton dépôt distant, comme GitHub). Le `git push`, c'est l'action d'envoyer ta valise (tes changements) à cette destination. +- En d'autres termes, `git push` prend toutes les modifications que tu as préparées et enregistrées (dans ta valise) et les envoie à un endroit accessible à d'autres personnes (comme un dépôt sur GitHub), pour que tout le monde puisse y accéder, les voir, ou les utiliser. + +Donc, en résumé : +- **Git add** = Mettre des fichiers dans la valise (préparer les changements). +- **Git commit** = Fermer la valise (enregistrer les changements). +- **Git push** = Envoyer la valise à ta destination (partager les changements avec tout le monde). + +C'est comme si tu avais travaillé sur un projet dans ta chambre (ton dépôt local), puis que tu envoyais tout ton travail (les fichiers) à l'endroit où tes collègues peuvent le récupérer et continuer à travailler dessus. + + + +| **Commande Git** | **Action Git** | **Analogie de la valise** | **Description en vrai vie** | +|------------------|----------------------------------------|---------------------------------------------------------------------|---------------------------------------------------------------| +| `git add` | Ajouter les fichiers à l'index | Mettre des objets dans la valise | Préparer les fichiers à être inclus dans le prochain commit | +| `git commit` | Enregistrer les changements | Fermer la valise et la préparer pour le voyage | Enregistrer définitivement les changements dans le dépôt local | +| `git push` | Envoyer les changements vers un dépôt distant | Envoyer la valise à la maison de vacances (destination finale) | Partager les changements avec d'autres en les envoyant sur un dépôt distant (comme GitHub) | + +### Explication détaillée : + +- **Git add** : Imagine que tu choisis des vêtements et des objets pour un voyage. En les mettant dans la valise, tu te prépares à emporter ces articles. Avec `git add`, tu fais la même chose pour tes fichiers : tu les "prépares" à être inclus dans le commit. + +- **Git commit** : Une fois ta valise bien remplie, tu la fermes et la prépares à être envoyée. Cela signifie que tout ce que tu as mis dans la valise est prêt et ne peut plus être changé. En faisant `git commit`, tu enregistres tous les fichiers ajoutés pour qu'ils soient une partie permanente de l'historique de ton projet. + +- **Git push** : Enfin, tu envoies ta valise à ta destination de vacances. Tes amis ou ta famille peuvent ouvrir la valise et utiliser ce que tu y as mis. Avec `git push`, tu envoies tes commits vers un dépôt distant, comme GitHub, où d'autres peuvent accéder à ton travail. + + +# Résumé : l'analogie de la valise : + +``` + +------------------+ + | Dossier Projet | +------------------+ + | (Local) | | Maison de Vacances| + +--------+----------+ | (Dépôt Distant) | + | +---------+--------+ + | | + git init | | + V | + +--------+----------+ | + | Répertoire Git | | + | Initialisé | | + +--------+----------+ | + | | + Créer | | + des fichiers| | + V | + +------------+-------------+ | + | page1.txt, page2.txt, | | + | page3.txt | | + +------------+-------------+ | + | | + git add | | + . | | + V | + +------------+-------------+ | + | Fichiers ajoutés dans | | + | l'index (valise) | | + +------------+-------------+ | + | | + git commit | | + -m "Ajout des| | + pages" V | + +------------+-------------+ | + | Valise (commit) fermée | | + | et prête pour le voyage | | + +------------+-------------+ | + | | + git push | | + V V + +--------+----------+ +---------+--------+ + | Fichiers envoyés |------------| Fichiers reçus | + | à la destination | | à la destination | + | (Dépôt Distant) | | (Dépôt Distant) | + +------------------+ +------------------+ +``` + +### Légende : +- **Dossier Projet (Local)** : Le répertoire où vous travaillez sur votre projet localement. +- **Maison de Vacances (Dépôt Distant)** : Le dépôt distant comme GitHub où vous envoyez votre travail. +- **Répertoire Git Initialisé** : Le dossier de projet qui a été initialisé pour utiliser Git. +- **Fichiers** : Les fichiers que vous créez et ajoutez à votre projet. +- **Index (Valise)** : L’endroit où vous préparez les fichiers pour les commits. +- **Commit** : L'action de fermer la valise, enregistrant définitivement les changements. +- **Push** : L'action d'envoyer la valise (vos commits) à la destination finale, où d'autres peuvent y accéder. + +Ce schéma vous aide à visualiser comment chaque commande Git fonctionne dans le processus de gestion des fichiers et des versions dans un projet. diff --git a/0 - git/02-pratique02-git.md b/0 - git/02-pratique02-git.md new file mode 100644 index 0000000..51a1d96 --- /dev/null +++ b/0 - git/02-pratique02-git.md @@ -0,0 +1,507 @@ +# L'histoire d'Eric : Un développeur passionné et ses amis + +Eric (vous dans cet exercice) est un développeur passionné par la technologie. Désireux de créer un CV qui reflète son parcours professionnel et ses compétences, il décide de se lancer dans ce projet. Mais Eric n'est pas seul dans cette aventure : ses amis, à gauche et à droite, l'accompagnent pour lui donner des recommandations et des conseils précieux tout au long du processus. + +- Voici comment Eric et ses amis construisent ensemble un CV remarquable à travers les commandes Git. + +## Projet : La création du CV d'Eric + +### 1. Créer un nouveau répertoire appelé `monCV` + +Eric commence par créer un nouvel espace de travail pour son projet de CV : + +```bash +mkdir monCV +``` + +### 2. Naviguer dans le répertoire `monCV` + +Il entre ensuite dans ce répertoire pour commencer à travailler : + +```bash +cd monCV +``` + +### 3. Initialiser un dépôt Git + +Pour suivre l'évolution de son CV, Eric initialise un dépôt Git local dans ce répertoire : + +```bash +git init +``` + +### 4. Vérifier l'état du dépôt + +Il vérifie l'état actuel du dépôt pour voir ce qui est suivi ou non : + +```bash +git status +``` + +### 5. Configurer les informations utilisateur globales + +Eric configure son nom et son email utilisateur globalement afin que chaque changement qu'il apportera à son CV soit correctement identifié : + +```bash +git config --global user.name "votreUserGithub" +git config --global user.email "votreVraiEmailGithub" +``` + +### exemple : + +Pour Eric : +```bash +git config --global user.name "eric-michaud" +git config --global user.email "michaud_e@hotmail.com" +``` + +Remplacez les commandes ci-dessus par les informations d'utilisateur appropriées lorsque vous changez d'utilisateur. Si vous avez besoin de changer fréquemment d'utilisateur, vous pouvez créer différents profils Git ou utiliser un script pour automatiser les changements de configuration (**Voir** *Annexe1*). + +### 6. Créer un fichier pour commencer à rédiger le CV + +Il crée un fichier appelé `cvEric.txt` pour commencer à raconter son histoire professionnelle : + +```bash +touch cvEric.txt +``` + +### 7. Vérifier à nouveau l'état du dépôt + +Après avoir créé le fichier, Eric vérifie l'état du dépôt pour voir où il en est : + +```bash +git status +``` + +### 8. Ajouter le fichier à l'index + +Eric ajoute le fichier `cvEric.txt` à l'index pour que son travail soit sauvegardé et prêt à être partagé : + +```bash +git add cvEric.txt +``` + +### 9. Vérifier l'état après ajout + +Il vérifie l'état du dépôt après avoir ajouté le fichier pour s'assurer que tout est en ordre : + +```bash +git status +``` + +### 10. Configurer les informations utilisateur locales + +Eric configure des informations utilisateur spécifiques à ce dépôt pour personnaliser davantage son projet : + +```bash +git config --local user.name "votreUserGithub" +git config --local user.email "votreVraiEmailGithub" +``` + +### 11. Commit des fichiers + +Il enregistre les modifications avec un message de commit, scellant ainsi la première version de son CV : + +```bash +git commit -m "The journey begins: First draft of my CV added" +``` + +### 12. Ajouter un dépôt distant + +Eric ajoute un dépôt distant pour partager son CV avec le monde : + +```bash +git remote add origin VOTRE_URL +``` +- Remplacez "VOTRE_URL" par l'URL de votre dépôt GitHub. + +### 13. Renommer la branche principale + +Il renomme la branche principale en `main`, marquant le début officiel de son projet : + +```bash +git branch -M main +``` + +### 14. Pousser les changements vers le dépôt distant + +Eric pousse ses changements vers la branche `main` sur le dépôt distant, lançant ainsi son CV dans l'univers numérique : + +```bash +git push -u origin main +``` + +### 15. Écrire une introduction avec l'aide de son ami à gauche + +Eric commence à écrire une introduction pour que les lecteurs puissent mieux le connaître. Son ami à gauche lui donne des conseils pour rendre cette introduction plus captivante : + +```bash +echo "Bonjour, je suis Sébastien et je recommande Eric. C'est un développeur passionné par la technologie." >> cvEric.txt +``` + +### 16. Configurer les informations utilisateur de son ami à gauche + +Pour refléter l'aide précieuse de son ami à gauche, Eric configure les informations utilisateur de ce dernier : + +```bash +git config --local user.name "usernameamiacotedevousa-gauche" +git config --local user.email "EmailGithubdevotreamiacotedevousa-gauche" +``` + +### exemple : + + +Pour Sébastien (sgag-2-6): +```bash +git config --global user.name "sgag-2-6" +git config --global user.email "seb.s.gag@gmail.com" +``` + + +### 17. Commit de l'introduction ajoutée + +Il scelle cette belle introduction dans un commit, honorant l'aide de son ami : + +```bash +git add . +git status +git commit -m "A friend's touch: Introduction added by l'ami à gauche" +git status +``` + +### 18. Pousser les changements vers le dépôt distant + +Eric pousse ces nouveaux changements vers le dépôt distant pour que cette introduction soit partagée avec tous : + +```bash +git push origin main +``` + +### 19. Ajouter des certifications et mises à jour des diplômes avec l'aide de son ami à droite + +Eric ajoute maintenant ses réalisations les plus significatives avec l'aide de son ami à droite, montrant ainsi ses compétences et qualifications : + +```bash +echo "Je suis Michael. Je vais ajouter des certifications au CV d'ERIC - AWS Certified Solutions Architect" >> cvEric.txt +``` + +### 20. Configurer les informations utilisateur de son ami à droite + +Pour refléter l'aide de son ami à droite, Eric configure les informations utilisateur de ce dernier : + +```bash +git config --local user.name "usernameamiacotedevousa-DROITE" +git config --local user.email "EmailGithubdevotreamiacotedevousa-DROITE" +``` + +### exemple : + +Pour Michael (HashMapScreft): +```bash +git config --global user.name "HashMapScreft" +git config --global user.email "screft@hotmail.com" +``` + +### 21. Commit des certifications et diplômes ajoutés + +Eric scelle cette étape importante dans un commit, posant une pierre angulaire dans l'édifice de sa carrière : + +```bash +git add . +git status +git commit -m "Milestones achieved: Certifications and diplomas added by l'ami à droite" +git status +``` + +### 22. Pousser les changements vers le dépôt distant + +Enfin, Eric pousse ces nouvelles réalisations vers le dépôt distant, complétant ainsi son CV pour qu'il soit prêt à impressionner le monde : + +```bash +git push origin main +``` + +--- + +Ainsi, Eric, avec l'aide de ses amis, a réussi à créer un CV qui non seulement reflète ses compétences et réalisations, mais aussi l'amitié et le soutien dont il a bénéficié tout au long de son parcours. Ce script raconte une histoire à travers les commandes Git, où chaque commit capture un moment significatif dans l'évolution du CV d'Eric. Les descriptions des commits ajoutent une touche narrative, transformant un simple projet technique en une aventure collaborative et enrichissante. + +# Résumé + +```bash +# Créer un nouveau répertoire appelé monCV +mkdir monCV + +# Naviguer dans le répertoire monCV +cd monCV + +# Initialiser un dépôt Git local dans le répertoire monCV +git init + +# Vérifier l'état actuel du dépôt Git (affiche les fichiers suivis et non suivis) +git status + +# Configurer votre nom d'utilisateur global pour Git +git config --global user.name "votreUserGithub" + +# Configurer votre adresse email globale pour Git +git config --global user.email "votreVraiEmailGithub" + +# Créer un nouveau fichier texte appelé cvEric.txt pour commencer à rédiger votre CV +touch cvEric.txt + +# Vérifier à nouveau l'état du dépôt Git (le fichier cvEric.txt apparaîtra comme non suivi) +git status + +# Ajouter le fichier cvEric.txt au suivi dans Git pour que votre travail soit sauvegardé et prêt à être partagé +git add cvEric.txt + +# Vérifier l'état du dépôt Git pour confirmer que cvEric.txt est maintenant suivi +git status + +# Configurer votre nom d'utilisateur local pour ce dépôt Git +git config --local user.name "votreUserGithub" + +# Configurer votre adresse email locale pour ce dépôt Git +git config --local user.email "votreVraiEmailGithub" + +# Effectuer un commit pour immortaliser la première version de votre CV, comme si vous graviez votre premier chapitre dans l'histoire de votre carrière +git commit -m "The journey begins: First draft of my CV added" + +# Ajouter une nouvelle origine distante pointant vers votre dépôt GitHub, où votre histoire numérique sera partagée avec le monde +git remote add origin VOTRE_URL + +# Renommer la branche actuelle en 'main' pour symboliser le début officiel de votre voyage +git branch -M main + +# Pousser le contenu de la branche 'main' vers l'origine distante, lançant ainsi votre CV dans l'univers numérique +git push -u origin main + +# Modification 1 : Vous commencez à écrire votre introduction, un premier aperçu de qui vous êtes et de vos aspirations +echo "Bonjour, je m'appelle Eric, et je suis un développeur passionné par la technologie. Voici une brève introduction sur moi." >> cvEric.txt + +# Configurer le nom d'utilisateur de votre ami à votre gauche pour ce dépôt Git +git config --local user.name "usernameamiacotedevousa-gauche" + +# Configurer l'adresse email de votre ami à votre gauche pour ce dépôt Git +git config --local user.email "EmailGithubdevotreamiacotedevousa-gauche" + +# Effectuer un commit pour capturer ce moment où votre ami vous aide à raconter votre histoire +git add . +git commit -m "A friend's touch: Introduction added by l'ami à gauche" + +# Pousser le contenu de la branche 'main' vers l'origine distante avec le nom de votre ami à gauche +git push origin main + +# Modification 2 : Vous ajoutez vos réalisations, les + + fruits de votre travail, pour montrer au monde ce que vous avez accompli +echo "Ajout des certifications : AWS Certified Solutions Architect, Google Cloud Professional Data Engineer. Mise à jour des diplômes : Master en Informatique." >> cvEric.txt + +# Configurer le nom d'utilisateur de votre ami à votre droite pour ce dépôt Git +git config --local user.name "usernameamiacotedevousa-DROITE" + +# Configurer l'adresse email de votre ami à votre droite pour ce dépôt Git +git config --local user.email "EmailGithubdevotreamiacotedevousa-DROITE" + +# Effectuer un commit pour immortaliser ces ajouts, comme si vous posiez une pierre angulaire dans l'édifice de votre carrière +git add . +git commit -m "Milestones achieved: Certifications and diplomas added by l'ami à droite" + +# Pousser le contenu de la branche 'main' vers l'origine distante avec le nom de votre ami à droite +git push origin main +``` + + + +# Exemple de configurations : + +Pour Eric : +```bash +git config --global user.name "eric-michaud" +git config --global user.email "michaud_e@hotmail.com" +``` + +Pour Sébastien (sgag-2-6): +```bash +git config --global user.name "sgag-2-6" +git config --global user.email "seb.s.gag@gmail.com" +``` + +Pour Michael (HashMapScreft): +```bash +git config --global user.name "HashMapScreft" +git config --global user.email "screft@hotmail.com" +``` + +---- + +# Annexe 1 : Automatiser la création des profils + +---- + + +Je vous propose un exemple de création de différents profils Git et d'un script pour automatiser les changements de configuration. + +### 1. Création de différents profils Git + +Vous pouvez créer des fichiers de configuration Git spécifiques à chaque utilisateur dans votre répertoire personnel. Par exemple : + +- **~/.gitconfig_eric** +```bash +[user] + name = eric-michaud + email = michaud_e@hotmail.com +``` + +- **~/.gitconfig_sebastien** +```bash +[user] + name = sgag-2-6 + email = seb.s.gag@gmail.com +``` + +- **~/.gitconfig_michael** +```bash +[user] + name = HashMapScreft + email = screft@hotmail.com +``` + +### 2. Script pour changer de profil + +Créez un script bash pour automatiser le changement de profil. Par exemple : + +**~/.change_git_profile.sh** +```bash +#!/bin/bash + +if [ "$1" == "eric" ]; then + cp ~/.gitconfig_eric ~/.gitconfig + echo "Profil Git changé pour Eric (eric-michaud)." +elif [ "$1" == "sebastien" ]; then + cp ~/.gitconfig_sebastien ~/.gitconfig + echo "Profil Git changé pour Sébastien (sgag-2-6)." +elif [ "$1" == "michael" ]; then + cp ~/.gitconfig_michael ~/.gitconfig + echo "Profil Git changé pour Michael (HashMapScreft)." +else + echo "Usage : $0 {eric|sebastien|michael}" +fi +``` + +### 3. Utilisation du script + +Donnez des permissions d'exécution au script et utilisez-le pour changer de profil : + +```bash +chmod +x ~/.change_git_profile.sh + +# Pour changer de profil à Eric +~/.change_git_profile.sh eric + +# Pour changer de profil à Sébastien +~/.change_git_profile.sh sebastien + +# Pour changer de profil à Michael +~/.change_git_profile.sh michael +``` + +Avec ce script, vous pouvez facilement changer de profil Git en exécutant une simple commande, ce qui est particulièrement utile si vous travaillez régulièrement avec plusieurs comptes GitHub. + +---- + +# Annexe 2 : Méthode 2 + +---- + + +- *Objectif* : créer les fichiers de configuration et le script nécessaire pour gérer plusieurs profils Git, en utilisant `sh ~/change_git_profile.sh` pour exécuter le script. + +### 1. Création des fichiers de configuration pour chaque profil +Ouvrez votre terminal et exécutez les commandes suivantes pour créer les fichiers de configuration pour chaque profil Git. + +**Pour Eric :** +```bash +cd ~ +cat << EOF > .gitconfig_eric +[user] + name = eric-michaud + email = michaud_e@hotmail.com +EOF +``` + +**Pour Sébastien :** +```bash +cat << EOF > .gitconfig_sebastien +[user] + name = sgag-2-6 + email = seb.s.gag@gmail.com +EOF +``` + +**Pour Michael :** +```bash +cat << EOF > .gitconfig_michael +[user] + name = HashMapScreft + email = screft@hotmail.com +EOF +``` + +### 2. Création du script pour changer de profil +Créez un script bash qui vous permettra de changer facilement de profil Git en fonction de l'utilisateur. + +```bash +cd ~ +cat << EOF > change_git_profile.sh +#!/bin/bash + +# Vérification de l'argument passé au script +if [ "\$1" == "eric" ]; then + cp ~/.gitconfig_eric ~/.gitconfig + echo "Profil Git changé pour Eric (eric-michaud)." +elif [ "\$1" == "sebastien" ]; then + cp ~/.gitconfig_sebastien ~/.gitconfig + echo "Profil Git changé pour Sébastien (sgag-2-6)." +elif [ "\$1" == "michael" ]; then + cp ~/.gitconfig_michael ~/.gitconfig + echo "Profil Git changé pour Michael (HashMapScreft)." +else + echo "Usage : \$0 {eric|sebastien|michael}" +fi +EOF +``` + +### 3. Rendre le script exécutable +Assurez-vous que le script est exécutable en utilisant la commande suivante : + +```bash +chmod +x ~/change_git_profile.sh +``` + +### 4. Utilisation du script +Vous pouvez maintenant utiliser le script pour changer de profil Git rapidement. Par exemple : + +**Pour changer au profil de Eric :** +```bash +sh ~/change_git_profile.sh eric +``` + +**Pour changer au profil de Sébastien :** +```bash +sh ~/change_git_profile.sh sebastien +``` + +**Pour changer au profil de Michael :** +```bash +sh ~/change_git_profile.sh michael +``` + +### 5. Validation de la configuration actuelle +Pour vérifier la configuration Git en cours après avoir changé de profil, vous pouvez exécuter : + +```bash +git config --global --list +``` + +Ce processus vous permet de gérer plusieurs profils Git de manière simple et efficace, avec la possibilité de passer d'un utilisateur à l'autre en fonction de vos besoins. diff --git a/0 - git/03-pratique03-branches.md b/0 - git/03-pratique03-branches.md new file mode 100644 index 0000000..502d216 --- /dev/null +++ b/0 - git/03-pratique03-branches.md @@ -0,0 +1,220 @@ +# L'histoire de Sébastien et ses coéquipiers : Collaborer avec Git pour créer un projet ensemble + +Sébastien, un étudiant en programmation, est très motivé par la gestion de projets en groupe. Il décide de créer un projet avec l'aide de ses amis Eric et Michael. Le projet consiste à développer une application web qui permet aux étudiants de partager leurs idées et ressources pour améliorer leur apprentissage. + +Sébastien, en tant que chef de projet, initie la première version du projet, et chaque membre de l'équipe travaille sur une fonctionnalité distincte à travers différentes branches Git. Voici comment Sébastien et son équipe collaborent pour mener à bien ce projet. + +--- + +## Projet : Application de partage pour les étudiants + +### 1. Créer un nouveau répertoire pour le projet + +Sébastien commence par créer un répertoire pour l'application web : + +```bash +mkdir partageEtudiants +cd partageEtudiants +``` + +### 2. Initialiser un dépôt Git + +Il initialise ensuite un dépôt Git pour suivre l'évolution du projet : + +```bash +git init +``` + +### 3. Configurer Git pour Sébastien + +Sébastien configure Git avec son nom d'utilisateur et son email : + +```bash +git config --global user.name "sgag-2-6" +git config --global user.email "seb.s.gag@gmail.com" +``` + +### 4. Créer la branche principale + +Sébastien crée une branche `main` pour représenter la version stable du projet : + +```bash +git branch -M main +``` + +### 5. Ajouter le premier fichier README + +Il crée un fichier README pour décrire le projet : + +```bash +echo "# Application de partage pour les étudiants" > README.md +git add README.md +git commit -m "Initial commit: Added README file" +``` + +### 6. Publier le projet sur un dépôt distant + +Sébastien configure un dépôt distant et pousse la branche `main` : + +```bash +git remote add origin +git push -u origin main +``` + +--- + +# Poste de Sébastien : Chef de projet + +### 7. Création d'une branche pour une nouvelle fonctionnalité par Sébastien + +Sébastien crée une nouvelle branche `interface` pour développer l'interface utilisateur de l'application : + +```bash +git checkout -b interface +``` + +### 8. Sébastien commence à travailler sur l'interface utilisateur + +Dans la branche `interface`, Sébastien crée les fichiers nécessaires pour l'interface utilisateur : + +```bash +mkdir ui +echo "

Bienvenue sur notre application de partage

" > ui/index.html +git add ui/index.html +git commit -m "Created the initial UI for the homepage" +``` + +### 9. Sébastien pousse ses changements sur la branche distante + +Sébastien pousse la branche `interface` vers le dépôt distant pour que les autres membres de l'équipe puissent y accéder : + +```bash +git push -u origin interface +``` + +--- + +# Poste d'Eric : Gestion des utilisateurs + + +### 10. Cloner le dépôt et créer une branche + +Eric, qui est responsable de la gestion des utilisateurs, doit d'abord cloner le dépôt avant de commencer : + +```bash +git clone +cd partageEtudiants +``` + +### 11. Configurer Git pour Eric + +Avant de commencer, Eric configure Git avec son nom d'utilisateur et son email : + +```bash +git config --global user.name "eric-michaud" +git config --global user.email "michaud_e@hotmail.com" +``` + +Ensuite, il met à jour sa copie locale de la branche `main` avant de créer une nouvelle branche `gestion-utilisateurs` : + +```bash +git pull origin main +git checkout -b gestion-utilisateurs +``` + +### 12. Eric ajoute la gestion des utilisateurs + +Dans la branche `gestion-utilisateurs`, Eric ajoute un fichier pour la gestion des utilisateurs : + +```bash +mkdir users +echo "module.exports = function registerUser() { console.log('User registered'); };" > users/user.js +git add users/user.js +git commit -m "Added user registration functionality" +git push -u origin gestion-utilisateurs +``` + +--- + +# Poste de Michael : Fonctionnalité de messagerie + + +### 13. Cloner le dépôt et créer une branche + +Michael suit les mêmes étapes pour cloner le dépôt et se synchroniser avec la branche `main` avant de créer sa propre branche `messaging` : + +```bash +git clone +cd partageEtudiants +git pull origin main +git checkout -b messaging +``` + +### 14. Configurer Git pour Michael + +Michael configure Git avec son nom d'utilisateur et son email : + +```bash +git config --global user.name "HashMapScreft" +git config --global user.email "screft@hotmail.com" +``` + +### 15. Michael ajoute la fonctionnalité de messagerie + +Il commence à travailler sur le backend de la messagerie : + +```bash +mkdir messaging +echo "module.exports = function sendMessage() { console.log('Message sent'); };" > messaging/message.js +git add messaging/message.js +git commit -m "Added messaging functionality" +git push -u origin messaging +``` + +--- + +# Poste de Sébastien : Chef de projet + +### 16. Mise à jour et fusion des branches dans `main` + +Avant de fusionner les branches de ses coéquipiers, Sébastien met à jour la branche `main` et se rébase sur les différentes branches créées par ses coéquipiers si nécessaire : + +```bash +git checkout main +git pull origin main +git rebase interface +git rebase gestion-utilisateurs +git rebase database +git rebase messaging +``` + +### 17. Sébastien fusionne les branches dans `main` + +Sébastien commence ensuite la fusion des branches dans `main` : + +```bash +git checkout main +git merge interface +git merge gestion-utilisateurs +git merge database +git merge messaging +``` + +### 18. Résolution des conflits (si nécessaire) + +Sébastien pourrait rencontrer des conflits lors de la fusion. Il résout les conflits et finalise la fusion. + +### 19. Pousser la version finale du projet + +Sébastien pousse la version finale sur la branche `main` : + +```bash +git push origin main +``` + +--- + +### Conclusion + +Grâce à cette approche collaborative utilisant des branches et des mises à jour régulières via `git pull` et `rebase`, Sébastien et son équipe ont réussi à créer une application de partage pour les étudiants. Chaque membre a pu travailler de manière indépendante sur sa fonctionnalité, puis les intégrer harmonieusement dans une version stable du projet. + diff --git a/0 - git/04-pratique04-git-merge-git-rebase.md b/0 - git/04-pratique04-git-merge-git-rebase.md new file mode 100644 index 0000000..84ff3d0 --- /dev/null +++ b/0 - git/04-pratique04-git-merge-git-rebase.md @@ -0,0 +1 @@ +https://medium.com/mindorks/understanding-git-merge-git-rebase-88e2afd42671 diff --git a/0 - git/05-pratique05-enonce.md b/0 - git/05-pratique05-enonce.md new file mode 100644 index 0000000..a614463 --- /dev/null +++ b/0 - git/05-pratique05-enonce.md @@ -0,0 +1,75 @@ +# TP #1 : La Chasse au Trésor Git + +## Contexte + +Dans ce projet, chaque étudiant contribuera à un dépôt Git partagé appelé **"La Chasse au Trésor"**. Le but est de placer des indices (ou des énigmes) dans le dépôt, que les autres étudiants devront résoudre pour progresser dans la chasse. Chaque indice mène au suivant. Les étudiants devront collaborer, résoudre des conflits Git, et interagir avec le dépôt tout en s'amusant ! + +## Prérequis + +- Connaissance de base de Git +- Accès au dépôt Git du projet "La Chasse au Trésor" +- Token fourni par le professeur + +## Instructions + +### 1. Préparation + +- Clonez le dépôt : + ```bash + git clone https://github.com/hrhouma/ChasseAuTresor.git + ``` +- Placez-vous dans le répertoire du projet : + ```bash + cd ChasseAuTresor + ``` + +### 2. Création de votre Énigme + +- Basculez vers une nouvelle branche avec votre nom : + ```bash + git checkout -b enigme_[votreNom] + ``` +- Créez un nouveau fichier avec votre nom : + ```bash + nano [votreNom].txt + ``` +- Écrivez une énigme amusante et sauvegardez. + +### 3. Publication de votre Énigme + +- Ajoutez et validez votre énigme : + ```bash + git add [votreNom].txt + git commit -m "Ajout de l'énigme de [votreNom]" + ``` +- Poussez votre branche vers le dépôt distant : + ```bash + git push origin enigme_[votreNom] + ``` + +### 4. Création d'une Pull Request + +- Accédez à votre dépôt GitHub et créez une pull request pour que votre branche soit fusionnée avec la branche `main`. +- Attendez que le chef de projet examine et fusionne votre pull request. + +### 5. Résolution d'Épreuves + +- Après que le chef de projet a fusionné votre pull request, basculez vers la branche `main` : + ```bash + git checkout main + ``` +- Mettez à jour votre branche : + ```bash + git pull origin main + ``` +- Tentez de résoudre au moins une énigme ajoutée par un camarade de classe. Lorsque vous trouvez la réponse, ajoutez-la à la fin du fichier correspondant. + +### 6. Scénario de Conflit + +- Imaginez que plusieurs étudiants travaillent simultanément sur le même fichier et que des conflits surviennent lors de la fusion des branches via une pull request. Le but est d'expérimenter la gestion des conflits Git dans un cadre collaboratif. + +## Objectifs d'Apprentissage + +- Comprendre les bases du travail collaboratif avec Git et GitHub. +- Expérimenter le processus de résolution de conflits. +- Encourager la communication et la collaboration entre étudiants. diff --git a/0 - git/05-pratique05-solution1.md b/0 - git/05-pratique05-solution1.md new file mode 100644 index 0000000..802c956 --- /dev/null +++ b/0 - git/05-pratique05-solution1.md @@ -0,0 +1,95 @@ +# SOLUTION - VARIANTE I (SANS CONFLITS) + +--- + +### La Chasse au Trésor Git avec Rebase + +---- + + +##### 1. Énigmes Individuelles + +Chaque étudiant crée sa propre énigme en suivant les étapes ci-dessous : + +**Léa :** + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Lea +echo "Je suis plein la journée, vide la nuit. Qui suis-je ?" > Lea.txt +git add Lea.txt +git commit -m "Ajout de l'énigme de Léa" +git push origin enigme_Lea +``` + +L'enseignant fusionne ensuite l'énigme de Léa avec la branche `main`. + +**Paul :** + +Paul suit les mêmes étapes pour créer et ajouter son énigme. + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Paul +echo "Plus je sèche, plus je deviens humide. Qui suis-je ?" > Paul.txt +git add Paul.txt +git commit -m "Ajout de l'énigme de Paul" +git push origin enigme_Paul +``` + +##### 2. Fusion de la Branche de Paul par l'Enseignant + +- L'enseignant fusionne la branche de Paul dans `main` pour intégrer sa solution avant que Marc ne commence à travailler. + +```bash +git checkout main +git pull origin main +git merge enigme_Paul +git push origin main +``` + +##### 3. Marc Réalise sa Réponse avec Rebase + +**Marc veut répondre à l'énigme de Léa.** Avant d'ajouter sa réponse, il met à jour sa branche avec `main`. + +- **Marc fait un `pull` pour s'assurer que sa branche est à jour** : + +```bash +git checkout enigme_Marc +git pull origin main # Mise à jour de sa branche avec les derniers changements de main +``` + +- Ensuite, **Marc effectue son rebase** pour s'assurer que son travail est basé sur la dernière version de `main` : + +```bash +git rebase origin/main +``` + +Dans ce cas, **comme Marc a fait un `git pull` suivi d'un `git rebase` sur la branche `main`, il n'y aura pas de conflit** lors de son travail, car sa branche est déjà alignée avec la dernière version de `main` contenant la réponse de Paul. + +**Marc ajoute ensuite sa réponse :** + +```bash +echo "Réponse de Marc : un sac" >> Lea.txt +git add Lea.txt +git commit -m "Marc résout l'énigme de Léa" +git push origin enigme_Marc +``` + +##### 4. Fusion de la Branche de Marc par l'Enseignant + +- Après que Marc a poussé sa solution, l'enseignant devra à nouveau fusionner cette branche dans `main`. + +```bash +git checkout main +git pull origin main +git merge enigme_Marc +git push origin main +``` + +--- + +**Conclusion :** +En résumé, si Marc met bien à jour sa branche avec `git pull origin main` avant de faire son rebase, il ne devrait pas rencontrer de conflits majeurs, car sa branche serait déjà alignée avec les changements récents intégrés par l'enseignant, y compris ceux de Paul. L'utilisation de `pull` suivie d'un `rebase` aide à maintenir une branche propre et minimise les conflits, rendant le processus de travail plus fluide. diff --git a/0 - git/05-pratique05-solution2.md b/0 - git/05-pratique05-solution2.md new file mode 100644 index 0000000..6430ced --- /dev/null +++ b/0 - git/05-pratique05-solution2.md @@ -0,0 +1,194 @@ +# SOLUTION - VARIANTE II (Avec un Conflit Garanti) + +--- + +### La Chasse au Trésor Git avec Rebase + +---- + + +# Objectif : Garantir un conflit à 100%, je vous propose un scénario qui illustre comment cela peut se produire : + +1. **Marc et Paul clonent le dépôt à peu près au même moment, mais ils travaillent indépendamment sur leurs branches sans se synchroniser avec `main` après que l'enseignant a fusionné la branche de Paul.** + +2. **Marc ne fait pas de `git pull` pour mettre à jour sa branche avant de faire son rebase ou son push.** + +3. **Marc pousse sa branche après que l'enseignant a fusionné la branche de Paul, ce qui provoquera un conflit lors de la fusion de la branche de Marc avec `main`.** + +--- + +# Étapes: + +---- + +# 1. Création des énigmes + +- Chaque étudiant crée sa propre énigme en suivant les étapes ci-dessous : + +**Léa :** + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Lea +echo "Je suis plein la journée, vide la nuit. Qui suis-je ?" > Lea.txt +git add Lea.txt +git commit -m "Ajout de l'énigme de Léa" +git push origin enigme_Lea +``` + +L'enseignant fusionne ensuite l'énigme de Léa avec la branche `main`. + +**Paul :** + +Paul suit les mêmes étapes pour créer et ajouter son énigme. + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Paul +echo "Plus je sèche, plus je deviens humide. Qui suis-je ?" > Paul.txt +git add Paul.txt +git commit -m "Ajout de l'énigme de Paul" +git push origin enigme_Paul +``` + +# 2. Fusion de la Branche de Paul par l'Enseignant + +- L'enseignant fusionne la branche de Paul dans `main` pour intégrer sa solution avant que Marc ne pousse son travail. + +```bash +git checkout main +git pull origin main +git merge enigme_Paul +git push origin main +``` + +# 3. Marc Réalise sa Réponse sans Mise à Jour + +**Marc clone le dépôt et commence à travailler sur sa branche en même temps que Paul ou avant la fusion de la branche de Paul dans `main`.** Marc ne fait **pas** de `pull` ou de `fetch` pour se synchroniser avec `main` avant de pousser sa branche. + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Marc +echo "Je vole sans ailes. Je pleure sans yeux. Partout je vais. Qui suis-je ?" > Marc.txt +git add Marc.txt +git commit -m "Ajout de l'énigme de Marc" +``` + +--- + +# TRÈS IMPORTANT : + +---- + +- Ces manipulations doivent se faire avant que l'ensignant fasse un pull request ou merge des changements de Paul dans la branche principale main !!!! + +**À ce stade, Marc n'est pas au courant des changements apportés par Paul, car il n'a pas mis à jour sa branche avec les derniers changements de `main`.** + +Marc ajoute ensuite sa réponse à l'énigme de Léa : + +```bash +echo "Réponse de Marc : un sac" >> Lea.txt +git add Lea.txt +git commit -m "Marc résout l'énigme de Léa" +``` + +##### 4. Marc Pousse sa Branche sans Rebase + +Marc pousse sa branche directement sans rebase ni pull : + +```bash +git push origin enigme_Marc +``` + +##### 5. Conflit lors de la Fusion par l'Enseignant + +- L'enseignant essaie de fusionner la branche de Marc avec `main`. Cependant, un conflit survient parce que les réponses de Paul et Marc modifient toutes deux `Lea.txt` à partir de versions de `main` qui sont différentes. + +```bash +git checkout main +git pull origin main +git merge enigme_Marc +# Conflit détecté dans Lea.txt ! +``` + +**Résolution du Conflit :** + +L'enseignant doit ouvrir `Lea.txt`, identifier les changements de Paul et Marc, et résoudre le conflit manuellement. + +```bash +nano Lea.txt # L'enseignant résout le conflit manuellement +git add Lea.txt +git commit -m "Résolution du conflit entre les réponses de Paul et Marc" +git push origin main +``` + +### Conclusion + +Dans ce scénario, le conflit est garanti car Marc n'a pas mis à jour sa branche avec les derniers changements de `main` avant de pousser son travail. Comme Marc et Paul ont tous deux modifié le même fichier (`Lea.txt`) dans des branches dérivées de versions différentes de `main`, cela provoque un conflit lorsqu'on tente de fusionner la branche de Marc avec `main`. + + + + + + + + + + +--- + +# Annexe : Rebase ? + +--- + + +# Question : +- Même si Marc effectue un rebase, n'est-ce pas qu'il va simplement se rebaser sur sa propre branche, sans intégrer les modifications de Paul, puisqu'il n'a pas fait de pull pour mettre à jour sa branche avec les derniers changements de `main` ? + +# Réponse: + +- Si Marc fait un `rebase` après avoir fait des modifications sans avoir d'abord mis à jour sa branche avec les derniers changements de `main`, le `rebase` se fera essentiellement sur lui-même, car sa branche n'aura pas les derniers changements de `main`. Cela ne résoudra pas le problème et ne préviendra pas le conflit. Pour garantir un conflit, voici ce qui se passe : + + + +##### 3. Marc Réalise sa Réponse sans Mise à Jour + +**Marc clone le dépôt et commence à travailler sur sa branche en même temps que Paul ou avant la fusion de la branche de Paul dans `main`.** + +Marc ne fait **pas** de `pull` ou de `fetch` pour se synchroniser avec `main` avant de faire son rebase ou son push. + +```bash +git clone https://github.com/hrhouma/ChasseAuTresor.git +cd ChasseAuTresor +git checkout -b enigme_Marc +echo "Je vole sans ailes. Je pleure sans yeux. Partout je vais. Qui suis-je ?" > Marc.txt +git add Marc.txt +git commit -m "Ajout de l'énigme de Marc" +``` + +- Marc ajoute ensuite sa réponse à l'énigme de Léa : + +```bash +echo "Réponse de Marc : un sac" >> Lea.txt +git add Lea.txt +git commit -m "Marc résout l'énigme de Léa" +``` + + +- Marc fait un `rebase`, mais comme il n'a pas mis à jour sa branche avec `main`, son `rebase` est inutile. Il se base seulement sur les changements de sa propre branche, sans intégrer les changements de Paul : + +```bash +git rebase origin/main # Ce rebase ne fait rien d'utile car il n'a pas fait de pull +git push origin enigme_Marc +``` + +**Même avec un `rebase`, Marc se rebase uniquement sur sa propre branche sans inclure les changements de `main`, ce qui garantit un conflit lors de la fusion.** + + + +### Conclusion + +En conclusion, même si Marc fait un `rebase`, tant qu'il n'a pas fait un `pull` ou un `fetch` pour se synchroniser avec la branche `main` après que Paul a poussé ses modifications, il y aura un conflit. Cela est dû au fait que Marc travaillera sur une ancienne version de `main`, et son `rebase` n'inclura pas les derniers changements, garantissant ainsi un conflit lors de la tentative de fusion par l'enseignant. diff --git a/0 - git/06-pratique06-suppression-accidentelle-dun-dossier.md b/0 - git/06-pratique06-suppression-accidentelle-dun-dossier.md new file mode 100644 index 0000000..6fb8fa5 --- /dev/null +++ b/0 - git/06-pratique06-suppression-accidentelle-dun-dossier.md @@ -0,0 +1,170 @@ +# Restauration du Répertoire `semaine3` + +## Contexte + +Haythem travaille sur un projet. Ce projet contient un répertoire nommé `semaine3` qui a été accidentellement supprimé dans un commit récent. Ce document décrit les étapes suivies pour restaurer ce répertoire à partir de l'historique Git. + +## Étapes de Restauration + +### 1. **Vérification de l'historique des commits** + +La première étape a consisté à vérifier l'historique des commits pour identifier le commit dans lequel le répertoire `semaine3` a été supprimé. + +```bash +git log -- semaine3/ +``` + +Cette commande a révélé que le commit `4839147759c6d18e051fc5672213e6fab2681445` a supprimé le répertoire `semaine3`. Les commits précédents ont été examinés pour trouver celui dans lequel le répertoire existait encore. + +### 2. **Identification du Dernier Commit où `semaine3` Existait** + +Le commit `b2dce13edae91ac81f196b8fb859337dd415ec2c` a été identifié comme étant le dernier commit où le répertoire `semaine3` existait avant sa suppression. + +### 3. **Restauration du Répertoire `semaine3`** + +Pour restaurer le répertoire `semaine3`, la commande suivante a été exécutée : + +```bash +git checkout b2dce13edae91ac81f196b8fb859337dd415ec2c -- semaine3/ +``` + +Cette commande a restauré tout le contenu du répertoire `semaine3` tel qu'il était dans le commit `b2dce13edae91ac81f196b8fb859337dd415ec2c`. + +### 4. **Vérification des Fichiers Restaurés** + +Après avoir restauré le répertoire, une vérification manuelle a été effectuée pour s'assurer que tous les fichiers attendus étaient présents dans `semaine3`. + +### 5. **Validation et Push des Changements** + +Une fois la restauration confirmée, les fichiers ont été ajoutés à l'index de Git et un commit a été créé pour valider la restauration : + +```bash +git add semaine3/ +git commit -m "Restauration du répertoire semaine3" +git push origin main +``` + +Ce commit a été poussé vers le dépôt distant, rendant le répertoire `semaine3` à nouveau disponible dans le projet. + +## Conclusion + +Ces étapes ont permis de restaurer avec succès le répertoire `semaine3` dans le projet. L'historique Git reste intact, et le répertoire est maintenant de nouveau disponible dans l'état où il était avant sa suppression. + +---- +---- +---- + +# ANNEXE PLUS DÉTAILLÉ - Histoire de la Restauration du Répertoire `semaine3` + +## Contexte + +Dans ce projet, le répertoire `semaine3`, contenant plusieurs fichiers importants, a été accidentellement supprimé dans un commit récent. Pour corriger cette erreur, nous avons utilisé les fonctionnalités de Git pour restaurer le répertoire à son état précédent. Ce document retrace les étapes suivies, les commandes exécutées, et les sorties obtenues lors de ce processus de restauration. + +## Étape 1 : Vérification de l'Historique des Commits + +Tout d'abord, il était nécessaire de comprendre quand et comment le répertoire `semaine3` avait été supprimé. Nous avons utilisé la commande suivante pour afficher l'historique des commits affectant ce répertoire : + +```bash +git log -- semaine3/ +``` + +### Sortie de la commande : +```plaintext +commit 4839147759c6d18e051fc5672213e6fab2681445 (HEAD -> main, origin/main, origin/HEAD) +Author: hrhouma1 +Date: Sun Sep 1 20:22:43 2024 -0400 + + Delete semaine3 directory + +commit b2dce13edae91ac81f196b8fb859337dd415ec2c +Author: hrhouma1 +Date: Sun Sep 1 20:22:30 2024 -0400 + + Create 03-DRAFT.md + +commit 40550a725338256a41048dec648093f83fbee3c9 +Author: hrhouma1 +Date: Sun Sep 1 20:12:48 2024 -0400 + + Update and rename 02.md to 02-SMB et Sécurisation du Trafic SMB.md + +commit de6e311f3724ccf9a01b8b66bb54cf4ed8d7a1b5 +Author: hrhouma1 +Date: Sun Sep 1 20:12:19 2024 -0400 + + Create 02.md + +commit 61b0b205885efaef93e6bc1cb5941841fb1c15af +Author: hrhouma1 +Date: Sun Sep 1 20:11:45 2024 -0400 + + Rename 01-cours.md to 01-Analyse des activités systèmes et réseaux.md +``` + +### Analyse : + +- Le commit `4839147759c6d18e051fc5672213e6fab2681445` est celui où le répertoire `semaine3` a été supprimé. +- Le commit précédent, `b2dce13edae91ac81f196b8fb859337dd415ec2c`, est celui où les fichiers dans `semaine3` étaient encore présents. + +## Étape 2 : Identification du Dernier Commit où `semaine3` Existait + +Nous avons identifié que le dernier commit avant la suppression était `b2dce13edae91ac81f196b8fb859337dd415ec2c`. C'est à partir de ce commit que nous allons restaurer le répertoire. + +## Étape 3 : Restauration du Répertoire `semaine3` + +Pour restaurer le répertoire supprimé, nous avons utilisé la commande suivante : + +```bash +git checkout b2dce13edae91ac81f196b8fb859337dd415ec2c -- semaine3/ +``` + +### Sortie de la commande : + +Cette commande ne produit pas de sortie visible si elle réussit, mais elle restaure les fichiers dans le répertoire `semaine3` dans l'état où ils étaient dans le commit `b2dce13edae91ac81f196b8fb859337dd415ec2c`. + +## Étape 4 : Vérification des Fichiers Restaurés + +Une fois le répertoire `semaine3` restauré, nous avons vérifié manuellement que tous les fichiers attendus étaient bien présents : + +- `01-Analyse des activités systèmes et réseaux.md` +- `02-SMB et Sécurisation du Trafic SMB.md` +- `03-DRAFT.md` +- `readme.md` + +Tous les fichiers ont été restaurés avec succès. + +## Étape 5 : Validation et Push des Changements + +Après avoir confirmé que tout était en ordre, nous avons ajouté les fichiers restaurés à l'index de Git et créé un nouveau commit pour valider ces changements : + +```bash +git add semaine3/ +git commit -m "Restauration du répertoire semaine3" +git push origin main +``` + +### Sortie de la commande `git commit` : +```plaintext +[main 789c1a7] Restauration du répertoire semaine3 + 4 files changed, 0 insertions(+), 0 deletions(-) + create mode 100644 semaine3/01-Analyse des activités systèmes et réseaux.md + create mode 100644 semaine3/02-SMB et Sécurisation du Trafic SMB.md + create mode 100644 semaine3/03-DRAFT.md + create mode 100644 semaine3/readme.md +``` + +### Sortie de la commande `git push` : +```plaintext +Enumerating objects: 6, done. +Counting objects: 100% (6/6), done. +Delta compression using up to 8 threads +Compressing objects: 100% (3/3), done. +Writing objects: 100% (4/4), 465 bytes | 465.00 KiB/s, done. +Total 4 (delta 0), reused 0 (delta 0) +To https://github.com/nom-utilisateur/nom-du-depot.git + 4839147..789c1a7 main -> main +``` + +## Conclusion + +Grâce à ces manipulations, nous avons pu restaurer avec succès le répertoire `semaine3` qui avait été accidentellement supprimé. Cette démarche montre l'importance de bien comprendre l'historique des commits dans Git et comment utiliser les commandes appropriées pour restaurer des éléments supprimés. En suivant ces étapes, vous pouvez éviter la perte de données et maintenir l'intégrité de votre projet. diff --git a/0 - git/FAQ/01-FAQ1-configuration.md b/0 - git/FAQ/01-FAQ1-configuration.md new file mode 100644 index 0000000..99027cc --- /dev/null +++ b/0 - git/FAQ/01-FAQ1-configuration.md @@ -0,0 +1,18 @@ +# FAQ sur la configuration Git + +### Question : +Si j'utilise la commande `git config --local user.name`, est-ce sécuritaire ? Une personne qui connaît mon nom d'utilisateur et mon email peut-elle se faire passer pour moi ? + +### Réponse : +Utiliser la commande `git config --local user.name` ou `git config --local user.email` n'est pas en soi une faille de sécurité. Ces commandes définissent des métadonnées dans votre dépôt local pour identifier qui a effectué des commits. Cependant, cela ne concerne pas l'authentification pour des actions telles que pousser des changements vers un dépôt distant comme GitHub. + +Voici les points à garder en tête : + +- **Authentification nécessaire** : Même si quelqu'un connaît votre nom d'utilisateur et votre email, il ne pourra pas accéder à votre compte GitHub sans une authentification, comme un jeton d'accès personnel ou une clé SSH. + +- **Commits falsifiés** : Si une personne a accès à votre dépôt local, elle peut théoriquement effectuer des commits sous votre nom. Cependant, pour pousser ces commits sur GitHub, elle aurait toujours besoin de vos identifiants d'authentification. + +- **Sécurité locale** : La sécurisation de votre environnement local (mot de passe fort, chiffrement des disques, etc.) est essentielle pour éviter toute modification non autorisée dans vos dépôts locaux. + +En résumé, connaître votre nom d'utilisateur et votre email ne permet pas à quelqu'un de se faire passer pour vous sur GitHub sans avoir également accès à vos mécanismes d'authentification. Assurez-vous de bien protéger vos identifiants et l'accès à votre machine. + diff --git a/0 - git/FAQ/02-FAQ2-ssh-keygen.md b/0 - git/FAQ/02-FAQ2-ssh-keygen.md new file mode 100644 index 0000000..cec51f5 --- /dev/null +++ b/0 - git/FAQ/02-FAQ2-ssh-keygen.md @@ -0,0 +1,117 @@ +# Tutoriel détaillé sur l’utilisation de `ssh-keygen` + +Ce tutoriel vous guide pas à pas dans l'utilisation de `ssh-keygen` pour configurer une authentification sécurisée avec des clés SSH pour interagir avec GitHub, sans avoir besoin d’entrer votre mot de passe à chaque fois. + +-------- +# Étape 1 : Générer une paire de clés SSH +-------- + +**Commande :** +```bash +ssh-keygen +``` +Cette commande génère une paire de clés RSA, composée d'une **clé publique** et d'une **clé privée**. Ces clés sont utilisées pour l'authentification SSH sécurisée. La **clé publique** peut être partagée librement tandis que la **clé privée** doit rester secrète et sécurisée sur votre machine. + +Vous allez être invité à : +- **Choisir l'emplacement** où enregistrer la clé. Par défaut, elle est enregistrée dans le dossier suivant : `/root/.ssh/id_rsa`. Si une clé existe déjà, vous pouvez choisir de la **remplacer** en tapant `y`. +- **Définir une passphrase** (facultatif). Si vous souhaitez sécuriser davantage la clé privée, vous pouvez définir une passphrase. Vous pouvez également laisser le champ vide si vous ne souhaitez pas de passphrase. + +Après la génération, les fichiers seront enregistrés ici : +- **Clé privée** : `/root/.ssh/id_rsa` +- **Clé publique** : `/root/.ssh/id_rsa.pub` + +-------- +# Étape 2 : Afficher la clé publique +-------- + +Une fois les clés générées, vous devrez copier la clé publique pour l’ajouter à GitHub. + +**Commande :** +```bash +cat /root/.ssh/id_rsa.pub +``` +Cela affichera le contenu de votre fichier de clé publique. Vous devez copier la sortie pour l'utiliser dans l'étape suivante. + + +-------- +# Étape 3 : Ajouter la clé publique à GitHub +-------- + +1. Allez dans les **paramètres** de votre dépôt GitHub. +2. Sélectionnez **Deploy keys** dans la barre de navigation gauche. +3. Cliquez sur **Add deploy key**. +4. Collez la clé publique que vous avez copiée dans le champ **Key**. +5. Donnez un titre à votre clé, par exemple **KeyProjetJava**. +6. Activez l'option **Allow write access** si vous avez besoin de pousser des changements vers ce dépôt. +7. Cliquez sur **Add key** pour enregistrer. + +-------- +# Étape 4 : Cloner le dépôt en utilisant SSH +-------- + +Maintenant que la clé SSH est ajoutée à GitHub, vous pouvez cloner votre dépôt sans avoir besoin de saisir de nom d'utilisateur ni de mot de passe. + +**Commande :** +```bash +git clone git@github.com:/.git +``` +Par exemple : +```bash +git clone git@github.com:hrhouma/ProjetJava.git +``` +Remplacez `` et `` par vos propres informations. + +-------- +# Étape 5 : Effectuer des opérations Git +-------- + +Une fois le dépôt cloné, naviguez dans le dossier du projet : +```bash +cd ProjetJava/ +``` + +Créez ou modifiez des fichiers, par exemple : +```bash +touch clara.json +``` + +Ajoutez et validez vos modifications : +```bash +git add clara.json +git commit -m "Ajout du fichier clara.json" +``` + +Poussez les modifications vers GitHub : +```bash +git push origin main +``` +Grâce à l'authentification par clé SSH, Git ne vous demandera plus de mot de passe. + +--- +# Annexe : Explication du fonctionnement des clés SSH +-------- +L'authentification par clé SSH repose sur une **clé publique** et une **clé privée**. Ce mécanisme de chiffrement asymétrique garantit une communication sécurisée entre deux systèmes. + +# 1. **Clé publique** et **Clé privée** + +- **Clé publique** : Elle est utilisée pour **chiffrer** les informations envoyées à un serveur. Vous pouvez la partager sans risque, car seule la clé privée correspondante peut déchiffrer les messages chiffrés avec la clé publique. + +- **Clé privée** : Elle reste sur votre machine et **ne doit jamais être partagée**. Cette clé privée sert à **décrypter** les messages chiffrés avec la clé publique, assurant ainsi que vous êtes le seul à pouvoir accéder aux données chiffrées. + +# 2. **Comment cela fonctionne-t-il ?** + +Imaginons un scénario où vous vous connectez à un serveur GitHub via SSH : + +1. Vous générez une paire de clés publique et privée avec `ssh-keygen`. +2. Vous **ajoutez la clé publique** sur GitHub. Elle sera utilisée pour chiffrer les demandes de connexion que GitHub vous enverra. +3. Lorsque vous essayez de vous connecter, GitHub envoie un message chiffré avec votre **clé publique**. +4. Vous utilisez votre **clé privée** pour déchiffrer ce message. Si le message est correctement déchiffré, cela prouve que vous possédez la clé privée correspondante à la clé publique, et GitHub vous autorise à accéder à votre dépôt. + +Ce système est extrêmement sécurisé, car même si quelqu'un intercepte la clé publique, il ne pourra pas déchiffrer les messages ou usurper votre identité sans la clé privée. + +# 3. **Avantages de l'authentification SSH avec des clés** + +- **Sécurité accrue** : Il est beaucoup plus difficile de compromettre une clé privée que de deviner un mot de passe. +- **Pas besoin de mot de passe** : Une fois configurée, l'authentification SSH par clé permet de se connecter sans mot de passe, ce qui est plus rapide et plus pratique. +- **Adapté pour l’automatisation** : Lors de l’utilisation de scripts ou d’outils automatisés (par exemple, CI/CD), l’authentification par clé SSH est plus pratique qu'un mot de passe. + diff --git a/0 - git/FAQ/README.md b/0 - git/FAQ/README.md new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/0 - git/FAQ/README.md @@ -0,0 +1 @@ + diff --git a/0 - git/PRATIQUE4 (Solution) - Travailler avec Rebase VS Merge.docx b/0 - git/PRATIQUE4 (Solution) - Travailler avec Rebase VS Merge.docx new file mode 100644 index 0000000..693c2dc Binary files /dev/null and b/0 - git/PRATIQUE4 (Solution) - Travailler avec Rebase VS Merge.docx differ diff --git a/0 - git/QUIZ/01-QUIZ01.md b/0 - git/QUIZ/01-QUIZ01.md new file mode 100644 index 0000000..526186b --- /dev/null +++ b/0 - git/QUIZ/01-QUIZ01.md @@ -0,0 +1,91 @@ +# QUIZ 1 (15 QUESTIONS) + +### 1. **Quelle commande utiliseriez-vous pour basculer vers une autre branche ?** + - A. `git switch [nom-de-branche]` + - B. `git branch [nom-de-branche]` + - C. `git checkout [nom-de-branche]` + - D. `git jump [nom-de-branche]` + +### 2. **Quelle commande Git est utilisée pour appliquer les derniers changements sauvegardés dans le stash sans les supprimer de la liste de stash ?** + - A. `git stash pop` + - B. `git stash apply` + - C. `git stash clear` + - D. `git stash save` + +### 3. **Vous souhaitez sauvegarder temporairement vos modifications locales sans les committer afin de pouvoir changer de branche. Quelle commande utilisez-vous ?** + - A. `git stash save` + - B. `git commit -m "temp"` + - C. `git pull` + - D. `git checkout -b` + +### 4. **Comment récupérez-vous les dernières modifications d'un dépôt distant et réappliquez-vous vos commits locaux sur la base de code mise à jour ?** + - A. `git merge` + - B. `git rebase` + - C. `git pull --rebase` + - D. `git fetch && git reapply` + +### 5. **Quelle commande utiliseriez-vous pour résoudre manuellement un conflit de fusion ?** + - A. `git resolve` + - B. `git merge --manual` + - C. `git add [fichier]` suivi de `git merge --continue` + - D. `git pull` + +### 6. **Comment rebaser la branche actuelle sur la branche master ?** + - A. `git rebase master` + - B. `git rebase --onto master` + - C. `git reapply master` + - D. `git pull --rebase master` + +### 7. **Si vous souhaitez fusionner une branche de fonctionnalité dans la branche master, quelle commande utilisez-vous ?** + - A. `git merge feature` + - B. `git pull feature` + - C. `git rebase feature` + - D. `git commit --merge feature` + +### 8. **Quelle commande Git utiliseriez-vous pour lister toutes les branches, locales et distantes ?** + - A. `git branch` + - B. `git branch --all` + - C. `git branch --remote` + - D. `git list branches` + +### 9. **Comment supprimer une branche locale dans Git ?** + - A. `git branch --delete [nom-de-branche]` + - B. `git remove [nom-de-branche]` + - C. `git delete [nom-de-branche]` + - D. `git branch -d [nom-de-branche]` + +### 10. **Vous êtes au milieu d'un rebase et réalisez que vous voulez l'arrêter et tout réinitialiser. Quelle commande devriez-vous utiliser ?** + - A. `git rebase --abort` + - B. `git reset --hard` + - C. `git rebase --stop` + - D. `git rebase --cancel` + +### 11. **Comment récupérez-vous toutes les branches d'un dépôt distant sans fusionner les modifications ?** + - A. `git pull` + - B. `git fetch` + - C. `git sync` + - D. `git clone` + +### 12. **Quelle commande permet de "squasher" plusieurs commits en un seul avant de pousser vers un dépôt distant ?** + - A. `git squash` + - B. `git rebase -i HEAD~[nombre]` + - C. `git commit --squash` + - D. `git reapply HEAD` + +### 13. **Vous travaillez sur une branche de fonctionnalité et vous souhaitez fusionner les changements de `main` dans votre branche pour rester à jour. Quelle commande devriez-vous utiliser ?** + - A. `git pull main` + - B. `git merge main` + - C. `git rebase main` + - D. `git sync main` + +### 14. **Quelle commande Git est utilisée pour indexer toutes les modifications, y compris les suppressions, dans votre répertoire de travail ?** + - A. `git add .` + - B. `git add -A` + - C. `git commit -a` + - D. `git add *` + +### 15. **Comment poussez-vous une nouvelle branche vers un dépôt distant pour la première fois ?** + - A. `git push origin main` + - B. `git push origin --all` + - C. `git push origin [nom-de-branche]` + - D. `git upload [nom-de-branche]` diff --git a/0 - git/QUIZ/02-QUIZ02.md b/0 - git/QUIZ/02-QUIZ02.md new file mode 100644 index 0000000..f9d1b0a --- /dev/null +++ b/0 - git/QUIZ/02-QUIZ02.md @@ -0,0 +1,213 @@ +# QUIZ 2 (30 questions) + +**1. Quelle commande utilise-t-on pour initialiser (ou créer) un nouveau dépôt Git (repository) ?** +*Choix unique. (5 points)* +- git clone +- git new +- git init +- git start + +**2. Quelle commande montre l'état actuel de votre espace de travail ?** +*Choix unique. (3.5 points)* +- git show +- git display +- git view +- git status + +**3. Comment ajoutez-vous tous les changements de l'espace de travail à l'index ?** +*Choix unique. (4 points)* +- git add . +- git commit . +- git push . +- git update . + +**4. Quelle commande est utilisée pour voir l'historique des commits ?** +*Choix unique. (2 points)* +- git logs +- git history +- git log +- git commit-history + +**5. Comment revenez-vous à un commit précédent en utilisant son hash ?** +*Choix unique. (0.5 points)* +- git revert [hash] +- git reset [hash] +- git return [hash] +- git back [hash] + +**6. Quelle commande est utilisée pour créer une nouvelle branche ?** +*Choix unique. (4 points)* +- git new [branch-name] +- git create [branch-name] +- git branch [branch-name] +- git make [branch-name] + +**7. Comment passez-vous d'une branche à une autre ?** +*Choix multiples. (4 points)* +- git checkout [branch-name] +- git switch [branch-name] +- git move [branch-name] +- git jump [branch-name] + +**8. Quelle commande fusionne une branche avec votre branche actuelle ?** +*Choix unique. (4 points)* +- git merge [branch-name] +- git join [branch-name] +- git fuse [branch-name] +- git combine [branch-name] + +**9. Comment renommez-vous une branche locale ?** +*Choix unique. (2 points)* +- git rename [old-name] [new-name] +- git branch -m [old-name] [new-name] +- git mv [old-name] [new-name] +- git change [old-name] [new-name] + +**10. Comment supprimez-vous une branche locale ?** +*Choix unique. (0.5 points)* +- git remove [branch-name] +- git branch -d [branch-name] +- git delete [branch-name] +- git branch -r [branch-name] + +**11. Comment clonez-vous un dépôt distant ?** +*Choix unique. (5 points)* +- git copy [url] +- git download [url] +- git get [url] +- git clone [url] + +**12. Quelle commande est utilisée pour voir les différences non indexées ?** +*Choix unique. (3 points)* +- git differences +- git diff +- git changes +- git compare + +**13. Comment annulez-vous les modifications non commitées dans un fichier ?** +*Choix unique. (1 point)* +- git restore [file] +- git undo [file] +- git reverse [file] +- git return [file] + +**14. Quelle commande est utilisée pour réinitialiser l'index et l'espace de travail, où [commit] est le hash du commit ?** +*Choix unique. (2 points)* +- git reset --hard [commit] +- git revert --hard [commit] +- git clear --hard [commit] +- git drop --hard [commit] + +**15. Comment configurez-vous votre email pour Git ?** +*Choix unique. (5 points)* +- git config user.email [your-email] +- git set user.email [your-email] +- git user email [your-email] +- git email --config [your-email] + +**16. Comment poussez-vous vos changements vers une branche spécifique d'un dépôt distant ?** +*Choix unique. (5 points)* +- git push [remote-name] [branch-name] +- git upload [remote-name] [branch-name] +- git send [remote-name] [branch-name] +- git transfer [remote-name] [branch-name] + +**17. Comment récupérez-vous les changements d'une branche spécifique depuis un dépôt distant ?** +*Choix multiples. (4 points)* +- git pull [remote-name] [branch-name] +- git fetch [remote-name] [branch-name] && git merge [remote-name]/[branch-name] +- git download [remote-name] [branch-name] +- git get [remote-name] [branch-name] + +**18. Quelle commande est utilisée pour lister toutes les branches locales ?** +*Choix unique. (5 points)* +- git list +- git show-branches +- git branches +- git branch + +**19. Comment annulez-vous le dernier commit ?** +*Choix unique. (0.5 points)* +- git undo +- git reset HEAD^ +- git revert HEAD +- git drop HEAD + +**20. Quelle commande est utilisée pour attacher la HEAD à un commit spécifique ?** +*Choix unique. (3 points)* +- git attach HEAD [commit] +- git connect HEAD [commit] +- git link HEAD [commit] +- git checkout [commit] + +**21. Comment fusionnez-vous deux commits en un seul ?** +*Choix unique. (0.5 points)* +- git fuse [commit1] [commit2] +- git combine [commit1] [commit2] +- git squash [commit1] [commit2] +- git merge [commit1] [commit2] + +**22. Quelle commande montre les branches qui ont été fusionnées avec la branche actuelle ?** +*Choix unique. (0.5 points)* +- git branch --merged +- git branch --fused +- git branch --combined +- git branch --joined + +**23. Comment modifiez-vous le dernier commit sans changer son message de commit ?** +*Choix unique. (0.5 points)* +- git commit --amend +- git commit --edit +- git commit --redo +- git commit --modify + +**24. Quelle commande montre les changements entre la branche actuelle et une autre branche ?** +*Choix unique. (2 points)* +- git diff [branch-name] +- git compare [branch-name] +- git changes [branch-name] +- git review [branch-name] + +**25. Comment créez-vous un alias pour une commande Git ?** +*Choix unique. (0.5 points)* +- git alias [alias-name] [git-command] +- git config --global alias.[alias-name] [git-command] +- git shortcut [alias-name] [git-command] +- git link [alias-name] [git-command] + +**26. Quelle commande est utilisée pour voir la configuration de Git ?** +*Choix multiples. (2 points)* +- git settings +- git show-config +- git view-config +- git config --list +- cat .git/config + +**27. Comment supprimez-vous un fichier de l'index ?** +*Choix unique. (2 points)* +- git delete [file-name] +- git remove [file-name] +- git unindex [file-name] +- git rm [file-name] + +**28. Comment modifiez-vous le message du dernier commit ?** +*Choix unique. (2 points)* +- git modify-message +- git edit-message +- git commit --amend -m "New message" +- git redo-commit -m "New message" + +**29. Quelle commande est utilisée pour initialiser un nouveau dépôt ?** +*Choix unique. (0.5 points)* +- git init --nude +- git init --bare +- git init --empty +- git start --none + +**30. Comment créez-vous une archive de votre dépôt ?** +*Choix unique. (0.5 points)* +- git pack +- git archive +- git zip +- git bundle + diff --git a/0 - git/QUIZ/03-QUIZ3.md b/0 - git/QUIZ/03-QUIZ3.md new file mode 100644 index 0000000..a35142a --- /dev/null +++ b/0 - git/QUIZ/03-QUIZ3.md @@ -0,0 +1,184 @@ +# QUIZ 3 (30 QUESTIONS) + +### 1. **Quel est le rôle de la commande `git init` ?** + - A. Initialiser un nouveau dépôt Git. + - B. Ajouter un fichier au suivi de Git. + - C. Fusionner des branches. + - D. Supprimer un dépôt Git. + +### 2. **Comment ajouter tous les fichiers modifiés et nouveaux fichiers au staging area (zone d'indexation) ?** + - A. `git add *` + - B. `git add .` + - C. `git add -A` + - D. `git commit -a` + +### 3. **Quelle commande permet de commiter des changements avec un message ?** + - A. `git save -m "message"` + - B. `git commit -m "message"` + - C. `git commit` + - D. `git save` + +### 4. **Que fait la commande `git pull` ?** + - A. Elle envoie les modifications locales vers le dépôt distant. + - B. Elle fusionne le dépôt distant avec le dépôt local. + - C. Elle récupère les changements du dépôt distant et les fusionne dans la branche courante. + - D. Elle crée une nouvelle branche. + +### 5. **Comment basculer vers une autre branche dans Git ?** + - A. `git change [branch-name]` + - B. `git branch [branch-name]` + - C. `git checkout [branch-name]` + - D. `git switch [branch-name]` + +### 6. **Quelle commande permet de lister toutes les branches, locales et distantes ?** + - A. `git branch` + - B. `git branch --all` + - C. `git branch --list` + - D. `git checkout` + +### 7. **Quelle commande fusionne les changements d'une branche dans la branche courante ?** + - A. `git pull` + - B. `git merge [branch-name]` + - C. `git rebase [branch-name]` + - D. `git checkout [branch-name]` + +### 8. **Comment appliquer les modifications enregistrées temporairement avec `git stash` ?** + - A. `git stash apply` + - B. `git stash pop` + - C. `git stash pull` + - D. `git stash push` + +### 9. **Comment annuler le dernier commit sans supprimer les modifications locales ?** + - A. `git reset --soft HEAD~1` + - B. `git reset --hard HEAD~1` + - C. `git revert HEAD` + - D. `git reset HEAD~1` + +### 10. **Quelle commande permet de réécrire l'historique Git en combinant plusieurs commits en un seul ?** + - A. `git squash` + - B. `git rebase -i` + - C. `git merge --squash` + - D. `git commit --amend` + +### 11. **Comment récupérer les modifications du dépôt distant sans les fusionner ?** + - A. `git fetch` + - B. `git pull` + - C. `git merge` + - D. `git sync` + +### 12. **Quel est le rôle de la commande `git checkout -b [branch-name]` ?** + - A. Créer une nouvelle branche et y basculer. + - B. Supprimer une branche. + - C. Afficher l'historique des commits. + - D. Fusionner une branche dans la branche courante. + +### 13. **Quelle commande permet de lister toutes les modifications enregistrées par `git stash` ?** + - A. `git stash list` + - B. `git stash show` + - C. `git stash logs` + - D. `git stash view` + +### 14. **Comment supprimer une branche locale ?** + - A. `git branch -d [branch-name]` + - B. `git branch --delete [branch-name]` + - C. `git remove [branch-name]` + - D. `git branch -rm [branch-name]` + +### 15. **Comment ajouter un tag annoté à un commit pour indiquer une version ?** + - A. `git tag -a v1.0 -m "Version 1.0"` + - B. `git tag v1.0` + - C. `git commit --tag v1.0` + - D. `git tag --annotate v1.0` + +### 16. **Quelle est la différence entre `git merge` et `git rebase` ?** + - A. `git merge` crée un commit de fusion, `git rebase` réapplique les commits sur la branche cible. + - B. `git merge` supprime l'historique, `git rebase` le conserve. + - C. `git merge` réécrit l'historique, `git rebase` non. + - D. `git merge` ne peut être utilisé que pour les branches locales, `git rebase` pour les branches distantes. + +### 17. **Que se passe-t-il lorsque vous utilisez `git rebase` sur une branche avec des conflits ?** + - A. Git résout automatiquement les conflits. + - B. Git vous demande de résoudre les conflits manuellement. + - C. Git annule le rebase et revient à l'état précédent. + - D. Git crée une nouvelle branche. + +### 18. **Quelle commande est utilisée pour combiner des commits dans un dépôt sans changer leur ordre ?** + - A. `git merge` + - B. `git rebase` + - C. `git cherry-pick` + - D. `git commit --amend` + +### 19. **Comment supprimer définitivement des modifications locales sans les commiter ?** + - A. `git reset --hard` + - B. `git reset --soft` + - C. `git stash` + - D. `git checkout` + +### 20. **Quelle commande permet de faire un commit rapide de tous les fichiers modifiés et suivis ?** + - A. `git commit -a -m "message"` + - B. `git commit -m "message"` + - C. `git commit -A` + - D. `git add . && git commit -m "message"` + +### 21. **Comment forcer le push d'une branche vers le dépôt distant en écrasant l'historique distant ?** + - A. `git push --force` + - B. `git push --force-with-lease` + - C. `git push origin --all` + - D. `git push -f` + +### 22. **Comment résoudre un conflit de fusion dans Git ?** + - A. Modifier les fichiers concernés, puis utiliser `git add` et `git commit`. + - B. Utiliser `git reset --hard` pour annuler la fusion. + - C. Utiliser `git stash` pour ignorer les changements. + - D. Supprimer le fichier en conflit. + +### 23. **Quelle commande permet de supprimer tous les changements locaux non suivis ?** + - A. `git clean -f` + - B. `git reset --hard` + - C. `git stash clear` + - D. `git remove --untracked` + +### 24. **Comment cloner un dépôt Git distant vers votre machine locale ?** + - A. `git init [URL]` + - B. `git clone [URL]` + - C. `git pull [URL]` + - D. `git checkout [URL]` + +### 25. **Que fait la commande `git log --oneline` ?** + - A. Affiche tous les commits avec une vue simplifiée. + - B. Affiche le détail de chaque commit. + - C. Affiche uniquement les branches. + - D. Montre les différences entre les branches. + +### 26. **Comment voir la différence entre deux commits dans un projet ?** + - A. `git diff` + - B. `git log` + - C. `git merge` + - D. `git status` + +### 27. **Comment renommer une branche Git locale ?** + - A. `git rename [old-name] [new-name]` + - B. `git branch -m [new-name]` + - C. `git branch --move [new-name]` + - D. `git change [new-name]` + +### 28. **Quelle commande permet de visualiser l’état actuel des fichiers suivis et non suivis dans le dépôt local ?** + - A. `git status` + - B. `git diff` + - C. `git log` + - D. `git show` + +### 29. **Que fait la commande `git cherry-pick` ?** + - A. Elle permet de sélectionner un ou plusieurs commits spécifiques à appliquer sur une autre branche. + - B. Elle crée une nouvelle branche à partir d’un commit spécifique. + - C. Elle permet de fusionner des commits en conflit. + - D. Elle supprime un commit spécifique. + +### 30. **Quelle commande est utilisée pour rétablir un fichier supprimé dans un dépôt local avant un commit ?** + - A. `git reset --hard` + + + - B. `git restore [file]` + - C. `git checkout -- [file]` + - D. `git revert [file]` + diff --git a/0 - git/QUIZ/README.md b/0 - git/QUIZ/README.md new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/0 - git/QUIZ/README.md @@ -0,0 +1 @@ +