Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Utilizar un proveedor de credencial

Un proveedor de credenciales es una función que devuelve un GuzzleHttp\Promise\PromiseInterface que se ejecuta con una instancia Aws\Credentials\CredentialsInterface o se rechaza con un Aws\Exception\CredentialsException. Puede utilizar proveedores de credenciales para implementar su propia lógica personalizada para crear credenciales o para optimizar la carga de credenciales.

Los proveedores de credenciales se transfieren a la opción de constructor de clientes credentials. Los proveedores de credenciales son asíncronos, lo que obliga a evaluarlos lentamente cada vez que se invoca una operación de la API. Por ello, si se pasa una función de proveedor de credenciales a un constructor de cliente del SDK, no se validan inmediatamente las credenciales. Si el proveedor de credenciales no devuelve un objeto de credenciales, se rechazará una operación de la API con una Aws\Exception\CredentialsException.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

// Use the default credential provider
$provider = CredentialProvider::defaultProvider();

// Pass the provider to the client
$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Proveedores integrados en el SDK

El SDK proporciona varios proveedores integrados que se pueden combinar con los proveedores personalizados que se deseen. Para obtener más información sobre la configuración de los proveedores estandarizados y la cadena de proveedores de credenciales en AWS los SDK, consulte los proveedores de credenciales estandarizados en la Guía de referencia de AWS SDK y herramientas.

Proveedor assumeRole

Si utiliza Aws\Credentials\AssumeRoleCredentialProvider para crear credenciales asumiendo un rol, debe proporcionar la información de 'client' con un objeto StsClient y con los detalles de 'assume_role_params', tal como se muestra a continuación.

use Aws\Credentials\CredentialProvider;
use Aws\Credentials\InstanceProfileProvider;
use Aws\Credentials\AssumeRoleCredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;

// Passing Aws\Credentials\AssumeRoleCredentialProvider options directly
$profile = new InstanceProfileProvider();
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";

$assumeRoleCredentials = new AssumeRoleCredentialProvider([
    'client' => new StsClient([
        'region' => 'us-east-2',
        'version' => '2011-06-15',
        'credentials' => $profile
    ]),
    'assume_role_params' => [
        'RoleArn' => $ARN,
        'RoleSessionName' => $sessionName,
    ],
]);

// To avoid unnecessarily fetching STS credentials on every API operation,
// the memoize function handles automatically refreshing the credentials when they expire
$provider = CredentialProvider::memoize($assumeRoleCredentials);

