Merge pull request #84 from max123kl/Chapter-7-14

Datei credentials.asc übersetzt

Author: max123kl

book/07-git-tools/sections/credentials.asc

@@ -3,47 +3,47 @@
 
 (((credentials)))
 (((git commands, credential)))
-If you use the SSH transport for connecting to remotes, it's possible for you to have a key without a passphrase, which allows you to securely transfer data without typing in your username and password.
-However, this isn't possible with the HTTP protocols – every connection needs a username and password.
-This gets even harder for systems with two-factor authentication, where the token you use for a password is randomly generated and unpronounceable.
-
-Fortunately, Git has a credentials system that can help with this.
-Git has a few options provided in the box:
-
-* The default is not to cache at all.
-  Every connection will prompt you for your username and password.
-* The ``cache'' mode keeps credentials in memory for a certain period of time.
-  None of the passwords are ever stored on disk, and they are purged from the cache after 15 minutes.
-* The ``store'' mode saves the credentials to a plain-text file on disk, and they never expire.
-  This means that until you change your password for the Git host, you won't ever have to type in your credentials again.
-  The downside of this approach is that your passwords are stored in cleartext in a plain file in your home directory.
-* If you're using a Mac, Git comes with an ``osxkeychain'' mode, which caches credentials in the secure keychain that's attached to your system account.
-  This method stores the credentials on disk, and they never expire, but they're encrypted with the same system that stores HTTPS certificates and Safari auto-fills.
-* If you're using Windows, you can install a helper called ``Git Credential Manager for Windows.''
-  This is similar to the ``osxkeychain'' helper described above, but uses the Windows Credential Store to control sensitive information.
-  It can be found at https://github.com/Microsoft/Git-Credential-Manager-for-Windows[].
-
-You can choose one of these methods by setting a Git configuration value:
+Wenn Sie den SSH-Transport für die Verbindung zu Remotes verwenden, ist es möglich, dass Sie einen Schlüssel ohne Passwort verwenden. Damit können Sie Daten sicher übertragen, ohne Ihren Benutzernamen und ein Passwort einzugeben.
+Mit den HTTP-Protokollen ist das aber nicht möglich – jede Verbindung benötigt einen Benutzernamen und ein Passwort.
+Noch schwieriger wird das bei Systemen mit Zwei-Faktor-Authentifizierung, bei denen das Token, das Sie für ein Kennwort verwenden, zufällig generiert wird und nicht ausgeprochen werden kann.
+
+Glücklicherweise hat Git ein Anmeldesystem, das hier weiter helfen kann.
+Git hat ein paar Optionen im Angebot:
+
+* Standardmäßig wird überhaupt nicht zwischengespeichert.
+  Bei jeder Verbindung wird nach Ihrem Benutzernamen und Passwort gefragt.
+* Der „Cache“-Modus hält die Anmeldedaten für eine gewisse Zeitspanne im Zwischenspeicher.
+Keines der Passwörter wird jemals auf der Festplatte abgelegt und nach 15 Minuten werden sie aus dem Cache gelöscht.
+* Der „Speicher“-Modus speichert die Zugangsdaten in einer Klartextdatei auf der Festplatte, und sie verfallen nie.
+Das bedeutet, dass Sie Ihre Anmeldedaten nie wieder eingeben müssen, bis Sie Ihr Passwort für den Git-Host ändern.
+Der Nachteil dieses Ansatzes ist, dass Ihre Passwörter im Klartext in einer einfachen Datei in Ihrem Homeverzeichnis gespeichert werden.
+* Wenn Sie einen Mac verwenden, verfügt Git über einen „osxkeychain“-Modus, der die Anmeldeinformationen im sicheren Schlüsselbund, der an Ihr Systemkonto angehängt ist, zwischenspeichert.
+Diese Methode speichert die Zugangsdaten, ohne Laufzeitbegrenzung auf der Festplatte. Sie werden mit dem gleichen Verfahren verschlüsselt, das auch HTTPS-Zertifikate und Safari-Automatiken verwaltet.
+* Wenn Sie Windows verwenden, können Sie das Hilfsprogramm „Git Credential Manager for Windows“ installieren.
+Dieses Programm ähnelt dem oben beschriebenen "osxkeychain"-Modus, verwendet jedoch den „Windows Credential Store“ zur Kontrolle sensibler Informationen.
+Es ist unter https://github.com/Microsoft/Git-Credential-Manager-for-Windows[] zu finden.
+
+Sie können eine dieser Methoden durch Setzen eines Git-Konfigurationswertes wählen:
 
 [source,console]
 ----
 $ git config --global credential.helper cache
 ----
 
