Services

Mémo git

Dernière mise à jour : 24/11/2022 à 10h10
Table des matières
  1. En local
    1. Initier le projet
    2. Ignorer des fichiers
    3. Gestion des branches
    4. Le remisage (git stash)
      1. Les différentes commandes git stash
      2. Exemple de mise en pratique
    5. La commande git log
    6. La commande git reset
  2. Dépôt distant
    1. Paramétrer les connexion au dépôt distant
      1. Via HTTPS (Via un token)
      2. Avec une clé SSH
        1. Générer sa paire de clé
        2. Déposer sa clé sur son compte github
        3. Activer le ssh-agent
    2. Quelques commandes relatives aux dépôts distants
Ici, juste un article me permettant de garder mémoire des commandes utiles (pour moi) sur git. Je n'utilise que peu git et cet outil permet tellement de choses qu'il est parfois complexe de s'y retrouver.

En local



Initier le projet



On se place dans le dossier que l'on veut "giter" :

Code BASH : 
 
git init                # initie un dépôt vide et créé les fichiers nécessaires
git add --all           # ajoute tous les fichiers du dossier dans l'index du dépôt 
git commit -m "test"    # enregistre les changements dans le dépôt. L'option -m ajoute un message (explication des modif. par exemple)
 


Ignorer des fichiers



Il existe différentes méthodes pour ignorer des fichiers. La plus simple et la plus connue reste l'utilisation du fichier .gitignore placé à la racine du dépôt.

On y ajoute ensuite les fichiers/dossiers qu'on veut ignorer. Cela peut être des noms de fichiers, de dossiers, des chemins, on peut utiliser aussi l'étoile.

Si on souhaite supprimer des fichiers qu'on a publié et qu'on ajoute au .gitignore :

Code BASH : 
git rm --cached filename


L'option --cached indique à git de ne pas supprimer le fichier de l'arborescence de travail mais seulement de le supprimer de l'index.
Avec un dossier, de manière récursive, on ajoute l'option -r :

Code BASH : 
git rm -r --cached directory


On peut faire un check avec l'option -n

Code BASH : 
git rm -r -n --cached directory


Gestion des branches



Pour créer une nouvelle branche :

Code BASH : 
git branch dev       # créé une branche nommée dev


Pour lister les branches :

Code BASH : 
git branch --list


Pour supprimer une branche :

Code BASH : 
git branch -d dev       # supprime la branche dev


Pour renommer une branche :

Code BASH : 
git branch -m dev tests    # renomme la branche dev en tests


Pour basculer sur une branche :

Code BASH : 
git checkout dev


Le remisage (git stash)



Les différentes commandes git stash



Code BASH : 
git stash


La commande git stash permet de remiser ("mettre de côté") des développements pour faire une petite modification et la "commiter" avant de reprendre ces développements mais sans les avoir commités. On peut en effet voir avec la commande git status après un git stash qu'il n'y a plus de modification à commiter.

La commande suivante permet de vérifier ce qui est remisé :

Code BASH : 
git stash list


Pour être plus précis et commenté ce qu'on a remisé :

Code BASH : 
git stash save commentaire même en plusieurs mots sans guillements


Pour avoir des détails sur une remise :

Code BASH : 
git stash show stash@{1}             # stash@{1} est le nom du stash visible avec la commande list


Encore plus de détails :

Code BASH : 
git stash show stash@{1} -p


Il est possible de faire plusieurs stash

Pour reprendre le travail remisé et l'appliquer au commit courant :

Code BASH : 
git stash apply


ou pour spécifier le stash si on en a plusieurs :

Code BASH : 
git stash apply stash@{1}


Les modifications remisées le sont toujours après la commande précédente même si elles ont été importées dans le commit courant. Pour les supprimer :
Code BASH : 
git stash drop

On peut également tout faire en une commande (apply + drop) avec la commande :
Code BASH : 
git stash pop stash@{1}



Par défaut, git stash ne prend pas en compte les nouveaux fichiers. Pour les prendre en compte :

Code BASH : 
git stash -u


Exemple de mise en pratique



Prenons un exemple qui m'est arrivé. J'ai une branche main, en prod et publiée sur GitHub, avec un fichier index.html. Pour faire de nouveaux développements, je créé une branche dev. Je fais des développements sans connaitre la fonction git stash :
  • Je fais des modifications dans index.html
  • Je créé un fichier style.css
  • Je créé un fichier background.png


Je voudrais commiter puis publier les modifications d'index.html dans la branche main car j'ai corrigé une erreur mais sans commiter le reste.

C'est parti !

Code BASH : 
 
git restore --staged style.css background.png          # à faire seulement si ils sont indexés, on peut le vérifier avec git status
git commit -m "modification d'index.html"              # pour commiter ma modification d'index.html
git add --all                                          # pour indexer mes fichiers avant des les remiser
git stash save nouveaux fichiers                      # pour remiser mes deux nouveaux fichiers avant de changer de branche
git checkout main                                      # pour rebasculer sur la branche main
git merge dev                                         # pour intégrer les modifications d'index.html présentes dans la branche dev dans la branche main
git checkout dev                                       # pour retourner sur la branche dev
git stash apply                                        # pour récupérer mes deux fichiers remisés
git stash drop                                         # pour supprimer mon stash
git add --all                                          # pour réindexer ces fichiers
 


