Le [guide de référence de l'API AWS SDK pour JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) décrit en détail toutes les opérations de l'API pour la AWS SDK pour JavaScript version 3 (V3). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configurer le SDK pour JavaScript
<a name="configuring-the-jssdk"></a>

Avant d'utiliser le SDK pour appeler des services Web JavaScript à l'aide de l'API, vous devez configurer le SDK. Vous devez au minimum configurer :
+ La AWS région dans laquelle vous demanderez des services
+ Comment votre code s'authentifie auprès de AWS

Outre ces paramètres, vous devrez peut-être également configurer des autorisations pour vos AWS ressources. Par exemple, vous pouvez limiter l'accès à un compartiment Amazon S3 ou restreindre l'accès en lecture seule à une table Amazon DynamoDB.

Le [guide de référence AWS SDKs and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/) contient également des paramètres, des fonctionnalités et d'autres concepts fondamentaux communs à de AWS SDKs nombreux. 

Les rubriques de cette section décrivent les méthodes de configuration du SDK JavaScript pour Node.js et son JavaScript exécution dans un navigateur Web.

**Topics**
+ [Configuration par service](global-config-object.md)
+ [Définissez la AWS région](setting-region.md)
+ [Définir les informations d'identification](setting-credentials.md)
+ [Considérations relatives à Node.js](node-js-considerations.md)
+ [Considérations à propos des scripts du navigateur](browser-js-considerations.md)

# Configuration par service
<a name="global-config-object"></a>

Vous pouvez configurer le SDK en transmettant les informations de configuration à un objet de service.

La configuration au niveau des services fournit un contrôle significatif sur les services individuels, ce qui vous permet de mettre à jour la configuration des objets de service individuels lorsque vos besoins diffèrent de la configuration par défaut.

**Note**  
Dans la version 2.x du AWS SDK pour JavaScript service, la configuration pouvait être transmise à des constructeurs clients individuels. Cependant, ces configurations seraient d'abord fusionnées automatiquement dans une copie de la configuration `AWS.config` globale du SDK.  
De plus, appeler `AWS.config.update({/* params *})` uniquement la configuration mise à jour pour les clients de service instanciés après l'appel de mise à jour, pas pour les clients existants.  
Ce comportement était une source fréquente de confusion et a rendu difficile l'ajout d'une configuration à l'objet global qui n'affecte qu'un sous-ensemble de clients de service d'une manière compatible avec la transmission. Dans la version 3, il n'existe plus de configuration globale gérée par le SDK. La configuration doit être transmise à chaque client de service instancié. Il est toujours possible de partager la même configuration entre plusieurs clients, mais cette configuration ne sera pas automatiquement fusionnée avec un état global.

## Définir la configuration par service
<a name="service-specific-configuration"></a>

Chaque service que vous utilisez dans le SDK JavaScript est accessible via un objet de service faisant partie de l'API de ce service. Par exemple, pour accéder au service Amazon S3, vous créez l'objet de service Amazon S3. Vous pouvez spécifier les paramètres de configuration spécifiques à un service dans le cadre du constructeur pour cet objet de service. 

Par exemple, si vous devez accéder à des objets Amazon EC2 dans plusieurs AWS régions, créez un objet de service Amazon EC2 pour chaque région, puis définissez la configuration régionale de chaque objet de service en conséquence.

```
var ec2_regionA = new EC2({region: 'ap-southeast-2', maxAttempts: 15});
var ec2_regionB = new EC2({region: 'us-west-2', maxAttempts: 15});
```

# Définissez la AWS région
<a name="setting-region"></a>

Une AWS région est un ensemble nommé de AWS ressources dans la même zone géographique. Un exemple de région est `us-east-1` la région de l'est des États-Unis (Virginie du Nord). Vous spécifiez une région lors de la création d'un client de service dans le SDK pour JavaScript que le SDK accède au service de cette région. Certains services sont disponibles uniquement dans certaines régions.

Le SDK pour JavaScript ne sélectionne pas de région par défaut. Vous pouvez toutefois définir la AWS région à l'aide d'une variable d'environnement ou d'un `config` fichier de configuration partagé.

## Dans un constructeur de classe client
<a name="setting-region-constructor"></a>

Lorsque vous instanciez un objet de service, vous pouvez spécifier la AWS région pour cette ressource dans le cadre du constructeur de classe client, comme illustré ici.

```
const s3Client = new S3.S3Client({region: 'us-west-2'});
```

## Utiliser une variable d'environnement
<a name="setting-region-environment-variable"></a>

Vous pouvez définir la région à l'aide de la variable d'environnement `AWS_REGION`. Si vous définissez cette variable, le SDK for la JavaScript lit et l'utilise.

## Utiliser un fichier de configuration partagé
<a name="setting-region-config-file"></a>

Tout comme le fichier d'informations d'identification partagé vous permet de stocker les informations d'identification à utiliser par le SDK, vous pouvez conserver votre AWS région et les autres paramètres de configuration dans un fichier partagé nommé `config` d'après le SDK à utiliser. Si la variable d'`AWS_SDK_LOAD_CONFIG`environnement est définie sur une valeur vraie, le SDK recherche JavaScript automatiquement un `config` fichier lors de son chargement. L'emplacement d'enregistrement du fichier `config` dépend de votre système d'exploitation :
+ Utilisateurs de Linux, de macOS ou d'Unix - `~/.aws/config`
+ Utilisateurs de Windows - `C:\Users\USER_NAME\.aws\config`

Si vous n'avez pas encore de fichier `config` partagé, vous pouvez en créer un dans le répertoire désigné. Dans l'exemple suivant, le fichier `config` définit la région et le format de sortie.

```
[default]
   region=us-west-2
   output=json
```

Pour plus d'informations sur l'utilisation du partage `config` et `credentials` des fichiers, consultez la section [Fichiers de configuration et d'informations d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) dans le *Guide de référence des outils AWS SDKs et*.

## Ordre de priorité pour définir la région
<a name="setting-region-order-of-precedence"></a>

L'ordre de priorité pour le réglage des régions est le suivant :

1. Si une région est transmise à un constructeur de classe client, cette région est utilisée.

1. Si une région est définie dans la variable d'environnement, cette région est utilisée.

1. Dans le cas contraire, la région définie dans le fichier de configuration partagé est utilisée.

# Définir les informations d'identification
<a name="setting-credentials"></a>

AWS utilise des informations d'identification pour identifier qui appelle les services et si l'accès aux ressources demandées est autorisé. 

Qu'il soit exécuté dans un navigateur Web ou sur un serveur Node.js, votre JavaScript code doit obtenir des informations d'identification valides avant de pouvoir accéder aux services via l'API. Les informations d'identification peuvent être définies par service, en les transmettant directement à un objet de service.

Il existe plusieurs manières de définir des informations d'identification qui diffèrent entre Node.js et JavaScript dans les navigateurs Web. Les rubriques de cette section décrivent comment définir les informations d'identification dans Node.js ou des navigateurs web. Dans chaque cas, les options sont présentées dans l'ordre recommandé.

## Bonnes pratiques en matière d'informations d'identification
<a name="credentials-best-practices"></a>

Si les informations d'identification sont correctement définies, le script de votre application ou navigateur peut accéder aux services et ressources nécessaires tout en réduisant l'exposition aux problèmes de sécurité qui peuvent avoir un impact sur les applications stratégiques ou compromettre les données sensibles.

Lors de la définition des informations d'identification, il convient de toujours accorder le moindre privilège requis pour la tâche. Il est plus sûr d'octroyer les autorisations minimales pour vos ressources et d'en ajouter d'autres au besoin, plutôt que d'accorder des autorisations qui dépassent le moindre privilège et, par conséquent, d'avoir à résoudre les problèmes de sécurité que vous pourriez découvrir par la suite. Par exemple, à moins que vous n'ayez besoin de lire et d'écrire des ressources individuelles, telles que des objets dans un compartiment Amazon S3 ou une table DynamoDB, définissez ces autorisations en lecture seule.

Pour plus d'informations sur l'octroi du moindre privilège, consultez la section [Accorder le moindre privilège](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) de la rubrique Bonnes pratiques du *Guide de l'utilisateur IAM*.

**Topics**
+ [Bonnes pratiques en matière d'informations d'identification](#credentials-best-practices)
+ [Définissez les informations d'identification dans Node.js](setting-credentials-node.md)
+ [Définir les informations d'identification dans un navigateur Web](setting-credentials-browser.md)

# Définissez les informations d'identification dans Node.js
<a name="setting-credentials-node"></a>

Nous recommandons aux nouveaux utilisateurs qui se développent localement et qui n'ont pas reçu de méthode d'authentification de la part de leur employeur de les configurer AWS IAM Identity Center. Pour de plus amples informations, veuillez consulter [Authentification du SDK avec AWS](getting-your-credentials.md).

Dans Node.js, il existe plusieurs façons de fournir vos informations d'identification au kit SDK. Certaines sont plus sécurisées, tandis que d'autres s'avèrent plus pratiques lors du développement d'une application. Lorsque vous obtenez des informations d'identification dans Node.js, veillez à ne pas vous fier à plusieurs sources, telles qu'une variable d'environnement et un fichier JSON que vous chargez. Vous pourriez en effet modifier les autorisations sous lesquelles s'exécute votre code sans vous en rendre compte.

AWS SDK pour JavaScript La version 3 fournit une chaîne de fournisseurs d'informations d'identification par défaut dans Node.js. Vous n'êtes donc pas obligé de fournir un fournisseur d'informations d'identification de manière explicite. La [chaîne de fournisseurs d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) par défaut tente de résoudre les informations d'identification provenant de différentes sources selon une priorité donnée, jusqu'à ce qu'une information d'identification soit renvoyée par l'une des sources. [Vous trouverez la chaîne de fournisseurs d'informations d'identification pour le SDK pour JavaScript V3 ici.](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromnodeproviderchain)

## Chaîne de fournisseurs d'identifiants
<a name="credchain"></a>

Tous SDKs ont une série de lieux (ou de sources) qu'ils vérifient afin d'obtenir des informations d'identification valides à utiliser pour faire une demande à un Service AWS. Une fois les informations d’identification valides trouvées, la recherche s’arrête. Cette recherche systématique est appelée chaîne de fournisseurs d'informations d'identification par défaut. 

Pour chaque étape de la chaîne, il existe différentes manières de définir les valeurs. La définition des valeurs directement dans le code est toujours prioritaire, suivie de la définition en tant que variables d'environnement, puis dans le AWS `config` fichier partagé. Pour plus d'informations, consultez la section [Priorité des paramètres](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#precedenceOfSettings) dans le *Guide de référence des outils AWS SDKs et des outils*. 

Le *guide de référence AWS SDKs and Tools* contient des informations sur les paramètres de configuration du SDK utilisés par tous AWS SDKs et les AWS CLI. Pour en savoir plus sur la configuration du SDK via le AWS `config` fichier partagé, consultez la section [Fichiers de configuration et d'informations d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html). Pour en savoir plus sur la configuration du SDK en définissant des variables d'environnement, consultez la section Prise en [charge des variables d'environnement](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html).

Pour s'authentifier AWS, AWS SDK pour JavaScript vérifie les fournisseurs d'informations d'identification dans l'ordre indiqué dans le tableau suivant.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)

Si vous avez suivi l'approche recommandée pour les nouveaux utilisateurs pour démarrer, vous avez configuré AWS IAM Identity Center l'authentification au cours [Authentification du SDK avec AWS](getting-your-credentials.md) de la rubrique Mise en route. D'autres méthodes d'authentification sont utiles dans différentes situations. Pour éviter les risques de sécurité, nous vous recommandons de toujours utiliser des informations d'identification à court terme. Pour les autres procédures relatives aux méthodes d'[authentification, voir Authentification et accès](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) dans le *guide de référence des outils AWS SDKs et*.

Les rubriques de cette section décrivent comment charger les informations d'identification dans Node.js.

**Topics**
+ [Chaîne de fournisseurs d'identifiants](#credchain)
+ [Charger les informations d'identification dans le fichier Node.js à partir des rôles IAM pour Amazon EC2](loading-node-credentials-iam.md)
+ [Charger les informations d'identification pour une fonction Lambda Node.js](loading-node-credentials-lambda.md)

# Charger les informations d'identification dans le fichier Node.js à partir des rôles IAM pour Amazon EC2
<a name="loading-node-credentials-iam"></a>

Si vous exécutez votre application Node.js sur une instance Amazon EC2, vous pouvez tirer parti des rôles IAM pour qu'Amazon EC2 fournisse automatiquement des informations d'identification à l'instance. Si vous configurez votre instance pour utiliser des rôles IAM, le SDK sélectionne automatiquement les informations d'identification IAM pour votre application, éliminant ainsi le besoin de fournir manuellement des informations d'identification.

Pour plus d'informations sur l'ajout de rôles IAM à une instance Amazon EC2, [consultez la section Rôles IAM pour Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) EC2.

# Charger les informations d'identification pour une fonction Lambda Node.js
<a name="loading-node-credentials-lambda"></a>

Lorsque vous créez une AWS Lambda fonction, vous devez créer un rôle IAM spécial autorisé à exécuter la fonction. Il s'agit du *rôle d'exécution*. Lorsque vous configurez une fonction Lambda, vous devez spécifier le rôle IAM que vous avez créé comme rôle d'exécution correspondant.

Le rôle d'exécution fournit à la fonction Lambda les informations d'identification dont elle a besoin pour s'exécuter et appeler d'autres services Web. Par conséquent, il n'est pas nécessaire de fournir des informations d'identification pour le code Node.js que vous écrivez dans une fonction Lambda.

*Pour plus d'informations sur la création d'un rôle d'exécution Lambda, voir [Gérer les autorisations : utilisation d'un rôle IAM (rôle d'exécution)](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) dans le Guide du AWS Lambda développeur.*

# Définir les informations d'identification dans un navigateur Web
<a name="setting-credentials-browser"></a>

Il existe plusieurs façons de fournir vos informations d'identification au kit SDK à partir des scripts de navigateur. Certaines sont plus sécurisées, tandis que d'autres s'avèrent plus pratiques lors du développement d'un script.

 Voici comment vous pouvez fournir vos informations d'identification, par ordre de recommandation :

1. Utilisation d'Amazon Cognito Identity pour authentifier les utilisateurs et fournir des informations d'identification

1. Utilisation de l'identité web fédérée

**Avertissement**  
Nous vous déconseillons de coder en dur vos AWS informations d'identification dans vos scripts. En effet, le codage en dur des informations d'identification risque d'exposer votre ID de clé d'accès et votre clé d'accès secrète.

**Topics**
+ [Utiliser Amazon Cognito Identity pour authentifier les utilisateurs](loading-browser-credentials-cognito.md)

# Utiliser Amazon Cognito Identity pour authentifier les utilisateurs
<a name="loading-browser-credentials-cognito"></a>

La méthode recommandée pour obtenir des AWS informations d'identification pour les scripts de votre navigateur consiste à utiliser le client d'identification Amazon Cognito Identity. `CognitoIdentityClient` Amazon Cognito permet l'authentification des utilisateurs par le biais de fournisseurs d'identité tiers.

Pour utiliser Amazon Cognito Identity, vous devez d'abord créer un pool d'identités dans la console Amazon Cognito. Un groupe d'identités représente le groupe des identités fournies par votre application à vos utilisateurs. Les identités attribuées aux utilisateurs identifient de manière unique chaque compte utilisateur. Les identités Amazon Cognito ne sont pas des informations d'identification. Ils sont échangés contre des informations d'identification à l'aide du support de fédération d'identité Web dans AWS Security Token Service (AWS STS).

Amazon Cognito vous aide à gérer l'abstraction des identités entre plusieurs fournisseurs d'identité. L'identité chargée est ensuite échangée contre les informations d'identification dans AWS STS.

## Configuration de l'objet d'identification Amazon Cognito Identity
<a name="browser-cognito-configuration"></a>

Si vous n'en avez pas encore créé un, créez un pool d'identités à utiliser avec les scripts de votre navigateur dans la [console Amazon Cognito](https://console.aws.amazon.com/cognito) avant de configurer votre client Amazon Cognito. Créez et associez des rôles IAM authentifiés et non authentifiés pour votre pool d'identités. Pour plus d'informations, consultez [Tutoriel : Création d'un pool d'identités](https://docs.aws.amazon.com/cognito/latest/developerguide/tutorial-create-identity-pool.html) dans le manuel *Amazon Cognito Developer Guide*.

L'identité des utilisateurs non authentifiés n'est pas vérifiée, ce rôle est donc approprié pour les utilisateurs invités de votre application ou dans les cas où le fait que l'identité des utilisateurs soit vérifiée n'a pas d'importance. Les utilisateurs authentifiés se connectent à votre application via un fournisseur d'identité tiers qui vérifie leur identité. Assurez-vous de définir de façon appropriée les autorisations des ressources afin de ne pas y accorder l'accès aux utilisateurs non authentifiés.

Après avoir configuré un pool d'identités, utilisez la `fromCognitoIdentityPool` méthode du `@aws-sdk/credential-providers` pour récupérer les informations d'identification du pool d'identités. Dans l'exemple suivant de création d'un client Amazon S3, remplacez-le *AWS\$1REGION* par la région et *IDENTITY\$1POOL\$1ID* par l'ID du pool d'identités.

```
// 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 propriété facultative `logins` est un mappage de noms de fournisseur d'identité avec les jetons d'identité de ces fournisseurs. La façon dont vous obtenez le jeton de la part de votre fournisseur d'identité dépend du fournisseur que vous utilisez. Par exemple, si vous utilisez un groupe d'utilisateurs Amazon Cognito comme fournisseur d'authentification, vous pouvez utiliser une méthode similaire à celle ci-dessous.

```
// 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;
};
```

## Passer d'utilisateurs non authentifiés à des utilisateurs authentifiés
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito prend en charge les utilisateurs authentifiés et non authentifiés. Les utilisateurs non authentifiés bénéficient d'un accès à vos ressources, même s'ils ne sont pas connectés avec l'un de vos fournisseurs d'identité. Ce degré d'accès est utile pour afficher du contenu aux utilisateurs avant qu'ils ne se connectent. Chaque utilisateur non authentifié possède une identité unique dans Amazon Cognito, même s'il n'a pas été connecté et authentifié individuellement.

### Utilisateur initialement non authentifié
<a name="browser-initially-unauthenticated-user"></a>

Les utilisateurs commencent généralement par le rôle non authentifié, pour lequel vous définissez la propriété des informations d'identification de votre objet de configuration sans propriété `logins`. Dans ce cas, vos informations d'identification par défaut peuvent ressembler à ce qui suit :

```
// Import the required AWS SDK pour 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.
});
```

### Basculement vers un utilisateur authentifié
<a name="switch-to-authenticated"></a>

Lorsqu'un utilisateur non authentifié se connecte à un fournisseur d'identité et que vous disposez d'un jeton, vous pouvez passer du statut d'utilisateur non authentifié à celui d'utilisateur authentifié en appelant une fonction personnalisée qui met à jour l'objet d'identification et ajoute le jeton. `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;
}
```

# Considérations relatives à Node.js
<a name="node-js-considerations"></a>

Bien que le code Node.js le soit JavaScript, l'utilisation du fichier AWS SDK pour JavaScript dans Node.js peut être différente de l'utilisation du SDK dans les scripts de navigateur. Certaines méthodes d'API fonctionnent dans Node.js, mais pas dans les scripts du navigateur et inversement. Et l'utilisation réussie de certains d'entre eux APIs dépend de votre connaissance des modèles de codage courants de Node.js, tels que l'importation et l'utilisation d'autres modules Node.js tels que le `File System (fs)` module.

**Note**  
AWS recommande d'utiliser la version Active LTS de Node.js pour le développement.

## Utiliser les modules Node.js intégrés
<a name="node-common-modules"></a>

Node.js fournit un ensemble de modules intégrés que vous pouvez utiliser sans les installer. Pour utiliser ces modules, créez un objet en appliquant la méthode `require` afin de nommer le module. Par exemple, pour inclure le module HTTP intégré, utilisez le code ci-dessous.

```
import http from 'http';
```

Invoquez les méthodes du module comme si elles étaient des méthodes de cet objet. Par exemple, voici un code qui lit un fichier 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
  }
});
```

Pour une liste complète de tous les modules intégrés fournis par Node.js, consultez la [documentation Node.js](https://nodejs.org/api/modules.html) sur le site Web Node.js.

## Utiliser les packages npm
<a name="node-npm-packages"></a>

Outre les modules intégrés, vous pouvez également inclure et intégrer du code tiers à partir du `npm` gestionnaire de packages Node.js. Il s'agit d'un référentiel de packages Node.js open source et d'une interface de ligne de commande permettant d'installer ces packages. Pour plus d'informations `npm` et pour obtenir la liste des packages actuellement disponibles, consultez [ https://www.npmjs.com](https://www.npmjs.com). Vous pouvez également en savoir plus sur les packages Node.js supplémentaires que vous pouvez utiliser [ici GitHub](https://github.com/sindresorhus/awesome-nodejs).

# Configurer les MaxSockets dans Node.js
<a name="node-configuring-maxsockets"></a>

Dans Node.js, vous pouvez définir le nombre maximal de connexions par origine. Si ` maxSockets` est défini, le client HTTP de bas niveau place les demandes en file d'attente et les affecte aux sockets au fur et à mesure qu'ils deviennent disponibles.

Vous pouvez ainsi définir un nombre maximal supérieur de demandes simultanées pour une origine donnée. Le fait de réduire cette valeur peut réduire le nombre d'erreurs de limitation ou d'expiration reçues. Toutefois, il peut aussi en résulter une utilisation accrue de la mémoire, car les demandes sont placées en file d'attente jusqu'à ce qu'un socket devienne disponible.

L'exemple suivant montre comment effectuer une configuration `maxSockets` pour un client 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
  });
});
```

Le SDK pour JavaScript utilise une `maxSockets` valeur de 50 si vous ne fournissez pas de valeur ou d'`Agent`objet. Si vous fournissez un `Agent` objet, sa `maxSockets` valeur sera utilisée. Pour plus d'informations sur `maxSockets` le paramétrage dans Node.js, consultez la [documentation Node.js](https://nodejs.org/dist/latest/docs/api/http.html#http_agent_maxsockets).

À partir de la version 3.521.0 du AWS SDK pour JavaScript, vous pouvez utiliser la syntaxe [abrégée](https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md#new-in-v35210) suivante pour configurer. `requestHandler`

```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";

const client = new DynamoDBClient({
  requestHandler: {
    requestTimeout: 3_000,
    httpsAgent: { maxSockets: 25 },
  },
});
```

# Réutiliser les connexions avec keep-alive dans Node.js
<a name="node-reusing-connections"></a>

L' HTTP/HTTPS agent Node.js par défaut crée une nouvelle connexion TCP pour chaque nouvelle demande. Pour éviter les coûts liés à l'établissement d'une nouvelle connexion, les connexions AWS SDK pour JavaScript TCP sont réutilisées *par défaut*.

Pour les opérations de courte durée, telles que les requêtes Amazon DynamoDB, le temps de latence associé à la configuration d'une connexion TCP peut être supérieur à celui de l'opération elle-même. En outre, étant donné que le [chiffrement DynamoDB au](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html) repos est intégré, vous pouvez [AWS KMS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html)rencontrer des latences lorsque la base de données doit rétablir de AWS KMS nouvelles entrées de cache pour chaque opération. 

Si vous ne souhaitez pas réutiliser les connexions TCP, vous pouvez désactiver la réutilisation active de ces connexions, client par service, comme indiqué dans l'exemple suivant pour un client DynamoDB. `keepAlive`

```
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 cette option `keepAlive` est activée, vous pouvez également définir le délai initial pour les paquets TCP Keep-Alive`keepAliveMsecs`, qui est par défaut de 1 000 ms. Consultez la [documentation Node.js](https://nodejs.org/api/http.html#new-agentoptions) pour plus de détails.

# Configurer les proxys pour Node.js
<a name="node-configuring-proxies"></a>

Si vous ne pouvez pas vous connecter directement à Internet, le SDK JavaScript prend en charge l'utilisation de proxys HTTP ou HTTPS via un agent HTTP tiers.

Pour trouver un agent HTTP tiers, recherchez « proxy HTTP » sur [npm](https://www.npmjs.com/).

Pour installer un agent proxy HTTP tiers, entrez le code suivant à l'invite de commande, où *PROXY* figure le nom du `npm` package. 

```
npm install PROXY --save
```

Pour utiliser un proxy dans votre application, utilisez la ` httpsAgent` propriété `httpAgent` and, comme illustré dans l'exemple suivant pour un client 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
    }),
});
```

**Note**  
`httpAgent`n'est pas la même chose que`httpsAgent`, et comme la plupart des appels du client seront adressés à`https`, les deux doivent être définis.

# Enregistrez les ensembles de certificats dans Node.js
<a name="node-registering-certs"></a>

Les magasins de confiance par défaut pour Node.js incluent les certificats nécessaires pour accéder aux AWS services. Dans certains cas, il peut être préférable d'inclure uniquement un ensemble de certificats donné.

Dans cet exemple, un certificat spécifique sur le disque est utilisé pour créer un ` https.Agent` qui rejette les connexions, à moins que le certificat désigné ne soit fourni. La nouvelle création `https.Agent` est ensuite utilisée par le client DynamoDB.

```
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
  })
});
```

# Considérations à propos des scripts du navigateur
<a name="browser-js-considerations"></a>

Les rubriques suivantes décrivent les considérations particulières relatives à l'utilisation des scripts AWS SDK pour JavaScript dans le navigateur.

**Topics**
+ [Créez le SDK pour les navigateurs](building-sdk-for-browsers.md)
+ [Partage des ressources cross-origin (CORS)](cors.md)
+ [Regroupez des applications avec Webpack](webpack.md)

# Créez le SDK pour les navigateurs
<a name="building-sdk-for-browsers"></a>

Contrairement au SDK pour JavaScript la version 2 (V2), la version 3 n'est pas fournie sous forme de JavaScript fichier avec prise en charge d'un ensemble de services par défaut. Au lieu de cela, la V3 vous permet de regrouper et d'inclure dans le navigateur uniquement le SDK pour les JavaScript fichiers dont vous avez besoin, ce qui réduit les frais de gestion. Nous vous recommandons d'utiliser Webpack pour regrouper le SDK requis pour JavaScript les fichiers, ainsi que tous les packages tiers supplémentaires dont vous avez besoin, dans un seul `Javascript` fichier, et le charger dans des scripts de navigateur à l'aide d'une `<script>` balise. Pour plus d'informations sur Webpack, consultez[Regroupez des applications avec Webpack](webpack.md). 

Si vous travaillez avec le SDK en dehors d'un environnement qui applique CORS dans votre navigateur et si vous souhaitez accéder à tous les services fournis par le SDK pour JavaScript, vous pouvez créer une copie personnalisée du SDK localement en clonant le référentiel et en exécutant les mêmes outils de génération que ceux utilisés pour créer la version hébergée par défaut du SDK. Les sections suivantes décrivent les étapes à suivre pour créer le kit SDK avec des services et des versions d'API supplémentaires.

## Utilisez le SDK Builder pour créer le SDK pour JavaScript
<a name="using-the-sdk-builder"></a>

**Note**  
La version 3 (V3) d'Amazon Web Services ne prend plus en charge Browser Builder. Pour minimiser l'utilisation de la bande passante par les applications du navigateur, nous vous recommandons d'importer des modules nommés et de les regrouper afin de réduire leur taille. Pour plus d'informations sur le regroupement, consultez[Regroupez des applications avec Webpack](webpack.md).

# Partage des ressources cross-origin (CORS)
<a name="cors"></a>

Le partage des ressources cross-origin, ou CORS, est une fonctionnalité de sécurité des navigateurs web modernes. Elle permet aux navigateurs web de négocier les domaines pouvant effectuer des demandes de sites web ou services externes. 

CORS est une fonction importante à prendre en considération lors du développement des applications de navigateur avec le kit AWS SDK pour JavaScript , car la plupart des demandes de ressources sont envoyées à un domaine externe, tel que le point de terminaison d'un service web. Si votre JavaScript environnement applique la sécurité CORS, vous devez configurer CORS avec le service.

CORS détermine s'il convient d'autoriser le partage de ressources dans une demande d'origine croisée sur la base des éléments suivants :
+ Le domaine spécifique qui effectue la demande 
+ Le type de demande HTTP effectuée (GET, PUT, POST, DELETE, etc.)

## Comment fonctionne CORS
<a name="how-cors-works"></a>

Dans le cas le plus simple, votre script de navigateur effectue une demande GET pour une ressource à partir d'un serveur appartenant à un autre domaine. Selon la configuration CORS de ce serveur, si la demande provient d'un domaine qui est autorisé à soumettre des demandes GET, le serveur cross-origin répond en retournant la ressource demandée.

Si le domaine effectuant la demande ou si le type de demande HTTP n'est pas autorisé, la demande est refusée. Toutefois, CORS permet de vérifier la demande en amont avant de la soumettre. Dans ce cas, une demande en amont est effectuée. Cette demande inclut l'envoi de l'opération de demande d'accès `OPTIONS`. Si la configuration de la fonction CORS du serveur cross-origin accorde l'accès au domaine demandeur, le serveur renvoie une réponse en amont qui répertorie tous les types de requête HTTP que le domaine demandeur peut faire sur la ressource demandée.

![\[Flux de processus pour les demandes CORS\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/cors-overview.png)


## La configuration CORS est-elle requise ?
<a name="the-need-for-cors-configuration"></a>

Les compartiments Amazon S3 nécessitent une configuration CORS avant que vous puissiez effectuer des opérations sur ceux-ci. Dans certains JavaScript environnements, le CORS peut ne pas être appliqué et sa configuration n'est donc pas nécessaire. Par exemple, si vous hébergez votre application à partir d'un compartiment Amazon S3 et que vous accédez à des ressources depuis un point de terminaison spécifique `*.s3.amazonaws.com` ou depuis un autre point de terminaison spécifique, vos demandes n'accèderont pas à un domaine externe. Par conséquent, cette configuration n'exige pas CORS. Dans ce cas, CORS est toujours utilisé pour des services autres qu'Amazon S3.

## Configurer CORS pour un compartiment Amazon S3
<a name="configuring-cors-s3-bucket"></a>

Vous pouvez configurer un compartiment Amazon S3 pour utiliser CORS dans la console Amazon S3.

Si vous configurez CORS dans la console de gestion des services AWS Web, vous devez utiliser JSON pour créer une configuration CORS. La nouvelle console de gestion des services AWS Web prend uniquement en charge les configurations JSON CORS. 

**Important**  
Dans la nouvelle console de gestion des services AWS Web, la configuration CORS doit être JSON.

1. Dans la console de gestion des services AWS Web, ouvrez la console Amazon S3, recherchez le compartiment que vous souhaitez configurer et cochez sa case.

1. Dans le volet qui s'ouvre, choisissez **Permissions**.

1. Dans l'onglet **Autorisation**, choisissez **Configuration CORS.**

1. **Entrez votre configuration CORS dans l'**éditeur de configuration CORS**, puis choisissez Enregistrer.**

Une configuration CORS est un fichier XML qui contient une série de règles au sein d'un élément `<CORSRule>`. Une configuration peut contenir jusqu'à 100 règles. Une règle est définie par l'une des balises suivantes :
+ `<AllowedOrigin>`— Spécifie les origines de domaines que vous autorisez à effectuer des demandes entre domaines.
+ `<AllowedMethod>`— Spécifie le type de demande que vous autorisez (GET, PUT, POST, DELETE, HEAD) dans les requêtes interdomaines.
+ `<AllowedHeader>`— Spécifie les en-têtes autorisés dans une demande de prévol.

Pour des exemples de configurations, voir [Comment configurer CORS sur mon bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cors.html#how-do-i-enable-cors) ? dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.

## Exemple de configuration CORS
<a name="cors-configuration-example"></a>

L'exemple de configuration CORS suivant permet à un utilisateur de visualiser, d'ajouter, de supprimer ou de mettre à jour des objets à l'intérieur d'un compartiment du domaine`example.org`. Cependant, nous vous recommandons de `<AllowedOrigin>` définir le domaine de votre site Web. Vous pouvez spécifier `"*"` pour autoriser n'importe quelle origine.

**Important**  
Dans la nouvelle console S3, la configuration CORS doit être de type JSON.

------
#### [ XML ]

```
<?xml version="1.0" encoding="UTF-8"?>
<CORSConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <CORSRule>
    <AllowedOrigin>https://example.org</AllowedOrigin>
    <AllowedMethod>HEAD</AllowedMethod>
    <AllowedMethod>GET</AllowedMethod>
    <AllowedMethod>PUT</AllowedMethod>
    <AllowedMethod>POST</AllowedMethod>
    <AllowedMethod>DELETE</AllowedMethod>
    <AllowedHeader>*</AllowedHeader>
    <ExposeHeader>ETag</ExposeHeader>
    <ExposeHeader>x-amz-meta-custom-header</ExposeHeader>
  </CORSRule>
