Organisation des Mehrbenutzerzugriffs auf den GIT-Server

Bei der Einrichtung und Konfiguration eines Git-Servers kommt die Frage auf, wie man den Zugriff mehrerer Benutzer auf verschiedene Projekte organisiert. Ich habe das Thema untersucht und eine Lösung gefunden, die all meinen Anforderungen entspricht: einfach, sicher und zuverlässig.

Meine Anforderungen sind folgende:

• jeder Benutzer soll sich mit einem eigenen Konto anmelden
• mehrere Benutzer sollten an einem Projekt arbeiten können
• derselbe Benutzer kann an mehreren Projekten arbeiten
• jeder Benutzer hat nur Zugang zu den Projekten, an denen er arbeitet
• es sollte die Möglichkeit geben, sich über die Eingabeaufforderung zu verbinden, und nicht nur über eine Weboberfläche

Es wäre auch toll:

• Leserechte für Aufsichtspersonen bereitzustellen
• Benutzer berechtigungen im Git einfach zu verwalten

Überblick über mögliche Zugangsoptionen zum GIT-Server

Zunächst muss man wissen, aus was man wählen kann, daher ein kurzer Überblick über die Git-Protokolle.

• ssh — es wird ein speziell eingerichtetes Benutzerkonto für den Zugriff auf den Server verwendet.
  • Es ist merkwürdig, dass Git nicht empfiehlt, ein einzelnes Konto für den Zugriff auf alle Repositories zu verwenden. Das entspricht nicht meinen Anforderungen.
  • Es können mehrere Konten verwendet werden, aber wie kann man den Zugriff eines Benutzers nur auf bestimmte Verzeichnisse beschränken?
    • Ein Home-Verzeichnis zu verwenden, ist nicht ideal, da es schwierig ist, anderen Benutzern Schreibzugriff zu gewähren.
    • Es ist auch kompliziert, symbolische Links aus dem Home-Verzeichnis zu nutzen, da Git sie nicht als Links interpretiert.
    • Den Zugriff auf den Interpreter einzuschränken ist möglich, aber es gibt keine Garantie, dass es immer funktioniert.
      • Man könnte sogar für solche Benutzer einen eigenen Befehlsinterpreter nutzen, aber
        • erstens wäre das eine komplexe Lösung,
        • und zweitens könnte man das umgehen.

  Aber vielleicht ist es kein Problem, dass Benutzer beliebige Befehle ausführen können?… Man sollte diese Methode nicht ausschließen, wenn man darüber nachdenkt, wie man sie konkret einsetzen kann. Lassen Sie uns später zu diesem Ansatz zurückkehren und zuvor kurz die anderen Alternativen betrachten; vielleicht gibt es dort einfachere Lösungen.

• Das git-Protokoll kann zusammen mit sshfs verwendet werden. Mehrere Benutzer sind möglich, aber im Grunde genommen ist es dasselbe wie im vorherigen Fall.
• HTTP — nur lesbar
• Git — nur lesbar
• HTTPS — schwer einzurichten, benötigt zusätzliche Software. Verwaltungspanel Für die Organisation des Benutzerzugangs... es sieht machbar aus, aber es ist irgendwie kompliziert.

Verwendung des SSH-Protokolls für den Mehrbenutzerzugang zu Git-Servern

Kehren wir zum SSH-Protokoll zurück.

Da der Zugriff über SSH für Git verwendet wird, muss die Datensicherheit des Servers gewährleistet sein. Der Benutzer, der sich über SSH verbindet, nutzt sein eigenes Login auf Server Linux, sodass er sich über einen SSH-Client verbinden und auf die Befehlszeile des Servers zugreifen kann.
Es gibt keinen vollständigen Schutz gegen den Zugriff.

Für den Benutzer sollten die Linux-Dateien jedoch nicht von Interesse sein. Bedeutende Informationen werden nur im Git-Repository gespeichert. Daher kann der Zugriff über die Befehlszeile nicht eingeschränkt, aber durch Linux-Mittel verboten werden, dass der Benutzer Projekte sieht, an denen er nicht beteiligt ist.
Offensichtlich ist es notwendig, ein Zugriffsrechtesystem unter Linux zu verwenden.

Wie bereits erwähnt, kann nur ein einziges Konto für den SSH-Zugang genutzt werden. Diese Konfiguration ist für mehrere Nutzer unsicher, obwohl diese Methode in der Liste der empfohlenen Git-Optionen aufgeführt ist.

