Comment installer Gitea sur Ubuntu en utilisant Docker

De Get Docs
Aller à :navigation, rechercher

Introduction

Lorsque l'on travaille sur le développement de logiciels, il est important de pouvoir gérer le code source de manière efficace et traçable. Les systèmes de gestion de code source (SCM) sont un excellent moyen de fournir un processus efficace et flexible pour travailler sur des projets de toute taille avec un nombre illimité de développeurs. De nombreux logiciels SCM différents ont existé au fil des ans, de CVS à SubVersion, de Perforce à Mercurial, mais le leader actuel de l'industrie est Git, qui a connu une croissance importante avec la popularité de sites tels que GitHub et GitLab. .

Cependant, avec des comptes gratuits sur ces services orientés vers des référentiels publics à code source ouvert, la possibilité de travailler sur des logiciels privés ou propriétaires entraîne un coût pour le développeur. De plus, l'accès au référentiel est redevable à une organisation externe, et beaucoup préféreraient contrôler leur propre logiciel du début à la fin.

À cette fin, plusieurs solutions auto-hébergées telles que Gogs, Gitea et GitLab ont été développées au cours des dernières années. Ce tutoriel se concentre sur la mise en place de l'une des solutions les plus populaires, Gitea, pour vous permettre d'héberger des référentiels privés et de gérer vos propres projets tout au long de leur cycle de vie. Gitea est petit, autonome et léger, ce qui en fait un processus rapide à déployer sans se ruiner en termes de configuration matérielle. Vous utiliserez une installation Docker de Gitea, qui garantit que le logiciel sera tenu à jour.

Conditions préalables

Avant de commencer ce didacticiel, vous devez disposer des éléments suivants :

  • Un serveur Ubuntu 20.04 avec un utilisateur non root configuré avec les privilèges sudo comme décrit dans la configuration initiale du serveur pour Ubuntu 20.04.
  • Docker installé sur votre serveur. Suivez Étapes 1 et 2 de Comment installer Docker sur Ubuntu 20.04 pour installer Docker.
  • Docker Compose installé sur votre serveur. Suivez Étape 1 de notre guide sur Comment installer et utiliser Docker Compose sur Ubuntu 20.04 pour le configurer.
  • Un nom de domaine pointé vers votre serveur. Si vous utilisez un Droplet DigitalOcean, vous pouvez le faire en suivant notre documentation Domaines et DNS. Ce didacticiel utilisera your_domain dans des exemples tout au long.

Étape 1 - Création de l'utilisateur Git

Gitea, comme de nombreux référentiels de code source, utilise SSH pour accéder aux référentiels distants. Cela permet aux utilisateurs de contrôler l'accès à leur code en gérant leurs clés SSH au sein même de Gitea. Cependant, pour que les utilisateurs puissent accéder à l'hôte via SSH, vous devrez créer un utilisateur git sur la machine hôte. Cette étape est effectuée en premier afin que vous puissiez accéder à l'ID d'utilisateur et de groupe de l'utilisateur.

Commencez par créer l'utilisateur sur l'hôte qui acceptera ces connexions :

sudo adduser --system --shell /bin/bash --gecos 'Git Version Control' --group --disabled-password --home /home/git git

Dans cette commande, vous créez un utilisateur système qui utilise bash comme shell, mais qui n'a pas de mot de passe de connexion. Cela vous permet d'utiliser sudo pour exécuter des commandes en tant qu'utilisateur, mais empêche de vous connecter en tant qu'utilisateur. Vous définissez également le répertoire personnel de l'utilisateur sur /home/git.

Cette commande affichera des informations sur l'utilisateur qu'elle vient de créer :

