

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 Beanstalk Cluster
<a name="beanstalk-cluster-getting-started"></a>

In diesem Tutorial erstellen Sie eine Elastic Beanstalk-Anwendung und eine Beanstalk-Cluster-Umgebung. Sie lassen die Anwendungsversion weg, sodass Elastic Beanstalk sein vorgefertigtes Beispiel-Container-Image bereitstellt. Anschließend warten Sie, bis die Umgebung bereit ist, rufen ihre URL ab und beenden sie. Alternativ können Sie in der AWS Managementkonsole beginnen, die eine umfassende Anleitung bietet, oder Ihren AI-Agenten auf die [Bohnendistel-Cluster](beanstalk-cluster.md) Dokumentation verweisen.

Geschätzte Dauer: ** 15—20 Minuten **

**Wichtig**  
Für Elastic Beanstalk fallen keine zusätzlichen Gebühren an, aber Sie zahlen für die AWS Ressourcen, die die Umgebung nutzt, einschließlich Amazon EKS und der zugehörigen Rechenleistung. Weitere Informationen finden Sie unter Preise für [ Elastic Beanstalk. ](https://aws.amazon.com/elasticbeanstalk/pricing/) Schließen Sie die Bereinigungsschritte ab, wenn Sie dieses Tutorial abgeschlossen haben.

## Bevor Sie beginnen
<a name="beanstalk-cluster-getting-started-prerequisites"></a>

Sie müssen folgende Voraussetzungen erfüllen:
+ Installieren und Konfigurieren der AWS CLI. Eine Anleitung finden Sie unter [ Erste Schritte mit dem AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) im *AWS Command Line Interface Benutzerhandbuch*.
+ Verwenden Sie einen IAM-Principal, der Elastic Beanstalk-Anwendungen und -Umgebungen erstellen und verwalten kann und der bei der Erstellung einer Umgebung die Cluster-, Knoten- und Observability-Rollen übernehmen kann. Die genauen Berechtigungen finden Sie unter. [Berechtigungen zum Erstellen der Umgebung](beanstalk-cluster-permissions.md#beanstalk-cluster-permissions-caller)
+ Erstellen Sie die Cluster-Rolle, die Amazon EKS übernimmt, die Knotenrolle, die die Amazon EC2-Knoten des Clusters übernehmen, und die Observability-Rolle, die die Metriken, Protokolle und Traces der Umgebung veröffentlicht, wie unter beschrieben. [Erstellen Sie die IAM-Rollen](#beanstalk-cluster-getting-started-roles) Informationen zur Auswahl der VPC-Subnetze, die die Umgebung verwendet, finden Sie unter. [Konfiguration des Netzwerks für Beanstalk Cluster-Umgebungen](configuring-cluster-networking.md)
+ Wählen Sie eine AWS Region aus, in der Beanstalk Cluster verfügbar ist. Die Befehle verwenden die Region aus Ihrer AWS CLI Konfiguration.

## Erstellen Sie die IAM-Rollen
<a name="beanstalk-cluster-getting-started-roles"></a>

Eine Beanstalk-Cluster-Umgebung benötigt drei IAM-Rollen, die Sie bereitstellen: eine Cluster-Rolle, eine Node-Rolle und eine Observability-Rolle. Die Elastic Beanstalk-Konsole erstellt sie für Sie, aber in diesem Tutorial werden sie verwendet. Erstellen Sie sie also zuerst. AWS CLI Verwenden Sie diese Namen, da die Konsole vorhandene Rollen nach Namen auswählt. Informationen zum Zweck der einzelnen Rollen und zu den Anruferberechtigungen, die Sie benötigen, um sie zu vergeben, finden Sie unter[Berechtigungen für Beanstalk Cluster](beanstalk-cluster-permissions.md).

**So erstellen Sie die Cluster-, Knoten- und Observability-Rollen**

1. Erstellen Sie eine Vertrauensrichtliniendatei für jeden Dienst, der eine Rolle übernimmt. Die Cluster-Rolle vertraut Amazon EKS, die Node-Rolle vertraut Amazon EC2 und die Observability-Rolle vertraut Amazon EKS Pod Identity.

   ```
   $ cat > eks-trust.json <<'EOF'
   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Principal": {"Service": "eks.amazonaws.com"},
       "Action": ["sts:AssumeRole", "sts:TagSession"]
     }]
   }
   EOF
   ```

   ```
   $ cat > ec2-trust.json <<'EOF'
   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Principal": {"Service": "ec2.amazonaws.com"},
       "Action": "sts:AssumeRole"
     }]
   }
   EOF
   ```

   ```
   $ cat > pods-trust.json <<'EOF'
   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Principal": {"Service": "pods.eks.amazonaws.com"},
       "Action": ["sts:AssumeRole", "sts:TagSession"]
     }]
   }
   EOF
   ```

1. Erstellen Sie die Cluster-Rolle und fügen Sie ihre Richtlinien hinzu.

   ```
   $ aws iam create-role \
       --role-name aws-elasticbeanstalk-eks-cluster-role \
       --assume-role-policy-document file://eks-trust.json
   $ for p in AmazonEKSClusterPolicy AmazonEKSNetworkingPolicy AmazonEKSComputePolicy \
            AmazonEKSBlockStoragePolicy AmazonEKSLoadBalancingPolicy AWSElasticBeanstalkEKSTagging; do
       aws iam attach-role-policy \
           --role-name aws-elasticbeanstalk-eks-cluster-role \
           --policy-arn arn:aws:iam::aws:policy/$p
   done
   ```

1. Erstellen Sie die Knotenrolle und fügen Sie ihre Richtlinien hinzu.

   ```
   $ aws iam create-role \
       --role-name aws-elasticbeanstalk-eks-node-role \
       --assume-role-policy-document file://ec2-trust.json
   $ for p in AmazonEKSWorkerNodeMinimalPolicy AmazonEC2ContainerRegistryPullOnly \
            AmazonSSMManagedInstanceCore; do
       aws iam attach-role-policy \
           --role-name aws-elasticbeanstalk-eks-node-role \
           --policy-arn arn:aws:iam::aws:policy/$p
   done
   ```

1. Erstellen Sie die Observability-Rolle und fügen Sie die zugehörigen Richtlinien hinzu.

   ```
   $ aws iam create-role \
       --role-name aws-elasticbeanstalk-eks-observability-role \
       --assume-role-policy-document file://pods-trust.json
   $ for p in CloudWatchAgentServerPolicy AWSElasticBeanstalkEKSObservability; do
       aws iam attach-role-policy \
           --role-name aws-elasticbeanstalk-eks-observability-role \
           --policy-arn arn:aws:iam::aws:policy/$p
   done
   ```

1. Notieren Sie die drei Rollen-ARNs. Sie übergeben sie, wenn Sie die Umgebung erstellen.

   ```
   $ for r in cluster node observability; do
       aws iam get-role --role-name aws-elasticbeanstalk-eks-$r-role \
           --query 'Role.Arn' --output text
   done
   ```

## Wählen Sie ein unterstütztes Bereitstellungstool
<a name="beanstalk-cluster-getting-started-tools"></a>

Sie können eine Beanstalk-Cluster-Umgebung mit der Elastic Beanstalk-Konsole, der Elastic Beanstalk-API oder der erstellen und verwalten. AWS CLI In diesem Tutorial wird die verwendet, AWS CLI sodass jede Anfrage sichtbar und wiederholbar ist.

Sie können die Bereitstellung auch mit der offiziellen GitHub Aktion durchführen und Ihre Umgebungen mit Terraform über den Anbieter als Infrastruktur als Code definieren. AWS Informationen zur GitHub Aktion finden Sie unter. [Verwenden von Aktionen zur Bereitstellung auf Elastic Beanstalk GitHub](deploying-github-actions.md)

## Erstellen Sie die Anwendung und stellen Sie das Beispiel bereit
<a name="beanstalk-cluster-getting-started-deploy"></a>

1. Erstellen Sie eine Elastic Beanstalk-Anwendung, die die Umgebung enthält.

   ```
   $ aws elasticbeanstalk create-application \
       --application-name getting-started-cluster-app
   ```

1. Erstellen Sie die Umgebung. Die `Cluster` Stufe wählt Beanstalk Cluster aus. Da diese Anfrage keine Versionsbezeichnung hat, stellt Elastic Beanstalk die Beispielanwendung bereit.

   ```
   $ aws elasticbeanstalk create-environment \
       --application-name getting-started-cluster-app \
       --environment-name getting-started-cluster-env \
       --tier Name=Cluster,Type=EKS \
       --option-settings \
           Namespace=aws:elasticbeanstalk:eks,OptionName=cluster-role,Value={{cluster-role-arn}} \
           Namespace=aws:elasticbeanstalk:eks,OptionName=node-role,Value={{node-role-arn}} \
           Namespace=aws:elasticbeanstalk:eks:environment,OptionName=observability-role,Value={{observability-role-arn}}
   ```

   Ersetzen Sie die RAN-Platzhalter für Rollen durch die Rollen, die Sie vorbereitet haben. In der Anfrage wird und ausgelassen. `service-port` `load-balancer-type` Elastic Beanstalk setzt diese Einstellungen auf ihre Standardwerte zurück, und. `8080` `ALB` Um andere Werte auszuwählen, übergeben Sie sie mit. `--option-settings` Die vollständige Referenz zu den Optionen finden Sie unter[Konfigurationsoptionen für Beanstalk Cluster-Umgebungen](command-options-general-eks.md).

1. Warten Sie, bis die Umgebung bereit ist. Eine erste Umgebung kann 15 bis 20 Minuten dauern, bis Elastic Beanstalk den Amazon EKS-Cluster erstellt und das Beispiel bereitstellt. Der AWS CLI bietet einen integrierten Kellner, der abfragt, bis die Umgebung Bericht erstattet. `Ready` Der Kellner fragt höchstens 20 Mal in Intervallen von 20 Sekunden ab, etwa 6 Minuten 40 Sekunden. Erwarten Sie also in der ersten Umgebung, dass er sich meldet. `Max attempts exceeded` Führen Sie es erneut aus, bis es Erfolg meldet.

   ```
   $ aws elasticbeanstalk wait environment-exists \
       --environment-names getting-started-cluster-env
   ```

   Der Kellner meldet `Max attempts exceeded` sowohl, wann die Umgebung noch erstellt wird, als auch, wenn die Erstellung fehlgeschlagen ist. Wenn nach einigen Durchläufen kein Erfolg gemeldet wird, überprüfen Sie die letzten Ereignisse der Umgebung und beheben Sie den gemeldeten Fehler, bevor Sie fortfahren.

   ```
   $ aws elasticbeanstalk describe-events \
       --environment-name getting-started-cluster-env \
       --query 'Events[].[EventDate,Severity,Message]' \
       --output table
   ```

1. Prüfen Sie den Umgebungsstatus, die Integritätsfarbe, den Integritätsstatus und die URL.

   ```
   $ aws elasticbeanstalk describe-environments \
       --application-name getting-started-cluster-app \
       --environment-names getting-started-cluster-env \
       --query 'Environments[0].[Status,Health,HealthStatus,CNAME]' \
       --output table
   ```

   Vergewissern Sie sich, dass die Umgebung meldet `Ready` und einen Wert zurückgibt, der nicht leer ist`CNAME`. Öffnen Sie in einem Webbrowser, `https://` gefolgt vom CNAME, und vergewissern Sie sich, dass die Beispielanwendung reagiert. Der Load Balancer antwortet nur über HTTPS. Eine Anfrage `http://` wartet also, bis ein Timeout eintritt. Informationen dazu, wie Sie HTTP-Anfragen akzeptieren und sie von Elastic Beanstalk an HTTPS umleiten lassen, finden Sie unter. [Konfiguration des Netzwerks für Beanstalk Cluster-Umgebungen](configuring-cluster-networking.md) Eine inaktive Umgebung kann anfänglich einen Bericht erstatten `Grey``NoData`, weil sie zu wenige Anfragen erhalten hat, um den Zustand der Anwendung zu ermitteln. Bei Integritätsereignissen wird dieser Status als angezeigt. `No Data` Dies weist nicht auf eine fehlgeschlagene Bereitstellung hin. Wenn die Anwendung genügend erfolgreiche Anfragen erhalten hat, wechselt der Status normalerweise zu `Green` und`Ok`. Wenn der CNAME leer ist, die Anwendung nicht reagiert oder der Systemzustand einen Fehler meldet, überprüfen Sie die aktuellen Ereignisse in der Umgebung, bevor Sie fortfahren:

   ```
   $ aws elasticbeanstalk describe-events \
       --environment-name getting-started-cluster-env \
       --query 'Events[].[EventDate,Severity,Message]' \
       --output table
   ```

   Das Cluster-Integritätsmodell finden Sie unter[Überwachung von Beanstalk Cluster-Umgebungen](monitoring-cluster-environments.md).

## Stellen Sie Ihr eigenes Container-Image bereit
<a name="beanstalk-cluster-getting-started-deploy-own"></a>

In der Umgebung wird die Beispielanwendung ausgeführt, da die Erstellungsanforderung keine Versionsbezeichnung trug. Um Ihre eigene Anwendung auszuführen, erstellen Sie eine * Anwendungsversion, * die Ihr Container-Image benennt, und stellen Sie diese Version dann in der Umgebung bereit. Dies ist der normale Elastic Beanstalk-Ablauf: Eine Anwendungsversion ist das bereitstellbare Artefakt, und das Beispiel zeigt, was Elastic Beanstalk bereitstellt, wenn Sie keine bereitstellen.

Bevor Sie beginnen, benötigen Sie ein Container-Image, das Sie bereits in eine Registry übertragen haben, z. B. in ein Amazon Elastic Container Registry (Amazon ECR) -Repository in Ihrem Konto. Das Image muss auf der Umgebung lauschen, sofern Sie es `service-port` nicht geändert haben. `8080` Durch die Bereitstellung Ihrer eigenen Version wird die Beispielanwendung ersetzt. Wenn Elastic Beanstalk das Image stattdessen aus Ihrer Quelle erstellen soll, und Informationen zu den Build-Optionen finden Sie unter. [Erstellen von Container-Images für Beanstalk Cluster-Umgebungen](beanstalk-cluster-app-versions.md)

1. Erstellen Sie eine Anwendungsversion, die auf Ihr Image verweist.

   ```
   $ aws elasticbeanstalk create-application-version \
       --application-name getting-started-cluster-app \
       --version-label v1 \
       --image-configuration Source={Uri={{your-image-uri}}}
   ```

   {{your-image-uri}}Ersetzen Sie es zum Beispiel durch Ihr Bild`111122223333.dkr.ecr.us-east-1.amazonaws.com/my-app:v1`. Da das Image bereits erstellt wurde, benötigt die Version keinen Build-Schritt und ist bereit für die Bereitstellung.

1. Stellen Sie die Version in der Umgebung bereit.

   ```
   $ aws elasticbeanstalk update-environment \
       --environment-name getting-started-cluster-env \
       --version-label v1
   ```

1. Vergewissern Sie sich, dass die Bereitstellung abgeschlossen ist und die Umgebung Ihre Anwendung unterstützt.

   ```
   $ aws elasticbeanstalk describe-events \
       --environment-name getting-started-cluster-env \
       --query 'Events[].[EventDate,Severity,Message]' \
       --output table
   ```

   Öffnen Sie in einem Webbrowser, `https://` gefolgt vom CNAME der Umgebung, und vergewissern Sie sich, dass Ihre Anwendung reagiert. Ist dies nicht der Fall, überprüfen Sie die Ereignisse auf einen Bereitstellungsfehler und vergewissern Sie sich, dass das Image die Umgebung überwacht. `service-port`

## Räumen Sie die Ressourcen für das Tutorial auf
<a name="beanstalk-cluster-getting-started-cleanup"></a>

1. Die Umgebung beenden.

   ```
   $ aws elasticbeanstalk terminate-environment \
       --environment-name getting-started-cluster-env
   ```

1. Warten Sie, bis die Umgebung den `Terminated` Status erreicht hat. Der AWS CLI bietet einen integrierten Kellner, der bis zum Abschluss der Kündigung abfragt. Dieser Kellner hat dasselbe Limit von 20 Versuchen. Führen Sie ihn also erneut aus, bis er Erfolg meldet.

   ```
   $ aws elasticbeanstalk wait environment-terminated \
       --environment-names getting-started-cluster-env
   ```

   Der Kellner meldet `Max attempts exceeded` sowohl, wenn die Kündigung noch im Gange ist, als auch, wenn sie fehlgeschlagen ist. Wenn nach einigen Durchläufen kein Erfolg gemeldet wird, beheben Sie den Fehler in den Umgebungsereignissen. Löschen Sie die Anwendung nicht, solange die Umgebung noch existiert.

1. Löschen Sie die Anwendung und ihre Anwendungsversionen, einschließlich der von Elastic Beanstalk erstellten Beispielversion und aller von Ihnen hinzugefügten Versionen. Dadurch wird weder ein von Ihnen bereitgestelltes Container-Image noch das Repository gelöscht, das es enthält; siehe. [Erstellen von Container-Images für Beanstalk Cluster-Umgebungen](beanstalk-cluster-app-versions.md)

   ```
   $ aws elasticbeanstalk delete-application \
       --application-name getting-started-cluster-app
   ```

Elastic Beanstalk löscht einen gemeinsam genutzten Amazon EKS-Cluster erst, nachdem Sie die letzte Umgebung beendet haben, in der er verwendet wird. Das Löschen eines Clusters kann bis zu drei Stunden dauern. Amazon EKS und andere Ressourcen werden solange berechnet, bis der Löschvorgang abgeschlossen ist. Durch die Kündigung werden die vom Kunden bereitgestellten Cluster-, Knoten- und Observability-IAM-Rollen nicht gelöscht. Überprüfen Sie das Löschen des Clusters wie unter beschrieben. [Löschen des Clusters](beanstalk-cluster-concepts.md#beanstalk-cluster-clusters-lifecycle)

## Nächste Schritte
<a name="beanstalk-cluster-getting-started-next"></a>
+ Stellen Sie Ihr eigenes Container-Image oder Ihre eigene Quelle bereit, indem Sie eine Anwendungsversion erstellen. Siehe [Erstellen von Container-Images für Beanstalk Cluster-Umgebungen](beanstalk-cluster-app-versions.md).
+ Konfigurieren Sie Ressourcenlimits, Skalierung, Bereitstellungsverhalten, Lastenausgleich und Beobachtbarkeit. Siehe [Konfigurationsoptionen für Beanstalk Cluster-Umgebungen](command-options-general-eks.md).
+ Erfahren Sie, wie Sie die Umgebung aktualisieren und überwachen. Siehe [Verwaltung von Elastic Beanstalk-Umgebungen](using-features.managing.md) und [Überwachung von Beanstalk Cluster-Umgebungen](monitoring-cluster-environments.md).