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
<a name="getting-started-eks"></a>

AWS Batch on Amazon EKS ist ein verwalteter Service für die Planung und Skalierung von Batch-Workloads in bestehende Amazon EKS-Cluster. AWS Batch erstellt, verwaltet oder führt keine Lebenszyklusoperationen Ihrer Amazon EKS-Cluster in Ihrem Namen durch. AWS Batch Die Orchestrierung skaliert Knoten, die von diesen Knoten verwaltet werden, nach oben und unten AWS Batch und führt Pods auf diesen Knoten aus.

AWS Batch berührt keine Knoten, Auto Scaling-Knotengruppen oder Pod-Lebenszyklen, die nicht mit AWS Batch Rechenumgebungen in Ihrem Amazon EKS-Cluster verknüpft sind. Für AWS Batch einen effektiven Betrieb benötigt die [servicebasierte Rolle](using-service-linked-roles.md) Kubernetes rollenbasierte Zugriffskontrollberechtigungen (RBAC) in Ihrem vorhandenen Amazon EKS-Cluster. *Weitere Informationen finden Sie in der Dokumentation unter [Verwenden der RBAC-Autorisierung](https://kubernetes.io/docs/reference/access-authn-authz/rbac/). Kubernetes*

AWS Batch benötigt einen Kubernetes Namespace, in den Pods als AWS Batch Jobs eingebunden werden können. Wir empfehlen einen dedizierten Namespace, um die AWS Batch Pods von Ihren anderen Cluster-Workloads zu isolieren.

Nachdem AWS Batch Sie RBAC-Zugriff erhalten und ein Namespace eingerichtet wurde, können Sie diesen Amazon EKS-Cluster mithilfe der [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html)API-Operation einer AWS Batch Rechenumgebung zuordnen. Dieser neuen Amazon EKS-Rechenumgebung kann eine Auftragswarteschlange zugeordnet werden. AWS Batch Jobs werden auf der Grundlage einer Amazon EKS-Auftragsdefinition mithilfe des [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)API-Vorgangs an die Auftragswarteschlange übermittelt. AWS Batch startet dann AWS Batch verwaltete Knoten und platziert Jobs aus der Job-Warteschlange als Kubernetes Pods in den EKS-Cluster, der mit einer AWS Batch Rechenumgebung verknüpft ist.

In den folgenden Abschnitten wird beschrieben, wie Sie sich AWS Batch auf Amazon EKS einrichten.

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

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

In diesem Tutorial wird gezeigt, wie Sie Amazon EKS mithilfe von AWS CLI, `kubectl` und einrichten AWS Batch `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:  
+ 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 30—40 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.html)

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

Bevor Sie mit diesem Tutorial beginnen, müssen Sie die folgenden Tools und Ressourcen installieren und konfigurieren, die Sie benötigen, um sowohl Amazon EKS-Ressourcen als auch Amazon EKS-Ressourcen zu erstellen AWS Batch und zu verwalten.
+ **AWS CLI** – Ein Befehlszeilen-Tool für die Arbeit mit AWS -Services, 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://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) im **Amazon-EKS-Benutzerhandbuch**.
+ **Erforderliche IAM-Berechtigungen** — Der von Ihnen verwendete IAM-Sicherheitsprinzipal muss über Berechtigungen für die Arbeit mit Amazon EKS-IAM-Rollen und serviceverknüpften Rollen sowie einer VPC und zugehörigen Ressourcen verfügen. CloudFormation Weitere Informationen finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html) und [Verwenden von serviceverknüpften Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) im *IAM-Benutzerhandbuch*. Sie müssen alle Schritte in diesem Handbuch als derselbe Benutzer ausführen.
+ **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` API-Vorgang. 
+ **AWS-Konto Nummer** — 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-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 Amazon EKS-Cluster für AWS Batch
<a name="getting-started-eks-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.

Nachdem Sie die Voraussetzungen installiert haben, müssen Sie Ihren Cluster mithilfe von erstellen`eksctl`. Die Erstellung des Clusters kann zwischen 10 und 15 Minuten dauern. 

```
$  eksctl create cluster --name my-cluster-name --region region-code
```

Im vorherigen Befehl ersetzen Sie:
+ *my-cluster-name*Ersetzen Sie es durch den Namen, den Sie für Ihren Cluster verwenden möchten. 
+ *region-code*Ersetzen Sie beispielsweise durch AWS-Region den, in dem der Cluster erstellt werden soll`us-west-2`.

Der Clustername und die Region werden später in diesem Tutorial benötigt.

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

Alle Schritte sind erforderlich.

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 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
   ```

1. Erstellen Sie eine Namespace-spezifische Kubernetes Rolle für die Verwaltung und den Lebenszyklus von AWS Batch Pods und deren Bindung. 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
   ```

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

   Ersetzen Sie im folgenden Befehl:
   + Ersetze es *<your-account-number>* durch deine AWS-Konto Nummer. 

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

   Ausgabe:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-number>: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-step-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-cluster-name`, 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-cluster-name \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ Der `instanceRole` wird erstellt, wenn Sie den Cluster erstellen. Um die `instanceRole` Liste aller Entitäten zu finden, die die `AmazonEKSWorkerNodePolicy` Richtlinie verwenden: 

  ```
  $  aws iam list-entities-for-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
  ```

  Der Name der Richtlinienrolle enthält den Namen des Clusters, den Sie erstellt haben`eksctl-my-cluster-name-nodegroup-example`. 

  Führen Sie den folgenden Befehl aus, um den `instanceRole` ARN zu finden:

  ```
  $  aws iam list-instance-profiles-for-role --role-name eksctl-my-cluster-name-nodegroup-example        
  ```

  Ausgabe:

  ```
  INSTANCEPROFILES        arn:aws:iam::<your-account-number>:instance-profile/eks-04cb2200-94b9-c297-8dbe-87f12example
  ```

  Weitere Informationen finden Sie unter [Erstellen der Amazon EKS-Node-IAM-Rolle](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role) und [Aktivieren des IAM-Prinzipalzugriffs auf Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) im *Amazon EKS-Benutzerhandbuch*. Wenn Sie Pod-Netzwerke verwenden, finden Sie weitere Informationen unter [Konfiguration des Amazon VPC Kubernetes CNI-Plug-ins für die Verwendung von IAM-Rollen für Dienstkonten](https://docs.aws.amazon.com/eks/latest/userguide/cni-iam-role.html) im **Amazon EKS-Benutzerhandbuch**.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:region-code:your-account-number:cluster/my-cluster-name",
    "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-internet-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 [Geteilte Verantwortung der Kubernetes Knoten](eks-ce-shared-responsibility.md).

## Schritt 4: Erstellen Sie eine Job-Warteschlange und hängen Sie die Rechenumgebung an
<a name="getting-started-eks-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 eine Jobdefinition
<a name="getting-started-eks-step-4"></a>

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

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "public.ecr.aws/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 6: Reichen Sie einen Job ein
<a name="getting-started-eks-step-5"></a>

Führen Sie den folgenden AWS CLI Befehl aus, um einen neuen Job einzureichen.

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

Um den Status eines Job zu überprüfen:

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

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

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

Gehen Sie wie folgt vor, um die Ausgabe des Jobs anzuzeigen:

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 **Jobs** aus. 

1. Wählen Sie im **Drop-down-Menü Job-Warteschlange** die Job-Warteschlange aus, die Sie für das Tutorial erstellt haben.

1. In der Tabelle „**Jobs**“ werden alle Ihre Jobs und ihr aktueller Status aufgeführt. Sobald der **Status** des Job **erfolgreich** ist, wählen Sie den **Namen** des Jobs*My-Eks-JQ1*, um die Details des Jobs anzuzeigen. 

1. Im **Detailbereich** sollten die Zeitpunkte „**Gestartet am**“ **und „Beendet** zu“ jeweils eine Minute voneinander entfernt sein. 

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

Dieser Job überschreibt den an den Container übergebenen Befehl. AWS Batch säubert die Pods nach Abschluss der Jobs aggressiv, um die Last auf zu reduzieren. Kubernetes Um die Details eines Auftrags überprüfen zu können, muss die Protokollierung konfiguriert werden. Weitere Informationen finden Sie unter [Verwenden Sie CloudWatch Logs, um AWS Batch Amazon EKS-Jobs zu überwachen](batch-eks-cloudwatch-logs.md).

```
$ 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).

