Créer un dépôt GitHub et envoyer son projet avec gitpush

Introduction

Dans le tutoriel précédent, nous avons créé un dépôt Git local sous Ubuntu et enregistré notre projet avec un premier commit.

Pour le moment, le projet et son historique sont uniquement présents sur l’ordinateur. Nous allons maintenant créer un dépôt sur GitHub, le relier au dépôt local et envoyer le projet en ligne avec la commande git push.

Dans ce tutoriel, nous allons découvrir :

• la différence entre un dépôt local et un dépôt distant ;
• la création d’un dépôt sur GitHub ;
• la commande git remote add ;
• le rôle du nom origin ;
• la commande git push ;
• l’envoi des prochaines modifications.

Le projet utilisé

Nous reprenons le projet créé dans le tutoriel précédent :

mon-projet/
|-- .git/
|-- README.md
|-- index.html
`-- style.css

Placez-vous dans son dossier :

cd ~/mon-projet

Vérifiez que le projet contient bien un commit :

git log --oneline

Un résultat similaire doit apparaître :

Le code situé à gauche est l’identifiant abrégé du commit.

Qu’est-ce qu’un dépôt distant ?

Le dossier mon-projet présent sur l’ordinateur est un dépôt local.

Un dépôt créé sur GitHub est appelé dépôt distant. Il permet d’héberger le projet et son historique sur une plateforme accessible en ligne.

Le projet sera donc présent à deux endroits :

La commande git push permet d’envoyer les commits du dépôt local vers le dépôt distant.

GitHub ne remplace pas Git :

• Git gère les versions du projet ;
• GitHub héberge le dépôt Git en ligne.

Créer un dépôt sur GitHub

Connectez-vous à votre compte sur :

https://github.com

Cliquez sur le bouton + situé en haut à droite, puis sur :

New repository

Dans le champ Repository name, saisissez :

mon-projet

Vous pouvez ajouter une description, par exemple :

Premier projet envoyé sur GitHub avec Git.

Choisissez ensuite la visibilité du dépôt :

• Public : le dépôt peut être consulté par tout le monde ;
• Private : le dépôt est uniquement accessible aux personnes autorisées.

Pour ce tutoriel, vous pouvez sélectionner Public.

Créer un dépôt GitHub vide

GitHub propose d’ajouter automatiquement différents fichiers :

• un fichier README.md ;
• un fichier .gitignore ;
• une licence.

Ne sélectionnez aucune de ces options.

Le projet local possède déjà ses fichiers et son propre historique. Le dépôt GitHub doit donc rester vide afin d’éviter de créer un historique différent.

La configuration doit être similaire à celle-ci :

Repository name : mon-projet
Visibility      : Public
Add a README    : Non
.gitignore      : None
License         : None

Cliquez ensuite sur Create repository.

Copier l’adresse SSH du dépôt

Après la création du dépôt, GitHub affiche les instructions permettant d’y envoyer un projet.

Sélectionnez l’onglet SSH.

L’adresse obtenue possède cette structure :

git@github.com:utilisateur/mon-projet.git

Remplacez utilisateur par votre nom d’utilisateur GitHub.

Exemple :

Copiez cette adresse. Elle permettra de relier le dépôt local au dépôt GitHub.

Nous utilisons ici SSH, car la connexion entre Ubuntu et GitHub a déjà été configurée dans un tutoriel précédent.

Relier le dépôt local à GitHub

Retournez dans le terminal et assurez-vous d’être dans le dossier du projet :

cd ~/mon-projet

Ajoutez le dépôt GitHub avec la commande suivante :

git remote add origin git@github.com:utilisateur/mon-projet.git

Cette commande contient plusieurs éléments :

• git remote permet de gérer les dépôts distants ;
• add ajoute une nouvelle adresse distante ;
• origin est le nom donné au dépôt distant ;
• l’adresse SSH indique l’emplacement du dépôt GitHub.

Cette commande n’envoie pas encore le projet. Elle enregistre uniquement l’adresse du dépôt GitHub dans la configuration du dépôt local.

Pourquoi utiliser le nom origin ?

Le nom origin est utilisé par convention pour désigner le dépôt distant principal.

Il représente ici le dépôt GitHub auquel le projet local est relié.

Nous pourrions utiliser un autre nom, mais origin est le nom habituellement utilisé dans les projets Git :

origin
??? git@github.com:utilisateur/mon-projet.git

Lorsque nous utiliserons origin dans une commande, Git saura qu’il doit communiquer avec cette adresse.

Vérifier le dépôt distant

Pour afficher les dépôts distants configurés, utilisez :

git remote -v

Git doit afficher deux lignes similaires :

La mention fetch correspond à l’adresse utilisée pour récupérer les données.

La mention push correspond à l’adresse utilisée pour envoyer les commits.

Les deux opérations utilisent ici la même adresse GitHub.

Utiliser main comme branche principale

Affichez le nom de la branche actuelle :

git branch

Vous devez obtenir un résultat similaire :

L’astérisque indique la branche actuellement utilisée.

Si la branche porte un autre nom, renommez-la en main :

git branch -M main

GitHub utilise généralement main comme branche principale. Utiliser le même nom localement permet de conserver une configuration cohérente.

Envoyer le projet sur GitHub

Le dépôt local est maintenant relié au dépôt GitHub.

Envoyez la branche main avec :

git push -u origin main

Cette commande signifie :

• git push envoie les commits vers un dépôt distant ;
• origin désigne le dépôt GitHub ;
• main désigne la branche à envoyer ;
• -u associe la branche locale main à la branche distante origin/main.

Un résultat similaire doit apparaître :

Le projet et ses commits sont maintenant présents sur GitHub.

Comprendre l’option -u

L’option -u crée une association entre la branche locale et la branche distante :

Cette association indique à Git où envoyer les prochains commits de la branche main.

Elle est nécessaire lors du premier envoi :

git push -u origin main

Pour les prochains envois, la commande suivante suffira :

git push

Vérifier le projet sur GitHub

Retournez sur la page du dépôt GitHub, puis actualisez-la.

Les fichiers du projet doivent maintenant apparaître :

README.md
index.html
style.css

GitHub affiche également :

• la branche main ;
• le dernier message de commit ;
• l’historique des commits ;
• le contenu du fichier README.md.

Le fichier README.md est automatiquement affiché sur la page principale du dépôt lorsqu’il se trouve à la racine du projet.

Envoyer une nouvelle modification

Après le premier envoi, le fonctionnement reste identique à celui découvert précédemment.

Modifiez par exemple le fichier README.md :

echo "Projet Git hébergé sur GitHub." >> README.md

Enregistrez la modification dans un nouveau commit :

git add README.md
git commit -m "Mise à jour du fichier README"

Le nouveau commit est enregistré localement, mais il n’est pas encore disponible sur GitHub.

Envoyez-le avec :

git push

Il n’est plus nécessaire d’indiquer origin main, car l’association a été créée lors du premier envoi avec l’option -u.

Actualisez ensuite la page GitHub pour voir la modification et le nouveau commit.

Comprendre le fonctionnement complet

Le projet suit désormais ce parcours :

La commande git commit enregistre une version sur l’ordinateur.

La commande git push envoie les commits locaux vers GitHub.

Il est donc possible de créer plusieurs commits localement, puis de les envoyer ensemble avec une seule commande git push.

Vérifier la synchronisation

Utilisez la commande suivante :

git status

Lorsque le dépôt local et GitHub sont synchronisés, Git affiche :

La ligne suivante est particulièrement importante :

Elle signifie que la branche locale main et la branche distante origin/main contiennent les mêmes commits.

Corriger une mauvaise adresse distante

Si vous avez ajouté une mauvaise adresse GitHub, affichez l’adresse actuelle :

git remote -v

Remplacez-la avec :

git remote set-url origin git@github.com:utilisateur/mon-projet.git

Vérifiez ensuite la nouvelle adresse :

git remote -v

Cette opération ne supprime ni les fichiers ni les commits du projet.

Corriger l’erreur « remote origin already exists »

Si vous essayez d’ajouter une nouvelle adresse alors que origin existe déjà, Git affiche un message d’erreur.

Cette erreur signifie qu’une adresse distante portant le nom origin est déjà configurée.

Affichez-la avec :

git remote -v

Si elle est incorrecte, remplacez-la :

git remote set-url origin git@github.com:utilisateur/mon-projet.git

Il ne faut pas relancer git init ni recréer le projet.

Attention aux informations confidentielles

Avant d’envoyer un projet sur GitHub, vérifiez qu’il ne contient pas :

• de mot de passe ;
• de clé privée SSH ;
• de jeton d’accès ;
• d’identifiants de base de données ;
• de fichier .env contenant des informations sensibles.

Un dépôt public est visible par tout le monde.

Même dans un dépôt privé, les informations confidentielles ne doivent pas être enregistrées directement dans Git.

Conclusion

Vous avez créé un dépôt GitHub et relié celui-ci au dépôt Git présent sur votre ordinateur.

Vous savez maintenant :

• créer un dépôt vide sur GitHub ;
• récupérer son adresse SSH ;
• ajouter un dépôt distant avec git remote add ;
• comprendre le rôle du nom origin ;
• envoyer une branche avec git push -u origin main ;
• envoyer les prochains commits avec git push ;
• vérifier la synchronisation entre le dépôt local et GitHub.

Le projet est désormais sauvegardé sur GitHub et peut être consulté depuis sa page en ligne.

Dans le prochain tutoriel, nous verrons comment récupérer un projet GitHub sur un ordinateur avec git clone.