-Some of these helpers have options.
-The ``store'' helper can take a `--file <path>` argument, which customizes where the plain-text file is saved (the default is `~/.git-credentials`).
-The ``cache'' helper accepts the `--timeout <seconds>` option, which changes the amount of time its daemon is kept running (the default is ``900'', or 15 minutes).
-Here's an example of how you'd configure the ``store'' helper with a custom file name:
+Einige dieser Hilfsmittel haben Optionen.
+Der „store“-Assistent kann das Argument `--file <path>` benutzen, das den Speicherort der Klartextdatei anpasst (der Standard ist `~/.git-credentials`).
+Der „cache“-Assistent akzeptiert die Option `--timeout <seconds>`, welche die Zeitspanne ändert, in der der Dämon läuft (die Vorgabe ist „900“, oder 15 Minuten).
+Hier folgt ein Beispiel, wie Sie der „store“-Assistent mit einem benutzerdefinierten Dateinamen konfigurieren könnten:
 
 [source,console]
 ----
 $ git config --global credential.helper 'store --file ~/.my-credentials'
 ----
 
-Git even allows you to configure several helpers.
-When looking for credentials for a particular host, Git will query them in order, and stop after the first answer is provided.
-When saving credentials, Git will send the username and password to *all* of the helpers in the list, and they can choose what to do with them.
-Here's what a `.gitconfig` would look like if you had a credentials file on a thumb drive, but wanted to use the in-memory cache to save some typing if the drive isn't plugged in:
+Mit Git können Sie auch mehrere Assistenten konfigurieren.
+Wenn Sie nach Anmeldeinformationen für einen bestimmten Host suchen, fragt Git diese der Reihe nach ab und stoppt nach der ersten, erhaltenen Antwort.
+Beim Speichern der Zugangsdaten sendet Git den Benutzernamen und das Passwort an *alle* Assistenten der Liste, diese entscheiden, was damit zu machen ist.
+So würde eine `.gitconfig` aussehen, wenn Sie eine Datei mit Zugangsdaten auf einem USB-Stick hätten, aber den Zwischenspeicher nutzen wollten, um sich die Eingabe zu sparen, wenn das Laufwerk nicht angeschlossen ist:
 
 [source,ini]
 ----
@@ -52,14 +52,14 @@ Here's what a `.gitconfig` would look like if you had a credentials file on a th
     helper = cache --timeout 30000
 ----
 
-==== Under the Hood
+==== Unter der (Motor-)Haube
 
-How does this all work?
-Git's root command for the credential-helper system is `git credential`, which takes a command as an argument, and then more input through stdin.
+Wie funktioniert das alles?
+Der Hauptbefehl für das Anmelde-System ist `git credential`, der einen Befehl als Argument und dann weitere Eingaben über stdin (Standardeingabe=Tastatur) entgegennimmt.
 
-This might be easier to understand with an example.
-Let's say that a credential helper has been configured, and the helper has stored credentials for `mygithost`.
-Here's a session that uses the ``fill'' command, which is invoked when Git is trying to find credentials for a host:
+Mit einem Beispiel ist das vielleicht leichter verständlich.
+Nehmen wir an, dass ein Assistent für die Anmeldung konfiguriert wurde und er Anmeldedaten für `mygithost` gespeichert hat.
+Die folgende Sitzung verwendet den Befehl „fill“, der aufgerufen wird, wenn Git versucht, Zugangsdaten für einen Host zu finden:
 
 [source,console]
 ----