OutputAdding system user `git' (UID 112) ...
Adding new group `git' (GID 119) ...
Adding new user `git' (UID 112) with group `git' ...
Creating home directory `/home/git' …

Notez les valeurs UID et GID fournies ici (dans ce cas, un UID de 112 et un GID de 119), car elles seront utilisées dans une étape ultérieure.

Étape 2 - Installation de l'image Gitea Docker

Gitea a une image disponible dans le référentiel Docker global, ce qui signifie qu'en utilisant Docker Compose, vous pouvez installer et exécuter cette image en tant que service avec peu de travail supplémentaire. L'image elle-même exécute les services Web et SSH de Gitea, permettant à Git d'accéder à la fois depuis le navigateur et la ligne de commande.

Afin de faire tourner le conteneur Gitea, vous utiliserez Docker Compose, un outil déclaratif de mise en place d'un environnement.

Pour commencer, créez un répertoire pour héberger votre service et entrez-le :

mkdir ~/gitea
cd ~/gitea

Une fois là-bas, créez un fichier appelé docker-compose.yml en utilisant votre éditeur de texte préféré. L'exemple suivant utilise nano. Ce fichier contiendra les descriptions des conteneurs qui fonctionneront dans le cadre de votre installation Gitea :

nano docker-compose.yml

Ajoutez ce qui suit dans ce nouveau fichier :

~/gitea/docker-compose.yml

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.16.5
    container_name: gitea
    environment:
      - USER_UID=UID_from_step_1
      - USER_GID=GID_from_step_1
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /home/git/.ssh/:/data/git/.ssh
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "127.0.0.1:3000:3000"
      - "127.0.0.1:2222:22"

Passons en revue ce que fait ce fichier :

  • version: "3" : cela permet à Docker Compose de quelle version du fichier de configuration il s'agit.
  • networks : cette section déclare la configuration réseau de notre collection de conteneurs. Dans ce cas, un réseau gitea est créé, mais n'est pas exposé à l'extérieur.
  • services
    • image: gitea/gitea:1.16.5 : cela précise que nous utiliserons la version 1.16.5 de Gitea ; cependant, vous pouvez modifier la valeur après les deux-points pour spécifier d'autres versions, qu'il s'agisse d'une version spécifique, d'une version majeure telle que :1 ou d'une balise telle que :latest ou :dev.
    • environment : la section environnement spécifie les variables d'environnement qui seront disponibles pour l'image lors de l'installation et de l'exécution. Dans ce cas, nous spécifions un ID d'utilisateur et de groupe pour l'environnement, en utilisant l'UID et le GID fournis dans la sortie de la commande adduser à l'étape 1.
    • restart: always : cette ligne indique à Docker de toujours redémarrer le conteneur s'il tombe en panne, que ce soit parce que le conteneur lui-même tombe en panne ou que la machine hôte le fait ; essentiellement, Gitea démarrera au démarrage.
    • networks : ceci précise que le service Gitea aura accès et sera accessible sur le réseau nommé ci-dessus.
    • ./gitea:/data et /home/git/.ssh/:/data/git/.ssh : il s'agit des emplacements où Gitea stockera ses référentiels et les données associées. Actuellement, ceci est mappé au dossier nommé gitea dans le répertoire actuel. Docker créera ce dossier au démarrage du conteneur s'il n'existe pas. Le dossier .ssh sera décrit plus loin à l'étape 6.
    • /etc/timezone et /etc/localtime : ces deux fichiers contiennent des informations sur le fuseau horaire et l'heure de la machine hôte. En les mappant directement dans le conteneur en tant que fichiers en lecture seule (spécifiés avec la partie finale :ro des définitions), le conteneur aura les mêmes informations que l'hôte.
    • ports : Gitea écoute les connexions sur deux ports. Il écoute les connexions HTTP sur le port 3000, où il sert l'interface Web pour le référentiel de code source, et il écoute les connexions SSH sur le port 22. Dans ce cas, vous conservez le port 3000 pour les connexions HTTP en le mappant au même numéro, et vous mappez le port sur le conteneur de Gitea de l'habituel 22 à 2222 pour éviter les conflits de ports. À l'étape 6, vous configurerez un shim SSH pour diriger le trafic vers Gitea sur demande.

Remarque : Ceci est un exemple minimal d'un fichier Docker Compose pour Gitea. Il existe plusieurs autres options que l'on peut inclure, telles que l'utilisation de MySQL ou PostGreSQL comme base de données de sauvegarde ou un volume nommé pour le stockage. Cette configuration minimale utilise SQLite comme base de données de sauvegarde et un volume utilisant le répertoire nommé gitea pour le stockage. Vous pouvez en savoir plus sur ces options dans la documentation de Gitea.


Enregistrez et fermez le fichier. Si vous avez utilisé nano pour modifier le fichier, vous pouvez le faire en appuyant sur CTRL + X, Y, puis sur ENTER.

Avec ce fichier en place, vous pouvez ensuite afficher les conteneurs à l'aide de Docker Compose :

docker-compose up

Cette commande déroulera les images, démarrera le conteneur Gitea et renverra une sortie comme celle-ci :

Output[+] Running 9/9
 ⠿ server Pulled                                                                                                  8.2s
   ⠿ e1096b72685a Pull complete                                                                                   1.4s
   ⠿ ac9df86bb932 Pull complete                                                                                   3.3s
   ⠿ 6d34ed99b58a Pull complete                                                                                   3.4s
   ⠿ a8913d040fab Pull complete                                                                                   3.6s
   ⠿ a5d3a72a2366 Pull complete                                                                                   5.3s
   ⠿ 1f0dcaae29cc Pull complete                                                                                   5.6s
   ⠿ f284bcea5adb Pull complete                                                                                   7.3s
   ⠿ 0f09c34c97e3 Pull complete                                                                                   7.5s
[+] Running 2/2
 ⠿ Network gitea_gitea  Created                                                                                   0.2s
 ⠿ Container gitea      Created                                                                                   0.2s
Attaching to gitea
gitea  | Generating /data/ssh/ssh_host_ed25519_key...
gitea  | Generating /data/ssh/ssh_host_rsa_key...
gitea  | Generating /data/ssh/ssh_host_dsa_key...
gitea  | Generating /data/ssh/ssh_host_ecdsa_key...
gitea  | Server listening on :: port 22.
gitea  | Server listening on 0.0.0.0 port 22.
gitea  | 2022/03/31 17:26:21 cmd/web.go:102:runWeb() [I] Starting Gitea on PID: 14
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:21:PreloadSettings() [I] AppPath: /usr/local/bin/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:22:PreloadSettings() [I] AppWorkPath: /app/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:23:PreloadSettings() [I] Custom path: /data/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:24:PreloadSettings() [I] Log path: /data/gitea/log
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:25:PreloadSettings() [I] Configuration file: /data/gitea/conf/app.ini
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:26:PreloadSettings() [I] Prepare to run install page
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:29:PreloadSettings() [I] SQLite3 is supported
gitea  | 2022/03/31 17:26:21 cmd/web.go:208:listen() [I] Listen: http://0.0.0.0:3000
gitea  | 2022/03/31 17:26:21 cmd/web.go:212:listen() [I] AppURL(ROOT_URL): http://localhost:3000/

Cependant, cela laissera le conteneur s'exécuter au premier plan et il s'arrêtera dès que vous quitterez le processus avec Ctrl + C ou en perdant votre connexion. Pour que le conteneur s'exécute en arrière-plan en tant que processus distinct, vous pouvez ajouter l'indicateur -d à la commande Compose :

docker-compose up -d

Vous serez averti lorsque le conteneur démarrera, puis renvoyé dans votre shell.

Étape 3 - Installation de Nginx en tant que proxy inverse

L'exécution d'un service Web tel que Gitea derrière un proxy inverse est une pratique courante, car les logiciels de serveur modernes tels qu'Apache ou Nginx peuvent plus facilement gérer plusieurs services sur une machine, équilibrer la charge sur plusieurs serveurs et gérer SSL. De plus, cela vous permettra de configurer un nom de domaine pointant vers votre instance Gitea fonctionnant sur des ports HTTP(S) standard.

Pour les besoins de ce didacticiel, nous utiliserons Nginx. Tout d'abord, mettez à jour les listes de packages sur votre machine hôte :

sudo apt update

Ensuite, installez Nginx en utilisant apt :

sudo apt install nginx

Maintenant, comme vous utilisez le pare-feu ufw, vous devrez autoriser l'accès à ces ports :

sudo ufw allow "Nginx Full"

Une fois installé, vous devriez pouvoir accéder à votre serveur dans votre navigateur en visitant http://your_domain. Cela vous mènera à une page très simple vous souhaitant la bienvenue à Nginx.

À ce stade, vous devrez créer une entrée de proxy inverse pour diriger le trafic entrant via Nginx vers l'instance Gitea exécutée dans Docker. Créez un nouveau fichier dans le répertoire Nginx sites-available à l'aide de votre éditeur de texte préféré. L'exemple suivant utilise nano :

sudo nano /etc/nginx/sites-available/gitea

Dans ce fichier, configurez un nouveau bloc de serveur avec des requêtes vers / proxy vers votre instance Gitea :

/etc/nginx/sites-available/gitea

server {
    # Listen for requests on your domain/IP address.
    server_name your_domain;

    root /var/www/html;

    location / {
        # Proxy all requests to Gitea running on port 3000
        proxy_pass http://localhost:3000;
        
        # Pass on information about the requests to the proxied service using headers
        proxy_set_header HOST $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Une fois que vous avez terminé de modifier le fichier, enregistrez-le et fermez-le.

Remarque : Pour plus d'informations sur la compréhension de ce qui se passe dans ces directives, consultez le didacticiel Comprendre le proxy HTTP Nginx, l'équilibrage de charge, la mise en mémoire tampon et la mise en cache.


Nginx détermine les sites qu'il servira réellement en fonction de la présence ou non de ces fichiers dans son répertoire sites-enabled. Celle-ci est gérée via des liens symboliques pointant vers les fichiers du répertoire sites-available. Vous devrez créer l'un de ces liens symboliques pour que Nginx commence à servir Gitea :

sudo ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/gitea

Avant de redémarrer Nginx pour appliquer vos modifications, vous devez demander à Nginx de vérifier lui-même que ces modifications sont valides en testant sa configuration.

sudo nginx -t

Si tout va bien, cette commande renverra une sortie comme celle-ci :

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

S'il y a des problèmes, il vous dira quoi et où ils se trouvent.

Lorsque vous êtes prêt à aller de l'avant avec ce changement, redémarrez le service système Nginx :

sudo systemctl restart nginx

Maintenant, lorsque vous visitez http://your_domain dans votre navigateur, vous devriez vous retrouver sur la page de configuration initiale de Gitea, prête à être remplie.

Étape 4 - Installation de Certbot et configuration des certificats TLS

Grâce à Certbot et à l'autorité de certification gratuite Let's Encrypt, ajouter le chiffrement TLS à votre application d'installation Gitea ne prendra que deux commandes.

Tout d'abord, installez Certbot et son plugin Nginx :

sudo apt install certbot python3-certbot-nginx

Ensuite, exécutez certbot en mode --nginx et spécifiez le même domaine que celui que vous avez utilisé dans la directive de configuration Nginx server_name :

sudo certbot --nginx -d your_domain_here

Vous serez invité à accepter les conditions d'utilisation de Let's Encrypt et à saisir une adresse e-mail.

Ensuite, il vous sera demandé si vous souhaitez rediriger tout le trafic HTTP vers HTTPS. C'est à vous de décider, mais cela est généralement recommandé et sûr à faire.

Après cela, Let's Encrypt confirmera votre demande et Certbot téléchargera votre certificat :

OutputCongratulations! You have successfully enabled https://your_domain

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=your_domain
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/your_domain/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/your_domain/privkey.pem
   Your cert will expire on 2022-05-09. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Certbot rechargera automatiquement Nginx avec la nouvelle configuration et les nouveaux certificats. Rechargez votre site dans votre navigateur et il devrait vous basculer automatiquement sur HTTPS si vous avez choisi l'option de redirection.

Votre site est maintenant sécurisé et vous pouvez continuer en toute sécurité avec les étapes de configuration Web.

Vous pouvez trouver plus d'informations sur la sécurisation des domaines avec Let's Encrypt dans le tutoriel Comment sécuriser Nginx avec Let's Encrypt sur Ubuntu 20.04.

Étape 5 — Configuration de Gitea et ajout d'un premier utilisateur

Vous pouvez maintenant passer à la configuration de Gitea lui-même et à la création du premier utilisateur administrateur. Visitez votre instance Gitea en ouvrant https://your_domain dans un navigateur. Sur l'écran de configuration initial de Gitea, il y aura plusieurs options pour le service :

Certains d'entre eux, tels que le titre du site, dépendent de votre cas d'utilisation particulier, mais pour les besoins de ce didacticiel, vous devrez modifier les éléments suivants :

  • Domaine du serveur : le domaine du serveur que vous avez configuré à l'étape 3
  • Gitea Base URL : l'URL complète que vous utiliserez pour accéder à Gitea dans le navigateur, y compris le protocole. Par exemple, https://your_domain.

Lorsque vous enregistrez vos modifications de configuration, vous serez dirigé vers la page de connexion Gitea.

Remarque : Une fois la configuration enregistrée, le service Gitea redémarrera. Comme cela peut prendre quelques secondes, vous pouvez rencontrer une erreur Nginx indiquant 502 Bad Gateway. Si vous rencontrez cette erreur, attendez quelques secondes et redémarrez la page.


Comme vous n'avez pas encore d'utilisateur, vous devrez d'abord en créer un. Clique le Besoin d'un compte? S'inscrire maintenant sous le formulaire de connexion pour enregistrer un nouvel utilisateur. En tant que premier utilisateur du système, cet utilisateur sera créé en tant qu'administrateur. Si vous configurez les paramètres de messagerie sur l'écran de configuration, vous devrez peut-être d'abord vérifier votre compte.

Une fois que vous êtes connecté en tant qu'utilisateur, cliquez sur votre icône d'utilisateur dans le coin supérieur droit de la page, puis cliquez sur Administration du site dans le menu déroulant pour accéder à une page où vous pourrez être en mesure d'exécuter des travaux de maintenance, de gérer des comptes d'utilisateurs et des organisations, et de configurer davantage Gitea.

Création d'un référentiel de test

Afin de tester Gitea, à la fois sur l'interface web et en utilisant Git lui-même, créez un dépôt de test. Vous pouvez toujours supprimer ce référentiel ultérieurement.

Cliquez sur le signe + dans le coin supérieur droit de la page, puis cliquez sur + Nouveau référentiel dans le menu déroulant. Ici, vous verrez un écran vous permettant de nommer et de personnaliser votre référentiel avec des informations telles que sa description, des paramètres tels que s'il est privé ou non, et tout contenu par défaut tel qu'un README ou .gitignore.

Une fois que vous avez cliqué sur Créer un référentiel , vous aurez un nouveau référentiel avec lequel jouer.

Étape 6 - Configuration d'un shim SSH

La dernière étape du processus consiste à préparer la machine hôte avec un shim SSH. Étant donné que Gitea s'exécute dans un conteneur Docker, il ne peut pas accepter les connexions SSH sur le port par défaut de 22, car cela entrerait en conflit avec l'hôte. Dans le fichier docker-compose.yml que vous avez créé ci-dessus, Docker a été chargé de mapper un port sur l'hôte au port 22 sur le conteneur afin qu'il accepte les connexions SSH au port 2222. De plus, le fichier SSH authorized_keys ne sera pas accessible à quelqu'un qui se connecte en SSH à l'hôte par défaut.

Afin de prendre cela en compte, vous devrez créer un shim SSH qui transmettra les connexions SSH à l'utilisateur git sur l'hôte sur le conteneur. Dans le fichier de composition, vous avez également spécifié que l'UTILISATEUR dans le conteneur aura un ID d'utilisateur et de groupe de 1000, et sur l'écran de configuration de Gitea, vous avez dit au service d'utiliser l'utilisateur nommé git.

Création de l'utilisateur Git et de sa clé SSH

Ensuite, vous devrez créer une clé SSH pour l'utilisateur. Cela ne sera utilisé que dans une étape ci-dessous et ne sera partagé avec personne en dehors de l'hôte.

sudo -u git ssh-keygen -t rsa -b 4096 -C "Gitea Host Key"

Cette commande utilise sudo pour créer une clé SSH en tant qu'utilisateur que vous avez créé ci-dessus. Dans ce cas, la clé sera une clé RSA 4096 bits. On vous posera une série de questions telles que le mot de passe que vous souhaitez pour la clé et le nom du fichier de clé. Appuyez sur ENTER pour chacun d'eux, en les laissant vides pour accepter la valeur par défaut.

Attention : Si vous définissez un mot de passe sur la clé, vous ne pourrez pas utiliser le shim.


Vous devrez vous assurer que l'utilisateur dans le conteneur Gitea acceptera cette clé. Vous pouvez le faire en l'ajoutant au fichier .ssh/authorized_keys :

sudo -u git cat /home/git/.ssh/id_rsa.pub | sudo -u git tee -a /home/git/.ssh/authorized_keys
sudo -u git chmod 600 /home/git/.ssh/authorized_keys

Ces commandes fonctionnent toutes avec le shim car le répertoire /home/git/.ssh sur l'hôte est monté en tant que volume sur le conteneur, ce qui signifie que le contenu est partagé entre eux. Lorsqu'une connexion à l'hôte via git sur SSH est reçue, elle utilisera le même fichier authorized_keys que le conteneur.

Création du script SSH Shim

La dernière étape du shim consiste à créer une commande stub gitea sur l'hôte. C'est ce qui permet aux commandes git de fonctionner sur SSH : lorsqu'une connexion SSH est établie, une commande par défaut sera exécutée. Cette commande gitea sur l'hôte est ce qui servira de proxy pour la connexion SSH au conteneur.

Pour ce script, utilisez cat pour écrire dans le fichier /usr/local/bin/gitea :

cat <<"EOF" | sudo tee /usr/local/bin/gitea
#!/bin/sh
ssh -p 2222 -o StrictHostKeyChecking=no [email protected] "SSH_ORIGINAL_COMMAND=\"$SSH_ORIGINAL_COMMAND\" $0 [email protected]"
EOF

La commande dans ce script est SSH vers le conteneur Gitea Docker, en transmettant le contenu de la commande d'origine utilisée par git.

Enfin, assurez-vous que le script est exécutable :

sudo chmod +x /usr/local/bin/gitea

Tester les connexions Git SSH

Vous pouvez tester l'extraction et la transmission vers les référentiels Git sur votre instance Gitea en ajoutant votre clé SSH à votre utilisateur Gitea.

Vous aurez besoin du contenu de votre clé publique SSH. Cela se trouve généralement dans un fichier nommé quelque chose comme ~/.ssh/id_rsa.pub, selon l'algorithme que vous avez utilisé lors de la création de votre clé :

cat ~/.ssh/id_rsa.pub

Remarque : Si vous devez créer une clé SSH pour la première fois, vous pouvez apprendre à le faire avec ce tutoriel Comment configurer des clés SSH sur Ubuntu 20.04.


Copiez la sortie de cette commande.

Dans Gitea, cliquez sur votre icône d'utilisateur dans le coin supérieur droit et sélectionnez Paramètres. Sur la page des paramètres, il y aura une série d'onglets en haut. Cliquez sur Clés SSH/GPG, puis sur le bouton Ajouter une clé à côté de Gérer les clés SSH. Collez votre clé dans la grande zone de texte du formulaire, puis cliquez sur le bouton Ajouter une clé en dessous.

Maintenant, accédez au référentiel de test que vous avez créé à l'étape 3 et copiez l'URL SSH fournie. Sur votre ordinateur local, clonez le dépôt :

git clone [email protected]_domain:username/test

Cela utilisera SSH pour cloner le référentiel. Si vous avez défini un mot de passe sur votre clé SSH, il vous sera demandé de le fournir.

Déplacez-vous dans ce répertoire, créez un nouveau fichier :

cd test
touch just_testing

Ensuite, ajoutez-le à vos modifications par étapes :

git add just_testing

Enfin, validez ce fichier :

git commit -am "Just testing pushing over SSH!"

Maintenant, vous devriez pouvoir envoyer vos modifications au dépôt distant :

git push origin master

Lorsque vous actualisez la page dans votre navigateur, votre nouveau fichier apparaît dans le référentiel.

Conclusion

Vous avez configuré un service Gitea à l'aide de Docker afin d'auto-héberger vos référentiels de code source. À partir de là, vous pourrez travailler sur des référentiels publics et privés, en utilisant des flux de travail familiers tels que des révisions de code de demande d'extraction et des projets organisés par organisation. Gitea fonctionne également bien avec divers outils d'intégration et de déploiement continus (CI/CD) tels que Drone, Jenkins et GoCD. De plus, l'utilisation de volumes Docker tels que celui-ci vous permet d'étendre votre stockage pour adapter le contenu Git LFS (stockage de fichiers volumineux) sur le réseau ou le stockage en mode bloc.