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.

# Tutorial: Erstellen Sie eine einfache Pipeline (CodeCommit Repository)
<a name="tutorials-simple-codecommit"></a>

In diesem Tutorial verwenden Sie, CodePipeline um Code, der in einem CodeCommit Repository verwaltet wird, auf einer einzelnen Amazon EC2 EC2-Instance bereitzustellen. Ihre Pipeline wird ausgelöst, wenn Sie eine Änderung an das CodeCommit Repository übertragen. Die Pipeline stellt Ihre Änderungen an einer Amazon EC2 EC2-Instance bereit, die CodeDeploy als Bereitstellungsservice verwendet wird.

**Wichtig**  
Im Rahmen der Erstellung einer Pipeline wird ein vom Kunden bereitgestellter S3-Artefakt-Bucket von for Artifacts verwendet. CodePipeline (Dies unterscheidet sich von dem Bucket, der für eine S3-Quellaktion verwendet wird.) Wenn sich der S3-Artefakt-Bucket in einem anderen Konto befindet als das Konto für Ihre Pipeline, stellen Sie sicher, dass der S3-Artefakt-Bucket denjenigen gehört AWS-Konten , die sicher und zuverlässig sind.

Die Pipeline hat zwei Phasen:
+ Eine Quellstufe (**Source**) für Ihre CodeCommit Quellaktion.
+ Eine Bereitstellungsphase (**Deploy**) für Ihre CodeDeploy Bereitstellungsaktion.

Der einfachste Weg, damit zu beginnen, AWS CodePipeline besteht darin, den Assistenten zum **Erstellen von Pipelines** in der CodePipeline Konsole zu verwenden.

**Anmerkung**  
Bevor du anfängst, stelle sicher, dass du deinen Git-Client so eingerichtet hast, dass er damit arbeiten kann CodeCommit. Anweisungen finden Sie unter [Einrichten für CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html).

## Schritt 1: Erstelle ein CodeCommit Repository
<a name="codecommit-create-repository"></a>

Zunächst erstellen Sie ein Repository in CodeCommit. Ihre Pipeline erhält Quellcode aus diesem Repository, wenn sie ausgeführt wird. Sie erstellen auch ein lokales Repository, in dem Sie Code verwalten und aktualisieren, bevor Sie ihn in das CodeCommit Repository übertragen.

**Um ein CodeCommit Repository zu erstellen**



1. Öffnen Sie die CodeCommit Konsole unter [https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/).

1. Wählen Sie in der Regionsauswahl den Ort aus, AWS-Region an dem Sie das Repository und die Pipeline erstellen möchten. Weitere Informationen finden Sie unter [AWS-Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html).

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**).

1. Wählen Sie **Erstellen** aus.

**Anmerkung**  
Die verbleibenden Schritte in diesem Tutorial werden **MyDemoRepo** für den Namen Ihres CodeCommit Repositorys verwendet. Wenn Sie einen anderen Namen auswählen, müssen Sie diesen im gesamten Tutorial verwenden.

**So richten Sie ein lokales Repository ein**

