La [Guía de referencia de la API de AWS SDK for JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) describe en detalle todas las operaciones de la API para la versión 3 (V3) de AWS SDK for JavaScript.
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 para JavaScript
Antes de usar el SDK para JavaScript invocar servicios web mediante la API, debe configurar el SDK. Como mínimo, tiene que configurar:
+ La AWS región en la que solicitará los servicios
+ Cómo se autentica su código con AWS
Además de configurar estos valores, es posible que también tenga que configurar permisos para sus recursos de AWS. Por ejemplo, puede limitar el acceso a un bucket de Amazon S3 o restringir una tabla de Amazon DynamoDB para acceso de solo lectura.
La [guía de referencia de AWS SDKs and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/) también contiene configuraciones, características y otros conceptos fundamentales comunes a muchos de los. AWS SDKs
En los temas de esta sección se describen las formas de configurar el SDK JavaScript para Node.js y su JavaScript ejecución en un navegador web.
**Topics**
+ [Configuración según el servicio](global-config-object.md)
+ [Establezca la región AWS](setting-region.md)
+ [Configuración de credenciales](setting-credentials.md)
+ [Consideraciones de Node.js](node-js-considerations.md)
+ [Consideraciones sobre los scripts de navegador](browser-js-considerations.md)
# Configuración según el servicio
Puede configurar el SDK pasando la información de configuración a un objeto de servicio.
La configuración a nivel de servicio proporciona un control significativo sobre los servicios individuales, lo que le permite actualizar la configuración de los objetos de servicio individuales cuando sus necesidades difieran de la configuración predeterminada.
**nota**
En la versión 2.x, la configuración del AWS SDK para JavaScript servicio se podía pasar a los constructores de clientes individuales. Sin embargo, estas configuraciones primero se fusionarían automáticamente en una copia de la configuración global del SDK `AWS.config`.
Además, llamar a `AWS.config.update({/* params *})` solo actualizaba la configuración de los clientes de servicio instanciados después de realizar la llamada de actualización, no a los clientes existentes.
Este comportamiento era una fuente frecuente de confusión y dificultaba añadir una configuración al objeto global que solo afectara a un subconjunto de clientes de servicio de forma compatible con versiones posteriores. En la versión 3, ya no existe una configuración global gestionada por el SDK. La configuración tiene que pasarse a cada cliente de servicio del que se cree una instancia. Sigue siendo posible compartir la misma configuración entre varios clientes, pero esa configuración no se fusionará automáticamente con un estado global.
## Ajuste de configuración según el servicio
Se accede a cada servicio que utilices en el SDK a través de un objeto de servicio que forma parte de la API de ese servicio. JavaScript Por ejemplo, para acceder al servicio de Amazon S3, tiene que crear el objeto de servicio de Amazon S3. Puede especificar los valores de configuración que son específicos de un servicio como parte del constructor para dicho objeto de servicio.
Por ejemplo, si necesita acceder a los objetos de Amazon EC2 en varias AWS regiones, cree un objeto de servicio de Amazon EC2 para cada región y, a continuación, establezca la configuración regional de cada objeto de servicio en consecuencia.
```
var ec2_regionA = new EC2({region: 'ap-southeast-2', maxAttempts: 15});
var ec2_regionB = new EC2({region: 'us-west-2', maxAttempts: 15});
```
# Establezca la región AWS
Una AWS región es un conjunto de AWS recursos con nombre asignado en la misma área geográfica. Un ejemplo de región es `us-east-1`, que es la región Este de EE. UU. (Norte de Virginia). Al crear un cliente de servicio en el SDK, se especifica una región JavaScript para que el SDK acceda al servicio de esa región. Algunos servicios de solo están disponibles en regiones específicas.
El SDK para JavaScript no selecciona una región de forma predeterminada. Sin embargo, puede configurar la AWS región mediante una variable de entorno o un `config` archivo de configuración compartido.
## En un constructor de clase de cliente
Al crear una instancia de un objeto de servicio, puede especificar la AWS región de ese recurso como parte del constructor de la clase de cliente, como se muestra aquí.
```
const s3Client = new S3.S3Client({region: 'us-west-2'});
```
## Uso de una variable de entorno
Puede establecer la región mediante la variable de entorno `AWS_REGION`. Si defines esta variable, el SDK la JavaScript lee y la usa.
## Uso de un archivo de configuración compartido
Del mismo modo que el archivo de credenciales compartidas te permite almacenar las credenciales para que las utilice el SDK, puedes guardar tu AWS región y otros ajustes de configuración en un archivo compartido con el nombre `config` que el SDK vaya a utilizar. Si la variable de `AWS_SDK_LOAD_CONFIG` entorno se establece en un valor verdadero, el SDK busca JavaScript automáticamente un `config` archivo cuando se carga. La ubicación donde guarde el archivo `config` depende de su sistema operativo:
+ Usuarios de Linux, macOS o Unix: `~/.aws/config`
+ Usuarios de Windows: `C:\Users\USER_NAME\.aws\config`
Si todavía no tiene un archivo `config` compartido, puede crear uno en el directorio designado. En el siguiente ejemplo, el archivo `config` establece la región y el formato de salida.
```
[default]
region=us-west-2
output=json
```
Para obtener más información sobre el uso de `credentials` archivos `config` AND compartidos, consulta los [archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
## Orden de prioridad para establecer la región
El orden de prioridad para la configuración de una región es el siguiente:
1. Si se transfiere una región a un constructor de clase de cliente, se usa dicha región.
1. Si se establece una región en la variable de entorno, se utiliza esa región.
1. De lo contrario, se utiliza la región definida en el archivo de configuración compartido.
# Configuración de credenciales
AWS usa las credenciales para identificar quién llama a los servicios y si se permite el acceso a los recursos solicitados.
Ya sea que se ejecute en un navegador web o en un servidor Node.js, el JavaScript código debe obtener credenciales válidas antes de poder acceder a los servicios a través de la API. Las credenciales se pueden configurar por servicio, por medio de la transferencia directa de las credenciales a un objeto de servicio.
Hay varias formas de configurar las credenciales que difieren entre Node.js y JavaScript en los navegadores web. En los temas de esta sección se describe cómo configurar credenciales en Node.js o en navegadores web. En cada caso, las opciones se presentan en el orden recomendado.
## Prácticas recomendadas para las credenciales
Configurar correctamente las credenciales garantiza que su aplicación o script de navegador pueda obtener acceso a los servicios y los recursos necesarios y, al mismo tiempo, minimiza su exposición a problemas de seguridad que puedan repercutir en aplicaciones críticas o pongan en peligro información confidencial.
Cuando se configuran credenciales es importante aplicar siempre el principio de conceder el privilegio mínimo necesario para llevar a cabo la tarea. Es más seguro proporcionar permisos mínimos sobre sus recursos y añadir más permisos según sea necesario, en lugar de proporcionar permisos que superan el privilegio mínimo y luego tener que solucionar problemas de seguridad que puedan aparecer más tarde. Por ejemplo, a menos que necesite leer y escribir recursos individuales, como objetos en un bucket de Amazon S3 o una tabla de DynamoDB, establezca dichos permisos en solo lectura.
Para obtener más información sobre la concesión de privilegios mínimos, consulte la sección [Conceder privilegios mínimos](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) del tema de prácticas recomendadas de la *Guía del usuario de IAM*.
**Topics**
+ [Prácticas recomendadas para las credenciales](#credentials-best-practices)
+ [Configuración de credenciales en Node.js](setting-credentials-node.md)
+ [Configuración de credenciales en un navegador web](setting-credentials-browser.md)
# Configuración de credenciales en Node.js
Recomendamos a los nuevos usuarios que se desarrollen localmente y que su empleador no les dé un método de autenticación para que lo configuren AWS IAM Identity Center. Para obtener más información, consulte [Autenticación del SDK con AWS](getting-your-credentials.md).
En Node.js hay varias formas de proporcionar sus credenciales al SDK. Algunas de ellas son más seguras y otras ofrecen más comodidad mientras se desarrolla una aplicación. Al obtener las credenciales en Node.js, sea especialmente cuidadoso si se basa en más de un origen como, por ejemplo, una variable de entorno y un archivo JSON que carga. Puede cambiar los permisos con los que se ejecuta su código sin darse cuenta de que se ha producido el cambio.
AWS SDK para JavaScript La versión 3 proporciona una cadena de proveedores de credenciales predeterminada en Node.js, por lo que no es necesario que proporciones un proveedor de credenciales de forma explícita. La [cadena de proveedores de credenciales](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) predeterminada intenta resolver las credenciales de una variedad de fuentes diferentes con una prioridad determinada, hasta que una de las fuentes devuelva una credencial. [Puede encontrar la cadena de proveedores de credenciales del SDK para la versión 3 aquí. JavaScript ](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromnodeproviderchain)
## Cadena de proveedores de credenciales
Todos SDKs tienen una serie de sitios (o fuentes) que consultan para obtener credenciales válidas que puedan utilizarlas para realizar una solicitud a un. Servicio de AWS Una vez que se encuentran las credenciales válidas, se detiene la búsqueda. Esta búsqueda sistemática se denomina cadena predeterminada de proveedores de credenciales.
Para cada paso de la cadena, hay diferentes maneras de establecer los valores. La configuración de los valores directamente en el código siempre tiene prioridad, seguida de la configuración como variables de entorno y, por último, en el AWS `config` archivo compartido. Para obtener más información, consulte [Prioridad de los ajustes](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#precedenceOfSettings) en la Guía de *referencia de herramientas AWS SDKs y herramientas*.
La *guía de referencia de AWS SDKs and Tools* contiene información sobre los ajustes de configuración del SDK que utilizan todos AWS SDKs y los AWS CLI. Para obtener más información sobre cómo configurar el SDK a través del AWS `config` archivo compartido, consulte [Archivos de credenciales y configuración compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html). Para obtener más información sobre cómo configurar el SDK mediante la configuración de variables de entorno, consulte [Compatibilidad con variables de entorno](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html).
Para autenticarse AWS, AWS SDK para JavaScript comprueba los proveedores de credenciales en el orden que se indica en la siguiente tabla.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)
Si siguió el enfoque recomendado para los nuevos usuarios para empezar, configuró la autenticación AWS Single Sign-On en [Autenticación del SDK con AWS](getting-your-credentials.md) del tema Introducción. Otros métodos de autenticación son útiles en diferentes situaciones. Para evitar riesgos de seguridad, recomendamos utilizar siempre credenciales a corto plazo. Para conocer otros procedimientos de métodos de autenticación, consulte [Autenticación y acceso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
En los temas de esta sección se describe cómo cargar credenciales en Node.js.
**Topics**
+ [Cadena de proveedores de credenciales](#credchain)
+ [Carga de credenciales en Node.js desde roles de IAM para Amazon EC2](loading-node-credentials-iam.md)
+ [Credenciales de carga para una función de Lambda de Node.js](loading-node-credentials-lambda.md)
# Carga de credenciales en Node.js desde roles de IAM para Amazon EC2
Si ejecuta su aplicación de Node.js en una instancia de Amazon EC2, puede utilizar roles de IAM para Amazon EC2, para suministrar automáticamente credenciales a la instancia. Si configura la instancia para que utilice roles de IAM, el SDK selecciona automáticamente las credenciales de IAM para su aplicación, lo que elimina la necesidad de proporcionar las credenciales manualmente.
Para obtener más información sobre cómo añadir roles de IAM a una instancia de Amazon EC2, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html).
# Credenciales de carga para una función de Lambda de Node.js
Al crear una AWS Lambda función, debe crear una función de IAM especial que tenga permiso para ejecutar la función. Este rol se denomina el *rol de ejecución*. Cuando configura una función de Lambda, tiene que especificar el rol de IAM que ha creado como el rol de ejecución correspondiente.
El rol de ejecución proporciona a la función de Lambda las credenciales que necesita para ejecutarse y para invocar otros servicios web. Como resultado, no es necesario proporcionar credenciales al código Node.js que escribe dentro de una función de Lambda.
Para obtener más información sobre cómo crear un rol de ejecución de Lambda, consulte [Administración de permisos: usar un rol de IAM (rol de ejecución)](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) en la *Guía para desarrolladores de Lambda*.
# Configuración de credenciales en un navegador web
Hay varias formas de proporcionar credenciales al SDK desde scripts de navegador. Algunas de ellas son más seguras y otras ofrecen más comodidad mientras se desarrolla un script.
A continuación se muestran las formas de suministro de credenciales según su orden de recomendación:
1. Uso de Amazon Cognito para autenticar usuarios y suministrar credenciales
1. Uso de identidades federadas web
**aviso**
No se recomienda codificar de forma rígida las credenciales de AWS en sus scripts. Si las codifica de forma rígida, corre el riesgo de que su ID de clave de acceso y la clave de acceso secreta queden expuestos.
**Topics**
+ [Uso de Amazon Cognito Identity para autenticar a los usuarios](loading-browser-credentials-cognito.md)
# Uso de Amazon Cognito Identity para autenticar a los usuarios
La forma recomendada de obtener credenciales de AWS para los scripts del navegador es utilizar el cliente de credenciales de Amazon Cognito Identity, `CognitoIdentityClient`. Amazon Cognito permite la autenticación de los usuarios a través de proveedores de identidad de terceros.
Para usar Amazon Cognito Identity, primero debe crear un grupo de identidades en la consola Amazon Cognito. Un grupo de identidades representa el grupo de identidades que su aplicación proporciona a los usuarios. Las identidades que se dan a los usuarios identifican de forma inequívoca cada cuenta de usuario. Las identidades de Amazon Cognito no son credenciales. Se intercambian por credenciales utilizando la compatibilidad con las identidades web federadas en AWS Security Token Service (AWS STS).
Amazon Cognito es útil para administrar la abstracción de identidades a través de varios proveedores de identidades. La identidad que se carga se intercambia por credenciales en AWS STS.
## Configuración del objeto de credenciales de Amazon Cognito Identity
Si todavía no ha creado un grupo de identidades, cree uno para usarlo con los scripts de navegador en la [consola Amazon Cognito](https://console.aws.amazon.com/cognito) antes de configurar su cliente de Amazon Cognito. Cree y asocie roles de IAM autenticados y sin autenticar para su grupo de identidades. Para obtener más información, consulte [Tutorial: Crear un grupo de identidades](https://docs.aws.amazon.com/cognito/latest/developerguide/tutorial-create-identity-pool.html) en la *Guía para desarrolladores de Amazon Cognito*.
La identidad de los usuarios sin autenticar no se verifica, lo que hace que este rol sea adecuado para los usuarios invitados de la aplicación o para cuando no importa si se ha verificado la identidad de los usuarios. Los usuarios autenticados inician sesión en la aplicación a través de un proveedor de identidades externo que verifica sus identidades. Asegúrese de asignar los permisos de los recursos de forma adecuada, para no conceder acceso a ellos a los usuarios no autenticados.
Tras configurar un grupo de identidades, utilice el método `fromCognitoIdentityPool` de `@aws-sdk/credential-providers` para recuperar las credenciales del grupo de identidades. En el siguiente ejemplo de creación de un cliente de Amazon S3, sustituya *AWS\$1REGION* por la región y *IDENTITY\$1POOL\$1ID* por el ID del grupo de identidades.
```
// Import required AWS SDK clients and command for Node.js
import {S3Client} from "@aws-sdk/client-s3";
import {fromCognitoIdentityPool} from "@aws-sdk/credential-providers";
const REGION = AWS_REGION;
const s3Client = new S3Client({
region: REGION,
credentials: fromCognitoIdentityPool({
clientConfig: { region: REGION }, // Configure the underlying CognitoIdentityClient.
identityPoolId: 'IDENTITY_POOL_ID',
logins: {
// Optional tokens, used for authenticated login.
},
})
});
```
La propiedad opcional `logins` es un mapeo entre los nombres de los proveedores de identidad y los tokens de identidad de los proveedores. La forma de obtener el token del proveedor de identidad depende del proveedor que se utilice. Por ejemplo, si utiliza un grupo de usuarios de Amazon Cognito como proveedor de autenticación, puede utilizar un método similar al que se muestra a continuación.
```
// Get the Amazon Cognito ID token for the user. 'getToken()' below.
let idToken = getToken();
let COGNITO_ID = "COGNITO_ID"; // 'COGNITO_ID' has the format 'cognito-idp.REGION.amazonaws.com/COGNITO_USER_POOL_ID'
let loginData = {
[COGNITO_ID]: idToken,
};
const s3Client = new S3Client({
region: REGION,
credentials: fromCognitoIdentityPool({
clientConfig: { region: REGION }, // Configure the underlying CognitoIdentityClient.
identityPoolId: 'IDENTITY_POOL_ID',
logins: loginData
})
});
// Strips the token ID from the URL after authentication.
window.getToken = function () {
var idtoken = window.location.href;
var idtoken1 = idtoken.split("=")[1];
var idtoken2 = idtoken1.split("&")[0];
var idtoken3 = idtoken2.split("&")[0];
return idtoken3;
};
```
## Cambio de usuarios sin autenticar a usuarios autenticados
Amazon Cognito es compatible con los usuarios autenticados y no autenticados. Los usuarios sin autenticar reciben acceso a sus recursos incluso si no han iniciado sesión con alguno de sus proveedores de identidades. Este grado de acceso es útil para mostrar contenido a usuarios antes de que inicien sesión. Cada usuario sin autenticar tiene una identidad única en Amazon Cognito, aunque no haya iniciado sesión ni se haya autenticado individualmente.
### Usuario sin autenticar inicialmente
Los usuarios suelen comenzar con el rol sin autenticar, para el que se establece la propiedad de credenciales de su objeto de configuración sin una propiedad `logins`. En este caso, las credenciales predeterminadas podrían tener el siguiente aspecto:
```
// Import the required AWS SDK para JavaScript v3 modules.
import {fromCognitoIdentityPool} from "@aws-sdk/credential-providers";
// Set the default credentials.
const creds = fromCognitoIdentityPool({
identityPoolId: 'IDENTITY_POOL_ID',
clientConfig: { region: REGION } // Configure the underlying CognitoIdentityClient.
});
```
### Cambie a usuario autenticado
Cuando un usuario sin autenticar inicia sesión en un proveedor de identidades y tiene un token, puede cambiar el usuario de no estar autenticado a estar autenticado llamando a una función personalizada que actualiza el objeto de credenciales y añade el token `logins`.
```
// Called when an identity provider has a token for a logged in user
function userLoggedIn(providerName, token) {
creds.params.Logins = creds.params.logins || {};
creds.params.Logins[providerName] = token;
// Expire credentials to refresh them on the next request
creds.expired = true;
}
```
# Consideraciones de Node.js
Aunque el código Node.js sí JavaScript lo es, su uso AWS SDK para JavaScript en Node.js puede diferir del uso del SDK en los scripts del navegador. Algunos métodos de API funcionan en Node.js pero no en scripts de navegador y viceversa. Y el uso correcto de algunos APIs de ellos depende de que esté familiarizado con los patrones de codificación habituales de Node.js, como la importación y el uso de otros módulos de Node.js, como el `File System (fs)` módulo.
**nota**
AWS recomienda utilizar la versión Active LTS de Node.js para el desarrollo.
## Uso de módulos de Node.js integrados
Node.js ofrece un conjunto de módulos integrados que puede utilizar sin necesidad de instalarlos. Para utilizar estos módulos, cree un objeto con el método `require` para especificar el nombre del módulo. Por ejemplo, para incluir el módulo HTTP integrado, utilice el código siguiente.
```
import http from 'http';
```
Invoque métodos del módulo como si fueran métodos de dicho objeto. Por ejemplo, a continuación le mostramos código que lee un archivo HTML.
```
// include File System module
import fs from "fs";
// Invoke readFile method
fs.readFile('index.html', function(err, data) {
if (err) {
throw err;
} else {
// Successful file read
}
});
```
Para obtener una lista completa de todos los módulos integrados que Node.js proporciona, consulte la [documentación de Node.js](https://nodejs.org/api/modules.html) sobre el sitio web de Node.js.
## Uso de paquetes de npm
Además de los módulos integrados, también puede incluir e incorporar código de terceros desde `npm`, el administrador de paquetes de Node.js. Se trata de un repositorio de paquetes Node.js de código abierto y una interfaz de línea de comandos para instalar dichos paquetes. Para obtener más información `npm` y una lista de los paquetes disponibles actualmente, consulte [ https://www.npmjs.com](https://www.npmjs.com). También puede obtener información sobre otros paquetes de Node.js que puede utilizar [aquí GitHub](https://github.com/sindresorhus/awesome-nodejs).
# Configuración de maxSockets en Node.js.
En Node.js, puede definir el número máximo de conexiones por origen. Si ` maxSockets` está establecido, el cliente HTTP de bajo nivel pone en cola las solicitudes y las asigna a conectores a medida que estos están disponibles.
Esto le permite configurar un límite máximo del número de solicitudes simultáneas a un determinado origen a la vez. Si disminuye este valor, podrá reducir el número de errores de tiempo de espera o de limitación controlada. Sin embargo, también puede aumentar el uso de la memoria, ya que las solicitudes se ponen en cola hasta que un conector esté disponible.
En el siguiente ejemplo, se muestra cómo se establece `maxSockets` para un cliente de DynamoDB.
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import https from "https";
let agent = new https.Agent({
maxSockets: 25
});
let dynamodbClient = new DynamoDBClient({
requestHandler: new NodeHttpHandler({
requestTimeout: 3_000,
httpsAgent: agent
});
});
```
El SDK JavaScript utiliza un `maxSockets` valor de 50 si no se proporciona un valor o un `Agent` objeto. Si se proporciona un objeto `Agent`, se utilizará su valor `maxSockets`. Para obtener más información sobre cómo configurar `maxSockets` en Node.js, consulte la [documentación de Node.js](https://nodejs.org/dist/latest/docs/api/http.html#http_agent_maxsockets).
A partir de la versión 3.521.0 del AWS SDK para JavaScript, puedes usar la siguiente sintaxis [abreviada](https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md#new-in-v35210) para configurar. `requestHandler`
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient({
requestHandler: {
requestTimeout: 3_000,
httpsAgent: { maxSockets: 25 },
},
});
```
# Reutilización de conexiones con Keep-Alive en Node.js
El HTTP/HTTPS agente Node.js predeterminado crea una nueva conexión TCP para cada nueva solicitud. Para evitar el coste de establecer una nueva conexión, AWS SDK para JavaScript reutiliza las conexiones TCP de *forma predeterminada*.
En el caso de las operaciones de corta duración, como las consultas de Amazon DynamoDB, la sobrecarga en latencia de la configuración de una conexión TCP puede ser mayor que la propia operación. Además, dado que el [cifrado en reposo de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html) está integrado, es posible que se [AWS KMS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html)produzcan latencias en la base de datos al tener que restablecer AWS KMS nuevas entradas de caché para cada operación.
Si no desea reutilizar las conexiones TCP, puede deshabilitar la reutilización activa de estas conexiones con `keepAlive` para cada cliente de servicio, como se muestra en el siguiente ejemplo para un cliente de DynamoDB.
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { Agent } from "https";
const dynamodbClient = new DynamoDBClient({
requestHandler: new NodeHttpHandler({
httpsAgent: new Agent({ keepAlive: false })
})
});
```
Si `keepAlive` está habilitado, también puede establecer el retraso inicial de los paquetes TCP Keep-Alive con `keepAliveMsecs`, que de forma predeterminada es 1000 ms. Consulte la [documentación de Node.js](https://nodejs.org/api/http.html#new-agentoptions) para obtener más detalles.
# Configuración de proxies para Node.js
Si no puede conectarse directamente a Internet, el SDK JavaScript admite el uso de proxies HTTP o HTTPS a través de un agente HTTP de terceros.
Para encontrar un agente HTTP de terceros, busque “proxy HTTP” en [npm](https://www.npmjs.com/).
Para instalar un agente HTTP proxy de terceros, introduce lo siguiente en la línea de comandos, donde *PROXY* aparece el nombre del `npm` paquete.
```
npm install PROXY --save
```
Para usar un proxy en su aplicación, utilice la propiedad `httpAgent` y ` httpsAgent`, como se muestra en el siguiente ejemplo para un cliente de DynamoDB.
```
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { HttpsProxyAgent } from "hpagent";
const agent = new HttpsProxyAgent({ proxy: "http://internal.proxy.com" });
const dynamodbClient = new DynamoDBClient({
requestHandler: new NodeHttpHandler({
httpAgent: agent,
httpsAgent: agent
}),
});
```
**nota**
`httpAgent` no es lo mismo que `httpsAgent`, y dado que la mayoría de las llamadas del cliente serán a `https`, ambas deberían estar configuradas.
# Registro de paquetes de certificados en Node.js
Los almacenes de confianza de Node.js incluyen los certificados necesarios para tener acceso a los servicios de AWS. En algunos casos, puede ser preferible incluir únicamente un conjunto específico de certificados.
En este ejemplo, se usa un certificado específico en el disco para crear un ` https.Agent` que rechace las conexiones a menos que se proporcione el certificado designado. A continuación, el cliente de DynamoDB utiliza el `https.Agent` que se acaba de crear.
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { Agent } from "https";
import { readFileSync } from "fs";
const certs = [readFileSync("/path/to/cert.pem")];
const agent = new Agent({
rejectUnauthorized: true,
ca: certs
});
const dynamodbClient = new DynamoDBClient({
requestHandler: new NodeHttpHandler({
httpAgent: agent,
httpsAgent: agent
})
});
```
# Consideraciones sobre los scripts de navegador
En los temas siguientes se describen las consideraciones especiales que se deben tener en cuenta a la hora de utilizarlos AWS SDK para JavaScript en los scripts del navegador.
**Topics**
+ [Creación del SDK para navegadores](building-sdk-for-browsers.md)
+ [Compartir recursos entre orígenes (CORS)](cors.md)
+ [Agrupación de aplicaciones con Webpack](webpack.md)
# Creación del SDK para navegadores
A diferencia del SDK de la JavaScript versión 2 (V2), la versión 3 no se proporciona como un JavaScript archivo con soporte incluido para un conjunto de servicios predeterminado. En cambio, la versión 3 le permite agrupar e incluir en el navegador solo el SDK para los JavaScript archivos que necesite, lo que reduce la sobrecarga. Recomendamos usar Webpack para agrupar el SDK necesario para JavaScript los archivos y cualquier paquete adicional de terceros que necesite en un solo `Javascript` archivo y cargarlo en los scripts del navegador mediante una `