

 **Unterstützung für die Verbesserung dieser Seite beitragen** 

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.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.

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.

# Einen Cluster mit Amazon EKS Auto Mode erstellen
<a name="create-auto"></a>

In diesem Kapitel wird erläutert, wie Sie mithilfe verschiedener Tools und Schnittstellen einen Amazon-EKS-Cluster mit Auto Mode erstellen. Auto Mode vereinfacht die Cluster-Erstellung durch die automatische Konfiguration und Verwaltung der Rechen-, Netzwerk- und Speicherinfrastruktur des Clusters. Sie erfahren, wie Sie mithilfe der AWS-CLI, AWS-Managementkonsole oder des Befehlszeilentools eksctl einen Auto-Mode-Cluster erstellen.

**Anmerkung**  
EKS Auto Mode erfordert Kubernetes Version 1.29 oder höher.

Wählen Sie Ihr bevorzugtes Tool entsprechend Ihren Anforderungen: Die AWS-Managementkonsole bietet eine visuelle Benutzeroberfläche, die sich ideal zum Kennenlernen der Feature von EKS Auto Mode und zum Erstellen einzelner Cluster eignet. Die AWS-CLI eignet sich am besten für Skripting- und Automatisierungsaufgaben, insbesondere bei der Integration der Cluster-Erstellung in vorhandene Workflows oder CI/CD-Pipelines. Die eksctl-CLI bietet eine Kubernetes-native Erfahrung und wird Benutzern empfohlen, die mit Kubernetes-Tools vertraut sind und vereinfachte Befehlszeilenvorgänge mit sinnvollen Standardeinstellungen wünschen.

Stellen Sie vor Beginn sicher, dass Sie über die erforderlichen Voraussetzungen verfügen, einschließlich der entsprechenden IAM-Berechtigungen zum Erstellen von EKS-Clustern. Informationen zur Installation von CLI-Tools wie `kubectl`, `aws` und `eksctl` finden Sie unter [Einrichtung zur Verwendung von Amazon EKS](setting-up.md).

Sie können die AWS-CLI, AWS-Managementkonsole, oder die eksctl CLI verwenden, um einen Cluster mit Amazon EKS Auto Mode zu erstellen.

**Topics**
+ [Erstellung eines EKS-Auto-Mode-Clusters mit der eksctl-Befehlszeilenschnittstelle](automode-get-started-eksctl.md)
+ [Erstellen Sie einen EKS-Auto-Mode-Cluster mit der AWS CLI](automode-get-started-cli.md)
+ [Erstellung eines EKS-Auto-Mode-Clusters mit AWS-Managementkonsole](automode-get-started-console.md)

# Erstellung eines EKS-Auto-Mode-Clusters mit der eksctl-Befehlszeilenschnittstelle
<a name="automode-get-started-eksctl"></a>

In diesem Abschnitt wird erläutert, wie Sie einen EKS-Auto-Mode-Cluster mithilfe der Befehlszeilenschnittstelle (CLI) eksctl erstellen. Sie können einen EKS-Auto-Mode-Cluster entweder durch Ausführen eines einzelnen CLI-Befehls oder durch Anwenden einer YAML-Konfigurationsdatei erstellen. Beide Methoden bieten die gleiche Funktionalität, wobei der YAML-Ansatz eine detailliertere Kontrolle über die Cluster-Einstellungen ermöglicht.

Die eksctl CLI vereinfacht den Prozess der Erstellung und Verwaltung von EKS-Auto-Mode-Clustern, indem sie die Erstellung und Konfiguration der zugrunde liegenden AWS-Ressourcen übernimmt. Stellen Sie vor dem Fortfahren sicher, dass Sie die erforderlichen AWS-Anmeldeinformationen und Berechtigungen auf Ihrem lokalen Rechner konfiguriert haben. Dieser Leitfaden setzt voraus, dass Sie mit den grundlegenden Konzepten von Amazon EKS vertraut sind und die erforderlichen CLI-Tools bereits installiert haben.