$client = new S3Client([
    'region'      => 'us-east-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Para obtener más información al respecto'assume_role_params', consulte. AssumeRole

Proveedor de SSO

Aws\Credentials\CredentialProvider::ssoes el proveedor de credenciales de inicio de sesión único. Este proveedor también se conoce como proveedor de credenciales. AWS IAM Identity Center

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$credentials = new Aws\CredentialProvider::sso('profile default');

$s3 = new Aws\S3\S3Client([
    'version'     => 'latest',
    'region'      => 'us-west-2',
    'credentials' => $credentials
]);

Si utiliza un perfil con nombre, sustituya el nombre de su perfil por “default” en el ejemplo anterior. Para obtener más información sobre la configuración de perfiles con nombre, consulte los archivos compartidos config y credentials en la Guía de referencia de los AWS SDK y las herramientas.. También puede utilizar la variable de entorno AWS_PROFILE para indicar la configuración del perfil que desea utilizar.

Para comprender mejor cómo funciona el proveedor del Centro de identidades de IAM, consulte Comprender la autenticación del Centro de Identidades de IAM en la Guía de referencia de los AWS SDK y las herramientas.

Encadenamiento de proveedores

Es posible encadenar los proveedores de credenciales mediante la función Aws\Credentials\CredentialProvider::chain(). Esta función acepta un número de argumentos variádico, cada uno de los cuales es una función de proveedor de credenciales. A continuación, esta función devuelve una función nueva que se compone de las funciones proporcionadas, de modo que se invocan una tras otra hasta que uno de los proveedores devuelve una promesa que se cumple correctamente.

El defaultProvider utiliza esta composición para comprobar varios proveedores antes de que se produzca un error. El origen del defaultProvider demuestra el uso de la función chain.

// This function returns a provider
public static function defaultProvider(array $config = [])
{
    // This function is the provider, which is actually the composition
    // of multiple providers. Notice that we are also memoizing the result by
    // default.
    return self::memoize(
        self::chain(
            self::env(),
            self::ini(),
            self::instanceProfile($config)
        )
    );
}

Creación de un proveedor personalizado

Los proveedores de credenciales son simplemente funciones que cuando se invocan devuelven una promesa (GuzzleHttp\Promise\PromiseInterface) que se cumple con un objeto Aws\Credentials\CredentialsInterface o se rechaza con una Aws\Exception\CredentialsException.

Una práctica recomendada para la creación de proveedores consiste en crear una función que se invoca para crear el proveedor de credenciales real. Por ejemplo esto es el origen del proveedor env (ligeramente modificado para los fines del ejemplo). Observe que es una función que devuelve la función de proveedor real. Esto le permite crear fácilmente proveedores de credenciales y pasarlos como valores.

use GuzzleHttp\Promise;
use GuzzleHttp\Promise\RejectedPromise;

// This function CREATES a credential provider
public static function env()
{
    // This function IS the credential provider
    return function () {
        // Use credentials from environment variables, if available
        $key = getenv(self::ENV_KEY);
        $secret = getenv(self::ENV_SECRET);
        if ($key && $secret) {
            return Promise\promise_for(
                new Credentials($key, $secret, getenv(self::ENV_SESSION))
            );
        }

        $msg = 'Could not find environment variable '
            . 'credentials in ' . self::ENV_KEY . '/' . self::ENV_SECRET;
        return new RejectedPromise(new CredentialsException($msg));
    };
}

Proveedor defaultProvider

Aws\Credentials\CredentialProvider::defaultProvider es el proveedor de credenciales predeterminado. Este proveedor se utiliza si se omite una opción credentials al crear un cliente. Primero intenta cargar las credenciales a partir de las variables de entorno, después desde un archivo .ini (primero un archivo .aws/credentials y luego un archivo .aws/config) y, por último, desde un perfil de instancia (primero EcsCredentials, seguido de los metadatos de Ec2).

Proveedor ecsCredentials

Aws\Credentials\CredentialProvider::ecsCredentials intenta cargar las credenciales mediante una solicitud GET cuyo URI se especifica mediante la variable de entorno AWS_CONTAINER_CREDENTIALS_RELATIVE_URI del contenedor.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $memoizedProvider
]);

Proveedor env

Aws\Credentials\CredentialProvider::env intenta cargar las credenciales desde las variables de entorno.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => CredentialProvider::env()
]);

assumeRoleWithWebIdentityCredentialProvider proveedor

Aws\Credentials\CredentialProvider::assumeRoleWithWebIdentityCredentialProvider intenta cargar las credenciales al asumir un rol. Si las variables de entorno AWS_ROLE_ARN y AWS_WEB_IDENTITY_TOKEN_FILE están presentes, el proveedor intentará asumir el rol especificado en AWS_ROLE_ARN utilizando el token en un disco en la ruta completa especificada en AWS_WEB_IDENTITY_TOKEN_FILE. Si se emplean las variables de entorno, el proveedor intentará establecer la sesión desde la variable de entorno AWS_ROLE_SESSION_NAME.

Si las variables de entorno no están establecidas, el proveedor utilizará el perfil predeterminado o el establecido como AWS_PROFILE. El proveedor lee los perfiles de ~/.aws/credentials y ~/.aws/config de forma predeterminada y puede leer desde los perfiles especificados en la opción de configuración filename. El proveedor asumirá el rol en el role_arn del perfil al leer un token desde la ruta completa establecida en el web_identity_token_file. El role_session_name se utilizará si está establecido en el perfil.

