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 Tutorials
<a name="Batch_GetStarted"></a>

Sie können den Assistenten für die AWS Batch erste Ausführung verwenden, um schnell loszulegen. AWS Batch Nachdem Sie die Voraussetzungen erfüllt haben, können Sie den Assistenten für die erste Ausführung verwenden, um eine Rechenumgebung, eine Auftragsdefinition und eine Auftragswarteschlange zu erstellen. 

Sie können auch einen Beispieljob für „Hello World“ einreichen, indem Sie den Assistenten für die AWS Batch erste Ausführung verwenden, um Ihre Konfiguration zu testen. Wenn Sie bereits über ein Docker-Image verfügen, in dem Sie starten möchten AWS Batch, können Sie dieses Image verwenden, um eine Jobdefinition zu erstellen. 

Anschließend können Sie mit dem Assistenten für die AWS Batch erste Ausführung eine Rechenumgebung und eine Job-Warteschlange erstellen und einen *Hello* World-Beispieljob einreichen. 

# Erste Schritte mit der Amazon EC2 EC2-Orchestrierung mithilfe des Wizards
<a name="getting-started-ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) – Bietet sichere und skalierbare Rechenkapazität in der AWS Cloud. Amazon EC2 beseitigt die Notwendigkeit, im Voraus in Hardware investieren zu müssen. Daher können Sie Anwendungen schneller entwickeln und bereitstellen. 

Mit Amazon EC2 können Sie so viele oder so wenige virtuelle Server starten, wie Sie benötigen, die Sicherheit und das Netzwerk konfigurieren und den Speicher verwalten. Amazon EC2 ermöglicht Ihnen, hoch- und runterzuskalieren, um Anforderungsänderungen oder Nutzungsspitzen zu bewältigen, was Ihren Bedarf an Traffic-Prognosen reduziert.

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

Dieses Tutorial zeigt, wie Sie Amazon EC2 AWS Batch mit dem Wizard einrichten und ausführen`Hello World`. 

**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**  
In diesem Tutorial erfahren Sie, wie Sie den AWS Batch Konsolenassistenten verwenden, um:  
+ Erstellen und konfigurieren Sie eine Amazon EC2 EC2-Rechenumgebung
+ Erstellen Sie eine Job-Warteschlange.
+ Erstellen Sie eine Auftragsdefinition
+ Erstellen Sie einen Job und reichen Sie ihn zur Ausführung ein
+ Sehen Sie sich die Ausgabe des Jobs an in CloudWatch

**Erforderliche Zeit**  
Die Fertigstellung dieses Tutorials sollte etwa 10—15 Minuten dauern.

**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-ec2.html)

## Voraussetzungen
<a name="getting-started-ec2-prerequisite"></a>

Bevor Sie beginnen:
+ Erstellen Sie eine AWS-Konto , falls Sie noch keine haben.
+ Erstellen Sie die [`ecsInstanceRole`Instanzrolle](batch-check-ecsinstancerole.md).

## Schritt 1: Erstellen Sie eine Rechenumgebung
<a name="create-ce-1"></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.

Gehen Sie wie folgt vor, um eine Rechenumgebung für eine Amazon EC2 EC2-Orchestrierung zu erstellen:

1. Öffnen Sie den Assistenten für die [erste AWS Batch Ausführung der Konsole](https://console.aws.amazon.com/batch/home#wizard).

1. Wählen **Sie für Job und Orchestrierungstyp konfigurieren** die Option **Amazon Elastic Compute Cloud (Amazon EC2**).

1. Wählen Sie **Weiter** aus.

1. Geben **Sie im Abschnitt Konfiguration der Rechenumgebung** für **Name** einen eindeutigen Namen für Ihre Rechenumgebung an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten. 

1. Wählen Sie **unter Instanzrolle** eine bestehende Instanzrolle aus, der die erforderlichen IAM-Berechtigungen zugewiesen sind. Diese Instance-Rolle ermöglicht es den Amazon ECS-Container-Instances in Ihrer Rechenumgebung, die erforderlichen AWS API-Operationen aufzurufen. Weitere Informationen finden Sie unter [Amazon ECS-Instance-Rolle](instance_IAM_role.md). 

   Der Standardname der **Instance-Rolle** lautet`ecsInstanceRole`. 

1. Für die **Instanzkonfiguration** können Sie die Standardeinstellungen beibehalten.

1. Verwenden Sie für die **Netzwerkkonfiguration** Ihre Standard-VPC für. AWS-Region

1. Wählen Sie **Weiter** aus.

## Schritt 2: Erstellen Sie eine Job-Warteschlange
<a name="create-job-queue-1"></a>

In einer Job-Warteschlange werden Ihre eingereichten Jobs gespeichert, bis der AWS Batch Scheduler den Job auf einer Ressource in Ihrer Computerumgebung ausführt. Weitere Informationen finden Sie unter [Auftragswarteschlangen](job_queues.md).

Gehen Sie wie folgt vor, um eine Job-Warteschlange für eine Amazon EC2 EC2-Orchestrierung zu erstellen:

1. Geben Sie **Job Job-Queue-Konfiguration** für **Name** einen eindeutigen Namen für Ihre Job-Warteschlange an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten. 

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 3: Erstellen Sie eine Jobdefinition
<a name="create-job-definition-1"></a>

AWS Batch Jobdefinitionen geben an, wie Jobs ausgeführt werden sollen. Obwohl jeder Job auf eine Auftragsdefinition verweisen muss, können viele der in der Auftragsdefinition angegebenen Parameter zur Laufzeit außer Kraft gesetzt werden. 

So erstellen Sie die Jobdefinition:

1. Für **Erstellen Sie eine Jobdefinition**

   1. Geben Sie für **Name** einen eindeutigen Namen für Ihre Job-Warteschlange ein. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

   1. Unter **Befehl — *optional*** können Sie `hello world` zu einer benutzerdefinierten Nachricht wechseln oder sie unverändert lassen.

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 4: Erstellen Sie einen Job
<a name="create-job-1"></a>

Gehen Sie wie folgt vor, um einen Job zu erstellen:

1. Geben Sie im Abschnitt **Auftragskonfiguration** für **Name** einen eindeutigen Namen für den Job an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 5: Überprüfen und Erstellen
<a name="review-create-1"></a>

**Überprüfen Sie auf der Seite Überprüfen und erstellen** die Konfigurationsschritte. Wenn Sie Änderungen vornehmen müssen, wählen Sie **Edit** (Bearbeiten). Wenn Sie fertig sind, wählen Sie **Ressourcen erstellen** aus.

1. Wählen Sie **unter Überprüfen und Erstellen** die Option **Ressourcen erstellen** aus.

1. Es öffnet sich ein Fenster, in dem Sie AWS Batch beginnen, Ihre Ressourcen zuzuweisen. Sobald Sie fertig sind, wählen Sie **Gehe zum Dashboard**. Auf dem Dashboard sollten Sie alle Ihnen zugewiesenen Ressourcen sehen und sehen, dass sich der Job im `Runnable` Status befindet. Ihr Job ist für die Ausführung geplant und sollte in 2—3 Minuten abgeschlossen sein.

## Schritt 6: Sehen Sie sich die Ausgabe des Jobs an
<a name="view-job-1"></a>

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

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 7: Bereinigen Sie Ihre Tutorial-Ressourcen
<a name="delete-1"></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. 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="procedure_additional_resources"></a>

Nachdem Sie das Tutorial abgeschlossen haben, möchten Sie sich möglicherweise mit den folgenden Themen befassen:
+ 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).

