Bien sûr, il n'y a rien dans Git qui nécessite un protocole particulier. Juste en dehors de la boîte le client standard prend en charge HTTP(S), SSH, le protocole personnalisé de Git et, surtout, la local protocole. Cela prend juste un chemin vers un local .git qui peut se trouver dans le répertoire de travail ( /path/to/project/.git ) ou simplement un répertoire vide ( /path/to/project.git ), bien que la dénomination ne soit qu'une convention.

Cela signifie que vous pouvez, bien sûr, ajouter une clé USB comme télécommande :

git remote add origin /mnt/flashdrive/foo.git

ou, sous Windows :

git remote add origin F:\foo.git

Ou même l'ajouter comme une télécommande supplémentaire avec un nom différent (si vous préférez origin pour pointer vers un serveur Internet quelque part) :

git remote add flashdrive /mnt/flashdrive/foo.git

Ensuite, vous pouvez simplement pousser/tirer vers/depuis cette télécommande comme n'importe quelle autre.

Si vous lisez le documentation vous remarquerez qu'il y a également une file:// qui se comporte de manière légèrement différente. Il est recommandé d'utiliser un chemin d'accès local, car cela permet de bénéficier de certaines optimisations supplémentaires. file:// git utilisera alors des composants réseau standard (pour communiquer avec le disque local), ce qui est plus lent.

Sur un simple ordinateur, rien de spécial n'est nécessaire. Exécuter git init dans le répertoire souhaité et travaillez avec Git comme vous le feriez normalement.

Pour synchroniser un référentiel entre multiple ordinateurs, il existe plusieurs méthodes.

Méthode 1a (pas de réseau du tout) : Vous pouvez créer un "référentiel nu" sur la clé USB, puis le charger et le décharger comme vous le feriez avec n'importe quel autre référentiel distant. En d'autres termes, les opérations de dépôt via des chemins locaux ne sont pas différentes des opérations via SSH ou des URL HTTPS.

1. Créer un référentiel "distant" :

   $ git init --bare /mnt/Stick/Repositories/Large_Project.git

2. Dans l'ordinateur 1, poussez tout vers lui :

   $ cd ~/Large_Project
   $ git remote add usb /mnt/Stick/Repositories/Large_Project.git
   $ git push usb master

3. Dans l'ordinateur 2, eh bien, comme d'habitude.

   $ git remote add usb /mnt/Stick/Repositories/Large_Project.git
   $ git pull usb

(Vous pouvez aussi pousser/récupérer/tirer directement d'une URL ou d'un chemin).

Méthode 1b (réseau interne) : Si vous avez un serveur interne avec SSH disponible, et si Git est installé sur ce serveur, vous pouvez faire ce qui suit la même chose que ci-dessus il suffit de spécifier une adresse SSH en utilisant l'option [user@]host:path o ssh://[user@]host/path la syntaxe.

1. Créez un référentiel "distant" en exécutant git init --bare <somepath.git> sur le serveur désigné (via SSH).

2. Dans l'ordinateur 1, de la même manière que celle démontrée précédemment.

   $ git remote add origin myserver.example.com:Gits/Large_Project.git

   Ou si vous préférez :

   $ git remote add origin ssh://myserver.example.com/~/Gits/Large_Project.git

3. Dans l'ordinateur 2, on procède à nouveau comme pour la méthode 1a.

Méthode 2 : Vous pouvez créer des 'paquets de transfert' qui archivent une liste donnée de commits dans un seul fichier.

Malheureusement, les commandes de regroupement ne se souviennent pas automatiquement de ce qui a déjà été regroupé la dernière fois, ce qui nécessite un marquage manuel ou une prise de notes. Je vais me contenter de prendre les exemples du manuel git-bundle.

1. Dans l'ordinateur 1, créez une liasse de la branche entière :

   $ cd ~/Large_Project
   $ git bundle create /mnt/Stick/Project.bundle master
   $ git tag -f last-bundled master

2. Dans l'ordinateur 2, tirez sur la liasse comme s'il s'agissait d'un dépôt :

   $ cd ~/Large_Project
   $ git pull /mnt/Stick/Project.bundle

Les paquets suivants n'ont pas besoin d'emballer la totalité master - ils peuvent emballer juste le commits nouvellement ajouté de last-bundled..master à la place.

1. Dans l'ordinateur 1, créez une liasse des commits nouvellement ajoutés :

   $ cd ~/Large_Project
   $ git bundle create /mnt/Stick/Project.bundle last-bundled..master
   $ git tag -f last-bundled master

