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.
# Proveedores de credenciales integrados en la AWS SDK para PHP versión 3
El SDK proporciona varios proveedores de credenciales integrados que puede utilizar de forma individual o combinar en una [cadena de proveedores de credenciales personalizada](chaining-providers.md).
Cuando especifica un proveedor de credenciales durante la creación del cliente de servicio, el SDK intenta cargar las credenciales solo con el proveedor de credenciales especificado. No utiliza la [cadena de proveedores de credenciales predeterminada](guide_credentials_default_chain.md). Si sabe que desea que un cliente de servicio utilice el proveedor `instanceProfile`, puede omitir la cadena predeterminada si especifica el proveedor `instanceProfile` en el constructor del cliente de servicio:
```
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',
'credentials' => $memoizedProvider // The default credential provider chain is not used.
]);
```
**importante**
Los proveedores de credenciales se invocan cada vez que se ejecuta una operación de la API. Si la carga de credenciales es una tarea costosa (por ejemplo, la carga se realiza desde un disco o un recurso de red) o si el proveedor no guarda en caché las credenciales, considere la posibilidad de encapsular el proveedor de credenciales en una función `Aws\Credentials\CredentialProvider::memoize`. El proveedor de credenciales predeterminado que utiliza el SDK se memoríza automáticamente.
**Topics**
+ [Proveedor `login` en el SDK para PHP](login-provider.md)
+ [Proveedor `assumeRole` en el SDK para PHP](assumerole-provider.md)
+ [Proveedor `sso` en el SDK para PHP](sso-provider.md)
+ [Proveedor `defaultProvider` en el SDK para PHP](defaultprovider-provider.md)
+ [Proveedor `ecsCredentials` en el SDK para PHP](ecscredentials-provider.md)
+ [Proveedor `env` en el SDK para PHP](env-provider.md)
+ [Proveedor `assumeRoleWithWebIdentityCredentialProvider` en el SDK para PHP](assume-role-with-web-identity-provider.md)
+ [Proveedor `ini` en el SDK para PHP](ini-provider.md)
+ [Proveedor `process` en el SDK para PHP](process-provider.md)
+ [Proveedor `instanceProfile` en el SDK para PHP](instanceprofile-provider.md)
# Proveedor `login` en el SDK para PHP
`Aws\Credentials\CredentialProvider::login`intenta cargar las credenciales configuradas por una sesión de inicio de sesión basada en un navegador facilitada por herramientas como la CLI AWS . Tras la autenticación, AWS genera credenciales temporales que funcionan en todas las herramientas AWS SDKs y locales.
Con este proceso, puedes autenticarte con las credenciales raíz creadas durante la configuración inicial de la cuenta, un usuario de IAM o una identidad federada de tu proveedor de identidad, y el AWS SDK para PHP administrará automáticamente las credenciales temporales por ti. Este enfoque mejora la seguridad al eliminar la necesidad de almacenar localmente las credenciales a largo plazo.
Al ejecutar el comando `aws login`, puede seleccionar una de las sesiones de consola activas o iniciar sesión mediante el flujo de autenticación basado en el navegador, lo que generará credenciales temporales automáticamente. El AWS SDK para PHP actualizará automáticamente estas credenciales mediante el servicio de inicio de sesión durante un máximo de 12 horas.
El proveedor de inicio de sesión intenta cargar el token de acceso generado por el flujo de trabajo de la sesión de inicio de sesión mencionado anteriormente, en función del perfil proporcionado. Si no se proporciona ningún perfil al llamar al proveedor, este intentará resolver un perfil comprobando primero la variable de `AWS_PROFILE` entorno antes de volver al perfil`default`. La configuración integrada en el código se puede transferir al proveedor, donde este buscará un `region` valor para el cliente del servicio de inicio de sesión utilizado para actualizar las credenciales. Si no se proporciona ninguna región en la matriz de configuración, el proveedor intentará resolver una región comprobando la variable de `AWS_REGION` entorno y, a continuación, un valor de región establecido en el perfil resuelto. Si no se encuentra ninguna región, el proveedor devolverá una promesa rechazada con instrucciones sobre cómo configurar una región.
Se llama al proveedor como parte de la cadena predeterminada y se le puede llamar directamente.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::login(, ['region' => ]);
// 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',
'credentials' => $provider
]);
```
De forma predeterminada, si no se proporciona ninguna configuración de credenciales en el cliente de servicio que desea utilizar, se llamará a este proveedor como parte de la cadena de `defaultProvider()` credenciales. En este escenario, la región del cliente de servicio se transfiere automáticamente al `login()` proveedor. También en este escenario, el valor del perfil transferido al proveedor de inicio de sesión se resolverá comprobando la variable de `AWS_PROFILE` entorno antes de volver al perfil`default`.
# Proveedor `assumeRole` en el SDK para PHP
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.
**nota**
Para evitar tener que buscar AWS STS credenciales de forma innecesaria en cada operación de la API, puedes utilizar la `memoize` función para actualizar automáticamente las credenciales cuando caduquen. Consulte el código siguiente para ver un ejemplo.
```
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](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)
# Proveedor `sso` en el SDK para PHP
`Aws\Credentials\CredentialProvider::sso` es el proveedor de credenciales de inicio de sesión único. Este proveedor también se conoce como proveedor de AWS IAM Identity Center credenciales.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$credentials = 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 asignado, consulte [`credentials`Archivos `config` y compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) en la *Guía de referencia de AWS SDKs and Tools*. También puede utilizar la variable de entorno [https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) para indicar la configuración del perfil que desea utilizar.
Para obtener más información sobre cómo funciona el proveedor del Centro de Identidad de IAM, consulte Cómo [entender la autenticación del Centro de Identidad de IAM](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) en la Guía de *referencia de herramientas AWS SDKs y herramientas*.
# Proveedor `defaultProvider` en el SDK para PHP
`Aws\Credentials\CredentialProvider::defaultProvider` es el proveedor de credenciales predeterminado y también se denomina [cadena de proveedores de credenciales predeterminada](guide_credentials_default_chain.md). Este proveedor se utiliza si se omite una opción `credentials` al crear un cliente. Por ejemplo, si crea un S3Client como se muestra en el siguiente fragmento, el SDK utiliza el proveedor predeterminado:
```
$client = new S3Client([
'region' => 'us-west-2'
]);
```
También puede utilizar defaultProvider en el código si desea proporcionar parámetros a proveedores de credenciales específicos de la cadena. En el siguiente ejemplo se establece un tiempo de espera de conexión personalizado y una configuración de reintentos si se utiliza la función del proveedor `ecsCredentials`.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::defaultProvider([
'timeout' => '1.5',
'retries' => 5
]);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
# Proveedor `ecsCredentials` en el SDK para PHP
`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` en el SDK para PHP
El uso de variables de entorno para contener sus credenciales evita que comparta accidentalmente su clave de acceso AWS secreta. Le recomendamos que nunca añada sus claves de AWS acceso directamente al cliente en ningún archivo de producción.
Para autenticarse en Amazon Web Services, el SDK comprueba primero las credenciales en sus variables de entorno. El SDK utiliza la función `getenv()` para buscar las variables de entorno `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `AWS_SESSION_TOKEN`. Estas credenciales se denominan credenciales de entorno. Para obtener instrucciones sobre cómo obtener estos valores, consulte [Autenticación mediante credenciales de corta duración](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
Si alojas la aplicación en ella [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_PHP_eb.html), puedes configurar las `AWS_ACCESS_KEY_ID` variables de `AWS_SESSION_TOKEN` entorno y las variables de entorno [a través de la AWS Elastic Beanstalk consola](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-softwaresettings.html#environments-cfg-softwaresettings-console) para que el SDK pueda usar esas credenciales automáticamente. `AWS_SECRET_KEY`
Para obtener más información sobre cómo configurar las variables de entorno, consulta la [compatibilidad con las variables de entorno](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*. Además, para obtener una lista de todas las variables de entorno compatibles con la mayoría AWS SDKs, consulte la [lista de variables de entorno](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings).
También puede definir las variables de entorno en la línea de comandos, tal y como se muestra aquí.
**Linux**
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Cuenta de AWS.
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Cuenta de AWS.
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Cuenta de AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs other than PHP.
```
**Windows**
```
C:\> SET AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Cuenta de AWS.
C:\> SET AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Cuenta de AWS.
C:\> SET AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Cuenta de AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs besides PHP.
```
`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()
]);
```
# Proveedor `assumeRoleWithWebIdentityCredentialProvider` en el SDK para PHP
`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` en el SDK para PHP
`Aws\Credentials\CredentialProvider::ini` intenta cargar las credenciales de los archivos `config` y `credentials` compartidos. De forma predeterminada, el SDK intenta cargar el perfil «predeterminado» desde el AWS `credentials` archivo compartido ubicado en`~/.aws/credentials`. Si el SDK encuentra la variable de `AWS_SDK_LOAD_NONDEFAULT_CONFIG` entorno, también busca un perfil «predeterminado» en el AWS `config` archivo compartido ubicado en`~/.aws/config`.
```
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` en el SDK para PHP
`Aws\Credentials\CredentialProvider::process`intenta cargar las credenciales ejecutando el `credential_process` valor especificado en un perfil de un [archivo de AWS configuración compartido](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
De forma predeterminada, el SDK intenta cargar primero el perfil «predeterminado» desde el AWS `credentials` archivo compartido ubicado en`~/.aws/credentials`. Si no se encuentra el perfil “default” en el archivo `credentials` compartido, el SDK busca el perfil predeterminado en el archivo `config` compartido. A continuación, se muestra un ejemplo de configuración del archivo `credentials` compartido.
```
[default]
credential_process = /path/to/file/credential_returning_executable.sh --custom-command custom_parameter
```
El SDK llamará al comando `credential_process` exactamente tal y como se ha indicado utilizando la función `shell_exec` de PHP y, a continuación, leerá los datos JSON desde la salida estándar (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` en el SDK para PHP
`Aws\Credentials\CredentialProvider::instanceProfile` intenta cargar credenciales para un rol de IAM especificado en un perfil 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`, tal como se muestra en el siguiente código.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile([
'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);
```
Si la variable de entorno `AWS_METADATA_SERVICE_NUM_ATTEMPTS` está disponible, el valor tiene prioridad sobre la opción “retries” mostrada anteriormente.
**nota**
Puede deshabilitar este intento de carga desde los perfiles de instancia de Amazon EC2 estableciendo la variable de entorno `AWS_EC2_METADATA_DISABLED` en `true`.