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.

# So platziert Amazon ECS Aufgaben in Container-Instances
<a name="task-placement"></a>

Mithilfe der Aufgabenplatzierung können Sie Amazon ECS so konfigurieren, dass Ihre Aufgaben auf Container-Instances platziert werden, die bestimmte Kriterien erfüllen, z. B. eine Availability Zone oder einen Instance-Typ.

Folgendes sind Komponenten der Aufgabenplatzierung:
+ Aufgabenplatzierungsstrategie – Ein Algorithmus zum Auswählen von Container-Instances zur Aufgabenplatzierung oder von Aufgaben zur Beendigung. Beispielsweise kann Amazon ECS Container-Instances nach dem Zufallsprinzip auswählen oder Instances so auswählen, dass Aufgaben gleichmäßig auf eine Gruppe von Instances verteilt sind.
+ Aufgabengruppe – Eine Gruppe verwandter Aufgaben, zum Beispiel Datenbankaufgaben.
+ Beschränkung der Aufgabenplatzierung – Dies sind Regeln, die erfüllt sein müssen, um eine Aufgabe auf einer Container-Instance platzieren zu können. Wenn die Einschränkung nicht erfüllt ist, wird die Aufgabe nicht platziert und verbleibt im Status `PENDING`. Sie können z. B. eine Einschränkung verwenden, um Aufgaben nur einem bestimmten Instance-Typ zuzuordnen. 

Amazon ECS hat unterschiedliche Algorithmen für die verschiedenen Kapazitätsoptionen. 

## Amazon ECS Managed Instances
<a name="managed-instances-launch-type"></a>

Für Aufgaben, die in Amazon ECS Managed Instances ausgeführt werden, muss Amazon ECS festlegen, wo die Aufgabe platziert werden soll und – wenn die Anzahl der Aufgaben herunterskaliert wird – welche Aufgaben beendet werden sollen. Amazon ECS trifft diese Entscheidung auf der Grundlage der Instance-Anforderungen, die in der Startvorlage für den Kapazitätsanbieter angegeben sind, der in der Aufgabendefinition angegebenen Anforderungen wie CPU und Arbeitsspeicher sowie der Einschränkungen bei der Aufgabenplatzierung.

**Anmerkung**  
Amazon ECS Managed Instances unterstützt keine Strategien zur Aufgabenplatzierung. Amazon ECS wird sich bemühen, Aufgaben über zugängliche Availability Zones zu verteilen.

Wenn Amazon ECS Aufgaben platziert, verwendet es das folgende Verfahren zum Auswählen von Container-Instances:

1. Identifizieren der Container-Instances, die die in der Aufgabendefinition angegebenen Anforderungen an CPU, GPU, Arbeitsspeicher und Port erfüllen.

1. Identifizieren der Container-Instances, die die Einschränkungen der Aufgabenplatzierung erfüllen.

1. Identifizieren Sie die Container-Instances, die die Instance-Anforderungen erfüllen, die in der Startvorlage für den Kapazitätsanbieter angegeben sind.

1. Auswählen der Container-Instances für die Aufgabenplatzierung.

## EC2
<a name="ec2-launch-type"></a>

Bei Aufgaben, die den EC2-Starttyp verwenden, muss Amazon ECS anhand der in der Aufgabendefinition angegebenen Anforderungen – beispielsweise CPU und Arbeitsspeicher – bestimmen, wo die Aufgabe platziert werden soll. Wenn Sie die Anzahl der Aufgaben herunterskalieren, muss Amazon ECS auf ähnliche Weise bestimmen, welche Aufgaben beendet werden sollen. Mit Aufgabenplatzierungsstrategien und -bedingungen können Sie festlegen, wie Amazon ECS Aufgaben platziert und beendet. 

Die Standardstrategien für die Aufgabenplatzierung hängen davon ab, ob Sie Aufgaben manuell (eigenständige Aufgaben) oder innerhalb eines Services ausführen. Für Aufgaben, die als Teil eines Amazon-ECS-Service ausgeführt werden, ist die Strategie zur Aufgabenplatzierung `spread` unter Verwendung von `attribute:ecs.availability-zone`. Es gibt keine Standardbeschränkung für die Aufgabenplatzierung für Aufgaben, die nicht in Services enthalten sind. Weitere Informationen finden Sie unter [Planen Sie Ihre Container in Amazon ECS](scheduling_tasks.md).

**Anmerkung**  
Aufgabenplatzierungsstrategien entsprechen bestem Bemühen. Amazon ECS versucht auch dann noch, Aufgaben zu platzieren, wenn die optimale Platzierungsoption nicht verfügbar ist. Einschränkungen der Aufgabenplatzierung sind jedoch verbindlich und können eine Aufgabenplatzierung verhindern. 

Sie können Aufgabenplatzierungsstrategien mit Bedingungen kombinieren. Beispielsweise können Sie eine Aufgabenplatzierungsstrategie und eine Aufgabenplatzierungsbeschränkung verwenden, um Aufgaben auf Availability Zones zu verteilen und Bin-Pack-Aufgaben basierend auf dem Arbeitsspeicher innerhalb jeder Availability Zone zu verteilen (jedoch nur für G2-Instances).

Wenn Amazon ECS Aufgaben platziert, verwendet es das folgende Verfahren zum Auswählen von Container-Instances:

1. Identifizieren der Container-Instances, die die in der Aufgabendefinition angegebenen Anforderungen an CPU, GPU, Arbeitsspeicher und Port erfüllen.

1. Identifizieren der Container-Instances, die die Einschränkungen der Aufgabenplatzierung erfüllen.

1. Identifizieren der Container-Instances, die die Aufgabenplatzierungsstrategien erfüllen.

1. Auswählen der Container-Instances für die Aufgabenplatzierung.

## Fargate
<a name="fargate-launch-type"></a>

