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.
# Jobdefinitionsparameter für ContainerProperties
Jobdefinitionen, die ich verwende, [https://docs.aws.amazon.com/batch/latest/APIReference/API_ContainerProperties.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_ContainerProperties.html)sind in mehrere Teile aufgeteilt:
+ Der Name der Jobdefinition
+ Der Typ der Jobdefinition
+ Der Platzhalter für die Parameterersetzung ist standardmäßig voreingestellt
+ Die Container-Eigenschaften für den Job
+ Die Amazon EKS-Eigenschaften für die Auftragsdefinition, die für Jobs erforderlich sind, die auf Amazon EKS-Ressourcen ausgeführt werden
+ Die Knoteneigenschaften, die für einen Paralleljob mit mehreren Knoten erforderlich sind
+ Die Plattformfunktionen, die für Jobs erforderlich sind, werden auf Fargate-Ressourcen ausgeführt
+ Die standardmäßigen Details zur Tag-Propagierung der Auftragsdefinition
+ Die standardmäßige Wiederholungsstrategie für die Jobdefinition
+ Die standardmäßige Planungspriorität für die Auftragsdefinition
+ Die Standard-Tags für die Jobdefinition
+ Das Standard-Timeout für die Jobdefinition
**Contents**
+ [Auftragsdefinitionsname](#jobDefinitionName)
+ [Typ](#type)
+ [Parameter](#parameters)
+ [Eigenschaften des Containers](#containerProperties)
+ [Amazon EKS-Eigenschaften](#job-definition-parameters-eks-properties)
+ [Plattformfunktionen](#job-definition-parameters-platform-capabilities)
+ [Tags propagieren](#job-definition-parameters-propagate-tags)
+ [Knoteneigenschaften](#nodeProperties)
+ [Wiederholungsstrategie](#retryStrategy)
+ [Priorität bei der Planung](#job-definition-parameters-schedulingPriority)
+ [Tags](#job-definition-parameters-tags)
+ [Timeout](#timeout)
## Auftragsdefinitionsname
`jobDefinitionName`
Wenn Sie eine Auftragsdefinition registrieren, geben Sie einen Namen ein. Der Name kann bis zu 128 Zeichen lang sein. Er kann Groß- und Kleinbuchstaben, Zahlen, Bindestriche (-) und Unterstriche (\$1) enthalten. Die erste Jobdefinition, die mit diesem Namen registriert ist, erhält die Revision 1. Alle nachfolgenden Auftragsdefinitionen, die mit diesem Namen registriert werden, erhalten eine inkrementelle Versionsnummer.
Typ: Zeichenfolge
Erforderlich: Ja
## Typ
`type`
Wenn Sie eine Auftragsdefinition registrieren, geben Sie den Auftragstyp an. Wenn der Job auf Fargate-Ressourcen ausgeführt wird, wird er `multinode` nicht unterstützt. Weitere Informationen zu parallelen Aufträgen mit mehreren Knoten finden Sie unter [Eine parallel Jobdefinition mit mehreren Knoten erstellen](create-multi-node-job-def.md).
Typ: Zeichenfolge
Zulässige Werte: `container` \$1 `multinode`
Erforderlich: Ja
## Parameter
`parameters`
Wenn Sie einen Job einreichen, können Sie Parameter angeben, die die Platzhalter ersetzen oder die Standardparameter der Jobdefinition überschreiben. Die Parameter in Anforderungen zum Senden von Aufträgen haben Vorrang vor den Standardeinstellungen in einer Auftragsdefinition. Das bedeutet, dass Sie dieselbe Jobdefinition für mehrere Jobs verwenden können, die dasselbe Format verwenden. Sie können Werte im Befehl auch während der Übermittlung programmgesteuert ändern.
Typ: Abbildung einer Zeichenfolge auf eine Zeichenfolge
Erforderlich: Nein
Wenn Sie eine Auftragsdefinition registrieren, können Sie Parameterersetzungsplatzhalter in das Feld `command` der Container-Eigenschaften eines Auftrags verwenden. Die Syntax ist wie folgt.
```
"command": [
"ffmpeg",
"-i",
"Ref::inputfile",
"-c",
"Ref::codec",
"-o",
"Ref::outputfile"
]
```
Im obigen Beispiel befinden sich die Parameterersetzungsplatzhalter `Ref::inputfile`, `Ref::codec` und `Ref::outputfile` im Befehl. Sie können das `parameters` Objekt in der Jobdefinition verwenden, um Standardwerte für diese Platzhalter festzulegen. Um beispielsweise einen Standard für die `Ref::codec`-Platzhalter einzustellen, legen Sie Folgendes in der Auftragsdefinition fest:
```
"parameters" : {"codec" : "mp4"}
```
Wenn diese Auftragsdefinition zur Ausführung übergeben wird, wird das `Ref::codec` Argument im Befehl für den Container durch den Standardwert ersetzt. `mp4`
## Eigenschaften des Containers
Wenn Sie eine Jobdefinition registrieren, geben Sie eine Liste von Container-Eigenschaften an, die bei der Auftragserteilung an den Docker-Daemon auf einer Container-Instance übergeben werden. Die folgenden Container-Eigenschaften sind in einer Auftragsdefinition zulässig. Für Aufträge mit einzelnen Knoten werden diese Container-Eigenschaften auf Auftragsdefinitionsebene festgelegt. Für parallele Aufträge mit mehreren Knoten werden die Container-Eigenschaften für jede Knotengruppe auf der Ebene der [Knoteneigenschaften](#nodeProperties) festgelegt.
`command`
Der Befehl, der an den Container übergeben wird. Dieser Parameter ist im Abschnitt [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote-API](https://docs.docker.com/engine/api/v1.38/) und dem Parameter `COMMAND` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) `Cmd` zugeordnet. [Weitere Informationen zum `CMD` Docker-Parameter finden Sie unter https://docs.docker.com/engine/ reference/builder/ \$1cmd.](https://docs.docker.com/engine/reference/builder/#cmd)
```
"command": ["string", ...]
```
Typ: Zeichenfolgen-Array
Erforderlich: Nein
`environment`
Die Umgebungsvariablen, die an einen Container übergeben werden. Dieser Parameter ordnet zu `Env` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--env` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu.
Wir raten davon ab, Umgebungsvariablen im Klartext für sensible Informationen wie Anmeldeinformationen zu verwenden.
Umgebungsvariablen dürfen nicht mit beginnen. `AWS_BATCH` Diese Namenskonvention ist Variablen vorbehalten, die vom AWS Batch Dienst festgelegt werden.
Typ: Array von Schlüssel-Wert-Paaren
Erforderlich: Nein
`name`
Der Name der Umgebungsvariable.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `environment` verwendet wird.
`value`
Der Wert der Umgebungsvariable.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `environment` verwendet wird.
```
"environment" : [
{ "name" : "envName1", "value" : "envValue1" },
{ "name" : "envName2", "value" : "envValue2" }
]
```
`executionRoleArn`
Wenn Sie eine Jobdefinition registrieren, können Sie eine IAM-Rolle angeben. Die Rolle gewährt dem Amazon ECS-Container-Agenten die Erlaubnis, die API-Aktionen, die in den zugehörigen Richtlinien angegeben sind, in Ihrem Namen aufzurufen. Jobs, die auf Fargate-Ressourcen ausgeführt werden, müssen eine Ausführungsrolle bereitstellen. Weitere Informationen finden Sie unter [AWS Batch Rolle „IAM-Ausführung“](execution-IAM-role.md).
Typ: Zeichenfolge
Erforderlich: Nein
`fargatePlatformConfiguration`
Die Plattformkonfiguration für Jobs, die auf Fargate-Ressourcen ausgeführt werden. Jobs, die auf EC2 Ressourcen ausgeführt werden, dürfen diesen Parameter nicht angeben.
Typ: [FargatePlatformConfiguration](https://docs.aws.amazon.com/batch/latest/APIReference/API_FargatePlatformConfiguration.html) Objekt
Erforderlich: Nein
`platformVersion`
Die AWS Fargate-Plattformversion, die für die Jobs verwendet wird, oder `LATEST` um eine aktuelle, zugelassene Version der AWS Fargate-Plattform zu verwenden.
Typ: Zeichenfolge
Standard: `LATEST`
Erforderlich: Nein
`image`
Das Bild, das zum Starten eines Jobs verwendet wurde. Diese Zeichenfolge wird direkt an den Docker-Daemon übergeben. Images in der Docker Hub-Registrierung sind standardmäßig verfügbar. Sie können auch andere Repositorys mit `repository-url/image:tag` angeben. Bis zu 255 Buchstaben (Groß- und Kleinbuchstaben), Ziffern, Bindestriche, Unterstriche, Doppelpunkte, Punkte und Schrägstriche sind zulässig. Dieser Parameter wird `Image` zugeordnet im Abschnitt [Create a container](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) (Erstellen eines Containers) im [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und dem `IMAGE`-Parameter von [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/).
Die Docker-Image-Architektur muss der Prozessorarchitektur der Compute-Ressourcen entsprechen, für die sie geplant sind. So können beispielsweise ARM-basierte Docker-Images nur auf ARM-basierten Compute-Ressourcen ausgeführt werden.
+ Bilder in öffentlichen Amazon ECR-Repositorys verwenden die vollständigen `registry/repository[:tag]` oder die `registry/repository[@digest]` Namenskonventionen (z. B.`public.ecr.aws/registry_alias/my-web-app:latest`).
+ Bilder in Amazon ECR-Repositorys verwenden die vollständige `registry/repository:[tag]` Namenskonvention. Beispiel, `aws_account_id.dkr.ecr.region.amazonaws.com``/my-web-app:latest`.
+ Images in offiziellen Repositorys in Docker Hub verwenden einen einzelnen Namen (z. B. `ubuntu` oder `mongo`).
+ Images in anderen Repositorys in Docker Hub sind mit einem Organisationsnamen qualifiziert (z. B, `amazon/amazon-ecs-agent`).
+ Image in anderen Online-Repositorys sind durch einen Domain-Namen zusätzlich qualifiziert (z. B. `quay.io/assemblyline/ubuntu`).
Typ: Zeichenfolge
Erforderlich: Ja
`instanceType`
Der Instance-Typ zur Verwendung für einen parallelen Auftrag mit mehreren Knoten. Alle Knotengruppen müssen in einem parallelen Auftrag mit mehreren Knoten den gleichen Instance-Typ verwenden. Dieser Parameter ist nicht gültig für Container-Jobs mit einem Knoten oder für Jobs, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Zeichenfolge
Erforderlich: Nein
`jobRoleArn`
Wenn Sie eine Jobdefinition registrieren, können Sie eine IAM-Rolle angeben. Die Rolle stellt dem Auftrags-Container Berechtigungen zum Aufrufen der API-Aktionen zur Verfügung, die in den zugehörigen Richtlinien in Ihrem Namen festgelegt sind. Weitere Informationen finden Sie unter [IAM-Rollen für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) im *Entwicklerhandbuch zum Amazon Elastic Container Service*.
Typ: Zeichenfolge
Erforderlich: Nein
`linuxParameters`
Linux-spezifische Änderungen, die auf den Container angewendet werden, z. B. Details für Gerätezuordnungen.
```
"linuxParameters": {
"devices": [
{
"hostPath": "string",
"containerPath": "string",
"permissions": [
"READ", "WRITE", "MKNOD"
]
}
],
"initProcessEnabled": true|false,
"sharedMemorySize": 0,
"tmpfs": [
{
"containerPath": "string",
"size": integer,
"mountOptions": [
"string"
]
}
],
"maxSwap": integer,
"swappiness": integer
}
```
Typ: [LinuxParameters](https://docs.aws.amazon.com/batch/latest/APIReference/API_LinuxParameters.html) Objekt
Erforderlich: Nein
`devices`
Liste der im Container zugeordneten Geräte. Dieser Parameter ist `Devices` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--device` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet.
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Array von [Device](https://docs.aws.amazon.com/batch/latest/APIReference/API_Device.html)-Objekten
Erforderlich: Nein
`hostPath`
Pfad, in dem sich das in der Host-Container-Instance verfügbare Gerät befindet.
Typ: Zeichenfolge
Erforderlich: Ja
`containerPath`
Pfad, in dem das Gerät im Container verfügbar gemacht wird. Wenn dies nicht angegeben ist, wird das Gerät unter demselben Pfad wie der Hostpfad verfügbar gemacht.
Typ: Zeichenfolge
Erforderlich: Nein
`permissions`
Berechtigungen für das Gerät im Container. Wenn dies nicht angegeben ist, sind die Berechtigungen auf `READ``WRITE`, und gesetzt`MKNOD`.
Typ: Zeichenfolgen-Array
Erforderlich: Nein
Zulässige Werte: `READ` \$1 `WRITE` \$1 `MKNOD`
`initProcessEnabled`
Wenn der Wert "true" lautet, führen Sie einen `init`-Prozess innerhalb des Containers aus, der Signalen weiterleitet und Prozesse aufnimmt. Dieser Parameter wird der Option `--init` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet. Für diesen Parameter muss Ihre Docker Remote API Version 1.25 oder höher in Ihrer Container-Instance verwenden. Um die Docker Remote API-Version auf Ihrer Container-Instance zu überprüfen, melden Sie sich bei Ihrer Container-Instance an und führen Sie den folgenden Befehl aus: `sudo docker version | grep "Server API version"`
Typ: Boolesch
Erforderlich: Nein
`maxSwap`
Die Gesamtmenge an Swap-Speicher (in MiB), die ein Job verwenden kann. Dieser Parameter ist in die Option `--memory-swap` zur [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) übersetzt, wobei der Wert die Summe aus dem Container-Speicher und dem Wert `maxSwap` ist. Weitere Informationen finden Sie unter [`--memory-swap`-Details](https://docs.docker.com/config/containers/resource_constraints/#--memory-swap-details) in der Docker-Dokumentation.
Wenn als `maxSwap`-Wert `0` angegeben wird, verwendet der Container keine Auslagerung. Zulässige Werte sind `0` oder eine beliebige positive Ganzzahl. Wenn der `maxSwap` Parameter weggelassen wird, verwendet der Container die Swap-Konfiguration für die Container-Instance, auf der er ausgeführt wird. Es muss ein Wert für `maxSwap` festgelegt werden, damit der Parameter `swappiness` verwendet werden kann.
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Ganzzahl
Erforderlich: Nein
`sharedMemorySize`
Der Wert für die Größe des `/dev/shm`-Volumes (in MiB). Dieser Parameter wird der Option `--shm-size` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet.
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Ganzzahl
Erforderlich: Nein
`swappiness`
Auf diese Weise können Sie das Speicherauslagerungsverhalten eines Containers optimieren. Ein `swappiness` Wert von `0` bewirkt, dass ein Austausch nicht stattfindet, sofern dies nicht unbedingt erforderlich ist. Ein `swappiness`-Wert von `100` führt dazu, dass Seiten aggressiv ausgelagert werden. Akzeptierte Werte sind Ganzzahlen zwischen `0` und `100`. Wenn der Parameter `swappiness` nicht angegeben wird, wird der Standardwert `60` verwendet. Wenn kein Wert für `maxSwap` angegeben ist, wird dieser Parameter ignoriert. Wenn `maxSwap` auf 0 gesetzt ist, verwendet der Container kein Auslagern. Dieser Parameter wird der Option `--memory-swappiness` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet.
Beachten Sie Folgendes, wenn Sie eine Auslagerungskonfiguration pro Container verwenden.
+ Der Auslagerungsbereich muss auf der Container-Instance aktiviert und zugewiesen werden, damit die Container verwenden können.
**Anmerkung**
Bei Amazon ECS-Optimierungen ist Swap standardmäßig AMIs nicht aktiviert. Sie müssen die Auslagerung auf der Instance aktivieren, um dieses Feature verwenden zu können. Weitere Informationen finden Sie unter [Instance Store Swap Volumes](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-store-swap-volumes.html) im * EC2 Amazon-Benutzerhandbuch* oder [Wie weise ich mithilfe einer Swap-Datei Speicher zu, der als Swap-Speicherplatz in einer EC2 Amazon-Instance verwendet werden](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-memory-swap-file/) soll? .
+ Die Swap-Space-Parameter werden nur für Jobdefinitionen unterstützt, die EC2 Ressourcen verwenden.
+ Wenn die Container-Definitionsparameter `maxSwap` und `swappiness` in einer Aufgabendefinition weggelassen werden, hat jeder Container den `swappiness`-Standardwert 60. Die gesamte Swap-Nutzung ist auf das Zweifache der Speicherreservierung des Containers begrenzt.
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Ganzzahl
Erforderlich: Nein
`tmpfs`
Der Container-Pfad, Mount-Optionen und Größe des tmpfs-Mounts.
Typ: Array von [Tmpfs](https://docs.aws.amazon.com/batch/latest/APIReference/API_Tmpfs.html)-Objekten
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Erforderlich: Nein
`containerPath`
Der absolute Dateipfad in dem Container, in dem das tmpfs-Volume gemountet ist.
Typ: Zeichenfolge
Erforderlich: Ja
`mountOptions`
Die Liste der Mount-Optionen für das tmpfs-Volume.
Gültige Werte: `defaults` "`ro`" \$1 `rw` "\$1`suid`" \$1 "\$1`nosuid`" \$1 `dev` "\$1`nodev`" \$1 `exec` "\$1`noexec`" \$1 `sync` "\$1`async`" \$1 "\$1`dirsync`" \$1 `remount` "\$1`mand`" \$1 `nomand` "\$1`atime`" \$1 `noatime` "\$1`diratime`" \$1 "\$1`nodiratime`" \$1 `bind` "\$1`rbind`" \$1 `unbindable` "\$1`runbindable`" \$1 `private` "\$1" \$1 `rprivate` "\$1`shared`" \$1 `rshared` "\$1`slave`" \$1 `rslave` "\$1`relatime`" \$1 `norelatime` "\$1" `strictatime` "\$1`nostrictatime`" \$1“ `mode`"\$1" `uid` "\$1" `gid` "\$1" `nr_inodes` "\$1" \$1 `nr_blocks` "\$1"`mpol`“
Typ: Zeichenfolgen-Array
Erforderlich: Nein
`size`
Die Größe des tmpfs-Volumes (in MB).
Typ: Ganzzahl
Erforderlich: Ja
`logConfiguration`
Die Protokollkonfigurationsspezifikation für den Job.
Dieser Parameter ist `LogConfig` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--log-driver` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet. Standardmäßig verwenden Container den gleichen Protokolltreiber wie der Docker-Daemon. Der Container kann jedoch einen anderen Logging-Treiber als der Docker-Daemon verwenden, indem ein Protokolltreiber mit diesem Parameter in der Container-Definition angegeben wird. Um einen anderen Logging-Treiber für einen Container zu verwenden, muss das Protokollsystem entweder auf der Container-Instance oder auf einem anderen Log-Server konfiguriert werden, um Remote-Logging-Optionen bereitzustellen. Weitere Informationen zu den Optionen für die verschiedenen unterstützten Protokolltreiber finden Sie unter [Configure logging drivers (Protokolltreiber konfigurieren)](https://docs.docker.com/engine/admin/logging/overview/) in der Docker-Dokumentation.
AWS Batch unterstützt derzeit eine Teilmenge der Protokollierungstreiber, die für den Docker-Daemon verfügbar sind (siehe [LogConfiguration](https://docs.aws.amazon.com/batch/latest/APIReference/API_LogConfiguration.html)Datentyp).
Für diesen Parameter muss Ihre Docker Remote API Version 1.18 oder höher in Ihrer Container-Instance verwenden. Um die Docker Remote API-Version auf Ihrer Container-Instance zu überprüfen, melden Sie sich bei Ihrer Container-Instance an und führen Sie den folgenden Befehl aus: `sudo docker version | grep "Server API version"`
```
"logConfiguration": {
"devices": [
{
"logDriver": "string",
"options": {
"optionName1" : "optionValue1",
"optionName2" : "optionValue2"
}
"secretOptions": [
{
"name" : "secretOptionName1",
"valueFrom" : "secretOptionArn1"
},
{
"name" : "secretOptionName2",
"valueFrom" : "secretOptionArn2"
}
]
}
]
}
```
Typ: [LogConfiguration](https://docs.aws.amazon.com/batch/latest/APIReference/API_LogConfiguration.html) Objekt
Erforderlich: Nein
`logDriver`
Der Protokolltreiber, der für den Job verwendet werden soll. AWS Batch Aktiviert standardmäßig den `awslogs` Protokolltreiber. Die für diesen Parameter aufgelisteten gültigen Werte sind Protokolltreiber, mit denen der Amazon-ECS-Container-Agent standardmäßig kommunizieren kann.
Dieser Parameter ist `LogConfig` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--log-driver` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet. Standardmäßig verwenden Jobs denselben Protokollierungstreiber, den der Docker-Daemon verwendet. Der Job kann jedoch einen anderen Logging-Treiber als der Docker-Daemon verwenden, indem ein Protokolltreiber mit diesem Parameter in der Jobdefinition angegeben wird. Wenn Sie einen anderen Protokollierungstreiber für einen Job angeben möchten, muss das Protokollsystem auf der Container-Instance in der Rechenumgebung konfiguriert werden. Oder konfigurieren Sie es alternativ auf einem anderen Protokollserver, um Optionen für die Remote-Protokollierung bereitzustellen. Weitere Informationen zu den Optionen für die verschiedenen unterstützten Protokolltreiber finden Sie unter [Configure logging drivers (Protokolltreiber konfigurieren)](https://docs.docker.com/engine/admin/logging/overview/) in der Docker-Dokumentation.
AWS Batch unterstützt derzeit eine Teilmenge der Protokollierungstreiber, die für den Docker-Daemon verfügbar sind. Es ist möglich, dass in zukünftigen Releases des Amazon-ECS-Container-Agenten weitere Protokolltreiber zur Verfügung stehen.
Die unterstützten Protokolltreiber sind `awslogs`, `fluentd`, `gelf`, `json-file`, `journald`, `logentries`, `syslog` und `splunk`.
Jobs, die auf Fargate-Ressourcen ausgeführt werden, sind auf die Treiber `awslogs` und die `splunk` Protokolltreiber beschränkt.
Für diesen Parameter muss Ihre Docker Remote API Version 1.18 oder höher in Ihrer Container-Instance verwenden. Um die Docker Remote API-Version auf Ihrer Container-Instance zu überprüfen, melden Sie sich bei Ihrer Container-Instance an und führen Sie den folgenden Befehl aus: `sudo docker version | grep "Server API version"`
Der Amazon ECS-Container-Agent, der auf einer Container-Instance ausgeführt wird, muss die Protokollierungstreiber, die auf dieser Instance verfügbar sind, mit der `ECS_AVAILABLE_LOGGING_DRIVERS` Umgebungsvariablen registrieren. Andernfalls können die auf dieser Instance platzierten Container diese Protokollkonfigurationsoptionen nicht verwenden. Weitere Informationen finden Sie unter [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) im *Entwicklerhandbuch zum Amazon Elastic Container Service*.
`awslogs`
Gibt den Amazon CloudWatch Logs-Protokollierungstreiber an. Weitere Informationen finden Sie unter [Verwenden Sie den awslogs-Protokolltreiber](using_awslogs.md) und [Amazon CloudWatch Logs-Protokollierungstreiber](https://docs.docker.com/config/containers/logging/awslogs/) in der Docker-Dokumentation.
`fluentd`
Gibt den Fluentd-Protokolltreiber an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Fluentd-Logging-Treiber](https://docs.docker.com/config/containers/logging/fluentd/) in der Docker-Dokumentation.
`gelf`
Gibt den Graylog Extended Format (GELF)-Protokolltreiber an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Graylog Extended Format-Logging-Treiber](https://docs.docker.com/config/containers/logging/gelf/) in der Docker-Dokumentation.
`journald`
Gibt den Journald-Protokolltreiber an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Journald Logging-Treiber](https://docs.docker.com/config/containers/logging/journald/) in der Docker-Dokumentation.
`json-file`
Gibt den Treiber für die JSON-Datei an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Treiber für die JSON-Dateiprotokollierung](https://docs.docker.com/config/containers/logging/json-file/) in der Docker-Dokumentation.
`splunk`
Gibt den Splunk-Protokolltreiber an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Splunk-Logging-Treiber](https://docs.docker.com/config/containers/logging/splunk/) in der Docker-Dokumentation.
`syslog`
Gibt den Syslog-Protokolltreiber an. Weitere Informationen, einschließlich Verwendung und Optionen, finden Sie unter [Syslog-Logging-Treiber](https://docs.docker.com/config/containers/logging/syslog/) in der Docker-Dokumentation.
Typ: Zeichenfolge
Erforderlich: Ja
Zulässige Werte: `awslogs` \$1 `fluentd` \$1 `gelf` \$1 `journald` \$1 `json-file` \$1 `splunk` \$1 `syslog`
Wenn Sie einen benutzerdefinierten Treiber haben, der nicht zuvor aufgeführt ist und den Sie mit dem Amazon ECS-Container-Agenten verwenden möchten, können Sie das Amazon ECS-Container-Agent-Projekt, [auf dem verfügbar](https://github.com/aws/amazon-ecs-agent) ist, forken GitHub und es so anpassen, dass es mit diesem Treiber funktioniert. Wir möchten Sie bitten, uns eventuelle Änderungswünsche mitzuteilen. Amazon Web Services unterstützt derzeit jedoch keine Anfragen, die modifizierte Kopien dieser Software ausführen.
`options`
Protokollkonfigurationsoptionen, die für den Job an einen Protokolltreiber gesendet werden sollen.
Für diesen Parameter muss Ihre Docker Remote API Version 1.19 oder höher in Ihrer Container-Instance verwenden.
Typ: Abbildung einer Zeichenfolge auf eine Zeichenfolge
Erforderlich: Nein
`secretOptions`
Ein Objekt, welches das Secret darstellt, der an die Protokollkonfiguration übergeben werden soll. Weitere Informationen finden Sie unter [Geben Sie sensible Daten an](specifying-sensitive-data.md).
Typ: Objekt-Array
Erforderlich: Nein
`name`
Der Name der Protokolltreiberoption, die im Job festgelegt werden soll.
Typ: Zeichenfolge
Erforderlich: Ja
`valueFrom`
Der Amazon-Ressourcenname (ARN) des Geheimnisses, das in der Protokollkonfiguration des Containers offengelegt werden soll. Die unterstützten Werte sind entweder der vollständige ARN des Secrets Manager Manager-Geheimnisses oder der vollständige ARN des Parameters im SSM-Parameterspeicher.
Wenn der Parameter SSM Parameter Store in derselben Datei AWS-Region wie die Aufgabe, die Sie starten, vorhanden ist, können Sie entweder den vollständigen ARN oder den Namen des Parameters verwenden. Wenn der Parameter in einer anderen Region existiert, muss der volle ARN angegeben werden.
Typ: Zeichenfolge
Erforderlich: Ja
`memory`
*Dieser Parameter ist veraltet. Verwenden Sie ihn stattdessen. `resourceRequirements`*
Die Anzahl der MiB an Speicher, die für den Job reserviert sind.
Als Beispiel für die Verwendung`resourceRequirements`, wenn Ihre Jobdefinition eine Syntax enthält, die der folgenden ähnelt.
```
"containerProperties": {
"memory": 512
}
```
Die entsprechende Syntax, die Sie verwenden, `resourceRequirements` lautet wie folgt.
```
"containerProperties": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "512"
}
]
}
```
Typ: Ganzzahl
Erforderlich: Ja
`mountPoints`
Die Mountingpunkte für Daten-Volumes in Ihrem Container. Dieser Parameter ordnet zu `Volumes` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--volume` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu.
```
"mountPoints": [
{
"sourceVolume": "string",
"containerPath": "string",
"readOnly": true|false
}
]
```
Typ: Objekt-Array
Erforderlich: Nein
`sourceVolume`
Der Name des zu mountenden Volumes.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `mountPoints` verwendet wird.
`containerPath`
Der Pfad auf dem Container, in den das Host-Volume gemountet werden soll.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `mountPoints` verwendet wird.
`readOnly`
Wenn dieser Wert `true` lautet, verfügt der Container über schreibgeschützten Zugriff auf das Volume. Lautet der Wert `false`, dann verfügt der Container über Schreibzugriff auf das Volume.
Typ: Boolesch
Erforderlich: Nein
Standard: False
`networkConfiguration`
Die Netzwerkkonfiguration für Jobs, die auf Fargate-Ressourcen ausgeführt werden. Jobs, die auf EC2 Ressourcen ausgeführt werden, dürfen diesen Parameter nicht angeben.
```
"networkConfiguration": {
"assignPublicIp": "string"
}
```
Typ: Objekt-Array
Erforderlich: Nein
`assignPublicIp`
Gibt an, ob die Aufgabe eine öffentliche IP-Adresse hat. Dies ist erforderlich, wenn der Job ausgehenden Netzwerkzugriff benötigt.
Typ: Zeichenfolge
Zulässige Werte: `ENABLED` \$1 `DISABLED`
Erforderlich: Nein
Standard: `DISABLED`
`privileged`
Wenn dieser Parameter den Wert „true“ aufweist, erhält der Container erhöhte Berechtigungen auf der Host-Container-Instance (ähnlich wie der `root`-Benutzer). Dieser Parameter ordnet zu `Privileged` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--privileged` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu. Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden. Geben Sie es nicht an und geben Sie es nicht als falsch an.
```
"privileged": true|false
```
Typ: Boolesch
Erforderlich: Nein
`readonlyRootFilesystem`
Wenn dieser Parameter den Wert „true“ aufweist, erhält der Container Lesezugriff auf das Root-Dateisystem. Dieser Parameter ordnet zu `ReadonlyRootfs` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--read-only` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu.
```
"readonlyRootFilesystem": true|false
```
Typ: Boolesch
Erforderlich: Nein
`resourceRequirements`
Die Art und Menge einer Ressource, die einem Container zugewiesen werden soll. Zu den unterstützten Ressourcen gehören `GPU`, `MEMORY` und `VCPU`.
```
"resourceRequirements" : [
{
"type": "GPU",
"value": "number"
}
]
```
Typ: Objekt-Array
Erforderlich: Nein
`type`
Die Art einer Ressource, die einem Container zugewiesen werden soll. Zu den unterstützten Ressourcen gehören `GPU`, `MEMORY` und `VCPU`.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `resourceRequirements` verwendet wird.
`value`
Die Menge der angegebenen Ressource, die für den Container reserviert werden soll. Die Werte variieren abhängig vom angegebenen `type`.
type="GPU"
Die Anzahl der physischen Objekte GPUs , die für den Container reserviert werden sollen. Die Anzahl der für alle Container in einem Job GPUs reservierten Container darf die Anzahl der verfügbaren Container GPUs auf der Rechenressource, auf der der Job gestartet wird, nicht überschreiten.
Typ="SPEICHER"
Die harte Arbeitsspeichergrenze (in MiB), die dem Container bereitgestellt wird. Wenn Ihr Container versucht, das hier angegebene Limit zu überschreiten, wird der Container beendet. Dieser Parameter ist `Memory` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--memory` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet. Sie müssen mindestens 4 MB Arbeitsspeicher für einen Auftrag festlegen. Dies ist erforderlich, kann jedoch an mehreren Stellen für parallele (MNP)-Aufgaben mit mehreren Knoten angegeben werden. Es muss mindestens einmal für jeden Knoten angegeben werden. Dieser Parameter ist `Memory` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--memory` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet.
Wenn Sie versuchen, Ihre Ressourcennutzung zu maximieren, indem Sie Ihren Jobs so viel Speicher wie möglich für einen bestimmten Instance-Typ zur Verfügung stellen, finden Sie weitere Informationen unter[Speicherverwaltung für Rechenressourcen](memory-management.md).
Für Jobs, die auf Fargate-Ressourcen ausgeführt werden, `value` müssen sie einem der unterstützten Werte entsprechen. Außerdem müssen die `VCPU` Werte einer der Werte sein, die für diesen Speicherwert unterstützt werden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/batch/latest/userguide/job_definition_parameters.html)
Typ="VCPU“
Die Nummer von v, die für den Job reserviert sind. CPUs Dieser Parameter ist `CpuShares` im Abschnitt [Einen Container erstellen](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker-Remote-API](https://docs.docker.com/engine/api/v1.38/) und der Option `--cpu-shares` für die [Docker-Ausführung](https://docs.docker.com/engine/reference/run/) zugeordnet. Jede vCPU entspricht 1.024 CPU-Anteilen. Für Jobs, die auf EC2 Ressourcen ausgeführt werden, müssen Sie mindestens eine vCPU angeben. Dies ist erforderlich, kann aber an mehreren Stellen angegeben werden. Es muss mindestens einmal für jeden Knoten angegeben werden.
Jobs, die auf Fargate-Ressourcen ausgeführt werden, `value` müssen einem der unterstützten Werte entsprechen und die `MEMORY` Werte müssen einem der Werte entsprechen, die für diesen VCPU-Wert unterstützt werden. Die unterstützten Werte sind 0,25, 0,5, 1, 2, 4, 8 und 16.
Das Standardkontingent für die Fargate On-Demand-vCPU-Ressourcenzahl ist 6 V. CPUs Weitere Informationen zu Fargate-Kontingenten finden Sie unter [AWS Fargate-Kontingente](https://docs.aws.amazon.com/general/latest/gr/ecs-service.html#service-quotas-fargate) in der. *Allgemeine Amazon Web Services-Referenz*
Typ: Zeichenfolge
Erforderlich: Ja, wenn `resourceRequirements` verwendet wird.
`secrets`
Die Geheimnisse für den Job, die als Umgebungsvariablen verfügbar gemacht werden. Weitere Informationen finden Sie unter [Geben Sie sensible Daten an](specifying-sensitive-data.md).
```
"secrets": [
{
"name": "secretName1",
"valueFrom": "secretArn1"
},
{
"name": "secretName2",
"valueFrom": "secretArn2"
}
...
]
```
Typ: Objekt-Array
Erforderlich: Nein
`name`
Der Name der Umgebungsvariablen, die das Geheimnis enthält.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `secrets` verwendet wird.
`valueFrom`
Das Geheimnis, das dem Container exponiert werden muss. Die unterstützten Werte sind entweder der vollständige Amazon Resource Name (ARN) des Secrets Manager Manager-Geheimnisses oder der vollständige ARN des Parameters im SSM Parameter Store.
Wenn der SSM Parameter Store-Parameter in derselben Datei AWS-Region wie der Job, den Sie starten, vorhanden ist, können Sie entweder den vollständigen ARN oder den Namen des Parameters verwenden. Wenn der Parameter in einer anderen Region existiert, muss der volle ARN angegeben werden.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `secrets` verwendet wird.
`ulimits`
Eine Liste der `ulimits`-Werte, die im Container festgelegt werden sollen. Dieser Parameter ordnet zu `Ulimits` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--ulimit` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu.
```
"ulimits": [
{
"name": string,
"softLimit": integer,
"hardLimit": integer
}
...
]
```
Typ: Objekt-Array
Erforderlich: Nein
`name`
Der `type` des `ulimit`-Werts.
Typ: Zeichenfolge
Erforderlich: Ja, wenn `ulimits` verwendet wird.
`hardLimit`
Das harte Limit für den `ulimit`-Typ.
Typ: Ganzzahl
Erforderlich: Ja, wenn `ulimits` verwendet wird.
`softLimit`
Das weiche Limit für den `ulimit`-Typ.
Typ: Ganzzahl
Erforderlich: Ja, wenn `ulimits` verwendet wird.
`user`
Der Benutzername, der im Container verwendet werden soll. Dieser Parameter ordnet zu `User` im Bereich [Erstellen eines Containers](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) der [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) und der Option `--user` für die [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/) zu.
```
"user": "string"
```
Typ: Zeichenfolge
Erforderlich: Nein
`vcpus`
*Dieser Parameter ist veraltet. Verwenden Sie ihn stattdessen. `resourceRequirements`*
Die Nummer von v, die für den CPUs Container reserviert ist.
Als Beispiel für die Verwendung`resourceRequirements`, falls Ihre Jobdefinition Zeilen enthält, die der folgenden ähneln:
```
"containerProperties": {
"vcpus": 2
}
```
Die entsprechende Verwendung von Zeilen `resourceRequirements` lautet wie folgt.
```
"containerProperties": {
"resourceRequirements": [
{
"type": "VCPU",
"value": "2"
}
]
}
```
Typ: Ganzzahl
Erforderlich: Ja
`volumes`
Wenn Sie eine Auftragsdefinition registrieren, können Sie eine Liste der Volumes angeben, die an den Docker-Daemon in einer Container-Instance übergeben werden sollen. Die folgenden Parameter sind in den Container-Eigenschaften zulässig:
```
"volumes": [
{
"name": "string",
"host": {
"sourcePath": "string"
},
"efsVolumeConfiguration": {
"authorizationConfig": {
"accessPointId": "string",
"iam": "string"
},
"fileSystemId": "string",
"rootDirectory": "string",
"transitEncryption": "string",
"transitEncryptionPort": number
}
}
]
```
`name`
Der Name des Volumes. Bis zu 255 Buchstaben (Groß- und Kleinbuchstaben), Ziffern, Bindestriche und Unterstriche sind zulässig. Auf diesen Namen wird im Parameter `sourceVolume` der Containerdefinition `mountPoints` verwiesen.
Typ: Zeichenfolge
Erforderlich: Nein
`host`
Der Inhalt des Parameters `host` bestimmt, ob Ihr Daten-Volume auf der Host-Container-Instance erhalten bleibt und wo es gespeichert wird. Wenn der Parameter `host` leer ist, weist der Docker-Daemon einen Host-Pfad für Ihr Daten-Volume zu. Es kann jedoch nicht garantiert werden, dass die Daten auch dann bestehen bleiben, wenn der ihnen zugeordnete Container nicht mehr läuft.
Dieser Parameter ist nicht auf Aufträge anwendbar, die auf Fargate-Ressourcen ausgeführt werden.
Typ: Objekt
Erforderlich: Nein
`sourcePath`
Der Pfad auf der Host-Container-Instance, die dem Container angezeigt wird. Wenn dieser Parameter leer ist, weist der Docker-Daemon einen Host-Pfad für Sie zu.
Wenn der Parameter `host` den Speicherort `sourcePath` enthält, bleibt das Daten-Volume an der angegebenen Position der Host-Container-Instance erhalten, bis Sie es manuell löschen. Wenn der `sourcePath`-Wert auf der Host-Container-Instance nicht vorhanden ist, wird der Docker-Daemon ihn erstellen. Wenn der Speicherort nicht vorhanden ist, wird der Inhalt des Quellpfadordners exportiert.
Typ: Zeichenfolge
Erforderlich: Nein
`efsVolumeConfiguration`
Dieser Parameter wird angegeben, wenn Sie ein Dateisystem von Amazon Elastic File System für die Aufgabenspeicherung verwenden. Weitere Informationen finden Sie unter [Amazon EFS-Volumes](efs-volumes.md).
Typ: Objekt
Erforderlich: Nein
`authorizationConfig`
Die Autorisierungskonfigurationsdetails für das Amazon EFS-Dateisystem.
Typ: Zeichenfolge
Erforderlich: Nein
`accessPointId`
Die Amazon EFS-Zugriffspunkt-ID, die verwendet werden soll. Wenn ein Zugriffspunkt angegeben ist, `EFSVolumeConfiguration` muss der in der angegebene Stammverzeichniswert entweder weggelassen oder auf `/` gesetzt werden. Dadurch wird der Pfad durchgesetzt, der auf dem EFS-Zugriffspunkt festgelegt ist. Wenn ein Zugriffspunkt verwendet wird, muss in `EFSVolumeConfiguration` die Transitverschlüsselung aktiviert sein. Weitere Informationen finden Sie unter [Arbeiten mit Amazon EFS-Zugriffspunkten](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) im *Amazon Elastic File System-Benutzerhandbuch*.
Typ: Zeichenfolge
Erforderlich: Nein
`iam`
Legt fest, ob beim Mounten des Amazon EFS-Dateisystems die in einer Auftragsdefinition definierte AWS Batch Job-IAM-Rolle verwendet werden soll. Wenn diese Option aktiviert ist, muss die Transit-Verschlüsselung in `EFSVolumeConfiguration` aktiviert sein. Wenn dieser Parameter nicht angegeben ist, wird der Standardwert `DISABLED` verwendet. Weitere Informationen finden Sie unter [Verwenden Sie Amazon EFS-Zugriffspunkte](efs-volumes.md#efs-volume-accesspoints).
Typ: Zeichenfolge
Zulässige Werte: `ENABLED` \$1 `DISABLED`
Erforderlich: Nein
`fileSystemId`
Die zu verwendende Amazon EFS-Dateisystem-ID.
Typ: Zeichenfolge
Erforderlich: Nein
`rootDirectory`
Das Verzeichnis im Amazon EFS-Dateisystem, das als Stammverzeichnis im Host bereitgestellt werden soll. Wenn dieser Parameter weggelassen wird, wird der Stamm des Amazon-EFS-Volumes verwendet. Wenn Sie dies angeben`/`, hat dies dieselbe Wirkung wie das Weglassen dieses Parameters. Die maximale Länge beträgt 4,096 Zeichen.
Wenn in der ein EFS-Zugriffspunkt angegeben ist`authorizationConfig`, muss der Stammverzeichnisparameter entweder weggelassen oder auf gesetzt werden`/`. Dadurch wird der Pfad durchgesetzt, der auf dem Amazon EFS-Zugriffspunkt festgelegt ist.
Typ: Zeichenfolge
Erforderlich: Nein
`transitEncryption`
Legt fest, ob die Verschlüsselung für Amazon-EFS-Daten während der Übertragung zwischen dem Amazon-ECS-Host und dem Amazon-EFS-Server aktiviert werden soll. Die Transit-Verschlüsselung muss aktiviert sein, wenn die Amazon-EFS-IAM-Autorisierung verwendet wird. Wenn dieser Parameter nicht angegeben ist, wird der Standardwert `DISABLED` verwendet. Weitere Informationen finden Sie unter [Verschlüsseln von Daten während der Übertragung](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) im *Benutzerhandbuch für Amazon Elastic File System*.
Typ: Zeichenfolge
Zulässige Werte: `ENABLED` \$1 `DISABLED`
Erforderlich: Nein
`transitEncryptionPort`
Der zu verwendende Port zum Senden verschlüsselter Daten zwischen dem Amazon-ECS-Host und dem Amazon EFS-Server. Wenn Sie keinen Transit-Verschlüsselungsport angeben, wird die Port-Auswahlstrategie verwendet, die der Amazon EFS-Mount-Helfer verwendet. Dieser Wert muss zwischen 0 und 65.535 liegen. Weitere Informationen finden Sie unter [EFS-Mount-Helfer](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) im *Benutzerhandbuch für Amazon Elastic File System*.
Typ: Ganzzahl
Erforderlich: Nein
## Amazon EKS-Eigenschaften
Ein Objekt mit verschiedenen Eigenschaften, die für Amazon-EKS-basierte Aufträge spezifisch sind. Dies darf für Amazon ECS-basierte Jobdefinitionen nicht angegeben werden.
`podProperties`
Die Eigenschaften für die Kubernetes Pod-Ressourcen eines Jobs.
Typ: [EksPodProperties](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPodProperties.html) Objekt
Erforderlich: Nein
`containers`
Die Eigenschaften des Containers, der im Amazon-EKS-Pod verwendet wird.
Typ: [EksContainer](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksContainer.html) Objekt
Erforderlich: Nein
`args`
Eine Reihe von Argumenten für den Einstiegspunkt. Wenn dies nicht angegeben ist, wird der `CMD` des Container-Images verwendet. Dies entspricht dem `args` Mitglied im [Entrypoint-Bereich](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint) des [Pods](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/) in. Kubernetes Verweise auf Umgebungsvariablen werden mithilfe der Umgebung des Containers erweitert.
Wenn die referenzierte Umgebungsvariable nicht existiert, wird die Referenz im Befehl nicht geändert. Wenn der Verweis beispielsweise „`$(NAME1)`“ lautet und die `NAME1`-Umgebungsvariable nicht existiert, bleibt die Befehlszeichenfolge „`$(NAME1)`“ erhalten. `$$` wird ersetzt durch `$` und die resultierende Zeichenfolge wird nicht erweitert. Beispielsweise wird `$$(VAR_NAME)` als `$(VAR_NAME)` übergeben, unabhängig davon, ob die Umgebungsvariable `VAR_NAME` vorhanden ist oder nicht. *Weitere Informationen finden Sie unter [CMD](https://docs.docker.com/engine/reference/builder/#cmd) in der *Dockerfile-Referenz* und [Definieren Sie einen Befehl und Argumente für einen Pod](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/) in der Dokumentation. Kubernetes*
Typ: Zeichenfolgen-Array
Erforderlich: Nein
`command`
Der Einstiegspunkt für den Container. Dies wird nicht in einer Shell ausgeführt. Wenn dies nicht angegeben ist, wird der `ENTRYPOINT` des Container-Images verwendet. Verweise auf Umgebungsvariablen werden mithilfe der Umgebung des Containers erweitert.
Wenn die referenzierte Umgebungsvariable nicht existiert, wird die Referenz im Befehl nicht geändert. Wenn der Verweis beispielsweise „`$(NAME1)`“ lautet und die `NAME1`-Umgebungsvariable nicht existiert, bleibt die Befehlszeichenfolge „`$(NAME1)`“ erhalten. `$$` wird ersetzt durch `$`, und die resultierende Zeichenfolge wird nicht erweitert. Beispielsweise wird `$$(VAR_NAME)` als `$(VAR_NAME)` übergeben, unabhängig davon, ob die Umgebungsvariable `VAR_NAME` vorhanden ist oder nicht. Der Einstiegspunkt kann nicht aktualisiert werden. [https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#entrypoint)
Typ: Zeichenfolgen-Array
Erforderlich: Nein
`env`
Die Umgebungsvariablen, die an einen Container übergeben werden.
Umgebungsvariablen können nicht mit `AWS_BATCH` beginnen. Diese Benennungskonvention ist Variablen vorbehalten, die festlegen. AWS Batch
Typ: Array von [EksContainerEnvironmentVariable](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksContainerEnvironmentVariable.html)-Objekten
Erforderlich: Nein
`name`
Der Name der Umgebungsvariable.
Typ: Zeichenfolge
Erforderlich: Ja
`value`
Der Wert der Umgebungsvariable.
Typ: Zeichenfolge
Erforderlich: Nein
`image`
Das Docker-Image zum Starten des Containers.
Typ: Zeichenfolge
Erforderlich: Ja
`imagePullPolicy`
Die Image-Pull-Richtlinie für den Container. Unterstützte Werte sind `Always`, `IfNotPresent` und `Never`. Dieser Parameter lautet standardmäßig `IfNotPresent`. Wenn das `:latest`-Tag jedoch angegeben ist, ist es standardmäßig `Always`. Weitere Informationen finden Sie in der *KubernetesDokumentation* unter [Bilder aktualisieren](https://kubernetes.io/docs/concepts/containers/images/#updating-images).
Typ: Zeichenfolge
Erforderlich: Nein
`name`
Name des Containers. Wenn der Name nicht angegeben ist, wird der Standardname „`Default`“ verwendet. Jeder Container in einem Pod muss einen eindeutigen Namen haben.
Typ: Zeichenfolge
Erforderlich: Nein
`resources`
Die Art und Menge an Ressourcen, die einem Container zugewiesen werden sollen. Zu den unterstützten Ressourcen gehören `memory`, `cpu` und `nvidia.com/gpu`. Weitere Informationen finden Sie in der *KubernetesDokumentation* unter [Ressourcenverwaltung für Pods und Container](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/).
Typ: [EksContainerResourceRequirements](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksContainerResourceRequirements.html) Objekt
Erforderlich: Nein
`limits`
Typ und Menge der Ressourcen, die für den Container reserviert werden sollen. Die Werte variieren abhängig vom angegebenen `name`. Ressourcen können entweder mithilfe der `limits`- oder `requests`-Objekte angefordert werden.
memory
Die harte Speichergrenze (in MB) für den Container, unter Verwendung ganzer Zahlen, mit dem Suffix „Mi“. Wenn Ihr Container versucht, das angegebene Limit zu überschreiten, wird der Container beendet. Sie müssen mindestens 4 MB Arbeitsspeicher für einen Auftrag festlegen. `memory` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `memory` in beiden Orten angegeben ist, muss der Wert, der in `limits` angegeben ist, dem Wert entsprechen, der in `requests` angegeben ist.
Um Ihre Ressourcenauslastung zu maximieren, stellen Sie Ihren Aufträgen so viel Arbeitsspeicher wie möglich für den spezifischen Instance-Typ zur Verfügung, den Sie verwenden. Um zu erfahren wie dies geht, vgl. [Speicherverwaltung für Rechenressourcen](memory-management.md).
cpu
Die Nummer CPUs davon ist für den Container reserviert. Werte müssen ein gerade Vielfaches von `0.25` sein. `cpu` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `cpu` in beiden Orten angegeben ist, muss der Wert, der in `limits` angegeben ist, mindestens so groß sein wie der Wert, der in `requests` angegeben ist.
nvidia.com/gpu
Die Nummer GPUs , die für den Container reserviert ist. Werte müssen eine ganze Zahl sein. `memory` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `memory` in beiden Orten angegeben ist, muss der Wert, der in `limits` angegeben ist, dem Wert entsprechen, der in `requests` angegeben ist.
Typ: Abbildung einer Zeichenfolge auf eine Zeichenfolge
Längenbeschränkungen des Wertes: Minimale Länge von 1. Maximale Länge beträgt 256 Zeichen.
Erforderlich: Nein
`requests`
Typ und Menge der für den Container anzufordernden Ressourcen. Die Werte variieren abhängig vom angegebenen `name`. Ressourcen können entweder mithilfe der `limits`-Objekte oder der `requests`-Objekte angefordert werden.
memory
Die harte Speichergrenze (in MB) für den Container, unter Verwendung ganzer Zahlen, mit dem Suffix „Mi“. Wenn Ihr Container versucht, das angegebene Limit zu überschreiten, wird der Container beendet. Sie müssen mindestens 4 MB Arbeitsspeicher für einen Auftrag festlegen. `memory` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `memory` in beiden angegeben ist, muss der Wert, der in `limits` angegeben ist, dem Wert entsprechen, der in `requests` angegeben ist.
Wenn Sie versuchen, Ihre Ressourcennutzung zu maximieren, indem Sie Ihren Jobs so viel Speicher wie möglich für einen bestimmten Instance-Typ zur Verfügung stellen, finden Sie weitere Informationen unter[Speicherverwaltung für Rechenressourcen](memory-management.md).
cpu
Die Anzahl CPUs davon ist für den Container reserviert. Werte müssen ein gerade Vielfaches von `0.25` sein. `cpu` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `cpu` in beiden angegeben ist, muss der Wert, der in `limits` angegeben ist, mindestens so groß sein wie der Wert, der in `requests` angegeben ist.
nvidia.com/gpu
Die Anzahl GPUs davon ist für den Container reserviert. Werte müssen eine ganze Zahl sein. `nvidia.com/gpu` kann in `limits`, `requests` oder in beiden angegeben werden. Wenn `nvidia.com/gpu` in beiden angegeben ist, muss der Wert, der in `limits` angegeben ist, dem Wert entsprechen, der in `requests` angegeben ist.
Typ: Abbildung einer Zeichenfolge auf eine Zeichenfolge
Längenbeschränkungen des Wertes: Minimale Länge von 1. Maximale Länge beträgt 256 Zeichen.
Erforderlich: Nein
`securityContext`
Der Sicherheitskontext für einen Auftrag. Weitere Informationen finden [Sie in der *KubernetesDokumentation* unter Konfigurieren eines Sicherheitskontextes für einen Pod oder Container](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/).
Typ: [EksContainerSecurityContext](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksContainerSecurityContext.html) Objekt
Erforderlich: Nein
`privileged`
Wenn dieser Parameter den Wert `true` aufweist, erhält der Container erhöhte Berechtigungen auf der Host-Container-Instance. Die Ebene der Berechtigungen ähnelt den `root` Benutzerberechtigungen. Der Standardwert ist `false`. Dieser Parameter entspricht der `privileged` Richtlinie in den [Sicherheitsrichtlinien für privilegierte Pods](https://kubernetes.io/docs/concepts/security/pod-security-policy/#privileged) in der *KubernetesDokumentation*.
Typ: Boolesch
Erforderlich: Nein
`readOnlyRootFilesystem`
Wenn dieser Parameter den Wert `true` aufweist, erhält der Container Lesezugriff auf das Root-Dateisystem. Der Standardwert ist `false`. Dieser Parameter ist der `ReadOnlyRootFilesystem` Richtlinie in den [Pod-Sicherheitsrichtlinien für Volumes und Dateisysteme](https://kubernetes.io/docs/concepts/security/pod-security-policy/#volumes-and-file-systems) in der *KubernetesDokumentation zugeordnet*.
Typ: Boolesch
Erforderlich: Nein
`runAsGroup`
Wenn dieser Parameter angegeben ist, wird der Container mit der angegebenen Gruppen-ID (`gid`) ausgeführt. Wird dieser Parameter nicht angegeben, wird standardmäßig die Gruppe verwendet, die in den Image-Metadaten angegeben ist. Dieser Parameter ist einer `MustRunAs` Richtlinie in den [Pod-Sicherheitsrichtlinien für Benutzer und Gruppen](https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups) in der *KubernetesDokumentation zugeordnet*. `RunAsGroup`
Type: Long
Erforderlich: Nein
`runAsNonRoot`
Wenn dieser Parameter angegeben ist, wird der Container als Benutzer mit einem `uid` mit anderen Wert als 0 ausgeführt. Wenn dieser Parameter nicht angegeben ist, wird eine solche Regel durchgesetzt. Dieser Parameter ist einer `MustRunAsNonRoot` Richtlinie in den [Pod-Sicherheitsrichtlinien für Benutzer und Gruppen](https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups) in der *KubernetesDokumentation zugeordnet*. `RunAsUser`
Type: Long
Erforderlich: Nein
`runAsUser`
Wenn dieser Parameter angegeben ist, wird der Container mit der angegebenen Benutzer-ID (`uid`) ausgeführt. Wird dieser Parameter nicht angegeben, wird standardmäßig der in den Image-Metadaten angegebene Benutzer verwendet. Dieser Parameter ist einer `MustRanAs` Richtlinie in den [Pod-Sicherheitsrichtlinien für Benutzer und Gruppen](https://kubernetes.io/docs/concepts/security/pod-security-policy/#users-and-groups) in der *KubernetesDokumentation zugeordnet*. `RunAsUser`
Type: Long
Erforderlich: Nein
`volumeMounts`
Die Volume-Mounts für einen Container für einen Amazon-EKS-Auftrag. Weitere Informationen zu Volumes und zum Einhängen von [Volumes finden Sie in Kubernetes der *KubernetesDokumentation* unter Volumes](https://kubernetes.io/docs/concepts/storage/volumes/).
Typ: Array von [EksContainerVolumeMount](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksContainerVolumeMount.html)-Objekten
Erforderlich: Nein
`mountPath`
Der Pfad auf dem Container, in dem das Volume gemountet ist.
Typ: Zeichenfolge
Erforderlich: Nein
`name`
Der Name des zu mountenden Volumes. Dieser muss mit dem Namen eines der Volumes im Pod übereinstimmen.
Typ: Zeichenfolge
Erforderlich: Nein
`readOnly`
Wenn dieser Wert `true` lautet, verfügt der Container über schreibgeschützten Zugriff auf das Volume. Andernfalls kann der Container auf das Volume schreiben. Der Standardwert ist `false`.
Typ: Boolesch
Erforderlich: Nein
`dnsPolicy`
Die DNS-Richtlinie für den Pod. Der Standardwert ist `ClusterFirst`. Wenn der `hostNetwork`-Parameter nicht angegeben ist, ist der Standardwert `ClusterFirstWithHostNet`. `ClusterFirst` gibt an, dass jede DNS-Abfrage, die nicht mit dem konfigurierten Cluster-Domain-Suffix übereinstimmt, an den vom Knoten geerbten Upstream-Nameserver weitergeleitet wird. Wenn `dnsPolicy` in der [RegisterJobDefinition](https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html)API-Operation kein Wert für angegeben wurde, wird weder `dnsPolicy` von noch von [DescribeJobDefinitions[DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobDefinitions.html)API-Vorgängen ein Wert zurückgegeben. Die Pod-Spezifikationseinstellung enthält entweder `ClusterFirst` oder `ClusterFirstWithHostNet`, abhängig vom Wert des `hostNetwork`-Parameters. Weitere Informationen finden Sie in [der *KubernetesDokumentation* zur DNS-Richtlinie von Pod](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/#pod-s-dns-policy).
Zulässige Werte: `Default` \$1 `ClusterFirst` \$1 `ClusterFirstWithHostNet`
Typ: Zeichenfolge
Erforderlich: Nein
`hostNetwork`
Gibt an, ob der Pod die Netzwerk-IP-Adresse der Hosts verwendet. Der Standardwert ist `true`. Wenn Sie dies auf einstellen, wird das Kubernetes Pod-Netzwerkmodell `false` aktiviert. Die meisten AWS Batch Workloads sind ausschließlich für ausgehende Verbindungen bestimmt und erfordern nicht den Mehraufwand der IP-Zuweisung für jeden Pod für eingehende Verbindungen. [https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking](https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking)
Typ: Boolesch
Erforderlich: Nein
`serviceAccountName`
Der Name des Servicekontos, das zum Ausführen des Pods verwendet wird. Weitere Informationen finden Sie unter [KubernetesDienstkonten](https://docs.aws.amazon.com/eks/latest/userguide/service-accounts.html) und [Konfiguration eines Kubernetes Dienstkontos für die Übernahme einer IAM-Rolle](https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html) im *Amazon EKS-Benutzerhandbuch* und [Servicekonten für Pods konfigurieren](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/) in der *KubernetesDokumentation*.
Typ: Zeichenfolge
Erforderlich: Nein
`volumes`
Gibt die Volumes für eine Auftragsdefinition an, die Amazon-EKS-Ressourcen verwendet.
Typ: Array von [EksVolume](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksVolume.html)-Objekten
Erforderlich: Nein
EmptyDir
Gibt die Konfiguration eines Volumes an Kubernetes`emptyDir`. Ein `emptyDir`-Volume wird zuerst erstellt, wenn ein Pod einem Knoten zugewiesen wird. Es existiert, solange der Pod auf diesem Knoten läuft. Das `emptyDir`-Volume ist zunächst leer. Alle Container im Pod können die Dateien im `emptyDir`-Volume lesen und schreiben. Das `emptyDir`-Volume kann jedoch in jedem Container auf den gleichen oder unterschiedlichen Pfaden gemountet werden. Wenn ein Pod aus irgendeinem Grund von einem Knoten entfernt wird, werden die Daten in `emptyDir` dauerhaft gelöscht. *Weitere Informationen finden Sie in der [Dokumentation unter EmptyDir](https://kubernetes.io/docs/concepts/storage/volumes/#emptydir). Kubernetes*
Typ: [EksEmptyDir](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksEmptyDir.html) Objekt
Erforderlich: Nein
Medium
Das Medium zum Speichern des Volumes. Der Standardwert ist eine leere Zeichenfolge, die den Speicher des Knotens verwendet.
""
**(Standard)** Verwenden Sie den Festplattenspeicher des Knotens.
„Arbeitsspeicher“
Verwenden Sie das `tmpfs`-Volume, das vom RAM des Knotens unterstützt wird. Der Inhalt des Volumes geht verloren, wenn der Knoten neu gestartet wird, und jeder Speicherplatz auf dem Volume wird auf das Speicherlimit des Containers angerechnet.
Typ: Zeichenfolge
Erforderlich: Nein
Größenbeschränkung
Die maximale Größe des Volumes. Standardmäßig ist keine maximale Größe definiert.
Typ: Zeichenfolge
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 256 Zeichen.
Erforderlich: Nein
Host-Pfad
Gibt die Konfiguration eines Kubernetes `hostPath` Volumes an. Ein `hostPath`-Volume mountet eine vorhandene Datei oder ein Verzeichnis aus dem Dateisystem des Hostknotens in Ihren Pod. Weitere Informationen finden Sie in der *KubernetesDokumentation* unter [HostPath](https://kubernetes.io/docs/concepts/storage/volumes/#hostpath).
Typ: [EksHostPath](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksHostPath.html) Objekt
Erforderlich: Nein
*path*
Der Pfad der Datei oder des Verzeichnisses auf dem Host, das in Containern auf dem Pod gemountet werden soll.
Typ: Zeichenfolge
Erforderlich: Nein
Name
Der Name des Volumes. Der Name muss als DNS-Sub-Domain-Name zulässig sein. *Weitere Informationen finden Sie in der Dokumentation unter [DNS-Subdomänennamen](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names). Kubernetes*
Typ: Zeichenfolge
Erforderlich: Ja
Secret
Gibt die Konfiguration eines Kubernetes `secret` Volumes an. Weitere Informationen finden Sie in der *KubernetesDokumentation* unter [Secret](https://kubernetes.io/docs/concepts/storage/volumes/#secret).
Typ: [EksSecret](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksSecret.html) Objekt
Erforderlich: Nein
optional
Gibt an, ob das Geheimnis oder die Schlüssel des Geheimnisses definiert werden müssen.
Typ: Boolesch
Erforderlich: Nein
Geheimer Name
Der Name des Secrets. Der Name muss als DNS-Sub-Domain-Name zulässig sein. *Weitere Informationen finden Sie in der Dokumentation unter [DNS-Subdomänennamen](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names). Kubernetes*
Typ: Zeichenfolge
Erforderlich: Ja
## Plattformfunktionen
`platformCapabilities`
Die Plattformfunktionen, die für die Jobdefinition erforderlich sind. Wenn kein Wert angegeben wird, wird standardmäßig der Wert `EC2` verwendet. Für Jobs, die auf Fargate-Ressourcen ausgeführt werden, `FARGATE` ist angegeben.
Wenn der Job auf Amazon EKS-Ressourcen ausgeführt wird, dürfen Sie keine Angaben machen`platformCapabilities`.
Typ: Zeichenfolge
Zulässige Werte: `EC2` \$1 `FARGATE`
Erforderlich: Nein
## Tags propagieren
`propagateTags`
Gibt an, ob die Tags aus dem Auftrag oder der Auftragsdefinition an die entsprechende Amazon ECS-Aufgabe weitergegeben werden sollen. Wenn kein Wert angegeben wird, werden die Tags nicht weitergegeben. Tags können nur dann an die Aufgaben weitergegeben werden, wenn die Aufgabe erstellt wird. Bei Tags mit demselben Namen haben Auftrags-Tags Vorrang vor Auftragsdefinitions-Tags. Wenn die Gesamtzahl der kombinierten Tags aus dem Job und der Auftragsdefinition über 50 liegt, wird der Job in den `FAILED` Status verschoben.
Wenn der Job auf Amazon EKS-Ressourcen ausgeführt wird, dürfen Sie keine Angaben machen`propagateTags`.
Typ: Boolesch
Erforderlich: Nein
## Knoteneigenschaften
`nodeProperties`
Wenn Sie eine parallel Auftragsdefinition mit mehreren Knoten registrieren, müssen Sie eine Liste von Knoteneigenschaften angeben. Diese Knoteneigenschaften definieren die Anzahl der Knoten, die in Ihrem Job verwendet werden sollen, den Hauptknotenindex und die verschiedenen zu verwendenden Knotenbereiche. Wenn der Job auf Fargate-Ressourcen ausgeführt wird, können Sie keine Angaben machen. `nodeProperties` Nutzen Sie stattdessen `containerProperties`. Die folgenden Knoteneigenschaften sind in einer Auftragsdefinition zulässig. Weitere Informationen finden Sie unter [Parallel ausgeführte Aufträge mit mehreren Knoten](multi-node-parallel-jobs.md).
Wenn der Job auf Amazon EKS-Ressourcen ausgeführt wird, dürfen Sie keine Angaben machen`nodeProperties`.
Typ: [NodeProperties](https://docs.aws.amazon.com/batch/latest/APIReference/API_NodeProperties.html) Objekt
Erforderlich: Nein
`mainNode`
Gibt den Knotenindex für den Hauptknoten eines parallelen Auftrags mit mehreren Knoten an. Dieser Knotenindexwert muss kleiner als die Anzahl der Knoten sein.
Typ: Ganzzahl
Erforderlich: Ja
`numNodes`
Die Anzahl der Knoten, die mit einem parallelen Auftrag mit mehreren Knoten verknüpft sind.
Typ: Ganzzahl
Erforderlich: Ja
`nodeRangeProperties`
Eine Liste von Knotenbereichen und deren Eigenschaften, die mit einem parallelen Auftrag mit mehreren Knoten verknüpft sind.
Eine Knotengruppe ist eine identische Gruppe von Auftragsknoten, die alle dieselben Containereigenschaften gemeinsam haben. Sie können AWS Batch damit bis zu fünf verschiedene Knotengruppen für jeden Job angeben.
Typ: Array von [NodeRangeProperty](https://docs.aws.amazon.com/batch/latest/APIReference/API_NodeRangeProperty.html)-Objekten
Erforderlich: Ja
`targetNodes`
Der Bereich der Knoten, die Knotenindexwerte verwenden. Ein Bereich von `0:3` zeigt Knoten mit Indexwerten von `0` bis `3` an. Wenn der Wert für den Startbereich weggelassen wird (`:n`), wird 0 verwendet, um den Bereich zu starten. Wenn der Endbereichswert ausgelassen wird (`n:`), wird für den Endbereich der höchstmögliche Knotenindex verwendet wird. Ihre gesamten Knotenbereiche müssen alle Knoten berücksichtigen (`0:n`). Sie können Knotenbereiche verschachteln, zum Beispiel `0:10` und`4:5`. In diesem Fall haben die `4:5` Bereichseigenschaften Vorrang vor den `0:10` Eigenschaften.
Typ: Zeichenfolge
Erforderlich: Nein
`container`
Die Container-Details für den Knotenbereich. Weitere Informationen finden Sie unter [Eigenschaften des Containers](#containerProperties).
Typ: [ContainerProperties](https://docs.aws.amazon.com/batch/latest/APIReference/API_ContainerProperties.html) Objekt
Erforderlich: Nein
## Wiederholungsstrategie
`retryStrategy`
Wenn Sie eine Auftragsdefinition registrieren, können Sie optional eine Wiederholungsstrategie für fehlgeschlagene Aufträge angeben, die mit dieser Auftragsdefinition übermittelt werden. Jede Wiederholungsstrategie, die während eines [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)Vorgangs angegeben wird, hat Vorrang vor der hier definierten Wiederholungsstrategie. Standardmäßig erfolgt ein Ausführungsversuch pro Auftrag. Wenn Sie mehr als einen Versuch angeben, wird der Job erneut versucht, falls er fehlschlägt. Beispiele für einen fehlgeschlagenen Versuch sind, dass der Job einen Exit-Code ungleich Null zurückgibt oder die Container-Instance beendet wird. Weitere Informationen finden Sie unter [Automatisierte Auftragswiederholungen](job_retries.md).
Typ: [RetryStrategy](https://docs.aws.amazon.com/batch/latest/APIReference/API_RetryStrategy.html) Objekt
Erforderlich: Nein
`attempts`
Gibt die Zahl der Wiederholungsversuche an, um einen Auftrag in den Status `RUNNABLE` zu verschieben. Sie können zwischen einem und zehn Versuche angeben. Wenn `attempts` größer als 1 ist, wird der Auftrag bei einem auftretenden Fehler entsprechend oft wiederholt, bis er in den Status `RUNNABLE` wechselt.
```
"attempts": integer
```
Typ: Ganzzahl
Erforderlich: Nein
`evaluateOnExit`
Array mit bis zu 5 Objekten, die Bedingungen angeben, unter denen der Job wiederholt wird oder fehlschlägt. Wenn dieser Parameter angegeben wird, muss der Parameter `attempts` ebenfalls angegeben werden. Wenn angegeben `evaluateOnExit` ist, aber keiner der Einträge zutrifft, wird der Job erneut versucht.
```
"evaluateOnExit": [
{
"action": "string",
"onExitCode": "string",
"onReason": "string",
"onStatusReason": "string"
}
]
```
Typ: Array von [EvaluateOnExit](https://docs.aws.amazon.com/batch/latest/APIReference/API_EvaluateOnExit.html)-Objekten
Erforderlich: Nein
`action`
Gibt die Aktion an, die durchgeführt werden soll, wenn alle angegebenen Bedingungen (`onStatusReason`, `onReason` und `onExitCode`) erfüllt sind. Bei den Werten muss die Groß- und Kleinschreibung beachtet werden.
Typ: Zeichenfolge
Erforderlich: Ja
Zulässige Werte: `RETRY` \$1 `EXIT`
`onExitCode`
Enthält ein Glob-Muster, das mit der Dezimaldarstellung von verglichen werden soll`ExitCode`, die für einen Job zurückgegeben wurde. Jedes Muster kann bis zu 512 Zeichen lang sein. Es kann nur Zahlen enthalten. Es darf keine Buchstaben oder Sonderzeichen enthalten. Es kann optional mit einem Sternchen (\$1) enden, so dass nur der Anfang der Zeichenfolge genau übereinstimmen muss.
Typ: Zeichenfolge
Erforderlich: Nein
`onReason`
Enthält ein Glob-Muster, das mit dem verglichen werden soll`Reason`, das für einen Job zurückgegeben wurde. Jedes Muster kann bis zu 512 Zeichen lang sein. Es kann Buchstaben, Zahlen, Punkte (.), Doppelpunkte (:) und Leerzeichen (Leerzeichen, Tabulatoren) enthalten. Es kann optional mit einem Sternchen (\$1) enden, so dass nur der Anfang der Zeichenfolge genau übereinstimmen muss.
Typ: Zeichenfolge
Erforderlich: Nein
`onStatusReason`
Enthält ein Glob-Muster, das mit dem verglichen werden soll`StatusReason`, das für einen Job zurückgegeben wurde. Jedes Muster kann bis zu 512 Zeichen lang sein. Es kann Buchstaben, Zahlen, Punkte (.), Doppelpunkte (:) und Leerzeichen (Leerzeichen, Tabulatoren) enthalten. Es kann optional mit einem Sternchen (\$1) enden, so dass nur der Anfang der Zeichenfolge genau übereinstimmen muss.
Typ: Zeichenfolge
Erforderlich: Nein
## Priorität bei der Planung
`schedulingPriority`
Die Planungspriorität für Jobs, die mit dieser Jobdefinition eingereicht werden. Dies betrifft nur Jobs in Auftragswarteschlangen mit einer Fair-Share-Richtlinie. Aufgaben mit einer höheren Planungspriorität werden vor Aufgaben mit einer niedrigeren Planungspriorität geplant.
Der unterstützte Mindestwert ist 0 und der unterstützte Höchstwert ist 9999.
Typ: Ganzzahl
Erforderlich: Nein
## Tags
`tags`
Schlüssel-Wert-Paar-Tags, die der Jobdefinition zugeordnet werden sollen. Weitere Informationen finden Sie unter [Kennzeichnen Sie Ihre AWS Batch Ressourcen](using-tags.md).
Typ: Abbildung einer Zeichenfolge auf eine Zeichenfolge
Erforderlich: Nein
## Timeout
`timeout`
Sie können eine Timeout-Dauer für Ihre Jobs konfigurieren, sodass der Job AWS Batch beendet wird, wenn er länger läuft. Weitere Informationen finden Sie unter [Timeouts bei der Job](job_timeouts.md). Wenn ein Job aufgrund eines Timeouts beendet wird, wird er nicht erneut versucht. Jede Timeout-Konfiguration, die während eines [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)Vorgangs angegeben wird, hat Vorrang vor der hier definierten Timeout-Konfiguration. Weitere Informationen finden Sie unter [Timeouts bei der Job](job_timeouts.md).
Typ: [JobTimeout](https://docs.aws.amazon.com/batch/latest/APIReference/API_JobTimeout.html) Objekt
Erforderlich: Nein
`attemptDurationSeconds`
Die Zeitdauer in Sekunden (gemessen anhand des `startedAt` Zeitstempels des Auftragsversuchs) nach AWS Batch Beendigung nicht abgeschlossener Jobs. Der Mindestwert für die Zeitüberschreitung beträgt 60 Sekunden.
Bei Array-Aufträgen gilt das Timeout für die untergeordneten Aufträge, nicht für den übergeordneten Array-Auftrag.
Bei parallel Aufträgen mit mehreren Knoten (MNP) gilt das Timeout für den gesamten Auftrag, nicht für die einzelnen Knoten.
Typ: Ganzzahl
Erforderlich: Nein