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.
# Konfiguration von Service-Clients im Code für die AWS SDK für PHP Version 3
Als Alternative oder zusätzlich zur [externen Konfiguration von Service-Clients](configuring-service-clients-ext.md) können Sie sie programmgesteuert im Code konfigurieren.
Durch die Konfiguration von Service-Clients im Code erhalten Sie eine detaillierte Kontrolle über die vielen Optionen, die Ihnen zur Verfügung stehen. Die meisten Konfigurationen, die Sie extern festlegen können, stehen Ihnen auch zur Verfügung, um sie im Code festzulegen.
## Grundkonfiguration im Code
Sie können einen Service-Client im Code erstellen und konfigurieren, indem Sie ein assoziatives Array von Optionen an den Konstruktor eines Clients übergeben. Im folgenden Beispiel enthält das assoziative Array nur die Option „Region“, die der Client verwendet:
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
use Aws\Exception\AwsException;
//Create an S3Client
$s3 = new S3Client([
'region' => 'eu-south-2'
]);
```
Informationen zum optionalen Parameter „Version“ finden Sie im Thema [Konfigurationsoptionen](guide_configuration.md#cfg-version).
Beachten Sie, dass wir **nicht** explizit Anmeldeinformationen für den Client angegeben haben. Das liegt daran, dass das SDK die [standardmäßige Anbieterkette für Anmeldeinformationen](guide_credentials_default_chain.md) verwendet, um nach Anmeldeinformationen zu suchen.
Alle allgemeinen Client-Konfigurationsoptionen werden unter ausführlich beschrieben. [Client-Konstruktor-Optionen für die AWS SDK für PHP Version 3](guide_configuration.md) Die Anzahl der Optionen, die einem Client zur Verfügung gestellt werden, kann je nach Client, den Sie erstellen, variieren. Diese benutzerdefinierten Clientkonfigurationsoptionen sind in der [API-Dokumentation](https://docs.aws.amazon.com/aws-sdk-php/latest/) für jeden Client beschrieben.
## Verwendung der `Sdk` Klasse
Die Klasse `Aws\Sdk` fungiert als Client-Factory und wird verwendet, um gemeinsame Konfigurationsoptionen für mehrere Clients zu verwalten. Viele der Optionen, die einem bestimmten Client-Konstruktor zur Verfügung gestellt werden können, können auch der `Aws\Sdk` Klasse zur Verfügung gestellt werden. Diese Optionen werden dann auf jeden Client-Konstruktor angewendet.
**Importe**
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
use Aws\Exception\AwsException;
```
**Beispiel-Code**
```
// The same options that can be provided to a specific client constructor can also be supplied to the Aws\Sdk class.
// Use the us-west-2 region and latest version of each client.
$sharedConfig = [
'region' => 'us-west-2'
];
// Create an SDK class used to share configuration across clients.
$sdk = new Aws\Sdk($sharedConfig);
// Create an Amazon S3 client using the shared configuration data.
$client = $sdk->createS3();
```
Optionen, die für alle Clients freigegeben sind, werden in Schlüssel/Wert-Paaren auf Stammebene platziert. Dienstspezifische Konfigurationsdaten können in einem assoziativen Array mit einem Schlüssel bereitgestellt werden, der dem Namespace eines Dienstes entspricht (z. B. „S3“, „DynamoDb“ usw.).
```
$sdk = new Aws\Sdk([
'region' => 'us-west-2',
'DynamoDb' => [
'region' => 'eu-central-1'
]
]);
// Creating an Amazon DynamoDb client will use the "eu-central-1" AWS Region.
$client = $sdk->createDynamoDb();
```
Servicespezifische Konfigurationswerte sind eine Vereinigung der servicespezifischen Werte und der Werte auf Stammebene (d. h. servicespezifische Werte werden flach auf Werte auf Stammebene zusammengeführt).
**Anmerkung**
Wir empfehlen dringend, dass Sie die Klasse `Sdk` verwenden, um Clients zu erstellen, wenn Sie mehrere Client-Instances in Ihrer Anwendung verwenden. Die Klasse `Sdk` verwendet automatisch denselben HTTP-Client für jeden SDK-Client, sodass SDK-Clients für verschiedene Services nicht blockierende HTTP-Anforderungen ausführen können. Wenn die SDK-Clients nicht denselben HTTP-Client verwenden, blockieren HTTP-Anforderungen, die vom SDK-Client gesendet werden, möglicherweise die Promise-Orchestrierung zwischen Services.
# Client-Konstruktor-Optionen für die AWS SDK für PHP Version 3
Client-Konstruktor-Optionen können in einem Client-Konstruktor oder der [https://docs.aws.amazon.com/aws-sdk-php/latest/class-Aws.Sdk.html](https://docs.aws.amazon.com/aws-sdk-php/latest/class-Aws.Sdk.html)Klasse bereitgestellt werden. Die Anzahl der Optionen, die einem bestimmten Clienttyp zur Verfügung stehen, kann variieren, je nachdem, welchen Client Sie anlegen. Diese benutzerdefinierten Client-Konfigurationsoptionen sind in der [API-Dokumentation](https://docs.aws.amazon.com/aws-sdk-php/latest/) für jeden Client beschrieben.
Wenn Sie die vom Client benötigten Client-Konstruktoroptionen nicht explizit angeben, sucht das SDK for PHP nach Werten aus Umgebungsvariablen oder aus einer AWS Konfigurationsdatei. Alle Clients benötigen einen Credential Provider-Wert und einen AWS-Region Wert, daher müssen Sie diese Werte als Konstruktoroptionen oder extern festlegen.
Standardmäßig befindet sich die zu überprüfende Konfigurationsdatei `.aws/config` in Ihrem Stammverzeichnis, in der Regel `~/.aws/config`. Sie können jedoch die Umgebungsvariable `AWS_CONFIG_FILE` verwenden, um den Standardspeicherort der Konfigurationsdatei festzulegen. Dies kann beispielsweise nützlich sein, wenn Sie den Dateizugriff auf bestimmte Verzeichnisse mit einschränken. `open_basedir`
Weitere Informationen zum Speicherort und zur Formatierung der gemeinsam genutzten AWS `config` `credentials` Dateien finden Sie unter [Konfiguration](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) im *Referenzhandbuch für Tools AWS SDKs und Tools.*
Einzelheiten zu allen globalen Konfigurationseinstellungen, die Sie in den AWS Konfigurationsdateien oder als Umgebungsvariablen festlegen können, finden Sie in der Referenz zu den [Einstellungen für Konfiguration AWS SDKs und Authentifizierung im Referenzhandbuch](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html) *für Tools*.
**Topics**
+ [api\$1provider](#api-provider)
+ [Anmeldedaten](#config_credentials)
+ [debug](#debug)
+ [stats](#config-stats)
+ [Endpunkt](#endpoint)
+ [endpoint\$1provider](#endpoint-provider)
+ [endpoint\$1discovery](#endpoint-discovery)
+ [handler](#handler)
+ [http](#config-http)
+ [http\$1handler](#http-handler)
+ [Profil](#profile)
+ [Region](#cfg-region)
+ [retries](#config-retries)
+ [scheme](#scheme)
+ [Service nicht zulässig](#service)
+ [signature\$1provider](#signature-provider)
+ [signature\$1version](#signature-version)
+ [ua\$1append](#ua-append)
+ [use\$1aws\$1shared\$1config\$1files](#use-aws-shared-config-files)
+ [validieren](#validate)
+ [version](#cfg-version)
Das folgende Beispiel zeigt, wie Optionen an einen Amazon S3 S3-Client-Konstruktor übergeben werden.
```
use Aws\S3\S3Client;
$options = [
'region' => 'us-west-2',
'version' => '2006-03-01',
'signature_version' => 'v4'
];
$s3Client = new S3Client($options);
```
Weitere Informationen [Einen Basis-Serviceclient erstellen](making-service-requests.md#creating-a-client) zum Konstruieren von Clients finden Sie unter.
## api\$1provider
Typ
`callable`
Eine aufrufbare PHP-Funktion, die ein Typ-, Service- und Versionsargument entgegennimmt und ein Array mit entsprechenden Konfigurationsdaten zurückgibt. Der Wert für den Typ kann `api`, `waiter` oder `paginator` sein.
Standardmäßig verwendet das SDK eine Instance von`Aws\Api\FileSystemApiProvider`, die Dateien aus dem `src/data`-Ordner der SDK-API lädt.
## Anmeldedaten
Typ
`array|Aws\CacheInterface|Aws\Credentials\CredentialsInterface|bool|callable`
Übergeben Sie ein `Aws\Credentials\CredentialsInterface`-Objekt, um eine spezifische Anmeldeinformationen-Instance zu verwenden. Im Folgenden wird angegeben, dass der IAM Identity Center-Anmeldeinformationsanbieter verwendet werden sollte. Dieser Anbieter wird auch als SSO-Anmeldeinformationsanbieter bezeichnet.
```
$credentials = Aws\Credentials\CredentialProvider::sso('profile default');
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Wenn Sie ein benanntes Profil verwenden, ersetzen Sie '`default`' im vorherigen Beispiel durch den Namen Ihres Profils. Weitere Informationen zum Einrichten benannter Profile finden Sie unter [Geteilte Profile `config` und `credentials` Dateien](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
Wenn Sie keinen zu verwendenden Anmeldeinformationsanbieter angeben und sich auf die Anmeldeinformationsanbieterkette verlassen, ist die Fehlermeldung aufgrund einer fehlgeschlagenen Authentifizierung in der Regel generisch. Sie wird anhand des letzten Anbieters in der Liste der Quellen generiert, die auf gültige Anmeldeinformationen überprüft werden. Dabei handelt es sich möglicherweise nicht um den Anbieter, den Sie verwenden möchten. Wenn Sie angeben, welcher Anmeldeinformationsanbieter verwendet werden soll, ist jede daraus resultierende Fehlermeldung hilfreicher und relevanter, da sie nur von diesem Anbieter stammt. Weitere Informationen zur Kette von Quellen, die auf Anmeldeinformationen überprüft wurden, finden Sie unter [Credential Provider Chain](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) im *AWS SDKs Tools-Referenzhandbuch*.
Übergeben Sie `false`, um keine Anmeldeinformationen zu verwenden und Anfragen nicht zu signieren.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'credentials' => false
]);
```
Übergeben Sie eine aufrufbare [Anmeldeinformationsanbieter](guide_credentials.md#cred-provider-defn-php)-Funktion, um Anmeldeinformationen unter Verwendung einer Funktion zu erstellen.
```
use Aws\Credentials\CredentialProvider;
// Only load credentials from environment variables
$provider = CredentialProvider::env();
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
Übergeben Sie in einer Instance von `Aws\CacheInterface` zwischengespeicherte Anmeldeinformationen, um die Werte von der Standard-Anbieterkette über mehrere Prozesse zwischenzuspeichern.
```
use Aws\Credentials\CredentialProvider;
use Aws\PsrCacheAdapter;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
$cache = new PsrCacheAdapter(new FilesystemAdapter);
$provider = CredentialProvider::defaultProvider();
$cachedProvider = CredentialProvider::cache($provider, $cache);
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'credentials' => $cachedProvider
]);
```
Weitere Informationen zur Bereitstellung von Anmeldeinformationen für einen Client finden Sie im Handbuch [Anmeldeinformationen für AWS SDK für PHP Version 3.](guide_credentials.md)
**Anmerkung**
Anmeldeinformationen werden langsam geladen und geprüft, wenn sie verwendet werden.
## debug
Typ
`bool|array`
Gibt Debugging-Informationen zu jeder Übertragung aus. Debugging-Informationen enthalten Informationen zu jeder Statusänderung einer Transaktion, wie sie erstellt und gesendet wird. Außerdem sind in der Debugging-Ausgabe Informationen zum jeweiligen HTTP-Handler enthalten, der von einem Client verwendet wird (z. B. debug cURL-Ausgabe).
Auf `true` setzen, um Debugging-Informationen anzeigen, wenn Anforderungen gesendet werden.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'debug' => true
]);
// Perform an operation to see the debug output
$s3->listBuckets();
```
Alternativ können Sie eine assoziatives Array mit den folgenden Schlüsseln bereitstellen.
**logfn (callable)**
Funktion, die mit Protokolleinträgen aufgerufen wird. Standardmäßig wird die `echo`-Funktion von PHP verwendet.
**stream\$1size (int)**
Wenn die Größe eines Datenstroms größer als diese Zahl ist, werden die Stream-Daten nicht protokolliert. Auf `0` setzen, um nicht alle Stream-Daten zu protokollieren.
**scrub\$1auth (bool)**
Stellen Sie diese Option ein`false`, um das Löschen von Authentifizierungsdaten aus den protokollierten Nachrichten zu deaktivieren (was bedeutet, dass Ihre AWS Zugriffsschlüssel-ID und Signatur an die `logfn` weitergegeben werden).
**http (bool)**
Auf `false` setzen, um die „Debug“-Funktion von HTTP-Handlern auf niedrigerer Ebene zu deaktivieren (z. B. verbose cURL-Ausgabe).
**auth\$1headers (array)**
Auf eine Schlüssel-Wert-Zuweisung von Headern setzen, die Sie ersetzten wollen, abgebildet auf den Wert, durch den Sie sie ersetzen möchten. Diese Werte werden nicht verwendet, es sei denn `scrub_auth` ist auf `true` gesetzt.
**auth\$1strings (array)**
Auf eine Schlüssel-Wert-Zuordnung regulärer Ausdrücke setzen, um eine Abbildung auf ihre Ersatzwerte vorzunehmen. Diese Werte werden vom Authentifizierungsdaten-Scrubber verwendet, wenn `scrub_auth` auf `true` gesetzt ist.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'debug' => [
'logfn' => function ($msg) { echo $msg . "\n"; },
'stream_size' => 0,
'scrub_auth' => true,
'http' => true,
'auth_headers' => [
'X-My-Secret-Header' => '[REDACTED]',
],
'auth_strings' => [
'/SuperSecret=[A-Za-z0-9]{20}/i' => 'SuperSecret=[REDACTED]',
],
]
]);
// Perform an operation to see the debug output
$s3->listBuckets();
```
**Anmerkung**
Diese Option gibt auch die zugrunde liegenden HTTP-Handler-Informationen aus, die von der `http` Debug-Option erzeugt wurden. Die Debugging-Ausgabe ist extrem hilfreich beim Diagnostizieren von Problemen in AWS SDK für PHP. Bitte geben Sie die Debugging-Ausgabe für einen isolierten Fehlerfall an, wenn Sie Tickets für das SDK eröffnen.
## stats
Typ
`bool|array`
Bindet Übertragungsstatistiken an Fehler und Ergebnisse, die von SDK-Operationen zurückgegeben wurden.
Auf `true` setzen, um Übertragungsstatistiken für gesendete Anforderungen zu erfassen.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'stats' => true
]);
// Perform an operation
$result = $s3->listBuckets();
// Inspect the stats
$stats = $result['@metadata']['transferStats'];
```
Alternativ können Sie eine assoziatives Array mit den folgenden Schlüsseln bereitstellen.
**retries (bool)**
Auf einstellen, `false` um die Berichterstattung über wiederholte Versuche zu deaktivieren. Wiederholungsstatistiken werden standardmäßig erfasst und zurückgegeben.
**http (bool)**
Wird auf gesetzt, `true` um das Sammeln von Statistiken von HTTP-Adaptern auf niedrigerer Ebene zu ermöglichen (z. B. zurückgegebene Werte). GuzzleHttpTransferStats HTTP-Handler müssen eine \$1\$1on\$1transfer\$1stats-Option unterstützen, damit dies eine Wirkung zeigt. HTTP-Statistiken werden als ein indiziertes Array assoziativer Arrays zurückgegeben; jedes assoziative Array enthält die Übertragungsstatistiken, die der HTTP-Handler des Clients für eine Anfrage zurückgibt. Standardmäßig deaktiviert.
Falls eine Anforderung wiederholt wurde, werden die Übertragungsstatistiken für jede Anforderung zurückgegeben, wobei `$result['@metadata']['transferStats']['http'][0]` die Statistiken für die erste Anforderung, `$result['@metadata']['transferStats']['http'][1]` die Statistiken für die zweite Anforderung und so weiter enthält.
**timer (bool)**
Auf `true` setzen, um einen Befehlstimer zu aktivieren, der die gesamte für eine Operation aufgewendete Zeit in Sekunden anzeigt. Standardmäßig deaktiviert.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-west-2',
'stats' => [
'retries' => true,
'timer' => false,
'http' => true,
]
]);
// Perform an operation
$result = $s3->listBuckets();
// Inspect the HTTP transfer stats
$stats = $result['@metadata']['transferStats']['http'];
// Inspect the number of retries attempted
$stats = $result['@metadata']['transferStats']['retries_attempted'];
// Inspect the total backoff delay inserted between retries
$stats = $result['@metadata']['transferStats']['total_retry_delay'];
```
## Endpunkt
Typ
`string`
Die vollständige URI des Webservice. Dies ist beispielsweise für Dienste erforderlich, die [AWS Elemental MediaConvert](https://docs.aws.amazon.com/mediaconvert/latest/ug/)kontospezifische Endpunkte verwenden. Für diese Dienste fordern Sie diesen Endpunkt mit der Methode an. `describeEndpoints`
Dies ist nur erforderlich, wenn Sie eine Verbindung zu einem benutzerdefinierten Endpunkt herstellen (z. B. eine lokale Version von Amazon S3 oder [Amazon DynamoDB Local)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html).
Hier ist ein Beispiel für eine Verbindung zu Amazon DynamoDB Local:
```
$client = new Aws\DynamoDb\DynamoDbClient([
'version' => '2012-08-10',
'region' => 'us-east-1',
'endpoint' => 'http://localhost:8000'
]);
```
Eine Liste der verfügbaren [AWS Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) finden Sie unter AWS Regionen und Endpunkte.
## endpoint\$1provider
Typ
`Aws\EndpointV2\EndpointProviderV2|callable`
Eine optionale aufrufbare Instanz von EndpointProvider V2 oder PHP, die einen Hash von Optionen akzeptiert, einschließlich eines „Service“ - und „Region“ -Schlüssels. Sie gibt `NULL` oder einen Hash für Endpunktdaten zurück, von denen der „Endpunktschlüssel“ benötigt wird.
Hier folgt ein Beispiel dafür, wie ein minimaler Endpunktanbieter eingerichtet wird.
```
$provider = function (array $params) {
if ($params['service'] == 'foo') {
return ['endpoint' => $params['region'] . '.example.com'];
}
// Return null when the provider cannot handle the parameters
return null;
});
```
## endpoint\$1discovery
Typ
`array|Aws\CacheInterface|Aws\EndpointDiscovery\ConfigurationInterface|callable`
Die Endpunkterkennung identifiziert den korrekten Endpunkt für Service-APIs, die die Endpunkterkennung unterstützen, und stellt eine Verbindung damit her. Aktivieren Sie während der Client-Erstellung `endpoint_discovery` für Services, die die Endpunkterkennung zwar unterstützen, aber nicht erfordern. Wenn ein Service die Endpunkterkennung nicht unterstützt, wird diese Konfiguration ignoriert.
`Aws\EndpointDiscovery\ConfigurationInterface`
Ein optionaler Konfigurationsanbieter, der automatische Verbindungsherstellung zum entsprechenden Endpunkt einer Service-API für Operationen ermöglicht, die der Service bestimmt.
Das Objekt `Aws\EndpointDiscovery\Configuration` akzeptiert zwei Optionen, darunter ein Boolescher Wert („enabled“), der angibt, ob die Endpunkterkennung aktiviert ist, und eine Ganzzahl („cache\$1limit“), die die maximale Anzahl von Schlüsseln im Endpunkt-Cache angibt.
Für jeden erstellten Client übergeben Sie ein Objekt `Aws\EndpointDiscovery\Configuration`, um eine bestimmte Konfiguration für die Endpunkterstellung zu nutzen.
```
use Aws\EndpointDiscovery\Configuration;
use Aws\S3\S3Client;
$enabled = true;
$cache_limit = 1000;
$config = new Aws\EndpointDiscovery\Configuration (
$enabled,
$cache_limit
);
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-2',
'endpoint_discovery' => $config,
]);
```
Übergeben Sie eine Instance von `Aws\CacheInterface`, um die Werte von der Endpunkterkennung über mehrere Prozesse im Cache zu speichern.
```
use Aws\DoctrineCacheAdapter;
use Aws\S3\S3Client;
use Doctrine\Common\Cache\ApcuCache;
$s3 = new S3Client([
'region' => 'us-west-2',
'endpoint_discovery' => new DoctrineCacheAdapter(new ApcuCache),
]);
```
Übergeben Sie der Endpunkterkennung ein Array.
```
use Aws\S3\S3Client;
$s3 = new S3Client([
'region' => 'us-west-2',
'endpoint_discovery' => [
'enabled' => true,
'cache_limit' => 1000
],
]);
```
## handler
Typ
`callable`
Ein Handler, der ein Befehlsobjekt und ein Anfrageobjekt akzeptiert und ein Versprechen zurückgibt (`GuzzleHttp\Promise\PromiseInterface`), das mit einem -Objekt erfüllt oder mit einer `Aws\ResultInterface` abgelehnt wird.`Aws\Exception\AwsException` Ein Handler akzeptiert keinen weiteren Handler, da er ein Terminal ist und einen Befehl ausführen soll. Wenn kein Handler bereitgestellt wird, wird eine Standard-Guzzle-Handler verwendet.
Du kannst den `Aws\MockHandler` benutzen, um modellhafte Ergebnisse zurückzugeben oder modellhafte Ausnahmen aufzuwerfen. Sie stellen Ergebnisse oder Ausnahmen in die Warteschlange und MockHandler dann werden sie in der FIFO-Reihenfolge aus der Warteschlange entfernt.
```
use Aws\Result;
use Aws\MockHandler;
use Aws\DynamoDb\DynamoDbClient;
use Aws\CommandInterface;
use Psr\Http\Message\RequestInterface;
use Aws\Exception\AwsException;
$mock = new MockHandler();
// Return a mocked result
$mock->append(new Result(['foo' => 'bar']));
// You can provide a function to invoke; here we throw a mock exception
$mock->append(function (CommandInterface $cmd, RequestInterface $req) {
return new AwsException('Mock exception', $cmd);
});
// Create a client with the mock handler
$client = new DynamoDbClient([
'region' => 'us-east-1',
'handler' => $mock
]);
// Result object response will contain ['foo' => 'bar']
$result = $client->listTables();
// This will throw the exception that was enqueued
$client->listTables();
```
## http
Typ
`array`
Auf ein Array von HTTP-Optionen setzen, die auf vom SDK erstellte HTTP-Anforderungen und -Übertragungen angewendet werden.
Das SDK unterstützt die folgenden Konfigurationsoptionen:
### cert
Typ
`string|array`
Geben Sie das PEM-formatierte Client-seitige Zertifikat an.
+ Als Zeichenfolge für den Pfad nur zur Zertifikatdatei festlegen.
```
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2',
'http' => ['cert' => '/path/to/cert.pem']
]);
```
+ Legen Sie dies als Array fest, das Pfad und Passwort enthält.
```
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2',
'http' => [
'cert' => ['/path/to/cert.pem', 'password']
]
]);
```
### connect\$1timeout
Ein Fließkommawert, der die Anzahl der Sekunden angibt, die man warten muss, während man versucht, eine Verbindung zu einem Server herzustellen. Verwenden Sie `0` für unbestimmtes Warten (das Standardverhalten).
```
use Aws\DynamoDb\DynamoDbClient;
// Timeout after attempting to connect for 5 seconds
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'connect_timeout' => 5
]
]);
```
### debug
Typ
`bool|resource`
Weist den zugrundeliegenden HTTP-Handler an, Debugging-Informationen auszugeben. Die Debugging-Informationen von verschiedenen HTTP-Handlern variieren.
+ Übergeben Sie `true`, um Debugging-Ausgaben auf STDOUT zu schreiben.
+ Übergeben Sie eine `resource` wie von `fopen` zurückgegeben, um Debugging-Ausgabe auf eine spezifische PHP-Stream-Ressource zu schreiben.
### decode\$1content
Typ
`bool`
Weist den zugrundeliegenden HTTP-Handler an, den Rumpf der komprimierten Antworten zu erweitern. Wenn dies nicht aktiviert ist, werden komprimierte Antwortrümpfe möglicherweise mit einem `GuzzleHttp\Psr7\InflateStream` erweitert.
**Anmerkung**
Die Inhaltsdekodierung ist im Standard-HTTP-Handler des SDK standardmäßig aktiviert. Aus Gründen der Abwärtskompatibilität kann diese Voreinstellung nicht geändert werden. Wenn Sie komprimierte Dateien in Amazon S3 speichern, empfehlen wir, die Inhaltsdekodierung auf S3-Client-Ebene zu deaktivieren.
```
use Aws\S3\S3Client;
use GuzzleHttp\Psr7\InflateStream;
$client = new S3Client([
'region' => 'us-west-2',
'http' => ['decode_content' => false],
]);
$result = $client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'massize_gzipped_file.tgz'
]);
$compressedBody = $result['Body']; // This content is still gzipped
$inflatedBody = new InflateStream($result['Body']); // This is now readable
```
### Verzögerung
Typ
`int`
Die Anzahl der Millisekunden für die Verzögerung vor dem Senden der Anfrage. Dies wird oft verwendet, um eine Anfrage zu verzögern, bevor sie erneut versucht wird.
### expect
Typ
`bool|string`
Diese Option wird durch die zugrunde liegenden HTTP-Handler übergeben. Standardmäßig werden Kopfzeilen mit „Expect: 100 Continue“ festgelegt, wenn der Textteil der Anforderung 1 MB überschreitet. `true` oder `false` aktiviert oder deaktiviert die Kopfzeile auf allen Anforderungen. Wenn eine Ganzzahl verwendet wird, verwenden nur Anforderungen diese Kopfzeile, deren Textteil diese Einstellung überschreitet. Bei Verwendung als Ganzzahl wird die expect-Kopfzeile mitgesendet, wenn die Textgröße nicht bekannt ist.
**Warnung**
Die Deaktivierung der expect-Kopfzeile kann Fehler hervorrufen, z. B. kann es sein, dass der Service keine Authentifizierung mehr zurückgibt. Diese sollte mit Vorsicht konfiguriert werden.
### progress
Typ
`callable`
Definiert eine Funktion, die aufgerufen wird, wenn Übertragungsfortschritt gemacht wird. Die Funktion akzeptiert die folgenden Argumente:
1. Die Gesamtanzahl der Bytes, die voraussichtlich heruntergeladen werden.
1. Die Anzahl der Bytes, die bisher heruntergeladen wurden.
1. Die Gesamtanzahl der Bytes, die voraussichtlich hochgeladen werden.
1. Die Anzahl der Bytes, die bisher hochgeladen wurden.
```
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2'
]);
// Apply the http option to a specific command using the "@http"
// command parameter
$result = $client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'large.mov',
'@http' => [
'progress' => function ($expectedDl, $dl, $expectedUl, $ul) {
printf(
"%s of %s downloaded, %s of %s uploaded.\n",
$expectedDl,
$dl,
$expectedUl,
$ul
);
}
]
]);
```
### Proxy
Typ
`string|array`
Mithilfe der `proxy` Option können Sie über einen Proxy eine Verbindung zu einem AWS Service herstellen.
+ Geben Sie einen Zeichenfolgenwert an, um eine Verbindung zu einem Proxy für alle Typen von herzustellen URIs. Der Proxy-Zeichenfolgenwert kann ein Schema, einen Benutzernamen und ein Passwort enthalten. Beispiel, `"http://username:password@192.168.16.1:10"`.
+ Stellen Sie ein assoziatives Array mit Proxy-Einstellungen bereit, wobei der Schlüssel das Schema der URI ist, und der Wert der Proxy für die angegebene URI (d. h. Sie können verschiedene Proxys für „http“- und „https“-Endpunkte angeben).
```
use Aws\DynamoDb\DynamoDbClient;
// Send requests through a single proxy
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'proxy' => 'http://192.168.16.1:10'
]
]);
// Send requests through a different proxy per scheme
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'proxy' => [
'http' => 'tcp://192.168.16.1:10',
'https' => 'tcp://192.168.16.1:11',
]
]
]);
```
Sie können die `HTTP_PROXY`-Umgebungsvariable verwenden, sodass ein „http“-Protokoll-spezifischer Proxy konfiguriert wird, und die `HTTPS_PROXY`-Umgebungsvariable, sodass ein „https“-spezifischer Proxy konfiguriert wird.
### sink
Typ
`resource|string|Psr\Http\Message\StreamInterface`
Die `sink`-Option steuert, wohin die Antwortdaten einer Operation heruntergeladen werden.
+ Geben Sie eine `resource` wie von `fopen` zurückgegeben zum Herunterladen des Antwortrumpfs in einen PHP-Stream an.
+ Geben Sie den Pfad zu einer Datei auf der Festplatte als `string`-Wert an, um den Antwortrumpf in eine bestimmte Datei auf der Festplatte herunterzuladen.
+ Geben Sie ein `Psr\Http\Message\StreamInterface` an, um den Antwortrumpf in ein spezifisches PSR-Streamobjekt herunterzuladen.
**Anmerkung**
Das SDK lädt den Antwortrumpf standardmäßig in einen temporären PHP-Stream herunter. Das bedeutet, dass die Daten im Speicher bleiben, bis die Größe des Rumpfs 2 MB erreicht. Zu diesem Zeitpunkt werden die Daten in eine temporäre Datei auf der Festplatte geschrieben.
### synchronous
Typ
`bool`
Die `synchronous`-Option informiert den zugrundeliegenden HTTP-Handler darüber, dass Sie das Ergebnis blockieren wollen.
### stream
Typ
`bool`
Auf `true` setzen, um dem zugrundeliegenden HTTP-Handler mitzuteilen, dass Sie den Antwortrupf einer Antwort vom Webservice streamen möchten, anstatt alles im Voraus herunterzuladen. Diese Option wird beispielsweise in der Amazon S3 S3-Stream-Wrapper-Klasse verwendet, um sicherzustellen, dass die Daten gestreamt werden.
### timeout
Typ
`float`
Eine Fließkommazahl, die das Timeout der Anfrage in Sekunden beschreibt. Verwenden Sie `0` für unbestimmtes Warten (das Standardverhalten).
```
use Aws\DynamoDb\DynamoDbClient;
// Timeout after 5 seconds
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'timeout' => 5
]
]);
```
### verify
Typ
`bool|string`
Mithilfe der Option können Sie das Verhalten des SDK bei der Überprüfung von SSL/TLS Peer-Zertifikaten anpassen. `verify` `http`
+ Stellen Sie diese `true` Option ein, um die Überprüfung von SSL/TLS Peer-Zertifikaten zu aktivieren und das vom Betriebssystem bereitgestellte Standard-CA-Paket zu verwenden.
+ Auf `false` setzen, um die Peer-Zertifikatsverifizierung zu deaktivieren. (Das ist nicht sicher\$1)
+ Auf eine Zeichenfolge setzen, um den Pfad zu einem CA-Zertifikat-Bundle bereitzustellen, um die Verifizierung mit einem benutzerdefinierten CA-Bundle zu ermöglichen.
Wenn das CA-Bundle für Ihr System nicht gefunden werden kann und Sie einen Fehler erhalten, stellen Sie dem SDK den Pfad zu einem CA-Bundle bereit. Wenn Sie kein bestimmtes CA-Bundle benötigen, bietet Mozilla ein häufig verwendetes CA-Bundle an, das Sie [hier](https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt) herunterladen können (dies wird vom Betreuer von cURL gepflegt.). Sobald Sie ein CA-Bundle auf der Festplatte haben, können Sie die `openssl.cafile` PHP .ini so einstellen, dass sie auf den Pfad zur Datei verweist, sodass Sie die `verify`-Anfrageoption weglassen können. Weitere Informationen über SSL-Zertifikate finden Sie auf der [cURL-Website](http://curl.haxx.se/docs/sslcerts.html).
```
use Aws\DynamoDb\DynamoDbClient;
// Use a custom CA bundle
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'verify' => '/path/to/my/cert.pem'
]
]);
// Disable SSL/TLS verification
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http' => [
'verify' => false
]
]);
```
## http\$1handler
Typ
`callable`
Die `http_handler`-Option wird für die Integration des SDK mit anderen HTTP-Clients verwendet. Eine `http_handler`-Option ist eine Funktion, die ein `Psr\Http\Message\RequestInterface`-Objekt akzeptiert, und ein Array mit `http`-Optionen, die auf den Befehl angewendet werden, und die ein `GuzzleHttp\Promise\PromiseInterface`-Objekt zurückgibt, das mit einem `Psr\Http\Message\ResponseInterface`-Objekt erfüllt oder mit einem Array mit den folgenden Ausnahmedaten abgelehnt wird:
+ `exception` – (`\Exception`) die Ausnahme, die festgestellt wurde.
+ `response` – (`Psr\Http\Message\ResponseInterface`) die (gegebenenfalls) erhaltene Antwort.
+ `connection_error` – (bool) gleich `true`, um den Fehler als Verbindungsfehler zu kennzeichnen. Wenn dieser Wert auf `true` gesetzt wird, kann das SDK die Operation gegebenenfalls automatisch wiederholen.
Das SDK konvertiert automatisch den vorgegebenen `http_handler` in eine normale `handler`-Option, indem es den bereitgestellten `http_handler` in ein `Aws\WrappedHttpHandler`-Objekt kapselt.
Standardmäßig verwendet das SDK Guzzle als HTTP-Handler. Sie können hier einen anderen HTTP-Handler angeben oder einen Guzzle-Client mit eigenen benutzerdefinierten Optionen bereitstellen.
**Festlegen der TLS-Version**
Ein Anwendungsfall besteht darin, die von Guzzle verwendete TLS-Version mit Curl festzulegen, vorausgesetzt, dass Curl in Ihrer Umgebung installiert ist. Beachten Sie die Curl-[Versionseinschränkungen](https://curl.haxx.se/libcurl/c/CURLOPT_SSLVERSION.html) für die unterstützte Version von TLS. Standardmäßig wird die neueste Version verwendet. Wenn die TLS-Version explizit festgelegt ist und der Remoteserver diese Version nicht unterstützt, wird anstelle einer früheren TLS-Version ein Fehler ausgegeben.
Sie können die TLS-Version festlegen, die für eine bestimmte Client-Operation verwendet wird, indem Sie die `debug`-Client-Option auf „true“ setzen und die SSL-Verbindungsausgabe prüfen. Diese Zeile könnte etwa so aussehen: `SSL connection using TLSv1.2`
Beispiel für das Festlegen von TLS 1.2 mit Guzzle 6:
```
use Aws\DynamoDb\DynamoDbClient;
use Aws\Handler\GuzzleV6\GuzzleHandler;
use GuzzleHttp\Client;
$handler = new GuzzleHandler(
new Client([
'curl' => [
CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1_2
]
])
);
$client = new DynamoDbClient([
'region' => 'us-west-2',
'http_handler' => $handler
]);
```
**Anmerkung**
Die `http_handler`-Option ersetzt alle angegebenen `handler`-Optionen.
## Profil
Typ
`string`
Die Option „Profil“ gibt an, welches Profil verwendet werden soll, wenn Anmeldeinformationen aus der AWS Anmeldeinformationsdatei in Ihrem HOME-Verzeichnis erstellt werden (normalerweise`~/.aws/credentials`). Diese Einstellung überschreibt die `AWS_PROFILE`-Umgebungsvariable.
**Anmerkung**
Wenn Sie die Option „Profil“ angeben, wird die `"credentials"` Option ignoriert und die Einstellungen für Anmeldeinformationen in der AWS Konfigurationsdatei werden (normalerweise`~/.aws/config`) ignoriert.
```
// Use the "production" profile from your credentials file
$ec2 = new Aws\Ec2\Ec2Client([
'version' => '2014-10-01',
'region' => 'us-west-2',
'profile' => 'production'
]);
```
Weitere Informationen [zur Konfiguration von Anmeldeinformationen und zum .ini-Dateiformat finden Sie unter Anmeldeinformationen für AWS SDK für PHP Version 3.](guide_credentials.md)
## Region
Typ
`string`
Erforderlich
true
AWS Region, zu der eine Verbindung hergestellt werden soll. Eine Liste der verfügbaren [AWS Regionen finden Sie unter Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html).
```
// Set the Region to the EU (Frankfurt) Region
$s3 = new Aws\S3\S3Client([
'region' => 'eu-central-1',
'version' => '2006-03-01'
]);
```
## retries
Typ
`int|array|Aws\CacheInterface|Aws\Retry\ConfigurationInterface|callable`
Standard
`int(3)`
Konfiguriert den Wiederholungsmodus und die maximal zulässige Anzahl von Wiederholungen für einen Client. Übergeben Sie `0`, um Wiederholungen zu deaktivieren.
Die drei Wiederholungsmodi sind:
+ `legacy`- die standardmäßige Legacy-Wiederholungsimplementierung
+ `standard`- fügt ein Quotensystem für Wiederholungsversuche hinzu, um Wiederholungsversuche zu verhindern, bei denen es unwahrscheinlich ist, dass sie erfolgreich sind
+ `adaptive` – baut auf dem Standardmodus auf und fügt eine clientseitige Ratenbegrenzung hinzu. Beachten Sie, dass dieser Modus als experimentell betrachtet wird.
Die Konfiguration für Wiederholungen besteht aus dem Modus und den maximal zulässigen Versuchen für die einzelnen Anforderungen. Die Konfiguration kann an mehreren verschiedenen Orten in der folgenden Rangfolge festgelegt werden.
**Rangfolge**
Die Rangfolge für die Wiederholungskonfiguration lautet wie folgt (1 überschreibt 2-3 usw.):
1. Client-Konfigurationsoption
1. Umgebungsvariablen
1. AWS Gemeinsam genutzte Konfigurationsdatei
**Umgebungsvariablen**
+ `AWS_RETRY_MODE` – festgelegt auf `legacy`, `standard` oder `adaptive`
+ `AWS_MAX_ATTEMPTS` – festgelegt auf einen ganzzahligen Wert für die maximal zulässigen Versuche pro Anforderung
**Schlüssel für Datei mit gemeinsam verwendeter Konfiguration**
+ `retry_mode` – festgelegt auf `legacy`, `standard` oder `adaptive`
+ `max_attempts` – festgelegt auf einen ganzzahligen Wert für die maximal zulässigen Versuche pro Anforderung
**Client-Konfiguration**
Das folgende Beispiel deaktiviert Wiederholungen für den Amazon DynamoDB-Client.
```
// Disable retries by setting "retries" to 0
$client = new Aws\DynamoDb\DynamoDbClient([
'version' => '2012-08-10',
'region' => 'us-west-2',
'retries' => 0
]);
```
Im folgenden Beispiel wird ein ganzzahliger Wert übergeben, der standardmäßig den `legacy`-Modus mit der übergebenen Anzahl von Wiederholungen aufweist
```
// Disable retries by setting "retries" to 0
$client = new Aws\DynamoDb\DynamoDbClient([
'version' => '2012-08-10',
'region' => 'us-west-2',
'retries' => 6
]);
```
**Das Objekt `Aws\Retry\Configuration` akzeptiert zwei Parameter, den Wiederholungsmodus**
und einen ganze Wert für die maximal zulässigen Versuche pro Anforderung. In diesem Beispiel wird ein
`Aws\Retry\Configuration`-Objekt für die Wiederholungskonfiguration übergeben.
```
use Aws\EndpointDiscovery\Configuration;
use Aws\S3\S3Client;
$enabled = true;
$cache_limit = 1000;
$config = new Aws\Retry\Configuration('adaptive', 10);
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-2',
'retries' => $config,
]);
```
In diesem Beispiel wird ein Array für die Wiederholungskonfiguration übergeben.
```
use Aws\S3\S3Client;
$s3 = new S3Client([
'region' => 'us-west-2',
'retries' => [
'mode' => 'standard',
'max_attempts' => 7
],
]);
```
In diesem Beispiel wird eine Instance von `Aws\CacheInterface` übergeben, um die vom Standardanbieter für Wiederholungskonfigurationen zurückgegebenen Werte zwischenzuspeichern.
```
use Aws\DoctrineCacheAdapter;
use Aws\S3\S3Client;
use Doctrine\Common\Cache\ApcuCache;
$s3 = new S3Client([
'region' => 'us-west-2',
'endpoint_discovery' => new DoctrineCacheAdapter(new ApcuCache),
]);
```
## scheme
Typ
`string`
Standard
`string(5) "https"`
URI-Schema, das für die Verbindung verwendet werden soll. Das SDK verwendet standardmäßig „https“-Endpunkte (d. h., SSL/TLS-Verbindungen). Sie können versuchen, eine Verbindung zu einem Service über einen unverschlüsselten „http“-Endpunkt herzustellen, indem Sie `scheme` auf „http“ setzen.
```
$s3 = new Aws\S3\S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'scheme' => 'http'
]);
```
Unter [AWS Regionen und Endpunkte finden Sie eine Liste der Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) und ob ein Service das Schema unterstützt. `http`
## Service nicht zulässig
Typ
`string`
Erforderlich
true
Name des zu verwendenden Service. Dieser Wert wird standardmäßig bereitgestellt, wenn Sie einen vom SDK bereitgestellten Client verwenden (z. B. `Aws\S3\S3Client`). Diese Option ist nützlich, wenn Sie einen Service testen, der noch nicht im SDK veröffentlicht wurde, aber auf der Festplatte verfügbar ist.
## signature\$1provider
Typ
`callable`
Ein Callable, das einen Signaturversionsnamen (z. B.`v4`), einen Dienstnamen und eine AWS Region akzeptiert und ein `Aws\Signature\SignatureInterface` Objekt zurückgibt oder `NULL` ob der Anbieter in der Lage ist, einen Unterzeichner für die angegebenen Parameter zu erstellen. Dieser Anbieter wird verwendet, um vom Client verwendete Signaturgeber zu erstellen.
Es gibt verschiedene Funktionen des SDK in der `Aws\Signature\SignatureProvider`-Klasse, die genutzt werden können, um benutzerdefinierte Signaturanbieter zu erstellen.
## signature\$1version
Typ
`string`
Eine Zeichenfolge, die eine benutzerdefinierte Signaturversion darstellt, die für einen Service verwendet wird (z. B. `v4` usw.). Die pro Operation verwendete Signaturversion KANN diese angeforderte Signaturversion bei Bedarf übersteuern.
Die folgenden Beispiele zeigen, wie ein Amazon S3 S3-Client für die Verwendung der [Signaturversion 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) konfiguriert wird:
```
// Set a preferred signature version
$s3 = new Aws\S3\S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'signature_version' => 'v4'
]);
```
**Anmerkung**
Der von Ihrem Client verwendete `signature_provider` MUSS die Möglichkeit bieten, die von Ihnen bereitgestellte `signature_version`-Option zu erstellen. Der vom SDK verwendete standardmäßige `signature_provider` kann Signaturobjekte für „v4“ und „anonyme“ Signaturversionen erstellen.
## ua\$1append
Typ
`string|string[]`
Standard
`[]`
Eine Zeichenfolge oder ein Array von Zeichenfolgen, die der dem HTTP-Handler übergebenen Benutzeragenten-Zeichenfolge hinzugefügt werden.
## use\$1aws\$1shared\$1config\$1files
Typ
`bool|array`
Standard
`bool(true)`
Auf false setzen, um die Suche nach einer gemeinsam genutzten Konfigurationsdatei in '\$1/ zu deaktivieren. aws/config’ and ‘\$1/.aws/credentials'. Dadurch wird die AWS\$1CONFIG\$1FILE Umgebungsvariable überschrieben.
## validieren
Typ
`bool|array`
Standard
`bool(true)`
Auf `false` setzen, um die clientseitige Parametervalidierung zu deaktivieren. Sie werden vielleicht feststellen, dass die Deaktivierung der Validierung die Leistung des Clients etwas verbessert, aber der Unterschied ist vernachlässigbar.
```
// Disable client-side validation
$s3 = new Aws\S3\S3Client([
'version' => '2006-03-01',
'region' => 'eu-west-1',
'validate' => false
]);
```
Auf ein assoziatives Array von Validierungsoptionen setzen, um spezifische Validierungsbedingungen zu aktivieren:
+ `required` – Validieren, ob die erforderlichen Parameter vorhanden sind (standardmäßig aktiviert).
+ `min` – Validieren der Mindestlänge eines Werts (standardmäßig aktiviert).
+ `max` – Validieren der maximalen Länge eines Werts.
+ `pattern` – Validieren, ob der Wert mit einem regulären Ausdruck übereinstimmt.
```
// Validate only that required values are present
$s3 = new Aws\S3\S3Client([
'version' => '2006-03-01',
'region' => 'eu-west-1',
'validate' => ['required' => true]
]);
```
## version
Typ
`string`
Erforderlich
false
Diese Option gibt die Version des Webdienstes an, die verwendet werden soll (z. B.`2006-03-01`).
Ab Version 3.277.10 des SDK ist die Option „Version“ nicht erforderlich. Wenn Sie die Option „Version“ nicht angeben, verwendet das SDK die neueste Version des Service-Clients.
In zwei Situationen ist ein „Version“ -Parameter erforderlich, wenn Sie einen Service-Client erstellen.
+ Sie verwenden eine ältere Version des PHP-SDK als 3.277.10.
+ Sie verwenden Version 3.277.10 oder höher und möchten eine andere Version als die „neueste“ für einen Service-Client verwenden.
Das folgende Snippet verwendet beispielsweise Version 3.279.7 des SDK, aber nicht die neueste Version für. `Ec2Client`
```
$ec2Client = new \Aws\Ec2\Ec2Client([
'version' => '2015-10-01',
'region' => 'us-west-2'
]);
```
Die Angabe einer Versionsbeschränkung stellt sicher, dass Ihr Code nicht durch eine Unterbrechung des Service beeinträchtigt wird.
Eine Liste der verfügbaren API-Versionen finden Sie auf den Seiten für die [API-Dokumentation](https://docs.aws.amazon.com/aws-sdk-php/v3/api/index.html) für jeden Client. Wenn Sie eine bestimmte API-Version nicht laden können, müssen Sie möglicherweise Ihre Kopie des SDK aktualisieren.