Aufgabenplatzierungs-Strategien und -Beschränkungen werden für Aufgaben mit Fargate nicht unterstützt. Fargate wird sich bemühen, Aufgaben über zugängliche Availability Zones zu verteilen. Wenn der Kapazitätsanbieter sowohl Fargate als auch Fargate Spot umfasst, ist das Verteilungsverhalten für jeden Kapazitätsanbieter unabhängig. 

# Auto Scaling und Aufgabenplatzierung mit Amazon ECS Managed Instances
<a name="managed-instance-auto-scaling"></a>

Amazon ECS Managed Instances verwendet intelligente Algorithmen, um Ihre Cluster-Kapazität automatisch zu skalieren und Aufgaben effizient in Ihrer gesamten Infrastruktur zu verteilen. Wenn Sie wissen, wie diese Algorithmen funktionieren, können Sie Ihre Servicekonfigurationen optimieren und Fehler beim Platzierungsverhalten beheben.

## Aufgabenplatzierungs-Algorithmus
<a name="managed-instance-task-placement-algorithm"></a>

Amazon ECS Managed Instances verwendet einen ausgeklügelten Platzierungsalgorithmus, der Verfügbarkeit, Ressourcennutzung und Netzwerkanforderungen bei der Planung von Aufgaben in Einklang bringt.

### Verteilung auf Availability Zones
<a name="managed-instance-az-spread-behavior"></a>

Standardmäßig priorisiert Amazon ECS Managed Instances die Verfügbarkeit, indem Aufgaben auf mehrere Availability Zones verteilt werden:
+ Bei Services mit mehreren Aufgaben stellt Amazon ECS Managed Instances nach Möglichkeit die Verteilung auf mindestens 3 Instances in verschiedenen Availability Zones sicher.
+ Dieses Verhalten bietet Fehlertoleranz, kann jedoch zu einer geringeren Ressourcenauslastung pro Instance führen
+ Die Verteilung auf Availability Zones hat Vorrang vor der Optimierung von Bin Packing.

### Bin-Packing-Verhalten
<a name="managed-instance-bin-packing"></a>

Amazon ECS Managed Instances kann zwar Bin Packing durchführen, um die Ressourcennutzung zu maximieren, aber dieses Verhalten wird von Ihrer Netzwerkkonfiguration beeinflusst:
+ Um Bin-Packing zu erreichen, konfigurieren Sie Ihren Service so, dass er ein einzelnes Subnetz verwendet.
+ Bei Konfigurationen mit mehreren Subnetzen hat die Verteilung auf Availability Zones Vorrang vor der Ressourcendichte.
+ Beim ersten Start des Services ist das Bin-Packing wahrscheinlicher als bei Skalierungsereignissen.

### Überlegungen zur ENI-Dichte
<a name="managed-instance-eni-density"></a>

Bei Services, die den Netzwerkmodus `awsvpc` verwenden, berücksichtigt Amazon ECS Managed Instances bei Platzierungsentscheidungen die Dichte der Elastic-Network-Schnittstelle (ENI):
+ Für jede Aufgabe im `awsvpc`-Modus ist eine spezielle ENI erforderlich.
+ Instance-Typen haben unterschiedliche ENI-Grenzwerte, die sich auf die Aufgabendichte auswirken.
+ Amazon ECS Managed Instances berücksichtigt die ENI-Verfügbarkeit bei der Auswahl von Ziel-Instances

**Anmerkung**  
Die ENI-Dichteberechnungen werden kontinuierlich verbessert, um die Platzierungsentscheidungen zu optimieren.

## Entscheidungslogik für Kapazitätsanbieter
<a name="managed-instance-capacity-provider-decisions"></a>

Die Kapazitätsanbieter von Amazon ECS Managed Instances treffen Skalierungs- und Platzierungsentscheidungen auf der Grundlage mehrerer Faktoren:

Ressourcenanforderungen  
CPU-, Arbeitsspeicher- und Netzwerkanforderungen für ausstehende Aufgaben

Instance-Verfügbarkeit  
Aktuelle Kapazität und Auslastung der vorhandenen Instances

Netzwerkeinschränkungen  
Subnetzkonfiguration und ENI-Verfügbarkeit

Verteilung von Availability Zones  
Aufrechterhaltung der Fehlertoleranz über mehrere Availability Zones hinweg

## Konfigurationsoptionen
<a name="managed-instance-configuration-options"></a>

### Strategie zur Auswahl von Subnetzen
<a name="managed-instance-subnet-strategy"></a>

Ihre Subnetzkonfiguration wirkt sich erheblich auf das Verhalten bei der Aufgabenplatzierung aus:

Mehrere Subnetze (Standard)  
Priorisiert die Verteilung auf Availability Zones für hohe Verfügbarkeit  
Kann zu einer geringeren Ressourcennutzung pro Instance führen  
Empfohlen für Produktions-Workloads, die Fehlertoleranz erfordern

Einzelnes Subnetz  
Ermöglicht Bin-Packing für eine höhere Ressourcenauslastung  
Reduziert die Fehlertoleranz, indem Aufgaben auf eine Availability Zone konzentriert werden  
Geeignet für Entwicklungs- oder kostenoptimierte Workloads

### Überlegungen zum Netzwerkmodus
<a name="managed-instance-network-mode-considerations"></a>

Der von Ihnen gewählte Netzwerkmodus wirkt sich auf die Platzierungsentscheidungen aus:
+ `awsvpc`-Modus – Für jede Aufgabe ist eine eigene ENI erforderlich, wodurch die Aufgabendichte pro Instance begrenzt wird
+ `host`-Modus – Aufgaben nutzen das Netzwerk des Hosts direkt, wobei die Platzierung in erster Linie von der Ressourcenverfügbarkeit abhängt

### Überlegungen zur CPU-Architektur
<a name="managed-instance-cpu-architecture-considerations"></a>

