Mémo gitWiki Les geekeries de rungis

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 :

Via un token, l'url est de la forme https://github.com/username/repository.git
Via SSH, l'url est de la forme [email protected]:username/repository.git

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