**Anmerkung**  
Sie müssen die Version `0.195.0` oder höher von eksctl installieren. Weitere Informationen finden Sie unter [eksctl-Versionen](https://github.com/eksctl-io/eksctl/releases) auf GitHub.

## Erstellung eines EKS-Auto-Mode-Clusters mit einem CLI-Befehl
<a name="_create_an_eks_auto_mode_cluster_with_a_cli_command"></a>

Sie müssen die `aws`- und `eksctl`-Tools installiert haben. Sie müssen bei der AWS-CLI mit ausreichenden Berechtigungen angemeldet sein, um AWS-Ressourcen zu verwalten, darunter: EC2-Instances, EC2-Netzwerke, EKS-Cluster und IAM-Rollen. Weitere Informationen finden Sie unter [Einrichtung zur Verwendung von Amazon EKS](setting-up.md).

Führen Sie den folgenden Befehl aus, um einen neuen EKS-Auto-Mode-Cluster zu erstellen

```
eksctl create cluster --name=<cluster-name> --enable-auto-mode
```

## Erstellung eines EKS-Auto-Mode-Clusters mit einer YAML-Datei
<a name="_create_an_eks_auto_mode_cluster_with_a_yaml_file"></a>

Sie müssen die `aws`- und `eksctl`-Tools installiert haben. Sie müssen bei der AWS-CLI mit ausreichenden Berechtigungen angemeldet sein, um AWS-Ressourcen zu verwalten, darunter: EC2-Instances, EC2-Netzwerke, EKS-Cluster und IAM-Rollen. Weitere Informationen finden Sie unter [Einrichtung zur Verwendung von Amazon EKS](setting-up.md).

Überprüfen Sie die Konfigurationsoptionen für EKS Auto Mode in der folgenden Beispiel-ClusterConfig-Ressource. Die vollständige ClusterConfig-Spezifikation finden Sie in der [eksctl-Dokumentation](https://eksctl.io/usage/creating-and-managing-clusters/).

 AWS empfiehlt, EKS Auto Mode zu aktivieren. Sollten Sie zum ersten Mal einen EKS-Auto-Mode-Cluster erstellen, lassen Sie `nodeRoleARN` unverändert, um eine Knoten-IAM-Rolle für EKS Auto Mode zu erstellen. Wenn Sie bereits über eine Knoten-IAM-Rolle in Ihrem AWS-Konto verfügen, empfiehlt AWS, diese wiederzuverwenden.

 AWS empfiehlt, keinen Wert für `nodePools` anzugeben. EKS Auto Mode erstellt Standard-Knoten-Pools. Sie können die Kubernetes-API verwenden, um zusätzliche Knoten-Pools zu erstellen.

```
# cluster.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: <cluster-name>
  region: <aws-region>

iam:
  # ARN of the Cluster IAM Role
  # optional, eksctl creates a new role if not supplied
  # suggested to use one Cluster IAM Role per account
  serviceRoleARN: <arn-cluster-iam-role>

autoModeConfig:
  # defaults to false
  enabled: boolean
  # optional, defaults to [general-purpose, system].
  # suggested to leave unspecified
  # To disable creation of nodePools, set it to the empty array ([]).
  nodePools: []string
  # optional, eksctl creates a new role if this is not supplied
  # and nodePools are present.
  nodeRoleARN: string
```

Speichern Sie die `ClusterConfig`-Datei als `cluster.yaml` und verwenden Sie den folgenden Befehl, um den Cluster zu erstellen:

```
eksctl create cluster -f cluster.yaml
```

# Erstellen Sie einen EKS-Auto-Mode-Cluster mit der AWS CLI
<a name="automode-get-started-cli"></a>

EKS-Auto-Mode-Cluster automatisieren routinemäßige Cluster-Verwaltungsaufgaben für Rechenleistung, Speicher und Netzwerke. EKS-Auto-Mode-Cluster erkennen beispielsweise automatisch, wenn zusätzliche Knoten erforderlich sind, und stellen neue EC2-Instances bereit, um den Workload-Anforderungen gerecht zu werden.

Dieses Thema führt Sie durch die Erstellung eines neuen EKS-Auto-Mode-Clusters mithilfe der AWS CLI und optional durch die Bereitstellung eines Beispiel-Workloads.

## Voraussetzungen
<a name="_prerequisites"></a>
+ Die neueste Version der AWS Befehlszeilenschnittstelle (AWS CLI) ist auf Ihrem Gerät installiert und konfiguriert. Um Ihre aktuelle Version zu überprüfen, verwenden Sie `aws --version`. Informationen zur Installation der neuesten Version finden Sie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und [Schnellkonfiguration](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-configure-quickstart-config) mit aws configure im Benutzerhandbuch für die AWS Befehlszeilenschnittstelle.
  + Melden Sie sich mit ausreichenden IAM-Berechtigungen bei der CLI an, um AWS Ressourcen wie IAM-Richtlinien, IAM-Rollen und EKS-Cluster zu erstellen.
+ Das kubectl-Befehlszeilentool, das auf Ihrem Gerät installiert ist. AWS schlägt vor, dass Sie dieselbe kubectl-Version wie die Kubernetes-Version Ihres EKS-Clusters verwenden. Informationen zum Installieren von kubectl finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).

## Angabe von VPC-Subnetzen
<a name="_specify_vpc_subnets"></a>

Amazon EKS Auto Mode stellt Knoten in VPC-Subnetzen bereit. Beim Erstellen eines EKS-Clusters müssen Sie die VPC-Subnetze angeben, in denen die Knoten bereitgestellt werden sollen. Sie können die Standard-VPC-Subnetze in Ihrem AWS Konto verwenden oder eine dedizierte VPC für kritische Workloads erstellen.
+  AWS schlägt vor, eine dedizierte VPC für Ihren Cluster zu erstellen. Weitere Informationen erhalten Sie unter [Erstellung einer Amazon VPC für Ihren Amazon-EKS-Cluster](creating-a-vpc.md).
+ Die EKS-Konsole unterstützt Sie bei der Erstellung einer neuen VPC. Weitere Informationen erhalten Sie unter [Erstellung eines EKS-Auto-Mode-Clusters mit AWS-Managementkonsole](automode-get-started-console.md).
+ Alternativ können Sie die Standard-VPC Ihres AWS Kontos verwenden. Verwenden Sie die folgenden Anweisungen, um das IDs Subnetz zu finden.

### So finden Sie das Subnetz IDs Ihrer Standard-VPC
<a name="auto-find-subnet"></a>

 **Verwenden der AWS CLI:** 

1. Führen Sie den folgenden Befehl aus, um die Standard-VPC und ihre Subnetze aufzulisten:

   ```
   aws ec2 describe-subnets --filters "Name=vpc-id,Values=$(aws ec2 describe-vpcs --query 'Vpcs[?IsDefault==`true`].VpcId' --output text)" --query 'Subnets[*].{ID:SubnetId,AZ:AvailabilityZone}' --output table
   ```

1. Speichern Sie die Ausgabe und notieren Sie sich das **Subnetz IDs**.

   Beispielausgabe:

   ```
   ----------------------------------------
   |             DescribeSubnets          |
   ----------------------------------------
   |   SubnetId        |   AvailabilityZone  |
   |--------------------|---------------------|
   |   subnet-012345678 |   us-west-2a        |
   |   subnet-234567890 |   us-west-2b        |
   |   subnet-345678901 |   us-west-2c        |
   ----------------------------------------
   ```

## IAM-Rollen für Cluster in EKS Auto Mode
<a name="auto-mode-create-roles"></a>

### Cluster-IAM-Rolle
<a name="auto-roles-cluster-iam-role"></a>

Der automatische EKS-Modus erfordert eine Cluster-IAM-Rolle, um Aktionen in Ihrem AWS Konto auszuführen, z. B. die Bereitstellung neuer EC2-Instances. Sie müssen diese Rolle erstellen, um EKS die erforderlichen Berechtigungen zu erteilen. AWS empfiehlt, die folgenden AWS verwalteten Richtlinien an die Cluster-IAM-Rolle anzuhängen:
+  [EKSComputeAmazon-Richtlinie](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSComputePolicy) 
+  [AmazonEKSBlockStoragePolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSBlockStoragePolicy) 
+  [AmazonEKSLoadBalancingPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSLoadBalancingPolicy) 
+  [EKSNetworkingAmazon-Richtlinie](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSNetworkingPolicy) 
+  [EKSClusterAmazon-Richtlinie](security-iam-awsmanpol.md#security-iam-awsmanpol-amazoneksclusterpolicy) 

### Knoten-IAM-Rolle
<a name="auto-roles-node-iam-role"></a>

Wenn Sie einen EKS-Auto-Mode-Cluster erstellen, geben Sie eine IAM-Rolle für den Knoten an. Wenn EKS Auto Mode Knoten zur Verarbeitung ausstehender Workloads erstellt, wird jedem neuen EC2-Instance-Knoten die Knoten-IAM-Rolle zugewiesen. Diese Rolle ermöglicht es dem Knoten, mit EKS zu kommunizieren, wird jedoch in der Regel nicht von den auf dem Knoten ausgeführten Workloads aufgerufen.

Wenn Sie Workloads, die auf einem Knoten ausgeführt werden, Berechtigungen gewähren möchten, verwenden Sie EKS Pod Identity. Weitere Informationen finden Sie unter [Erfahren Sie, wie EKS Pod Identity Pods Zugriff auf AWS-Services gewährt](pod-identities.md).

Sie müssen diese Rolle erstellen und die folgende AWS verwaltete Richtlinie anhängen:
+  [AmazonEKSWorkerNodeMinimalPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSWorkerNodeMinimalPolicy) 
+  [AmazonEC2ContainerRegistryPullOnly](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonEC2ContainerRegistryPullOnly) 

EKS Auto Mode erfordert außerdem eine serviceverknüpfte Rolle, die automatisch von AWS erstellt und konfiguriert wird. Weitere Informationen finden Sie unter [AWSServiceRoleForAmazonEKS](using-service-linked-roles-eks.md).

## Erstellung einer IAM-Rolle für einen Cluster in EKS Auto Mode
<a name="_create_an_eks_auto_mode_cluster_iam_role"></a>

### Schritt 1: Vertrauensrichtlinie erstellen
<a name="_step_1_create_the_trust_policy"></a>

Erstellen Sie eine Vertrauensrichtlinie, mit welcher der Amazon-EKS-Service die Rolle übernehmen kann. Speichern Sie die Richtlinie als `trust-policy.json`:

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow", 
      "Principal": {
        "Service": "eks.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ]
    }
  ]
}
```

### Schritt 2: Erstellen der IAM-Rolle
<a name="_step_2_create_the_iam_role"></a>

Verwenden Sie die Vertrauensrichtlinie, um die Cluster-IAM-Rolle zu erstellen:

```
aws iam create-role \
    --role-name AmazonEKSAutoClusterRole \
    --assume-role-policy-document file://trust-policy.json