2. Idem que ci-dessus.

git bundle create

L'une des méthodes consiste à utiliser un stockage externe pour échanger des données entre les référentiels. bundle git . De cette façon, vous n'avez que des fichiers uniques pour chaque transfert, et non des dépôts Git intermédiaires.

Chaque "git push" se traduit par la création d'un fichier, "git fetch" récupère les éléments de ce fichier.

Session de démonstration

Créer le premier dépôt et faire le premier "push".

gitbundletest$ mkdir repo1

gitbundletest$ cd repo1

repo1$ git init
Initialized empty Git repository in /tmp/gitbundletest/repo1/.git/
repo1$ echo 1 > 1 && git add 1 && git commit -m 1
[master (root-commit) c8b9ff9] 1
 1 file changed, 1 insertion(+)
 create mode 100644 1

repo1$ git bundle create /tmp/1.bundle master HEAD
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 384 bytes | 384.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)

"clonage" vers le second référentiel (c'est-à-dire le second ordinateur) :

gitbundletest$ git clone /tmp/1.bundle repo2
Cloning into 'repo2'...
Receiving objects: 100% (3/3), done.

gitbundletest$ cd repo2/

repo2$ cat 1
1

Effectuer des modifications et les "pousser" vers un autre fichier groupé :

repo2$ echo 2 > 1 && git add 1 && git commit -m 2
[master 250d387] 2
 1 file changed, 1 insertion(+), 1 deletion(-)

repo2$ git bundle create /tmp/2.bundle origin/master..master origin/HEAD..HEAD
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 415 bytes | 415.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)

"tirer" les changements vers le premier référentiel :

repo2$ cd ../repo1

repo1$ git pull /tmp/2.bundle 
Receiving objects: 100% (3/3), done.
From /tmp/2.bundle
 * branch            HEAD       -> FETCH_HEAD
Updating c8b9ff9..250d387
Fast-forward
 1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

repo1$ cat 1
2

Contrairement au premier paquet, le second ne contient qu'un historique partiel de Git et n'est pas directement clonable :

repo1$ cd ..

gitbundletest$ git clone /tmp/2.bundle repo3
Cloning into 'repo3'...
error: Repository lacks these prerequisite commits:
error: c8b9ff94942039469fa1937f6d38d85e0e39893a 
fatal: bad object 250d38747656401e15eca289a27024c61e63ed68
fatal: remote did not send all necessary objects

L'inconvénient de l'utilisation des bundles est que vous devez spécifier manuellement quelle plage de commits chaque bundle doit contenir. Contrairement à git push , git bundle ne garde pas la trace de ce qui était dans le paquet précédent, vous devez ajuster manuellement refs/remotes/origin/master ou des paquets serait plus important qu'il ne pourrait l'être.

Vous devez d'abord installer Git . Ensuite, pour créer un nouveau référentiel, exécutez dans le dossier que vous avez copié :

git init

Ensuite, vous pouvez ajouter les fichiers que vous voulez au contrôle de version en git add (ajouter -a pour tous les fichiers) et commencer à valider les changements ( git commit ).

Vous n'avez pas besoin de pousser à distance, car vous pouvez travailler sur votre historique local ( git log ).

Pour plus d'informations, consultez le site :

• Tutoriel Git .
• git - le guide simple

Pousser/tirer sans internet

Utilisation de git push il est possible de pousser sur SSH (en utilisant une connexion locale, intranet) :

git remote add server ssh://[user@]host.xz[:port]/path/to/dev/repo.git/
git push server

ou en poussant dans le dossier :

git push /mnt/usb/my_repo

Cela suppose que vous avez deux copies de votre référentiel.

Il en va de même pour la traction, par exemple.

git pull /mnt/usb/my_repo

Parcheando

Pour appliquer des correctifs, vous pouvez utiliser patch ou git apply .

Voir : Créer un patch ou un fichier diff à partir d'un dépôt git et l'appliquer à un autre dépôt git différent. .

Vous pouvez également utiliser Git en local. Dans ce cas, vos commits ne sont stockés que localement, et vous avez toujours le contrôle de version avec lui (et pouvez diff/merge etc.), mais vous ne pouvez simplement pas accéder au dépôt depuis un autre ordinateur.

Vous pouvez démarrer un dépôt Git local en exécutant git init dans votre dossier local. Comme décrit ici .