# Erste Schritte mit AWS Batch und Fargate-Orchestrierung mithilfe des Wizards
<a name="getting-started-fargate"></a>

AWS Fargate startet und skaliert die Berechnung so, dass sie den Ressourcenanforderungen, die Sie für den Container angeben, genau entspricht. Mit Fargate müssen Sie nicht zu viele Server bereitstellen oder für zusätzliche Server bezahlen. Weitere Informationen finden Sie unter [Fargate](https://docs.aws.amazon.com//batch/latest/userguide/fargate.html#when-to-use-fargate).

## -Übersicht
<a name="getting-started-fargate-contextual"></a>

Dieses Tutorial zeigt, wie Sie AWS Fargate AWS Batch mit dem Wizard einrichten und ausführen`Hello World`. 

**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**  
In diesem Tutorial erfahren Sie, wie Sie den AWS Batch Konsolenassistenten verwenden, um:  
+ Erstellen und konfigurieren Sie eine AWS Fargate-Rechenumgebung
+ Erstellen Sie eine Job-Warteschlange.
+ Erstellen Sie eine Auftragsdefinition
+ Erstellen Sie einen Job und reichen Sie ihn zur Ausführung ein
+ Sehen Sie sich die Ausgabe des Jobs an in CloudWatch

**Erforderliche Zeit**  
Die Fertigstellung dieses Tutorials sollte etwa 10—15 Minuten dauern.

**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-fargate.html)

## Voraussetzungen
<a name="getting-started-fargate-prerequisite"></a>

Bevor Sie beginnen: 
+ Erstellen Sie eine AWS-Konto , falls Sie noch keine haben.
+ Erstellen Sie die Rolle zur Aufgabenausführung. Wenn Sie die [Aufgabenausführungsrolle](create-execution-role.md) noch nicht erstellt haben, können Sie sie im Rahmen dieses Tutorials erstellen.

## Schritt 1: Erstellen Sie eine Rechenumgebung
<a name="create-ce-2"></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.

Gehen Sie wie folgt vor, um eine Rechenumgebung für eine Fargate-Orchestrierung zu erstellen:

1. Öffnen Sie den Assistenten für die [erste AWS Batch Ausführung der Konsole](https://console.aws.amazon.com/batch/home#wizard).

1. Wählen **Sie für Job und Orchestrierungstyp konfigurieren** die Option **Fargate** aus.

1. Wählen Sie **Weiter** aus.

1. Geben **Sie im Abschnitt Konfiguration der Rechenumgebung** für **Name** einen eindeutigen Namen für Ihre Rechenumgebung an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 2: Erstellen Sie eine Job-Warteschlange
<a name="create-job-queue-2"></a>

In einer Job-Warteschlange werden Ihre eingereichten Jobs gespeichert, bis der AWS Batch Scheduler den Job auf einer Ressource in Ihrer Computerumgebung ausführt. So erstellen Sie eine Job-Warteschlange:

Gehen Sie wie folgt vor, um eine Job-Warteschlange für eine Fargate-Orchestrierung zu erstellen:

1. Geben Sie im Abschnitt **Konfiguration der Job-Warteschlange** für **Name** einen eindeutigen Namen für Ihre Job-Warteschlange ein. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

1. Geben Sie als **Priorität** den Wert 900 für die Auftragswarteschlange ein. 

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 3: Erstellen Sie eine Jobdefinition
<a name="create-job-definition-2"></a>

So erstellen Sie die Jobdefinition:

1. Gehen Sie im Abschnitt **Allgemeine Konfiguration** wie folgt vor:

   1. Geben Sie im Abschnitt **Allgemeine Konfiguration** für **Name** einen eindeutigen Namen für Ihre Jobdefinition an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

1. Im Abschnitt zur **Konfiguration der Fargate-Plattform**:

   1. Aktivieren Sie die **Option Öffentliche IP** zuweisen, um eine öffentliche IP-Adresse zuzuweisen. Sie benötigen eine öffentliche IP, um das Container-Image herunterzuladen, sofern Sie kein privates Image-Repository eingerichtet haben.

   1. Wählen Sie für die **Ausführungsrolle** eine Aufgabenausführungsrolle aus, mit der Agenten von Amazon Elastic Container Service (Amazon ECS) in Ihrem Namen AWS Anrufe tätigen können. Wählen Sie entweder **ecsTaskExecutionRolle** oder **BatchEcsTaskExecutionRole**. 

      Um die **Ausführungsrolle** zu **erstellen, wählen Sie Ausführungsrolle** erstellen. Wählen **Sie im Modal „IAM-Rolle erstellen**“ die Option **IAM-Rolle erstellen** aus. 

      1. In der IAM-Konsole ist die Berechtigungseinstellung für die Erstellung der Ausführungsrolle bereits konfiguriert. 

      1. Stellen Sie sicher, dass der **AWS Dienst** **als vertrauenswürdiger Entitätstyp** ausgewählt ist.

      1. Vergewissern Sie sich, dass für **Service oder Benutzerfall** **Elastic Container Service** ausgewählt ist.

      1. Wählen Sie **Weiter** aus.

      1. Vergewissern Sie sich, dass **Amazon** für **Berechtigungsrichtlinien** ausgewählt ECSTask ExecutionRolePolicy ist.

      1. Wählen Sie **Weiter** aus.

      1. Vergewissern **Sie sich bei Name, review und create**, dass der Rollenname lautet **BatchEcsTaskExecutionRole**. 

      1. Wählen Sie **Rolle erstellen** aus.

      1. Wählen Sie in der AWS Batch Konsole die Schaltfläche „Aktualisieren“ neben „**Ausführungsrolle**“. Wählen Sie die **BatchEcsTaskExecutionRole**Ausführungsrolle aus.

1. Gehen Sie im Abschnitt **Container-Konfiguration** wie folgt vor:

   1. Unter **Command** können Sie `hello world` zu einer benutzerdefinierten Nachricht wechseln oder sie unverändert lassen.

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 4: Erstellen Sie einen Job
<a name="create-job-2"></a>

Gehen Sie wie folgt vor, um einen Fargate-Job zu erstellen:

1. Geben Sie im Abschnitt **Auftragskonfiguration** für **Name** einen eindeutigen Namen für den Job an. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten.

1. Für alle anderen Konfigurationsoptionen können Sie den Standardwert beibehalten.

1. Wählen Sie **Weiter** aus.

## Schritt 5: Überprüfen und Erstellen
<a name="review-create-2"></a>

**Überprüfen Sie auf der Seite Überprüfen und erstellen** die Konfigurationsschritte. Wenn Sie Änderungen vornehmen müssen, wählen Sie **Edit** (Bearbeiten). Wenn Sie fertig sind, wählen Sie **Ressourcen erstellen** aus.

## Schritt 6: Sehen Sie sich die Ausgabe des Jobs an
<a name="view-job-fargate"></a>

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

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 7: Bereinigen Sie Ihre Tutorial-Ressourcen
<a name="delete-fargate"></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. 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="fargate-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).

# Erste Schritte mit AWS Batch und Fargate mit dem AWS CLI
<a name="getting-started-with-fargate-using-the-aws-cli"></a>

Dieses Tutorial zeigt, wie Sie AWS Batch mit AWS Fargate Orchestration einen einfachen „Hello World“ -Job einrichten und mit der AWS Command Line Interface () ausführen.AWS CLI Sie erfahren, wie Sie Rechenumgebungen, Jobwarteschlangen und Jobdefinitionen erstellen und Jobs an senden. AWS Batch

**Topics**
+ [Voraussetzungen](#prerequisites)
+ [Erstellen Sie eine IAM-Ausführungsrolle](#tutorial-fargate-using-the-aws-cli-create-an-iam-execution-role)
+ [Erstellen Sie eine Rechenumgebung](#create-a-compute-environment)
+ [Erstellen Sie eine Job-Warteschlange](#cli-create-a-job-queue)
+ [Erstellen Sie eine Auftragsdefinition](#cli-create-a-job-definition)
+ [Einen Job einreichen und überwachen](#cli-submit-and-monitor-a-job)
+ [Job-Ausgabe anzeigen](#cli-view-job-output)
+ [Bereinigen von Ressourcen](#cli-clean-up-resources)
+ [In die Produktion übergehen](#cli-going-to-production)
+ [Nächste Schritte](#cli-next-steps)

## Voraussetzungen
<a name="prerequisites"></a>

Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen.

1. Das AWS CLI. Wenn Sie die CLI installieren müssen, folgen Sie der [AWS CLI -Installationsanleitung](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Sie können auch [verwenden AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), was die beinhaltet AWS CLI.

1. Hat Ihre AWS CLI mit den entsprechenden Anmeldeinformationen konfiguriert. Führen Sie `aws configure` aus, falls Sie Ihre Anmeldeinformationen noch nicht eingerichtet haben.

1. Grundlegende Vertrautheit mit Befehlszeilenschnittstellen und Konzepten zur Containerisierung.

1. [Wie AWS Batch funktioniert mit IAM](security_iam_service-with-iam.md)um AWS Batch Ressourcen, IAM-Rollen und VPC-Ressourcen in Ihrem zu erstellen und zu verwalten. AWS-Konto

1. Eine Subnetz-ID und eine Sicherheitsgruppen-ID von einer VPC in Ihrem. AWS-Konto Wenn Sie keine VPC haben, können Sie [eine erstellen](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc.html). *Weitere Informationen zur Verwendung von AWS CLI zum Abrufen dieser Ressourcen IDs finden Sie unter [describe-subnets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-subnets.html) und [describe-security-groups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-groups.html)in der Befehlsreferenz.AWS CLI *

**Erforderliche Zeit**: Ungefähr 15 bis 20 Minuten, um dieses Tutorial abzuschließen.

**Kosten**: In diesem Tutorial werden Fargate-Rechenressourcen verwendet. Die geschätzten Kosten für die Durchführung dieses Tutorials belaufen sich auf weniger als 0,01 USD, vorausgesetzt, Sie befolgen die Bereinigungsanweisungen, um Ressourcen unmittelbar nach Abschluss zu löschen. Die Fargate-Preise basieren auf den verbrauchten vCPU- und Speicherressourcen und werden pro Sekunde berechnet, mindestens jedoch 1 Minute. [Aktuelle Preisinformationen finden Sie unter Preise.AWS Fargate](https://aws.amazon.com/fargate/pricing/)

## Erstellen Sie eine IAM-Ausführungsrolle
<a name="tutorial-fargate-using-the-aws-cli-create-an-iam-execution-role"></a>

AWS Batch erfordert eine Ausführungsrolle, die es Agenten von Amazon Elastic Container Service (Amazon ECS) ermöglicht, AWS API-Aufrufe in Ihrem Namen durchzuführen. Diese Rolle ist für Fargate-Aufgaben erforderlich, um Container-Images abzurufen und Logs an Amazon CloudWatch zu schreiben.

**Erstellen Sie ein Dokument mit Vertrauensrichtlinien**

Erstellen Sie zunächst eine Vertrauensrichtlinie, die es dem Amazon ECS-Aufgabenservice ermöglicht, die Rolle zu übernehmen.

```
cat > batch-execution-role-trust-policy.json << EOF
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF
```

**Erstellen Sie die Ausführungsrolle**

Mit dem folgenden Befehl wird eine IAM-Rolle erstellt, die `BatchEcsTaskExecutionRoleTutorial` anhand der soeben erstellten Vertrauensrichtlinie benannt wird.

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

**Hängen Sie die erforderliche Richtlinie an**

Fügen Sie die AWS verwaltete Richtlinie hinzu, die die erforderlichen Berechtigungen für die Ausführung von Amazon ECS-Aufgaben bereitstellt.

```
aws iam attach-role-policy \
    --role-name BatchEcsTaskExecutionRoleTutorial \
    --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```

Die Rolle kann jetzt AWS Batch für die Ausführung von Fargate-Aufgaben verwendet werden.

## Erstellen Sie eine Rechenumgebung
<a name="create-a-compute-environment"></a>

Eine Rechenumgebung definiert die Rechenressourcen, auf denen Ihre Batch-Jobs ausgeführt werden. In diesem Tutorial erstellen Sie eine verwaltete Fargate-Rechenumgebung, die Ressourcen automatisch auf der Grundlage der Jobanforderungen bereitstellt und skaliert.

**Erstellen Sie die Rechenumgebung**

Der folgende Befehl erstellt eine Fargate-Rechenumgebung. Ersetzen Sie das Beispielsubnetz und die Sicherheitsgruppe IDs durch Ihre eigenen gemäß. [Voraussetzungen](#prerequisites)

```
aws batch create-compute-environment \
    --compute-environment-name my-fargate-compute-env \
    --type MANAGED \
    --state ENABLED \
    --compute-resources type=FARGATE,maxvCpus=128,subnets=subnet-a123456b,securityGroupIds=sg-a12b3456
```

Im Folgenden wird gezeigt, wie die Ausgabe aussieht, wenn der Befehl erfolgreich ausgeführt wird.

```
{
    "computeEnvironmentName": "my-fargate-compute-env",
    "computeEnvironmentArn": "arn:aws:batch:us-west-2:123456789012:compute-environment/my-fargate-compute-env"
}
```

**Warten Sie, bis die Rechenumgebung bereit ist**

Überprüfen Sie den Status Ihrer Computerumgebung, um sicherzustellen, dass sie bereit ist, bevor Sie fortfahren.

```
aws batch describe-compute-environments \
    --compute-environments my-fargate-compute-env \
    --query 'computeEnvironments[0].status'
```

```
"VALID"
```

Wenn der Status angezeigt wird`VALID`, ist Ihre Rechenumgebung bereit, Jobs anzunehmen.

## Erstellen Sie eine Job-Warteschlange
<a name="cli-create-a-job-queue"></a>

In einer Job-Warteschlange werden eingereichte Jobs gespeichert, bis der AWS Batch Scheduler sie auf Ressourcen in Ihrer Rechenumgebung ausführt. Jobs werden in der Warteschlange in der Reihenfolge ihrer Priorität verarbeitet.

**Erstellen Sie die Job-Warteschlange**

Der folgende Befehl erstellt eine Auftragswarteschlange mit der Priorität 900, die Ihre Fargate-Rechenumgebung verwendet.

```
aws batch create-job-queue \
    --job-queue-name my-fargate-job-queue \
    --state ENABLED \
    --priority 900 \
    --compute-environment-order order=1,computeEnvironment=my-fargate-compute-env
```

Im Folgenden wird gezeigt, wie die Ausgabe aussieht, wenn der Befehl erfolgreich ausgeführt wird.

```
{
    "jobQueueName": "my-fargate-job-queue",
    "jobQueueArn": "arn:aws:batch:us-west-2:123456789012:job-queue/my-fargate-job-queue"
}
```

**Stellen Sie sicher, dass die Auftragswarteschlange bereit ist**

Vergewissern Sie sich, dass sich Ihre Auftragswarteschlange im `ENABLED` Status befindet und bereit ist, Jobs anzunehmen.

```
aws batch describe-job-queues \
    --job-queues my-fargate-job-queue \
    --query 'jobQueues[0].state' "ENABLED"
```

## Erstellen Sie eine Auftragsdefinition
<a name="cli-create-a-job-definition"></a>

Eine Auftragsdefinition gibt an, wie Jobs ausgeführt werden sollen, einschließlich des zu verwendenden Docker-Images, der Ressourcenanforderungen und anderer Parameter. Für Fargate verwenden Sie Ressourcenanforderungen anstelle herkömmlicher vCPU- und Speicherparameter.

**Erstellen Sie die Jobdefinition**

Der folgende Befehl erstellt eine Jobdefinition, die einen einfachen „Hello World“ -Befehl unter Verwendung des Busybox-Container-Images ausführt. `123456789012`Ersetzen Sie es durch Ihre tatsächliche AWS-Konto ID und ersetzen Sie das Beispiel AWS-Region durch Ihre eigene.

```
aws batch register-job-definition \
    --job-definition-name my-fargate-job-def \
    --type container \
    --platform-capabilities FARGATE \
    --container-properties '{
        "image": "busybox",
        "resourceRequirements": [
            {"type": "VCPU", "value": "0.25"},
            {"type": "MEMORY", "value": "512"}
        ],
        "command": ["echo", "hello world"],
        "networkConfiguration": {
            "assignPublicIp": "ENABLED"
        },
        "executionRoleArn": "arn:aws:iam::123456789012:role/BatchEcsTaskExecutionRoleTutorial"
    },
{
    "jobDefinitionName": "my-fargate-job-def",
    "jobDefinitionArn": "arn:aws:batch:us-west-2:123456789012:job-definition/my-fargate-job-def:1",
    "revision": 1
}'
```

Die Auftragsdefinition spezifiziert 0,25 vCPU und 512 MB Arbeitsspeicher. Dies sind die Mindestressourcen für eine Fargate-Aufgabe. Die `assignPublicIp` Einstellung ist aktiviert, sodass der Container das Busybox-Image von Docker Hub abrufen kann.

## Einen Job einreichen und überwachen
<a name="cli-submit-and-monitor-a-job"></a>

Da Sie nun über alle erforderlichen Komponenten verfügen, können Sie einen Job an Ihre Warteschlange senden und dessen Fortschritt überwachen.

**Reichen Sie einen Job ein**

Mit dem folgenden Befehl wird mithilfe der von Ihnen erstellten Auftragsdefinition ein Job an Ihre Warteschlange gesendet.

```
aws batch submit-job \
    --job-name my-hello-world-job \
    --job-queue my-fargate-job-queue \
    --job-definition my-fargate-job-def
```

Im Folgenden wird gezeigt, wie die Ausgabe aussieht, wenn der Befehl erfolgreich ausgeführt wird.

```
{
    "jobArn": "arn:aws:batch:us-west-2:123456789012:job/my-hello-world-job",
    "jobName": "my-hello-world-job",
    "jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a"
}
```

Notieren Sie sich die in der Antwort `jobId` zurückgegebenen Informationen, da Sie sie verwenden werden, um den Fortschritt des Jobs zu überwachen.

**Überwachen Sie den Auftragsstatus**

Verwenden Sie die Job-ID, um den Status Ihres Jobs zu überprüfen. Der Job durchläuft mehrere Status:`SUBMITTED`,`PENDING`,`RUNNABLE`,`STARTING`,`RUNNING`, und schließlich `SUCCEEDED` oder`FAILED`.

```
aws batch describe-jobs --jobs 1509xmpl-4224-4da6-9ba9-1d1acc96431a
```

Im Folgenden wird gezeigt, wie die Ausgabe aussieht, wenn der Befehl erfolgreich ausgeführt wird.

```
{
    "jobs": [
        {
            "jobArn": "arn:aws:batch:us-west-2:123456789012:job/my-hello-world-job",
            "jobName": "my-hello-world-job",
            "jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a",
            "jobQueue": "arn:aws:batch:us-west-2:123456789012:job-queue/my-fargate-job-queue",
            "status": "SUCCEEDED",
            "createdAt": 1705161908000,
            "jobDefinition": "arn:aws:batch:us-west-2:123456789012:job-definition/my-fargate-job-def:1"
        }
    ]
}
```

Wenn der Status angezeigt wird`SUCCEEDED`, wurde Ihr Job erfolgreich abgeschlossen.

## Job-Ausgabe anzeigen
<a name="cli-view-job-output"></a>

Nachdem Ihr Job abgeschlossen ist, können Sie seine Ausgabe in Amazon CloudWatch Logs anzeigen.

**Rufen Sie den Namen des Log-Streams ab**

Rufen Sie zunächst den Namen des Log-Streams aus den Jobdetails ab. Ersetzen Sie die Beispiel-Job-ID durch Ihre eigene.

```
aws batch describe-jobs --jobs 1509xmpl-4224-4da6-9ba9-1d1acc96431a \
    --query 'jobs[0].attempts[0].containers[0].logStreamName' \
    --output text
```

```
my-fargate-job-def/default/1509xmpl-4224-4da6-9ba9-1d1acc96431a
```

**Sehen Sie sich die Jobprotokolle an**

Verwenden Sie den Namen des Log-Streams, um die Ausgabe des Jobs aus CloudWatch Logs abzurufen.

```
aws logs get-log-events \
    --log-group-name /aws/batch/job \
    --log-stream-name my-fargate-job-def/default/1509xmpl-4224-4da6-9ba9-1d1acc96431a \
    --query 'events[*].message' \
    --output text
```

In der Ausgabe wird „Hello World“ angezeigt, was bestätigt, dass Ihr Job erfolgreich ausgeführt wurde.

## Bereinigen von Ressourcen
<a name="cli-clean-up-resources"></a>

Um laufende Gebühren zu vermeiden, bereinigen Sie die Ressourcen, die Sie in diesem Tutorial erstellt haben. Aufgrund von Abhängigkeiten müssen Sie Ressourcen in der richtigen Reihenfolge löschen.

**Deaktivieren und löschen Sie die Job-Warteschlange**

Deaktivieren Sie zuerst die Jobwarteschlange und löschen Sie sie dann.

```
aws batch update-job-queue \
    --job-queue my-fargate-job-queue \
    --state DISABLED
```

```
aws batch delete-job-queue \
    --job-queue my-fargate-job-queue
```

**Deaktivieren und löschen Sie die Rechenumgebung**

Nachdem die Jobwarteschlange gelöscht wurde, deaktivieren und löschen Sie die Rechenumgebung.

```
aws batch update-compute-environment \
    --compute-environment my-fargate-compute-env \
    --state DISABLED
```

```
aws batch delete-compute-environment \
    --compute-environment my-fargate-compute-env
```

**Bereinigen Sie die IAM-Rolle**

Entfernen Sie den Richtlinienanhang und löschen Sie die IAM-Rolle.

```
aws iam detach-role-policy \
    --role-name BatchEcsTaskExecutionRoleTutorial \
    --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```

```
aws iam delete-role \
    --role-name BatchEcsTaskExecutionRoleTutorial
```

**Temporäre Dateien entfernen**

Löschen Sie die von Ihnen erstellte Vertrauensrichtlinien-Datei.

```
rm batch-execution-role-trust-policy.json
```

Alle Ressourcen wurden erfolgreich bereinigt.

## In die Produktion übergehen
<a name="cli-going-to-production"></a>

Dieses Tutorial soll Ihnen helfen zu verstehen, wie Fargate AWS Batch funktioniert. Beachten Sie bei Produktionsbereitstellungen die folgenden zusätzlichen Anforderungen:

**Überlegungen zur Sicherheit:**
+ Erstellen Sie dedizierte Sicherheitsgruppen mit minimalem erforderlichen Zugriff, anstatt Standardsicherheitsgruppen zu verwenden
+ Verwenden Sie private Subnetze mit NAT Gateway anstelle einer öffentlichen IP-Zuweisung für Container
+ Speichern Sie Container-Images in Amazon ECR, anstatt öffentliche Repositorys zu verwenden
+ Implementieren Sie VPC-Endpunkte für die AWS Dienstkommunikation, um Internetverkehr zu vermeiden

**Überlegungen zur Architektur:**
+ Stellen Sie die Lösung für hohe Verfügbarkeit in mehreren Availability Zones bereit
+ Implementieren Sie Strategien zur Auftragswiederholung und Warteschlangen für die Fehlerbehandlung
+ Verwenden Sie mehrere Jobwarteschlangen mit unterschiedlichen Prioritäten für das Workload-Management
+ Konfigurieren Sie Richtlinien für die auto Skalierung auf der Grundlage der Warteschlangentiefe und der Ressourcennutzung
+ Implementieren Sie Überwachungs- und Warnmeldungen bei Auftragsausfällen und Ressourcennutzung

**Betriebliche Überlegungen:**
+ Richten Sie CloudWatch Dashboards und Alarme für die Überwachung ein
+ Implementieren Sie angemessene Protokollierungs- und Prüfpfade
+ Verwenden Sie CloudFormation oder die AWS CDK für die Infrastruktur als Code
+ Richten Sie Sicherungs- und Notfallwiederherstellungsverfahren ein

[Umfassende Anleitungen zu produktionsreifen Architekturen finden Sie im [AWS Well-Architected Framework](https://aws.amazon.com/architecture/well-architected/) and Security Best Practices.AWS](https://aws.amazon.com/architecture/security-identity-compliance/)

## Nächste Schritte
<a name="cli-next-steps"></a>

Nachdem Sie dieses Tutorial abgeschlossen haben, können Sie sich mit weiteren Funktionen vertraut machen: AWS Batch 
+ [Auftragswarteschlangen](job_queues.md)— Erfahren Sie mehr über die Planung von Jobwarteschlangen und die Prioritätsverwaltung
+ [Berufsdefinitionen](job_definitions.md)— Erkunden Sie erweiterte Konfigurationen für Auftragsdefinitionen, einschließlich Umgebungsvariablen, Volumes und Wiederholungsstrategien
+ [Rechenumgebungen für AWS Batch](compute_environments.md)— Machen Sie sich mit verschiedenen Arten von Rechenumgebungen und Skalierungsoptionen vertraut
+ [Parallel ausgeführte Aufträge mit mehreren Knoten](multi-node-parallel-jobs.md)— Führen Sie Jobs aus, die sich über mehrere Rechenknoten erstrecken
+ [Ordnen Sie Jobs an](array_jobs.md)— Reichen Sie eine große Anzahl ähnlicher Jobs effizient ein
+ [Bewährte Methoden für AWS Batch](best-practices.md)— Erlernen Sie Optimierungstechniken für Produktionsworkloads

# 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 in der Drop-down-Liste **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 in der Drop-down-Liste **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).
+ 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).

# 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) .

# Erste Schritte mit AWS Batch einer SageMaker KI
<a name="getting-started-sagemaker"></a>

AWS Batch Servicejobs ermöglichen es Ihnen, SageMaker Schulungsaufträge über AWS Batch Jobwarteschlangen mit Funktionen zur Planung, Priorisierung und Warteschleifenbildung einzureichen. In diesem Tutorial wird gezeigt, wie Sie mithilfe AWS Batch von Serviceaufträgen einen einfachen SageMaker Schulungsjob einrichten und ausführen.

**Contents**
+ [-Übersicht](#getting-started-sagemaker-context)
+ [Voraussetzungen](#getting-started-sagemaker-prerequisites)
+ [Schritt 1: Erstellen Sie eine SageMaker AI-Ausführungsrolle](#getting-started-sagemaker-step-1)
+ [Schritt 2: Erstellen Sie Ihre Serviceumgebung](#getting-started-sagemaker-step-2)
+ [Schritt 3: Erstellen Sie Ihre SageMaker Job-Warteschlange](#getting-started-sagemaker-step-3)
+ [Schritt 4: Einen Schulungsjob erstellen und einreichen](#getting-started-sagemaker-step-4)
+ [Schritt 5: Auftragsstatus überwachen](#getting-started-sagemaker-step-5)
+ [Schritt 6: Jobausgabe anzeigen](#getting-started-sagemaker-step-6)
+ [Schritt 7: Bereinigen Sie Ihre Tutorial-Ressourcen](#getting-started-sagemaker-step-7)
+ [Weitere Ressourcen](#getting-started-sagemaker-additional-resources)

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

Dieses Tutorial zeigt, wie Sie AWS Batch Servicejobs für SageMaker Trainingsjobs mithilfe von einrichten AWS CLI.

**Beabsichtigte Zielgruppe**  
Dieses Tutorial richtet sich an Datenwissenschaftler und Entwickler, die für die Einrichtung und Ausführung von Schulungsaufträgen für maschinelles Lernen in großem Umfang verantwortlich sind.

**Verwendete Funktionen**  
Dieses Tutorial zeigt Ihnen, wie Sie das verwenden AWS CLI können:  
+ Erstellen Sie eine Serviceumgebung für SageMaker Schulungsjobs
+ Erstellen Sie eine Warteschlange für SageMaker Schulungsjobs
+ Reichen Sie Serviceaufträge mithilfe der `SubmitServiceJob` API ein
+ Überwachen Sie den Auftragsstatus und sehen Sie sich die Ergebnisse an
+  CloudWatch Zugriffs-Logs für Trainingsjobs

**Benötigte Zeit**  
Es sollte etwa 15 Minuten dauern, bis Sie dieses Tutorial abgeschlossen haben.

**Regionale Einschränkungen**  
Dieses Tutorial kann in jeder AWS Region abgeschlossen werden, in der AWS Batch sowohl SageMaker KI als auch KI verfügbar sind.

**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 Kosten für die folgenden Ressourcen entstehen:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/batch/latest/userguide/getting-started-sagemaker.html)

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

Bevor Sie mit diesem Tutorial beginnen, müssen Sie die folgenden Tools und Ressourcen installieren und konfigurieren, die Sie für die Erstellung und Verwaltung von AWS Batch SageMaker AI-Ressourcen benötigen.
+ **AWS CLI**— Ein Befehlszeilentool für die Arbeit mit AWS Diensten, einschließlich AWS Batch SageMaker KI. Für dieses Handbuch müssen Sie Version 2.8.6 oder höher verwenden. Weitere Informationen finden Sie unter [Installation, Aktualisierung und Deinstallation von AWS CLI im AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) *Benutzerhandbuch*. 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*.

## Schritt 1: Erstellen Sie eine SageMaker AI-Ausführungsrolle
<a name="getting-started-sagemaker-step-1"></a>

SageMaker KI verwendet Ausführungsrollen, um Operationen in Ihrem Namen mithilfe anderer AWS Dienste auszuführen. Sie müssen eine Ausführungsrolle erstellen und der SageMaker KI Berechtigungen zur Nutzung der Dienste und Ressourcen gewähren, die für Schulungsaufgaben benötigt werden. Verwenden Sie die `AmazonSageMakerFullAccess` verwaltete Richtlinie, da sie Berechtigungen für Amazon S3 beinhaltet. 

**Anmerkung**  
Verwenden Sie die folgenden Anweisungen, um die SageMaker AI-Ausführungsrolle für dieses Tutorial zu erstellen.  
Bevor Sie eine Ausführungsrolle für Ihre Produktionsumgebung erstellen, empfehlen wir Ihnen, den Abschnitt [So verwenden Sie SageMaker KI-Ausführungsrollen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) im *[SageMaker KI-Entwicklerhandbuch](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)* zu lesen.

1. 

**Erstellen Sie die IAM-Rolle**

   Erstellen Sie eine JSON-Datei `sagemaker-trust-policy.json` mit dem Namen der folgenden Vertrauensrichtlinie:

------
#### [ JSON ]

****  

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

------

   Erstellen Sie die IAM-Rolle mithilfe der Vertrauensrichtlinie:

   ```
   aws iam create-role \
       --role-name SageMakerExecutionRole \
       --assume-role-policy-document file://sagemaker-trust-policy.json \
       --description "Execution role for SageMaker training jobs"
   ```

1. 

**Verwaltete Richtlinien anhängen**

   Hängen Sie die erforderlichen verwalteten Richtlinien an die Rolle an:

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   ```

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   ```

1. 

**Notieren Sie sich die Rolle ARN**

   Besorgen Sie sich den Rollen-ARN, den Sie in späteren Schritten benötigen:

   ```
   aws iam get-role --role-name SageMakerExecutionRole --query 'Role.Arn' --output text
   ```

   Speichern Sie diesen ARN, da Sie ihn bei der Erstellung Ihrer Payload für Trainingsjobs verwenden werden.

## Schritt 2: Erstellen Sie Ihre Serviceumgebung
<a name="getting-started-sagemaker-step-2"></a>

Eine Serviceumgebung definiert die Kapazitätsbeschränkungen für SageMaker Schulungsjobs. Die Serviceumgebung kapselt die maximale Anzahl von Trainingsinstanzen, die gleichzeitig ausgeführt werden können.

**Wichtig**  
Wenn Sie Ihre erste Serviceumgebung für SageMaker Training erstellen, AWS Batch wird automatisch eine serviceverknüpfte Rolle erstellt, die in Ihrem Konto aufgerufen wird`AWSServiceRoleForAWSBatchWithSagemaker`. Diese Rolle ermöglicht es AWS Batch , SageMaker Schulungsjobs in Ihrem Namen in die Warteschlange zu stellen und zu verwalten. Weitere Informationen zu dieser dienstbezogenen Rolle und ihren Berechtigungen finden Sie unter[Verwendung von Rollen für AWS Batch mit KI SageMaker](using-service-linked-roles-batch-sagemaker.md).

Erstellen Sie eine Serviceumgebung, die bis zu 5 Instanzen verarbeiten kann:

```
aws batch create-service-environment \
    --service-environment-name TutorialServiceEnvironment \
    --service-environment-type SAGEMAKER_TRAINING \
    --capacity-limits capacityUnit=NUM_INSTANCES,maxCapacity=5
```

Ausgabe:

```
{
    "serviceEnvironmentName": "TutorialServiceEnvironment",
    "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
}
```

Stellen Sie sicher, dass Ihre Serviceumgebung erfolgreich erstellt wurde:

```
aws batch describe-service-environments --service-environments TutorialServiceEnvironment
```

Ausgabe:

```
{
    "serviceEnvironments": [
        {
            "serviceEnvironmentName": "TutorialServiceEnvironment",
            "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment",
            "serviceEnvironmentType": "SAGEMAKER_TRAINING",
            "state": "ENABLED",
            "status": "VALID",
            "capacityLimits": [
                {
                    "maxCapacity": 5,
                    "capacityUnit": "NUM_INSTANCES"
                }
            ],
            "tags": {}
        }
    ]
}
```

Weitere Informationen zu Serviceumgebungen finden Sie unter[Serviceumgebungen für AWS Batch](service-environments.md).

## Schritt 3: Erstellen Sie Ihre SageMaker Job-Warteschlange
<a name="getting-started-sagemaker-step-3"></a>

Eine SageMaker Jobwarteschlange verwaltet die Planung und Ausführung von Servicejobs. Jobs, die an diese Warteschlange gesendet werden, werden je nach verfügbarer Kapazität an Ihre Serviceumgebung weitergeleitet.

Erstellen Sie eine Warteschlange für SageMaker Schulungsaufträge:

```
aws batch create-job-queue \
    --job-queue-name my-sm-training-fifo-jq \
    --job-queue-type SAGEMAKER_TRAINING \
    --priority 1 \
    --service-environment-order order=1,serviceEnvironment=TutorialServiceEnvironment
```

Ausgabe:

```
{
    "jobQueueName": "my-sm-training-fifo-jq",
    "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq"
}
```

Stellen Sie sicher, dass Ihre Job-Warteschlange erfolgreich erstellt wurde:

```
aws batch describe-job-queues --job-queues my-sm-training-fifo-jq
```

Ausgabe:

```
{
    "jobQueues": [
        {
            "jobQueueName": "my-sm-training-fifo-jq",
            "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
            "state": "ENABLED",
            "status": "VALID",
            "statusReason": "JobQueue Healthy",
            "priority": 1,
            "computeEnvironmentOrder": [],
            "serviceEnvironmentOrder": [
                {
                    "order": 1,
                    "serviceEnvironment": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
                }
            ],
            "jobQueueType": "SAGEMAKER_TRAINING",
            "tags": {}
        }
    ]
}
```

Weitere Informationen zu SageMaker Auftragswarteschlangen finden Sie unter[Erstellen Sie eine Warteschlange für SageMaker Schulungsjobs in AWS Batch](create-sagemaker-job-queue.md).

## Schritt 4: Einen Schulungsjob erstellen und einreichen
<a name="getting-started-sagemaker-step-4"></a>

Jetzt erstellen Sie einen einfachen Schulungsjob und reichen ihn in Ihre Job-Warteschlange ein. In diesem Beispiel wird ein einfacher „Hello World“ -Schulungsjob verwendet, der die Funktionalität der Servicejobs demonstriert.

Erstellen Sie eine Datei mit dem Namen `my_training_job.json` und dem folgenden Inhalt. Ersetze es *your-account-id* durch deine AWS Konto-ID:

**Anmerkung**  
`S3OutputPath`ist für die Erstellung des SageMaker Trainingsjobs erforderlich, aber die Ergebnisse dieses Tutorials werden nicht im Amazon S3 S3-Bucket gespeichert und Sie können den Pfad in der folgenden JSON-Datei verwenden. In Ihrer Produktionsumgebung benötigen Sie einen gültigen Amazon S3 S3-Bucket, um die Ausgabe dort zu speichern, falls Sie dies wünschen.

```
{
    "TrainingJobName": "my-simple-training-job",
    "RoleArn": "arn:aws:iam::your-account-id:role/SageMakerExecutionRole",
    "AlgorithmSpecification": {
        "TrainingInputMode": "File",
        "TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:2.0.0-cpu-py310",
        "ContainerEntrypoint": [
            "echo",
            "hello world"
        ]
    },
    "ResourceConfig": {
        "InstanceType": "ml.c5.xlarge",
        "InstanceCount": 1,
        "VolumeSizeInGB": 1
    },
    "OutputDataConfig": {
        "S3OutputPath": "s3://your-s3-bucket/output"
    },
    "StoppingCondition": {
        "MaxRuntimeInSeconds": 30
    }
}
```

Reichen Sie den Schulungsjob über die [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API ein:

```
aws batch submit-service-job \
    --job-queue my-sm-training-fifo-jq \
    --job-name my-batch-sm-job \
    --service-job-type SAGEMAKER_TRAINING \
    --retry-strategy attempts=1 \
    --timeout-config attemptDurationSeconds=60 \
    --service-request-payload file://my_training_job.json
```

Ausgabe:

```
{
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobName": "my-batch-sm-job",
    "jobId": "your-job-id"
}
```

Weitere Informationen zu Payloads für Servicejobs finden Sie unter[Payloads für Servicejobs in AWS Batch](service-job-payload.md). Weitere Informationen zum Einreichen von Serviceaufträgen finden Sie unter[Reichen Sie einen Servicejob ein in AWS Batch](service-job-submit.md).

## Schritt 5: Auftragsstatus überwachen
<a name="getting-started-sagemaker-step-5"></a>

Sie können Ihre Trainingsjobs wie folgt überwachen AWS Batch APIs: [DescribeServiceJob[ListServiceJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_ListServiceJobs.html)](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html), und [GetJobQueueSnapshot](https://docs.aws.amazon.com/batch/latest/APIReference/API_GetJobQueueSnapshot.html). In diesem Abschnitt werden verschiedene Möglichkeiten zur Überprüfung des Jobstatus und der Warteschlangeninformationen beschrieben.

Laufende Jobs in Ihrer Warteschlange anzeigen:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNING
```

Ausgabe:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING",
            "startedAt": 1753718820
        }
    ]
}
```

Jobs anzeigen, die sich im `RUNNABLE` Bundesstaat befinden:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNABLE
```

Verschaffen Sie sich einen Überblick über die bevorstehenden Jobs in Ihrer Warteschlange:

```
aws batch get-job-queue-snapshot --job-queue my-sm-training-fifo-jq
```

Ausgabe:

```
{
    "frontOfQueue": {
        "jobs": [
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
                "earliestTimeAtPosition": 1753718880
            },
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id-2",
                "earliestTimeAtPosition": 1753718940
            }
        ],
        "lastUpdatedAt": 1753718970
    }
}
```

Suchen Sie nach Jobs nach Namen:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq \
    --filters name=JOB_NAME,values="my-batch-sm-job"
```

Ausgabe:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING"
        }
    ]
}
```

Weitere Informationen zur Zuordnung des Jobstatus finden Sie unter[Zuordnen AWS Batch des Dienstauftragsstatus zum SageMaker AI-Status](service-job-status.md).

## Schritt 6: Jobausgabe anzeigen
<a name="getting-started-sagemaker-step-6"></a>

Sobald Ihr Job abgeschlossen ist, können Sie die Ausgabe und die Protokolle sowohl AWS Batch über KI als auch über SageMaker KI einsehen APIs.

Detaillierte Informationen zu Ihrem Job erhalten Sie von AWS Batch:

```
aws batch describe-service-job \
    --job-id your-job-id
```

Ausgabe:

```
{
    "attempts": [
        {
            "serviceResourceId": {
                "name": "TrainingJobArn",
                "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
            },
            "startedAt": 1753718820,
            "stoppedAt": 1753718880,
            "statusReason": "Received status from SageMaker: Training job completed"
        }
    ],
    "createdAt": 1753718760,
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobId": "your-job-id",
    "jobName": "my-batch-sm-job",
    "jobQueue": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
    "latestAttempt": {
        "serviceResourceId": {
            "name": "TrainingJobArn",
            "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
        }
    },
    "retryStrategy": {
        "attempts": 1,
        "evaluateOnExit": []
    },
    "serviceRequestPayload": "your-training-job-request-json",
    "serviceJobType": "SAGEMAKER_TRAINING",
    "startedAt": 1753718820,
    "status": "SUCCEEDED",
    "statusReason": "Received status from SageMaker: Training job completed",
    "stoppedAt": 1753718880,
    "tags": {},
    "timeoutConfig": {
        "attemptDurationSeconds": 60
    }
}
```

Dieser Befehl gibt umfassende Jobinformationen zurück, einschließlich des ARN für den SageMaker Trainingsjob, mit dem Sie direkt über SageMaker KI auf den Job zugreifen können:

```
aws sagemaker describe-training-job \
    --training-job-name AWSBatch<my-simple-training-job><your-attempt-id>
```

Um die CloudWatch Logs für deinen Trainingsjob einzusehen, musst du zuerst den Namen des Log-Streams abrufen:

```
aws logs describe-log-streams \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name-prefix AWSBatchmy-simple-training-job
```

Ausgabe:

```
{
    "logStreams": [
        {
            "logStreamName": "your-log-stream-name",
            "creationTime": 1753718830,
            "firstEventTimestamp": 1753718840,
            "lastEventTimestamp": 1753718850,
            "lastIngestionTime": 1753718860,
            "uploadSequenceToken": upload-sequence-token,
            "arn": "arn:aws:logs:your-region:your-account-id:log-group:/aws/sagemaker/TrainingJobs:log-stream:AWSBatch<my-simple-training-job><your-attempt-id>/algo-1-algo-id",
            "storedBytes": 0
        }
    ]
}
```

Rufen Sie dann die Logs mit dem Log-Stream-Namen aus der vorherigen Antwort ab:

```
aws logs get-log-events \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name your-log-stream-name
```

Ausgabe:

```
{
    "events": [
        {
            "timestamp": 1753718845,
            "message": "hello world",
            "ingestionTime": 1753718865
        }
    ],
    "nextForwardToken": "next-forward-token",
    "nextBackwardToken": "next-backward-token"
}
```

In der Protokollausgabe wird die Meldung „Hello World“ aus Ihrem Trainingsjob angezeigt, mit der bestätigt wird, dass der Job erfolgreich ausgeführt wurde.

## Schritt 7: Bereinigen Sie Ihre Tutorial-Ressourcen
<a name="getting-started-sagemaker-step-7"></a>

Wenn Sie mit dem Tutorial fertig sind, bereinigen Sie die Ressourcen, die Sie erstellt haben, um laufende Gebühren zu vermeiden.

Deaktivieren und löschen Sie zunächst die Job-Warteschlange:

```
aws batch update-job-queue \
    --job-queue my-sm-training-fifo-jq \
    --state DISABLED
```

Warten Sie, bis die Job-Warteschlange deaktiviert ist, und löschen Sie sie dann:

```
aws batch delete-job-queue \
    --job-queue my-sm-training-fifo-jq
```

Deaktivieren und löschen Sie als Nächstes die Serviceumgebung:

```
aws batch update-service-environment \
    --service-environment TutorialServiceEnvironment \
    --state DISABLED
```

Warten Sie, bis die Serviceumgebung deaktiviert ist, und löschen Sie sie dann:

```
aws batch delete-service-environment \
    --service-environment TutorialServiceEnvironment
```

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

Nachdem Sie das Tutorial abgeschlossen haben, möchten Sie sich vielleicht mit den folgenden Themen befassen:
+ Wir empfehlen, das pySDK für die Erstellung von Servicejobs und die Übermittlung an Ihre Job-Warteschlange zu verwenden, da pySDK über Hilfsklassen und Hilfsprogramme verfügt. Ein Beispiel für die Verwendung von pySDK finden Sie unter [SageMaker KI-Beispiele](https://github.com/aws/amazon-sagemaker-examples) auf. GitHub
+ Weitere Informationen zu [Servicejobs in AWS Batch](service-jobs.md).
+ Hier finden Sie komplexere Konfigurationen [Payloads für Servicejobs in AWS Batch](service-job-payload.md) für Trainingsjobs.
+ Erfahren Sie mehr über [Reichen Sie einen Servicejob ein in AWS Batch](service-job-submit.md) und die `SubmitServiceJob` API.
+ Lesen Sie[Zuordnen AWS Batch des Dienstauftragsstatus zum SageMaker AI-Status](service-job-status.md), um mehr über die Veränderungen im Berufsstatus zu erfahren.
+ Weitere funktionsreiche Möglichkeiten zum Erstellen und Einreichen von SageMaker Trainingsaufträgen mit [Python finden Sie in der SageMaker AI Python SDK-Dokumentation](https://sagemaker.readthedocs.io/en/stable/).
+ Sehen Sie sich [SageMakerBeispiel-Notebooks](https://github.com/aws/amazon-sagemaker-examples) für komplexere Workflows für maschinelles Lernen an.