```

### Schritt 3: Rollen-ARN notieren
<a name="_step_3_note_the_role_arn"></a>

Rufen Sie die ARN der neuen Rolle ab und speichern Sie sie für die Verwendung in den folgenden Schritten:

```
aws iam get-role --role-name AmazonEKSAutoClusterRole --query "Role.Arn" --output text
```

### Schritt 4: Erforderliche Richtlinien hinzufügen
<a name="_step_4_attach_required_policies"></a>

Fügen Sie der Cluster-IAM-Rolle die folgenden AWS verwalteten Richtlinien hinzu, um die erforderlichen Berechtigungen zu gewähren:

 **EKSClusterAmazon-Richtlinie**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSClusterPolicy
```

 **EKSComputeAmazon-Richtlinie**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSComputePolicy
```

 **Amazon EKSBlock StoragePolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSBlockStoragePolicy
```

 **Amazon EKSLoad BalancingPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSLoadBalancingPolicy
```

 **EKSNetworkingAmazon-Richtlinie**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSNetworkingPolicy
```

## Erstellung einer Knoten-IAM-Rolle in EKS Auto Mode
<a name="_create_an_eks_auto_mode_node_iam_role"></a>

### Schritt 1: Vertrauensrichtlinie erstellen
<a name="_step_1_create_the_trust_policy_2"></a>

