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.
# Uso de AWS SDK para PHP proveedores de credenciales de la versión 3
Para obtener información de referencia sobre los mecanismos de credenciales disponibles AWS SDKs, consulte [Credenciales y acceso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) en la Guía de *referencia de herramientas AWS SDKs y herramientas*.
**importante**
Por motivos de seguridad, *le recomendamos encarecidamente* que **no** utilice la cuenta raíz para AWS acceder. Consulte siempre las [mejores prácticas de seguridad en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) en la *Guía del usuario de IAM* para conocer las recomendaciones de seguridad más recientes.
La función de un proveedor de credenciales en la AWS SDK para PHP versión 3 es obtener y proporcionar credenciales a los Servicio de AWS clientes del SDK. El SDK utiliza las credenciales que obtiene para autenticarse en el servicio mediante la firma criptográfica de cada solicitud. Las credenciales suelen consistir en claves de acceso: un ID de clave de acceso y una clave de acceso secreta juntas.
Cuando utilizas credenciales temporales, como cuando [configuras la autenticación del Centro de Identidad de IAM](credentials.md#use-idc-for-auth) o configuras tu entorno de ejecución para [que asuma una función de IAM](assumerole-provider.md), se añade un token de sesión a las claves de acceso, lo que proporciona un acceso a los recursos por tiempo limitado. AWS
## ¿Qué es un proveedor de credenciales en la versión 3? AWS SDK para PHP
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`. El [SDK proporciona varias implementaciones](built-in-providers-in-the-sdk.md) de funciones de proveedor de credenciales o bien puede [implementar una lógica propia](creating-a-custom-provider.md) y personalizada para crear credenciales u 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 ECS credential provider.
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials.
$memoizedProvider = CredentialProvider::memoize($provider);
// Pass the provider to the client
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# Descripción de la cadena de proveedores de credenciales predeterminada en la AWS SDK para PHP versión 3
La cadena de proveedores de credenciales predeterminada se compone de una serie de proveedores de credenciales integrados que invoca el SDK. Se implementa mediante la función de proveedor de credenciales [defaultProvider](defaultprovider-provider.md) sin parámetros. Una vez que se encuentran las credenciales válidas, se detiene la búsqueda.
AWS SDK para PHP Ejecuta los proveedores de credenciales en el siguiente orden:
+ [**Proveedor `env`**](env-provider.md): el SDK busca las [claves de acceso de AWS que se han establecido como variables de entorno](https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html).
+ [**Proveedor `assumeRoleWithWebIdentityCredentialProvider`**](assume-role-with-web-identity-provider.md): el SDK busca el rol de IAM y la configuración del archivo de token de identidad web.
+ En este punto de la cadena, el SDK busca la configuración en los archivos AWS `config` AND `credentials` compartidos. El SDK busca la configuración en el perfil “default”, pero si se ha establecido la variable de entorno `AWS_PROFILE`, el SDK utiliza el valor de perfil con nombre.
+ [**Proveedor `sso`**](sso-provider.md): el SDK busca las [opciones de configuración de IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) en el archivo `config` compartido.
+ [**`login provider`**](login-provider.md)- El SDK busca los ajustes de configuración de AWS la sesión de inicio de sesión de la consola en el `config` archivo compartido.
+ [**Proveedor `process`**](process-provider.md): el SDK busca la configuración `credential_process` en el archivo `credentials` compartido.
+ [**`ini`proveedor**](ini-provider.md): el SDK busca AWS las credenciales o la información sobre las funciones de IAM en el `credentials` archivo compartido.
+ [**Proveedor `process`**](process-provider.md): el SDK busca la configuración `credential_process` en el archivo `config` compartido.
+ [**`ini`proveedor**](ini-provider.md): el SDK busca las AWS credenciales o la información del rol de IAM en el archivo compartido`config`.
+ [**Proveedor `ecsCredentials`**](ecscredentials-provider.md): el SDK busca las variables de entorno `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI `o `AWS_CONTAINER_CREDENTIALS_FULL_URI` que proporcionan información para obtener credenciales temporales.
+ [**Proveedor `instanceProfile`**](instanceprofile-provider.md): el SDK utiliza el servicio de metadatos de instancia de EC2 para obtener el rol de IAM especificado en el perfil de instancia. Con la información del rol, el SDK utiliza credenciales temporales.
**nota**
El resultado del proveedor predeterminado se memoíza automáticamente.
Puedes revisar el código de la cadena en el [código GitHub fuente](https://github.com/aws/aws-sdk-php/blob/0a99dab427f0a1c082775301141aeac3558691ad/src/Credentials/CredentialProvider.php#L77).
# 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`.
# Encadenamiento de proveedores de credenciales en el SDK para PHP
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 de credenciales personalizado para utilizarlo con el SDK para PHP
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 Create::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));
};
}
```
# Almacenamiento en memoria de las credenciales en el SDK para PHP
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.
# Asuma una función de IAM con la AWS SDK para PHP versión 3
## Uso de roles de IAM para credenciales variables de instancias de Amazon EC2
Si ejecuta la aplicación en una instancia de Amazon EC2, la forma preferida de proporcionar credenciales para realizar llamadas AWS es utilizar un [rol de IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) para obtener credenciales de seguridad temporales.
Si utiliza roles de IAM, no tiene que ocuparse de la administración de credenciales desde la aplicación. Permiten que una instancia "asuma" un rol recuperando credenciales temporales del servidor de metadatos de la instancia de Amazon EC2.
Las credenciales temporales, que a menudo reciben el nombre de **credenciales del perfil de instancia**, permiten obtener acceso a las acciones y los recursos permitidos por la política del rol. Amazon EC2 administra todas las operaciones de autenticación segura de las instancias en el servicio de IAM para asumir el rol, así como las operaciones de actualización periódica de las credenciales del rol recuperadas. Esto mantiene su aplicación segura prácticamente sin esfuerzo por su parte. Para obtener una lista de los servicios que aceptan credenciales de seguridad temporales, consulte [los servicios AWS que funcionan con IAM ](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) en la*Guía del usuario de IAM*.
**nota**
Para evitar llegar siempre al servicio de metadatos, puede pasar una instancia de `Aws\CacheInterface` como opción `'credentials'` a un constructor de clientes. De este modo, el SDK utiliza las credenciales del perfil de instancia en su lugar. Para obtener información detallada, consulte [Configuración de la versión 3 de AWS SDK para PHP](guide_configuration.md).
*Para obtener más información sobre el desarrollo de aplicaciones de Amazon EC2 mediante el SDKs, consulte [Uso de funciones de IAM para instancias de Amazon EC2](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) en la AWS SDKs Guía de referencia de herramientas y herramientas.*
### Creación y asignación de un rol de IAM a una instancia de Amazon EC2
1. Cree un cliente de IAM.
**Importaciones**
```
require 'vendor/autoload.php';
use Aws\Iam\IamClient;
```
**Código de muestra**
```
$client = new IamClient([
'region' => 'us-west-2',
'version' => '2010-05-08'
]);
```
1. Cree un rol de IAM con los permisos necesarios para las acciones y los recursos que vaya a utilizar.
**Código de muestra**
```
$result = $client->createRole([
'AssumeRolePolicyDocument' => 'IAM JSON Policy', // REQUIRED
'Description' => 'Description of Role',
'RoleName' => 'RoleName', // REQUIRED
]);
```
1. Cree un perfil de instancia de IAM y guarde el nombre de recurso de Amazon (ARN) del resultado.
**nota**
Si utiliza la consola de IAM en lugar de la AWS SDK para PHP, la consola crea un perfil de instancia automáticamente y le asigna el mismo nombre que la función a la que corresponde.
**Código de muestra**
```
$IPN = 'InstanceProfileName';
$result = $client->createInstanceProfile([
'InstanceProfileName' => $IPN ,
]);
$ARN = $result['Arn'];
$InstanceID = $result['InstanceProfileId'];
```
1. Cree un cliente de Amazon EC2.
**Importaciones**
```
require 'vendor/autoload.php';
use Aws\Ec2\Ec2Client;
```
**Código de muestra**
```
$ec2Client = new Ec2Client([
'region' => 'us-west-2',
'version' => '2016-11-15',
]);
```
1. Añada el perfil de instancia a una instancia de Amazon EC2 en ejecución o detenida. Utilice el nombre del perfil de instancia del rol de IAM.
**Código de muestra**
```
$result = $ec2Client->associateIamInstanceProfile([
'IamInstanceProfile' => [
'Arn' => $ARN,
'Name' => $IPN,
],
'InstanceId' => $InstanceID
]);
```
Para obtener más información, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.
## Uso de roles de IAM para tareas de Amazon ECS
Una tarea de Amazon Elastic Container Service (Amazon ECS) puede asumir una función de IAM para realizar llamadas a AWS la API. Esta es una estrategia de administración de credenciales para que las utilicen las aplicaciones, similar al modo en que los perfiles de instancia de Amazon EC2 proporcionan credenciales a las instancias de Amazon EC2.
[En lugar de crear y distribuir AWS credenciales de larga duración a los contenedores o utilizar la función de la instancia Amazon EC2, puede asociar una función de IAM que utilice credenciales temporales a una definición de tarea de ECS o `RunTask` a una operación de API.](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-ecs-2014-11-13.html#runtask)
Para obtener más información sobre el uso de los roles de IAM que pueden asumir las tareas de contenedores, consulte el tema sobre los [roles de IAM en las tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) de la *Guía para desarrolladores de Amazon ECS*. Para ver ejemplos del uso del rol de IAM de tareas en forma de `taskRoleArn` en las definiciones de tareas, consulte también [Ejemplos de las definiciones de tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-example-taskdefs.html) en la *Guía para desarrolladores de Amazon ECS*.
## Asumir una función de IAM en otra Cuenta de AWS
Si trabaja en una Cuenta de AWS (cuenta A) y quiere asumir una función en otra cuenta (cuenta B), primero debe crear una función de IAM en la cuenta B. Esta función permite a las entidades de su cuenta (cuenta A) realizar acciones específicas en la cuenta B. Para obtener más información sobre el acceso entre cuentas, consulte el [tutorial: Delegar el acceso entre AWS cuentas mediante](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) funciones de IAM.
Después de crear un rol en Cuenta B, registre los ARN de rol. Utilizará este ARN cuando asuma la función desde la cuenta A. Asumirá la función con las AWS credenciales asociadas a su entidad en la cuenta A.
Cree un AWS STS cliente con credenciales para su. Cuenta de AWS A continuación, utilizamos un perfil de credenciales, pero puede utilizar cualquier método. Con el cliente de AWS STS recién creado, llame a assume-role y proporcione un valor de sessionName personalizado. Recupere las nuevas credenciales temporales del resultado. De forma predeterminada, las credenciales duran una hora.
**Código de muestra**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$result = $stsClient->AssumeRole([
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Para obtener más información, consulte [Uso de funciones de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) o [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)en la referencia de la AWS SDK para PHP API.
## Uso de un rol de IAM con la identidad web
Web Identity Federation permite a los clientes utilizar proveedores de identidad de terceros para autenticarse al acceder a AWS los recursos. Para poder asumir un rol con identidad web, debe crear un rol de IAM y configurar un proveedor de identidad web (IdP). Para obtener más información, consulte [Creación de un rol para identidades federadas web u OpenID Connect (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html).
Tras [crear un proveedor de identidades](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) y [crear un rol para su identidad web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html), utilice un AWS STS cliente para autenticar a un usuario. Proporcione el webIdentityToken y ProviderId para su identidad y el ARN del rol para el rol de IAM con permisos para el usuario.
**Código de muestra**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$duration = 3600;
$result = $stsClient->AssumeRoleWithWebIdentity([
'WebIdentityToken' => "FACEBOOK_ACCESS_TOKEN",
'ProviderId' => "graph.facebook.com",
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Para obtener más información, consulte [AssumeRoleWithWebIdentity—La federación mediante un proveedor de identidad basado en la web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity.html) o [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity)en la referencia de la AWS SDK para PHP API.
## Asumir rol con perfil
### Definir perfiles en `~/.aws/credentials`
Puede configurarlo AWS SDK para PHP para que utilice un rol de IAM definiendo un perfil en. `~/.aws/credentials`
Cree un nuevo perfil con la configuración de `role_arn` para el rol que quiere asumir. Incluya también la configuración de `source_profile` de otro perfil con credenciales que tenga permisos para asumir el rol de IAM. Para obtener más información sobre estas opciones de configuración, consulte [Asumir credenciales de rol](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) en la *Guía de referencia de AWS SDKs and Tools*.
Por ejemplo, en el siguiente `~/.aws/credentials`, el perfil de `project1` establece `role_arn` y especifica el perfil de `default` como el origen de las credenciales para verificar la entidad asociada que puede asumir el rol.
```
[project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Si se establece la variable de entorno `AWS_PROFILE` o se usa el parámetro `profile` al crear la instancia de un cliente de servicio, se asumirá el rol especificado en `project1`, utilizando el perfil `default` como credenciales de origen.
En el siguiente fragmento se muestra el uso del parámetro `profile` en un constructor `S3Client`. `S3Client` tendrá los permisos asociados al rol asociado al perfil de `project1`.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
### Definir perfiles en `~/.aws/config`
El archivo `~/.aws/config` también puede contener los perfiles que quiera que se asuman. Si establece la variable de entorno `AWS_SDK_LOAD_NONDEFAULT_CONFIG`, el SDK para PHP carga los perfiles del archivo `config`. Cuando `AWS_SDK_LOAD_NONDEFAULT_CONFIG` está establecido, el SDK carga los perfiles tanto de `~/.aws/config` como de `~/.aws/credentials`. Los perfiles de `~/.aws/credentials` se cargan en último lugar y tienen prioridad sobre un perfil de `~/.aws/config` con el mismo nombre. Los perfiles de cualquier ubicación pueden servir como `source_profile` o el perfil que se asumirá.
En el siguiente ejemplo se utiliza el perfil de `project1` definido en el archivo `config` y el perfil de `default` del archivo `credentials`. También se ha establecido `AWS_SDK_LOAD_NONDEFAULT_CONFIG`.
```
# Profile in ~/.aws/config.
[profile project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
```
```
# Profile in ~/.aws/credentials.
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Cuando se ejecute el constructor `S3Client` que se muestra en el siguiente fragmento, se asumirá el rol definido en el perfil de `project1` con las credenciales asociadas al perfil de `default`.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
# Usa credenciales temporales AWS STS del SDK for PHP
AWS Security Token Service (AWS STS) le permite solicitar **credenciales temporales** con privilegios limitados para los usuarios de IAM o para los usuarios que autentique mediante una federación de identidades. Para obtener más información, consulte [Credenciales de seguridad temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) en la *guía del usuario de IAM*. Puede utilizar credenciales de seguridad temporales para acceder a la mayoría AWS de los servicios. Para obtener una lista de los servicios que aceptan credenciales de seguridad temporales, consulte [los servicios AWS que funcionan con IAM ](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) en la*Guía del usuario de IAM*.
Un caso de uso habitual de las credenciales temporales consiste en conceder a las aplicaciones móviles o del lado del cliente acceso a AWS los recursos mediante la autenticación de los usuarios a través de proveedores de identidad externos (consulte [Web Identity](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) Federation).
## Obtención de credenciales temporales
AWS STS tiene varias operaciones que devuelven credenciales temporales, pero la `GetSessionToken` operación es la más sencilla de demostrar. El siguiente fragmento recupera las credenciales temporales al llamar al método `getSessionToken` del cliente STS del SDK de PHP.
```
$sdk = new Aws\Sdk([
'region' => 'us-east-1',
]);
$stsClient = $sdk->createSts();
$result = $stsClient->getSessionToken();
```
El resultado de `GetSessionToken` y las demás AWS STS operaciones siempre contienen un `'Credentials'` valor. Si imprime `$result` (por ejemplo, mediante `print_r($result)`), tendrá el siguiente aspecto.
```
Array
(
...
[Credentials] => Array
(
[SessionToken] => ''
[SecretAccessKey] => ''
[Expiration] => 2013-11-01T01:57:52Z
[AccessKeyId] => ''
)
...
)
```
## Proporcionar credenciales temporales al AWS SDK para PHP
Puede usar credenciales temporales con otro AWS cliente creando una instancia del cliente y transfiriendo los valores recibidos directamente de AWS STS él.
```
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
También puede crear un objeto `Aws\Credentials\Credentials` y utilizarlo cuando cree una instancia del cliente.
```
use Aws\Credentials\Credentials;
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$credentials = new Credentials(
$result['Credentials']['AccessKeyId'],
$result['Credentials']['SecretAccessKey'],
$result['Credentials']['SessionToken']
);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Sin embargo, la *mejor* manera de proporcionar credenciales temporales es utilizar el método de ayudante `createCredentials()` incluido con `StsClient`. Este método extrae los datos de un AWS STS resultado y crea el `Credentials` objeto automáticamente.
```
$result = $stsClient->getSessionToken();
$credentials = $stsClient->createCredentials($result);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Para obtener más información sobre por qué podría necesitar usar credenciales temporales en su aplicación o proyecto, consulte [Escenarios para la concesión de acceso temporal](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) en la AWS STS documentación.
# Creación de clientes anónimos en el SDK para PHP
En algunos casos es posible que desee crear un cliente que no esté asociado a ninguna credencial. De este modo podrá realizar solicitudes anónimas a un servicio.
Por ejemplo, puede configurar tanto los objetos de Amazon S3 como los dominios de Amazon CloudSearch para que permitan el acceso anónimo.
Para crear un cliente anónimo, debe establecer la opción `'credentials'` en `false`.
```
$s3Client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => false
]);
// Makes an anonymous request. The object would need to be publicly
// readable for this to succeed.
$result = $s3Client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'my-key',
]);
```