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 AWS Batch Amazon EKS Private Clusters
<a name="getting-started-eks-privateclusters"></a>

AWS Batch ist ein verwalteter Service, der Batch-Workloads in Ihren Amazon Elastic Kubernetes Service (Amazon EKS) -Clustern orchestriert. Dazu gehören Warteschlangen, Abhängigkeitsverfolgung, verwaltete Auftragswiederholungen und Prioritäten, Pod-Verwaltung und Knotenskalierung. Diese Funktion verbindet Ihren bestehenden privaten Amazon EKS-Cluster mit AWS Batch , um Ihre Jobs skalierbar auszuführen. Sie können [https://eksctl.io/usage/eks-private-cluster/](https://eksctl.io/usage/eks-private-cluster/)(eine Befehlszeilenschnittstelle für Amazon EKS), die AWS Konsole oder die verwenden, [AWS Command Line Interface](https://aws.amazon.com/cli/)um einen privaten Amazon EKS-Cluster mit allen anderen erforderlichen Ressourcen zu erstellen. 

[Amazon EKS-Cluster, die nur privat](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html#private-access) sind, haben standardmäßig keinen inbound/outbound Internetzugang, und Sie können nur von Ihrer VPC oder einem verbundenen Netzwerk aus auf den API-Server zugreifen. Amazon VPC-Endpunkte werden verwendet, um privaten Zugriff auf andere AWS Dienste zu ermöglichen. `eksctl`unterstützt die Erstellung vollständig privater Cluster mit einer bereits vorhandenen Amazon VPC und Subnetzen. `eksctl`erstellt außerdem Amazon VPC-Endpunkte in der bereitgestellten Amazon VPC und ändert Routentabellen für die bereitgestellten Subnetze.

Jedem Subnetz sollte eine explizite Routing-Tabelle zugeordnet sein, da die Haupt-Routing-Tabelle `eksctl` nicht verändert wird. Ihr [Cluster](#getting-started-eks-privateclusters) muss Images aus einer Container-Registry abrufen, die sich in Ihrer Amazon VPC befindet. Sie können auch eine Amazon Elastic Container Registry in Ihrer Amazon VPC erstellen und Container-Images dorthin kopieren, damit Ihre Knoten sie abrufen können. Weitere Informationen finden Sie unter [Kopieren eines Container-Images von einem Repository in ein anderes Repository](https://docs.aws.amazon.com/eks/latest/userguide/copy-image-to-repository.html). Informationen zu den ersten Schritten mit privaten Amazon ECR-Repositorys finden Sie unter Private [Amazon ECR-Repositorys](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html).

Sie können optional eine [Pull-Through-Cache-Regel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache.html) mit Amazon ECR erstellen. Sobald eine Pull-Through-Cache-Regel für eine externe öffentliche Registry erstellt wurde, können Sie mithilfe Ihrer Amazon ECR Private Registry Uniform Resource Identifier (URI) ein Image aus dieser externen öffentlichen Registrierung abrufen. Dann erstellt Amazon ECR ein Repository und speichert das Bild im Cache. Wenn ein zwischengespeichertes Image mithilfe der privaten Amazon ECR-Registrierungs-URI abgerufen wird, überprüft Amazon ECR die Remote-Registrierung, um festzustellen, ob es eine neue Version des Images gibt, und aktualisiert Ihre private Registrierung bis zu einmal alle 24 Stunden.

**Contents**
+ [-Übersicht](#getting-started-eks-context)
+ [Voraussetzungen](#getting-started-eks-privateclusters-prerequisites)
+ [Schritt 1: Erstellen Sie Ihren EKS-Cluster für AWS Batch](#getting-started-eks-privateclusters-step-0)
+ [Schritt 2: Bereiten Sie Ihren EKS-Cluster vor für AWS Batch](#getting-started-eks-privateclusters-step-1)
+ [Schritt 3: Erstellen Sie eine Amazon EKS-Rechenumgebung](#getting-started-eks-privateclusters-2)
+ [Schritt 4: Erstellen Sie eine Job-Warteschlange und hängen Sie die Rechenumgebung an](#getting-started-eks-privateclusters-step-3)
+ [Schritt 5: Erstellen Sie einen Amazon ECR mit Pull-Through-Cache](#getting-started-eks-privateclusters-step-ecr)
+ [Schritt 6: Registrieren Sie eine Jobdefinition](#getting-started-eks-privateclusters-step-4)
+ [Schritt 7: Reichen Sie einen Job zur Ausführung ein](#getting-started-eks-privateclusters-step-5)
+ [Schritt 8: Sehen Sie sich die Ausgabe des Jobs an](#getting-started-eks-privateclusters-step-7)
+ [Schritt 9: (Optional) Reichen Sie einen Job mit Überschreibungen ein](#getting-started-eks-privateclusters-step-6)
+ [Schritt 10: Bereinigen Sie Ihre Tutorial-Ressourcen](#getting-started-eks-privateclusters-step-8)
+ [Weitere Ressourcen](#getting-started-eks-additional-resources)
+ [Fehlerbehebung](#getting-started-eks-privateclusters-troubleshooting)

## -Übersicht
<a name="getting-started-eks-context"></a>

Dieses Tutorial zeigt, wie Sie AWS Batch mit einem privaten Amazon EKS mithilfe von AWS CloudShell, `kubectl` und einrichten`eksctl`. 

**Beabsichtigte Zielgruppe**  
Dieses Tutorial richtet sich an Systemadministratoren und Entwickler, die für die Einrichtung, das Testen und die Bereitstellung verantwortlich sind AWS Batch.

**Verwendete Funktionen**  
Dieses Tutorial zeigt Ihnen, wie Sie das verwenden können AWS CLI, um:  
+ Verwenden Sie Amazon Elastic Container Registry (Amazon ECR) zum Speichern von Container-Images 
+ Erstellen und konfigurieren Sie eine Amazon EKS-Rechenumgebung
+ Erstellen Sie eine Job-Warteschlange.
+ Erstellen Sie eine Auftragsdefinition
+ Erstellen Sie einen Job und reichen Sie ihn zur Ausführung ein
+ Reichen Sie einen Job mit Überschreibungen ein

**Erforderliche Zeit**  
Es sollte etwa 40—50 Minuten dauern, bis Sie dieses Tutorial abgeschlossen haben.

**Regionale Einschränkungen**  
Es gibt keine landesspezifischen oder regionalen Einschränkungen im Zusammenhang mit der Verwendung dieser Lösung.

**Kosten für die Ressourcennutzung**  
Für die Erstellung eines AWS Kontos fallen keine Gebühren an. Durch die Implementierung dieser Lösung können Ihnen jedoch einige oder alle Kosten entstehen, die in der folgenden Tabelle aufgeführt sind.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/batch/latest/userguide/getting-started-eks-privateclusters.html)

## Voraussetzungen
<a name="getting-started-eks-privateclusters-prerequisites"></a>

In diesem Tutorial wird eine browserbasierte, vorauthentifizierte Shell verwendet AWS CloudShell , die Sie direkt von der aus starten. AWS-Managementkonsole Dies ermöglicht den Zugriff auf den Cluster, sobald dieser keinen öffentlichen Internetzugang mehr hat. Das AWS CLI`kubectl`, und ist `eksctl` möglicherweise bereits als Teil von installiert AWS CloudShell. Weitere Informationen zu AWS CloudShell finden Sie im [AWS CloudShell*Benutzerhandbuch*](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). Eine Alternative dazu AWS CloudShell besteht darin, eine Verbindung zur VPC Ihres Clusters oder zu einem [verbundenen Netzwerk](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/introduction.html) herzustellen.

Um kubectl-Befehle auszuführen, benötigen Sie privaten Zugriff auf Ihren Amazon EKS-Cluster. Das bedeutet, dass der gesamte Datenverkehr zu Ihrem Cluster-API-Server aus der VPC Ihres Clusters oder einem verbundenen Netzwerk stammen muss.
+ **AWS CLI**— Ein Befehlszeilentool für die Arbeit mit AWS Diensten, einschließlich Amazon EKS. Für dieses Handbuch müssen Sie Version 2.8.6 oder höher oder 1.26.0 oder höher verwenden. *Weitere Informationen finden Sie unter [Installation, Aktualisierung und Deinstallation von AWS CLI im Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).AWS Command Line Interface * Nach der Installation empfehlen wir AWS CLI, dass Sie es auch konfigurieren. Weitere Informationen finden Sie unter [Schnellkonfiguration mit `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *AWS Command Line Interface Benutzerhandbuch*.
+ **`kubectl`** – Ein Befehlszeilentool für die Arbeit mit Kubernetes-Clustern. Dieses Handbuch erfordert, dass Sie Version `1.23` oder höher verwenden. Weitere Informationen finden Sie unter [Installieren oder Aktualisieren von `kubectl`](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) im *Amazon-EKS-Benutzerhandbuch*.
+ **`eksctl`**— Ein Befehlszeilentool für die Arbeit mit Amazon EKS-Clustern, das viele einzelne Aufgaben automatisiert. Dieses Handbuch erfordert, dass Sie Version `0.115.0` oder höher verwenden. Weitere Informationen finden Sie unter [Installieren oder Aktualisieren von `eksctl`](https://eksctl.io/installation/) im **Amazon-EKS-Benutzerhandbuch**.
+ **Berechtigungen** — Benutzer, die den [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html)API-Vorgang aufrufen, um eine Rechenumgebung zu erstellen, die Amazon EKS-Ressourcen verwendet, benötigen Berechtigungen für den `eks:DescribeCluster` und `eks:ListClusters` API-Vorgang. Sie können die [AWSBatchFullAccess](batch_managed_policies.md)verwaltete Richtlinie an Ihr Benutzerkonto anhängen, indem Sie den Anweisungen zum [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) im *IAM-Benutzerhandbuch* folgen. 
+ **InstanceRole**— Sie müssen `InstanceRole` für Ihre Amazon EKS-Knoten einen erstellen, der die `AmazonEC2ContainerRegistryPullOnly` Richtlinien `AmazonEKSWorkerNodePolicy` und enthält. Anweisungen zur Erstellung der [IAM-Rolle für Amazon EKS Node `InstanceRole` finden Sie unter Creating the Amazon EKS node](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role). Sie benötigen den ARN von`InstanceRole`.
+ **AWS-Konto ID** — Sie müssen Ihre AWS-Konto ID kennen. Folgen Sie den Anweisungen unter [Ihre AWS-Konto ID anzeigen](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html).
+ **(Optional) CloudWatch** — Um die Details von [(optional) Einen Job mit Überschreibungen einreichen](getting-started-eks.md#getting-started-eks-step-6) zu überprüfen, muss die Protokollierung konfiguriert sein. Weitere Informationen finden Sie unter [Verwenden Sie CloudWatch Logs, um AWS Batch Amazon EKS-Jobs zu überwachen](batch-eks-cloudwatch-logs.md).

## Schritt 1: Erstellen Sie Ihren EKS-Cluster für AWS Batch
<a name="getting-started-eks-privateclusters-step-0"></a>

**Wichtig**  
Um so einfach und schnell wie möglich loszulegen, enthält dieses Tutorial Schritte mit Standardeinstellungen. Wir empfehlen Ihnen, sich vor der Erstellung für den produktiven Einsatz mit allen Einstellungen vertraut zu machen und die Bereitstellung mit den Einstellungen vorzunehmen, die Ihren Anforderungen entsprechen.

Wir empfehlen Ihnen, die folgende Konfigurationsdatei zu verwenden`eksctl`, um Ihren Cluster zu erstellen. Um Ihren Cluster manuell einzurichten, folgen Sie den Anweisungen unter [Bereitstellen von privaten Clustern mit eingeschränktem Internetzugang](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) im *Amazon EKS-Benutzerhandbuch*.

1. Öffnen Sie die [AWS CloudShell Konsole](https://console.aws.amazon.com/cloudshell/home) und stellen Sie die Region auf ein`us-east-1`. Stellen Sie für den Rest des Tutorials sicher, dass Sie verwenden`us-east-1`.

1. Erstellen Sie mithilfe der `eksctl` Beispielkonfigurationsdatei einen privaten EKS-Cluster in der `us-east-1` Region. Speichern Sie die Yaml-Datei in Ihrer AWS CloudShell Umgebung und geben Sie ihr einen Namen. `clusterConfig.yaml` Sie können den Namen ändern*my-test-cluster*, den Sie für Ihren Cluster verwenden möchten. 

   ```
   kind: ClusterConfig 
   apiVersion: eksctl.io/v1alpha5
   metadata:
       name: my-test-cluster 
       region: us-east-1
   availabilityZones: 
       - us-east-1a 
       - us-east-1b 
       - us-east-1c
   managedNodeGroups:
       - name: ng-1
         privateNetworking: true 
   privateCluster: 
       enabled: true 
       skipEndpointCreation: false
   ```

1. Erstellen Sie Ihre Ressourcen mit dem folgenden Befehl:. `eksctl create cluster -f clusterConfig.yaml` Die Clustererstellung kann zwischen 10 und 15 Minuten dauern.

1. Sobald die Erstellung des Clusters abgeschlossen ist, müssen Sie Ihre AWS CloudShell IP-Adresse zur Zulassungsliste hinzufügen. Um Ihre AWS CloudShell IP-Adresse zu finden, führen Sie den folgenden Befehl aus:

   ```
   curl http://checkip.amazonaws.com
   ```

   Sobald Sie die öffentliche IP-Adresse haben, müssen Sie eine Regel für die Zulassungsliste erstellen:

   ```
   aws eks update-cluster-config \
     --name my-test-cluster \
     --region us-east-1 \
     --resources-vpc-config endpointPublicAccess=true,endpointPrivateAccess=true,publicAccessCidrs=["<Public IP>/32"]
   ```

   Wenden Sie dann das Update auf die kubectl-Konfigurationsdatei an:

   ```
   aws eks update-kubeconfig --name my-test-cluster --region us-east-1
   ```

1. Um zu testen, ob Sie Zugriff auf die Knoten haben, führen Sie den folgenden Befehl aus:

   ```
   kubectl get nodes
   ```

   Die Ausgabe des Befehls lautet:

   ```
   NAME                              STATUS   ROLES    AGE     VERSION
   ip-192-168-107-235.ec2.internal   Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-165-40.ec2.internal    Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-98-54.ec2.internal     Ready    none     1h   v1.32.1-eks-5d632ec
   ```

## Schritt 2: Bereiten Sie Ihren EKS-Cluster vor für AWS Batch
<a name="getting-started-eks-privateclusters-step-1"></a>

Alle Schritte sind erforderlich und müssen in ausgeführt werden AWS CloudShell.

1. 

**Erstellen Sie einen dedizierten Namespace für Jobs AWS Batch**

   Wird verwendet`kubectl`, um einen neuen Namespace zu erstellen.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl create -f -
   {
     "apiVersion": "v1",
     "kind": "Namespace",
     "metadata": {
       "name": "${namespace}",
       "labels": {
         "name": "${namespace}"
       }
     }
   }
   EOF
   ```

   Ausgabe:

   ```
   namespace/my-aws-batch-namespace created
   ```

1. 

**Aktivieren Sie den Zugriff über die rollenbasierte Zugriffskontrolle (RBAC)**

   Wird verwendet`kubectl`, um eine Kubernetes Rolle für den Cluster zu erstellen, mit der AWS Batch Knoten und Pods überwacht und die Rolle gebunden werden kann. Sie müssen dies einmal für jeden Amazon EKS-Cluster tun.

   ```
   $ cat - <<EOF | kubectl apply -f -
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: aws-batch-cluster-role
   rules:
     - apiGroups: [""]
       resources: ["namespaces"]
       verbs: ["get"]
     - apiGroups: [""]
       resources: ["nodes"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["events"]
       verbs: ["list"]
     - apiGroups: [""]
       resources: ["configmaps"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["apps"]
       resources: ["daemonsets", "deployments", "statefulsets", "replicasets"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["clusterroles", "clusterrolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: aws-batch-cluster-role-binding
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: aws-batch-cluster-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Ausgabe:

   ```
   clusterrole.rbac.authorization.k8s.io/aws-batch-cluster-role created
   clusterrolebinding.rbac.authorization.k8s.io/aws-batch-cluster-role-binding created
   ```

   Erstellen Sie eine Namespace-spezifische Kubernetes Rolle für die Verwaltung und den Lebenszyklus von Pods und AWS Batch binden Sie sie. Sie müssen dies einmal für jeden eindeutigen Namespace tun.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl apply -f - --namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: aws-batch-compute-environment-role
     namespace: ${namespace}
   rules:
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["create", "get", "list", "watch", "delete", "patch"]
     - apiGroups: [""]
       resources: ["serviceaccounts"]
       verbs: ["get", "list"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: aws-batch-compute-environment-role-binding
     namespace: ${namespace}
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: aws-batch-compute-environment-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Ausgabe:

   ```
   role.rbac.authorization.k8s.io/aws-batch-compute-environment-role created
   rolebinding.rbac.authorization.k8s.io/aws-batch-compute-environment-role-binding created
   ```

   Aktualisieren Sie Kubernetes `aws-auth` die Konfigurationsübersicht, um die vorherigen RBAC-Berechtigungen der dienstverknüpften Rolle zuzuordnen. AWS Batch 

   ```
   $ eksctl create iamidentitymapping \
       --cluster my-test-cluster \
       --arn "arn:aws:iam::<your-account-ID>:role/AWSServiceRoleForBatch" \
       --username aws-batch
   ```

   Ausgabe:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-ID>:role/AWSServiceRoleForBatch" to auth ConfigMap
   ```
**Anmerkung**  
Der Pfad `aws-service-role/batch.amazonaws.com/` wurde aus dem ARN der serviceverknüpften Rolle entfernt. Dies liegt an einem Problem mit der `aws-auth` Konfigurationsübersicht. Weitere Informationen finden Sie unter [Rollen mit Pfaden funktionieren nicht, wenn der Pfad in ihrem ARN in der enthalten ist aws-authconfigmap](https://github.com/kubernetes-sigs/aws-iam-authenticator/issues/268).

## Schritt 3: Erstellen Sie eine Amazon EKS-Rechenumgebung
<a name="getting-started-eks-privateclusters-2"></a>

AWS Batch Rechenumgebungen definieren Rechenressourcenparameter, um Ihre Batch-Workload-Anforderungen zu erfüllen. AWS Batch Hilft Ihnen in einer verwalteten Datenverarbeitungsumgebung, die Kapazität und die Instance-Typen der Rechenressourcen (KubernetesKnoten) in Ihrem Amazon EKS-Cluster zu verwalten. Dies basiert auf der Rechenressourcenspezifikation, die Sie bei der Erstellung der Rechenumgebung definieren. Sie können EC2-On-Demand-Instances oder EC2-Spot-Instances verwenden.

Jetzt, da die **AWSServiceRoleForBatch**serviceverknüpfte Rolle Zugriff auf Ihren Amazon EKS-Cluster hat, können Sie AWS Batch Ressourcen erstellen. Erstellen Sie zunächst eine Rechenumgebung, die auf Ihren Amazon EKS-Cluster verweist.
+ Zum `subnets` Ausführen`eksctl get cluster my-test-cluster`, um die vom Cluster verwendeten Subnetze abzurufen. 
+ Als `securityGroupIds` Parameter können Sie dieselbe Sicherheitsgruppe wie der Amazon EKS-Cluster verwenden. Dieser Befehl ruft die Sicherheitsgruppen-ID für den Cluster ab.

  ```
  $ aws eks describe-cluster \
      --name my-test-cluster \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ Verwenden Sie den ARN, den `instanceRole` Sie in den Voraussetzungen erstellt haben.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:us-east-1:<your-account-ID>:cluster/my-test-cluster",
    "kubernetesNamespace": "my-aws-batch-namespace"
  },
  "computeResources": {
    "type": "EC2",
    "allocationStrategy": "BEST_FIT_PROGRESSIVE",
    "minvCpus": 0,
    "maxvCpus": 128,
    "instanceTypes": [
        "m5"
    ],
    "subnets": [
        "<eks-cluster-subnets-with-access-to-the-image-for-image-pull>"
    ],
    "securityGroupIds": [
        "<eks-cluster-sg>"
    ],
    "instanceRole": "<eks-instance-profile>"
  }
}
EOF
```

```
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-compute-environment.json
```

**Hinweise**
+ Die Wartung einer Amazon EKS-Rechenumgebung ist eine gemeinsame Verantwortung. Weitere Informationen finden Sie unter [Sicherheit in Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security.html).

## Schritt 4: Erstellen Sie eine Job-Warteschlange und hängen Sie die Rechenumgebung an
<a name="getting-started-eks-privateclusters-step-3"></a>

**Wichtig**  
Bevor Sie fortfahren, müssen Sie sich vergewissern, dass die Rechenumgebung fehlerfrei ist. Dazu kann die [DescribeComputeEnvironments](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeComputeEnvironments.html)API-Operation verwendet werden.  

```
$ aws batch describe-compute-environments --compute-environments My-Eks-CE1
```
Vergewissern Sie sich, dass der `status` Parameter dies nicht ist`INVALID`. Wenn ja, schauen Sie sich den `statusReason` Parameter für die Ursache an. Weitere Informationen finden Sie unter [Problembehebung AWS Batch](troubleshooting.md).

Jobs, die an diese neue Auftragswarteschlange gesendet wurden, werden als Pods auf AWS Batch verwalteten Knoten ausgeführt, die dem Amazon EKS-Cluster beigetreten sind, der mit Ihrer Rechenumgebung verknüpft ist.

```
$ cat <<EOF > ./batch-eks-job-queue.json
 {
    "jobQueueName": "My-Eks-JQ1",
    "priority": 10,
    "computeEnvironmentOrder": [
      {
        "order": 1,
        "computeEnvironment": "My-Eks-CE1"
      }
    ]
  }
EOF
```

```
$ aws batch create-job-queue --cli-input-json file://./batch-eks-job-queue.json
```

## Schritt 5: Erstellen Sie einen Amazon ECR mit Pull-Through-Cache
<a name="getting-started-eks-privateclusters-step-ecr"></a>

Da der Cluster keinen öffentlichen Internetzugang hat, müssen Sie einen Amazon ECR für Container-Images erstellen. Mit den folgenden Anweisungen wird ein Amazon ECR mit einer Pull-Through-Cache-Regel zum Speichern des Images erstellt.

1. Mit dem folgenden Befehl wird die Pull-Through-Cache-Regel erstellt. Sie können es durch ein anderes *tutorial-prefix* Präfix ersetzen.

   ```
   aws ecr create-pull-through-cache-rule \
       --ecr-repository-prefix "my-prefix" \
       --upstream-registry-url "public.ecr.aws" \
       --region us-east-1
   ```

1. Authentifizieren Sie sich mit dem öffentlichen ECR.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com
   ```

   Jetzt können Sie ein Bild abrufen.

   ```
   docker pull <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

1. Sie können das Repository und das Image überprüfen, indem Sie die folgenden Befehle ausführen:

   ```
   aws ecr describe-repositories
   ```

   ```
   aws ecr describe-images --repository-name my-prefix/amazonlinux/amazonlinux
   ```

1. Die Bildzeichenfolge, die zum Abrufen des Containers verwendet werden soll, hat das folgende Format:

   ```
   <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

## Schritt 6: Registrieren Sie eine Jobdefinition
<a name="getting-started-eks-privateclusters-step-4"></a>

Die folgende Jobdefinition weist den Pod an, 60 Sekunden lang in den Ruhemodus zu wechseln.

Anstatt einen Link zu einem Bild in einem öffentlichen ECR-Repository bereitzustellen, geben Sie im Bildfeld der Jobdefinition den Link zu dem Bild ein, das in unserem privaten ECR-Repository gespeichert ist. Sehen Sie sich die folgende Beispiel-Auftragsdefinition an:

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "<your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2",
          "command": [
            "sleep",
            "60"
          ],
          "resources": {
            "limits": {
              "cpu": "1",
              "memory": "1024Mi"
            }
          }
        }
      ],
      "metadata": {
        "labels": {
          "environment": "test"
        }
      }
    }
  }
}
EOF
```

```
$ aws batch register-job-definition --cli-input-json file://./batch-eks-job-definition.json
```



**Hinweise**
+ Es gibt Überlegungen zu den `memory` Parametern `cpu` und. Weitere Informationen finden Sie unter [Überlegungen zu Arbeitsspeicher und vCPUs für AWS Batch Amazon EKS](memory-cpu-batch-eks.md).

## Schritt 7: Reichen Sie einen Job zur Ausführung ein
<a name="getting-started-eks-privateclusters-step-5"></a>

Führen Sie den folgenden AWS CLI Befehl aus AWS CloudShell , um einen neuen Job einzureichen, und geben Sie die eindeutige JobID zurück.

```
$ aws batch submit-job --job-queue My-Eks-JQ1 \
    --job-definition MyJobOnEks_Sleep - -job-name My-Eks-Job1
```

**Hinweise**
+ Weitere Informationen zum Ausführen von Aufträgen auf Amazon EKS-Ressourcen finden Sie unter[Stellenangebote bei Amazon EKS](eks-jobs.md).

## Schritt 8: Sehen Sie sich die Ausgabe des Jobs an
<a name="getting-started-eks-privateclusters-step-7"></a>

Um den Status eines Job zu überprüfen:

```
$ aws batch describe-jobs --job <JobID-from-submit-response>
```

Das `startedAt` und `stoppedAt` sollte eine Minute voneinander entfernt sein. 

## Schritt 9: (Optional) Reichen Sie einen Job mit Überschreibungen ein
<a name="getting-started-eks-privateclusters-step-6"></a>

Dieser Job überschreibt den an den Container übergebenen Befehl.

```
$ cat <<EOF > ./submit-job-override.json
{
  "jobName": "EksWithOverrides",
  "jobQueue": "My-Eks-JQ1",
  "jobDefinition": "MyJobOnEks_Sleep",
  "eksPropertiesOverride": {
    "podProperties": {
      "containers": [
        {
          "command": [
            "/bin/sh"
          ],
          "args": [
            "-c",
            "echo hello world"
          ]
        }
      ]
    }
  }
}
EOF
```

```
$ aws batch submit-job - -cli-input-json file://./submit-job-override.json
```

**Hinweise**
+ Aktivieren Sie die Protokollierung der Amazon EKS-Kontrollebene, um einen besseren Einblick in die Einzelheiten der Vorgänge zu erhalten. Weitere Informationen finden Sie unter [Protokollierung der Amazon EKS-Kontrollebene](https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html) im **Amazon EKS-Benutzerhandbuch**.
+ Daemonsetsund der kubelets Overhead wirkt sich auf die verfügbaren vCPU- und Speicherressourcen aus, insbesondere auf Skalierung und Stellenvermittlung. Weitere Informationen finden Sie unter [Überlegungen zu Arbeitsspeicher und vCPUs für AWS Batch Amazon EKS](memory-cpu-batch-eks.md).

## Schritt 10: Bereinigen Sie Ihre Tutorial-Ressourcen
<a name="getting-started-eks-privateclusters-step-8"></a>

Die Amazon EC2 EC2-Instance wird Ihnen in Rechnung gestellt, solange sie aktiviert ist. Sie können die Instance löschen, damit keine Gebühren mehr anfallen.

Gehen Sie wie folgt vor, um die von Ihnen erstellten Ressourcen zu löschen:

1. Öffnen Sie die AWS Batch Konsole unter [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. Wählen Sie im Navigationsbereich die Option **Job-Warteschlange** aus. 

1. Wählen Sie in der Tabelle **Job-Queue** die Job-Warteschlange aus, die Sie für das Tutorial erstellt haben.

1. Wählen Sie **unter Aktionen** die Option **Deaktivieren** aus. Sobald der **Status** der Job-Warteschlange deaktiviert ist, können Sie **Löschen** wählen.

1. Sobald die Job-Warteschlange gelöscht ist, wählen Sie im Navigationsbereich **Computing-Umgebungen** aus.

1. Wählen Sie die Rechenumgebung aus, die Sie für dieses Tutorial erstellt haben, und wählen Sie dann unter **Aktionen** die **Option Deaktivieren** aus. Es kann 1—2 Minuten dauern, bis die Deaktivierung der Rechenumgebung abgeschlossen ist.

1. **Sobald der **Status** der Rechenumgebung Deaktiviert ist, wählen Sie Löschen aus.** Es kann 1—2 Minuten dauern, bis die Rechenumgebung gelöscht ist.

## Weitere Ressourcen
<a name="getting-started-eks-additional-resources"></a>

Nachdem Sie das Tutorial abgeschlossen haben, möchten Sie sich möglicherweise mit den folgenden Themen befassen:
+ Erfahren Sie mehr über die [Best Practices](best-practices.md).
+ Erkunden Sie die AWS Batch Kernkomponenten. Weitere Informationen finden Sie unter [Bestandteile von AWS Batch](batch_components.md).
+ Erfahren Sie mehr über die verschiedenen verfügbaren [Rechenumgebungen](compute_environments.md) unter AWS Batch.
+ Erfahren Sie mehr über [Job-Warteschlangen](job_queues.md) und ihre verschiedenen Planungsoptionen.
+ Erfahren Sie mehr über [Jobdefinitionen](job_definitions.md) und die verschiedenen Konfigurationsoptionen.
+ Erfahren Sie mehr über die verschiedenen Arten von [Jobs](jobs.md).

## Fehlerbehebung
<a name="getting-started-eks-privateclusters-troubleshooting"></a>

Wenn Knoten, die von gestartet wurden, AWS Batch keinen Zugriff auf das Amazon ECR-Repository (oder ein anderes Repository) haben, in dem Ihr Image gespeichert ist, können Ihre Jobs im Status STARTING verbleiben. Das liegt daran, dass der Pod das Image nicht herunterladen und Ihren AWS Batch Job ausführen kann. Wenn Sie auf den von gestarteten Pod-Namen klicken, sollten AWS Batch Sie die Fehlermeldung sehen und das Problem bestätigen können. Die Fehlermeldung sollte etwa wie folgt aussehen:

```
Failed to pull image "public.ecr.aws/amazonlinux/amazonlinux:2": rpc error: code =
Unknown desc = failed to pull and unpack image
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to resolve reference
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to do request: Head
"https://public.ecr.aws/v2/amazonlinux/amazonlinux/manifests/2": dial tcp: i/o timeout
```

Weitere häufig auftretende Problembehandlungsszenarien finden Sie unter [Problembehandlung AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/batch-eks-troubleshooting.html). Informationen zur Fehlerbehebung basierend auf dem Pod-Status finden Sie unter [https://repost.aws/knowledge-center/eks-pod-status-troubleshooting](https://repost.aws/knowledge-center/eks-pod-status-troubleshooting) .