Erstellen Sie eine Vertrauensrichtlinie, mit welcher der Amazon-EKS-Service die Rolle übernehmen kann. Speichern Sie die Richtlinie als `node-trust-policy.json`:

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "ec2.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

#### Schritt 2: Knoten-IAM-Rolle erstellen
<a name="_step_2_create_the_node_iam_role"></a>

Verwenden Sie die **node-trust-policyJSON-Datei** aus dem vorherigen Schritt, um zu definieren, welche Entitäten die Rolle übernehmen können. Führen Sie den folgenden Befehl aus, um die Knoten-IAM-Rolle zu erstellen:

```
aws iam create-role \
    --role-name AmazonEKSAutoNodeRole \
    --assume-role-policy-document file://node-trust-policy.json
```

#### Schritt 3: Rollen-ARN notieren
<a name="_step_3_note_the_role_arn_2"></a>

Rufen Sie nach dem Erstellen der Rolle die ARN der Knoten-IAM-Rolle ab und speichern Sie sie. Sie benötigen diese ARN in den nachfolgenden Schritten. Um die ARN abzurufen, verwenden Sie den folgenden Befehl.

```
aws iam get-role --role-name AmazonEKSAutoNodeRole --query "Role.Arn" --output text
```

#### Schritt 4: Erforderliche Richtlinien hinzufügen
<a name="_step_4_attach_required_policies_2"></a>

