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. # Wählen Sie den Parallelitätsmodus für CloudFormation StackSets **Der Parallelitätsmodus** ist ein Parameter, mit dem Sie auswählen können [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_StackSetOperationPreferences.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_StackSetOperationPreferences.html), wie sich die Parallelitätsebene während des Betriebs verhält. StackSet Dabei haben Sie die Wahl zwischen den folgenden Modi: + **Strikte Fehlertoleranz**: Diese Option senkt den Umfang der Parallelität dynamisch, damit die Anzahl der fehlerhaften Konten niemals den Wert der **Fehlertoleranz** \$11 überschreitet. Die anfängliche tatsächliche Parallelität wird auf den Wert der Option **Maximale Anzahl gleichzeitiger Konten** oder auf den Wert der **Fehlertoleranz** \$11 festgelegt (je nachdem, welcher niedriger ist). Die tatsächliche Parallelität wird dann proportional zur Anzahl der Fehler reduziert. Dies ist das Standardverhalten. + **Lose Fehlertoleranz**: Diese Option entkoppelt die **Fehlertoleranz** von der tatsächlichen Parallelität. Dadurch können StackSet Operationen unabhängig von der Anzahl der Fehler auf der Parallelitätsebene ausgeführt werden, die durch den Wert „**Maximale Anzahl gleichzeitiger Konten**“ festgelegt ist. **Strict Failure Tolerance** senkt die Bereitstellungsgeschwindigkeit, wenn StackSet Betriebsfehler auftreten, da die Parallelität mit jedem Fehler abnimmt. **Soft Failure Tolerance** priorisiert die Geschwindigkeit der Bereitstellung und nutzt CloudFormation gleichzeitig die Sicherheitsfunktionen. Auf diese Weise können Sie StackSet Betriebsfehler im Hinblick auf häufig auftretende Probleme überprüfen und beheben, z. B. Probleme im Zusammenhang mit vorhandenen Ressourcen, Dienstkontingenten und Berechtigungen. Weitere Informationen zu Fehlern bei StackSets Stack-Vorgängen finden Sie unter[Häufige Gründe für Störungen der Stack-Operationen](stacksets-troubleshooting.md#common-reasons-for-stack-operation-failure). Weitere Informationen zu den Optionen **Maximale Anzahl gleichzeitiger Konten** und **Fehlertoleranz** finden Sie unter [StackSet Operationsoptionen](stacksets-concepts.md#stackset-ops-options). ## So funktionieren die einzelnen Parallelitätsmodi Die folgenden Bilder zeigen visuell, wie die einzelnen **Parallelitätsmodi** während eines StackSet Vorgangs funktionieren. Die Knotenfolge stellt eine Bereitstellung für einen einzelnen Knoten dar, AWS-Region und jeder Knoten ist ein Ziel AWS-Konto. **Strikte Fehlertoleranz** Wenn bei einem StackSet Vorgang, der **Strict Failure Tolerance** verwendet, der Wert für die **Fehlertoleranz** auf 5 und der Wert für die **maximale Anzahl gleichzeitiger Konten** auf 10 festgelegt ist, ist die tatsächliche Parallelität 6. Die tatsächliche Parallelität beträgt 6, da der Wert der **Fehlertoleranz** von 5 \$11 niedriger ist als der Wert für **Maximale Anzahl gleichzeitiger Konten**. Die folgende Abbildung zeigt die Auswirkungen, die der Wert für die **Fehlertoleranz** auf den Wert „**Maximale Anzahl gleichzeitiger Konten**“ hat, und zeigt, wie sich beide Werte auf die tatsächliche Parallelität des Vorgangs auswirken: StackSet ![\[Ein StackSet Vorgang mit strikter Fehlertoleranz. Die Fehlertoleranz ist 5, die maximale Anzahl gleichzeitiger Konten ist 10 und die Gleichzeitigkeit ist 6.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-strict-failure-tolerance-1.png) Wenn die Bereitstellung beginnt und es fehlerhafte Stack-Instances gibt, verringert sich die tatsächliche Parallelität, um eine sichere Bereitstellung zu gewährleisten. Die tatsächliche Parallelität reduziert sich von 6 auf 5, wenn 1 Stack-Instance StackSets nicht bereitgestellt werden kann. ![\[Bei dem StackSet Vorgang, bei dem Strict Failure Tolerance verwendet wurde, gab es zwei erfolgreiche Bereitstellungen und einen Fehler.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-strict-failure-tolerance-2.png) ![\[Der StackSet Vorgang, bei dem Strict Failure Tolerance verwendet wurde, hat die tatsächliche Parallelität auf 5 reduziert, da nun ein Fehler aufgetreten ist.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-strict-failure-tolerance-3.png) Der Modus **Strikte Fehlertoleranz** verringert die tatsächliche Parallelität proportional zur Anzahl der fehlerhaften Stack-Instances. Im folgenden Beispiel wird die tatsächliche Parallelität von 5 auf 3 reduziert, wenn 2 weitere Stack-Instances StackSets nicht bereitgestellt werden können, wodurch sich die Gesamtzahl der ausgefallenen Stack-Instances auf 3 erhöht. ![\[Bei dem StackSet Vorgang, bei dem Strict Failure Tolerance verwendet wurde, sind jetzt 3 Bereitstellungen fehlgeschlagen. Die Gleichzeitigkeit hat sich auf 3 reduziert.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-strict-failure-tolerance-4.png) StackSets schlägt beim StackSet Vorgang fehl, wenn die Anzahl der ausgefallenen Stack-Instances dem definierten Wert für die **Fehlertoleranz \$11** entspricht. Im folgenden Beispiel StackSets schlägt der Vorgang fehl, wenn es 6 ausgefallene Stack-Instances gibt und der **Fehlertoleranzwert** 5 ist. ![\[Bei dem StackSet Vorgang, bei dem Strict Failure Tolerance verwendet wurde, sind jetzt 6 Bereitstellungen fehlgeschlagen. Der StackSet Vorgang schlägt fehl.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-strict-failure-tolerance-5.png) In diesem Beispiel CloudFormation wurden 9 Stack-Instances (3 erfolgreich und 6 gescheitert) bereitgestellt, bevor der StackSet Vorgang gestoppt wurde. **Lose Fehlertoleranz** Wenn bei einem StackSet Vorgang, der **Soft Failure Tolerance** verwendet, der **Fehlertoleranzwert** auf 5 und der Wert für **maximale Anzahl gleichzeitiger Konten** auf 10 festgelegt ist, ist die tatsächliche Parallelität 10. ![\[Ein StackSet Vorgang mit Soft Failure Tolerance. Die Fehlertoleranz beträgt maximal 5 gleichzeitige Konten und die tatsächliche Gleichzeitigkeit beträgt 10.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-soft-failure-tolerance-1.png) Wenn die Bereitstellung beginnt und es fehlerhafte Stack-Instances gibt, ändert sich die tatsächliche Parallelität nicht. Im folgenden Beispiel ist 1 Stack-Vorgang fehlgeschlagen, die tatsächliche Parallelität bleibt jedoch bei 10. ![\[Bei der StackSet Operation mit Soft Failure Tolerance tritt der erste Fehler auf. Die tatsächliche Gleichzeitigkeit bleibt bei 10.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-soft-failure-tolerance-2.png) Die tatsächliche Parallelität bleibt auch nach 2 weiteren Stack-Instance-Fehlern bei 10. ![\[Der StackSet Vorgang mit Soft Failure Tolerance hat jetzt 2 Erfolge und 3 Fehlschläge, aber die tatsächliche Parallelität beträgt immer noch 10.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-soft-failure-tolerance-3.png) StackSets schlägt beim StackSet Vorgang fehl, wenn ausgefallene Stack-Instances den **Fehlertoleranzwert** überschreiten. Im folgenden Beispiel StackSets schlägt der Vorgang fehl, wenn 6 ausgefallene Stack-Instances vorhanden sind und die Anzahl der **Fehlertoleranz** 5 beträgt. Der Vorgang wird jedoch erst beendet, wenn die restlichen Vorgänge in der Parallelitätswarteschlange abgeschlossen sind. ![\[Der StackSet Vorgang mit Soft Failure Tolerance erreicht 6 Fehler, aber er muss den Rest der Parallelitätswarteschlange beenden.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-soft-failure-tolerance-4.png) StackSets setzt die Bereitstellung von Stack-Instances fort, die sich bereits in der Parallelitätswarteschlange befinden. Das bedeutet, dass die Anzahl der fehlerhaften Stack-Instances höher sein kann als die **Fehlertoleranz**. Im folgenden Beispiel sind 8 Stack-Instances ausgefallen, da in der Parallelitätswarteschlange noch 7 Operationen ausgeführt werden mussten, obwohl der StackSet Vorgang die **Fehlertoleranz** von 5 erreicht hatte. ![\[Der StackSet Vorgang weist insgesamt 8 Fehlschläge auf, da nach Erreichen des Fehlerschwellenwerts noch 7 Bereitstellungen in der Warteschlange verbleiben.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/concurrency-soft-failure-tolerance-5.png) In diesem Beispiel StackSets wurden 15 Stack-Instances (7 erfolgreich und 8 gescheitert) bereitgestellt, bevor der Stack-Vorgang gestoppt wurde. ## Wählen zwischen strikter und loser Fehlertoleranz auf Grundlage der Bereitstellungsgeschwindigkeit Die Wahl zwischen den Modi **Strikte Fehlertoleranz** **und Weiche Fehlertoleranz** hängt von der bevorzugten Geschwindigkeit Ihrer StackSet Bereitstellung und der zulässigen Anzahl von Bereitstellungsfehlern ab. Die folgenden Tabellen zeigen, wie jeder Parallelitätsmodus mit einem StackSet Vorgang umgeht, der beim Versuch, insgesamt 1000 Stack-Instances bereitzustellen, fehlschlägt. In jedem Szenario ist der Wert der **Fehlertoleranz** auf 100 Stack-Instances und der Wert für **Maximale Anzahl gleichzeitiger Konten** auf 250 Stack-Instances eingestellt. In diesem Beispiel werden Konten StackSets zwar als verschiebbares Fenster in die Warteschlange gestellt (siehe[So funktionieren die einzelnen Parallelitätsmodi](#concurrency-mode-example)), aber dieses Beispiel zeigt den Vorgang in Batches, um die Geschwindigkeit der einzelnen Modi zu demonstrieren. ### Strikte Fehlertoleranz In diesem Beispiel mit dem Modus **Strikte Fehlertoleranz** wird die tatsächliche Parallelität im Verhältnis zur Anzahl der Fehler verringert, die jeweils im vorherigen Stapel aufgetreten sind. Jeder Stapel hat 20 fehlgeschlagene Instanzen, wodurch die tatsächliche Parallelität des folgenden Batches um 20 verringert wird, bis der StackSet Vorgang den **Fehlertoleranzwert** von 100 erreicht. In der folgenden Tabelle liegt die anfängliche tatsächliche Parallelität des ersten Stapels bei 101 Stack-Instances. Die tatsächliche Parallelität beträgt 101, da der Wert der **Fehlertoleranz** (100) \$11 niedriger ist als der Wert für **Maximale Anzahl gleichzeitiger Konten** (250). Jeder Stapel enthält 20 fehlerhafte Bereitstellungen von Stack-Instances, wodurch sich die tatsächliche Parallelität jedes nachfolgenden Stapels um 20 Stack-Instances verringert. | **Strikte Fehlertoleranz** | **Stapel 1** | **Stapel 2** | **Stapel 3** | **Stapel 4** | **Stapel 5** | **Stapel 6** | | --- | --- | --- | --- | --- | --- | --- | | Anzahl der tatsächlichen Parallelität | 101 | 81 | 61 | 41 | 21 | - | | Anzahl fehlerhafter Instances | 20 | 20 | 20 | 20 | 20 | - | | Anzahl erfolgreicher Stack-Instances | 81 | 61 | 41 | 21 | 1 | - | Bei dem Vorgang, bei dem **Strict Failure Tolerance** verwendet wurde, wurden 305 Stack-Instance-Bereitstellungen in 5 Batches abgeschlossen, bis der StackSet Vorgang die **Fehlertoleranz** von 100 Stack-Instances erreichte. Der StackSet Vorgang stellt erfolgreich 205 Stack-Instances bereit, bevor er fehlschlägt. ### Lose Fehlertoleranz In diesem Beispiel mit dem Modus **Lose Fehlertoleranz** wird unabhängig von der Anzahl der fehlerhaften Instances die gleiche Anzahl der tatsächlichen Parallelität beibehalten, die durch den Wert für **Maximale Anzahl gleichzeitiger Konten** von 250 Stack-Instances definiert ist. Bei den StackSet Vorgängen wird dieselbe tatsächliche Parallelität beibehalten, bis der **Fehlertoleranzwert** von 100 Instanzen erreicht ist. In der folgenden Tabelle liegt die anfängliche tatsächliche Parallelität des ersten Stapels bei 250 Stack-Instances. Die tatsächliche Parallelität liegt bei 250, da der Wert „**Maximale Anzahl gleichzeitiger Konten**“ auf 250 festgelegt ist und der Modus „**Weiche Fehlertoleranz**“ es StackSets ermöglicht, diesen Wert unabhängig von der Anzahl der Fehler als tatsächliche Parallelität zu verwenden. Obwohl in diesem Beispiel in jedem Stapel 50 Fehler aufgetreten sind, bleibt die tatsächliche Parallelität davon unberührt. | **Lose Fehlertoleranz** | **Stapel 1** | **Stapel 2** | **Stapel 3** | **Stapel 4** | **Stapel 5** | **Stapel 6** | | --- | --- | --- | --- | --- | --- | --- | | Anzahl der tatsächlichen Parallelität | 250 | 250 | - | - | - | - | | Anzahl fehlerhafter Instances | 50 | 50 | - | - | - | - | | Anzahl erfolgreicher Stack-Instances | 200 | 200 | - | - | - | - | Mit den gleichen Werten für **Maximale Anzahl gleichzeitiger Konten** und **Fehlertoleranz** wurden beim Vorgang mit dem Modus **Lose Fehlertoleranz** 500 Bereitstellungen von Stack-Instances in 2 Stapeln abgeschlossen. Der StackSet Vorgang stellt erfolgreich 400 Stack-Instances bereit, bevor er fehlschlägt. ## Auswahl des Gleichzeitigkeitsmodus (Konsole) Wählen Sie beim Erstellen oder Aktualisieren einer StackSet auf der Seite „**Bereitstellungsoptionen festlegen**“ für den **Parallelitätsmodus** die Option **Strikte Fehlertoleranz oder **Weiche Fehlertoleranz**** aus. ## Auswahl des Gleichzeitigkeitsmodus (AWS CLI) Sie können den `ConcurrencyMode` Parameter mit den folgenden StackSets Befehlen verwenden: + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack-instances.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack-instances.html) + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/delete-stack-instances.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/delete-stack-instances.html) + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/detect-stack-set-drift.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/detect-stack-set-drift.html) + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/import-stacks-to-stack-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/import-stacks-to-stack-set.html) + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack-instances.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack-instances.html) + [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack-set.html) Diese Befehle verfügen über einen bestehenden Parameter namens `--operation-preferences`, bei dem die Einstellung `ConcurrencyMode` verwendet werden kann. `ConcurrencyMode` kann auf einen der folgenden Werte eingestellt werden: + `STRICT_FAILURE_TOLERANCE` + `SOFT_FAILURE_TOLERANCE` Das folgende Beispiel erstellt eine Stack-Instance unter Verwendung von `STRICT_FAILURE_TOLERANCE`,`ConcurrencyMode` wobei `FailureToleranceCount` auf 10 und `MaxConcurrentCount` auf 5 gesetzt wird. ``` aws cloudformation create-stack-instances \ --stack-set-name example-stackset \ --accounts 123456789012 \ --regions eu-west-1 \ --operation-preferences ConcurrencyMode=STRICT_FAILURE_TOLERANCE,FailureToleranceCount=10,MaxConcurrentCount=5 ``` **Anmerkung** Ausführliche Verfahren zum Erstellen und Aktualisieren eines StackSet finden Sie in den folgenden Themen: [Erstellen StackSets (selbstverwaltete Berechtigungen)](stacksets-getting-started-create-self-managed.md) [Erstellen StackSets (vom Service verwaltete Berechtigungen)](stacksets-orgs-associate-stackset-with-org.md) [Aktualisieren StackSets](stacksets-update.md)