Die `cpuArchitecture` Angaben, die Sie in Ihrer Aufgabendefinition angeben, werden verwendet, um Aufgaben auf einer bestimmten Architektur zu platzieren. Wenn Sie kein angeben, versucht Amazon ECS`cpuArchitecture`, Aufgaben auf jeder verfügbaren CPU-Architektur zu platzieren, die auf der Konfiguration des Kapazitätsanbieters basiert. Sie können entweder `X86_64` oder `ARM64` angeben.

## Fehlerbehebung bei der Aufgabenplatzierung
<a name="managed-instance-troubleshooting-placement"></a>

### Gängige Platzierungsmuster
<a name="managed-instance-common-placement-patterns"></a>

Wenn Sie die zu erwartenden Platzierungsmuster verstehen, können Sie normales Verhalten von potenziellen Problemen unterscheiden:

Verteilung  
Auf mehrere Instances verteilte Aufgaben mit teilweiser Auslastung  
Normales Verhalten bei der Verwendung mehrerer Subnetze  
Zeigt an, dass der Verfügbarkeit Vorrang vor der Ressourceneffizienz eingeräumt wird

Konzentrierte Platzierung  
Mehrere Aufgaben werden auf weniger Instances mit höherer Auslastung verteilt  
Wird erwartet, wenn eine Konfiguration mit einem einzigen Subnetz verwendet wird  
Kann beim ersten Start des Services auftreten

Ungleiche Verteilung  
Einige Instances werden stark ausgelastet, während andere nach wie vor zu wenig genutzt werden  
Kann auf ENI-Limits oder Ressourcenbeschränkungen hinweisen  
Erwägen Sie, die Instance-Typen und die Netzwerkkonfiguration zu überprüfen

### Optimierung des Platzierungsverhaltens
<a name="managed-instance-placement-optimization"></a>

So optimieren Sie die Aufgabenplatzierung für Ihre spezifischen Anforderungen:

1. Bewerten Sie Ihre Verfügbarkeitsanforderungen im Vergleich zu Ihren Anforderungen an die Kostenoptimierung.

1. Wählen Sie die passende Subnetzkonfiguration auf der Grundlage Ihrer Prioritäten.

1. Wählen Sie Instance-Typen mit ausreichender ENI-Kapazität für Ihren Netzwerkmodus.

1. Überwachen Sie die Platzierungsmuster und passen Sie die Konfiguration nach Bedarf an.

## Best Practices
<a name="managed-instance-best-practices"></a>
+ **Für Produktions-Workloads** – Verwenden Sie mehrere Subnetze in verschiedenen Availability Zones, um eine hohe Verfügbarkeit zu gewährleisten und nehmen Sie dabei Kompromisse bei der Ressourcennutzung in Kauf.
+ **Für Entwicklung oder Tests** – Ziehen Sie eine Konfiguration mit einem einzigen Subnetz in Betracht, um die Ressourcennutzung zu maximieren und den Preis zu senken.
+ **Für den `awsvpc`-Modus** – Wählen Sie Instance-Typen mit ausreichender ENI-Kapazität, um Platzierungsbeschränkungen zu vermeiden.
+ **Zur Kostenoptimierung** – Überwachen Sie die Nutzungsmuster und passen Sie die Servicekonfiguration an, um ein Gleichgewicht zwischen Verfügbarkeit und Effizienz zu finden.
+ **Zur Fehlerbehebung** – Überprüfen Sie die Subnetzkonfiguration und den Netzwerkmodus, wenn Sie unerwartete Platzierungsmuster untersuchen.

# Strategien zur Festlegung der Amazon-ECS-Aufgabenplatzierung verwenden
<a name="task-placement-strategies"></a>

Bei Aufgaben, die den EC2-Starttyp verwenden, muss Amazon ECS anhand der in der Aufgabendefinition angegebenen Anforderungen – beispielsweise CPU und Arbeitsspeicher – bestimmen, wo die Aufgabe platziert werden soll. Wenn Sie die Anzahl der Aufgaben herunterskalieren, muss Amazon ECS auf ähnliche Weise bestimmen, welche Aufgaben beendet werden sollen. Mit Aufgabenplatzierungsstrategien und -bedingungen können Sie festlegen, wie Amazon ECS Aufgaben platziert und beendet. 

Die Standardstrategien für die Aufgabenplatzierung hängen davon ab, ob Sie Aufgaben manuell (eigenständige Aufgaben) oder innerhalb eines Services ausführen. Für Aufgaben, die als Teil eines Amazon-ECS-Service ausgeführt werden, ist die Strategie zur Aufgabenplatzierung `spread` unter Verwendung von `attribute:ecs.availability-zone`. Es gibt keine Standardbeschränkung für die Aufgabenplatzierung für Aufgaben, die nicht in Services enthalten sind. Weitere Informationen finden Sie unter [Planen Sie Ihre Container in Amazon ECS](scheduling_tasks.md).

**Anmerkung**  
Aufgabenplatzierungsstrategien entsprechen bestem Bemühen. Amazon ECS versucht auch dann noch, Aufgaben zu platzieren, wenn die optimale Platzierungsoption nicht verfügbar ist. Einschränkungen der Aufgabenplatzierung sind jedoch verbindlich und können eine Aufgabenplatzierung verhindern. 

Sie können Aufgabenplatzierungsstrategien mit Bedingungen kombinieren. Beispielsweise können Sie eine Aufgabenplatzierungsstrategie und eine Aufgabenplatzierungsbeschränkung verwenden, um Aufgaben auf Availability Zones zu verteilen und Bin-Pack-Aufgaben basierend auf dem Arbeitsspeicher innerhalb jeder Availability Zone zu verteilen (jedoch nur für G2-Instances).

Wenn Amazon ECS Aufgaben platziert, verwendet es das folgende Verfahren zum Auswählen von Container-Instances:

1. Identifizieren der Container-Instances, die die in der Aufgabendefinition angegebenen Anforderungen an CPU, GPU, Arbeitsspeicher und Port erfüllen.

1. Identifizieren der Container-Instances, die die Einschränkungen der Aufgabenplatzierung erfüllen.

1. Identifizieren der Container-Instances, die die Aufgabenplatzierungsstrategien erfüllen.