In diesem Schritt richten Sie ein lokales Repository ein, um eine Verbindung mit Ihrem Remote- CodeCommit-Repository herzustellen.
**Anmerkung**  
Sie müssen kein lokales Repository einrichten. Sie können die Konsole auch verwenden, um Dateien hochzuladen, wie unter beschrieben[Schritt 2: Fügen Sie Ihrem CodeCommit Repository Beispielcode hinzu](#codecommit-add-code).

1. Wenn Ihr neues Repository in der Konsole geöffnet ist, wählen Sie **Clone URL (URL klonen)** oben rechts auf der Seite und dann **Clone SSH (SSH klonen)** aus. Die Adresse zum Klonen Ihres Git-Repositorys wird in die Zwischenablage kopiert.

1. Navigieren Sie in Ihrem Terminal oder in der Befehlszeile zu einem lokalen Verzeichnis, in dem Ihr lokales Repository gespeichert werden soll. In diesem Tutorial verwenden wir `/tmp`.

1. Führen Sie den folgenden Befehl aus, um das Repository zu klonen. Ersetzen Sie dabei die SSH-Adresse durch die Adresse, die Sie im vorherigen Schritt kopiert haben. Mit diesem Befehl wird ein Verzeichnis namens `MyDemoRepo` erstellt. Kopieren Sie eine Beispielanwendung in dieses Verzeichnis.

   ```
   git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
   ```

## Schritt 2: Fügen Sie Ihrem CodeCommit Repository Beispielcode hinzu
<a name="codecommit-add-code"></a>

In diesem Schritt laden Sie Code für eine Beispielanwendung herunter, die für eine CodeDeploy exemplarische Vorgehensweise erstellt wurde, und fügen ihn Ihrem CodeCommit Repository hinzu.



1. Laden Sie als Nächstes ein Beispiel herunter und speichern Sie es in einem Ordner oder Verzeichnis auf Ihrem lokalen Computer.

   1. Wählen Sie eine der folgenden Optionen aus. Wählen Sie aus, `SampleApp_Linux.zip` ob Sie die Schritte in diesem Tutorial für Linux-Instances befolgen möchten.
      + Wenn Sie die Bereitstellung auf Amazon Linux-Instances mithilfe durchführen möchten CodeDeploy, laden Sie die Beispielanwendung hier herunter: [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).
      + Wenn Sie die Bereitstellung auf Windows Server-Instances mithilfe durchführen möchten CodeDeploy, laden Sie die Beispielanwendung hier herunter: [SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip).

      Die Beispielanwendung enthält die folgenden Dateien für die Bereitstellung mit CodeDeploy: 
      + `appspec.yml`— Die Anwendungsspezifikationsdatei (AppSpecDatei) ist eine Datei im [YAML-Format](http://www.yaml.org), die CodeDeploy zur Verwaltung einer Bereitstellung verwendet wird. *Weitere Informationen zu der AppSpec Datei finden Sie unter [CodeDeploy AppSpec Dateireferenz im AWS CodeDeploy Benutzerhandbuch.](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)*
      + `index.html`— Die Indexdatei enthält die Homepage für die bereitgestellte Beispielanwendung.
      + `LICENSE.txt`— Die Lizenzdatei enthält Lizenzinformationen für die Beispielanwendung.
      + Dateien für Skripts — Die Beispielanwendung verwendet Skripts, um Textdateien an einen Speicherort auf Ihrer Instance zu schreiben. Für jedes der verschiedenen Ereignisse im CodeDeploy Bereitstellungslebenszyklus wird wie folgt eine Datei geschrieben:
        + `scripts`Ordner (nur Linux-Beispiel) — Der Ordner enthält die folgenden Shell-Skripts zum Installieren von Abhängigkeiten und zum Starten und Beenden der Beispielanwendung für die automatisierte Bereitstellung: `install_dependencies``start_server`, und`stop_server`.
        + (Nur Windows-Beispiel) `before-install.bat` — Dies ist ein Batch-Skript für das `BeforeInstall` Deployment-Lifecycle-Ereignis, das ausgeführt wird, um alte Dateien zu entfernen, die während früherer Bereitstellungen dieses Beispiels geschrieben wurden, und einen Speicherort auf Ihrer Instanz zu erstellen, in den die neuen Dateien geschrieben werden.

   1. Laden Sie die komprimierte ZIP-Datei herunter.

1. Entpacken Sie die Dateien aus [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) in das lokale Verzeichnis, das Sie zuvor erstellt haben (z. B. `/tmp/MyDemoRepo` oder`c:\temp\MyDemoRepo`).

   Stellen Sie sicher, dass Sie die Dateien direkt in Ihrem lokalen Repository platzieren. Beziehen Sie keinen `SampleApp_Linux` Ordner ein. Auf Ihrem lokalen Linux-, macOS- oder Unix-Computer sollte Ihre Verzeichnis- und Dateihierarchie beispielsweise so aussehen:

   ```
   /tmp
      └-- MyDemoRepo
          │-- appspec.yml
          │-- index.html
          │-- LICENSE.txt
          └-- scripts
              │-- install_dependencies
              │-- start_server
              └-- stop_server
   ```

1. Verwenden Sie eine der folgenden Methoden, um Dateien in Ihr Repository hochzuladen.

   1. So verwenden Sie die CodeCommit Konsole, um Ihre Dateien hochzuladen: 

      1. Öffnen Sie die CodeCommit Konsole und wählen Sie Ihr Repository aus der **Repository-Liste** aus.

      1. Wählen Sie **Add file (Datei hinzufügen)** und dann **Upload file (Datei hochladen)** aus. 

      1. Wählen Sie **Choose file (Datei auswählen)** und navigieren Sie dann zu Ihrer Datei. Um eine Datei unter einem Ordner hinzuzufügen, wählen Sie **Datei erstellen** und geben Sie dann den Ordnernamen mit dem Dateinamen ein, z. B. `scripts/install_dependencies` Fügen Sie den Dateiinhalt in die neue Datei ein.

         Übernehmen Sie die Änderung, indem Sie Ihren Benutzernamen und Ihre E-Mail-Adresse eingeben. 

         Wählen Sie **Commit changes (Änderungen übernehmen)** aus.

      1. Wiederholen Sie diesen Schritt für jede Datei.

         Der Inhalt Ihres Repositorys sollte wie folgt aussehen:

         ```
                │-- appspec.yml
                │-- index.html
                │-- LICENSE.txt
                └-- scripts
                    │-- install_dependencies
                    │-- start_server
                    └-- stop_server
         ```

   1. So verwendest du Git-Befehle, um deine Dateien hochzuladen: 

      1. Ändern von Verzeichnisses in Ihrem lokalen Repository:

         ```
         (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
         (For Windows) cd c:\temp\MyDemoRepo
         ```

      1. Führen Sie den folgenden Befehl aus, um alle Dateien auf einmal zu übertragen:

         ```
         git add -A
         ```

      1. Führen Sie den folgenden Befehl aus, um einen Commit für Dateien mit einer Commit-Nachricht durchzuführen:

         ```
         git commit -m "Add sample application files"
         ```

      1. Führen Sie den folgenden Befehl aus, um die Dateien aus Ihrem lokalen Repository in Ihr CodeCommit-Repository zu übertragen:

         ```
         git push
         ```

1. Die Dateien, die du heruntergeladen und zu deinem lokalen Repo hinzugefügt hast, wurden nun dem `main` Branch in deinem CodeCommit `MyDemoRepo` Repository hinzugefügt und können nun in eine Pipeline aufgenommen werden.

## Schritt 3: Erstellen Sie eine Amazon EC2 EC2-Linux-Instance und installieren Sie den Agenten CodeDeploy
<a name="codecommit-create-deployment"></a>

In diesem Schritt erstellen Sie die Amazon EC2 EC2-Instance, in der Sie eine Beispielanwendung bereitstellen. Erstellen Sie im Rahmen dieses Prozesses eine Instance-Rolle, die die Installation und Verwaltung des CodeDeploy Agenten auf der Instance ermöglicht. Der CodeDeploy Agent ist ein Softwarepaket, das die Verwendung einer Instanz in CodeDeploy Bereitstellungen ermöglicht. Sie fügen auch Richtlinien hinzu, die es der Instanz ermöglichen, Dateien abzurufen, die der CodeDeploy Agent zur Bereitstellung Ihrer Anwendung verwendet, und die Verwaltung der Instanz durch SSM zu ermöglichen.

**So erstellen Sie eine Instance-Rolle**

1. Öffnen Sie die IAM-Konsole unter). [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie im Dashboard der Konsole die Option **Rollen** aus.

1. Wählen Sie **Rolle erstellen** aus.

1. **Wählen Sie unter Typ der vertrauenswürdigen Entität** auswählen **AWS-Service**die Option aus. **Wählen Sie unter Wählen Sie einen Anwendungsfall** die Option **EC2** aus. Wählen Sie in **Select your use case (Anwendungsfall auswählen)** die Option **EC2** aus. Wählen Sie **Weiter: Berechtigungen** aus.

1. Suchen Sie nach der genannten **`AmazonEC2RoleforAWSCodeDeploy`**Richtlinie und wählen Sie sie aus. 

1. Suchen Sie nach der genannten Richtlinie und wählen Sie sie aus **`AmazonSSMManagedInstanceCore`**. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

1. Klicken Sie auf **Weiter: Prüfen**. Geben Sie einen Namen für die Rolle ein (z. B. **EC2InstanceRole**).
**Anmerkung**  
Notieren Sie sich Ihren Rollennamen für den nächsten Schritt. Sie wählen diese Rolle, wenn Sie Ihre Instance erstellen.

   Wählen Sie **Rolle erstellen** aus.

**So starten Sie eine Instance**

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie in der Seitennavigation **Instances** und dann oben auf der Seite **Launch Instances** aus.

1. Geben Sie unter **Name** **MyCodePipelineDemo** ein. Dadurch wird der Instance ein **Tag-Schlüssel** von **Name** und ein **Tag-Wert** von **MyCodePipelineDemo** zugewiesen. Später erstellen Sie eine CodeDeploy Anwendung, die die Beispielanwendung auf dieser Instanz bereitstellt. CodeDeploywählt die bereitzustellenden Instanzen auf der Grundlage der Tags aus.

1. Suchen Sie unter **Anwendungs- und Betriebssystem-Images (Amazon Machine Image)** die **Amazon Linux** AMI-Option mit dem AWS Logo und stellen Sie sicher, dass sie ausgewählt ist. (Dieses AMI wird als Amazon Linux 2 AMI (HVM) bezeichnet und trägt die Bezeichnung „Für das kostenlose Kontingent in Frage“.)

1. Wählen Sie unter **Instance-Typ** den `t2.micro` Typ aus, für den das kostenlose Kontingent in Frage kommt, als Hardwarekonfiguration für Ihre Instance.

1. Wählen Sie unter **key pair (Anmeldung)** ein Schlüsselpaar aus oder erstellen Sie eines. 

   Sie können auch **Proceed without a key pair** wählen.
**Anmerkung**  
Für die Zwecke dieses Tutorials können Sie ohne Schlüsselpaar fortfahren. Um SSH zu verwenden, wenn eine Verbindung zu Ihren Instances herstellen, erstellen Sie ein Schlüsselpaar oder verwenden Sie ein vorhandenes.

1. Gehen Sie unter **Netzwerkeinstellungen** wie folgt vor.

   Vergewissern Sie sich, dass **unter Öffentliche IP automatisch zuweisen** der Status **Enable** lautet.

   Wählen Sie für die erstellte Sicherheitsgruppe **HTTP** und dann unter **Quelltyp** die Option **Meine IP** aus.

1. Erweitern Sie **Advanced Details** (Erweiterte Details). Wählen Sie im **IAM-Instanzprofil** die IAM-Rolle aus, die Sie im vorherigen Verfahren erstellt haben (z. B.**EC2InstanceRole**).

1. Geben Sie unter **Zusammenfassung** unter **Anzahl der Instanzen den Wert**.. `1`

1. Wählen Sie **Launch Instance (Instance starten)** aus. 

1. Sie können den Status des Starts auf der Seite **Instances** anzeigen. Wenn Sie eine Instance starten, lautet ihr anfänglicher Status `pending`. Nachdem die Instance gestartet ist, lautet ihr Status `running`. Sie erhält dann einen öffentlichen DNS-Namen. (Wenn die Spalte **Public DNS** nicht angezeigt wird, wählen Sie das **Show/Hide**-Symbol aus und wählen Sie dann **Public DNS** aus.)

## Schritt 4: Erstellen Sie eine Anwendung in CodeDeploy
<a name="codecommit-create-codedeploy-app"></a>

In CodeDeploy ist eine [https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) eine Ressource, die die Softwareanwendung enthält, die Sie bereitstellen möchten. Später verwenden Sie diese Anwendung mit, CodePipeline um die Bereitstellung der Beispielanwendung auf Ihrer Amazon EC2 EC2-Instance zu automatisieren.

Zunächst erstellen Sie eine Rolle, die die Durchführung von CodeDeploy Bereitstellungen ermöglicht. Anschließend erstellen Sie eine CodeDeploy -Anwendung.

**Um eine CodeDeploy Servicerolle zu erstellen**

1. Öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. Wählen Sie im Dashboard der Konsole die Option **Rollen** aus.

1. Wählen Sie **Rolle erstellen** aus.

1. **Wählen Sie unter Vertrauenswürdige Entität** auswählen die Option **AWS-Service**. Wählen Sie unter **Use case** (Anwendungsfall) **CodeDeploy** aus. Wählen Sie **CodeDeploy**aus den aufgelisteten Optionen aus. Wählen Sie **Weiter** aus. Die `AWSCodeDeployRole`-verwaltete Richtlinie ist der Rolle bereits zugewiesen.

1. Wählen Sie **Weiter** aus.

1. Geben Sie einen Namen für die Rolle ein (beispielsweise **CodeDeployRole**) und wählen Sie **Next (Weiter)** aus.

**Um eine Anwendung zu erstellen in CodeDeploy**

1. Öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).

1. **Wenn die Seite „**Anwendungen**“ nicht angezeigt wird, wählen Sie im Menü „Anwendungen“.**

1. Wählen Sie **Create application** aus.

1. Geben Sie unter **Application name (Anwendungsname)** **MyDemoApplication** ein. 

1. Wählen Sie unter **Compute Platform (Plattform für die Datenverarbeitung)** die Option **EC2/On-premises (EC2/Lokal)** aus.

1. Wählen Sie **Create application** aus.

**Um eine Bereitstellungsgruppe zu erstellen in CodeDeploy**

Eine [https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) ist eine Ressource, die Bereitstellungseinstellungen definiert, z. B. für welche Instances und wie schnell sie bereitgestellt werden sollen.

1. Wählen Sie auf der Seite mit Ihrer Anwendung **Create deployment group (Bereitstellungsgruppe erstellen)**.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **MyDemoDeploymentGroup** ein.

1. Wählen Sie **unter Servicerolle** den ARN der Servicerolle aus, die Sie zuvor erstellt haben (z. B.**`arn:aws:iam::account_ID:role/CodeDeployRole`**).

1. Wählen Sie unter **Deployment type (Bereitstellungstyp)** die Option **In-place (Direkt)**.

1. Wählen Sie unter **Environment configuration (Umgebungskonfiguration)** die Option **Amazon EC2-Instances** aus. Geben Sie im Feld **Schlüssel** den Wert ein**Name**. Geben Sie im Feld **Wert** den Namen ein, mit dem Sie die Instanz markiert haben (z. B.**MyCodePipelineDemo**).

1. Wählen Sie unter **Agentenkonfiguration mit AWS Systems Manager** die Option **Jetzt und planen Sie Updates**. Dadurch wird der Agent auf der Instanz installiert. Die Linux-Instanz ist bereits mit dem SSM-Agenten konfiguriert und wird nun mit dem CodeDeploy Agenten aktualisiert.

1. Wählen Sie in **Deployment configuration (Bereitstellungskonfiguration)** die Option `CodeDeployDefault.OneAtaTime` aus.

1. Stellen Sie sicher, dass unter **Load Balancer** die Option **Load Balancing aktivieren** nicht ausgewählt ist. Sie müssen keinen Load Balancer einrichten oder eine Zielgruppe für dieses Beispiel auswählen.

1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**.

## Schritt 5: Erstellen Sie Ihre erste Pipeline in CodePipeline
<a name="codecommit-create-pipeline"></a>

Sie sind jetzt bereit, um Ihre erste Pipeline zu erstellen und auszuführen. In diesem Schritt erstellen Sie eine Pipeline, die automatisch ausgeführt wird, wenn Code in Ihr CodeCommit Repository übertragen wird.

**Um eine CodePipeline Pipeline zu erstellen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodePipeline Konsole unter [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

   Öffnen Sie die CodePipeline Konsole unter [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Wählen sie auf der Seite **Welcome (Willkommen)** die Option **Getting started (Erste Schritte)** aus, oder auf der Seite **Pipelines** die Option **Create pipeline (Pipeline erstellen)**.

1. Wählen Sie auf der Seite **Schritt 1: Erstellungsoption auswählen** unter **Erstellungsoptionen** die Option **Benutzerdefinierte Pipeline erstellen** aus. Wählen Sie **Weiter** aus.

1. Geben Sie in **Schritt 2: Pipeline-Einstellungen auswählen** im Feld **Pipeline-Name** den Wert ein**MyFirstPipeline**.

1. CodePipeline bietet Pipelines vom Typ V1 und V2, die sich in Eigenschaften und Preis unterscheiden. Der Typ V2 ist der einzige Typ, den Sie in der Konsole auswählen können. Weitere Informationen finden Sie unter [Pipeline-Typen](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Informationen zur Preisgestaltung für finden Sie CodePipeline unter [Preisgestaltung](https://aws.amazon.com/codepipeline/pricing/).

1. Wählen Sie unter **Servicerolle** die Option **Neue Servicerolle** aus, um CodePipeline die Erstellung einer Servicerolle in IAM zu ermöglichen.

1. Belassen Sie die Einstellungen unter **Erweiterte Einstellungen** bei den Standardeinstellungen, und wählen Sie dann **Next (Weiter)** aus.

1. Wählen Sie in **Schritt 3: Quellstufe hinzufügen** im Feld **Quellanbieter** die Option **CodeCommit**. Wählen Sie unter **Repository-Name** den Namen des CodeCommit Repositorys aus, in dem Sie es erstellt haben[Schritt 1: Erstelle ein CodeCommit Repository](#codecommit-create-repository). Wählen Sie unter **Branch name** (Name der Verzweigung) die Option `main` und dann **Next step (Nächster Schritt)** aus.

   Nachdem Sie den Repository-Namen und den Branch ausgewählt haben, wird in einer Meldung die Amazon CloudWatch Events-Regel angezeigt, die für diese Pipeline erstellt werden soll. 

   Lassen Sie die Standardwerte in **Change detection options** unverändert. Auf diese Weise können CodePipeline Sie Amazon CloudWatch Events verwenden, um Änderungen in Ihrem Quell-Repository zu erkennen.

   Wählen Sie **Weiter** aus.

1. Wählen Sie in **Schritt 4: Build-Phase hinzufügen** die Option **Build-Phase überspringen** und akzeptieren Sie dann die Warnmeldung, indem Sie erneut auf **Überspringen** klicken. Wählen Sie **Weiter** aus.
**Anmerkung**  
In diesem Tutorial stellen Sie Code bereit, der keinen Build-Service erfordert, sodass Sie diesen Schritt überspringen können. Wenn Ihr Quellcode jedoch erstellt werden muss, bevor er für Instances bereitgestellt wird, können Sie in diesem Schritt [CodeBuild](https://aws.amazon.com/codebuild/) konfigurieren.

1. Wählen Sie in **Schritt 5: Testphase hinzufügen** die Option **Testphase überspringen** aus und akzeptieren Sie dann die Warnmeldung, indem Sie erneut **Überspringen** wählen. 

   Wählen Sie **Weiter** aus.

1. Wählen Sie in **Schritt 6: Bereitstellungsphase hinzufügen** unter **Bereitstellungsanbieter** die Option aus **CodeDeploy**. Wählen Sie unter **Application name (Anwendungsname)** die Option **MyDemoApplication** aus. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **MyDemoDeploymentGroup** , und dann **Next step (Nächster Schritt)** aus.

1. Überprüfen **Sie in Schritt 7: Überprüfen** Sie die Informationen und wählen Sie dann **Pipeline erstellen** aus.

1. Die Pipeline wird ausgeführt, nachdem sie erstellt wurde. Es lädt den Code aus Ihrem CodeCommit Repository herunter und erstellt ein CodeDeploy Deployment für Ihre EC2-Instance. Sie können sich Fortschritts-, Erfolgs- und Fehlschlagsmeldungen anzeigen lassen, während das CodePipeline Beispiel die Webseite für die Amazon EC2 EC2-Instance in der CodeDeploy Bereitstellung bereitstellt.  
![\[Eine Ansicht einer Pipeline, die in der Konsole zu laufen beginnt. CodePipeline\]](http://docs.aws.amazon.com/de_de/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

Herzlichen Glückwunsch\$1 Sie haben gerade eine einfache Pipeline in erstellt CodePipeline. 

Im nächsten Schritt überprüfen Sie die Ergebnisse.

**So verifizieren Sie, ob Ihre Pipeline erfolgreich ausgeführt wurde**

1. Zeigen Sie den anfänglichen Fortschritt der Pipeline an. Der Status jeder Phase ändert sich von **Zurzeit keine Ausführungen** zu **Laufend**. Danach ändert er sich entweder zu **Erfolgreich** oder **Fehlgeschlagen**. Die Pipeline sollte die erste Ausführung innerhalb weniger Minuten abschließen.

1. Nachdem **Successed** für den Pipeline-Status angezeigt wird, wählen Sie im Statusbereich für die **Bereitstellungsphase** die Option **CodeDeploy**. Dadurch wird die CodeDeploy Konsole geöffnet. Wenn **Succeeded (Erfolgreich)** nicht angezeigt wird, finden Sie weitere Informationen unter [Problembehebung CodePipeline](troubleshooting.md).

1.  Wählen Sie in der Registerkarte **Deployments (Bereitstellungen)** die Bereitstellungs-ID aus. Wählen Sie auf der Seite für die Bereitstellung unter **Deployment lifecycle events (Bereitstellungslebenszyklusereignisse)** die Instance-ID aus. Daraufhin wird die EC2-Konsole geöffnet.

1. Kopieren Sie in der Registerkarte **Description (Beschreibung)** in **Public DNS (Öffentliches DNS)** die Adresse (z. B. `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`) und fügen Sie diese in die Adressleiste Ihres Webbrowsers ein.

   Die Webseite für die Beispielanwendung, die Sie heruntergeladen und in Ihr CodeCommit Repository übertragen haben, wird angezeigt.

Weitere Informationen über Phasen, Aktionen und die Funktionsweise von Pipelines finden Sie unter [CodePipeline Konzepte ](concepts.md).

## Schritt 6: Ändern Sie den Code in Ihrem CodeCommit Repository
<a name="codecommit-push-code"></a>

Ihre Pipeline ist so konfiguriert, dass sie ausgeführt wird, sobald der Code in Ihrem CodeCommit-Repository geändert wird. In diesem Schritt nehmen Sie Änderungen an der HTML-Datei vor, die Teil der CodeDeploy Beispielanwendung im CodeCommit Repository ist. Wenn Sie diese Änderungen übertragen, wird Ihre Pipeline erneut ausgeführt. Die Änderungen, die Sie vornehmen, sind an der Webadresse sichtbar, auf die Sie zuvor zugegriffen haben.

1. Ändern von Verzeichnisses in Ihrem lokalen Repository:

   ```
   (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
   (For Windows) cd c:\temp\MyDemoRepo
   ```

1. Verwenden Sie einen Texteditor zum Ändern der `index.html`-Datei:

   ```
   (For Linux or Unix)gedit index.html
   (For OS X)open –e index.html
   (For Windows)notepad index.html
   ```

1. Ändern Sie den Inhalt der `index.html`-Datei auf die gewünschte Hintergrundfarbe und ändern Sie einigen Text auf der Webseite. Speichern Sie dann die Datei. 

   ```
   <!DOCTYPE html>
   <html>
   <head>
     <title>Updated Sample Deployment</title>
     <style>
       body {
         color: #000000;
         background-color: #CCFFCC;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
           
       h1 {
         font-size: 250%;
         font-weight: normal;
         margin-bottom: 0;
       }
       
       h2 {
         font-size: 175%;
         font-weight: normal;
         margin-bottom: 0;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Updated Sample Deployment</h1></div>
     <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
     <div align="center">
       <p>Learn more:</p> 
       <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
     </div>
   </body>
   </html>
   ```

1. Übernehmen Sie Ihre Änderungen und übertragen Sie sie in Ihr CodeCommit Repository, indem Sie nacheinander die folgenden Befehle ausführen:

   ```
   git commit -am "Updated sample application files"
   ```

   ```
   git push
   ```

**So verifizieren Sie, ob Ihre Pipeline erfolgreich ausgeführt wurde**

1. Zeigen Sie den anfänglichen Fortschritt der Pipeline an. Der Status jeder Phase ändert sich von **Zurzeit keine Ausführungen** zu **Laufend**. Danach ändert er sich entweder zu **Erfolgreich** oder **Fehlgeschlagen**. Die Ausführung der Pipeline sollte innerhalb weniger Minuten abgeschlossen sein.

1. Nachdem **Succeeded (Erfolgreich)** für den Aktionsstatus angezeigt wird, aktualisieren Sie die Demo-Seite, auf die Sie zuvor in Ihrem Browser zugegriffen haben.

   Die aktualisierte Webseite wird angezeigt.

## Schritt 7: Bereinigen von Ressourcen
<a name="codecommit-clean-up"></a>

Sie können einige der Ressourcen, die Sie in diesem Tutorial erstellt haben, für andere Tutorials in diesem Handbuch verwenden. Sie können beispielsweise die CodeDeploy Anwendung und die Bereitstellung wiederverwenden. Nach Abschluss dieses und jedes anderen Tutorials sollten Sie jedoch die Pipeline und die von ihr verwendeten Ressourcen löschen, damit Ihnen keine Kosten für die weitere Nutzung der Ressourcen entstehen. Löschen Sie zuerst die Pipeline, dann die CodeDeploy Anwendung und die zugehörige Amazon EC2 EC2-Instance und schließlich das CodeCommit Repository.

**So bereinigen Sie die in diesem Tutorial verwendeten Ressourcen**

1. Um Ihre CodePipeline Ressourcen zu bereinigen, folgen Sie den Anweisungen unter [Eine Pipeline löschen in AWS CodePipeline](pipelines-delete.md).

1. Um Ihre CodeDeploy Ressourcen zu bereinigen, folgen Sie den Anweisungen unter [Ressourcen zum Aufräumen der Bereitstellung](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up).

1. Folgen Sie den Anweisungen unter Löschen eines CodeCommit Repositorys, um das [ CodeCommitRepository zu löschen](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html).

## Schritt 8: Weitere Informationen
<a name="codecommit-optional-tasks"></a>

Erfahre mehr darüber, wie das CodePipeline funktioniert:
+ Weitere Informationen über Phasen, Aktionen und die Funktionsweise von Pipelines finden Sie unter [CodePipeline Konzepte ](concepts.md).
+ Informationen zu den Aktionen, die Sie mit ausführen können CodePipeline, finden Sie unter[Integrationen mit CodePipeline Aktionstypen](integrations-action-type.md).
+ Testen Sie dieses erweiterte Tutorial: [Tutorial: Erstellen einer vierstufigen Pipeline](tutorials-four-stage-pipeline.md). Es wird eine mehrstufige Pipeline erstellt, die einen Schritt enthält, mit dem Code vor der Bereitstellung erstellt wird.