-
1. Erste Schritte
- 1.1 Über Versionskontrolle
- 1.2 Eine kurze Geschichte von Git
- 1.3 Was ist Git?
- 1.4 Die Kommandozeile
- 1.5 Git installieren
- 1.6 Erstmalige Git-Einrichtung
- 1.7 Hilfe bekommen
- 1.8 Zusammenfassung
-
2. Git Grundlagen
-
3. Git Branching
- 3.1 Branches im Überblick
- 3.2 Grundlegendes Branching und Merging
- 3.3 Branch-Management
- 3.4 Branching-Workflows
- 3.5 Remote-Branches
- 3.6 Rebasing
- 3.7 Zusammenfassung
-
4. Git auf dem Server
- 4.1 Die Protokolle
- 4.2 Git auf einem Server einrichten
- 4.3 Generieren Ihres SSH-Public-Keys
- 4.4 Einrichten des Servers
- 4.5 Git Daemon
- 4.6 Smart HTTP
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Drittanbieter-Hosting-Optionen
- 4.10 Zusammenfassung
-
5. Verteiltes Git
-
6. GitHub
-
7. Git-Werkzeuge
- 7.1 Revisionsauswahl
- 7.2 Interaktives Staging
- 7.3 Stashing und Bereinigen
- 7.4 Ihre Arbeit signieren
- 7.5 Suchen
- 7.6 Historie umschreiben
- 7.7 Reset entmystifiziert
- 7.8 Fortgeschrittenes Merging
- 7.9 Rerere
- 7.10 Debugging mit Git
- 7.11 Submodule
- 7.12 Bundling
- 7.13 Ersetzen
- 7.14 Credential-Speicher
- 7.15 Zusammenfassung
-
8. Git anpassen
-
9. Git und andere Systeme
- 9.1 Git als Client
- 9.2 Migration zu Git
- 9.3 Zusammenfassung
-
10. Git-Interna
- 10.1 Plumbing und Porcelain
- 10.2 Git-Objekte
- 10.3 Git-Referenzen
- 10.4 Packfiles
- 10.5 Die Refspec
- 10.6 Übertragungsprotokolle
- 10.7 Wartung und Datenwiederherstellung
- 10.8 Umgebungsvariablen
- 10.9 Zusammenfassung
-
Anhang A: Git in anderen Umgebungen
- A1.1 Grafische Oberflächen
- A1.2 Git in Visual Studio
- A1.3 Git in Visual Studio Code
- A1.4 Git in IntelliJ / PyCharm / WebStorm / PhpStorm / RubyMine
- A1.5 Git in Sublime Text
- A1.6 Git in Bash
- A1.7 Git in Zsh
- A1.8 Git in PowerShell
- A1.9 Zusammenfassung
-
Anhang B: Git in Ihre Anwendungen einbetten
- A2.1 Kommandozeilen-Git
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
Anhang C: Git-Befehle
- A3.1 Einrichtung und Konfiguration
- A3.2 Projekte abrufen und erstellen
- A3.3 Grundlegendes Snapshotting
- A3.4 Branching und Merging
- A3.5 Projekte teilen und aktualisieren
- A3.6 Inspektion und Vergleich
- A3.7 Debugging
- A3.8 Patching
- A3.9 E-Mail
- A3.10 Externe Systeme
- A3.11 Administration
- A3.12 Plumbing-Befehle
5.1 Verteiltes Git - Verteilte Workflows
Nachdem Sie nun ein entferntes Git-Repository eingerichtet haben, das als Sammelpunkt für alle Entwickler zur gemeinsamen Nutzung ihres Codes dient, und Sie mit den grundlegenden Git-Befehlen in einem lokalen Workflow vertraut sind, werden Sie sich nun damit beschäftigen, wie Sie einige der verteilten Workflows nutzen können, die Git Ihnen bietet.
In diesem Kapitel lernen Sie, wie Sie in einer verteilten Umgebung mit Git als Mitwirkender und Integrator arbeiten. Das heißt, Sie lernen, wie Sie Code erfolgreich zu einem Projekt beitragen und es für Sie und den Projektverantwortlichen so einfach wie möglich machen, und auch, wie Sie ein Projekt erfolgreich mit einer Reihe von Mitwirkenden pflegen.
Verteilte Workflows
Im Gegensatz zu zentralisierten Versionskontrollsystemen (CVCSs) ermöglicht die verteilte Natur von Git eine viel flexiblere Zusammenarbeit der Entwickler an Projekten. In zentralisierten Systemen ist jeder Entwickler ein Knotenpunkt, der mehr oder weniger gleichberechtigt mit einer zentralen Anlaufstelle arbeitet. In Git ist jedoch jeder Entwickler potenziell sowohl ein Knotenpunkt als auch eine Anlaufstelle; das heißt, jeder Entwickler kann sowohl Code zu anderen Repositories beitragen als auch ein öffentliches Repository pflegen, auf dem andere ihre Arbeit basieren und zu dem sie beitragen können. Dies eröffnet eine riesige Bandbreite an Workflow-Möglichkeiten für Ihr Projekt und/oder Ihr Team, daher werden wir einige gängige Paradigmen abdecken, die diese Flexibilität nutzen. Wir werden die Stärken und möglichen Schwächen jedes Designs besprechen; Sie können eines auswählen oder Funktionen aus mehreren kombinieren.
Zentralisierter Workflow
In zentralisierten Systemen gibt es im Allgemeinen ein einziges Kooperationsmodell – den zentralisierten Workflow. Eine zentrale Anlaufstelle oder ein Repository kann Code akzeptieren, und jeder synchronisiert seine Arbeit damit. Eine Reihe von Entwicklern sind Knotenpunkte – Konsumenten dieser Anlaufstelle – und synchronisieren sich mit diesem zentralen Ort.
Das bedeutet, wenn zwei Entwickler vom Hub klonen und beide Änderungen vornehmen, kann der erste Entwickler, der seine Änderungen zurückschreibt, dies ohne Probleme tun. Der zweite Entwickler muss die Arbeit des ersten zusammenführen, bevor er seine Änderungen hochlädt, um die Änderungen des ersten Entwicklers nicht zu überschreiben. Dieses Konzept ist in Git genauso wahr wie in Subversion (oder jedem CVCS), und dieses Modell funktioniert in Git perfekt.
Wenn Sie mit einem zentralisierten Workflow in Ihrem Unternehmen oder Team bereits vertraut sind, können Sie diesen Workflow problemlos mit Git fortsetzen. Richten Sie einfach ein einziges Repository ein und geben Sie allen in Ihrem Team Push-Zugriff; Git wird nicht zulassen, dass Benutzer sich gegenseitig überschreiben.
Nehmen wir an, John und Jessica beginnen gleichzeitig zu arbeiten. John beendet seine Änderung und pusht sie auf den Server. Dann versucht Jessica, ihre Änderungen zu pushen, aber der Server lehnt sie ab. Ihr wird mitgeteilt, dass sie versucht, Nicht-Fast-Forward-Änderungen zu pushen, und dass sie dies erst tun kann, wenn sie fetched und mergt. Dieser Workflow ist für viele attraktiv, da es sich um ein Paradigma handelt, das vielen vertraut und angenehm ist.
Dies ist auch nicht auf kleine Teams beschränkt. Mit dem Branching-Modell von Git ist es möglich, dass Hunderte von Entwicklern gleichzeitig an einem einzigen Projekt über Dutzende von Branches arbeiten.
Integrationsmanager-Workflow
Da Git Ihnen erlaubt, mehrere entfernte Repositories zu haben, ist es möglich, einen Workflow zu haben, bei dem jeder Entwickler Schreibzugriff auf sein eigenes öffentliches Repository und Lesezugriff auf die Repositories aller anderen hat. Dieses Szenario beinhaltet oft ein kanonisches Repository, das das "offizielle" Projekt darstellt. Um zu diesem Projekt beizutragen, erstellen Sie Ihren eigenen öffentlichen Klon des Projekts und pushen Ihre Änderungen dorthin. Dann können Sie dem Maintainer des Hauptprojekts eine Anfrage senden, Ihre Änderungen zu pullen. Der Maintainer kann dann Ihr Repository als Remote hinzufügen, Ihre Änderungen lokal testen, sie in seinen Branch mergen und zurück in sein Repository pushen. Der Prozess funktioniert wie folgt (siehe Integrationsmanager-Workflow)
-
Der Projektverantwortliche pusht in sein öffentliches Repository.
-
Ein Mitwirkender klont dieses Repository und nimmt Änderungen vor.
-
Der Mitwirkende pusht in seine eigene öffentliche Kopie.
-
Der Mitwirkende sendet dem Maintainer eine E-Mail mit der Bitte, die Änderungen zu pullen.
-
Der Maintainer fügt das Repository des Mitwirkenden als Remote hinzu und mergt lokal.
-
Der Maintainer pusht die gemergten Änderungen in das Haupt-Repository.
Dies ist ein sehr gängiger Workflow mit Hub-basierten Tools wie GitHub oder GitLab, wo es einfach ist, ein Projekt zu forken und Ihre Änderungen in Ihren Fork zu pushen, damit jeder sie sehen kann. Einer der Hauptvorteile dieses Ansatzes ist, dass Sie weiterarbeiten können und der Maintainer des Haupt-Repositories Ihre Änderungen jederzeit pullen kann. Mitwirkende müssen nicht darauf warten, dass das Projekt ihre Änderungen übernimmt – jede Partei kann in ihrem eigenen Tempo arbeiten.
Diktator- und Leutnant-Workflow
Dies ist eine Variante eines Multi-Repository-Workflows. Er wird generell von riesigen Projekten mit Hunderten von Mitwirkenden verwendet; ein berühmtes Beispiel ist der Linux-Kernel. Verschiedene Integrationsmanager sind für bestimmte Teile des Repositories verantwortlich; sie werden Leutnants genannt. Alle Leutnants haben einen Integrationsmanager, der als wohlwollender Diktator bekannt ist. Der wohlwollende Diktator pusht von seinem Verzeichnis in ein Referenz-Repository, von dem aus alle Mitwirkenden pullen müssen. Der Prozess funktioniert so (siehe Wohlwollender Diktator-Workflow)
-
Reguläre Entwickler arbeiten an ihrem Topic-Branch und rebasen ihre Arbeit auf
master. Dermaster-Branch ist der des Referenz-Repositories, in das der Diktator pusht. -
Leutnants mergen die Topic-Branches der Entwickler in ihren
master-Branch. -
Der Diktator mergt die
master-Branches der Leutnants in denmaster-Branch des Diktators. -
Schließlich pusht der Diktator diesen
master-Branch in das Referenz-Repository, damit die anderen Entwickler darauf basieren können.
Diese Art von Workflow ist nicht üblich, kann aber bei sehr großen Projekten oder in stark hierarchischen Umgebungen nützlich sein. Sie ermöglicht es dem Projektleiter (dem Diktator), viel Arbeit zu delegieren und große Code-Teilmengen an mehreren Punkten zu sammeln, bevor sie integriert werden.
Muster zur Verwaltung von Quellcode-Branches
|
Hinweis
|
Martin Fowler hat eine Anleitung "Patterns for Managing Source Code Branches" erstellt. Diese Anleitung behandelt alle gängigen Git-Workflows und erklärt, wie/wann sie verwendet werden. Es gibt auch einen Abschnitt, der hohe und niedrige Integrationsfrequenzen vergleicht. |
Workflows Zusammenfassung
Dies sind einige gängige Workflows, die mit einem verteilten System wie Git möglich sind, aber Sie können sehen, dass viele Variationen möglich sind, um Ihren spezifischen realen Workflow anzupassen. Nachdem Sie nun hoffentlich bestimmen können, welche Workflow-Kombination für Sie funktionieren könnte, werden wir einige spezifischere Beispiele dafür behandeln, wie die Hauptrollen, aus denen sich die verschiedenen Flows zusammensetzen, umgesetzt werden. Im nächsten Abschnitt lernen Sie einige gängige Muster für die Mitwirkung an einem Projekt kennen.