Um die zu Beginn des Artikels genannten Anforderungen zu erfüllen, wird die folgende Verzeichnisstruktur mit festgelegten Rechten und Eigentümern erstellt:

1) Projektverzeichnisse

dir1(proj1:proj1,0770)
dir2(proj2:proj2,0770)
dir3(proj3:proj3,0770)
…
wobei
dir1, dir2, dir3 – Projektverzeichnisse: Projekt 1, Projekt 2, Projekt 3.

proj1:proj1, proj2:proj2, proj3:proj3 – speziell erstellte Linux-Nutzer, die als Eigentümer der entsprechenden Projektverzeichnisse zugewiesen werden.

Die Rechte für alle Verzeichnisse werden auf 0770 festgelegt – vollständiger Zugriff für den Eigentümer und dessen Gruppe sowie vollständiges Verbot für alle anderen.

2) Entwicklerkonten

Entwickler 1: dev1:dev1,proj1,proj2
Entwickler 2: dev2:dev2,proj2,proj3

Der entscheidende Punkt ist, dass den Entwicklern eine zusätzliche Gruppe des Systembenutzers, der Eigentümer des entsprechenden Projekts ist, zugewiesen wird. Dies erfolgt durch den Administrator des Linux-Servers mit einem einzigen Befehl.

In diesem Beispiel arbeitet "Entwickler 1" an den Projekten proj1 und proj2, während "Entwickler 2" an den Projekten proj2 und proj3 arbeitet.

Wenn einer der Entwickler über SSH über die Eingabeaufforderung verbindet, hat er nicht einmal die Berechtigungen, um den Inhalt der Projektverzeichnisse, an denen er nicht beteiligt ist, anzusehen. Er kann dies nicht selbst ändern.

Da die Grundlage dieses Prinzips die grundlegende Sicherheit von Linux-Rechten ist, ist dieses Schema zuverlässig. Darüber hinaus ist das Schema sehr einfach zu administrieren.

Kommen wir zur Praxis.

Erstellen von Git-Repositories auf einem Linux-Server

Überprüfen wir.

[root@server ~]# cd /var/
[root@server var]# useradd gitowner
[root@server var]# mkdir gitservertest
[root@server var]# chown gitowner:gitowner gitservertest
[root@server var]# adduser proj1
[root@server var]# adduser proj2
[root@server var]# adduser proj3
[root@server var]# adduser dev1
[root@server var]# adduser dev2
[root@server var]# passwd dev1
[root@server var]# passwd dev2

es ist mühsam, alles von Hand einzugeben...

[root@server gitservertest]# sed "s/ /n/g" <<< "proj1 proj2 proj3" | while read u; do mkdir $u; chown $u:$u $u; chmod 0770 $u; done

[root@server gitservertest]# usermod -aG proj1 dev1
[root@server gitservertest]# usermod -aG proj2 dev1
[root@server gitservertest]# usermod -aG proj2 dev2
[root@server gitservertest]# usermod -aG proj3 dev2

Wir stellen sicher, dass es unmöglich ist, über die Eingabeaufforderung auf die Repositories anderer zuzugreifen oder sogar deren Inhalt anzusehen.

[dev1@server ~]$ cd /var/gitservertest/proj3
-bash: cd: /var/gitservertest/proj3: Permission denied
[dev1@server ~]$ ls /var/gitservertest/proj3
ls: cannot open directory /var/gitservertest/proj3: Permission denied

Gemeinsame Arbeit mehrerer Entwickler an einem Git-Projekt.

Es bleibt eine Frage: Wenn ein Entwickler eine neue Datei hinzufügt, können die anderen Entwickler diese nicht ändern, da er der Eigentümer der Datei ist (z. B. dev1) und nicht der projektbezogene Benutzer (z. B. proj1). Da wir ein Server-Repository haben, ist es zunächst wichtig zu wissen, wie das Verzeichnis „.git“ strukturiert ist und ob neue Dateien erstellt werden.

Erstellung eines lokalen Git-Repositories und Push auf den Git-Server.

Lassen Sie uns auf die Client-Maschine wechseln.

Microsoft Windows [Version 6.1.7601]
(c) Microsoft Corporation, 2009. Alle Rechte vorbehalten.

C:gittest>git init .
Leeres Git-Repository in C:/gittest/.git/ initialisiert.

C:gittest>echo "test dev1 to proj2" > test1.txt

C:gittest>git add .

C:gittest>git status
Auf dem Branch master
Keine Commits vorhanden
Änderungen, die committet werden:
  (verwenden Sie "git rm --cached <file>...", um die Staging-Phase aufzuheben)
        neue Datei:   test1.txt