@@ -83,39 +83,39 @@ username=bob
 password=s3cre7
 ----
 
-<1> This is the command line that initiates the interaction.
-<2> Git-credential is then waiting for input on stdin.
-    We provide it with the things we know: the protocol and hostname.
-<3> A blank line indicates that the input is complete, and the credential system should answer with what it knows.
-<4> Git-credential then takes over, and writes to stdout with the bits of information it found.
-<5> If credentials are not found, Git asks the user for the username and password, and provides them back to the invoking stdout (here they're attached to the same console).
+<1> Diese Befehlszeile leitet die eigentliche Interaktion ein.
+<2> Das Anmeldesystem wartet auf die Eingabe von stdin.
+    Wir geben das „Protokoll“ und den „Hostnamen“ ein.
+<3> Eine leere Zeile signalisiert, dass die Eingabe vollständig ist und das Anmeldesystem sollte mit dem antworten, was ihm bekannt ist.
+<4> Dann übernimmt das Programm Git-Credential und gibt auf stdout die gefundenen Informationen aus.
+<5> Falls keine Anmeldeinformationen gefunden werden, fragt Git den Benutzer nach dem Benutzernamen und dem Kennwort und gibt sie an den aufrufenden stdout zurück (hier sind sie an dieselbe Konsole angeschlossen).
 
-The credential system is actually invoking a program that's separate from Git itself; which one and how depends on the `credential.helper` configuration value.
-There are several forms it can take:
+Das Anmeldesystem ruft in Wirklichkeit ein Programm auf, das von Git selbst unabhängig ist und bei dem der Konfigurationswert `credential.helper` bestimmt, was und auf welche Weise es aufgerufen wird.
+Es kann unterschiedliche Varianten anbieten:
 
 [options="header"]
 |======
-| Configuration Value | Behavior
-| `foo` | Runs `git-credential-foo`
-| `foo -a --opt=bcd` | Runs `git-credential-foo -a --opt=bcd`
-| `/absolute/path/foo -xyz` | Runs `/absolute/path/foo -xyz`
-| `!f() { echo "password=s3cre7"; }; f` | Code after `!` evaluated in shell
+| Konfiguration-Wert | Verhalten
+| `foo` | läuft als `git-credential-foo`
+| `foo -a --opt=bcd` | läuft als `git-credential-foo -a --opt=bcd`
+| `/absolute/path/foo -xyz` | läuft als `/absolute/path/foo -xyz`
+| `!f() { echo "password=s3cre7"; }; f` | Code nach `!` wird in der Shell ausgewertet
 |======
 
-So the helpers described above are actually named `git-credential-cache`, `git-credential-store`, and so on, and we can configure them to take command-line arguments.
-The general form for this is ``git-credential-foo [args] <action>.''
-The stdin/stdout protocol is the same as git-credential, but they use a slightly different set of actions:
+Die oben beschriebenen Hilfsprogramme heißen also eigentlich `git-credential-cache`, `git-credential-store` usw. und wir können sie so konfigurieren, dass sie Befehlszeilenargumente übernehmen.
+Die allgemeine Form dafür ist „git-credential-foo [Argument] <Aktion>“.
+Das stdin/stdout-Protokoll ist das gleiche wie beim Anmeldesystem, aber sie verwenden einen etwas anderen Befehls-Satz:
 
-* `get` is a request for a username/password pair.
-* `store` is a request to save a set of credentials in this helper's memory.
-* `erase` purge the credentials for the given properties from this helper's memory.
+* `get` ist die Abfrage nach einem Benutzernamen/Passwort-Paar.
+* `store` ist die Aufforderung, einen Satz von Anmeldeinformationen im Speicher dieses Assistenten zu hinterlegen.
+* `erase` löscht die Anmeldeinformationen für die angegebenen Einstellungen aus dem Speicher dieses Assistenten.
 
-For the `store` and `erase` actions, no response is required (Git ignores it anyway).
-For the `get` action, however, Git is very interested in what the helper has to say.
-If the helper doesn't know anything useful, it can simply exit with no output, but if it does know, it should augment the provided information with the information it has stored.
-The output is treated like a series of assignment statements; anything provided will replace what Git already knows.
+Für die `store` und `erase` Aktionen ist keine Reaktion erforderlich (Git ignoriert sie ohnehin).
+Für die Aktion `get` ist Git allerdings stark darauf bedacht, was der Assistent sagt.
+Wenn das Hilfsprogramm nichts Sinnvolles kennt, kann es einfach ohne Ausgabe abbrechen. Weiß es aber etwas, sollte es die bereitgestellten Informationen mit den gespeicherten Informationen ergänzen.
+Die Ausgabe wird wie eine Reihe von Assignment-Statements behandelt. Alles, was zur Verfügung gestellt wird, ersetzt das, was Git bereits kennt.
 
-Here's the same example from above, but skipping git-credential and going straight for git-credential-store:
+Hier ist das gleiche Beispiel von oben, aber ohne das Git-Anmeldesystem und direkt zu `git-credential-store`:
 
 [source,console]
 ----
@@ -132,52 +132,52 @@ username=bob <3>
 password=s3cre7
 ----
 
-<1> Here we tell `git-credential-store` to save some credentials: the username ``bob'' and the password ``s3cre7'' are to be used when `https://mygithost` is accessed.
-<2> Now we'll retrieve those credentials.
-    We provide the parts of the connection we already know (`https://mygithost`), and an empty line.
-<3> `git-credential-store` replies with the username and password we stored above.
+<1> Hier weisen wir `git-credential-store` an, einige Anmeldedaten zu speichern: der Benutzername „bob“ und das Passwort „s3cre7“ sollen verwendet werden, wenn auf `https://mygithost` zugegriffen wird.
+<2> Jetzt rufen wir diese Anmeldedaten ab.
+    Wir geben die bereits bekannten Teile der Internetadresse (`https://mygithost`) und eine leere Zeile ein.
+<3> `git-credential-store` antwortet mit dem Benutzernamen und dem Passwort, die wir beide oben gespeichert haben.
 
-Here's what the `~/git.store` file looks like:
+So sieht die Datei `~/git.store` jetzt aus:
 
 [source,ini]
 ----
 https://bob:s3cre7@mygithost
 ----
 
-It's just a series of lines, each of which contains a credential-decorated URL.
-The `osxkeychain` and `wincred` helpers use the native format of their backing stores, while `cache` uses its own in-memory format (which no other process can read).
+Sie besteht nur aus einer Reihe von Zeilen, von denen jede eine mit einem Anmeldeinformationen versehene URL enthält.
+Die Assistenten `osxkeychain` und `wincred` verwenden das native Format ihrer Zwischenspeicher, während `cache` ein eigenes Speicherformat verwendet (das kein anderer Prozess lesen kann).
 
-==== A Custom Credential Cache
+==== Benutzerdefinierter Cache für Anmeldeinformationen.
 
-Given that `git-credential-store` and friends are separate programs from Git, it's not much of a leap to realize that _any_ program can be a Git credential helper.
-The helpers provided by Git cover many common use cases, but not all.
-For example, let's say your team has some credentials that are shared with the entire team, perhaps for deployment.
-These are stored in a shared directory, but you don't want to copy them to your own credential store, because they change often.
-None of the existing helpers cover this case; let's see what it would take to write our own.
-There are several key features this program needs to have:
+Angenommen, dass `git-credential-store` und seine Verwandten von Git getrennte Programme sind, dann ist es kein großer Schritt, zu erkennen, dass _jedes_ Programm ein Hilfsprogramm für die Git-Anmeldung sein kann.
+Die von Git bereitgestellten Assistenten decken viele gewöhnliche Anwendungsfälle ab, aber nicht alle.
+Nehmen wir zum Beispiel an, Ihr Team hat einige Anmeldedaten, die dem gesamten Team zur Verfügung gestellt werden sollen, eventuell für die Entwicklung.
+Diese werden in einem freigegebenen Verzeichnis gespeichert, aber Sie möchten sie nicht in Ihr eigenes Anmeldesystem kopieren, da sie sich häufig ändern.
+Keines der vorhandenen Hilfsprogramme ist auf diesen Fall anwendbar; schauen wir mal, was nötig wäre, um unser Eigenes zu schreiben.
+Dieses Programm muss mehrere Schlüsselfunktionen haben:
 
-. The only action we need to pay attention to is `get`; `store` and `erase` are write operations, so we'll just exit cleanly when they're received.
-. The file format of the shared-credential file is the same as that used by `git-credential-store`.
-. The location of that file is fairly standard, but we should allow the user to pass a custom path just in case.
+. Die einzige Aktion, auf die wir achten müssen, ist `get`. Die Aktionen `store` und `erase` sind Schreiboperationen, also werden wir sie einfach sauber beenden, sobald sie auftauchen.
+. Das Dateiformat der Datei für die gemeinsamen Anmeldedaten ist das gleiche wie es von `git-credential-store` verwendet wird.
+. Der Speicherort dieser Datei ist eigentlich standardisiert, aber wir sollten es dem Benutzer erlauben, einen benutzerdefinierten Pfad anzugeben, nur für den Fall, dass er es wünscht.
 
-Once again, we'll write this extension in Ruby, but any language will work so long as Git can execute the finished product.
-Here's the full source code of our new credential helper:
+Noch einmal zur Erinnerung: Wir werden diese Erweiterung in Ruby schreiben, aber jede Programmiersprache wird funktionieren, solange Git das fertige Produkt ausführen kann.
+Hier ist der vollständige Quellcode unseres neuen Anmeldehelfers:
 
 [source,ruby]
 --------
 include::../git-credential-read-only[]
 --------
 
-<1> Here we parse the command-line options, allowing the user to specify the input file.
-    The default is `~/.git-credentials`.
-<2> This program only responds if the action is `get` and the backing-store file exists.
-<3> This loop reads from stdin until the first blank line is reached.
-    The inputs are stored in the `known` hash for later reference.
-<4> This loop reads the contents of the storage file, looking for matches.
-    If the protocol and host from `known` match this line, the program prints the results to stdout and exits.
+<1> Hier parsen wir die Befehlszeilenoptionen und erlauben dem Benutzer, die Eingabedatei zu spezifizieren.
+    Die Vorgabe ist `~/.git-credentials`.
+<2> Dieses Programm antwortet nur, wenn die Aktion `get` lautet und die Backup-Speicherdatei existiert.
+<3> Die Schleife hier, liest von stdin, bis die erste leere Zeile erkannt wird.
+    Die Eingaben werden im Hash `known` zur späteren Referenz gespeichert.
+<4> Die Schleife hier, liest den Inhalt der Speicherdatei und sucht nach Übereinstimmungen.
+    Wenn die Protokolldaten und der Host mit `known` in dieser Zeile übereinstimmen, gibt das Programm die Ergebnisse auf stdout aus und beendet sich.
 
-We'll save our helper as `git-credential-read-only`, put it somewhere in our `PATH` and mark it executable.
-Here's what an interactive session looks like:
+Wir speichern unser Hilfsprogramm als `git-credential-read-only`, legen es irgendwo in unserem `PATH` ab und markieren es als ausführbar.
+So sieht dann eine interaktive Sitzung aus:
 
 [source,console]
 ----
@@ -191,11 +191,11 @@ username=bob
 password=s3cre7
 ----
 
-Since its name starts with ``git-'', we can use the simple syntax for the configuration value:
+Da der Name mit „git-“ beginnt, können wir die einfache Syntax für den Konfigurationswert verwenden:
 
 [source,console]
 ----
 $ git config --global credential.helper 'read-only --file /mnt/shared/creds'
 ----
 
-As you can see, extending this system is pretty straightforward, and can solve some common problems for you and your team.
+Wie Sie sehen, ist die Erweiterung dieses Systems ziemlich unkompliziert und kann einige typische Probleme für Sie und Ihr Team lösen.