</CORSConfiguration>
```

------
#### [ JSON ]

```
[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "HEAD",
            "GET",
            "PUT",
            "POST",
            "DELETE"
        ],
        "AllowedOrigins": [
            "https://www.example.org"
        ],
        "ExposeHeaders": [
             "ETag",
             "x-amz-meta-custom-header"]
    }
]
```

------

Cette configuration n'autorise pas l'utilisateur à effectuer des actions sur le compartiment. Il active le modèle de sécurité du navigateur pour autoriser une demande à Amazon S3. Les autorisations doivent être configurées via des autorisations de compartiment ou des autorisations de rôle IAM.

Vous pouvez l'utiliser `ExposeHeader` pour permettre au SDK de lire les en-têtes de réponse renvoyés par Amazon S3. Par exemple, si vous lisez l'`ETag`en-tête d'un téléchargement partitionné `PUT` ou partiel, vous devez inclure la `ExposeHeader` balise dans votre configuration, comme indiqué dans l'exemple précédent. Le kit SDK ne peut accéder qu'aux en-têtes qui sont exposés via la configuration CORS. Si vous définissez des métadonnées sur l'objet, les valeurs sont renvoyées sous forme d'en-têtes avec le préfixe `x-amz-meta-`, comme `x-amz-meta-my-custom-header` par exemple, et doivent également être exposées de la même manière.

# Regroupez des applications avec Webpack
<a name="webpack"></a>

L'utilisation de modules de code par des applications Web dans des scripts de navigateur ou dans Node.js crée des dépendances. Ces modules de code peuvent avoir leurs propres dépendances, ce qui se traduit par un ensemble de modules interconnectés nécessaires à votre application pour fonctionner. Pour gérer les dépendances, vous pouvez utiliser un bundler de modules tel que`webpack`.

Le `webpack` module bundler analyse le code de votre application, à la recherche d'`require`instructions `import` ou d'instructions, pour créer des ensembles contenant tous les actifs dont votre application a besoin. Cela permet de diffuser facilement les actifs via une page Web. Le SDK pour JavaScript peut être inclus `webpack` comme l'une des dépendances à inclure dans le bundle de sortie.

Pour plus d'informations sur`webpack`, consultez le [bundler du module Webpack](https://webpack.github.io/) sur. GitHub

## Installer webpack
<a name="webpack-installing"></a>

Pour installer le bundler de `webpack` modules, vous devez d'abord installer npm, le gestionnaire de packages Node.js. Tapez la commande suivante pour installer la `webpack` CLI et le JavaScript module.

```
npm install --save-dev webpack
```

Pour utiliser le `path` module permettant de travailler avec les chemins de fichiers et de répertoires, qui est installé automatiquement avec Webpack, vous devrez peut-être installer le `path-browserify` package Node.js. 

```
npm install --save-dev path-browserify
```

## Configurer le webpack
<a name="webpack-configuring"></a>

Par défaut, Webpack recherche un JavaScript fichier nommé `webpack.config.js` dans le répertoire racine de votre projet. Ce fichier spécifie vos options de configuration. Voici un exemple de fichier de `webpack.config.js` configuration pour les WebPack versions 5.0.0 et ultérieures.

**Note**  
Les exigences de configuration du Webpack varient en fonction de la version du Webpack que vous installez. Pour plus d'informations, consultez la [documentation du Webpack](https://webpack.js.org/configuration/). 

```
// Import path for resolving file paths
var path = require("path");
module.exports = {
  // Specify the entry point for our app.
  entry: [path.join(__dirname, "browser.js")],
  // Specify the output file containing our bundled code.
  output: {
    path: __dirname,
    filename: 'bundle.js'
  },
   // Enable WebPack to use the 'path' package.
   resolve:{
  fallback: { path: require.resolve("path-browserify")}
  }
  /**
  * In Webpack version v2.0.0 and earlier, you must tell 
  * webpack how to use "json-loader" to load 'json' files.
  * To do this Enter 'npm --save-dev install json-loader' at the 
  * command line to install the "json-loader' package, and include the 
  * following entry in your webpack.config.js.
  * module: {
    rules: [{test: /\.json$/, use: use: "json-loader"}]
  }
  **/
};
```

Dans cet exemple, `browser.js` est spécifié comme *point d'entrée*. Le *point d'entrée* est le fichier `webpack` utilisé pour commencer à rechercher les modules importés. Le nom de fichier de la sortie est spécifié en tant que `bundle.js`. Ce fichier de sortie contiendra tout ce dont JavaScript l'application a besoin pour fonctionner. Si le code spécifié dans le point d'entrée importe ou nécessite d'autres modules, tels que le SDK pour JavaScript, ce code est groupé sans qu'il soit nécessaire de le spécifier dans la configuration.

## Exécuter le webpack
<a name="webpack-running"></a>

Pour créer une application à utiliser`webpack`, ajoutez ce qui suit à l'`scripts`objet de votre `package.json` fichier.

```
"build": "webpack"
```

Voici un exemple de `package.json` fichier illustrant l'ajout`webpack`.

```
{
  "name": "aws-webpack",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@aws-sdk/client-iam": "^3.32.0",
    "@aws-sdk/client-s3": "^3.32.0"
  },
  "devDependencies": {
    "webpack": "^5.0.0"
  }
}
```

Pour créer votre application, entrez la commande suivante.

```
npm run build
```

Le `webpack` module bundler génère ensuite le JavaScript fichier que vous avez spécifié dans le répertoire racine de votre projet.

## Utiliser le bundle Webpack
<a name="webpack-using-bundle"></a>

Pour utiliser le bundle dans un script de navigateur, vous pouvez l'intégrer à l'aide d'une `<script>` balise, comme illustré dans l'exemple suivant.

```
<!DOCTYPE html>
<html>
    <head>
        <title>Amazon SDK with webpack</title>
    </head> 
    <body>
        <div id="list"></div>
        <script src="bundle.js"></script>
    </body>