C:gittest>git commit -am "neue Testdatei hinzugefügt"
[master (root-commit) a7ac614] neue Testdatei hinzugefügt
 1 Datei geändert, 1 Einfügung(+)
 Erstelle Modus 100644 test1.txt
 
C:gittest>git remote add origin "ssh://dev1@10.1.1.11/var/gitservertest/proj2"

C:gittest>git push origin master
dev1:dev1@10.1.1.11's Passwort:
Objekte zählen: 3, fertig.
Objekte schreiben: 100% (3/3), 243 Bytes | 243.00 KiB/s, fertig.
Insgesamt 3 (delta 0), 0 wiederverwendet (delta 0)
Zu ssh://10.1.1.11/var/gitservertest/proj2
 * [neuer Branch]      master -> master

C:gittest>

Zur selben Zeit entstehen auf dem Server neue Dateien, die dem Benutzer gehören, der den Push durchgeführt hat.

[dev1@server proj2]$ tree
.
├── 1.txt
├── branches
├── config
├── description
├── HEAD
├── hooks
│   ├── applypatch-msg.sample
│   ├── commit-msg.sample
│   ├── post-update.sample
│   ├── pre-applypatch.sample
│   ├── pre-commit.sample
│   ├── prepare-commit-msg.sample
│   ├── pre-push.sample
│   ├── pre-rebase.sample
│   └── update.sample
├── info
│   └── exclude
├── objects
│   ├── 75
│   │   └── dcd269e04852ce2f683b9eb41ecd6030c8c841
│   ├── a7
│   │   └── ac6148611e69b9a074f59a80f356e1e0c8be67
│   ├── f0
│   │   └── 82ea1186a491cd063925d0c2c4f1c056e32ac3
│   ├── info
│   └── pack
└── refs
    ├── heads
    │   └── master
    └── tags

12 Verzeichnisse, 18 Dateien
[dev1@server proj2]$ ls -l objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
-r--r--r--. 1 dev1 dev1 54 Jun 20 14:34 objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
[dev1@server proj2]$

Beim Hochladen von Änderungen auf den Server werden zusätzliche Dateien und Verzeichnisse erstellt, und tatsächlich gehört der Eigentümer dieser Dateien zu dem Benutzer, der das Hochladen durchführt. In diesem Fall entspricht die Gruppe dieser Dateien und Verzeichnisse auch der Hauptgruppe dieses Benutzers, das heißt, die Gruppe dev1 für den Benutzer dev1 und die Gruppe dev2 für den Benutzer dev2 (eine Änderung der Hauptgruppe des Entwicklers hilft nicht, da man sonst nicht an mehreren Projekten arbeiten kann). In diesem Fall kann Benutzer dev2 die von Benutzer dev1 erstellten Dateien nicht ändern, was die Funktionalität beeinträchtigen kann.

Linux chown — Ändern des Dateieigentümers durch einen normalen Benutzer

Der Eigentümer einer Datei kann deren Zugehörigkeit nicht ändern. Er kann jedoch die Gruppe der Datei ändern, die ihm gehört, und dann kann diese Datei von anderen Benutzern, die sich in derselben Gruppe befinden, geändert werden. Das ist genau das, was wir brauchen.

Verwendung von Git Hook

Das Arbeitsverzeichnis für den Hook ist das Stammverzeichnis des Projekts. Der Hook ist eine ausführbare Datei, die unter dem Benutzer ausgeführt wird, der das Push-Dokument überträgt. Mit diesem Wissen können wir das Vorhaben umsetzen.

[dev1@server proj2]$ mv hooks/post-update{.sample,}
[dev1@server proj2]$ sed -i '2,$ s/^/#/' hooks/post-update
[dev1@server proj2]$ cat <<> hooks/post-update

oder einfach

vi hooks/post-update

Lassen Sie uns zur Client-Maschine zurückkehren.

C:gittest>echo "dev1 3. Zeile" >> test1.txt

C:gittest>git commit -am "3. von dev1, Server-Hook testen"
[master b045e22] 3. von dev1, Server-Hook testen
 1 Datei geändert, 1 Einfügung(+)

C:gittest>git push origin master
dev1:dev1@10.1.1.11's Passwort:
   d22c66e..b045e22  master -> master

Überprüfen Sie auf dem Git-Server nach dem Commit, ob der post-update Hook funktioniert.

[dev1@server proj2]$ find . ! -group proj2

— leer, alles in Ordnung.

Einbindung des zweiten Entwicklers in Git

