La AWS SDK pour .NET V3 est passée en mode maintenance.

Nous vous recommandons de migrer vers la version [AWS SDK pour .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Pour plus de détails et d'informations sur la façon de migrer, veuillez consulter notre [annonce relative au mode de maintenance](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).

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.

# Configuration avancée pour votre AWS SDK pour .NET projet
<a name="net-dg-advanced-config"></a>

Les rubriques de cette section contiennent des informations sur les tâches et méthodes de configuration supplémentaires susceptibles de vous intéresser.

**Topics**
+ [AWSSDK.Prolongations. NETCore.Configuration et IConfiguration](net-dg-config-netcore.md)
+ [Configuration d'autres paramètres de l'application](net-dg-config-other.md)
+ [Référence des fichiers de configuration pour AWS SDK pour .NET](net-dg-config-ref.md)

# À l'aide de AWSSDK .Extensions. NETCore.Setup et interface IConfiguration
<a name="net-dg-config-netcore"></a>

(Cette rubrique était auparavant intitulée « Configuration du AWS SDK pour .NET avec .NET Core »)

L'un des principaux changements apportés à .NET Core est la suppression des normes `ConfigurationManager` `app.config` et des `web.config` fichiers utilisés avec les applications .NET Framework et ASP.NET.

La configuration dans .NET Core est basée sur des paires clé-valeur établies par les fournisseurs de configuration. Les fournisseurs de configuration lisent les données de configuration en paires clé-valeur à partir de diverses sources de configuration, y compris des arguments de ligne de commande, des fichiers de répertoire, des variables d'environnement et des fichiers de paramètres.

**Note**  
Pour plus d'informations, consultez [Configuration in ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration).

Pour faciliter l'utilisation AWS SDK pour .NET avec .NET Core, vous pouvez utiliser les [AWSSDK.Extensions. NETCore NuGet .Package d'installation](https://www.nuget.org/packages/AWSSDK.Extensions.NETCore.Setup/). Comme de nombreuses bibliothèques .NET Core, elle ajoute des méthodes d'extension à l'`IConfiguration`interface pour faciliter la AWS configuration.

Le code source de ce package se trouve GitHub sur[https://github.com/aws/aws-sdk-net/tree/aws-sdk-net-v3.7/extensions/src/AWSSDK.Extensions.NETCore.Setup](https://github.com/aws/aws-sdk-net/tree/aws-sdk-net-v3.7/extensions/src/AWSSDK.Extensions.NETCore.Setup).

## À l'aide de AWSSDK .Extensions. NETCore.Configuration
<a name="net-core-configuration-builder"></a>

Supposons que vous créiez une application ASP.NET Core Model-View-Controller (MVC), ce qui peut être réalisé à l'aide du modèle d'**application Web ASP.NET Core** dans Visual Studio ou en l'exécutant `dotnet new mvc ...` dans la CLI .NET Core. Lorsque vous créez une telle application, le constructeur de `Startup.cs` gère la configuration en lisant diverses sources d'entrée provenant de fournisseurs de configuration tels que`appsettings.json`.

```
public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}
```

Pour utiliser l'`Configuration`objet afin d'obtenir les *AWS*options, ajoutez d'abord le `AWSSDK.Extensions.NETCore.Setup` NuGet package. Ajoutez ensuite vos options au fichier de configuration comme décrit ci-dessous.

Notez que l'un des fichiers ajoutés à votre projet est`appsettings.Development.json`. Cela correspond à un `EnvironmentName` ensemble de **développement**. Au cours du développement, vous insérez votre configuration dans ce fichier, qui n'est lu que lors des tests locaux. Lorsque vous déployez une instance Amazon EC2 `EnvironmentName` définie sur **Production**, ce fichier est ignoré et les informations d'identification IAM et la AWS SDK pour .NET région configurées pour l'instance Amazon EC2 sont renvoyées.

Les paramètres de configuration suivants présentent des exemples de valeurs que vous pouvez ajouter dans le `appsettings.Development.json` fichier de votre projet pour fournir des AWS paramètres.

```
{
  "AWS": {
    "Profile": "local-test-profile",
    "Region": "us-west-2"
  },
  "SupportEmail": "TechSupport@example.com"
}
```

Pour accéder à un paramètre dans un fichier *CSHTML*, utilisez la directive. `Configuration`

```
@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration

<h1>Contact</h1>

<p>
    <strong>Support:</strong> <a href='mailto:@Configuration["SupportEmail"]'>@Configuration["SupportEmail"]</a><br />
</p>
```

Pour accéder aux AWS options définies dans le fichier à partir du code, appelez la méthode d'`GetAWSOptions`extension ajoutée à`IConfiguration`.

Pour construire un client de service à partir de ces options, appelez `CreateServiceClient`. L'exemple suivant montre comment créer un client de service Amazon S3. (Assurez-vous d'ajouter le NuGet package [AWSSDK.S3](https://www.nuget.org/packages/AWSSDK.S3) à votre projet.)

```
var options = Configuration.GetAWSOptions();
IAmazonS3 client = options.CreateServiceClient<IAmazonS3>();
```

Vous pouvez également créer plusieurs clients de service avec des paramètres incompatibles en utilisant plusieurs entrées dans le `appsettings.Development.json` fichier, comme indiqué dans les exemples suivants où la configuration pour `service1` inclut la `us-west-2` région et la configuration pour `service2` inclut l'*URL* du point de terminaison spécial.

```
{
  "service1": {
    "Profile": "default",
    "Region": "us-west-2"
  },
  "service2": {
    "Profile": "default",
    "ServiceURL": "URL"
  }
}
```

Vous pouvez ensuite obtenir les options pour un service spécifique en utilisant l'entrée dans le fichier JSON. Par exemple, pour obtenir les paramètres, `service1` utilisez ce qui suit.

```
var options = Configuration.GetAWSOptions("service1");
```

### Valeurs autorisées dans le fichier appsettings
<a name="net-core-appsettings-values"></a>

Les valeurs de configuration d'application suivantes peuvent être définies dans le fichier `appsettings.Development.json`. Les noms des champs doivent utiliser le boîtier illustré. Pour plus de détails sur ces paramètres, consultez le `[AWS.Runtime.ClientConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Runtime/TClientConfig.html)` cours.
+ Région
+ Profil
+ ProfilesLocation
+ SignatureVersion
+ RegionEndpoint
+ UseHttp
+ ServiceURL
+ AuthenticationRegion
+ AuthenticationServiceName
+ MaxErrorRetry
+ LogResponse
+ BufferSize
+ ProgressUpdateInterval
+ ResignRetries
+ AllowAutoRedirect
+ LogMetrics
+ DisableLogging
+ UseDualstackEndpoint

## Injection de dépendances ASP.NET Core
<a name="net-core-dependency-injection"></a>

Les *AWSSDK.Extensions. NETCoreLe NuGet package .Setup* s'intègre également à un nouveau système d'injection de dépendances dans ASP.NET Core. La `ConfigureServices` méthode de la `Startup` classe de votre application est celle où les services MVC sont ajoutés. Si l'application utilise Entity Framework, c'est également là que l'initialisation se produit.

```
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();
}
```

**Note**  
Des informations générales sur l'injection de dépendances dans .NET Core sont disponibles sur le [site de documentation .NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection).

Le `AWSSDK.Extensions.NETCore.Setup` NuGet package ajoute de nouvelles méthodes d'extension `IServiceCollection` que vous pouvez utiliser pour ajouter AWS des services à l'injection de dépendances. Le code suivant explique comment ajouter les AWS options lues `IConfiguration` pour ajouter Amazon S3 et DynamoDB à la liste des services. (Assurez-vous d'ajouter les DBv2 NuGet packages [AWSSDK.S3](https://www.nuget.org/packages/AWSSDK.S3) et [AWSSDK.Dynamo](https://www.nuget.org/packages/AWSSDK.DynamoDBv2) à votre projet.)

```
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    services.AddDefaultAWSOptions(Configuration.GetAWSOptions());
    services.AddAWSService<IAmazonS3>();
    services.AddAWSService<IAmazonDynamoDB>();
}
```

Désormais, si vos contrôleurs MVC utilisent `IAmazonS3` ou `IAmazonDynamoDB` en tant que paramètres dans leurs constructeurs, le système d'injection de dépendances transmet ces services.

```
public class HomeController : Controller
{
    IAmazonS3 S3Client { get; set; }

    public HomeController(IAmazonS3 s3Client)
    {
        this.S3Client = s3Client;
    }

    ...

}
```

# Configuration d'autres paramètres de l'application
<a name="net-dg-config-other"></a>

**Note**  
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework. Les `Web.config` fichiers `App.config` et ne sont pas présents par défaut dans les projets basés sur .NET Core.

## Ouvrir pour afficher le contenu du .NET Framework
<a name="w2aab9c31b9b5b1"></a>

Vous pouvez configurer un certain nombre de paramètres d'application :
+  `AWSLogging` 
+  `AWSLogMetrics` 
+  `AWSRegion` 
+  `AWSResponseLogging` 
+  `AWS.DynamoDBContext.TableNamePrefix` 
+  `AWS.S3.UseSignatureVersion4` 
+  `AWSEndpointDefinition` 
+  [AWS Points de terminaison générés par le service](#config-setting-service-generated-awsendpointdefinition) 

Ces paramètres peuvent être configurés dans le fichier `App.config` ou `Web.config` de l'application. Bien que vous puissiez également les configurer à l'aide de l' AWS SDK pour .NET API, nous vous recommandons d'utiliser le `.config` fichier de l'application. Les deux approches sont décrites ici.

Pour plus d'informations sur l'utilisation de l'`<aws>`élément, comme décrit plus loin dans cette rubrique, consultez la section [Référence des fichiers de configuration pour AWS SDK pour .NET](net-dg-config-ref.md).

### AWSLogging
<a name="config-setting-awslogging"></a>

Configure comment SDK doit consigner les événements, le cas échéant. Par exemple, l'approche recommandée consiste à utiliser l'élément `<logging>`, élément enfant de l'élément `<aws>` :

```
<aws>
  <logging logTo="Log4Net"/>
</aws>
```

Autrement :

```
<add key="AWSLogging" value="log4net"/>
```

Les valeurs possibles sont :

** `None` **  
Désactivez la journalisation des événements . Il s’agit de l’option par défaut.

** `log4net` **  
Journaliser à l'aide de log4net.

** `SystemDiagnostics` **  
Journaliser à l'aide de la classe `System.Diagnostics`.

Vous pouvez définir plusieurs valeurs pour l'attribut `logTo`, séparées par des virgules. L'exemple suivant définit la journalisation `log4net` et `System.Diagnostics` dans le fichier `.config` :

```
<logging logTo="Log4Net, SystemDiagnostics"/>
```

Autrement :

```
<add key="AWSLogging" value="log4net, SystemDiagnostics"/>
```

Vous pouvez également, à l'aide de l' AWS SDK pour .NET API, combiner les valeurs de l'[LoggingOptions](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TLoggingOptions.html)énumération et définir la propriété [AWSConfigs.Logging](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html) :

```
AWSConfigs.Logging = LoggingOptions.Log4Net | LoggingOptions.SystemDiagnostics;
```

Les modifications apportées à ce paramètre ne prennent effet que pour les nouvelles instances AWS clientes.

### AWSLogMétriques
<a name="config-setting-awslogmetrics"></a>

Spécifie si SDK doit ou non journaliser les métriques de performance. Pour définir la configuration de journalisation des métriques dans le fichier `.config`, définissez la valeur de l'attribut `logMetrics` dans l'élément `<logging>`, élément enfant de l'élément `<aws>` :

```
<aws>
  <logging logMetrics="true"/>
</aws>
```

Sinon, définissez la clé `AWSLogMetrics` dans la section `<appSettings>` :

```
<add key="AWSLogMetrics" value="true">
```

Sinon, pour définir la journalisation des métriques avec l' AWS SDK pour .NET API, définissez le [AWSConfigs. LogMetrics](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriété :

```
AWSConfigs.LogMetrics = true;
```

Ce paramètre configure la propriété `LogMetrics` par défaut pour tous les clients et toutes les configurations. Les modifications apportées à ce paramètre ne prennent effet que pour les nouvelles instances AWS clientes.

### AWSRegion
<a name="config-setting-awsregion"></a>

Configure la AWS région par défaut pour les clients qui n'ont pas explicitement spécifié de région. Pour définir la région dans le fichier `.config`, l'approche recommandée consiste à définir la valeur de l'attribut `region` dans l'élément `aws` :

```
<aws region="us-west-2"/>
```

Sinon, définissez la clé *AWSRegion* dans la section `<appSettings>` :

```
<add key="AWSRegion" value="us-west-2"/>
```

Sinon, pour définir la région à l'aide de l' AWS SDK pour .NET API, définissez le [AWSConfigs. AWSRegion](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriété :

```
AWSConfigs.AWSRegion = "us-west-2";
```

Pour plus d'informations sur la création d'un AWS client pour une région spécifique, consultez la section [Sélection de AWS région](net-dg-region-selection.md). Les modifications apportées à ce paramètre ne prennent effet que pour les nouvelles instances AWS clientes.

### AWSResponseJournalisation
<a name="config-setting-awsresponselogging"></a>

Configure quand SDK doit journaliser les réponses du service. Les valeurs possibles sont :

** `Never` **  
Les réponses du service ne sont jamais journalisées. Il s’agit de l’option par défaut.

** `Always` **  
Les réponses du service sont toujours journalisées.

** `OnError` **  
Journaliser les réponses du service uniquement lorsqu'une erreur se produit.

Pour définir la configuration de journalisation de service dans le fichier `.config`, l'approche recommandée consiste à définir la valeur de l'attribut `logResponses` dans l'élément `<logging>`, élément enfant de l'élément `<aws>` :

```
<aws>
  <logging logResponses="OnError"/>
</aws>
```

Vous pouvez également définir la clé de *AWSResponsejournalisation* dans la `<appSettings>` section :

```
<add key="AWSResponseLogging" value="OnError"/>
```

Sinon, pour configurer la journalisation des services avec l' AWS SDK pour .NET API, définissez le [AWSConfigs. ResponseLogging](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriété à l'une des valeurs de l'[ResponseLoggingOption](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TResponseLoggingOption.html)énumération :

```
AWSConfigs.ResponseLogging = ResponseLoggingOption.OnError;
```

Les modifications apportées à ce paramètre prennent effet immédiatement.

### `AWS.DynamoDBContext.TableNamePrefix`
<a name="config-setting-aws-dynamodbcontext-tablenameprefix"></a>

Configure la valeur par défaut de `TableNamePrefix` ; `DynamoDBContext` est utilisé si aucune configuration manuelle n'est effectuée.

Pour définir le préfixe du nom de table dans le fichier `.config`, l'approche recommandée consiste à définir la valeur de l'attribut `tableNamePrefix` dans l'élément `<dynamoDBContext>`, élément enfant de l'élément `<dynamoDB>`, lui-même élément enfant de l'élément `<aws>` :

```
<dynamoDBContext tableNamePrefix="Test-"/>
```

Sinon, définissez la clé `AWS.DynamoDBContext.TableNamePrefix` dans la section `<appSettings>` :

```
<add key="AWS.DynamoDBContext.TableNamePrefix" value="Test-"/>
```

Sinon, pour définir le préfixe du nom de table avec l' AWS SDK pour .NET API, définissez la propriété [AWSConfigs.Dynamo DBContext TableNamePrefix](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html) :

```
AWSConfigs.DynamoDBContextTableNamePrefix = "Test-";
```

Les modifications apportées à ce paramètre prennent effet uniquement pour les instances nouvellement construites de `DynamoDBContextConfig` et `DynamoDBContext`.

### `AWS.S3.UseSignatureVersion4`
<a name="config-setting-aws-s3-usesignatureversion4"></a>

Configure si le client Amazon S3 doit ou non utiliser la signature version 4 pour signer avec les demandes.

Pour définir la signature de la version 4 pour Amazon S3 dans le `.config` fichier, l'approche recommandée consiste à définir l'`useSignatureVersion4`attribut de l'`<s3>`élément, qui est un élément enfant de l'`<aws>`élément :

```
<aws>
  <s3 useSignatureVersion4="true"/>
</aws>
```

Vous pouvez également définir la `AWS.S3.UseSignatureVersion4` clé sur `true` dans la `<appSettings>` section :

```
<add key="AWS.S3.UseSignatureVersion4" value="true"/>
```

Sinon, pour définir la signature de la version 4 de la signature avec l' AWS SDK pour .NET API, définissez la propriété [AWSConfigs.S3 UseSignatureVersion 4](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html) sur `true` :

```
AWSConfigs.S3UseSignatureVersion4 = true;
```

Par défaut, ce paramètre est `false`, mais Signature version 4 peut être utilisé par défaut dans certains cas ou avec certaines régions. Lorsque le paramètre est `true`, Signature version 4 est utilisé pour toutes les demandes. Les modifications apportées à ce paramètre ne prennent effet que pour les nouvelles instances du client Amazon S3.

### AWSEndpointDéfinition
<a name="config-setting-awsendpointdefinition"></a>

Configure si SDK doit utiliser un fichier de configuration personnalisé qui définit les régions et les points de terminaison.

Pour définir le fichier de définition de point de terminaison dans le fichier `.config`, nous vous recommandons de définir la valeur de l'attribut `endpointDefinition` dans l'élément `<aws>`.

```
<aws endpointDefinition="c:\config\endpoints.json"/>
```

Vous pouvez également définir la clé de *AWSEndpointdéfinition* dans la `<appSettings>` section :

```
<add key="AWSEndpointDefinition" value="c:\config\endpoints.json"/>
```

Sinon, pour définir le fichier de définition du point de terminaison avec l' AWS SDK pour .NET API, définissez le [AWSConfigs. EndpointDefinition](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriété :

```
AWSConfigs.EndpointDefinition = @"c:\config\endpoints.json";
```

Si vous n'indiquez pas de nom de fichier, aucun fichier de configuration personnalisé ne sera utilisé. Les modifications apportées à ce paramètre ne prennent effet que pour les nouvelles instances AWS clientes. Le fichier endpoint.json est disponible sur. [https://github.com/aws/aws-sdk-net/blob/aws-sdk-net-v3.7/sdk/src/Core/endpoints.json](https://github.com/aws/aws-sdk-net/blob/aws-sdk-net-v3.7/sdk/src/Core/endpoints.json)

### AWS Points de terminaison générés par le service
<a name="config-setting-service-generated-awsendpointdefinition"></a>

Certains AWS services génèrent leurs propres points de terminaison au lieu de consommer un point de terminaison régional. Les clients de ces services utilisent une URL de service spécifique à chaque service et à vos ressources. Amazon CloudSearch et AWS IoT. Les exemples suivants illustrent comment obtenir les points de terminaison pour ces services.

#### Exemple de CloudSearch point de terminaison Amazon
<a name="cs-endpoints-example"></a>

Le CloudSearch client Amazon est utilisé pour accéder au service CloudSearch de configuration Amazon. Vous utilisez le service CloudSearch de configuration Amazon pour créer, configurer et gérer des domaines de recherche. Pour créer un domaine de recherche, créez un [CreateDomainRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCreateDomainRequest.html)objet et indiquez la `DomainName` propriété. Créez un [AmazonCloudSearchClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCloudSearchClient.html)objet à l'aide de l'objet de demande. Appelez la méthode [CreateDomain](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/MCloudSearchCreateDomainCreateDomainRequest.html). L'[CreateDomainResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCreateDomainResponse.html)objet renvoyé par l'appel contient une `DomainStatus` propriété qui possède à la fois les `SearchService` points de terminaison `DocService` et. Créez un [AmazonCloudSearchDomainConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearchDomain/TCloudSearchDomainConfig.html)objet et utilisez-le pour initialiser `DocService` les `SearchService` instances de la [AmazonCloudSearchDomainClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearchDomain/TCloudSearchDomainClient.html)classe.

```
// Create domain and retrieve DocService and SearchService endpoints
DomainStatus domainStatus;
using (var searchClient = new AmazonCloudSearchClient())
{
    var request = new CreateDomainRequest
    {
        DomainName = "testdomain"
    };
    domainStatus = searchClient.CreateDomain(request).DomainStatus;
    Console.WriteLine(domainStatus.DomainName + " created");
}

// Test the DocService endpoint
var docServiceConfig = new AmazonCloudSearchDomainConfig
{
    ServiceURL = "https://" + domainStatus.DocService.Endpoint
};
using (var domainDocService = new AmazonCloudSearchDomainClient(docServiceConfig))
{
    Console.WriteLine("Amazon CloudSearchDomain DocService client instantiated using the DocService endpoint");
    Console.WriteLine("DocService endpoint = " + domainStatus.DocService.Endpoint);

    using (var docStream = new FileStream(@"C:\doc_source\XMLFile4.xml", FileMode.Open))
    {
        var upload = new UploadDocumentsRequest
        {
            ContentType = ContentType.ApplicationXml,
            Documents = docStream
        };
        domainDocService.UploadDocuments(upload);
    }
}

// Test the SearchService endpoint
var searchServiceConfig = new AmazonCloudSearchDomainConfig
{
    ServiceURL = "https://" + domainStatus.SearchService.Endpoint
};
using (var domainSearchService = new AmazonCloudSearchDomainClient(searchServiceConfig))
{
    Console.WriteLine("Amazon CloudSearchDomain SearchService client instantiated using the SearchService endpoint");
    Console.WriteLine("SearchService endpoint = " + domainStatus.SearchService.Endpoint);

    var searchReq = new SearchRequest
    {
        Query = "Gambardella",
        Sort = "_score desc",
        QueryParser = QueryParser.Simple
    };
    var searchResp = domainSearchService.Search(searchReq);
}
```

#### AWS IoT Exemple de points de terminaison
<a name="iotlong-endpoints-example"></a>

Pour obtenir le point de terminaison pour AWS IoT, créez un [AmazonIoTClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/TIoTClient.html)objet et appelez la [DescribeEndPoint](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/MIoTDescribeEndpointDescribeEndpointRequest.html)méthode. L'[DescribeEndPointResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/TDescribeEndpointResponse.html)objet renvoyé contient le`EndpointAddress`. Créez un [AmazonIotDataConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IotData/TIotDataConfig.html)objet, définissez la `ServiceURL` propriété et utilisez-le pour instancier la [AmazonIotDataClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IotData/TIotDataClient.html)classe.

```
string iotEndpointAddress;
using (var iotClient = new AmazonIoTClient())
{
    var endPointResponse = iotClient.DescribeEndpoint();
    iotEndpointAddress = endPointResponse.EndpointAddress;
}

var ioTdocServiceConfig = new AmazonIotDataConfig
{
    ServiceURL = "https://" + iotEndpointAddress
};
using (var dataClient = new AmazonIotDataClient(ioTdocServiceConfig))
{
    Console.WriteLine("AWS IoTData client instantiated using the endpoint from the IotClient");
}
```

# Référence des fichiers de configuration pour AWS SDK pour .NET
<a name="net-dg-config-ref"></a>

**Note**  
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework. Les `Web.config` fichiers `App.config` et ne sont pas présents par défaut dans les projets basés sur .NET Core.

## Ouvrir pour afficher le contenu du .NET Framework
<a name="w2aab9c31c11b5b1"></a>

Vous pouvez utiliser un projet `App.config` ou un `Web.config` fichier .NET pour spécifier des AWS paramètres, tels que les AWS informations d'identification, les options de journalisation, les points de terminaison de AWS service et AWS les régions, ainsi que certains paramètres pour AWS des services tels qu'Amazon DynamoDB EC2, Amazon et Amazon S3. Vous trouverez ci-dessous des informations expliquant comment mettre correctement en forme un fichier `App.config` ou `Web.config` pour spécifier ces types de paramètres.

**Note**  
Bien que vous puissiez continuer à utiliser l'`<appSettings>`élément dans un `Web.config` fichier `App.config` OR pour spécifier des AWS paramètres, nous vous recommandons d'utiliser les `<aws>` éléments `<configSections>` et comme décrit plus loin dans cette rubrique. Pour plus d'informations sur l'`<appSettings>`élément, consultez les exemples d'`<appSettings>`éléments dans [Configuration de votre AWS SDK pour .NET application](net-dg-config.md).

**Note**  
Bien que vous puissiez continuer à utiliser les propriétés de [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)classe suivantes dans un fichier de code pour spécifier des AWS paramètres, les propriétés suivantes sont obsolètes et ne seront peut-être pas prises en charge dans les versions futures :  
 `DynamoDBContextTableNamePrefix` 
 `EC2UseSignatureVersion4` 
 `LoggingOptions` 
 `LogMetrics` 
 `ResponseLoggingOption` 
 `S3UseSignatureVersion4` 
En général, nous recommandons qu'au lieu d'utiliser les propriétés de `AWSConfigs` classe d'un fichier de code pour spécifier AWS les paramètres, vous utilisiez les `<aws>` éléments `<configSections>` et d'un `Web.config` fichier `App.config` or pour spécifier AWS les paramètres, comme décrit plus loin dans cette rubrique. Pour plus d'informations sur les propriétés précédentes, consultez les exemples de `AWSConfigs` code dans [Configuration de votre AWS SDK pour .NET application](net-dg-config.md).

**Topics**
+ [Déclarer une section AWS de paramètres](#net-dg-config-ref-declaring)
+ [Éléments autorisés](#net-dg-config-ref-elements)
+ [Informations de référence sur les éléments](#net-dg-config-ref-elements-ref)

### Déclarer une section AWS de paramètres
<a name="net-dg-config-ref-declaring"></a>

Vous définissez AWS les paramètres dans un `Web.config` fichier `App.config` or à partir de l'`<aws>`élément. Avant de commencer à utiliser l'élément `<aws>`, vous devez créer un élément `<section>` (qui est un élément enfant de l'élément `<configSections>`) et affecter à son attribut `name` la valeur `aws` et à son attribut `type` la valeur `Amazon.AWSSection, AWSSDK.Core`, comme dans l'exemple suivant :

```
<?xml version="1.0"?>
<configuration>
  ...
  <configSections>
    <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/>
  </configSections>
  <aws>
    <!-- Add your desired AWS settings declarations here. -->
  </aws>
  ...
</configuration>
```

L'éditeur Visual Studio ne fournit pas de saisie automatique du code (IntelliSense) pour l'`<aws>`élément ou ses éléments enfants.

Pour vous aider à créer une version correctement mise en forme de l'élément `<aws>`, appelez la méthode `Amazon.AWSConfigs.GenerateConfigTemplate`. Celle-ci génère une version canonique de l'élément `<aws>` sous la forme d'une chaîne bien formée, que vous pouvez adapter à vos besoins. Les sections suivantes décrivent les attributs et les éléments enfants de l'élément `<aws>`.

### Éléments autorisés
<a name="net-dg-config-ref-elements"></a>

Voici une liste des relations logiques entre les éléments autorisés dans une section de AWS paramètres. Vous pouvez générer la dernière version de cette liste en appelant la méthode `Amazon.AWSConfigs.GenerateConfigTemplate`, qui génère une version canonique de l'élément `<aws>` sous la forme d'une chaîne que vous pouvez adapter à vos besoins.

```
<aws
  endpointDefinition="string value"
  region="string value"
  profileName="string value"
  profilesLocation="string value">
  <logging
    logTo="None, Log4Net, SystemDiagnostics"
    logResponses="Never | OnError | Always"
    logMetrics="true | false"
    logMetricsFormat="Standard | JSON"
    logMetricsCustomFormatter="NameSpace.Class, Assembly" />
  <dynamoDB
    conversionSchema="V1 | V2">
    <dynamoDBContext
      tableNamePrefix="string value">
      <tableAliases>
        <alias
          fromTable="string value"
          toTable="string value" />
      </tableAliases>
      <map
        type="NameSpace.Class, Assembly"
        targetTable="string value">
        <property
          name="string value"
          attribute="string value"
          ignore="true | false"
          version="true | false"
          converter="NameSpace.Class, Assembly" />
      </map>
    </dynamoDBContext>
  </dynamoDB>
  <s3
    useSignatureVersion4="true | false" />
  <ec2
    useSignatureVersion4="true | false" />
  <proxy
    host="string value"
    port="1234"
    username="string value"
    password="string value" />
</aws>
```

### Informations de référence sur les éléments
<a name="net-dg-config-ref-elements-ref"></a>

Voici une liste des éléments autorisés dans une section de AWS paramètres. Pour chaque élément, ses attributs autorisés et éléments parents-enfants sont répertoriés.

**Topics**
+ [alias](#net-dg-config-ref-elements-alias)
+ [`aws`](#net-dg-config-ref-elements-aws)
+ [dynamoDB](#net-dg-config-ref-elements-dynamodb)
+ [dynamo DBContext](#net-dg-config-ref-elements-ddbcontext)
+ [ec2](#net-dg-config-ref-elements-ec2)
+ [journalisation](#net-dg-config-ref-elements-logging)
+ [map](#net-dg-config-ref-elements-map)
+ [property](#net-dg-config-ref-elements-property)
+ [proxy](#net-dg-config-ref-elements-proxy)
+ [s3](#net-dg-config-ref-elements-s3)

#### alias
<a name="net-dg-config-ref-elements-alias"></a>

L'élément `<alias>` représente un élément unique dans une collection d'un ou plusieurs mappages entre la table de départ et la table d'arrivée qui spécifie une table différente de celle configurée pour un type. Cet élément est mappé à une instance de la classe `Amazon.Util.TableAlias` à partir de la propriété `Amazon.AWSConfigs.DynamoDBConfig.Context.TableAliases` du AWS SDK pour .NET. Le remappage intervient avant l'application d'un préfixe de nom de table.

Cet élément peut inclure les attributs suivants :

** `fromTable` **  
Partie « table de départ » du mappage entre la table de départ et la table d'arrivée. Cet attribut est mappé à la propriété `Amazon.Util.TableAlias.FromTable` du AWS SDK pour .NET.

** `toTable` **  
Partie « table d'arrivée » du mappage entre la table de départ et la table d'arrivée. Cet attribut est mappé à la propriété `Amazon.Util.TableAlias.ToTable` du AWS SDK pour .NET.

Le parent de l'élément `<alias>` est l'élément `<tableAliases>`.

L'élément `<alias>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<alias>` utilisé :

```
<alias
  fromTable="Studio"
  toTable="Studios" />
```

#### `aws`
<a name="net-dg-config-ref-elements-aws"></a>

L'`<aws>`élément représente l'élément le plus haut d'une section de AWS paramètres. Cet élément peut inclure les attributs suivants :

** `endpointDefinition` **  
Le chemin absolu vers un fichier de configuration personnalisé qui définit les AWS régions et les points de terminaison à utiliser. Cet attribut est mappé à la propriété `Amazon.AWSConfigs.EndpointDefinition` du AWS SDK pour .NET.

** `profileName` **  
Le nom du profil pour les AWS informations d'identification stockées qui seront utilisées pour effectuer des appels de service. Cet attribut est mappé à la propriété `Amazon.AWSConfigs.AWSProfileName` du AWS SDK pour .NET.

** `profilesLocation` **  
Le chemin absolu vers l'emplacement du fichier d'informations d'identification partagé avec d'autres AWS SDKs. Par défaut, le fichier d'informations d'identification est stocké dans le répertoire `.aws` situé dans le répertoire de base de l'utilisateur actif. Cet attribut est mappé à la propriété `Amazon.AWSConfigs.AWSProfilesLocation` du AWS SDK pour .NET.

** `region` **  
L'ID de AWS région par défaut pour les clients qui n'ont pas explicitement spécifié de région. Cet attribut est mappé à la propriété `Amazon.AWSConfigs.AWSRegion` du AWS SDK pour .NET.

L'élément `<aws>` n'a pas d'élément parent.

L'élément `<aws>` peut inclure les éléments enfants suivants :
+  `<dynamoDB>` 
+  `<ec2>` 
+  `<logging>` 
+  `<proxy>` 
+  `<s3>` 

Voici un exemple de l'élément `<aws>` utilisé :

```
<aws
  endpointDefinition="C:\Configs\endpoints.xml"
  region="us-west-2"
  profileName="development"
  profilesLocation="C:\Configs">
  <!-- ... -->
</aws>
```

#### dynamoDB
<a name="net-dg-config-ref-elements-dynamodb"></a>

L'élément `<dynamoDB>` représente un ensemble de paramètres pour Amazon DynamoDB. Cet élément peut inclure l'attribut *conversionSchema*, qui représente la version à utiliser pour la conversion entre des objets .NET et des objets DynamoDB. Les valeurs autorisées sont notamment V1 et V2. Cet attribut est mappé à la classe `Amazon.DynamoDBv2.DynamoDBEntryConversion` du AWS SDK pour .NET. Pour plus d'informations, consultez [DynamoDB Series – Conversion Schemas](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas).

Le parent de l'élément `<dynamoDB>` est l'élément `<aws>`.

L'élément `<dynamoDB>` peut inclure l'élément enfant `<dynamoDBContext>`.

Voici un exemple de l'élément `<dynamoDB>` utilisé :

```
<dynamoDB
  conversionSchema="V2">
  <!-- ... -->
</dynamoDB>
```

#### dynamo DBContext
<a name="net-dg-config-ref-elements-ddbcontext"></a>

L'élément `<dynamoDBContext>` représente un ensemble de paramètres propres au contexte Amazon DynamoDB. Cet élément peut inclure l'*tableNamePrefix*attribut, qui représente le préfixe de nom de table par défaut que le contexte DynamoDB utilisera s'il n'est pas configuré manuellement. Cet attribut est mappé à la propriété `Amazon.Util.DynamoDBContextConfig.TableNamePrefix` à partir de la propriété `Amazon.AWSConfigs.DynamoDBConfig.Context.TableNamePrefix` du AWS SDK pour .NET. Pour plus d'informations, consultez [Enhancements to the DynamoDB SDK](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK).

Le parent de l'élément `<dynamoDBContext>` est l'élément `<dynamoDB>`.

L'élément `<dynamoDBContext>` peut inclure les éléments enfants suivants :
+  `<alias>` (une ou plusieurs instances)
+  `<map>` (une ou plusieurs instances)

Voici un exemple de l'élément `<dynamoDBContext>` utilisé :

```
<dynamoDBContext
  tableNamePrefix="Test-">
  <!-- ... -->
</dynamoDBContext>
```

#### ec2
<a name="net-dg-config-ref-elements-ec2"></a>

L'`<ec2>`élément représente un ensemble de EC2 paramètres Amazon. Cet élément peut inclure l'attribut *useSignatureVersion4*, qui indique si la signature version 4 sera utilisée pour toutes les demandes (vrai) ou si la signature version 4 ne sera pas utilisée pour toutes les demandes (faux, valeur par défaut). Cet attribut est mappé à la propriété `Amazon.Util.EC2Config.UseSignatureVersion4` à partir de la propriété `Amazon.AWSConfigs.EC2Config.UseSignatureVersion4` du AWS SDK pour .NET.

Le parent de l'`<ec2>`élément est l'élément.

L'élément `<ec2>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<ec2>` utilisé :

```
<ec2
  useSignatureVersion4="true" />
```

#### journalisation
<a name="net-dg-config-ref-elements-logging"></a>

L'élément `<logging>` représente un ensemble de paramètres pour la journalisation des réponses et la journalisation des métriques de performance. Cet élément peut inclure les attributs suivants :

** `logMetrics` **  
Indique si les métriques de performance sont journalisées pour tous les clients et toutes les configurations (true) ; sinon, false. Cet attribut est mappé à la propriété `Amazon.Util.LoggingConfig.LogMetrics` à partir de la propriété `Amazon.AWSConfigs.LoggingConfig.LogMetrics` du AWS SDK pour .NET.

** `logMetricsCustomFormatter` **  
Type de données et nom d'assembly d'un formateur personnalisé pour les métriques de performance. Cet attribut est mappé à la propriété `Amazon.Util.LoggingConfig.LogMetricsCustomFormatter` à partir de la propriété `Amazon.AWSConfigs.LoggingConfig.LogMetricsCustomFormatter` du AWS SDK pour .NET.

** `logMetricsFormat` **  
Format sous lequel se présentent les métriques de journalisation (mappé à la propriété `Amazon.Util.LoggingConfig.LogMetricsFormat` à partir de la propriété `Amazon.AWSConfigs.LoggingConfig.LogMetricsFormat` du AWS SDK pour .NET).  
Les valeurs autorisées sont les suivantes :    
** `JSON` **  
Utilise le format JSON.  
** `Standard` **  
Utilise le format par défaut.

** `logResponses` **  
Indique à quel moment les réponses du service sont journalisées (mappé à la propriété `Amazon.Util.LoggingConfig.LogResponses` à partir de la propriété `Amazon.AWSConfigs.LoggingConfig.LogResponses` du AWS SDK pour .NET).  
Les valeurs autorisées sont les suivantes :    
** `Always` **  
Les réponses du service sont toujours journalisées.  
** `Never` **  
Les réponses du service ne sont jamais journalisées.  
** `OnError` **  
Les réponse du service sont journalisées uniquement en cas d'erreur.

** `logTo` **  
Où se connecter (cartes de la `LogTo` propriété depuis la `Amazon.AWSConfigs.LoggingConfig.LogTo` propriété dans le AWS SDK pour .NET).  
Les valeurs autorisées comprennent une ou plusieurs des valeurs suivantes :    
** `Log4Net` **  
Journalisation dans log4net.  
** `None` **  
Désactivation de la journalisation.  
** `SystemDiagnostics` **  
Journalisation dans System.Diagnostics.

Le parent de l'élément `<logging>` est l'élément `<aws>`.

L'élément `<logging>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<logging>` utilisé :

```
<logging
  logTo="SystemDiagnostics"
  logResponses="OnError"
  logMetrics="true"
  logMetricsFormat="JSON"
  logMetricsCustomFormatter="MyLib.Util.MyMetricsFormatter, MyLib" />
```

#### map
<a name="net-dg-config-ref-elements-map"></a>

L'`<map>`élément représente un élément unique d'une collection de type-to-table mappages entre les types .NET et les tables DynamoDB (correspond à une instance de `TypeMapping` la classe à partir de la propriété `Amazon.AWSConfigs.DynamoDBConfig.Context.TypeMappings` du). AWS SDK pour .NET Pour plus d'informations, consultez [Enhancements to the DynamoDB SDK](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK).

Cet élément peut inclure les attributs suivants :

** `targetTable` **  
Table DynamoDB à laquelle le mappage s'applique. Cet attribut est mappé à la propriété `Amazon.Util.TypeMapping.TargetTable` du AWS SDK pour .NET.

** `type` **  
Type et nom d'assembly auxquels le mappage s'applique. Cet attribut est mappé à la propriété `Amazon.Util.TypeMapping.Type` du AWS SDK pour .NET.

Le parent de l'élément `<map>` est l'élément `<dynamoDBContext>`.

L'élément `<map>` peut inclure une ou plusieurs instances de l'élément enfant `<property>`.

Voici un exemple de l'élément `<map>` utilisé :

```
<map
  type="SampleApp.Models.Movie, SampleDLL"
  targetTable="Movies">
  <!-- ... -->
</map>
```

#### property
<a name="net-dg-config-ref-elements-property"></a>

L'élément `<property>` représente une propriété DynamoDB. (Cet élément correspond à une instance d'Amazon.Util. PropertyConfig [classe issue de la `AddProperty` méthode décrite dans le AWS SDK pour .NET) Pour plus d'informations, consultez [Améliorations apportées au SDK DynamoDB et aux attributs DynamoDB](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK).](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DeclarativeTagsList.html)

Cet élément peut inclure les attributs suivants :

** `attribute` **  
Nom d'un attribut de la propriété, par exemple le nom d'une clé de plage. Cet attribut est mappé à la propriété `Amazon.Util.PropertyConfig.Attribute` du AWS SDK pour .NET.

** `converter` **  
Type du convertisseur qui doit être utilisé pour cette propriété. Cet attribut est mappé à la propriété `Amazon.Util.PropertyConfig.Converter` du AWS SDK pour .NET.

** `ignore` **  
Indique si la propriété associée doit être ignorée (true) ; sinon, false. Cet attribut est mappé à la propriété `Amazon.Util.PropertyConfig.Ignore` du AWS SDK pour .NET.

** `name` **  
Le nom de la propriété. Cet attribut est mappé à la propriété `Amazon.Util.PropertyConfig.Name` du AWS SDK pour .NET.

** `version` **  
Indique si cette propriété doit stocker le numéro de version de l'élément (true) ; sinon, false. Cet attribut est mappé à la propriété `Amazon.Util.PropertyConfig.Version` du AWS SDK pour .NET.

Le parent de l'élément `<property>` est l'élément `<map>`.

L'élément `<property>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<property>` utilisé :

```
<property
  name="Rating"
  converter="SampleApp.Models.RatingConverter, SampleDLL" />
```

#### proxy
<a name="net-dg-config-ref-elements-proxy"></a>

L'élément `<proxy>` représente les paramètres de configuration d'un proxy pour le AWS SDK pour .NET à utiliser. Cet élément peut inclure les attributs suivants :

**hôte**  
Nom d'hôte ou adresse IP du serveur proxy. Cet attribut est mappé à la propriété `Amazon.Util.ProxyConfig.Host` à partir de la propriété `Amazon.AWSConfigs.ProxyConfig.Host` du AWS SDK pour .NET.

**mot de passe**  
Mot de passe permettant de s'authentifier auprès du serveur proxy. Cet attribut est mappé à la propriété `Amazon.Util.ProxyConfig.Password` à partir de la propriété `Amazon.AWSConfigs.ProxyConfig.Password` du AWS SDK pour .NET.

**port**  
Numéro de port du proxy. Cet attribut est mappé à la propriété `Amazon.Util.ProxyConfig.Port` à partir de la propriété `Amazon.AWSConfigs.ProxyConfig.Port` du AWS SDK pour .NET.

**nom d’utilisateur**  
Nom d'utilisateur permettant de s'authentifier auprès du serveur proxy. Cet attribut est mappé à la propriété `Amazon.Util.ProxyConfig.Username` à partir de la propriété `Amazon.AWSConfigs.ProxyConfig.Username` du AWS SDK pour .NET.

Le parent de l'élément `<proxy>` est l'élément `<aws>`.

L'élément `<proxy>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<proxy>` utilisé :

```
<proxy
  host="192.0.2.0"
  port="1234"
  username="My-Username-Here"
  password="My-Password-Here" />
```

#### s3
<a name="net-dg-config-ref-elements-s3"></a>

L'élément `<s3>` représente un ensemble de paramètres Amazon S3. Cet élément peut inclure l'attribut *useSignatureVersion4*, qui indique si la signature version 4 sera utilisée pour toutes les demandes (vrai) ou si la signature version 4 ne sera pas utilisée pour toutes les demandes (faux, valeur par défaut). Cet attribut est mappé à la propriété `Amazon.AWSConfigs.S3Config.UseSignatureVersion4` du AWS SDK pour .NET.

Le parent de l'élément `<s3>` est l'élément `<aws>`.

L'élément `<s3>` ne contient aucun élément enfant.

Voici un exemple de l'élément `<s3>` utilisé :

```
<s3 useSignatureVersion4="true" />
```