1. Auswählen der Container-Instances für die Aufgabenplatzierung.

Sie geben Strategien zur Aufgabenplatzierung in der Servicedefinition oder der Aufgabendefinition mithilfe des Parameters `placementStrategy` an.

```
"placementStrategy": [
    {
        "field": "The field to apply the placement strategy against",
        "type": "The placement strategy to use"
    }
]
```

Sie können die Strategien angeben, wenn Sie eine Aufgabe ausführen ([RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)), einen neuen Service erstellen ([CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)) oder einen vorhandenen Service aktualisieren ([UpdateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html)).

Die folgende Tabelle beschreibt die verfügbaren Typen und Felder.


| type | Zulässige Feldwerte | 
| --- | --- | 
| binpack Aufgaben werden auf Container-Instances platziert, um so wenig ungenutzten CPU- oder Arbeitsspeicherplatz wie möglich zu belassen. Diese Strategie minimiert die Anzahl der verwendeten Container-Instances. Wenn diese Strategie verwendet wird und eine Abskalierungs-Aktion durchgeführt wird, beendet Amazon ECS Aufgaben. Es tut dies basierend auf der Menge der Ressourcen, die nach dem Beenden der Aufgabe in der Container-Instance verbleiben. Die Container-Instance, die nach der Beendigung der Aufgabe die meisten verfügbaren Ressourcen hat, veranlasst die Beendigung dieser Aufgabe. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/task-placement-strategies.html)  | 
| random Aufgaben werden nach dem Zufallsprinzip platziert. | Nicht verwendet | 
| spreadAufgaben werden gleichmäßig basierend auf dem angegebenen Wert platziert. Service-Aufgaben werden basierend auf den Aufgaben von diesem Service verteilt. Eigenständige Aufgaben werden basierend auf den Aufgaben derselben Aufgabengruppe verteilt. Weitere Informationen über Aufgabengruppen finden Sie unter [Gruppenbezogene Amazon-ECS-Aufgaben](task-groups.md). Wenn die `spread`-Strategie verwendet wird und eine Abskalierungs-Aktion durchgeführt wird, wählt Amazon ECS Aufgaben zum Beenden aus, die ein Gleichgewicht über Availability Zones aufrechterhalten. Innerhalb einer Availability Zone werden Aufgaben nach dem Zufallsprinzip ausgewählt. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/task-placement-strategies.html)  | 

Die Aufgabenplatzierungsstrategien können auch für bestehende Services aktualisiert werden. Weitere Informationen finden Sie unter [So platziert Amazon ECS Aufgaben in Container-Instances](task-placement.md).

Sie können eine Strategie zur Aufgabenverteilung erstellen, die mehrere Strategien verwendet, indem Sie Arrays von Strategien in der Reihenfolge erstellen, in der sie ausgeführt werden sollen. Wenn Sie beispielsweise Aufgaben auf Availability Zones und anschließend mit der Binpacks-Strategie basierend auf dem Speicher innerhalb der einzelnen Availability Zone platzieren möchten, geben Sie die Availability-Zone-Strategie gefolgt von der Speicherstrategie an. Beispielstrategien finden Sie unter [Beispielsstrategien für die Amazon-ECS-Aufgabenplatzierung](strategy-examples.md).

# Beispielsstrategien für die Amazon-ECS-Aufgabenplatzierung
<a name="strategy-examples"></a>

Sie können Strategien zur Aufgabenplatzierung mit den folgenden Aktionen angeben: [CreateService[UpdateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html)](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html), und [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).