</html>
```

## Bundle pour Node.js
<a name="webpack-nodejs-bundles"></a>

Vous pouvez l'utiliser `webpack` pour générer des bundles qui s'exécutent dans Node.js en les spécifiant `node` comme cible dans la configuration.

```
target: "node"
```

Cela s'avère utile lors de l'exécution d'une application Node.js dans un environnement où l'espace disque est limité. Voici un exemple de configuration `webpack.config.js` avec Node.js spécifié comme cible de sortie.

```
// Import path for resolving file paths
var path = require("path");
module.exports = {
  // Specify the entry point for our app.
  entry: [path.join(__dirname, "browser.js")],
  // Specify the output file containing our bundled code.
  output: {
    path: __dirname,
    filename: 'bundle.js'
  },
  // Let webpack know to generate a Node.js bundle.
  target: "node",
   // Enable WebPack to use the 'path' package.
   resolve:{
  fallback: { path: require.resolve("path-browserify")}
   /**
   * In Webpack version v2.0.0 and earlier, you must tell 
   * webpack how to use "json-loader" to load 'json' files.
   * To do this Enter 'npm --save-dev install json-loader' at the 
   * command line to install the "json-loader' package, and include the 
   * following entry in your webpack.config.js.
   module: {
    rules: [{test: /\.json$/, use: use: "json-loader"}]
  }
  **/
};
```