Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit Git und AWS CodeCommit
Wenn du neu bei Git und bist CodeCommit, hilft dir dieses Tutorial dabei, einige einfache Befehle zu erlernen, um dir den Einstieg zu erleichtern. Wenn Sie bereits mit Git vertraut sind, können Sie dieses Tutorial überspringen und mit [Erste Schritte mit CodeCommit ](getting-started-cc.md) fortfahren.
In diesem Tutorial erstellst du ein Repository, das eine lokale Kopie des CodeCommit Repositorys darstellt, das wir als lokales Repo bezeichnen.
Nachdem Sie das lokale Repository erstellt haben, nehmen Sie einige Änderungen daran vor. Dann senden (pushen) Sie Ihre Änderungen an das CodeCommit Repository.
Sie simulieren auch eine Teamumgebung, in der zwei Benutzer unabhängig voneinander Änderungen in ihr lokales Repository übernehmen und diese Änderungen in das CodeCommit Repository übertragen. Die Benutzer ziehen dann die Änderungen aus dem CodeCommit Repository in ihr eigenes lokales Repository, um die Änderungen zu sehen, die der andere Benutzer vorgenommen hat.
Außerdem erstellen Sie Branches und Tags und verwalten einige Zugriffsberechtigungen im CodeCommit Repository.
Wenn Sie dieses Tutorial abgeschlossen haben, sollten Sie ausreichend Übung im Umgang mit den grundlegenden Git- und CodeCommit -Konzepten haben, um sie für Ihre eigenen Projekte anzuwenden.
Sorgen Sie dafür, dass die [Voraussetzungen erfüllt sind und die Einrichtung abgeschlossen ist](setting-up.md), einschließlich:
+ Weisen Sie dem IAM-Benutzer Berechtigungen zu.
+ Richten Sie CodeCommit die Verbindung zu einem Repository über [HTTPS](setting-up-gc.md), SSH oder ein. [**git-remote-codecommit**](setting-up-git-remote-codecommit.md) Weitere Informationen zu diesen Optionen finden Sie unter [Einrichtung für AWS CodeCommit](setting-up.md).
+ Konfigurieren Sie, AWS CLI ob Sie die Befehlszeile oder das Terminal für alle Operationen verwenden möchten, einschließlich der Erstellung des Repositorys.
**Topics**
+ [
## Schritt 1: Erstellen Sie ein CodeCommit Repository
](#getting-started-create-repo)
+ [
## Schritt 2: Erstellen Sie ein lokales Repo
](#getting-started-set-up-folders)
+ [
## Schritt 3: Erstelle deinen ersten Commit
](#getting-started-create-commit)
+ [
## Schritt 4: Push deinen ersten Commit
](#getting-started-init-repo)
+ [
## Schritt 5: Teile das CodeCommit Repository und führe einen weiteren Commit per Push und Pull durch
](#getting-started-pull-commits)
+ [
## Schritt 6: Einen Branch erstellen und teilen
](#getting-started-branching)
+ [
## Schritt 7: Erstelle und teile ein Tag
](#getting-started-tags)
+ [
## Schritt 8: Zugriffsberechtigungen einrichten
](#getting-started-permissions)
+ [
## Schritt 9: Bereinigen
](#getting-started-clean-up)
## Schritt 1: Erstellen Sie ein CodeCommit Repository
In diesem Schritt verwenden Sie die CodeCommit Konsole, um das Repository zu erstellen.
Sie können diesen Schritt überspringen, wenn Sie bereits über ein CodeCommit Repository verfügen, das Sie verwenden möchten.
**Anmerkung**
Abhängig von Ihrer Nutzung können Ihnen Gebühren für die Erstellung oder den Zugriff auf ein Repository berechnet werden. Weitere Informationen finden Sie auf der CodeCommit Produktinformationsseite unter [Preise](https://aws.amazon.com/codecommit/pricing).
**Um das CodeCommit Repository zu erstellen**
1. Öffnen Sie die CodeCommit Konsole unter [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. Verwenden Sie die Regionsauswahl, um den Ort auszuwählen, AWS-Region an dem Sie das Repository erstellen möchten. Weitere Informationen finden Sie unter [Regionen und Git-Verbindungsendpunkte](regions.md).
1. Wählen Sie auf der Seite **Repositorys** die Option **Repository auswählen**.
1. Geben Sie auf der Seite **Create repository (Repository erstellen)** unter **Repository name (Repository-Name)** einen Namen für Ihr Repository ein (z. B. **MyDemoRepo**).
**Anmerkung**
Bei Repository-Namen muss die Groß- und Kleinschreibung beachtet werden. Er darf nicht mehr als 100 Zeichen enthalten. Weitere Informationen finden Sie unter [Limits](limits.md#limits-repository-names).
1. (Optional) Geben Sie unter **Description (Beschreibung)** eine Beschreibung ein (z. B. **My demonstration repository**). Dadurch können Sie und andere Benutzer den Zweck des Repositorys leichter erkennen.
1. (Optional) Wählen Sie **Tag hinzufügen**, um Ihrem Repository ein oder mehrere Repository-Tags (eine benutzerdefinierte Attributbezeichnung, mit der Sie Ihre AWS Ressourcen organisieren und verwalten können) hinzuzufügen. Weitere Informationen finden Sie unter [Kennzeichnen von Repositorys in AWS CodeCommit](how-to-tag-repository.md).
1. (Optional) Erweitern Sie **Zusätzliche Konfiguration**, um anzugeben, ob Sie den Standardschlüssel Von AWS verwalteter Schlüssel oder Ihren eigenen, vom Kunden verwalteten Schlüssel zum Verschlüsseln und Entschlüsseln der Daten in diesem Repository verwenden möchten. Wenn Sie Ihren eigenen, vom Kunden verwalteten Schlüssel verwenden möchten, müssen Sie sicherstellen, dass er dort verfügbar ist, AWS-Region wo Sie das Repository erstellen, und dass der Schlüssel aktiv ist. Weitere Informationen finden Sie unter [AWS Key Management Service und Verschlüsselung für AWS CodeCommit Repositorien](encryption.md).
1. (Optional) Wählen Sie **Amazon CodeGuru Reviewer für Java und Python aktivieren**, wenn dieses Repository Java- oder Python-Code enthält und Sie möchten, dass CodeGuru Reviewer diesen Code analysiert. CodeGuru Reviewer verwendet mehrere Modelle für maschinelles Lernen, um Codefehler zu finden und automatisch Verbesserungen und Korrekturen in Pull-Requests vorzuschlagen. Weitere Informationen finden Sie im Amazon CodeGuru Reviewer-Benutzerhandbuch.
1. Wählen Sie **Erstellen** aus.
**Anmerkung**
Die verbleibenden Schritte in diesem Tutorial werden `MyDemoRepo` für den Namen des CodeCommit Repositorys verwendet. Wenn Sie einen anderen Namen auswählen, müssen Sie diesen im gesamten Tutorial verwenden.
Weitere Informationen zum Erstellen von Repositorys, darunter auch die Erstellung eines Repositorys vom Terminal oder über die Befehlszeile, finden Sie unter [Erstellen eines -Repositorys](how-to-create-repository.md).
## Schritt 2: Erstellen Sie ein lokales Repo
In diesem Schritt richten Sie ein lokales Repository auf Ihrem lokalen Computer ein, um eine Verbindung zu Ihrem Repository herzustellen. Dazu wählen Sie ein Verzeichnis auf Ihrem lokalen Computer aus, das das lokale Repository darstellt. Sie verwenden Git, um eine Kopie Ihres leeren CodeCommit Repositorys in diesem Verzeichnis zu klonen und zu initialisieren. Anschließend geben Sie den Git-Benutzernamen und die E-Mail-Adresse an, die Sie zum Kommentieren Ihrer Commits verwendet haben.
1. [Öffne die CodeCommit Konsole unter https://console.aws.amazon.com/codesuite/ codecommit/home.](https://console.aws.amazon.com/codesuite/codecommit/home)
1. Wählen Sie in der Regionsauswahl den Ort aus, AWS-Region an dem das Repository erstellt wurde. Repositorys sind spezifisch für ein. AWS-Region Weitere Informationen finden Sie unter [Regionen und Git-Verbindungsendpunkte](regions.md).
1. Suchen Sie das Repository, zu dem Sie eine Verbindung herstellen möchten, in der Liste und wählen Sie es aus. Wählen Sie **Clone URL (URL klonen)** und dann das Protokoll aus, das Sie beim Klonen oder bei der Verbindung zu dem Repository verwenden möchten. Dadurch wird die Klon-URL kopiert.
+ Kopieren Sie die HTTPS-URL, wenn Sie entweder Git-Anmeldeinformationen mit Ihrem IAM-Benutzer oder den Credential Helper verwenden, der im Lieferumfang von enthalten ist. AWS CLI
+ Kopieren Sie die HTTPS-URL (GRC), wenn Sie den Befehl **git-remote-codecommit** auf Ihrem lokalen Computer verwenden.
+ Kopieren Sie die SSH-URL, wenn Sie ein public/private SSH-Schlüsselpaar mit Ihrem IAM-Benutzer verwenden.
**Anmerkung**
Wenn Sie statt einer Liste von Repositorys eine **Willkommensseite** sehen, sind in dem Land, in AWS-Region dem Sie angemeldet sind, keine Repositorys mit Ihrem AWS Konto verknüpft. Informationen zur Erstellung eines Repositorys finden Sie unter [Erstellen Sie ein Repository AWS CodeCommit](how-to-create-repository.md), oder befolgen Sie die Schritte im Tutorial [Erste Schritte mit Git und CodeCommit](#getting-started).
1. (Optional) Wir empfehlen, dass du deinen lokalen Git-Client so konfigurierst, dass er **main** als Namen für den Standard-Branch für dein Repository verwendet wird. Dies ist der Name, der in allen Beispielen in diesem Handbuch für den Standard-Branch verwendet wird. Es ist auch derselbe Standard-Branch-Name, den Sie CodeCommit verwenden, wenn Sie Ihren ersten Commit in der Konsole durchführen. Führen Sie den folgenden Befehl aus, um den Standard-Branch-Namen global für Ihr System zu konfigurieren:
```
git config --global init.defaultBranch main
```
Wenn Sie es vorziehen, einen anderen Standard-Branch-Namen für all Ihre Repositorys zu verwenden, **main** ersetzen Sie ihn durch Ihren bevorzugten Namen. In diesem Tutorial wird davon ausgegangen, dass Ihr Standard-Branch den Namen *main* trägt.
Wenn Sie unterschiedliche Standard-Branch-Namen für verschiedene Repositorys verwenden möchten, können Sie dieses Attribut lokal (**--local**) statt global (**--global**) setzen.
1. Klonen Sie das Repository am Terminal oder in der Befehlszeile mit dem **git clone** Befehl und geben Sie die Klon-URL ein, die Sie in Schritt 3 kopiert haben. Ihre Klon-URL hängt davon ab, welches Protokoll und welche Konfiguration Sie verwenden. Wenn Sie beispielsweise HTTPS mit Git-Anmeldeinformationen verwenden, um ein Repository zu klonen, das *MyDemoRepo* in der Region USA Ost (Ohio) benannt ist:
```
git clone https://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo my-demo-repo
```
Wenn Sie HTTPS mit **git-remote-codecommit** verwenden:
```
git clone codecommit://MyDemoRepo my-demo-repo
```
Bei Verwendung von SSH:
```
git clone ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo my-demo-repo
```
**Anmerkung**
Wenn bei dem Versuch, ein Repository zu klonen, ein Fehler angezeigt wird, haben Sie möglicherweise die Einrichtung nicht abgeschlossen, die für Ihren lokalen Computer erforderlich ist. Weitere Informationen finden Sie unter [Einrichtung für AWS CodeCommit](setting-up.md).
## Schritt 3: Erstelle deinen ersten Commit
In diesem Schritt erstellen Sie Ihren ersten Commit in Ihrem lokalen Repo. Dazu erstellen Sie zwei Beispieldateien in Ihrem lokalen Repo. Sie verwenden Git, um die Änderung in Ihrem lokalen Repository bereitzustellen und die Änderung dann in Ihr lokales Repository zu übertragen.
1. Erstellen Sie mit einem Texteditor die beiden folgenden Beispieltextdateien in Ihrem Verzeichnis. Geben Sie den Dateien die Namen `cat.txt` und `dog.txt`:
```
cat.txt
-------
The domestic cat (Felis catus or Felis silvestris catus) is a small, usually furry, domesticated, and carnivorous mammal.
```
```
dog.txt
-------
The domestic dog (Canis lupus familiaris) is a canid that is known as man's best friend.
```
1. Führen Sie aus**git config**, um Ihren Benutzernamen und Ihre E-Mail-Adresse, dargestellt durch Platzhalter*your-user-name*, *your-email-address* zu Ihrem lokalen Repository hinzuzufügen. Dies vereinfacht die Identifizierung der erstellten Commits:
```
git config --local user.name "your-user-name"
git config --local user.email your-email-address
```
1. Wenn Sie Ihren Standard-Branch-Namen nicht global festgelegt haben, als Sie das lokale Repository erstellt haben, führen Sie den folgenden Befehl aus, um den Standard-Branch-Namen auf festzulegen: **main**
```
git config --local init.defaultBranch main
```
1. Führen Sie **git add** aus, um die Änderung per Stage zu übertragen:
```
git add cat.txt dog.txt
```
1. Führen Sie **git commit** aus, um die Änderung festzuschreiben:
```
git commit -m "Added cat.txt and dog.txt"
```
**Tipp**
Um Details zu dem soeben durchgeführten Commit anzuzeigen, führen Sie **git log** aus.
## Schritt 4: Push deinen ersten Commit
In diesem Schritt pushen Sie den Commit von Ihrem lokalen Repository in Ihr CodeCommit Repository.
Run**git push**, um deinen Commit über den Standard-Remote-Namen, den Git für dein CodeCommit Repository (`origin`) verwendet, aus dem Standard-Branch in deinem lokalen Repo (`main`) zu pushen:
```
git push -u origin main
```
**Tipp**
Nachdem du Dateien in dein CodeCommit Repository gepusht hast, kannst du die CodeCommit Konsole verwenden, um den Inhalt anzusehen. Weitere Informationen finden Sie unter [Dateien in einem Repository durchsuchen](how-to-browse.md).
## Schritt 5: Teile das CodeCommit Repository und führe einen weiteren Commit per Push und Pull durch
In diesem Schritt teilst du Informationen über das CodeCommit Repository mit einem anderen Teammitglied. Das Teammitglied verwendet diese Informationen, um eine lokale Kopie zu erstellen, einige Änderungen daran vorzunehmen und dann die geänderte lokale Kopie in Ihr CodeCommit Repository zu übertragen. Anschließend ziehen Sie die Änderungen aus dem CodeCommit Repository in Ihr lokales Repository.
In diesem Tutorial wird der zweite Benutzer simuliert. Dazu lassen Sie Git zusätzlich zu dem in [Schritt 2](#getting-started-set-up-folders) erstellten Verzeichnis ein weiteres Verzeichnis erstellen. (In der Regel befindet sich dieses Verzeichnis auf einem anderen Computer.) Dieses neue Verzeichnis ist eine Kopie Ihres CodeCommit Repositorys. Alle Änderungen, die Sie an dem vorhandenen oder diesem neuen Verzeichnis vornehmen, werden unabhängig voneinander vorgenommen. Die einzige Möglichkeit, Änderungen an diesen Verzeichnissen zu erkennen, besteht darin, sie aus dem CodeCommit Repository abzurufen.
Obwohl sie sich auf demselben lokalen Computer befinden, nennen wir das vorhandene Verzeichnis *lokales Repository (local repo)* und das neue Verzeichnis *freigegebenes Repository (shared repo)*.
Aus dem neuen Verzeichnis erhalten Sie eine separate Kopie des CodeCommit Repositorys. Anschließend fügen Sie eine neue Beispieldatei hinzu, übertragen die Änderungen in das gemeinsam genutzte Repository und übertragen dann den Commit aus dem gemeinsam genutzten Repository in Ihr CodeCommit Repository.
Schließlich ziehen Sie die Änderungen aus Ihrem Repository in Ihr lokales Repo und durchsuchen es dann, um die Änderungen zu sehen, die vom anderen Benutzer übernommen wurden.
1. Wechseln Sie in das Verzeichnis `/tmp` oder in das Verzeichnis `c:\temp`.
1. Führen Sie **git clone** aus, um eine Pull-Übertragung einer Kopie des Repositorys in das freigegebene Repository (shared repo) durchzuführen:
Für HTTPS:
```
git clone https://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo shared-demo-repo
```
Für HTTPS mit **git-remote-codecommit**:
```
git clone codecommit://MyDemoRepo shared-demo-repo
```
Für SSH:
```
git clone ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo shared-demo-repo
```
**Anmerkung**
Beim Klonen eines Repositorys mit SSH auf Windows-Betriebssystemen müssen Sie möglicherweise die SSH-Schlüssel-ID wie folgt der Verbindungszeichenfolge hinzufügen:
```
git clone ssh://Your-SSH-Key-ID@git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo my-demo-repo
```
Weitere Informationen finden Sie unter [Für SSH-Verbindungen unter Windows](setting-up-ssh-windows.md).
In diesem Befehl `MyDemoRepo` steht der Name Ihres CodeCommit Repositorys. `shared-demo-repo`ist der Name des Verzeichnisses, das Git in dem `/tmp` Verzeichnis oder dem `c:\temp` Verzeichnis erstellt. Wenn Git das Verzeichnis erstellt hat, überträgt Git eine Kopie Ihres Repositorys per Pull in das Verzeichnis `shared-demo-repo`.
1. Wechseln Sie in das Verzeichnis `shared-demo-repo`:
```
(For Linux, macOS, or Unix) cd /tmp/shared-demo-repo
(For Windows) cd c:\temp\shared-demo-repo
```
1. Führen Sie **git config** den Befehl aus, um einen weiteren Benutzernamen und eine E-Mail-Adresse hinzuzufügen, die durch Platzhalter *other-user-name* und *other-email-address* dargestellt werden. Dadurch wird es einfacher, festzustellen, welche Commits von dem anderen Benutzer durchgeführt werden:
```
git config --local user.name "other-user-name"
git config --local user.email other-email-address
```
1. Erstellen Sie mit einem Texteditor die folgende Beispieltextdateien im Verzeichnis `shared-demo-repo`. Benennen Sie die Datei `horse.txt`:
```
horse.txt
-------
The horse (Equus ferus caballus) is one of two extant subspecies of Equus ferus.
```
1. Führen Sie **git add** aus, um die Änderung per Stage an das freigegebene Repository (shared repo) zu übertragen:
```
git add horse.txt
```
1. Führen Sie **git commit** aus, um die Änderung im dem freigegebenen Repository (shared repo) festzuschreiben:
```
git commit -m "Added horse.txt"
```
1. Führen Sie aus**git push**, um Ihren ersten Commit über den Standard-Remote-Namen, den Git für Ihr CodeCommit Repository (`origin`) verwendet, aus dem Standard-Branch in Ihrem lokalen Repo (`main`) zu pushen:
```
git push -u origin main
```
1. Wechsle zu deinem lokalen Repo und führe den Befehl aus**git pull**, um den Commit, den das gemeinsame Repo für das Repository vorgenommen hat, in dein lokales Repo zu ziehen. CodeCommit Führen Sie anschließend **git log** aus, um den Commit anzeigen zu lassen, der von dem freigegebenen Repository (shared repo) initiiert wurde.
## Schritt 6: Einen Branch erstellen und teilen
In diesem Schritt erstellen Sie einen Branch in Ihrem lokalen Repository, nehmen einige Änderungen vor und übertragen den Branch dann per Push in Ihr CodeCommit Repository. Anschließend ziehen Sie den Branch aus Ihrem CodeCommit Repository in das gemeinsam genutzte Repo.
Ein Branch ermöglicht Ihnen die unabhängige Entwicklung einer abweichenden Version der Repository-Inhalte (zum Beispiel, um an einer neuen Softwarefunktion zu arbeiten, ohne die Arbeit Ihrer Teammitglieder zu beeinträchtigen). Wenn diese Funktion stabil ist, können Sie den Branch mit einem stabileren Software-Branch zusammenführen.
Sie erstellen den Branch mit Git und verweisen damit auf den ersten Commit, den Sie durchgeführt haben. Sie verwenden Git, um den Branch in das CodeCommit Repository zu übertragen. Dann wechselst du zu deinem gemeinsamen Repo und verwendest Git, um den neuen Branch in dein gemeinsames lokales Repo zu ziehen und den Branch zu erkunden.
1. Führen **git checkout** Sie von Ihrem lokalen Repo aus den Befehl aus und geben Sie dabei den Namen des Branches (zum Beispiel`MyNewBranch`) und die ID des ersten Commits an, den Sie im lokalen Repository vorgenommen haben.
Wenn Sie die Commit-ID nicht kennen, führen Sie **git log** aus, um sie abzurufen. Stellen Sie sicher, dass in dem Commit Ihr Benutzername und Ihre E-Mail-Adresse und nicht die Daten des anderen Benutzers verwendet werden. Damit wird simuliert, dass `main` es sich um eine stabile Version des CodeCommit Projektarchivs handelt und der `MyNewBranch` Branch für ein neues, relativ instabiles Feature vorgesehen ist:
```
git checkout -b MyNewBranch commit-ID
```
1. Führen Sie den Befehl aus**git push**, um den neuen Branch vom lokalen Repository an das CodeCommit Repository zu senden:
```
git push origin MyNewBranch
```
1. Übertragen Sie nun den Branch per Pull an das freigegebene Repository (shared repo) und überprüfen Sie die Ergebnisse:
1. Wechseln Sie in das Verzeichnis des freigegebenen Repositorys (shared-demo-repo).
1. Rufen Sie den neuen Branch per Pull ab (**git fetch origin**).
1. Überprüfen Sie, ob der Branch per Pull übertragen wurde (**git branch --all** zeigt eine Liste aller Branches für das Repository an).
1. Umstellen auf den neuen Branch (**git checkout MyNewBranch**).
1. Überprüfen Sie, ob Sie zum Branch `MyNewBranch` gewechselt haben, indem Sie **git status** oder **git branch** ausführen. Die Ausgabe zeigt Ihnen, in welchem Branch Sie sich befinden. In diesem Fall sollte es sich um `MyNewBranch` handeln.
1. Lassen Sie die Liste der Commits in dem Branch anzeigen (**git log**).
Im Folgenden sind die aufzurufenden Git-Befehle aufgeführt:
```
git fetch origin
git branch --all
git checkout MyNewBranch
git branch or git status
git log
```
1. Wechseln Sie zurück zum Branch `main` und lassen Sie die Liste der zugehörigen Commits anzeigen. Die Git-Befehle sollten wie folgt aussehen:
```
git checkout main
git log
```
1. Wechseln Sie zu dem `main` Zweig in Ihrem lokalen Repo. Sie können **git status** oder **git branch** ausführen. Die Ausgabe zeigt Ihnen, in welchem Branch Sie sich befinden. In diesem Fall sollte es sich um `main` handeln. Die Git-Befehle sollten wie folgt aussehen:
```
git checkout main
git branch or git status
```
## Schritt 7: Erstelle und teile ein Tag
In diesem Schritt erstellen Sie zwei Tags in Ihrem lokalen Repository, verknüpfen die Tags mit Commits und übertragen die Tags dann in Ihr CodeCommit Repository. Anschließend ziehen Sie die Änderungen aus dem CodeCommit Repository in das gemeinsam genutzte Repo.
Ein Tag wird verwendet, um einem Commit (oder einem Branch oder sogar einem anderen Tag) einen für Menschen lesbaren Namen zuzuweisen. Dies könnte zum Beispiel vorkommen, wenn Sie einen Commit mit `v2.1` markieren möchten. Ein Commit, ein Branch oder ein Tag kann mit beliebig vielen Tags verknüpft sein, aber ein bestimmter Tag ist mit nur einem bestimmten Commit, Branch oder Tag verknüpft. In diesem Tutorial markieren Sie einen Commit mit `release` und einen weiteren mit `beta`.
Sie erstellen die Tags mit Git und verweisen mit dem Tag `release` auf den ersten Commit und mit dem Tag `beta` auf den vom anderen Benutzer durchgeführten Commit. Anschließend verwenden Sie Git, um die Tags in das CodeCommit Repository zu übertragen. Dann wechselst du zu deinem gemeinsamen Repo und verwendest Git, um die Tags in dein gemeinsames lokales Repo zu ziehen und die Tags zu erkunden.
1. Führen **git tag** Sie von Ihrem lokalen Repo aus den Befehl aus und geben Sie dabei den Namen des neuen Tags (`release`) und die ID des ersten Commits an, den Sie im lokalen Repo vorgenommen haben.
Wenn Sie die Commit-ID nicht kennen, führen Sie **git log** aus, um sie abzurufen. Stellen Sie sicher, dass in dem Commit Ihr Benutzername und Ihre E-Mail-Adresse und nicht die Daten des anderen Benutzers verwendet werden. Dies dient dazu, zu simulieren, dass es sich bei Ihrem Commit um eine stabile Version des CodeCommit Repositorys handelt:
```
git tag release commit-ID
```
Führen Sie **git tag** erneut aus, um den Commit des anderen Benutzers mit dem Tag `beta` zu versehen. Dadurch wird simuliert, dass der Commit für eine neue, relativ instabile Funktion durchgeführt wird:
```
git tag beta commit-ID
```
1. Führen Sie aus**git push --tags**, um die Tags an das CodeCommit Repository zu senden.
1. Übertragen Sie nun die Tags per Pull an das freigegebene Repository (shared repo) und überprüfen Sie die Ergebnisse:
1. Wechseln Sie in das Verzeichnis des freigegebenen Repositorys (shared-demo-repo).
1. Rufen Sie die neuen Tags per Pull ab (**git fetch origin**).
1. Überprüfen Sie, ob die Tags per Pull übertragen wurden (**git tag** zeigt eine Liste aller Tags für das Repository an).
1. Zeigen Sie Informationen zu jedem Tag an (**git log release** und **git log beta**).
Im Folgenden sind die aufzurufenden Git-Befehle aufgeführt:
```
git fetch origin
git tag
git log release
git log beta
```
1. Probieren Sie das auch im lokalen Repo aus:
```
git log release
git log beta
```
## Schritt 8: Zugriffsberechtigungen einrichten
In diesem Schritt erteilen Sie einem Benutzer die Erlaubnis, das gemeinsam genutzte Repo mit dem CodeCommit Repository zu synchronisieren. Dieser Schritt ist optional. Es wird Benutzern empfohlen, die mehr darüber erfahren möchten, wie der Zugriff auf CodeCommit Repositorys gesteuert werden kann, wenn Benutzer Git-Anmeldeinformationen verwenden oder SSH-Schlüsselpaare mit IAM-Benutzern für den Zugriff auf Repositorys verwendet werden. CodeCommit
**Anmerkung**
Wenn Sie Verbundzugriff, temporäre Anmeldeinformationen oder einen Web-Identitätsanbieter wie IAM Identity Center verwenden, richten Sie Benutzer, Zugriff und Berechtigungen für Ihren Identitätsanbieter ein und verwenden Sie dann. **git-remote-codecommit** Weitere Informationen erhalten Sie unter [Einrichtungsschritte für HTTPS-Verbindungen AWS CodeCommit mit git-remote-codecommit](setting-up-git-remote-codecommit.md) und [Verbindung zu AWS CodeCommit Repositorys mit rotierenden Anmeldeinformationen herstellen](temporary-access.md).
Dazu verwenden Sie die IAM-Konsole, um einen Benutzer zu erstellen, der standardmäßig nicht berechtigt ist, das gemeinsam genutzte Repository mit dem Repository zu synchronisieren. CodeCommit Sie können **git pull** ausführen, um dies zu überprüfen. Wenn der neue Benutzer keine Berechtigung zur Synchronisierung hat, funktioniert der Befehl nicht. Dann kehren Sie zur IAM-Konsole zurück und wenden eine Richtlinie an, die dem Benutzer die Verwendung ermöglicht. **git pull** Sie können wieder **git pull** ausführen, um dies zu überprüfen.
Dieser Schritt wurde unter der Annahme geschrieben, dass Sie berechtigt sind, IAM-Benutzer in Ihrem Amazon Web Services Services-Konto zu erstellen. Wenn Sie diese Berechtigungen nicht haben, können Sie diesen Schritt nicht ausführen. Fahren Sie mit [Schritt 9: Bereinigen](#getting-started-clean-up) fort, um die Ressourcen zu bereinigen, die Sie für das Tutorial verwendet haben.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
Stellen Sie sicher, dass Sie sich mit demselben Benutzernamen und demselben Passwort anmelden, das Sie auch in [Einrichtung ](setting-up.md) verwendet haben.
1. Wählen Sie im Navigationsbereich **Users** und dann **Create New Users** aus.
1. Geben Sie im ersten Feld unter **Enter User Names (Benutzernamen eingeben)** einen Beispiel-Benutzernamen ein (zum Beispiel **JaneDoe-CodeCommit**). Aktivieren Sie das Kontrollkästchen **Generate an access key for each user (Zugriffsschlüssel für jeden Benutzer generieren)** und wählen Sie dann **Create (Erstellen)**.
1. Wählen Sie die Option **Show User Security Credentials**. Notieren Sie sich die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel oder wählen Sie **Download Credentials**.
1. Folgen Sie den Anweisungen unter[Für HTTPS-Benutzer, die Git-Anmeldeinformationen verwenden](setting-up-gc.md), um die Anmeldeinformationen des IAM-Benutzers zu generieren und bereitzustellen.
Wenn Sie SSH verwenden möchten, befolgen Sie die Anweisungen in [SSH und Linux, macOS oder Unix: Richten Sie die öffentlichen und privaten Schlüssel für Git ein und CodeCommit](setting-up-ssh-unixes.md#setting-up-ssh-unixes-keys-unixes) oder [Schritt 3: Richten Sie die öffentlichen und privaten Schlüssel für Git ein und CodeCommit](setting-up-ssh-windows.md#setting-up-ssh-windows-keys-windows), um für den Benutzer öffentliche und private Schlüssel einzurichten.
1. Führen Sie **git pull**. Die folgende Fehlermeldung sollte angezeigt werden:
Für HTTPS:
`fatal: unable to access 'https://git-codecommit.us-east-2.amazonaws.com/v1/repos/repository-name/': The requested URL returned error: 403`.
Für SSH:
`fatal: unable to access 'ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/repository-name/': The requested URL returned error: 403`.
Der Fehler tritt auf, weil der neue Benutzer nicht berechtigt ist, das gemeinsam genutzte Repository mit dem CodeCommit Repository zu synchronisieren.
1. Kehren Sie zur IAM-Konsole zurück. Wählen Sie im Navigationsbereich **Richtlinien** und dann **Richtlinie erstellen**. (Wenn die Schaltfläche **Get Started (Erste Schritte)** angezeigt wird, klicken Sie darauf und wählen Sie anschließend **Create Policy (Richtlinie erstellen)** aus.)
1. Klicken Sie neben **Create Your Own Policy** auf **Select**.
1. Geben Sie in das Feld **Policy Name (Richtlinienname)** einen Namen ein (z. B. **CodeCommitAccess-GettingStarted**).
1. Geben Sie im Feld **Richtliniendokument** Folgendes ein, sodass ein IAM-Benutzer Daten aus jedem Repository abrufen kann, das dem IAM-Benutzer zugeordnet ist:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull"
],
"Resource": "*"
}
]
}
```
------
**Tipp**
Wenn Sie möchten, dass der IAM-Benutzer Commits in jedes Repository übertragen kann, das dem IAM-Benutzer zugeordnet ist, geben Sie stattdessen Folgendes ein:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush"
],
"Resource": "*"
}
]
}
```
Informationen zu anderen CodeCommit Aktions- und Ressourcenberechtigungen, die Sie Benutzern gewähren können, finden Sie unter. [Authentifizierung und Zugriffskontrolle für AWS CodeCommit](auth-and-access-control.md)
1. Klicken Sie im Navigationsbereich auf **Users (Benutzer)**.
1. Wählen Sie den Beispiel-Benutzernamen (zum Beispiel **JaneDoe-CodeCommit**), dem Sie die Richtlinie anfügen möchten.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. Klicken Sie unter **Managed Policies** auf **Attach Policy**.
1. Wählen Sie die **CodeCommitAccess-GettingStarted**-Richtlinie aus, die Sie eben erstellt haben, und dann **Attach Policy (Richtlinie anfügen)**.
1. Führen Sie **git pull**. Nun sollte der Befehl funktionieren und eine Meldung des Typs `Already up-to-date` sollte angezeigt werden.
1. Wenn Sie HTTPS verwenden, wechseln Sie zu Ihren ursprünglichen Git-Anmeldeinformationen oder, falls Sie **git-remote-codecommit** verwenden, zu Ihrem üblichen Profil. Weitere Informationen finden Sie in den Anweisungen unter [Einrichtung für HTTPS-Benutzer mit Git-Anmeldeinformationen](setting-up-gc.md) oder [Einrichtungsschritte für HTTPS-Verbindungen AWS CodeCommit mit git-remote-codecommit](setting-up-git-remote-codecommit.md).
Wenn Sie SSH verwenden, wechseln Sie zu Ihren ursprünglichen Schlüsseln. Für weitere Informationen siehe [SSH und Linux, macOS oder Unix: Richten Sie die öffentlichen und privaten Schlüssel für Git ein und CodeCommit](setting-up-ssh-unixes.md#setting-up-ssh-unixes-keys-unixes) oder [Schritt 3: Richten Sie die öffentlichen und privaten Schlüssel für Git ein und CodeCommit](setting-up-ssh-windows.md#setting-up-ssh-windows-keys-windows).
Sie haben das Ende dieses Tutorials erreicht.
## Schritt 9: Bereinigen
In diesem Schritt löschen Sie das CodeCommit Repository, das Sie in diesem Tutorial verwendet haben, sodass Ihnen der Speicherplatz nicht weiter in Rechnung gestellt wird.
Sie entfernen auch das lokale Repository und das gemeinsam genutzte Repo auf Ihrem lokalen Computer, da sie nach dem Löschen des CodeCommit Repositorys nicht mehr benötigt werden.
**Wichtig**
Nachdem Sie dieses Repository gelöscht haben, können Sie es nicht mehr in ein lokales Repo oder ein gemeinsam genutztes Repository klonen. Sie werden auch nicht in der Lage sein, Daten aus einem lokalen oder gemeinsam genutzten Repo daraus abzurufen oder Daten dorthin zu übertragen. Diese Aktion kann nicht rückgängig gemacht werden.
### Um das CodeCommit Repository zu löschen (Konsole)
1. Öffnen Sie die CodeCommit Konsole unter [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. Wählen Sie auf der Seite **Dashboard** in der Liste der Repositorys den Eintrag **MyDemoRepo**.
1. Wählen Sie im Navigationsbereich **Settings** (Einstellungen).
1. Klicken Sie auf der Seite **Settings** unter **Delete repository** auf **Delete repository**.
1. Geben Sie in das Feld neben **Type the name of the repository to confirm deletion (Namen des Repositorys eingeben, um das Löschen zu bestätigen)** die Zeichenfolge **MyDemoRepo** ein und klicken Sie dann auf **Delete (Löschen)**.
### Um das Repository zu löschen () CodeCommit AWS CLI
Führen Sie den Befehl [delete-repository](how-to-delete-repository.md#how-to-delete-repository-cli) aus:
```
aws codecommit delete-repository --repository-name MyDemoRepo
```
### Um das lokale Repo und das gemeinsame Repo zu löschen
Für Linux, macOS oder Unix:
```
cd /tmp
rm -rf /tmp/my-demo-repo
rm -rf /tmp/shared-demo-repo
```
Für Windows:
```
cd c:\temp
rd /s /q c:\temp\my-demo-repo
rd /s /q c:\temp\shared-demo-repo
```