La commande git log



La commande git-log permet de voir l'historique des commit.
La plus courante, renvoit une liste de commits, avec leurs identifiants :

Code BASH : 
git log --oneline


Quelques options complémentaires utiles :
  • --name-status liste les fichiers créés, modifiés ou supprimés pour chaque commit
  • -n 2 ou -2 ou --max-count=2 limite le nombre de commits affichés à 2
  • --skip=3 n'affichera pas les 3 derniers commits
  • --berfore=MM/JJ/AAAA limite aux commits avant la date donnée (attention au format)
  • --after=MM/JJ/AAAA limite aux commits après la date donnée


La commande git reset



La commande git reset va affecter l'historique en supprimant des commits !

La commande git reset permet de revenir en arrière sur les commits.
Tout d'abord, il faut connaitre l'identifiant du commit voulu (voir ci-dessus la commande git log).

Ensuite la commande de base, va permettre de revenir en arrière en supprimant les commits suivants mais en conservant la modification des fichiers. Les fichiers seront alors en statut non stagé :

Code BASH : 
git reset 5fb06a6           # 5fb06a6 est le numéro du commit


Il existe plusieurs modes de fonctionnement de la commande git reset, j'en présente 3 ici :

  • --mixed [valeur par défaut] se comporte comme décrit ci-dessus.
  • --soft se comporte comme ci-dessus sauf que les fichiers seront stagged
  • --hard ne conserve pas la modification des fichiers. Attention !


Dépôt distant



Paramétrer les connexion au dépôt distant



Il est aussi possible de passer directement via CLI sans token mais cela nécessite l'installation de GitHub qui n'est pas dans les dépôts officiels de Debian ou autres distributions. Je trouve les méthodes via token et SSH bien mieux.

Via HTTPS (Via un token)



Pour générer un token, il faut se rendre sur son compte GitHub, cliquer sur son image en haut à droite puis Settings.
Cliquer ensuite tout en bas à gauche sur Developer settings puis Personnal access tokens et Tokens (classic).
Cliquer ensuite sur Generate new token puis Generate new token (classic).

Dans cette fenêtre, on peut paramétrer les accès et la date d'expiration du token. Une fois rempli, cliquer en bas sur Generate token.

La clé est générée et affichée. Elle sert de mot de passe à la place du mot de passe utilisateur dans la commande git push (voir plus bas dans l'article)

github_token

Attention à bien copier cette clé car on ne peut la retrouver ensuite

Avec une clé SSH



Pour cela, il est nécessaire :
  • d'avoir une paire de clé (privée/publique)
  • de déposer sa clé publique sur son compte github
  • d'activer ssh-agent sur son poste local


Générer sa paire de clé


Pour cela, plein de tutos existent. Sinon, un petit tour sur mon article Ansible et c'est décrit.

Déposer sa clé sur son compte github


Pour cela, c'est très simple, on se rend sur compte Github, puis on clique sur l'icone en haut à droite puis settings.
On va ensuite à gauche dans le menu SSH and GPG keys avant de cliquer sur le bouton vert "New SSH Key".

On peut ensuite faire un copier/coller du texte contenu dans le fichier de clé publique (fichier.pub).

Attention à ne pas copier le contenu de sa clé privée !

Activer le ssh-agent


Il faut ensuite activer ssh-agent sur le poste local avec la commande suivante :

Code BASH : 
$ eval "$(ssh-agent -s)"
> Agent pid 59566


puis ajouter sa clé à l'agent ssh :

Code BASH : 
ssh-add ~/.ssh/id_ed25519                 # id_ed25519 est le nom du fichier de clé privée


Si vous avez entrer une passphrase sur la clé (ce qui est fortement recommandé), elle sera demandée ici

On peut ensuite tester la connexion à github avec la commande suivante :

Code BASH : 
ssh -T git@github.com


après avoir validé l'empreinte, vous devriez avoir un beau message de confirmation !

Quelques commandes relatives aux dépôts distants



Pour ajouter un dépôt distant (dans lequel on publiera les fichiers) :

Code BASH : 
git remote add origin UrlDépôtGit


permet d'ajouter le dépôt distant défini par son url.



Cette URL peut varier en fonction de la méthode de publication :



Pour publier les commits d'une nouvelle branche (qu'on a en local mais en distant) :

Code BASH : 
git push -u origin main               # origin est le nom du dépôt distant et main le nom de la branche


Pour publier les modifications de toutes les branches :

Code BASH : 
git push --all


La commande suivante permet de voir quel dépôt distant est associé au dépôt local :

Code BASH : 
git remote -v



Cette page a été vue 1925 fois