Simulieren wir die Arbeit des zweiten Entwicklers.

Auf dem Client

C:gittest>git remote remove origin

C:gittest>git remote add origin "ssh://dev2@10.1.1.11/var/gitservertest/proj2"

C:gittest>echo "!!! dev2 hat dies hinzugefügt" >> test1.txt

C:gittest>echo "!!! dev2 schrieb" > test2.txt

C:gittest>git add test2.txt

C:gittest>git commit -am "dev2 hat test1 ergänzt und test2 erstellt"
[master 55d49a6] dev2 hat test1 ergänzt und test2 erstellt
 2 Dateien geändert, 2 Einfügungen(+)
 Erstellmodus 100644 test2.txt

C:gittest>git push origin master
dev2@10.1.1.11's Passwort:
   b045e22..55d49a6  master -> master

Und gleichzeitig, auf dem Server…

[dev1@server proj2]$ find . ! -group proj2

— wieder nichts, alles funktioniert.

Löschen des Git-Projekts und Herunterladen des Projekts vom Git-Server

Nun können wir uns noch einmal vergewissern, dass alle Änderungen gespeichert wurden.

C:gittest>rd /S /Q .
Der Prozess kann auf die Datei nicht zugreifen, da diese von einem anderen Prozess verwendet wird.

— für das Löschen des Git-Projekts löschen wir einfach das gesamte Verzeichnis. Wir akzeptieren die angezeigte Fehlermeldung, da das aktuelle Verzeichnis mit diesem Befehl nicht gelöscht werden kann, aber genau dieses Verhalten brauchen wir.

C:gittest>dir
 Inhalt des Ordners C:gittest

21.06.2019  08:43              .
21.06.2019  08:43              ..

C:gittest>git clone ssh://dev2@10.1.1.11/var/gitservertest/proj2
Klonen in 'proj2'...
dev2@10.1.1.11's Passwort:

C:gittest>cd proj2

C:gittestproj2>dir
 Inhalt des Ordners C:gittestproj2

21.06.2019  08:46              .
21.06.2019  08:46              ..
21.06.2019  08:46               114 test1.txt
21.06.2019  08:46                19 test2.txt
C:gittestproj2>type test1.txt
"test dev1 zu proj2"
"dev1 hat etwas hinzugefügt"
"dev1 3. Zeile"
"!!! dev2 hat dies hinzugefügt"

C:gittestproj2>type test2.txt
"!!! dev2 schrieb"

Zugriffsteilung in Git

Jetzt vergewissern wir uns, dass auch über Git der zweite Entwickler keinen Zugang zum Projekt Proj1 hat, an dem er nicht arbeitet.

C:gittestproj2>git remote remove origin

C:gittestproj2>git remote add origin "ssh://dev2@10.1.1.11/var/gitservertest/proj1"

C:gittestproj2>git push origin master
dev2@10.1.1.11's password:
fatal: '/var/gitservertest/proj1' scheint kein Git-Repository zu sein
fatal: Konnte nicht vom Remote-Repository lesen.

Bitte stellen Sie sicher, dass Sie die richtigen Zugriffsrechte haben
und das Repository existiert.

Jetzt gewähren wir den Zugang

[root@server ~]# usermod -aG proj1 dev2

und danach funktioniert alles.

C:gittestproj2>git push origin master
dev2@10.1.1.11's password:
To ssh://10.1.1.11/var/gitservertest/proj1
 * [neuer Branch]      master -> master

Weitere Informationen

Zusätzlich, falls es ein Standardberechtigungsproblem beim Erstellen von Dateien und Verzeichnissen gibt, kann in CentOS der Befehl

setfacl -Rd -m o::5 -m g::7 /var/gitservertest

In dem Artikel finden Sie auch einige nützliche Kleinigkeiten:

• wie man in Linux ein Verzeichnisbaum erstellt
• wie man in sed einen Adressbereich von einer bestimmten Zeile bis zum Ende der Datei übergibt, also in sed eine Ersetzung in allen Zeilen außer der ersten Zeile durchführt
• Wie man in Linux find die Suchbedingungen inverteriert
• wie man in der Linux-Shell mehrere Zeilen über eine Einzeilige in eine Schleife übergibt
• wie man in bash einfache Anführungszeichen escaped
• wie man in der Windows-Eingabeaufforderung ein Verzeichnis mit allem Inhalt löscht
• Wie man mit bash mv eine Datei umbenennt, ohne sie neu zu schreiben

Vielen Dank für Ihre Aufmerksamkeit.

Quelle: habr.com