Utilisation de Git sur plusieurs systèmes sans accès réseau

Question

Je souhaite utiliser le contrôle de version, mais pour des raisons de sécurité, le serveur sur lequel je travaille n'a pas d'accès Internet: je ne peux déplacer des fichiers que sur une clé USB. Puis-je toujours utiliser Git avec cette configuration? Puis-je créer de petits correctifs que je peux appliquer sur un référentiel Git?

Bob · Answer

Bien sûr, rien dans Git n’exige de protocole particulier. Tout juste prêt à l'emploi le client standard prend en charge HTTP (S), SSH, le protocole Git personnalisé et, plus important encore, le protocole local . Cela prend juste un chemin vers un répertoire .git local, qui peut être dans un répertoire de travail (/path/to/project/.git) ou juste un répertoire nu (/path/to/project.git), bien que le nommage ne soit qu'une convention.

Cela signifie que vous pouvez bien sûr ajouter un lecteur flash 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 en tant que télécommande supplémentaire avec un nom différent (si vous préférez que Origin pointe 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 une autre.

Si vous lisez le documentation , vous remarquerez qu'il existe également un protocole file:// qui se comporte légèrement différemment. Il est recommandé d’utiliser un chemin local car cela utilisera des optimisations supplémentaires - si vous utilisez le protocole file://, alors git utilisera des composants réseau standard (pour parler au disque local), ce qui est plus lent.

grawity · Answer

Sur un single computer, rien de spécial n’est nécessaire. Exécutez git init dans le répertoire de votre choix et travaillez avec Git comme vous le feriez normalement.

Pour synchroniser un référentiel sur multiple , 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 y appuyer et en extraire comme vous le feriez avec tout autre référentiel distant. En d'autres termes, les opérations de référentiel via des chemins locaux ne sont pas différentes des opérations via des URL SSH ou HTTPS.

Créez un référentiel 'distant':

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

Dans l'ordinateur 1, appuyez sur tous les éléments:

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

Dans l'ordinateur 2, bien, comme toujours.

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

(Vous pouvez également pousser/récupérer/extraire directement depuis une URL ou un chemin.)

Méthode 1b (réseau interne): Si vous avez un serveur interne avec SSH disponible, et si Git est installé, vous pouvez faire comme ci-dessus, spécifiez simplement une adresse SSH en utilisant la syntaxe [user@]Host:path ou ssh://[user@]Host/path.

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

Dans l'ordinateur 1, de la même manière que démontré 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

Dans l'ordinateur 2, encore la même chose que la méthode 1a.

Méthode 2: Vous pouvez créer des "ensembles de transfert" qui archivent une liste donnée de validations dans un seul fichier.

Malheureusement, les commandes de regroupement ne se souviennent pas automatiquement de ce qui était déjà groupé la dernière fois. Il est donc nécessaire de marquer manuellement ou de conserver les notes. Je prendrai juste les exemples du manuel de git-bundle.

Sur l’ordinateur 1, créez un ensemble de toute la branche:

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

Dans l'ordinateur 2, tirez de la liasse comme s'il s'agissait d'un référentiel:
```
$ cd ~/Large_Project $ git pull /mnt/Stick/Project.bundle 
```

Les ensembles suivants ne doivent pas nécessairement contenir la totalité de la master; ils peuvent uniquement emballer les nouveaux commits ajoutés à partir de last-bundled..master.

Dans l’ordinateur 1, créez un ensemble des nouveaux commits ajoutés:

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

Comme ci-dessus.

Vi. · Answer

`git bundle create`

L’une des méthodes consiste à utiliser la mémoire externe pour échanger des données entre des référentiels: git bundle . De cette façon, vous ne disposez que de fichiers uniques pour chaque transfert, et non de référentiels Git intermédiaires.

Chaque "git Push" se transforme en 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 deuxième référentiel (c.-à-d. le deuxième ordinateur):

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

Faire quelques changements et les "pousser" dans un autre fichier bundle:

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)

"extraire" les modifications dans 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

Il est désavantageux d'utiliser des ensembles dont vous avez besoin pour spécifier manuellement la plage de validations que chaque ensemble doit contenir. Contrairement à git Push, git bundle ne garde pas trace de ce qui était dans le groupe précédent, vous devez ajuster manuellement refs/remotes/Origin/master ou les groupes seraient plus volumineux qu'ils ne le pourraient.

kenorb · Answer

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

git init

Ensuite, vous pouvez ajouter les fichiers que vous souhaitez contrôler par le biais de git add (ajouter -a pour tous les fichiers) et commencer à valider les modifications (git commit).

Vous ne devez pas appuyer sur une télécommande, vous pouvez travailler sur votre historique local (git log).

Pour plus d'informations, consultez:

Pousser/tirer sans internet

À l'aide de la commande git Push, il est possible d'effectuer une commande Push sur SSH (à l'aide d'une connexion locale, d'un 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 ayez deux copies de votre référentiel.

La même chose avec tirer, par exemple.

git pull /mnt/usb/my_repo

Patcher

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

Voir: Créer un fichier patch ou diff à partir du référentiel git et l'appliquer à un autre référentiel git différent .

dhae · Answer

Vous pouvez aussi utiliser Git localement. Ensuite, vos commits ne sont stockés que localement et vous avez toujours le contrôle de version (et pouvez différer/fusionner, etc.), mais vous ne pouvez tout simplement pas accéder au référentiel depuis un autre ordinateur.

Vous pouvez démarrer un référentiel Git local en exécutant git init dans votre dossier local. Comme décrit ici .