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.

# Versprechen in der AWS SDK für PHP Version 3
<a name="guide_promises"></a>

Die AWS SDK für PHP Verwendung **verspricht**, asynchrone Workflows zu ermöglichen, und diese Asynchronität ermöglicht das gleichzeitige Senden von HTTP-Anfragen. Die vom SDK verwendete Promise-Spezifikation lautet [Promises/A\$1](https://promisesaplus.com/).

## Was ist ein Versprechen?
<a name="what-is-a-promise"></a>

Ein *Promise* repräsentiert das Ergebnis einer asynchronen Operation. Der primäre Weg der Interaktion mit einem Promise ist durch seine `then`-Methode. Diese Methode registriert Callbacks, um entweder den möglichen Wert eines Promises oder den Grund zu erhalten, warum das Promise nicht erfüllt werden kann.

The AWS SDK für PHP stützt sich bei der Implementierung seiner Promises auf das Composer-Paket [guzzlehttp/promises](https://github.com/guzzle/promises). Guzzle unterstützt blockierende und nicht blockierende Workflows und kann mit jeder nicht blockierenden Ereignisschleife verwendet werden.

**Anmerkung**  
HTTP-Anfragen werden gleichzeitig AWS SDK für PHP unter Verwendung eines einzigen Threads gesendet, wobei nicht blockierende Aufrufe verwendet werden, um eine oder mehrere HTTP-Anfragen zu übertragen und gleichzeitig auf Statusänderungen zu reagieren (z. B. Versprechen zu erfüllen oder abzulehnen).

## Promises im SDK
<a name="promises-in-the-sdk"></a>

Promises werden im gesamten SDK verwendet. [Promises werden beispielsweise in den meisten vom SDK bereitgestellten allgemeinen Abstraktionen verwendet: [Paginatoren](guide_paginators.md#async-paginators), [Kellner](guide_waiters.md#async-waiters), [Befehlspools, [mehrteilige](s3-multipart-upload.md) Uploads](guide_commands.md#command-pool), S3-Übertragungen usw. directory/bucket ](s3-transfer.md)

Alle Clients, die das SDK bereitstellt, geben Rück-Promises, wenn Sie eine der Suffixmethoden `Async` aufrufen. Der folgende Code zeigt beispielsweise, wie ein Versprechen zum Abrufen der Ergebnisse eines Amazon DynamoDB DynamoDB-Vorgangs `DescribeTable` erstellt wird.

```
$client = new Aws\DynamoDb\DynamoDbClient([
    'region'  => 'us-west-2',
    'version' => 'latest',
]);

// This will create a promise that will eventually contain a result
$promise = $client->describeTableAsync(['TableName' => 'mytable']);
```

Beachten Sie, dass Sie entweder `describeTable` oder`describeTableAsync` aufrufen können. Diese Methoden sind magische `__call` Methoden auf einem Client, die durch das API-Modell und `version` Nummer mit dem Client verbunden sind. Indem Methoden wie `describeTable` ohne das Suffix `Async` aufgerufen werden, blockiert der Client, während er eine HTTP-Anfrage sendet und entweder ein `Aws\ResultInterface`-Objekt zurückgibt oder eine `Aws\Exception\AwsException` auslöst. Durch Suffix des Operationsnamens mit `Async` (d. h. `describeTableAsync`) erstellt der Client ein Promise, das schließlich mit einem Objekt `Aws\ResultInterface` erfüllt oder mit einer `Aws\Exception\AwsException` abgelehnt wird.

**Wichtig**  
Wenn das Promise zurückgegeben wird, ist das Ergebnis möglicherweise bereits angekommen (z. B. bei Verwendung eines Mock-Handlers) oder die HTTP-Anforderung wurde möglicherweise nicht initiiert.

Sie können einen Callback mit dem Promise mit der Methode `then` registrieren. Diese Methode akzeptiert zwei Callbacks, `$onFulfilled` und `$onRejected`, die beide optional sind. Der Callback `$onFulfilled` wird aufgerufen, wenn das Promise erfüllt ist, und der Callback `$onRejected` wird aufgerufen, wenn das Promise abgelehnt wird (d.h. es ist fehlgeschlagen).

```
$promise->then(
    function ($value) {
        echo "The promise was fulfilled with {$value}";
    },
    function ($reason) {
        echo "The promise was rejected with {$reason}";
    }
);
```

### Gleichzeitige Ausführung von Befehlen
<a name="executing-commands-concurrently"></a>

Mehrere Promises können zusammen so zusammengesetzt werden, dass sie gleichzeitig ausgeführt werden. Dies kann erreicht werden, indem das SDK in eine nicht blockierende Ereignisschleife integriert wird oder indem mehrere Promises aufgebaut und darauf gewartet wird, dass sie gleichzeitig ausgeführt werden.

```
use GuzzleHttp\Promise\Utils;

$sdk = new Aws\Sdk([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

$s3 = $sdk->createS3();
$ddb = $sdk->createDynamoDb();

$promises = [
    'buckets' => $s3->listBucketsAsync(),
    'tables'  => $ddb->listTablesAsync(),
];

// Wait for both promises to complete.
$results = Utils::unwrap($promises);

// Notice that this method will maintain the input array keys.
var_dump($results['buckets']->toArray());
var_dump($results['tables']->toArray());
```

**Anmerkung**  
Das [CommandPool](guide_commands.md#command-pool)bietet einen leistungsfähigeren Mechanismus für die gleichzeitige Ausführung mehrerer API-Operationen.

## Versprechen verketten
<a name="chaining-promises"></a>

Einer der besten Aspekte von Promises ist, dass sie zusammensetzbar sind, sodass Sie Transformations-Pipelines erstellen können. Promise werden durch Verkettung `then` von Callbacks mit nachfolgenden `then` Callbacks zusammengestellt. Der Rückgabewert einer `then`-Methode ist ein Promise, das basierend auf dem Ergebnis der bereitgestellten Callbacks erfüllt oder abgelehnt wird.

```
$promise = $client->describeTableAsync(['TableName' => 'mytable']);

$promise
    ->then(
        function ($value) {
            $value['AddedAttribute'] = 'foo';
            return $value;
        },
        function ($reason) use ($client) {
            // The call failed. You can recover from the error here and
            // return a value that will be provided to the next successful
            // then() callback. Let's retry the call.
            return $client->describeTableAsync(['TableName' => 'mytable']);
        }
    )->then(
        function ($value) {
            // This is only invoked when the previous then callback is
            // fulfilled. If the previous callback returned a promise, then
            // this callback is invoked only after that promise is
            // fulfilled.
            echo $value['AddedAttribute']; // outputs "foo"
        },
        function ($reason) {
            // The previous callback was rejected (failed).
        }
    );
```

**Anmerkung**  
Der Rückgabewert eines Zusage-Callbacks ist das Argument `$value` , das an Downstream-Promises übergeben wird. Wenn Sie Downstream-Promise-Ketten einen Wert bereitstellen möchten, müssen Sie einen Wert in der Callback-Funktion zurückgeben.

### Ablehnung, Weiterleitung
<a name="rejection-forwarding"></a>

Sie können einen Callback registrieren, der aufgerufen werden soll, wenn ein Promise abgelehnt wird. Wenn in einem Callback eine Ausnahme ausgelöst wird, wird das Promise mit der Ausnahme abgelehnt und die nächsten Promise in der Kette werden mit der Ausnahme abgelehnt. Wenn Sie einen Wert aus einem `$onRejected`-Callback erfolgreich zurückgeben, werden die nächsten Promises in der Promise-Kette mit dem Rückgabewert aus dem Callback `$onRejected` erfüllt.

## Ich warte auf Versprechen
<a name="waiting-on-promises"></a>

Sie können die Promises synchron erzwingen, indem Sie die `wait` -Methode eines Promises verwenden.

```
$promise = $client->listTablesAsync();
$result = $promise->wait();
```

Wenn beim Aufrufen der Funktion `wait` eines Promises eine Ausnahme auftritt, wird das Promise mit der Ausnahme abgelehnt und die Ausnahme wird ausgelöst.

```
use Aws\Exception\AwsException;

$promise = $client->listTablesAsync();

try {
    $result = $promise->wait();
} catch (AwsException $e) {
    // Handle the error
}
```

Der Aufruf von `wait` auf einem erfüllten Promise löst die Wartefunktion nicht aus. Es gibt einfach den zuvor gelieferten Wert zurück.

```
$promise = $client->listTablesAsync();
$result = $promise->wait();
assert($result ### $promise->wait());
```

Der Aufruf von `wait` bei einem abgelehnten Promise löst eine Ausnahme aus. Wenn der Ablehnungsgrund eine Instance von `\Exception` ist, wird der Grund geworfen. Andernfalls wird eine `GuzzleHttp\Promise\RejectionException` ausgelöst und der Grund kann durch Aufrufen der `getReason`-Methode der Ausnahme erhalten werden.

**Anmerkung**  
API-Operationsaufrufe in AWS SDK für PHP werden mit Unterklassen der `Aws\Exception\AwsException` Klasse zurückgewiesen. Es ist jedoch möglich, dass der Grund, der an eine `then`-Methode geliefert wird, ein anderer ist, weil eine benutzerdefinierte Middleware hinzugefügt wird, die einen Ablehnungsgrund ändert.

## Versprechen stornieren
<a name="canceling-promises"></a>

Promise können mit der `cancel()`-Methode eines Promises abgebrochen werden. Wenn eine Zusage bereits gelöst wurde, hat der Aufruf von `cancel()` keine Wirkung. Das Abbrechen eines Promises löscht das Promise und alle Promises, die auf die Lieferung vom Promise warten. Ein gelöschtes Promise wird mit einer `GuzzleHttp\Promise\RejectionException` abgelehnt.

## Versprechen kombinieren
<a name="combining-promises"></a>

Sie können Promise zu zusammengefassten Promises kombinieren, um anspruchsvollere Workflows zu erstellen. Das Paket `guzzlehttp/promise` enthält verschiedene Funktionen, mit denen Sie Promises kombinieren können.

Die API-Dokumentation für alle Funktionen zur Sammlung von Versprechen finden Sie unter [namespace- GuzzleHttp .Promise](https://docs.aws.amazon.com/aws-sdk-php/v3/api/namespace-GuzzleHttp.Promise.html).

### each und each\$1limit
<a name="each-and-each-limit"></a>

Verwenden Sie die [CommandPool](guide_commands.md#command-pool)Option, wenn Sie eine Aufgabenwarteschlange mit `Aws\CommandInterface` Befehlen haben, die gleichzeitig mit einer festen Poolgröße ausgeführt werden sollen (die Befehle können sich im Speicher befinden oder von einem Lazy-Iterator abgerufen werden). Die `CommandPool` stellt sicher, dass eine feste Anzahl von Befehlen gleichzeitig gesendet wird, bis der bereitgestellte Iterator erschöpft ist.

Das `CommandPool` funktioniert nur mit den gleichen Client-Befehlen, die ausgeführt werden. Sie können die Funktion `GuzzleHttp\Promise\each_limit` verwenden, um Sendebefehle verschiedener Clients gleichzeitig mit einer festen Poolgröße auszuführen.

```
use GuzzleHttp\Promise;

$sdk = new Aws\Sdk([
    'version' => 'latest',
    'region'  => 'us-west-2'
]);

$s3 = $sdk->createS3();
$ddb = $sdk->createDynamoDb();

// Create a generator that yields promises
$promiseGenerator = function () use ($s3, $ddb) {
    yield $s3->listBucketsAsync();
    yield $ddb->listTablesAsync();
    // yield other promises as needed...
};

// Execute the tasks yielded by the generator concurrently while limiting the
// maximum number of concurrent promises to 5
$promise = Promise\each_limit($promiseGenerator(), 5);

// Waiting on an EachPromise will wait on the entire task queue to complete
$promise->wait();
```

### Versprich Coroutinen
<a name="promise-coroutines"></a>

Eine der leistungsstärkeren Funktionen der Guzzle Promise-Bibliothek ist, dass Sie Promise-Coroutinen verwenden können, die das Schreiben von asynchronen Arbeitsabläufen mehr wie das Schreiben von traditionellen synchronen Arbeitsabläufen erscheinen lassen. Tatsächlich verwendet das AWS SDK für PHP Coroutine-Promises in den meisten Abstraktionen auf hoher Ebene.

Stellen Sie sich vor, Sie möchten mehrere Buckets erstellen und eine Datei in den Bucket hochladen, sobald der Bucket verfügbar wird. Sie möchten dies alles gleichzeitig tun, damit es so schnell wie möglich geschieht. Sie können dies leicht tun, indem Sie mehrere Coroutine-Promises mit der Funktion `all()` kombinieren.

```
use GuzzleHttp\Promise;

$uploadFn = function ($bucket) use ($s3Client) {
    return Promise\coroutine(function () use ($bucket, $s3Client) {
        // You can capture the result by yielding inside of parens
        $result = (yield $s3Client->createBucket(['Bucket' => $bucket]));
        // Wait on the bucket to be available
        $waiter = $s3Client->getWaiter('BucketExists', ['Bucket' => $bucket]);
        // Wait until the bucket exists
        yield $waiter->promise();
        // Upload a file to the bucket
        yield $s3Client->putObjectAsync([
            'Bucket' => $bucket,
            'Key'    => '_placeholder',
            'Body'   => 'Hi!'
        ]);
    });
};

// Create the following buckets
$buckets = ['amzn-s3-demo-bucket1', 'amzn-s3-demo-bucket2', 'amzn-s3-demo-bucket3'];
$promises = [];

// Build an array of promises
foreach ($buckets as $bucket) {
    $promises[] = $uploadFn($bucket);
}

// Aggregate the promises into a single "all" promise
$aggregate = Promise\all($promises);

// You can then() off of this promise or synchronously wait
$aggregate->wait();
```