Fügen Sie der Node-IAM-Rolle die folgenden AWS verwalteten Richtlinien hinzu, um die erforderlichen Berechtigungen bereitzustellen:

 **Amazon EKSWorker NodeMinimalPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoNodeRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEKSWorkerNodeMinimalPolicy
```

 **Amazon EC2 ContainerRegistryPullOnly**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoNodeRole \
    --policy-arn arn:aws: iam::aws:policy/AmazonEC2ContainerRegistryPullOnly
```

## Erstellung eines Clusters in EKS Auto Mode
<a name="_create_an_eks_auto_mode_cluster"></a>

### -Übersicht
<a name="_overview"></a>

Um einen EKS-Auto-Mode-Cluster mit der AWS CLI zu erstellen, benötigen Sie die folgenden Parameter:
+  `cluster-name`: Der Name des Clusters.
+  `k8s-version`: Die Kubernetes-Version (z. B. 1.31).
+  `subnet-ids`: In den vorherigen Schritten IDs identifiziertes Subnetz.
+  `cluster-role-arn`: ARN der Cluster-IAM-Rolle.
+  `node-role-arn`: ARN der Knoten-IAM-Rolle.

#### Standard-Cluster-Konfigurationen
<a name="_default_cluster_configurations"></a>

Überprüfen Sie diese Standardwerte und Feature, bevor Sie den Cluster erstellen:
+  `nodePools`: EKS Auto Mode beinhaltet universelle und systemseitige Standard-Knoten-Pools. Weitere Informationen zu [Knoten-Pools](create-node-pool.md)

 **Hinweis:** Knoten-Pools in EKS Auto Mode unterscheiden sich von Amazon EKS verwalteten Knotengruppen, können jedoch im selben Cluster koexistieren.
+  `computeConfig.enabled`: Automatisiert routinemäßige Rechenaufgaben, wie das Erstellen und Löschen von EC2-Instances.
+  `kubernetesNetworkConfig.elasticLoadBalancing.enabled`: Automatisiert Load-Balancing-Aufgaben, einschließlich des Erstellens und Löschens von Elastic Load Balancers.
+  `storageConfig.blockStorage.enabled`: Automatisiert Speicheraufgaben, wie das Erstellen und Löschen von Amazon-EBS-Volumes.
+  `accessConfig.authenticationMode`: Erfordert EKS-Zugriffseinträge. Weitere Informationen zu [EKS-Authentifizierungsmodi](grant-k8s-access.md).

#### Ausführen des Befehls
<a name="_run_the_command"></a>

Verwenden Sie den folgenden Befehl, um den Cluster zu erstellen:

```
aws eks create-cluster \
  --region ${AWS_REGION} \
  --cli-input-json \
  "{
      \"name\": \"${CLUSTER_NAME}\",
      \"version\": \"${K8S_VERSION}\",
      \"roleArn\": \"${CLUSTER_ROLE_ARN}\",
      \"resourcesVpcConfig\": {
        \"subnetIds\": ${SUBNETS_JSON},
        \"endpointPublicAccess\": true,
        \"endpointPrivateAccess\": true
      },
      \"computeConfig\": {
        \"enabled\": true,
        \"nodeRoleArn\":\"${NODE_ROLE_ARN}\",
        \"nodePools\": [\"general-purpose\", \"system\"]
      },
      \"kubernetesNetworkConfig\": {
        \"elasticLoadBalancing\": {
          \"enabled\": true
        }
      },
      \"storageConfig\": {
        \"blockStorage\": {
          \"enabled\": true
        }
      },
      \"accessConfig\": {
        \"authenticationMode\": \"API\"
      }
    }"
```

### Cluster-Status überprüfen
<a name="_check_cluster_status"></a>

#### Schritt 1: Cluster-Erstellung überprüfen
<a name="_step_1_verify_cluster_creation"></a>

Führen Sie den folgenden Befehl aus, um den Status Ihres Clusters zu überprüfen. Die Cluster-Erstellung dauert in der Regel 15 Minuten.

```
aws eks describe-cluster --name "${CLUSTER_NAME}" --output json
```

#### Schritt 2: kubeconfig aktualisieren
<a name="_step_2_update_kubeconfig"></a>

Sobald der Cluster bereit ist, aktualisieren Sie Ihre lokale kubeconfig-Datei, um die Kommunikation zwischen `kubectl` und dem Cluster zu ermöglichen. Diese Konfiguration verwendet die AWS CLI für die Authentifizierung.

```
aws eks update-kubeconfig --name "${CLUSTER_NAME}"
```

#### Schritt 3: Knoten-Pools überprüfen
<a name="_step_3_verify_node_pools"></a>

Listen Sie die Knoten-Pools in Ihrem Cluster mit dem folgenden Befehl auf:

```
kubectl get nodepools
```

## Nächste Schritte
<a name="_next_steps"></a>
+ Erfahren Sie, wie Sie einen [Beispiel-Workload in Ihrem neuen Cluster in EKS Auto Mode bereitstellen](automode-workload.md).

# Erstellung eines EKS-Auto-Mode-Clusters mit AWS-Managementkonsole
<a name="automode-get-started-console"></a>

Die Erstellung eines EKS-Auto-Mode-Clusters in AWS-Managementkonsole erfordert weniger Konfigurationsaufwand als andere Optionen. EKS lässt sich in AWS IAM- und VPC-Netzwerke integrieren, um Sie bei der Erstellung der einem EKS-Cluster zugeordneten Ressourcen zu unterstützen.

Sie haben zwei Möglichkeiten, einen Cluster in der Konsole zu erstellen:
+ Schnellkonfiguration (mit EKS Auto Mode)
+ Benutzerdefinierte Konfiguration

In diesem Abschnitt erfahren Sie, wie Sie einen EKS-Auto-Mode-Cluster mithilfe der Schnellkonfigurations-Option erstellen.

## Erstellung von EKS Auto Mode mithilfe der Schnellkonfigurations-Option
<a name="_create_an_eks_auto_mode_using_the_quick_configuration_option"></a>

Sie müssen mit ausreichenden Berechtigungen bei AWS-Managementkonsole angemeldet sein, um AWS-Ressourcen verwalten zu können, darunter: EC2-Instances, EC2-Netzwerke, EKS-Cluster und IAM-Rollen.

1. Navigieren Sie zur EKS-Konsole

1. Klicken Sie auf **Cluster erstellen** 

1. Bestätigen Sie, dass die Option **Schnellkonfiguration** ausgewählt ist

1. Ermitteln Sie die folgenden Werte oder verwenden Sie die Standardwerte für einen Test-Cluster.
   + Cluster-**Name** 
   + Kubernetes-Version

