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.
# Configurar el SDK
En la AWS SDK para Go versión 2, puede configurar los ajustes comunes para los clientes de servicio, como el registrador, el nivel de registro y la configuración de reintentos. La mayoría de los ajustes son opcionales. Sin embargo, para cada cliente de servicio, debe especificar una AWS región y sus credenciales. El SDK usa estos valores para enviar solicitudes a la región correcta y firmar las solicitudes con las credenciales correctas. Puede especificar estos valores mediante programación en el código o a través del entorno de ejecución.
## Cargando archivos de configuración AWS compartidos
Existen varias formas de inicializar un cliente de API de servicio, pero el siguiente patrón es el más común que se recomienda a los usuarios.
Para configurar el SDK para que utilice los archivos de configuración AWS compartidos, utilice el siguiente código:
```
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/config"
)
// ...
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
log.Fatalf("failed to load configuration, %v", err)
}
```
`config.LoadDefaultConfig(context.TODO())`construirá un [AWS.config](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Config) utilizando las fuentes de configuración AWS compartidas. Esto incluye configurar un proveedor de credenciales, configurar la AWS región y cargar la configuración específica del servicio. Los clientes de servicio se pueden crear mediante la instancia de `aws.Config` cargada, lo que proporciona un patrón coherente para la creación de clientes.
Para obtener más información sobre los archivos de configuración AWS compartidos, consulte [Configuración](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) en la Guía de referencia de herramientas AWS SDKs y herramientas.
## Especificación de la AWS región
A especificar la región, se especifica dónde enviar las solicitudes, por ejemplo, `us-west-2` o `us-east-2`. Para ver una lista de regiones para cada servicio, consulte [Puntos de conexión de servicio y cuotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) en la Referencia general de Amazon Web Services.
El SDK no tiene ninguna región predeterminada. Para especificar una región:
+ Establezca la variable de entorno `AWS_REGION` en la región predeterminada.
+ Establezca la región de forma explícita mediante la [configuración. WithRegion](https://github.com/aws/aws-sdk-go-v2/blob/config/v0.2.2/config/provider.go#L127)como argumento `config.LoadDefaultConfig` al cargar la configuración.
Revisión: Si establece una región mediante todas estas técnicas, el SDK utilizará la región que haya especificado de forma explícita.
### Configuración de la región con una variable de entorno
#### Linux, macOS o Unix
```
export AWS_REGION=us-west-2
```
#### Windows
```
set AWS_REGION=us-west-2
```
### Especificación de la región mediante programación
```
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
```
## Especificación de credenciales
AWS SDK para Go Requiere credenciales (una clave de acceso y una clave de acceso secreta) para firmar las solicitudes AWS. Puede especificar sus credenciales en varias ubicaciones, en función de su caso de uso concreto. Para obtener más información sobre cómo obtener las credenciales, consulte [Empiece a utilizar AWS SDK para Go](getting-started.md).
Al inicializar una `aws.Config` instancia mediante`config.LoadDefaultConfig`, el SDK utiliza su cadena de credenciales predeterminada para buscar AWS las credenciales. Esta cadena de credenciales predeterminada busca las credenciales en este orden:
1. Variables de entorno.
1. Credenciales estáticas (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `AWS_SESSION_TOKEN`)
1. Token de identidad web (`AWS_WEB_IDENTITY_TOKEN_FILE`)
1. Archivos de configuración compartida
1. El SDK tiene como valor predeterminado el archivo `credentials` de la carpeta `.aws` que se encuentra en la carpeta de inicio de su computadora.
1. El SDK tiene como valor predeterminado el archivo `config` de la carpeta `.aws` que se encuentra en la carpeta de inicio de su computadora.
1. Si su aplicación utiliza una definición de tareas o una operación de RunTask API de Amazon ECS, la función de IAM para las tareas.
1. Si la aplicación se ejecuta en una instancia de Amazon EC2, el rol de IAM para Amazon EC2.
El SDK detecta y utiliza los proveedores integrados de forma automática, sin necesidad de realizar configuraciones manuales. Por ejemplo, si utiliza roles de IAM para las instancias de Amazon EC2, sus aplicaciones utilizarán las credenciales de la instancia de forma automática. No es necesario configurar manualmente las credenciales en la aplicación.
Como práctica recomendada, se AWS recomienda especificar las credenciales en el siguiente orden:
1. Utilice funciones de IAM para las tareas si su aplicación utiliza una definición de tarea o una operación de RunTask API de Amazon ECS.
1. Use roles de IAM para Amazon EC2 (si la aplicación se ejecuta en una instancia de Amazon EC2).
Los roles de IAM proporcionan a las aplicaciones de la instancia credenciales de seguridad temporales para realizar AWS llamadas. Los roles de IAM ofrecen una forma sencilla de distribuir y administrar credenciales en varias instancias de Amazon EC2.
1. Utilice archivos de configuración o credenciales compartidos.
Las credenciales y los archivos de configuración se comparten entre otras AWS SDKs y AWS CLI. Como práctica recomendada de seguridad, recomendamos utilizar un archivo de credenciales para configurar valores confidenciales, como la clave de acceso IDs y las claves secretas. Estos son los [requisitos de formato](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) para cada uno de estos archivos.
1. Utilice variables de entorno.
La configuración de las variables de entorno es útil si está realizando trabajos de desarrollo en un equipo que no sea una instancia de Amazon EC2.
### Roles de IAM para las tareas
Si su aplicación utiliza una definición de tarea de Amazon ECS o una operación `RunTask`, utilice [roles de IAM para las tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) a fin de especificar un rol de IAM que los contenedores puedan utilizar en una tarea.
### Roles de IAM para las instancias de Amazon EC2
Si ejecuta una aplicación en una instancia de Amazon EC2, utilice el [rol de IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) de la instancia a fin de obtener credenciales de seguridad temporales para realizar llamadas a AWS.
Si ha configurado la instancia para que utilice roles de IAM, el SDK utiliza estas credenciales para su aplicación de forma automática. No es necesario especificar las credenciales manualmente.
### Credenciales y configuración compartidas
Las credenciales compartidas y los archivos de configuración se pueden usar para compartir configuraciones comunes AWS SDKs entre otras herramientas. Si utiliza credenciales distintas para cada herramienta o aplicación, puede utilizar *perfiles* para configurar varias claves de acceso en el mismo archivo de configuración.
Puede proporcionar varias ubicaciones de archivos de credenciales y de configuración mediante `config.LoadOptions`. De forma predeterminada, el SDK carga los archivos almacenados en las ubicaciones predeterminadas que se indican en [Especificación de credenciales](#specifying-credentials).
```
import (
"context"
"github.com/aws/aws-sdk-go-v2/config"
)
// ...
cfg , err := config.LoadDefaultConfig(context.TODO(),
config.WithSharedCredentialsFiles(
[]string{"test/credentials", "data/credentials"},
),
config.WithSharedConfigFiles(
[]string{"test/config", "data/config"},
)
)
```
Al trabajar con archivos de credenciales y configuración compartidas, en caso de especificarse perfiles duplicados estos se fusionan para resolver un perfil. En caso de conflicto al fusionar:
1. Si se especifican perfiles duplicados en un mismo credentials/config archivo, prevalecen las propiedades del perfil especificadas en este último perfil.
1. Si se especifican perfiles duplicados en varios archivos de credenciales o de configuración, las propiedades de perfil se resolverán según el orden de entrada del archivo en `config.LoadOptions`. Las propiedades de perfil de los últimos archivos tienen prioridad.
1. Si existe un perfil tanto en el archivo de credenciales como en el de configuración, las propiedades del archivo de credenciales tendrán prioridad.
Si es necesario, puede habilitar `LogConfigurationWarnings` en `config.LoadOptions` y registrar los pasos de resolución de perfiles.
#### Creación del archivo de credenciales
Si no tiene un archivo de credenciales compartido (`.aws/credentials`), puede usar cualquier editor de texto para crear uno en su directorio principal. Añada el siguiente contenido a su archivo de credenciales, sustituyendo {{}} y {{}} por sus credenciales.
```
[default]
aws_access_key_id = {{}}
aws_secret_access_key = {{}}
```
El encabezado `[default]` define las credenciales para el perfil predeterminado, que el SDK utilizará a menos que lo configure para usar otro perfil.
También puede utilizar credenciales de seguridad temporales mediante la adición de los tokens de sesión a su perfil, como se muestra en el ejemplo siguiente:
```
[temp]
aws_access_key_id = {{}}
aws_secret_access_key = {{}}
aws_session_token = {{}}
```
El nombre de la sección correspondiente a un perfil no predeterminado en un archivo de credenciales no debe empezar por la palabra `profile`. Puede obtener más información en la [Guía AWS SDKs de referencia de herramientas](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-creds).
#### Creación del archivo de configuración
Si no tiene un archivo de credenciales compartido (`.aws/config`), puede usar cualquier editor de texto para crear uno en su directorio principal. Añada el siguiente contenido a su archivo de configuración y {{}} sustitúyalo por la región deseada.
```
[default]
region = {{}}
```
El encabezado `[default]` define la configuración para el perfil predeterminado, que el SDK utilizará a menos que lo configure para usar otro perfil.
Puede utilizar perfiles con nombre, como se muestra en el ejemplo siguiente:
```
[profile named-profile]
region = {{}}
```
El nombre de sección de un perfil no predeterminado de un archivo de configuración siempre debe empezar por la palabra `profile`, seguida del nombre de perfil previsto. Puede obtener más información en la [Guía de referencia de herramientas AWS SDKs y herramientas](https://docs.aws.amazon.com/credref/latest/refdocs/file-format.html#file-format-config).
#### Especificación de perfiles
Puede incluir varias claves de acceso en el mismo archivo de configuración; para ello, asocie cada conjunto de claves de acceso a un perfil. Por ejemplo, en el archivo de credenciales, puede declarar varios perfiles, de la siguiente manera.
```
[default]
aws_access_key_id =
aws_secret_access_key =
[test-account]
aws_access_key_id =
aws_secret_access_key =
[prod-account]
; work profile
aws_access_key_id =
aws_secret_access_key =
```
De forma predeterminada, el SDK comprueba la variable de entorno `AWS_PROFILE` para determinar qué perfil se va a utilizar. Si no se ha establecido ninguna variable `AWS_PROFILE`, el SDK usa el perfil `default`.
Puede que a veces quiera utilizar un perfil diferente con su aplicación. Por ejemplo, desea usar las credenciales `test-account` con su aplicación `myapp`. Puede usar este perfil mediante el siguiente comando:
```
$ AWS_PROFILE=test-account myapp
```
También puede indicar al SDK que seleccione un perfil mediante una llamada a `os.Setenv("AWS_PROFILE", "test-account")` antes de llamar a `config.LoadDefaultConfig`, o mediante la transferencia de un perfil explícito como argumento, como se muestra en el ejemplo siguiente:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithSharedConfigProfile("test-account"))
```
**nota**
Si especifica las credenciales en variables de entorno, el SDK siempre usará esas credenciales, independientemente del perfil que especifique.
### Variables de entorno
De forma predeterminada, el SDK detecta AWS las credenciales configuradas en su entorno y las utiliza para firmar las solicitudes AWS. De ese modo, no es necesario administrar las credenciales en las aplicaciones.
El SDK busca credenciales en las siguientes variables de entorno:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_SESSION_TOKEN` (opcional)
En los ejemplos siguientes se muestra cómo configurar las variables de entorno:
#### Linux, OS X o Unix
```
$ export AWS_ACCESS_KEY_ID=YOUR_AKID
$ export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
$ export AWS_SESSION_TOKEN=TOKEN
```
#### Windows
```
> set AWS_ACCESS_KEY_ID=YOUR_AKID
> set AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
> set AWS_SESSION_TOKEN=TOKEN
```
### Especificación de credenciales mediante programación
`config.LoadDefaultConfig`le permite proporcionar una [AWS explícita. CredentialProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsProvider)al cargar las fuentes de configuración compartidas. Para pasar un proveedor de credenciales explícito al cargar la configuración compartida, utilice [config. WithCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithCredentialsProvider). Por ejemplo, si `customProvider` hace referencia a una instancia de implementación de `aws.CredentialProvider`, se puede transferir durante la carga de la configuración de la siguiente manera:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithCredentialsProvider(customProvider))
```
Si proporciona credenciales de forma explícita, como en este ejemplo, el SDK solo usa esas credenciales.
**nota**
Todos los proveedores de credenciales transferidos o devueltos `LoadDefaultConfig` se incluyen de forma [CredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#CredentialsCache)automática. Esto permite un almacenamiento en caché y una rotación de credenciales seguros para el uso simultáneo. Si configuras explícitamente un proveedor `aws.Config` directamente, también debes empaquetar explícitamente el proveedor con este tipo mediante [NewCredentialsCache](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#NewCredentialsCache).
#### Credenciales estáticas
Puede codificar de forma rígida las credenciales en su aplicación mediante las [credenciales. NewStaticCredentialsProvider](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials#NewStaticCredentialsProvider)proveedor de credenciales para establecer de forma explícita las claves de acceso que se van a utilizar. Por ejemplo:
```
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider("AKID", "SECRET_KEY", "TOKEN")),
)
```
**aviso**
No incruste credenciales dentro de una aplicación. Use este método solo con fines de prueba.
#### Credenciales de inicio de sesión único
El SDK proporciona un proveedor de credenciales para recuperar credenciales temporales AWS mediante. AWS IAM Identity Center Con el AWS CLI, se autentica en el portal de acceso y se autoriza el AWS acceso a las credenciales temporales. AWS A continuación, configuras la aplicación para que cargue el perfil de inicio de sesión único (SSO) y el SDK utiliza tus credenciales de SSO para recuperar las AWS credenciales temporales que se renovarán automáticamente si caducan. Si sus credenciales de SSO caducan, debe renovarlas de forma explícita. Para ello, vuelva a iniciar sesión en su cuenta del Centro de Identidad de IAM mediante. AWS CLI
Por ejemplo, puede crear un perfil`dev-profile`, autenticar y autorizar ese perfil mediante la AWS CLI aplicación y configurar su aplicación como se muestra a continuación.
1. Primero, cree los elementos `profile` y `sso-session`.
```
[profile dev-profile]
sso_session = dev-session
sso_account_id = 012345678901
sso_role_name = Developer
region = us-east-1
[sso-session dev-session]
sso_region = us-west-2
sso_start_url = https://company-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
1. Inicie sesión con el AWS CLI para autenticar y autorizar el perfil de inicio de sesión único.
```
$ aws --profile dev-profile sso login
Attempting to automatically open the SSO authorization page in your default browser.
If the browser does not open or you wish to use a different device to authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
ABCD-EFGH
Successully logged into Start URL: https://company-sso-portal.awsapps.com/start
```
1. A continuación, configure la aplicación para que utilice el perfil de SSO.
```
import "github.com/aws/aws-sdk-go-v2/config"
// ...
cfg, err := config.LoadDefaultConfig(
context.Background(),
config.WithSharedConfigProfile("dev-profile"),
)
if err != nil {
return err
}
```
Para obtener más información sobre la configuración de los perfiles de SSO y la autenticación mediante el uso, AWS CLI consulte [Configuración del uso AWS IAM Identity Center en la AWS CLI Guía del](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) usuario. AWS CLI Para obtener más información sobre cómo crear el proveedor de credenciales de SSO mediante programación, consulte la documentación de referencia de la API [ssocreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ssocreds).
#### Credenciales de acceso
Puede usar sus credenciales de inicio de sesión AWS de Management Console actuales para acceder a AWS los servicios mediante programación. Tras un flujo de autenticación basado en un navegador, AWS genera credenciales temporales que funcionan en todas las herramientas de desarrollo local, como la AWS CLI y Herramientas de AWS para PowerShell . AWS SDKs Esta función simplifica el proceso de configuración y administración de las credenciales de AWS CLI, especialmente si prefiere la autenticación interactiva en lugar de administrar las claves de acceso a largo plazo.
1. Inicie el flujo de inicio de sesión mediante la AWS CLI y siga las instrucciones del navegador. En este ejemplo, guardamos la sesión de inicio de sesión en un perfil nuevo**dev-profile**, pero esto es opcional.
```
$ aws --profile dev-profile login
```
1. (Opcional) Inspeccione el archivo de configuración AWS compartido para comprobar que la sesión se ha establecido.
```
[profile dev-profile]
login_session = arn:aws:sts::{{account id>}}:{{role}}
```
1. A continuación, configure la aplicación para que utilice el perfil de inicio de sesión.
```
import "github.com/aws/aws-sdk-go-v2/config"
// ...
cfg, err := config.LoadDefaultConfig(
context.Background(),
// only necessary if login session is saved to a non-default profile
config.WithSharedConfigProfile("dev-profile"),
)
if err != nil {
return err
}
```
Para obtener más información sobre la configuración de los perfiles de inicio de sesión y la autenticación mediante la AWS CLI, consulte [Inicio de sesión para el desarrollo AWS local con credenciales de consola](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
#### Otros proveedores de credenciales
El SDK proporciona otros métodos para recuperar credenciales en el módulo [credentials](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials). Por ejemplo, puede recuperar credenciales de seguridad temporales AWS Security Token Service o credenciales de un almacenamiento cifrado.
**Proveedores de credenciales disponibles**:
+ [ec2rolecreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds): recupere credenciales de roles de instancias de Amazon EC2 a través de servicios de metadatos de instancias (IMDS) de Amazon EC2.
+ [endpointcreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds): recupere credenciales de un punto de conexión HTTP arbitrario.
+ [processcreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/processcreds): recupere credenciales de un proceso externo que invocará el intérprete de comandos del entorno de host.
+ [stscreds](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/credentials/stscreds): recupera credenciales de AWS STS