Gehen Sie wie folgt vor, um die Ausgabe des Jobs anzuzeigen:

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 **Jobs** aus. 

1. Wählen Sie im **Drop-down-Menü Job-Warteschlange** die Job-Warteschlange aus, die Sie für das Tutorial erstellt haben.

1. In der Tabelle „**Jobs**“ werden alle Ihre Jobs und ihr aktueller Status aufgeführt. Sobald der **Status** des Job **erfolgreich** ist, wählen Sie den **Namen** des Jobs, um die Details des Jobs anzuzeigen. 

1. Wählen Sie im **Detailbereich** den **Namen des Protokollstreams** aus. Die CloudWatch Konsole für den Job wird geöffnet und es sollte ein Ereignis mit der **Nachricht** von `hello world` oder Ihrer benutzerdefinierten Nachricht geben.

## Schritt 9: Bereinigen Sie Ihre Tutorial-Ressourcen
<a name="getting-started-eks-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 **Disable ** (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 klicken Sie dann auf **Deaktivieren**. 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#best-practices.title).
+ 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#compute_environments.title) unter AWS Batch.
+ Erfahren Sie mehr über [Job-Warteschlangen](job_queues.md#job_queues.title) und ihre verschiedenen Planungsoptionen.
+ Erfahren Sie mehr über [Jobdefinitionen](job_definitions.md#job_definitions.title) und die verschiedenen Konfigurationsoptionen.
+ Erfahren Sie mehr über die verschiedenen Arten von [Jobs](jobs.md#jobs.title).