1. Wählen Sie die Cluster-IAM-Rolle aus. Wenn Sie zum ersten Mal einen EKS-Cluster im Automatikmodus erstellen, verwenden Sie die Option **Empfohlene Rolle erstellen**.
   + Optional können Sie eine einzelne Cluster-IAM-Rolle in Ihrem AWS-Konto für alle EKS-Auto-Mode-Cluster wiederverwenden.
   + Die Cluster-IAM-Rolle enthält die erforderlichen Berechtigungen für EKS Auto Mode, um Ressourcen wie EC2-Instances, EBS-Volumes und EC2 Load-Balancer zu verwalten.
   + Die Option **Empfohlene Rolle erstellen** füllt alle Felder mit empfohlenen Werten vorab aus. Wählen Sie **Weiter** und dann **Erstellen** aus. Die Rolle wird den vorgeschlagenen `AmazonEKSAutoClusterRole`-Namen verwenden.
   + Wenn Sie kürzlich eine neue Rolle erstellt haben, verwenden Sie das Symbol **Aktualisieren**, um die Dropdown-Liste für die Rollenauswahl neu zu laden.

1. Wählen Sie die Knoten-IAM-Rolle aus. Wenn Sie zum ersten Mal einen EKS-Cluster im Automatikmodus erstellen, verwenden Sie die Option **Empfohlene Rolle erstellen**.
   + Optional können Sie eine einzelne Knoten-IAM-Rolle in Ihrem AWS-Konto für alle EKS-Auto-Mode-Cluster wiederverwenden.
   + Die Knoten-IAM-Rolle enthält die erforderlichen Berechtigungen für Knoten im Automatikmodus, um eine Verbindung zum Cluster herzustellen. Die Knoten-IAM-Rolle muss Berechtigungen zum Abrufen von ECR-Images für Ihre Container enthalten.
   + Die Option **Empfohlene Rolle erstellen** füllt alle Felder mit empfohlenen Werten vorab aus. Wählen Sie **Weiter** und dann **Erstellen** aus. Die Rolle wird den vorgeschlagenen `AmazonEKSAutoNodeRole`-Namen verwenden.
   + Wenn Sie kürzlich eine neue Rolle erstellt haben, verwenden Sie das Symbol **Aktualisieren**, um die Dropdown-Liste für die Rollenauswahl neu zu laden.

1. Wählen Sie die VPC für Ihren EKS-Auto-Mode-Cluster aus. Wählen Sie **VPC erstellen**, um eine neue VPC für EKS zu erstellen, oder wählen Sie eine VPC aus, die Sie zuvor für EKS erstellt haben.
   + Wenn Sie die VPC-Konsole zum Erstellen einer neuen VPC verwenden, empfiehlt AWS, mindestens ein NAT-Gateway pro Availability Zone zu erstellen. Andernfalls können Sie alle anderen Standardeinstellungen verwenden.
   + Weitere Informationen und Details zu den Anforderungen für IPv6-Cluster finden Sie unter [Erstellung einer Amazon VPC für Ihren Amazon-EKS-Cluster](creating-a-vpc.md).

1. (Optional) EKS Auto Mode füllt automatisch die privaten Subnetze für die von Ihnen ausgewählte VPC. Sie können unerwünschte Subnetze entfernen.
   + EKS wählt automatisch private Subnetze aus der VPC gemäß bewährten Methoden aus. Optional können Sie zusätzliche Subnetze aus der VPC auswählen, beispielsweise öffentliche Subnetze.

1. (optional) Wählen Sie **Standardeinstellungen für die Schnellkonfiguration anzeigen** aus, um alle Konfigurationseinstellungen für den neuen Cluster zu überprüfen. Die Tabelle zeigt, dass einige Werte nach der Erstellung des Clusters nicht mehr bearbeitet werden können.

1. Wählen Sie **Cluster erstellen** aus. Beachten Sie, dass die Erstellung des Clusters bis zu fünfzehn Minuten dauern kann.

## Nächste Schritte
<a name="_next_steps"></a>
+ Erfahren Sie, wie Sie eine [Beispiel-Workload in Ihrem Cluster in EKS Auto Mode bereitstellen](sample-storage-workload.md). 