El proveedor se denomina como parte de la cadena predeterminada y se le puede llamar directamente.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

De forma predeterminada, este proveedor de credenciales heredará la región configurada que utilizará StsClient para asumir la función. Opcionalmente, se StsClient puede proporcionar una versión completa. Las credenciales deben configurarse como false en las que se proporcionan StsClient.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;

$stsClient = new StsClient([
    'region'      => 'us-west-2',
    'version'     => 'latest',
    'credentials' => false
])

$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider([
    'stsClient' => $stsClient
]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Proveedor ini

Aws\Credentials\CredentialProvider::ini intenta cargar las credenciales desde un archivo de credenciales ini. De forma predeterminada, el SDK intenta cargar el perfil «predeterminado» desde el AWS credentials archivo compartido ubicado en~/.aws/credentials.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$provider = CredentialProvider::ini();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Puede utilizar un perfil personalizado o una ubicación de archivo.ini proporcionando argumentos a la función que crea el proveedor.

$profile = 'production';
$path = '/full/path/to/credentials.ini';

$provider = CredentialProvider::ini($profile, $path);
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Proveedor process

Aws\Credentials\CredentialProvider::process intenta cargar las credenciales desde un credential_process especificado en un archivo ini de credenciales. De forma predeterminada, el SDK intenta cargar el perfil «predeterminado» desde el AWS credentials archivo compartido ubicado en~/.aws/credentials. El SDK llamará al comando credential_process exactamente como se especifica y, a continuación, leerá los datos JSON desde stdout. El comando credential_process debe escribir las credenciales en stdout con el formato siguiente:

{
    "Version": 1,
    "AccessKeyId": "",
    "SecretAccessKey": "",
    "SessionToken": "",
    "Expiration": ""
}

SessionToken y Expiration son opcionales. Si se utilizan, las credenciales se considerarán temporales.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$provider = CredentialProvider::process();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Puede utilizar un perfil personalizado o una ubicación de archivo.ini proporcionando argumentos a la función que crea el proveedor.

$profile = 'production';
$path = '/full/path/to/credentials.ini';

$provider = CredentialProvider::process($profile, $path);
$provider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Proveedor instanceProfile

Aws\Credentials\CredentialProvider::instanceProfile intenta cargar credenciales desde perfiles de instancia de Amazon EC2.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $memoizedProvider
]);

De forma predeterminada, el proveedor vuelve a intentar buscar licencias hasta tres veces. El número de reintentos se puede establecer con la opción retries y se puede deshabilitar por completo al establecer la opción en 0.

use Aws\Credentials\CredentialProvider;

$provider = CredentialProvider::instanceProfile([
    'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);

Memoización de credenciales

A veces es necesario crear un proveedor de credenciales que recuerde el valor de retorno anterior. Esto puede resultar útil para el rendimiento cuando cargar credenciales es una operación costosa o cuando se utiliza la clase Aws\Sdk para compartir un proveedor de credenciales entre varios clientes. Puede añadir memoización a un proveedor de credenciales encapsulando la función de proveedor de credenciales en una función memoize.

use Aws\Credentials\CredentialProvider;

$provider = CredentialProvider::instanceProfile();
// Wrap the actual provider in a memoize function
$provider = CredentialProvider::memoize($provider);

// Pass the provider into the Sdk class and share the provider
// across multiple clients. Each time a new client is constructed,
// it will use the previously returned credentials as long as
// they haven't yet expired.
$sdk = new Aws\Sdk(['credentials' => $provider]);

$s3 = $sdk->getS3(['region' => 'us-west-2', 'version' => 'latest']);
$ec2 = $sdk->getEc2(['region' => 'us-west-2', 'version' => 'latest']);

assert($s3->getCredentials() === $ec2->getCredentials());

Cuando vencen las credenciales memoizadas, el encapsulador de memoización invoca al proveedor encapsulado para actualizarlas.