Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
En Pratique : Se connecter et utiliser GitHub à partir de MorphOS
(Article écrit par Rafal Zabdyr et extrait de Polish Amiga Portal - décembre 2022)
|
|
Voici un tutoriel montrant comment se connecter et utiliser GitHub à partir de MorphOS.
Configuration requise :
Liens utiles :
Ce tutoriel se base sur les versions à l'automne 2022 de MorphOS (3.17), du MorphOS SDK (3.16), de Wayfarer (4.x)
et de GitHub lui-même.
1. Logiciel de gestion de versions
Pour citer Wikipédia : "Un logiciel de gestion de versions/révisions est un logiciel utilisé pour suivre
les modifications apportées principalement au code source et pour aider les développeurs à fusionner les
modifications apportées aux fichiers par plusieurs personnes à des moments différents."
En simplifiant un peu, un tel logiciel permet d'avoir automatiquement des copies des versions successives
du logiciel que vous développez. Là encore, il vous est plus facile de vérifier rapidement, par exemple,
quelles modifications ont entraîné l'apparition d'un bogue particulier depuis une version donnée. Cela
vous permet également de revenir sans problème à une version spécifique des sources.
Depuis quelques années, l'un des logiciels de gestion de versions les plus populaires est Git. Sur Internet,
vous disposez de plusieurs services d'hébergement qui vous permettent de gérer vos dépôts avec le code
que vous avez sous contrôle Git : des services tels que GitHub, GitLab et SourceForge. En utilisant ces
services, vous obtenez une sécurisation de votre travail.
Dans ce tutoriel, nous allons couvrir l'intégration et l'utilisation de base de GitHub, qui n'est pas
seulement un endroit où conserver votre code (dépôt avec historique), mais aussi un service qui dispose
d'un gestionnaire de bogues (BugTracker), qui vous permet de publier vos dépôts (dépôts publics) et de
les garder privés (dépôts privés). Vous pouvez également contribuer à d'autres dépôts publics en
corrigeant des bogues, en ajoutant de nouvelles fonctionnalités ou simplement en signalant des bogues, etc.
2. Créer un compte sur GitHub
Pour travailler activement avec GitHub, vous avez besoin d'un compte. Sans compte, vous ne pouvez que
consulter passivement les dépôts publics (mais avec la possibilité de les cloner, etc.). Vous allez
l'utiliser pour travailler sur vos propres projets privés ou publics.
La page d'inscription pour la création d'un compte est accessible depuis la
page principale de GitHub,
Celle-ci n'est pas très utile car elle consomme beaucoup de temps processeur, ce qui la rend terriblement
lente sur des machines avec par exemple un PowerPC G4 à 1,42 GHz. Il est intéressant de noter que sur des
PC vieux de quelques années (par exemple avec un Intel Core i5-4310U à 2 GHz) avec un navigateur Chrome/Firefox
à jour, cette page est utilisable bien que sa réactivité laisse beaucoup à désirer.
Cependant, il existe une alternative à ce site "poussif" : une autre page d'enregistrement simple et plus
légère est disponible à l'adresse github.com/join, et c'est celle-ci
que vous utiliserez.
Une fois sur le site, remplissez les données de base telles que votre nom d'utilisateur (les minuscules, les majuscules
et un maximum d'un signe "moins" sont autorisés), votre adresse électronique et votre mot de passe. Et à la toute
fin, il y a une procédure de vérification avec un CAPTCHA.
Si la création du compte se déroule avec succès, vous êtes redirigé vers une page où vous devez saisir
le code de confirmation que vous avez reçu dans votre boîte aux lettres électronique. Après avoir saisi
le code correct et passé la personnalisation (qui peut être ignorée), votre compte GitHub est pleinement
actif et vous êtes redirigé vers la page d'accueil de GitHub.
3. Paramètres supplémentaires du compte
Une fois le compte créé, il est utile d'apporter quelques modifications aux paramètres du compte. Par
exemple, le nom d'utilisateur public, l'image de profil, l'URL de votre propre page, le nom par défaut
de la branche principale du projet, la double authentification (2FA), le thème graphique, etc.
Nom par défaut de la branche principale
Cela fait quelque temps que le mot "main" est le nom de branche par défaut pour chaque nouveau dépôt.
Auparavant, la branche principale de Git était habituellement appelée "master", mais GitHub a décidé
d'être "politiquement correct" et a changé ce nom mal connoté en "main". Cependant, certaines personnes
sont habituées au nom "master" et souhaitent le conserver, ou bien les utilisateurs de SVN souhaitent
conserver le nom "trunk", qui désignait habituellement la branche principale. Ce changement de nom peut se
faire via les paramètres disponibles dans le menu déroulant (en haut à droite avec l'icône de l'utilisateur).
Puis sur la page "Settings" (Paramètres) en sélectionnant "Repositories" (Dépôts) dans le menu de gauche.
Sur la page "Settings" (Paramètres) des dépôts, vous pouvez définir un nom qui vous convient pour la
branche principale.
4. Nouveau dépôt
En cliquant sur l'icône "GitHub" dans le coin supérieur droit, vous retournez à la page d'accueil de
votre compte. Et en sélectionnant "Create repository" (Créer un dépôt), vous créez votre premier
(et nouveau) dépôt.
Sur la page de création du dépôt, donnez un nom au dépôt avec "Repository name" (Nom du dépôt) ainsi
qu'une courte description optionnelle avec "Description" (Description). Vous pouvez aussi décider si le dépôt
doit être public ou privé. Pour l'instant, créez votre dépôt privé, choisissez donc "Private" (Privé).
C'est aussi une bonne idée d'ajouter un fichier en cochant "Add a README file" (Ajouter un fichier README),
ainsi qu'un fichier ".gitignore" qui définit les règles selon lesquelles Git ignorera certains fichiers
et ne les inclura pas dans la gestion des versions. Cela concerne par exemple les fichiers objets
(avec l'extension ".o") créés lors de la compilation de programmes écrits en C/C++. Dans notre exemple
de nouveau dépôt, choisissez un modèle de fichier ".gitignore" pour le langage C.
Après avoir sélectionné "Create repository" (Créer un dépôt), vous arrivez immédiatement sur la page
principale de votre nouveau dépôt. Comme vous pouvez le voir, le nom de la branche principale est "master",
il y a une soumission/modification avec le titre "Initial commit" (Modification initiale). Les seuls fichiers du dépôt
sont un ".gitignore" et un "README.md" pré-rempli (un fichier texte au format
Markdown).
5. Cloner le dépôt
5.1 Utiliser HTTPS, ... ça marche encore ?
Sur la page du dépôt, cliquez sur le bouton "Code" (Code), qui montre plusieurs options pour cloner
le dépôt, la première étant le clonage via HTTPS. Cliquez sur l'icône copier l'URL (à droite de l'URL) dans
le presse-papiers. Lancez ensuite un Shell sous MorphOS.
Dans le Shell, naviguez vers le répertoire où vous voulez cloner votre dépôt. Ensuite, appelez
Git avec l'option "clone" et l'adresse du dépôt ("git clone <url>"). Dans mon cas, il s'agit de :
git clone https://github.com/PPA-user/ppa.git
|
Ensuite, entrez le nom d'utilisateur (votre adresse électronique) et le mot de passe. Dans mon cas,
lorsque j'entre mon adresse électronique, je ne vois pas ce que j'entre, je ne sais pas si c'est
la faute à MorphOS ou à Git lui-même, mais ne soyez pas surpris. Votre nom d'utilisateur n'apparaîtra
qu'en dessous dans la ligne du mot de passe. Bien sûr, le mot de passe est aussi invisible que possible
lorsqu'on le tape.
Comme vous pouvez le voir, la tentative de cloner en utilisant HTTPS et en s'authentifiant uniquement
par nom d'utilisateur et mot de passe a échoué, car cette méthode d'authentification a été supprimée
sur GitHub il y a quelque temps. Que pouvez-vous faire dans cette situation ? Selon les pages d'aide
de GitHub, pour utiliser HTTPS, il faut créer un
jeton
d'accès personnel ("Personal access token"). Faites-le. Retournez dans votre navigateur et utilisez le
menu pour aller à la page "Settings" (Paramètres), où vous sélectionnez "<> Developer Settings" (<> Paramètres
développeur) dans le menu de gauche (tout en bas). En cours de route, vous verrez probablement une page de
confirmation d'accès avec un mot de passe, cette page peut parfois apparaître en fonction des paramètres que
vous avez choisis. Ainsi, sur la page suivante, allez dans l'option du menu de gauche "Personal access tokens"
(Jetons d'accès personnel), dans laquelle vous sélectionnez "Tokens (classic)" (Jetons (classique)).
Une autre page apparaît, sur laquelle il faut appeler le menu "Generate new token" (Générer un nouveau jeton)
sous l'option "Generate new token (classic)" (Générer un nouveau jeton (classique)).
Lors de la définition d'un nouveau jeton, indiquez le nom du jeton, par exemple celui de votre machine
"MorphOS-iBook-G4", puis indiquez la durée de vie du jeton. GitHub recommande de ne pas créer de jetons
avec des durées de vie illimitées. La dernière option importante est la plage d'accès pour le jeton,
dans votre cas, cochez simplement "repo -> Full control of private repositories" (repo -> Accès complet aux dépôts
privés), ce qui cochera automatiquement les options en dessous.
Il ne reste plus qu'à générer un jeton sur la base de vos paramètres, en utilisant le bouton situé à la
fin du formulaire. Une page s'affiche alors où vous pouvez voir votre jeton généré, et vous devez
le copier dans le presse-papiers (en utilisant à nouveau l'icône de copie).
Ensuite, retournez dans le Shell et exécutez la même commande clone que précédemment, mais cette fois-ci,
au lieu de votre mot de passe GitHub, collez le jeton que vous avez copié. Et voilà, une fois approuvé,
votre dépôt s'est cloné lui-même et vous l'avez dans un sous-répertoire nommé de la même manière que le
nom du dépôt, dans mon cas le répertoire "ppa".
Malheureusement, le jeton n'est pas mémorisé et lors de l'utilisation des commandes Git qui font référence
à un dépôt distant, c'est-à-dire "git push", "git pull", etc., vous devez entrer votre nom d'utilisateur
et votre mot de passe (autrement dit votre jeton) à chaque fois. Vous êtes donc obligé de sauvegarder le
jeton dans un fichier texte local.
5.2 Utiliser SSH
L'autre moyen recommandé pour s'authentifier auprès de GitHub dans votre situation est d'utiliser SSH,
c'est-à-dire d'utiliser votre clé publique. La première chose à faire est de créer une telle clé
(en tandem avec la clé privée) sur votre machine. Supposons que vous ne les avez pas déjà.
La création de clés se fait à partir du Shell et de la commande "ssh-keygen", où l'un des paramètres
est l'adresse électronique, dans mon cas, la commande ressemble à ceci :
ssh-keygen -t ed25519 -C ppa@tdolphin.org
|
Lors de la génération, on vous demandera le nom (et l'emplacement) du fichier dans lequel enregistrer
la clé, la valeur par défaut sera donnée (il s'agit du répertoire ".ssh" dans votre répertoire personnel,
dans mon cas, il s'agit de "System:Home/.ssh") et on vous demandera le mot de passe pour la clé.
Le répertoire personnel de l'utilisateur est défini dans les préférences de MorphOS (menu Ambient -> Préférences
MorphOS... puis préférence "Utilisateurs"). Pour la génération de la clé, vous pouvez vous référer à la description sur
GitHub même, où
la création de la clé est expliquée.
Note : n'oubliez pas de ne jamais donner votre clé privée à qui que ce soit !
Après avoir généré la paire de clés, retournez sur GitHub et ajoutez votre clé publique (c'est celle qui
porte l'extension ".pub"). Sur la page du dépôt, cliquez sur le bouton "Code" (Code), puis sélectionnez
l'option "SSH". Là, il y aura un message indiquant qu'il n'y a pas de clé SSH, ajoutez donc une nouvelle
clé publique.
Vous arrivez maintenant sur la page d'ajout d'une nouvelle clé publique, dont la valeur peut être copiée
depuis le Shell, vous pouvez l'afficher avec la commande :
cat Home/.ssh/id_ed25519.pub
|
Nommez la nouvelle clé et collez la clé publique copiée dans le formulaire et confirmez en cliquant sur
"Add SSH key" (Ajouter une clé SSH).
Il vous sera également demandé de confirmer l'opération avec votre mot de passe GitHub. Et vous devriez
voir votre clé dans la liste.
Retournez à votre dépôt et, cette fois, il n'y a plus de message concernant une clé manquante et vous
pouvez copier en toute confiance l'URL du dépôt dans le presse-papiers.
Allez de nouveau dans le Shell MorphOS, naviguez vers l'endroit où vous voulez cloner votre dépôt et
exécutez la commande de clonage ("git clone"). Dans mon cas, il s'agit de :
git clone git@github.com:PPA-user/ppa.git
|
La première fois, on vous demandera de confirmer la connexion à github.com, répondez "oui" et github.com
sera dans ce qu'on appelle les hôtes connus (Home:.ssh/known_hosts). Entrez le mot de passe de votre clé
et le dépôt se clone dans un répertoire nommé d'après ce dépôt. Entrez dans ce répertoire où vous pouvez
vérifier l'historique des soumissions/modifications avec la commande "git log".
Malheureusement, toutes les opérations faisant référence au serveur GitHub requièrent un mot de passe à
tout moment, comme la commande "git fetch" utilisée pour mettre à jour la version de votre dépôt local.
Pour cela, vous devez à nouveau entrer le mot de passe.
Actuellement, MorphOS ne dispose pas d'une mémoire permanente pour l'authentification SSH à un dépôt distant.
Cependant, il est possible de maintenir l'authentification SSH au sein d'une session MorphOS en cours
d'exécution. Cela se fait à l'aide de la commande "ssh-agent" du SDK. À partir de la ligne de commande,
exécutez ssh-agent avec le paramètre "-D", qui lui permettra de fonctionner en arrière-plan et de se
mettre à l'écoute :
Ensuite (à partir du nouveau Shell), il vous suffit d'ajouter votre authentification, ce que vous
pouvez faire à l'aide de la commande "ssh-add" avec le paramètre de votre clé privée et le mot de passe qui
vous est demandé :
ssh-add Home:.ssh/id_ed25519
|
Maintenant, toute référence à un dépôt sur GitHub qui a été cloné en utilisant SSH ne nécessitera
pas de mot de passe. Cela se fera seulement dans la session MorphOS en cours, c'est-à-dire jusqu'à ce
que le système redémarre.
Vous pouvez automatiser un peu le lancement de l'agent SSH en ajoutant la ligne appropriée à la
user-startup :
run <nil: >nil: ssh-agent -D
|
6. Projet existant
Que faire quand vous avez un projet existant et que vous voulez le télécharger sur GitHub ?
La première chose à faire est de créer un dépôt approprié en suivant les étapes ci-dessus.
Nommez-le et choisissez (ou non) de créer un fichier "README" ainsi qu'un fichier ".gitignore".
Clonez le dépôt ainsi créé, également selon les étapes ci-dessus. Ensuite, copiez l'ensemble de
votre projet existant dans le dépôt cloné, de préférence seulement les fichiers qui ne sont pas
créés par exemple pendant la construction, tels que les fichiers "#?.o", bien que si vous avez
choisi lors de la création du dépôt d'ajouter un fichier ".gitignore" avec un modèle approprié
(par exemple pour le langage C Ansi), alors les fichiers "#?.o" seront ignorés (comme mentionné
précédemment).
Depuis le Shell, allez dans le répertoire du projet et appelez la commande suivante qui ajoute tous les fichiers
(y compris les sous-répertoires non vides, récursivement) à l'index du dépôt (note : il y a bien un point à la fin) :
Avant d'effectuer la modification ("commit" - c'est-à-dire d'approuver les modifications), vérifiez l'état actuel
des modifications, ce qui donnera une liste des fichiers qui seront ajoutés :
Si tout est correct, approuvez vos changements (commit) avec la commande "git commit" ainsi que le
commentaire approprié à la modification :
git commit -m "commentaire sur la modification"
|
A ce stade, vous continuez à avoir vos modifications dans le dépôt localement, vous devez
les mettre sur le serveur GitHub. Vous pouvez le faire à chaque fois que vous procédez à des modifications,
par exemple :
Dans mon exemple, le résultat ressemble à cela :
Vous pouvez consulter l'historique de vos modifications dans le dépôt avec la commande "git log" :
Après ces quelques commandes, votre dépôt avec le projet sur GitHub a déjà "des mains et des pieds".
7. Un mot pour conclure
Vous pouvez maintenant continuer à travailler sur votre projet en utilisant toute la gamme de
facilités que Git et GitHub vous offrent. C'est-à-dire travailler en équipe, sur des "branches"
séparées, émettre des "pull requests"
(demandes
de tirage), avoir une base de données des problèmes, de fonctionnalités, etc. Mais cela fera peut-être
l'objet d'un autre tutoriel.
NDLR : l'auteur de ce tutoriel a également réalisé Git Desktop
(sur MorphOS-Storage et
Aminet), une interface graphique Git pour MorphOS,
assez similaire à GitHub Desktop et GitLab Discovery.
|
