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 einer einfachen Pipeline (S3-Bucket)
Der einfachste Weg, eine Pipeline zu erstellen, besteht darin, den Assistenten zum **Erstellen von Pipelines** in der AWS CodePipeline Konsole zu verwenden.
In diesem Tutorial erstellen Sie eine zweistufige Pipeline, die einen versionierten S3-Quell-Bucket verwendet CodeDeploy , und zur Veröffentlichung einer Beispielanwendung.
**Anmerkung**
Wenn Amazon S3 der Quellanbieter für Ihre Pipeline ist, können Sie Ihre Quelldatei (en) in eine einzige ZIP-Datei komprimieren und die ZIP-Datei in Ihren Quell-Bucket hochladen. Sie können auch eine einzelne Datei ungezippt hochladen, aber nachgelagerte Aktionen, die eine ZIP-Datei erwarten, schlagen dann fehl.
**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.
Nach dem Erstellen dieser einfachen Pipeline fügen Sie eine weitere Stufe hinzu und deaktivieren und aktivieren anschließend den Übergang zwischen Stufen.
**Wichtig**
Viele der Aktionen, die Sie Ihrer Pipeline in diesem Verfahren hinzufügen, beinhalten AWS Ressourcen, die Sie erstellen müssen, bevor Sie die Pipeline erstellen. AWS Ressourcen für Ihre Quellaktionen müssen immer in derselben AWS Region erstellt werden, in der Sie Ihre Pipeline erstellen. Wenn Sie Ihre Pipeline beispielsweise in der Region USA Ost (Ohio) erstellen, muss sich Ihr CodeCommit Repository in der Region USA Ost (Ohio) befinden.
Sie können beim Erstellen Ihrer Pipeline regionsübergreifende Aktionen hinzufügen. AWS Ressourcen für regionsübergreifende Aktionen müssen sich in derselben AWS Region befinden, in der Sie die Aktion ausführen möchten. Weitere Informationen finden Sie unter [Fügen Sie eine regionsübergreifende Aktion hinzu in CodePipeline](actions-create-cross-region.md).
Stellen Sie vor Beginn sicher, dass die unter [Erste Schritte mit CodePipeline](getting-started-codepipeline.md) beschriebenen Voraussetzungen erfüllt sind.
**Topics**
+ [Schritt 1: Erstellen Sie einen S3-Quell-Bucket für Ihre Anwendung](#s3-create-s3-bucket)
+ [Schritt 2: Amazon EC2 EC2-Windows-Instances erstellen und den CodeDeploy Agenten installieren](#S3-create-instances)
+ [Schritt 3: Erstellen Sie eine Anwendung in CodeDeploy](#S3-create-deployment)
+ [Schritt 4: Erstellen Sie Ihre erste Pipeline in CodePipeline](#s3-create-pipeline)
+ [Schritt 5: Hinzufügen einer weiteren Phase zur Pipeline](#s3-add-stage)
+ [(Optional) Schritt 6: Deaktivieren und aktivieren Sie Übergänge zwischen den Phasen in CodePipeline](#s3-configure-transitions)
+ [Schritt 7: Bereinigen von Ressourcen](#s3-clean-up)
## Schritt 1: Erstellen Sie einen S3-Quell-Bucket für Ihre Anwendung
Sie können Ihre Quelldateien oder Anwendungen an jedem versionierten Speicherort speichern. In diesem Tutorial erstellen Sie einen S3-Bucket für die Beispielanwendungsdateien und aktivieren die Versionierung für diesen Bucket. Nach der Aktivierung des Versioning kopieren Sie die Beispielanwendungen zu diesem Bucket.
**So erstellen Sie einen S3-Bucket**
1. Melden Sie sich bei der Konsole an unter AWS-Managementkonsole. Öffnen Sie die S3-Konsole.
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Geben Sie in **Bucket Name (Bucket-Name)** einen Namen für Ihren Bucket ein (z. B. **awscodepipeline-demobucket-example-date**).
**Anmerkung**
Da alle Bucket-Namen in Amazon S3 eindeutig sein müssen, verwenden Sie einen eigenen Namen, nicht den im Beispiel gezeigten Namen. Sie können den Beispielnamen abändern, indem Sie ihm das Datum hinzufügen. Notieren Sie sich diesen Namen, da Sie ihn für den Rest dieser Anleitung benötigen.
Wählen Sie **unter Region** die Region aus, in der Sie Ihre Pipeline erstellen möchten, z. B. **USA West (Oregon)**, und wählen Sie dann **Create Bucket** aus.
1. Nachdem der Bucket erstellt wurde, wird ein Erfolgsbanner angezeigt. Wählen Sie **Go to bucket details (Zu Bucket-Details wechseln)** aus.
1. Wählen Sie auf der Registerkarte **Properties (Eigenschaften)** die Option **Versioning** aus. Wählen Sie **Enable versioning (Versioning aktivieren)** und dann **Save (Speichern)**aus.
Wenn die Versionierung aktiviert ist, speichert Amazon S3 jede Version jedes Objekts im Bucket.
1. Behalten Sie auf der Registerkarte **Permissions (Berechtigungen)** die Standardwerte bei. Weitere Informationen über Bucket- und Objekt-Berechtigungen in S3 finden Sie unter [Specifying Permissions in a Policy (Berechtigungen in Richtlinien festlegen)](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html).
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 `SampleApp_Windows.zip` aus, wenn Sie die Schritte in diesem Tutorial für Windows Server-Instances ausführen 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. Entpacken Sie die Datei nicht.
1. Laden Sie in der Amazon S3 S3-Konsole für Ihren Bucket die Datei hoch:
1. Klicken Sie auf **Upload**.
1. Ziehen Sie die Datei oder wählen Sie **Add Files (Dateien hinzufügen) aus** und suchen Sie die Datei.
1. Klicken Sie auf **Upload**.
## Schritt 2: Amazon EC2 EC2-Windows-Instances erstellen und den CodeDeploy Agenten installieren
**Anmerkung**
Dieses Tutorial enthält Beispielschritte für die Erstellung von Amazon EC2 EC2-Windows-Instances. Beispielschritte zum Erstellen von Amazon EC2 EC2-Linux-Instances finden Sie unter[Schritt 3: Erstellen Sie eine Amazon EC2 EC2-Linux-Instance und installieren Sie den Agenten CodeDeploy](tutorials-simple-codecommit.md#codecommit-create-deployment). Wenn Sie zur Eingabe der Anzahl der zu erstellenden Instances aufgefordert werden, geben Sie **2** an.
In diesem Schritt erstellen Sie die Windows Server Amazon EC2 EC2-Instances, auf denen Sie eine Beispielanwendung bereitstellen werden. Im Rahmen dieses Prozesses erstellen Sie eine Instance-Rolle mit Richtlinien, die die Installation und Verwaltung des CodeDeploy Agenten auf den Instances ermöglichen. 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 **Choose a use case (Anwendungsfall auswählen)** die Option **EC2** und dann **Next: Permissions (Weiter: Berechtigungen)** aus.
1. Suchen Sie nach der genannten Richtlinie und wählen Sie sie aus **`AmazonEC2RoleforAWSCodeDeploy`**.
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.
**Starten von Instances**
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 und Tags** im Feld **Name** den Wert ein**MyCodePipelineDemo**. Dadurch wird den Instanzen ein **Tag-Schlüssel** von **Name** und ein **Tag-Wert** von **MyCodePipelineDemo** zugewiesen. Später erstellen Sie eine CodeDeploy Anwendung, die die Beispielanwendung auf den Instanzen bereitstellt. CodeDeploywählt die bereitzustellenden Instanzen auf der Grundlage der Tags aus.
1. Wählen Sie unter **Anwendungs- und Betriebssystem-Images (Amazon Machine Image)** die Option **Windows** aus. (Dieses AMI wird als **Microsoft Windows Server 2019 Base** beschrieben und trägt die Bezeichnung „Kostenloses Nutzungskontingent“. Es ist unter **Quick Start zu** finden.)
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.
+ Klicken Sie neben **Assign a security group (Sicherheitsgruppe zuweisen)** auf **Create a new security group (Neue Sicherheitsgruppe zuweisen)**.
+ Wählen Sie in der Zeile für **SSH** unter **Quelltyp** die Option **Meine** IP aus.
+ Wählen **Sie Sicherheitsgruppe hinzufügen**, wählen Sie **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**.. `2`
1. Wählen Sie **Launch Instance (Instance starten)** aus.
1. Wählen Sie **View all Instances** (Alle Instances anzeigen) aus, um die Bestätigungsseite zu schließen und zur Konsole zurückzukehren.
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.)
1. Es kann ein paar Minuten dauern, bis die Instance zur Verbindung bereitsteht. Stellen Sie sicher, dass Ihre Instance ihre Statusprüfungen bestanden hat. Sie können diese Informationen in der Spalte **Statusprüfungen** abrufen.
## Schritt 3: Erstellen Sie eine Anwendung in CodeDeploy
CodeDeployIn ist eine *Anwendung* eine Kennung in Form eines Namens für den Code, den Sie bereitstellen möchten. CodeDeploy verwendet diesen Namen, um sicherzustellen, dass während einer Bereitstellung auf die richtige Kombination aus Version, Bereitstellungskonfiguration und Bereitstellungsgruppe verwiesen wird. Sie wählen den Namen der CodeDeploy Anwendung, die Sie in diesem Schritt erstellen, wenn Sie später in diesem Tutorial Ihre Pipeline erstellen.
Sie erstellen zunächst eine Servicerolle CodeDeploy zur Verwendung. Wenn Sie bereits eine Servicerolle erstellt haben, müssen Sie keine weitere erstellen.
**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 AWS CodeDeploy 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**
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** die Servicerolle aus, die Sie zuvor erstellt haben. Sie müssen eine Servicerolle verwenden, die mindestens den unter [Eine Servicerolle erstellen für CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html) beschriebenen Vertrauensstellungen und Berechtigungen vertraut AWS CodeDeploy . Informationen zum Erhalt des Servicerollen-ARN finden Sie unter [Abrufen des Servicerollen-ARN (Konsole)](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console).
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. Wählen Sie im Feld **Schlüssel** die Option **Name** und geben Sie im Feld **Wert** die Eingabe ein**MyCodePipelineDemo**.
**Wichtig**
Sie müssen hier denselben Wert für den Schlüssel **Name** auswählen, den Sie Ihrer EC2-Instance beim Erstellen zugewiesen haben. Wenn Sie die Instances nicht mit **MyCodePipelineDemo** markiert haben, sollten Sie Ihren Wert verwenden.
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 Windows-Instanz ist bereits mit dem SSM-Agenten konfiguriert und wird nun mit dem CodeDeploy Agenten aktualisiert.
1. Wählen Sie unter **Bereitstellungseinstellungen** die Option`CodeDeployDefault.OneAtaTime`.
1. Stellen Sie sicher, dass unter **Load Balancer** das Feld **Load Balancing aktivieren** nicht ausgewählt ist. Sie müssen keinen Load Balancer einrichten oder eine Zielgruppe für dieses Beispiel auswählen. Nachdem Sie das Kontrollkästchen deaktiviert haben, werden die Load Balancer-Optionen nicht angezeigt.
1. Behalten Sie im Abschnitt **Advanced (Fortgeschritten)** die Standardwerte bei.
1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**.
## Schritt 4: Erstellen Sie Ihre erste Pipeline in CodePipeline
In diesem Teil des Tutorials erstellen Sie die Pipeline. Das Beispiel wird automatisch durch die Pipeline geführt.
**Um einen CodePipeline automatisierten Release-Prozess 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).
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**.
**Anmerkung**
Wenn Sie einen anderen Namen für Ihre Pipeline verwenden, stellen Sie sicher, dass Sie im Rest dieses Tutorials diesen Namen anstelle von **MyFirstPipeline** verwenden. Der Name einer erstellten Pipeline kann nicht nachträglich geändert werden. Pipeline-Namen unterliegen einigen Einschränkungen. Weitere Informationen finden Sie unter [Kontingente in AWS CodePipeline](limits.md).
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. Führen Sie unter **Service role** (Service-Rolle) einen der folgenden Schritte aus:
+ Wählen Sie **Neue Servicerolle** aus, CodePipeline um eine neue Servicerolle in IAM erstellen zu können.
+ Wählen Sie **Existing service role (Vorhandene Servicerolle)**, um eine Servicerolle zu verwenden, die in IAM bereits erstellt wurde. Wählen Sie unter **Name der Rolle** in der Liste Ihre Servicerolle aus.
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** unter **Quellanbieter** die Option **Amazon S3** aus. Geben Sie unter **Bucket** den Namen des S3-Buckets ein, den Sie in [Schritt 1: Erstellen Sie einen S3-Quell-Bucket für Ihre Anwendung](#s3-create-s3-bucket) erstellt haben. Geben Sie im **S3-Objektschlüssel** den Objektschlüssel mit oder ohne Dateipfad ein, und denken Sie daran, die Dateierweiterung einzuschließen. Geben Sie beispielsweise für `SampleApp_Windows.zip` den Namen der Beispieldatei ein, wie in diesem Beispiel gezeigt:
```
SampleApp_Windows.zip
```
Klicken Sie auf **Nächster Schritt**.
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-Bucket zu erkennen.
Wählen Sie **Weiter** aus.
1. Wählen Sie in **Schritt 4: Build-Phase hinzufügen** die Option **Build-Phase überspringen** aus und akzeptieren Sie dann die Warnmeldung, indem Sie erneut auf **Überspringen** klicken. Wählen Sie **Weiter** aus.
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 **. Das Feld **Region** ist standardmäßig auf dasselbe AWS-Region wie Ihre Pipeline eingestellt. Geben Sie unter **Application name (Anwendungsname)** `MyDemoApplication` ein, oder klicken Sie auf die Schaltfläche **Refresh (Aktualisieren)**, und wählen Sie dann den Namen der Anwendung aus der Liste aus. Geben Sie unter **Deployment group (Bereitstellungsgruppe)** **MyDemoDeploymentGroup** ein oder wählen Sie den Eintrag aus der Liste. Klicken Sie dann auf **Next (Weiter)**.
**Anmerkung**
Der Name „Deploy“ (Bereitstellen) ist der Name, der der Phase in **Step 4: Add deploy stage (Schritt 4: Bereitstellungsphase hinzufügen)** standardmäßig gegeben wird, so wie auch der ersten Phase der Pipeline der Name „Source“ (Quelle) gegeben wird.
1. Überprüfen **Sie in Schritt 7: Überprüfen** die Informationen und wählen Sie dann **Pipeline erstellen** aus.
1. Die Pipeline startet die Ausführung. Sie können sich Fortschritts-, Erfolgs- und Fehlschlagsmeldungen anzeigen lassen, während das CodePipeline Beispiel eine Webseite für jede Amazon EC2 EC2-Instance in der CodeDeploy Bereitstellung bereitstellt.
Herzlichen Glückwunsch\$1 Sie haben gerade eine einfache Pipeline in erstellt. CodePipeline Die Pipeline hat zwei Phasen:
+ Eine Quellstufe mit dem Namen **Source (Quelle)**, die Änderungen in der Versioning-Beispielanwendung erkennt, die im S3-Bucket gespeichert ist, und diese Änderungen in die Pipeline zieht.
+ Eine **Deploy (Bereitstellung)**-Phase, die diese Änderungen EC2-Instances mit CodeDeploy bereitstellt.
Anschließend ü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 **Succeeded (Erfolgreich)** für den Aktionsstatus angezeigt wird, wählen Sie im Statusbereich für die Phase **Deploy (Bereitstellen)** die Option **Details** aus. Dadurch wird die CodeDeploy Konsole geöffnet.
1. Wählen Sie auf der Registerkarte **Deployment group (Bereitstellungsgruppe)** unter **Deployment lifecycle events (Bereitstellungslebenszyklusereignisse)** eine Instance-ID aus. Daraufhin wird die EC2-Konsole geöffnet.
1. Kopieren Sie auf der Registerkarte **Description** in **Public DNS** die Adresse und fügen Sie diese in die Adressleiste Ihres Webbrowsers ein. Zeigen Sie die Indexseite für die Beispielanwendung an, die Sie in Ihren S3-Bucket hochgeladen haben.
Die Webseite für die Beispielanwendung, die Sie in Ihren S3-Bucket hochgeladen haben, wird angezeigt.
Weitere Informationen über Phasen, Aktionen und die Funktionsweise von Pipelines finden Sie unter [CodePipeline Konzepte ](concepts.md).
## Schritt 5: Hinzufügen einer weiteren Phase zur Pipeline
Nun fügen Sie der Pipeline eine weitere Phase hinzu, um mithilfe von CodeDeploy die Bereitstellung von Staging-Servern zu Produktionsservern auszuführen. Zunächst erstellen Sie eine weitere Bereitstellungsgruppe CodePipelineDemoApplication in CodeDeploy. Anschließend fügen Sie eine Phase hinzu, die eine Aktion enthält, die diese Bereitstellungsgruppe verwendet. Um eine weitere Phase hinzuzufügen, verwenden Sie die CodePipeline Konsole oder die, AWS CLI um die Struktur der Pipeline in einer JSON-Datei abzurufen und manuell zu bearbeiten, und führen dann den **update-pipeline** Befehl aus, um die Pipeline mit Ihren Änderungen zu aktualisieren.
**Topics**
+ [Erstellen Sie eine zweite Bereitstellungsgruppe in CodeDeploy](#s3-add-stage-part-1)
+ [Hinzufügen der Bereitstellungsgruppe als weitere Phase in Ihrer Pipeline](#s3-add-stage-part-2)
### Erstellen Sie eine zweite Bereitstellungsgruppe in CodeDeploy
**Anmerkung**
In diesem Teil des Tutorials erstellen Sie eine zweite Bereitstellungsgruppe, die Bereitstellung erfolgt jedoch auf denselben Amazon EC2 EC2-Instances wie zuvor. Dies erfolgt lediglich zu Demonstrationszwecken. Es ist bewusst so konzipiert, dass es Ihnen nicht zeigt, wie Fehler in angezeigt werden. CodePipeline
**Um eine zweite Bereitstellungsgruppe in zu erstellen CodeDeploy**
1. Öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
1. Wählen Sie die Liste **Applications (Anwendungen)** aus, und wählen Sie in der Liste `MyDemoApplication` aus.
1. Wählen Sie die Registerkarte **Deployment groups (Bereitstellungsgruppen)** und klicken Sie dann auf **Create deployment group (Bereitstellungsgruppe erstellen)**.
1. Geben Sie auf der Seite **Create deployment group (Bereitstellungsgruppe erstellen)** unter **Deployment group name (Name der Bereitstellungsgruppe)** einen Namen für die zweite Bereitstellungsgruppe ein (z. B. **CodePipelineProductionFleet**).
1. Wählen Sie **unter Service Role** dieselbe CodeDeploy Servicerolle aus, die Sie für die erste Bereitstellung verwendet haben (nicht die CodePipeline Servicerolle).
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. Wählen Sie **Name** im Feld **Key (Schlüssel)** aus und wählen Sie im Feld **Value (Wert)** aus der Liste die Option `MyCodePipelineDemo` aus. Lassen Sie die Standardkonfiguration für **Deployment sttings (Bereitstellungseinstellungen)** unverändert.
1. Wählen Sie in **Deployment configuration (Bereitstellungskonfiguration)** die Option `CodeDeployDefault.OneAtaTime` aus.
1. Deaktivieren Sie unter **Load Balancer** die Option **Enable load balancing (Load Balancing aktivieren)**.
1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**.
### Hinzufügen der Bereitstellungsgruppe als weitere Phase in Ihrer Pipeline
Da Sie nun eine weitere Bereitstellungsgruppe erstellt haben, können Sie eine Phase hinzufügen, die diese Bereitstellungsgruppe verwendet, um eine Bereitstellung für die gleichen EC2-Instances wie zuvor auszuführen. Sie können die CodePipeline Konsole oder die verwenden AWS CLI , um diese Phase hinzuzufügen.
**Topics**
+ [Erstellen einer dritten Phase (Konsole)](#s3-add-stage-part-2-console)
+ [Erstellen einer dritten Phase (CLI)](#s3-add-stage-part-2-cli)
#### Erstellen einer dritten Phase (Konsole)
Sie können die CodePipeline Konsole verwenden, um eine neue Phase hinzuzufügen, die die neue Bereitstellungsgruppe verwendet. Da diese Bereitstellungsgruppe Bereitstellungen für die gleichen EC2-Instances wie zuvor ausführt, schlägt die Bereitstellungsaktion in dieser Phase fehl.
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).
1. Wählen Sie im Feld **Name** den Namen der Pipeline aus, den Sie zuvor erstellt haben ( MyFirstPipeline).
1. Wählen Sie auf der Pipelinedetails-Seite **Edit** aus.
1. Wählen Sie auf der Seite **Edit (Bearbeiten)** die Option **\$1 Add stage (Phase hinzufügen)** aus, um eine Phase unmittelbar hinter der Phase "Deploy" (Bereitstellung) hinzuzufügen.
![\[Bild, das die Schaltfläche „+ Stufe hinzufügen“ auf dem Bearbeitungsbildschirm zeigt\]](http://docs.aws.amazon.com/de_de/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)
1. Geben Sie unter **Add stage (Stufe hinzufügen)** in das Feld **Stage name (Stufenname)** **Production** ein. Klicken Sie auf **Add stage (Phase hinzufügen)**.
1. Wählen Sie in der neuen Phase **\$1 Add action group (Aktionsgruppe hinzufügen)**.
1. Geben Sie unter **Edit action (Aktion bearbeiten)** in das Feld **Action name (Aktionsname)** **Deploy-Second-Deployment** ein. Wählen Sie in **Action Provider** unter **Deploy** die Option **CodeDeploy**.
1. Wählen Sie in dem CodeDeploy Abschnitt unter **Anwendungsname** eine Option `MyDemoApplication` aus der Dropdownliste aus, wie Sie es beim Erstellen der Pipeline getan haben. Wählen Sie in **Deployment group (Bereitstellungsgruppe)** die Bereitstellungsgruppe aus, die Sie gerade erstellt haben, **CodePipelineProductionFleet**. Wählen Sie unter **Input artifacts (Eingabe-Artefakte)** das Eingabe-Artefakt aus der Quellaktion aus. Wählen Sie **Speichern**.
1. Klicken Sie auf der Seite **Edit (Bearbeiten)** auf **Save (Speichern)**. Klicken Sie unter **Save pipeline changes (Pipeline-Änderungen speichern)** auf **Save (Speichern)**.
1. Obwohl die neue Stufe der Pipeline hinzugefügt wurde, wird der Status **No executions yet (Zurzeit keine Ausführungen)** angezeigt. Dies liegt daran, dass noch keine Änderungen eine weitere Ausführung der Pipeline ausgelöst haben. Sie müssen die letzte Revision manuell erneut ausführen, um die Ausführung der Pipeline nach der Bearbeitung zu testen. Wählen Sie auf der Seite mit den Pipeline-Details die Option **Versionsänderung** aus und klicken Sie dann auf **Freigabe**, wenn Sie dazu aufgefordert werden. Dadurch wird die letzte Revision gestartet, die in jedem in einer Quellaktion der Pipeline angegebenen Quellspeicherort vorhanden ist.
AWS CLI Um die Pipeline erneut auszuführen, führen Sie alternativ den Befehl von einem Terminal auf Ihrem lokalen Linux-, macOS- oder Unix-Computer oder von einer Befehlszeile auf Ihrem lokalen Windows-Computer aus und geben Sie den Namen der Pipeline an. **start-pipeline-execution** Dadurch wird die Anwendung in Ihrem Quell-Bucket über die Pipeline ein zweites Mal ausgeführt.
```
aws codepipeline start-pipeline-execution --name MyFirstPipeline
```
Dieser Befehl gibt ein `pipelineExecutionId`-Objekt zurück.
1. Kehren Sie zur CodePipeline Konsole zurück und wählen Sie in der Liste der Pipelines, ob Sie die Ansichtsseite öffnen **MyFirstPipeline**möchten.
Die Pipeline zeigt drei Phasen und den Status des ausgeführten Artefakts in den drei Phasen an. Es kann bis zu fünf Minuten dauern, bis die Pipeline alle Phasen durchlaufen hat. Für die ersten zwei Stufen wird wie zuvor die erfolgreiche Bereitstellung angezeigt. Die Stufe **Production (Produktion)** zeigt jedoch an, dass die Aktion **Deploy-Second-Deployment** fehlgeschlagen ist.
1. Klicken Sie in der **Deploy-Second-Deployment-**-Aktion auf **Details**. Sie werden auf die Seite für die CodeDeploy-Bereitstellung weitergeleitet. In diesem Fall wird der Fehler durch die Bereitstellung der ersten Instance-Gruppe in allen EC2-Instances verursacht. Somit verbleiben keine Instances für die zweite Bereitstellungsgruppe.
**Anmerkung**
Dieser Fehler ist beabsichtigt. Er soll demonstrieren, was passiert, wenn es einen Fehler in einer Pipeline-Phase gibt.
#### Erstellen einer dritten Phase (CLI)
Das Hinzufügen einer Phase AWS CLI zu Ihrer Pipeline ist zwar komplexer als das Verwenden der Konsole, bietet jedoch einen besseren Einblick in die Struktur der Pipeline.
**So erstellen Sie eine dritte Phase für Ihre Pipeline**
1. Öffnen Sie eine Terminalsitzung auf Ihrem lokalen Linux-, macOS- oder Unix-Computer oder eine Befehlszeile auf Ihrem lokalen Windows-Computer und führen Sie den **get-pipeline** Befehl aus, um die Struktur der Pipeline anzuzeigen, die Sie gerade erstellt haben. Für **MyFirstPipeline** geben Sie beispielsweise den folgenden Befehl ein:
```
aws codepipeline get-pipeline --name "MyFirstPipeline"
```
Dieser Befehl gibt die Struktur von zurück MyFirstPipeline. Der erste Teil der Ausgabe sollte wie folgt aussehen:
```
{
"pipeline": {
"roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service",
"stages": [
...
```
Der letzte Teil der Ausgabe enthält die Pipelinemetadaten und sollte in etwa wie folgt aussehen:
```
...
],
"artifactStore": {
"type": "S3"
"location": "amzn-s3-demo-bucket",
},
"name": "MyFirstPipeline",
"version": 4
},
"metadata": {
"pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline",
"updated": 1501626591.112,
"created": 1501626591.112
}
}
```
1. Kopieren Sie diese Struktur in einen Texteditor und speichern Sie die Datei als **pipeline.json**. Speichern Sie diese Datei der Einfachheit halber in dem Verzeichnis, in dem Sie die **aws codepipeline**-Befehle ausgeführt haben.
**Anmerkung**
Sie können den JSON-Code mit dem Befehl **get-pipeline** folgendermaßen direkt in eine Datei umleiten:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
1. Kopieren Sie den Phasenabschnitt **Deploy (Bereitstellen)** und fügen Sie ihn hinter den ersten beiden Phasen ein. Da es sich um eine Bereitstellungsphase handelt (genau wie die Phase **Staging**), können Sie diese als Vorlage für die dritte Phase nutzen.
1. Ändern Sie den Namen der Phase und die Details der Bereitstellungsgruppe.
**Das folgende Beispiel zeigt den JSON-Code, den Sie der Datei pipeline.json nach der Bereitstellungsphase hinzufügen.** Ändern Sie die Werte der hervorgehobenen Elemente. Denken Sie daran, die Phasendefinitionen **Deploy (Bereitstellen)** und **Production (Produktion)** durch ein Komma zu trennen.
```
,
{
"name": "Production",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "Deploy-Second-Deployment",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"version": "1",
"provider": "CodeDeploy"
},
"outputArtifacts": [],
"configuration": {
"ApplicationName": "CodePipelineDemoApplication",
"DeploymentGroupName": "CodePipelineProductionFleet"
},
"runOrder": 1
}
]
}
```
1. Wenn Sie mit einer Pipeline-Struktur arbeiten, die Sie mit dem Befehl **get-pipeline** abgerufen haben, müssen Sie die `metadata`-Zeilen aus der JSON-Datei entfernen. Andernfalls kann der **update-pipeline**-Befehl sie nicht nutzen. Entfernen Sie die `"metadata": { }`-Zeilen und die Felder `"created"`, `"pipelineARN"` und `"updated"`.
Entfernen Sie z. B. die folgenden Zeilen aus der Struktur:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
}
```
Speichern Sie die Datei.
1. Führen Sie den Befehl **update-pipeline** aus. Geben Sie die Pipeline-JSON-Datei dabei folgendermaßen an:
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Dieser Befehl gibt die gesamte Struktur der aktualisierten Pipeline zurück.
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
1. Führen Sie den Befehl **start-pipeline-execution** aus und geben Sie dabei den Namen der Pipeline an. Dadurch wird die Anwendung in Ihrem Quell-Bucket über die Pipeline ein zweites Mal ausgeführt.
```
aws codepipeline start-pipeline-execution --name MyFirstPipeline
```
Dieser Befehl gibt ein `pipelineExecutionId`-Objekt zurück.
1. Öffnen Sie die CodePipeline Konsole und wählen Sie **MyFirstPipeline**aus der Liste der Pipelines aus.
Die Pipeline zeigt drei Phasen und den Status des ausgeführten Artefakts in den drei Phasen an. Es kann bis zu fünf Minuten dauern, bis die Pipeline alle Phasen durchlaufen hat. Die ersten zwei Phasen werden, wie zuvor, erfolgreich bereitgestellt. Die Phase **Production** zeigt an, dass die Aktion **Deploy-Second-Deployment-** fehlgeschlagen ist.
1. Klicken Sie in der Aktion **Deploy-Second-Deployment-** auf **Details**, um Details zum Fehler anzuzeigen. Sie werden auf die Detailseite für die CodeDeploy Bereitstellung weitergeleitet. In diesem Fall wird der Fehler durch die Bereitstellung der ersten Instance-Gruppe in allen EC2-Instances verursacht. Somit verbleiben keine Instances für die zweite Bereitstellungsgruppe.
**Anmerkung**
Dieser Fehler ist beabsichtigt. Er soll demonstrieren, was passiert, wenn es einen Fehler in einer Pipeline-Phase gibt.
## (Optional) Schritt 6: Deaktivieren und aktivieren Sie Übergänge zwischen den Phasen in CodePipeline
Sie können den Übergang zwischen Phasen in einer Pipeline aktivieren oder deaktivieren. Durch die Deaktivierung des Übergangs zwischen Phasen können Sie die Übergänge zwischen Phasen manuell steuern. Beispielsweise möchten Sie die ersten beiden Phasen einer Pipeline ausführen, den Übergang zur dritten Phase jedoch deaktivieren, bis Sie für die Bereitstellung für die Produktion bereit sind oder während Sie ein Problem oder einen Ausfall für die betreffende Phase beheben.
**Um Übergänge zwischen Stufen in einer CodePipeline Pipeline zu deaktivieren und zu aktivieren**
1. Öffnen Sie die CodePipeline Konsole und wählen Sie **MyFirstPipeline**aus der Liste der Pipelines aus.
1. Klicken Sie auf der Detailseite für die Pipeline auf die Schaltfläche **Disable transition (Übergang deaktivieren)** zwischen der zweiten Phase, **Deploy (Bereitstellen)**), und der dritten Phase, **Production (Produktion)**, die Sie im vorigen Abschnitt hinzugefügt haben.
1. Geben Sie unter **Disable transition (Übergang deaktivieren)** einen Grund für das Deaktivieren des Übergangs zwischen den Stufen ein und klicken Sie dann auf **Disable (Deaktivieren)**.
Der Pfeil zwischen den Phasen zeigt ein Symbol an, die Farbe ändert sich und die Schaltfläche **Enable transition (Übergang aktivieren)** wird angezeigt.
![\[Das Bild zeigt den eingegebenen Grund für die Deaktivierung des Übergangs als „Deaktivierung des Übergangs, während ich den Fehler behebe“\]](http://docs.aws.amazon.com/de_de/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)
1. Laden Sie Ihr Beispiel erneut in den S3-Bucket hoch. Da der Bucket versioniert ist, startet diese Änderung die Pipeline.
1. Kehren Sie zur Detailseite für Ihre Pipeline zurück und prüfen Sie den Status der Phasen. Die Pipelineanzeige ändert sich und zeigt den Fortschritt und den Erfolg für die ersten zwei Phasen an. Für die dritte Phase werden keine Änderungen durchgeführt. Dieser Vorgang kann einige Minuten dauern.
1. Aktivieren Sie den Übergang, indem Sie die Schaltfläche **Enable transition (Übergang aktivieren)** zwischen den beiden Phasen auswählen. Wählen Sie im Dialogfeld **Enable transition** die Option **Enable** aus. Die Phase wird in ein paar Minuten ausgeführt und versucht, das bereits für die ersten beiden Phasen der Pipeline ausgeführte Artefakt zu verarbeiten.
**Anmerkung**
Wenn Sie möchten, dass diese dritte Phase erfolgreich ist, bearbeiten Sie die CodePipelineProductionFleet Bereitstellungsgruppe, bevor Sie den Übergang aktivieren, und geben Sie einen anderen Satz von EC2-Instances an, auf denen die Anwendung bereitgestellt wird. Weitere Informationen dazu finden Sie unter [Ändern der Einstellungen von Bereitstellungsgruppen](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html). Wenn Sie mehrere EC2-Instances erstellen, können für Sie zusätzliche Kosten entstehen.
## Schritt 7: Bereinigen von Ressourcen
Sie können einige der Ressourcen, die Sie in diesem Tutorial erstellt haben, für [Tutorial: Erstellen einer vierstufigen Pipeline](tutorials-four-stage-pipeline.md) verwenden. Sie können beispielsweise die CodeDeploy Anwendung und die Bereitstellung wiederverwenden. Sie können eine Build-Aktion mit einem Anbieter wie CodeBuild, einem vollständig verwalteten Build-Service in der Cloud, konfigurieren. Sie können eine Build-Aktion auch so konfigurieren, dass ein Anbieter mit einem Build-Server oder -System verwendet wird, z. B. Jenkins.
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örigen Amazon EC2 EC2-Instances und schließlich den S3-Bucket.
**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 [So bereinigen Sie Ressourcen (Konsole)](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console).
1. Folgen Sie den Anweisungen unter [Löschen oder Leeren von Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html), um den S3-Bucket zu löschen. Wenn Sie nicht noch weitere Pipelines erstellen möchten, löschen Sie den S3-Bucket, den Sie für die Speicherung Ihrer Pipeline-Artefakte erstellt haben. Unter [CodePipeline Konzepte ](concepts.md) finden Sie weitere Informationen zu diesem Bucket.