**Topics**
+ [Gleichmäßiges Verteilen von Aufgaben auf Availability Zones](#even-az)
+ [Gleichmäßiges Verteilen von Aufgaben auf alle Instances](#even-instance)
+ [Binpacks-Aufgaben basierend auf dem Speicher](#binpack)
+ [Zufälliges Platzieren von Aufgaben](#random)
+ [Verteilen Sie die Aufgaben gleichmäßig über die Availability Zones und verteilen Sie sie dann gleichmäßig auf die Instances innerhalb jeder Availability Zone](#az-instance)
+ [Verteilen Sie Aufgaben gleichmäßig auf Availability Zones und anschließend mit der Binpack-Strategie basierend auf dem Speicher innerhalb jeder Availability Zone](#az-memory)
+ [Gleichmäßige Verteilung der Aufgaben auf die Instances, woraufhin Aufgaben auf der Grundlage des Speichers zu Bin-Packs zugeordnet werden](#instance-memory)

## Gleichmäßiges Verteilen von Aufgaben auf Availability Zones
<a name="even-az"></a>

Mit der folgenden Strategie werden Aufgaben gleichmäßig auf Availability Zones verteilt.

```
"placementStrategy": [
    {
        "field": "attribute:ecs.availability-zone",
        "type": "spread"
    }
]
```

## Gleichmäßiges Verteilen von Aufgaben auf alle Instances
<a name="even-instance"></a>

Mit der folgenden Strategie werden Aufgaben gleichmäßig auf alle Instances verteilt.

```
"placementStrategy": [
    {
        "field": "instanceId",
        "type": "spread"
    }
]
```

## Binpacks-Aufgaben basierend auf dem Speicher
<a name="binpack"></a>

Mit der folgenden Strategie werden Binpack-Aufgaben basierend auf dem Speicherplatz erstellt.

```
"placementStrategy": [
    {
        "field": "memory",
        "type": "binpack"
    }
]
```

## Zufälliges Platzieren von Aufgaben
<a name="random"></a>

Mit der folgenden Strategie werden Aufgaben zufällig platziert.

```
"placementStrategy": [
    {
        "type": "random"
    }
]
```

## Verteilen Sie die Aufgaben gleichmäßig über die Availability Zones und verteilen Sie sie dann gleichmäßig auf die Instances innerhalb jeder Availability Zone
<a name="az-instance"></a>

Mit der folgenden Strategie werden Aufgaben gleichmäßig auf Availability Zones und anschließend gleichmäßig auf die Instances innerhalb der einzelnen Availability Zone verteilt.

```
"placementStrategy": [
    {
        "field": "attribute:ecs.availability-zone",
        "type": "spread"
    },
    {
        "field": "instanceId",
        "type": "spread"
    }
]
```

## Verteilen Sie Aufgaben gleichmäßig auf Availability Zones und anschließend mit der Binpack-Strategie basierend auf dem Speicher innerhalb jeder Availability Zone
<a name="az-memory"></a>

Mit der folgenden Strategie werden Aufgaben gleichmäßig auf Availability Zones und anschließend mit der Binpack-Strategie basierend auf dem Speicher innerhalb der einzelnen Availability Zone platziert.

```
"placementStrategy": [
    {
        "field": "attribute:ecs.availability-zone",
        "type": "spread"
    },
    {
        "field": "memory",
        "type": "binpack"
    }
]
```

## Gleichmäßige Verteilung der Aufgaben auf die Instances, woraufhin Aufgaben auf der Grundlage des Speichers zu Bin-Packs zugeordnet werden
<a name="instance-memory"></a>

Mit der folgenden Strategie werden Aufgaben gleichmäßig auf alle Instances und anschließend mit der Binpacks-Strategie basierend auf dem Speicher innerhalb der einzelnen Instance platziert. 

```
"placementStrategy": [
    {
        "field": "instanceId",
        "type": "spread"
    },
    {
        "field": "memory",
        "type": "binpack"
    }
]
```

# Gruppenbezogene Amazon-ECS-Aufgaben
<a name="task-groups"></a>

Sie können eine Reihe verwandter Aufgaben identifizieren und sie einer Aufgabengruppe zuordnen. Alle Aufgaben mit demselben Aufgabengruppennamen werden bei der Aufgabenplatzierungsstrategie mit `spread` als Satz betrachtet. Nehmen wir zum Beispiel an, dass Sie verschiedene Anwendungen in einem Cluster ausführen, beispielsweise Datenbanken und Webserver. Um sicherzustellen, dass Ihre Datenbanken gleichmäßig auf die Availability Zones verteilt sind, fügen Sie sie zu einer Aufgabengruppe mit der Bezeichnung `databases` hinzu und verwenden Sie anschließend die `spread`-Aufgabenplatzierungsstrategie. Weitere Informationen finden Sie unter [Strategien zur Festlegung der Amazon-ECS-Aufgabenplatzierung verwenden](task-placement-strategies.md).

Aufgabengruppen können auch als Einschränkung für die Aufgabenplatzierung verwendet werden. Wenn Sie eine Aufgabengruppe in der `memberOf`-Einschränkung angeben, werden die Aufgaben nur an Container-Instances gesendet, die sich in der angegebenen Aufgabengruppe befinden. Ein Beispiel finden Sie unter [Beispiel für Amazon-ECS-Aufgabenplatzierungsbeschränkungen](constraint-examples.md).

Standardmäßig verwenden eigenständige Aufgaben den Familiennamen der Aufgabendefinition (z. B. `family:my-task-definition`) als Aufgabengruppen-Namen, wenn kein benutzerdefinierter Aufgabengruppen-Name angegeben ist. Aufgaben, die als Teil eines Dienstes gestartet werden, verwenden den Dienstnamen als Aufgabengruppenname und können nicht geändert werden.

Es gelten die folgenden Anforderungen an die Aufgabengruppe.
+ Ein Aufgabengruppen-Name darf höchstens 255 Zeichen lang sein.
+ Jede Aufgabe kann nur einer Gruppe zugeordnet werden.
+ Nach dem Launchen einer Aufgabe können Sie deren Aufgabengruppe nicht modifizieren.

# Definieren der Container-Instances, die Amazon ECS für Aufgaben verwendet
<a name="task-placement-constraints"></a>

Eine Aufgabenplatzierungsbeschränkung ist eine Regel für eine Container-Instance, anhand derer Amazon ECS bestimmt, ob die Aufgabe auf der Instance ausgeführt werden darf. Mindestens eine Container-Instance muss der Einschränkung entsprechen. Wenn es keine Instances gibt, die der Einschränkung entsprechen, verbleibt die Aufgabe im Status `PENDING`. Wenn Sie einen neuen Service erstellen oder einen vorhandenen aktualisieren, können Sie Einschränkungen bei der Aufgabenplatzierung für die Aufgaben des Services angeben. 

Sie geben Aufgabenplatzierungsbeschränkungen in der Servicedefinition oder der Aufgabendefinition mithilfe des Parameters `placementConstraint` an.

```
"placementConstraints": [
    {
        "expression": "The expression that defines the task placement constraints",
        "type": "The placement constraint type to use"
    }
]
```

Die folgende Tabelle beschreibt die Verwendung dieser Parameter.


| Einschränkungstypen | Kann angegeben werden, wann | 
| --- | --- | 
| distinctInstancePlatzieren Sie jede Aufgabe auf einer anderen Container-Instance.Amazon ECS prüft den gewünschten Status der Aufgaben für die Aufgabenplatzierung. Wenn beispielsweise der gewünschte Status der vorhandenen Aufgabe `STOPPED` lautet (der letzte Status jedoch nicht), kann eine neue eingehende Aufgabe trotz der Platzierungsbeschränkung `distinctInstance` derselben Instance zugewiesen werden. Daher werden Ihnen möglicherweise zwei Aufgaben mit dem letzten Status `RUNNING` auf derselben Instance angezeigt. Wir empfehlen Kunden, die für ihre Aufgaben eine starke Isolierung suchen, Fargate zu verwenden. Fargate führt jede Aufgabe in einer Hardware-Virtualisierungsumgebung aus. Workloads, die auf Fargate ausgeführt werden, teilen sich keine Netzwerkschnittstellen, flüchtigen Fargate-Speicher, CPU oder Arbeitsspeicher mit anderen Aufgaben. Weitere Informationen finden Sie unter [Sicherheitsüberblick von AWS Fargate](https://d1.awsstatic.com/whitepapers/AWS_Fargate_Security_Overview_Whitepaper.pdf). |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/task-placement-constraints.html)  | 
| memberOfPlatzierung von Aufgaben auf Container-Instances, die einem Ausdruck entsprechen.  | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/task-placement-constraints.html) | 

Wenn Sie den Einschränkungstyp `memberOf` verwenden, können Sie mithilfe der Cluster-Abfragesprache einen Ausdruck erstellen, der die Container-Instances definiert, in denen Amazon ECS Aufgaben platzieren kann. Mit dem Ausdruck können Sie Ihre Container-Instances nach Attributen gruppieren. Der Ausdruck gehört zum `expression `-Parameter von `placementConstraint`.

## Attribute von Amazon-ECS-Container-Instances
<a name="attributes"></a>

Sie können zu Ihren Container-Instances benutzerdefinierte Metadaten hinzufügen, die als *Attribute* bezeichnet werden. Jedes Attribut hat einen Namen und einen optionalen Zeichenfolgenwert. Sie können die von Amazon ECS vergebenen Attribute verwenden oder benutzerdefinierte Attribute erstellen.

Die folgenden Abschnitte enthalten Beispiele für integrierte, optionale und benutzerdefinierte Attribute.

### Integrierte Attribute
<a name="ecs-automatic-attributes"></a>

Amazon ECS wendet automatisch die folgenden Attribute auf Ihre Container-Instances an.

`ecs.ami-id`  
Die ID des zum Start der Instance verwendeten AMI. Ein Beispielwert für dieses Attribut ist `ami-1234abcd`.

`ecs.availability-zone`  
Die Availability Zone für die Instance. Ein Beispielwert für dieses Attribut ist `us-east-1a`.

`ecs.instance-type`  
Den Instance-Typ für die Instance. Ein Beispielwert für dieses Attribut ist `g2.2xlarge`.

`ecs.os-type`  
Das Betriebssystem für die Instance. Die möglichen Werte für dieses Attribut sind `linux` und `windows`.

`ecs.os-family`  
Die Betriebssystemversion für die Instance.  
Für Linux-Instances ist der gültige Wert `LINUX`. Für Windows-Instances legt ECS den Wert im Format `WINDOWS_SERVER_<OS_Release>_<FULL or CORE>` fest. Die gültigen Werte sind `WINDOWS_SERVER_2022_FULL`, `WINDOWS_SERVER_2022_CORE`, `WINDOWS_SERVER_20H2_CORE`, `WINDOWS_SERVER_2019_FULL`, `WINDOWS_SERVER_2019_CORE` und `WINDOWS_SERVER_2016_FULL`.  
Dies ist wichtig für Windows-Container und Windows containers on AWS Fargate weil die Betriebssystemversion jedes Windows-Containers mit der des Hosts übereinstimmen muss. Wenn sich die Windows-Version des Container-Images von der des Hosts unterscheidet, startet der Container nicht. Weitere Informationen finden Sie unter [Kompatibilität mit Windows-Containern](https://learn.microsoft.com/en-us/virtualization/windowscontainers/deploy-containers/version-compatibility?tabs=windows-server-2022%2Cwindows-11) auf der Microsoft-Dokumentations-Website.  
Wenn auf Ihrem Cluster mehrere Windows-Versionen ausgeführt werden, können Sie mithilfe der Platzierungsbeschränkung `memberOf(attribute:ecs.os-family == WINDOWS_SERVER_<OS_Release>_<FULL or CORE>)` sicherstellen, dass eine Aufgabe auf einer EC2-Instance platziert wird, die auf derselben Version ausgeführt wird. Weitere Informationen finden Sie unter [Abrufen der Amazon-ECS-optimierten Windows-AMI-Metadaten](retrieve-ecs-optimized_windows_AMI.md).

`ecs.cpu-architecture`  
Die CPU-Architektur für die Instance. Beispielwerte für dieses Attribut sind `x86_64` und `arm64`.

`ecs.vpc-id`  
Die VPC, in der die Instance gestartet wurde. Ein Beispielwert für dieses Attribut ist `vpc-1234abcd`.

`ecs.subnet-id`  
Das Subnetz, das die Instance verwendet. Ein Beispielwert für dieses Attribut ist `subnet-1234abcd`.

**Anmerkung**  
Amazon ECS Managed Instances unterstützt die folgende Teilmenge von Attributen:  
`ecs.subnet-id`
`ecs.availability-zone`
`ecs.instance-type`
`ecs.cpu-architecture`

### Optionale Attribute
<a name="ecs-optional-attributes"></a>

Amazon ECS kann die folgenden Attribute zu Ihren Container-Instances hinzufügen.

`ecs.awsvpc-trunk-id`  
Wenn dieses Attribut vorhanden ist, verfügt die Instance über eine Trunk-Netzwerkschnittstelle. Weitere Informationen finden Sie unter [Erhöhung der Netzwerkschnittstellen für Linux-Container-Instances von Amazon ECS](container-instance-eni.md).

`ecs.outpost-arn`  
Wenn dieses Attribut existiert, enthält es den Amazon-Ressourcennamen (ARN) des Outpost. Weitere Informationen finden Sie unter [Amazon Elastic Container Service auf AWS Outposts](using-outposts.md).

`ecs.capability.external`  
Wenn dieses Attribut vorhanden ist, wird die Instance als externe Instance identifiziert. Weitere Informationen finden Sie unter [Amazon-ECS-Cluster für externe Instances](ecs-anywhere.md).

### Benutzerdefinierte Attribute
<a name="ecs-custom-attributes"></a>

Sie können benutzerdefinierte Attribute für Ihre Container-Instances festlegen. Beispielsweise können Sie ein Attribut mit dem Namen „stack“ und dem Wert „prod“ definieren.

Bei der Angabe benutzerdefinierter Attribute sollte Folgendes berücksichtigt werden.
+ `name` muss zwischen 1 und 128 Zeichen sein und Name kann Buchstaben (Groß- und Kleinbuchstaben), Ziffern, Bindestriche, Unterstriche, Schrägstriche, Gegenschrägstriche oder Punkte enthalten.
+ `value` muss zwischen 1 und 128 Zeichen sein und Buchstaben (Groß- und Kleinbuchstaben), Ziffern, Bindestriche, Unterstriche, Punkte, At-Zeichen (@), Schrägstriche, Gegenschrägstriche, Doppelpunkte oder Leerzeichen enthalten. Der Wert darf keine führenden oder nachgestellten Leerzeichen enthalten.

# Ausdrücke erstellen, um Container-Instances für Amazon-ECS-Aufgaben zu definieren
<a name="cluster-query-language"></a>

Cluster-Abfragen sind Ausdrücke, die Ihnen das Gruppieren von Objekten ermöglichen. Beispielsweise können Sie Container-Instances nach Attributen gruppieren, z. B. Availability Zone, Instance-Typ oder benutzerdefinierte Metadaten. Weitere Informationen finden Sie unter [Attribute von Amazon-ECS-Container-Instances](task-placement-constraints.md#attributes).

Nachdem Sie eine Gruppe von Container-Instances definiert haben, können Sie Amazon ECS so anpassen, dass Aufgaben basierend auf der Gruppe auf Container-Instances platziert werden. Weitere Informationen finden Sie unter [Ausführen einer Anwendung als Amazon-ECS-Aufgabe](standalone-task-create.md) und [Erstellung einer Amazon-ECS-Bereitstellung mit fortlaufender Aktualisierung](create-service-console-v2.md). Sie können bei der Auflistung von Container-Instances auch einen Gruppenfilter anwenden.

## Ausdruck-Syntax
<a name="expression-syntax"></a>

Ausdrücke haben die folgende Syntax:

```
subject operator [argument]
```

**Betreff**  
Das auszuwertende Attribut oder Feld.

`agentConnected`  
Wählen Sie Container-Instances anhand des Verbindungsstatus ihres Amazon-ECS-Container-Agenten aus. Mithilfe dieses Filters können Sie nach Instances mit getrennten Container-Agenten suchen.  
Gültige Operatoren: equals (==), not\$1equals (\$1=), in, not\$1in (\$1in), matches (=\$1), not\$1matches (\$1\$1)

`agentVersion`  
Wählen Sie Container-Instances anhand der Version ihres Amazon-ECS-Container-Agenten aus. Mithilfe dieses Filters können Sie Instances suchen, auf denen veraltete Versionen des Amazon-ECS-Container-Agenten ausgeführt werden.  
Gültige Operatoren: equals (==), not\$1equals (\$1=), greater\$1than (>), greater\$1than\$1equal (>=), less\$1than (<), less\$1than\$1equal (<=)

`attribute:attribute-name`  
Wählen Sie Container-Instances nach Attribut aus. Weitere Informationen finden Sie unter [Attribute von Amazon-ECS-Container-Instances](task-placement-constraints.md#attributes).

`ec2InstanceId`  
Wählen Sie Container-Instances nach ihrer Amazon-EC2-Instance-ID aus.  
Gültige Operatoren: equals (==), not\$1equals (\$1=), in, not\$1in (\$1in), matches (=\$1), not\$1matches (\$1\$1)

`registeredAt`  
Wählen Sie Container-Instances nach ihrem Registrierungsdatum aus. Mithilfe dieses Filters können Sie neu registrierte Instances oder sehr alte Instances finden.  
Gültige Operatoren: equals (==), not\$1equals (\$1=), greater\$1than (>), greater\$1than\$1equal (>=), less\$1than (<), less\$1than\$1equal (<=)  
Gültige Datumsformate: 2018-06-18T22:28:28\$100:00, 2018-06-18T22:28:28Z, 2018-06-18T22:28:28, 2018-06-18

`runningTasksCount`  
Wählen Sie Container-Instances nach der Anzahl der ausgeführten Aufgaben aus. Mithilfe dieses Filters können Sie Instances finden, die leer oder nahezu leer sind, auf denen also wenige Aufgaben ausgeführt werden.  
Gültige Operatoren: equals (==), not\$1equals (\$1=), greater\$1than (>), greater\$1than\$1equal (>=), less\$1than (<), less\$1than\$1equal (<=)

`task:group`  
Wählen Sie Container-Instances nach Aufgabengruppe aus. Weitere Informationen finden Sie unter [Gruppenbezogene Amazon-ECS-Aufgaben](task-groups.md).

**Operator**  
Der Vergleichsoperator. Folgende Operatoren werden unterstützt.


|  Operator  |  Description  | 
| --- | --- | 
|  ==, equals  |  Zeichenfolgen-Übereinstimmung  | 
|  \$1=, not\$1equals  |  Keine Zeichenfolgen-Übereinstimmung  | 
|  >, greater\$1than  |  größer als  | 
|  >=, greater\$1than\$1equal  |  größer als oder gleich  | 
|  <, less\$1than  |  kleiner als  | 
|  <=, less\$1than\$1equal  |  kleiner als oder gleich  | 
|  exists  |  Subjekt ist vorhanden  | 
|  \$1exists, not\$1exists  |  Subjekt ist nicht vorhanden  | 
|  in  |  Wert in Argumentliste enthalten  | 
|  \$1in, not\$1in  |  Wert nicht in Argumentliste enthalten  | 
|  =\$1, matches  |  Muster-Übereinstimmung  | 
|  \$1\$1, not\$1matches  |  Keine Muster-Übereinstimmung  | 

**Anmerkung**  
Ein einzelner Ausdruck kann keine Klammern enthalten. Klammern können jedoch in zusammengesetzten Ausdrücken verwendet werden, um eine Rangfolge anzugeben.

**Argument**  
Bei vielen Operatoren ist das Argument ein Literalwert.

Die Operatoren `in` und `not_in` setzen eine Argumentliste als Argument voraus. Geben Sie eine Argumentliste wie folgt an:

```
[argument1, argument2, ..., argumentN]
```

Die Operatoren „matches“ und „not\$1matches“ setzen ein Argument voraus, das die reguläre Java-Ausdrucksyntax erfüllt. Weitere Informationen finden Sie unter [java.util.regex.Pattern](http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html).

**Zusammengesetzte Ausdrücke**

Sie können Ausdrücke mit den folgenden booleschen Operatoren miteinander kombinieren:
+ &&, und
+ \$1\$1, oder
+ \$1, nicht

Sie können Klammern verwenden, um eine Rangfolge anzugeben:

```
(expression1 or expression2) and expression3
```

## Beispiel-Ausdrücke
<a name="expression-examples"></a>

Es folgen Beispiel-Ausdrücke.

**Beispiel: Zeichenfolgen-Übereinstimmung**  
Mit dem folgenden Ausdruck werden Instances des angegebenen Instance-Typs ausgewählt.

```
attribute:ecs.instance-type == t2.small
```

**Beispiel: Argumentliste**  
Mit dem folgenden Ausdruck werden Instances in der Availability Zone us-east-1a oder us-east-1b ausgewählt.

```
attribute:ecs.availability-zone in [us-east-1a, us-east-1b]
```

**Beispiel: zusammengesetzter Ausdruck**  
Mit dem folgenden Ausdruck werden G2-Instances ausgewählt, die nicht in der Availability Zone us-east-1d enthalten sind.

```
attribute:ecs.instance-type =~ g2.* and attribute:ecs.availability-zone != us-east-1d
```

**Beispiel: Aufgaben-Affinität**  
Mit dem folgenden Ausdruck werden Instances ausgewählt, die Aufgaben in der Gruppe `service:production` hosten.

```
task:group == service:production
```

**Beispiel: Aufgaben-Anti-Affinität**  
Mit dem folgenden Ausdruck werden Instances ausgewählt, die keine Aufgaben in der Datenbankgruppe hosten.

```
not(task:group == database)
```

**Beispiel: Anzahl der ausgeführten Aufgaben**  
Mit dem folgenden Ausdruck werden Instances ausgewählt, auf denen nur eine Aufgabe ausgeführt wird.

```
runningTasksCount == 1
```

**Beispiel: Amazon-ECS-Container-Agent-Version**  
Mit dem folgenden Ausdruck werden Instances ausgewählt, auf denen eine Container-Agenten-Version unter Version 1.14.5 ausgeführt wird.

```
agentVersion < 1.14.5
```

**Beispiel: Zeitpunkt der Instance-Registrierung**  
Mit dem folgenden Ausdruck werden Instances ausgewählt, die vor dem 13. Februar 2018 registriert wurden.

```
registeredAt < 2018-02-13
```

**Beispiel: ID der Amazon-EC2-Instance**  
Der folgende Ausdruck wählt Instances mit der folgenden Amazon EC2 EC2-Instance IDs aus.

```
ec2InstanceId in ['i-abcd1234', 'i-wxyx7890']
```

# Beispiel für Amazon-ECS-Aufgabenplatzierungsbeschränkungen
<a name="constraint-examples"></a>

Nachfolgend finden Sie Beispiele für Aufgabenplatzierungsbedingungen.

In diesem Beispiel wird die Beschränkung `memberOf` verwendet, um Aufgaben in T2-Instances zu platzieren. Er kann mit den folgenden Aktionen angegeben werden: [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html), [UpdateService[RegisterTaskDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RegisterTaskDefinition.html)](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html), und [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).

```
"placementConstraints": [
    {
        "expression": "attribute:ecs.instance-type =~ t2.*",
        "type": "memberOf"
    }
]
```

Das Beispiel verwendet die Einschränkung `memberOf`, um Replikataufgaben auf Instances mit Aufgaben in der `daemon-service`-Aufgabengruppe des Daemon-Service zu platzieren, wobei alle ebenfalls angegebenen Strategien zur Aufgabenplatzierung berücksichtigt werden. Diese Einschränkung stellt sicher, dass die Daemon-Serviceaufgaben vor den Replikatserviceaufgaben auf der EC2-Instance platziert werden.

Ersetzen Sie `daemon-service` durch den Namen des Daemon-Services.

```
"placementConstraints": [
    {
        "expression": "task:group == service:daemon-service",
        "type": "memberOf"
    }
]
```

In dem Beispiel wird die `memberOf`-Bedingung verwendet, um Aufgaben in Instances mit anderen Aufgaben in der `databases`-Aufgabengruppe unter Beachtung aller ebenfalls angegebenen Strategien zur Aufgaben-Platzierung zu platzieren. Weitere Informationen über Aufgabengruppen finden Sie unter [Gruppenbezogene Amazon-ECS-Aufgaben](task-groups.md). Es kann mit den folgenden Aktionen angegeben werden: [CreateService[UpdateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html)](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html), [RegisterTaskDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RegisterTaskDefinition.html), und [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).

```
"placementConstraints": [
    {
        "expression": "task:group == databases",
        "type": "memberOf"
    }
]
```

Mit der Bedingung `distinctInstance` wird jede Aufgabe in der Gruppe auf einer anderen Instance platziert. Es kann mit den folgenden Aktionen angegeben werden: [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html), [UpdateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html), und [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)

Amazon ECS prüft den gewünschten Status der Aufgaben für die Aufgabenplatzierung. Wenn beispielsweise der gewünschte Status der vorhandenen Aufgabe `STOPPED` lautet (der letzte Status jedoch nicht), kann eine neue eingehende Aufgabe trotz der Platzierungsbeschränkung `distinctInstance` derselben Instance zugewiesen werden. Daher werden Ihnen möglicherweise zwei Aufgaben mit dem letzten Status `RUNNING` auf derselben Instance angezeigt.

```
"placementConstraints": [
    {
        "type": "distinctInstance"
    }
]
```