O AWS SDK para .NET V3 entrou no modo de manutenção.

Recomendamos que você migre para a [AWS SDK para .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Para obter detalhes e informações adicionais sobre como migrar, consulte nosso [anúncio do modo de manutenção](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurações avançadas para seu projeto do AWS SDK para .NET
<a name="net-dg-advanced-config"></a>

Os tópicos desta seção contêm informações sobre tarefas e métodos de configurações adicionais que podem ser do seu interesse.

**Topics**
+ [AWSSDK.Extensões. NETCore.Configuração e IConfiguration](net-dg-config-netcore.md)
+ [

# Configuração de outros parâmetros do aplicativo
](net-dg-config-other.md)
+ [

# Referência dos arquivos de configuração para o AWS SDK para .NET
](net-dg-config-ref.md)

# Usando AWSSDK .Extensions. NETCore.Configuração e interface IConfiguration
<a name="net-dg-config-netcore"></a>

(Este tópico era anteriormente intitulado “Configurando o AWS SDK para .NET com o.NET Core”)

Uma das principais alterações no .NET Core é a retirada do `ConfigurationManager` e dos arquivos padrão `app.config` e `web.config` usados nos aplicativos .NET Framework e ASP.NET.

A configuração no .NET Core é baseada em pares de chave/valor estabelecidos pelos provedores de configuração. Os provedores de configuração leem dados de configuração em pares de chave/valor de uma variedade de fontes de configuração, incluindo argumentos de linha de comando, arquivos de diretório, variáveis de ambiente e arquivos de configurações.

**nota**  
Para obter mais informações, consulte [Configuração no ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration).

Para facilitar o uso do AWS SDK para .NET com o.NET Core, você pode usar as [AWSSDK.Extensions. NETCore NuGet .Pacote de configuração](https://www.nuget.org/packages/AWSSDK.Extensions.NETCore.Setup/). Como muitas bibliotecas.NET Core, ela adiciona métodos de extensão à `IConfiguration` interface para facilitar a obtenção da AWS configuração.

O código-fonte desse pacote está GitHub em[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).

## Usando AWSSDK .Extensions. NETCore.Configuração
<a name="net-core-configuration-builder"></a>

Suponha que você crie um aplicativo ASP.NET Core Model-View-Controller (MVC), o que pode ser feito com o modelo de **aplicativo Web ASP.NET Core** no Visual Studio ou executando na `dotnet new mvc ...` CLI do.NET Core. Quando você cria tal aplicativo, o construtor do `Startup.cs` lida com a configuração lendo várias fontes de entrada de provedores de configuração, como o `appsettings.json`.

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

Para usar o `Configuration` objeto para obter as *AWS*opções, primeiro adicione o `AWSSDK.Extensions.NETCore.Setup` NuGet pacote. Em seguida, adicione as opções ao arquivo de configuração, conforme descrito a seguir.

Observe que um dos arquivos adicionados ao seu projeto é `appsettings.Development.json`. Isso corresponde a um `EnvironmentName` definido como **Desenvolvimento**. Durante o desenvolvimento, você coloca sua configuração nesse arquivo, que só é lido durante o teste local. Quando você implanta uma instância do Amazon EC2 que foi `EnvironmentName` configurada como **Produção**, esse arquivo é ignorado e volta para as AWS SDK para .NET credenciais e a região do IAM que estão configuradas para a instância do Amazon EC2.

As definições de configuração a seguir mostram exemplos dos valores que você pode incluir no arquivo `appsettings.Development.json` em seu projeto para fornecer as configurações da AWS .

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

Para acessar uma configuração em um arquivo *CSHTML*, use a diretiva `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>
```

Para acessar as AWS opções definidas no arquivo a partir do código, chame o método de `GetAWSOptions` extensão adicionado `IConfiguration` a.

Para construir um cliente de serviço a partir dessas opções, chame `CreateServiceClient`. O código de exemplo a seguir mostra como criar um cliente de serviço do Amazon S3. (Certifique-se de adicionar o [AWSSDK NuGet pacote.S3](https://www.nuget.org/packages/AWSSDK.S3) ao seu projeto.)

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

Também é possível criar vários clientes de serviço com configurações incompatíveis ao usar várias entradas no arquivo `appsettings.Development.json`, conforme mostrado nos exemplos a seguir, em que a configuração de `service1` inclui a região `us-west-2` e a configuração de `service2` inclui o *URL* do endpoint especial.

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

Depois, você pode obter as opções para um serviço específico usando a entrada no arquivo JSON. Por exemplo, para obter as configurações para `service1`, use o seguinte.

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

### Valores permitidos no arquivo appsettings
<a name="net-core-appsettings-values"></a>

Os valores de configuração do aplicativo a seguir podem ser definidos no arquivo `appsettings.Development.json`. Os nomes de campo devem usar a capitalização mostrada. Para obter mais detalhes sobre essas configurações, consulte a classe `[AWS.Runtime.ClientConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Runtime/TClientConfig.html)`.
+ Região
+ Perfil
+ ProfilesLocation
+ SignatureVersion
+ RegionEndpoint
+ UseHttp
+ ServiceURL
+ AuthenticationRegion
+ AuthenticationServiceName
+ MaxErrorRetry
+ LogResponse
+ BufferSize
+ ProgressUpdateInterval
+ ResignRetries
+ AllowAutoRedirect
+ LogMetrics
+ DisableLogging
+ UseDualstackEndpoint

## Injeção de dependência no núcleo do ASP.NET
<a name="net-core-dependency-injection"></a>

As *AWSSDKextensões. NETCoreO NuGet pacote.Setup* também se integra a um novo sistema de injeção de dependência no ASP.NET Core. O método `ConfigureServices` na classe `Startup` do seu aplicativo é o local onde os serviços MVC são adicionados. Se o aplicativo usa a Estrutura de entidade, também é aqui que ela é inicializada.

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

**nota**  
O histórico sobre a injeção de dependência no .NET Core está disponível no [site de documentação do .NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection).

O `AWSSDK.Extensions.NETCore.Setup` NuGet pacote adiciona novos métodos de extensão `IServiceCollection` que você pode usar para adicionar AWS serviços à injeção de dependência. O código a seguir mostra como adicionar as AWS opções que são lidas `IConfiguration` para adicionar o Amazon S3 e o DynamoDB à lista de serviços. (Certifique-se de adicionar os DBv2 NuGet pacotes [AWSSDK.S3](https://www.nuget.org/packages/AWSSDK.S3) e [AWSSDK.Dynamo ao seu projeto](https://www.nuget.org/packages/AWSSDK.DynamoDBv2).)

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

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

Agora, se os controladores MVC usam `IAmazonS3` ou `IAmazonDynamoDB` como parâmetros em seus construtores, o sistema de injeção de dependência passa nesses serviços.

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

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

    ...

}
```

# Configuração de outros parâmetros do aplicativo
<a name="net-dg-config-other"></a>

**nota**  
As informações neste tópico são específicas para projetos baseados no .NET Framework. Os arquivos `App.config` e `Web.config` não estão presentes por padrão em projetos baseados no .NET Core.

## Abra para ver o conteúdo do .NET Framework
<a name="w2aab9c31b9b5b1"></a>

Há diversos parâmetros do aplicativo que você pode configurar:
+  `AWSLogging` 
+  `AWSLogMetrics` 
+  `AWSRegion` 
+  `AWSResponseLogging` 
+  `AWS.DynamoDBContext.TableNamePrefix` 
+  `AWS.S3.UseSignatureVersion4` 
+  `AWSEndpointDefinition` 
+  [AWS Endpoints gerados por serviços](#config-setting-service-generated-awsendpointdefinition) 

Esses parâmetros podem ser configurados no arquivo `App.config` ou `Web.config` do aplicativo. Embora você também possa configurá-los com a AWS SDK para .NET API, recomendamos que você use o `.config` arquivo do aplicativo. Ambas as abordagens são descritas aqui.

Para obter mais informações sobre o uso do elemento `<aws>` conforme descrito posteriormente neste tópico, consulte [Referência de arquivos de configuração para o AWS SDK para .NET](net-dg-config-ref.md).

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

Configura a forma como o SDK registra os eventos, caso registre. Por exemplo, a abordagem recomendada é usar o elemento `<logging>`, que é um elemento filho do elemento `<aws>`:

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

Alternativa:

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

Os valores possíveis são:

** `None` **  
Desative o registro de eventos do . Esse é o padrão.

** `log4net` **  
Registre usando o log4net.

** `SystemDiagnostics` **  
Registre usando a classe `System.Diagnostics`.

Defina diversos valores para o atributo `logTo`, separado por vírgulas. O exemplo a seguir define ambos os registros `log4net` e `System.Diagnostics` no arquivo `.config`:

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

Alternativa:

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

[Como alternativa, usando a AWS SDK para .NET API, combine os valores da [LoggingOptions](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TLoggingOptions.html)enumeração e defina a AWSConfigs propriedade .Logging:](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)

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

As alterações nessa configuração entram em vigor somente para novas instâncias AWS do cliente.

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

Especifica se o SDK deve ou não registrar as métricas de desempenho. Para definir a configuração do registro das métricas no arquivo `.config`, defina o valor do atributo `logMetrics` no elemento `<logging>`, que é um elemento filho do elemento `<aws>`:

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

Como alternativa, defina a chave `AWSLogMetrics` na seção`<appSettings>`:

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

Como alternativa, para definir o registro de métricas com a AWS SDK para .NET API, defina [AWSConfigso. LogMetrics](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriedade:

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

Essa definição configura propriedade padrão `LogMetrics` para todos os clientes/configurações. As alterações nessa configuração entram em vigor somente para novas instâncias AWS do cliente.

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

Configura a AWS região padrão para clientes que não especificaram explicitamente uma região. Para definir a região no arquivo `.config`, a abordagem recomendada é definir o valor do atributo `region` no elemento `aws`:

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

Como alternativa, defina a chave *AWSRegion* na seção`<appSettings>`:

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

Como alternativa, para definir a região com a AWS SDK para .NET API, defina [AWSConfigso. AWSRegion](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriedade:

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

Para obter mais informações sobre como criar um AWS cliente para uma região específica, consulte [Seleção de AWS região](net-dg-region-selection.md). As alterações nessa configuração entram em vigor somente para novas instâncias AWS do cliente.

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

Configura quando o SDK deve registrar respostas de serviços. Os valores possíveis são:

** `Never` **  
Nunca registrar as respostas de serviços. Esse é o padrão.

** `Always` **  
Sempre registrar as respostas de serviços.

** `OnError` **  
Somente registrar as respostas de serviços quando ocorrer um erro.

Para definir a configuração do registro de serviços no arquivo `.config`, a abordagem recomendada é definir o valor do atributo `logResponses` no elemento `<logging>`, que é um elemento filho do elemento `<aws>`:

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

Como alternativa, defina a chave de *AWSResponseregistro* na `<appSettings>` seção:

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

Como alternativa, para definir o registro de serviços com a AWS SDK para .NET API, defina [AWSConfigso. ResponseLogging](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriedade de um dos valores da [ResponseLoggingOption](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TResponseLoggingOption.html)enumeração:

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

As alterações desta configuração entram em vigor imediatamente.

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

Configura a `TableNamePrefix` padrão que o `DynamoDBContext` usará, se não for configurada manualmente.

Para definir o prefixo do nome da tabela no arquivo `.config`, a abordagem recomendada é definir o valor do atributo `tableNamePrefix` no elemento `<dynamoDBContext>`, que é um elemento filho do elemento `<dynamoDB>`, que por sua vez é um elemento filho do elemento `<aws>`:

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

Como alternativa, defina a chave `AWS.DynamoDBContext.TableNamePrefix` na seção`<appSettings>`:

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

Como alternativa, para definir o prefixo do nome da tabela com a AWS SDK para .NET API, defina a propriedade [AWSConfigsDBContextTableNamePrefix.Dynamo](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html):

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

As alterações desta configuração serão implementadas somente em instâncias recentemente criadas do `DynamoDBContextConfig` e `DynamoDBContext`.

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

Configura se o cliente do Amazon S3 deve ou não usar a assinatura do Signature versão 4 com as solicitações.

Para definir a assinatura da versão 4 para o Amazon S3 no arquivo `.config`, a abordagem recomendada é definir o valor do atributo `useSignatureVersion4` do elemento `<s3>`, que é um elemento filho do elemento `<aws>`:

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

Como alternativa, defina a chave `AWS.S3.UseSignatureVersion4` como `true` na seção `<appSettings>`:

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

Como alternativa, para definir a assinatura da versão 4 com a AWS SDK para .NET API, defina a propriedade [AWSConfigs.S3 UseSignatureVersion 4](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html) como: `true`

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

Por padrão, esta configuração é `false`, mas o Signature versão 4 pode ser usado como padrão em alguns casos ou em algumas regiões. Quando a configuração é `true`, o Signature versão 4 será usada em todas as solicitações. As alterações desta configuração entram em vigor somente para novas instâncias de cliente do Amazon S3.

### AWSEndpointDefinição
<a name="config-setting-awsendpointdefinition"></a>

Configura se o SDK deve ou não usar um arquivo de configuração personalizado que define as regiões e os endpoints.

Para definir o arquivo de definição do endpoint no arquivo `.config`, recomendamos definir o valor do atributo `endpointDefinition` no elemento `<aws>`.

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

Como alternativa, você pode definir a chave de *AWSEndpointdefinição* na `<appSettings>` seção:

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

[Como alternativa, para definir o arquivo de definição do endpoint com a AWS SDK para .NET API, defina o. AWSConfigs EndpointDefinition](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html)propriedade:

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

Se nenhum nome de arquivo for fornecido, não será usado um arquivo de configuração personalizado. As alterações nessa configuração entram em vigor somente para novas instâncias AWS do cliente. O arquivo endpoint.json está disponível em [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 Endpoints gerados por serviços
<a name="config-setting-service-generated-awsendpointdefinition"></a>

Alguns AWS serviços geram seus próprios endpoints em vez de consumir um endpoint regional. Os clientes desses serviços consomem um URL de serviço específico ao serviço e aos recursos. Dois exemplos desses serviços são Amazon CloudSearch AWS IoT e. Os exemplos a seguir mostram como obter os endpoints para esses serviços.

#### Exemplo de CloudSearch endpoints da Amazon
<a name="cs-endpoints-example"></a>

O CloudSearch cliente da Amazon é usado para acessar o serviço de CloudSearch configuração da Amazon. Você usa o serviço CloudSearch de configuração da Amazon para criar, configurar e gerenciar domínios de pesquisa. Para criar um domínio de pesquisa, crie um [CreateDomainRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCreateDomainRequest.html)objeto e forneça a `DomainName` propriedade. Crie um [AmazonCloudSearchClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCloudSearchClient.html)objeto usando o objeto de solicitação. Chame o método [CreateDomain](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/MCloudSearchCreateDomainCreateDomainRequest.html). O [CreateDomainResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearch/TCreateDomainResponse.html)objeto retornado da chamada contém uma `DomainStatus` propriedade que tem os `SearchService` pontos finais `DocService` e. Crie um [AmazonCloudSearchDomainConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudSearchDomain/TCloudSearchDomainConfig.html)objeto e use-o para inicializar `DocService` as `SearchService` instâncias da [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 Exemplo de endpoints
<a name="iotlong-endpoints-example"></a>

Para obter o endpoint para AWS IoT, crie um [AmazonIoTClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/TIoTClient.html)objeto e chame o [DescribeEndPoint](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/MIoTDescribeEndpointDescribeEndpointRequest.html)método. O [DescribeEndPointResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IoT/TDescribeEndpointResponse.html)objeto retornado contém `EndpointAddress` o. Crie um [AmazonIotDataConfig](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/IotData/TIotDataConfig.html)objeto, defina a `ServiceURL` propriedade e use o objeto para instanciar a [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");
}
```

# Referência dos arquivos de configuração para o AWS SDK para .NET
<a name="net-dg-config-ref"></a>

**nota**  
As informações neste tópico são específicas para projetos baseados no .NET Framework. Os arquivos `App.config` e `Web.config` não estão presentes por padrão em projetos baseados no .NET Core.

## Abra para ver o conteúdo do .NET Framework
<a name="w2aab9c31c11b5b1"></a>

Use um arquivo `App.config` ou `Web.config` de projeto .NET para especificar as configurações da AWS, como credenciais da AWS, opções de registro em log, endpoints de serviço da AWS e regiões da AWS, bem como algumas configurações dos serviços da AWS, como Amazon DynamoDB, Amazon EC2 e Amazon S3. As informações a seguir descrevem como formatar de forma apropriada um arquivo `App.config` ou `Web.config` para especificar esses tipos de configurações.

**nota**  
Embora seja possível continuar a usar o elemento `<appSettings>` em um arquivo `App.config` ou `Web.config` para especificar as configurações da AWS, recomendamos o uso dos elementos `<configSections>` e `<aws>` conforme descrito posteriormente neste tópico. Para obter mais informações sobre o elemento `<appSettings>`, consulte os exemplos do elemento `<appSettings>` em [Configuração do seu aplicativo AWS SDK para .NET](net-dg-config.md).

**nota**  
Embora seja possível continuar a usar as propriedades a seguir da classe [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Amazon/TAWSConfigs.html) em um arquivo de código para especificar as configurações da AWS, estas propriedades são obsoletas e podem não comportar versões futuras:  
 `DynamoDBContextTableNamePrefix` 
 `EC2UseSignatureVersion4` 
 `LoggingOptions` 
 `LogMetrics` 
 `ResponseLoggingOption` 
 `S3UseSignatureVersion4` 
Geralmente, recomendamos que em vez de usar as propriedades da classe `AWSConfigs` em um arquivo de código para especificar as configurações da AWS, use os elementos `<configSections>` e `<aws>` em um arquivo `App.config` ou `Web.config` para especificar as configurações da AWS, conforme descrito posteriormente neste tópico. Para obter mais informações sobre as propriedades anteriores, consulte os exemplos de códigos da `AWSConfigs` em [Configuração do seu aplicativo AWS SDK para .NET](net-dg-config.md).

**Topics**
+ [

### Declarar uma seção de configurações da AWS
](#net-dg-config-ref-declaring)
+ [

### Elementos permitidos
](#net-dg-config-ref-elements)
+ [

### Referência dos elementos
](#net-dg-config-ref-elements-ref)

### Declarar uma seção de configurações da AWS
<a name="net-dg-config-ref-declaring"></a>

Especifique as configurações da AWS em um arquivo `App.config` ou `Web.config` a partir do elemento `<aws>`. Antes de começar a usar o elemento `<aws>`, é necessário criar um elemento `<section>` (que é um elemento filho do elemento `<configSections>`) e definir o seu atributo `name` como `aws` e o atributo `type` como `Amazon.AWSSection, AWSSDK.Core`, conforme mostrado no seguinte exemplo:

```
<?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>
```

O editor do Visual Studio não oferece a conclusão de código automática (IntelliSense) para o elemento `<aws>` ou para os seus elementos filho.

Para auxiliá-lo na criação de uma versão corretamente formatada `<aws>`, chame o método `Amazon.AWSConfigs.GenerateConfigTemplate`. Isso gera como saída uma versão canônica do elemento `<aws>` como uma string formatada, que pode ser adaptada para as suas necessidades. As seções a seguir descrevem os atributos e os elementos filho do elemento `<aws>`.

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

A seguir encontra-se uma lista das relações lógicas entre os elementos permitidos em uma seção de configurações da AWS. Gere a versão mais recente dessa lista chamando o método `Amazon.AWSConfigs.GenerateConfigTemplate`, que gera como saída uma versão canônica do elemento `<aws>` como uma string que pode ser adaptada para as suas necessidades.

```
<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>
```

### Referência dos elementos
<a name="net-dg-config-ref-elements-ref"></a>

A seguir encontra-se uma lista dos elementos permitidos em uma seção de configurações da AWS. Para cada elemento, são listados os atributos permitidos e os elementos filho.

**Topics**
+ [

#### alias
](#net-dg-config-ref-elements-alias)
+ [

#### `aws`
](#net-dg-config-ref-elements-aws)
+ [

#### dynamoDB
](#net-dg-config-ref-elements-dynamodb)
+ [

#### dynamoDBContext
](#net-dg-config-ref-elements-ddbcontext)
+ [

#### ec2
](#net-dg-config-ref-elements-ec2)
+ [

#### registro em log
](#net-dg-config-ref-elements-logging)
+ [

#### mapear
](#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>

O elemento `<alias>` representa um único item em um conjunto de um ou mais mapeamentos from-table até to-table, que especifica uma tabela diferente daquela configurada para um tipo. Esse elemento é mapeado para uma instância da classe `Amazon.Util.TableAlias` da propriedade `Amazon.AWSConfigs.DynamoDBConfig.Context.TableAliases` no AWS SDK para .NET. O remapeamento é feito antes de aplicar um prefixo de nome da tabela.

Esse elemento pode incluir os seguintes atributos:

** `fromTable` **  
A parte from-table do mapeamento from-table até to-table. Esse atributo é mapeado para a propriedade `Amazon.Util.TableAlias.FromTable` no AWS SDK para .NET.

** `toTable` **  
A parte to-table do mapeamento from-table até to-table. Esse atributo é mapeado para a propriedade `Amazon.Util.TableAlias.ToTable` no AWS SDK para .NET.

O pai do elemento `<alias>` é o elemento `<tableAliases>`.

O elemento `<alias>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<alias>` em uso:

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

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

O elemento `<aws>` representa o elemento mais superior em uma seção de configurações da AWS. Esse elemento pode incluir os seguintes atributos:

** `endpointDefinition` **  
O caminho absoluto para um arquivo de configuração personalizado que define as regiões e endpoints da AWS para o uso. Esse atributo é mapeado para a propriedade `Amazon.AWSConfigs.EndpointDefinition` no AWS SDK para .NET.

** `profileName` **  
O nome do perfil para as credenciais da AWS armazenadas que serão utilizadas para realizar chamadas de serviços. Esse atributo é mapeado para a propriedade `Amazon.AWSConfigs.AWSProfileName` no AWS SDK para .NET.

** `profilesLocation` **  
O caminho absoluto do local do arquivo de credenciais compartilhado com outros SDKs da AWS. Por padrão, o arquivo de credenciais está armazenado no diretório `.aws` no diretório base do usuário atual. Esse atributo é mapeado para a propriedade `Amazon.AWSConfigs.AWSProfilesLocation` no AWS SDK para .NET.

** `region` **  
O ID da região da AWS padrão para clientes que não especificaram explicitamente uma região. Esse atributo é mapeado para a propriedade `Amazon.AWSConfigs.AWSRegion` no AWS SDK para .NET.

O elemento `<aws>` não possui elemento pai.

O elemento `<aws>` pode incluir os seguintes elementos filho:
+  `<dynamoDB>` 
+  `<ec2>` 
+  `<logging>` 
+  `<proxy>` 
+  `<s3>` 

Veja a seguir um exemplo do elemento `<aws>` em uso:

```
<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>

O elemento `<dynamoDB>` representa um conjunto de configurações do Amazon DynamoDB. Este elemento pode incluir o atributo *conversionSchema*, que representa a versão a ser usada para conversão entre objetos .NET e DynamoDB. Os valores permitidos incluem V1 e V2. Esse atributo é mapeado para a classe `Amazon.DynamoDBv2.DynamoDBEntryConversion` no AWS SDK para .NET. Para obter mais informações, consulte [Série DynamoDB – esquemas de conversão](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas).

O pai do elemento `<dynamoDB>` é o elemento `<aws>`.

O elemento `<dynamoDB>` pode incluir o elemento filho `<dynamoDBContext>`.

Veja a seguir um exemplo do elemento `<dynamoDB>` em uso:

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

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

O elemento `<dynamoDBContext>` representa um conjunto de configurações específicas de contexto do Amazon DynamoDB. Este elemento pode incluir o atributo *tableNamePrefix*, que representa o prefixo do nome da tabela padrão que o contexto do DynamoDB usará se não for configurado manualmente. Esse atributo é mapeado para a propriedade `Amazon.Util.DynamoDBContextConfig.TableNamePrefix` da propriedade `Amazon.AWSConfigs.DynamoDBConfig.Context.TableNamePrefix` no AWS SDK para .NET. Para obter mais informações, consulte [Aprimoramentos do DynamoDB SDK](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK).

O pai do elemento `<dynamoDBContext>` é o elemento `<dynamoDB>`.

O elemento `<dynamoDBContext>` pode incluir os seguintes elementos filho:
+  `<alias>` (uma ou mais instâncias)
+  `<map>` (uma ou mais instâncias)

Veja a seguir um exemplo do elemento `<dynamoDBContext>` em uso:

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

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

O elemento `<ec2>` representa um conjunto de configurações do Amazon EC2. Este elemento pode incluir o atributo *useSignatureVersion4*, que especifica se a assinatura do Signature Version4 será usada para todas as solicitações (verdadeiro) ou se ela não será usada para todas as solicitações (falso, o padrão). Esse atributo é mapeado para a propriedade `Amazon.Util.EC2Config.UseSignatureVersion4` da propriedade `Amazon.AWSConfigs.EC2Config.UseSignatureVersion4` no AWS SDK para .NET.

O pai do elemento `<ec2>` é o elemento.

O elemento `<ec2>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<ec2>` em uso:

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

#### registro em log
<a name="net-dg-config-ref-elements-logging"></a>

O elemento `<logging>` representa um conjunto de configurações para o registro de respostas e de métricas de desempenho. Esse elemento pode incluir os seguintes atributos:

** `logMetrics` **  
Se as métricas de desempenho serão registradas para todos os clientes e configurações (verdadeiro); caso contrário, falso. Esse atributo é mapeado para a propriedade `Amazon.Util.LoggingConfig.LogMetrics` da propriedade `Amazon.AWSConfigs.LoggingConfig.LogMetrics` no AWS SDK para .NET.

** `logMetricsCustomFormatter` **  
O tipo de dados e o nome do conjunto de um formatador personalizado para as métricas de registro. Esse atributo é mapeado para a propriedade `Amazon.Util.LoggingConfig.LogMetricsCustomFormatter` da propriedade `Amazon.AWSConfigs.LoggingConfig.LogMetricsCustomFormatter` no AWS SDK para .NET.

** `logMetricsFormat` **  
O formato em que as métricas de registro são apresentadas (é mapeado para a propriedade `Amazon.Util.LoggingConfig.LogMetricsFormat` da propriedade `Amazon.AWSConfigs.LoggingConfig.LogMetricsFormat` no AWS SDK para .NET).  
Os valores permitidos incluem:    
** `JSON` **  
Use o formato JSON.  
** `Standard` **  
Use o formato padrão.

** `logResponses` **  
Quando registrar as respostas de serviços (é mapeado para a propriedade `Amazon.Util.LoggingConfig.LogResponses` da propriedade `Amazon.AWSConfigs.LoggingConfig.LogResponses` no AWS SDK para .NET).  
Os valores permitidos incluem:    
** `Always` **  
Sempre registrar as respostas de serviços.  
** `Never` **  
Nunca registrar as respostas de serviços.  
** `OnError` **  
Somente registrar as respostas de serviços quando existirem erros.

** `logTo` **  
Onde registrar (é mapeado para a propriedade `LogTo` a partir da propriedade `Amazon.AWSConfigs.LoggingConfig.LogTo` no AWS SDK para .NET).  
Os valores permitidos incluem um ou mais entre:    
** `Log4Net` **  
Registrar no log4net.  
** `None` **  
Desativar o registro.  
** `SystemDiagnostics` **  
Registrar no System.Diagnostics.

O pai do elemento `<logging>` é o elemento `<aws>`.

O elemento `<logging>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<logging>` em uso:

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

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

O elemento `<map>` representa um único item em um conjunto de mapeamentos type-to-table de tipos .NET para tabelas do DynamoDB (é mapeado para uma instância da classe `TypeMapping` da propriedade `Amazon.AWSConfigs.DynamoDBConfig.Context.TypeMappings` no AWS SDK para .NET). Para obter mais informações, consulte [Aprimoramentos do DynamoDB SDK](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK).

Esse elemento pode incluir os seguintes atributos:

** `targetTable` **  
A tabela do DynamoDB a qual o mapeamento se aplica. Esse atributo é mapeado para a propriedade `Amazon.Util.TypeMapping.TargetTable` no AWS SDK para .NET.

** `type` **  
O tipo e o nome do conjunto ao qual o mapeamento se aplica. Esse atributo é mapeado para a propriedade `Amazon.Util.TypeMapping.Type` no AWS SDK para .NET.

O pai do elemento `<map>` é o elemento `<dynamoDBContext>`.

O elemento `<map>` pode incluir uma ou mais instâncias do elemento filho `<property>`.

Veja a seguir um exemplo do elemento `<map>` em uso:

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

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

O elemento `<property>` representa uma propriedade do DynamoDB. (Este elemento é mapeado para uma instância da classe Amazon.Util.PropertyConfig do método `AddProperty` no AWS SDK para .NET) Para obter mais informações, consulte [Aprimoramentos do DynamoDB SDK](http://blogs.aws.amazon.com/net/post/Tx2C4MHH2H0SA5W/Enhancements-to-the-DynamoDB-SDK) e [Atributos do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DeclarativeTagsList.html).

Esse elemento pode incluir os seguintes atributos:

** `attribute` **  
O nome de um atributo da propriedade, como o nome de uma chave de intervalo. Esse atributo é mapeado para a propriedade `Amazon.Util.PropertyConfig.Attribute` no AWS SDK para .NET.

** `converter` **  
O tipo de conversor que deve ser usado para esta propriedade. Esse atributo é mapeado para a propriedade `Amazon.Util.PropertyConfig.Converter` no AWS SDK para .NET.

** `ignore` **  
Se a propriedade associada deve ser ignorada (verdadeiro); caso contrário, falso. Esse atributo é mapeado para a propriedade `Amazon.Util.PropertyConfig.Ignore` no AWS SDK para .NET.

** `name` **  
O nome da propriedade. Esse atributo é mapeado para a propriedade `Amazon.Util.PropertyConfig.Name` no AWS SDK para .NET.

** `version` **  
Se essa propriedade deve armazenar o número da versão do item (verdadeiro); caso contrário, falso. Esse atributo é mapeado para a propriedade `Amazon.Util.PropertyConfig.Version` no AWS SDK para .NET.

O pai do elemento `<property>` é o elemento `<map>`.

O elemento `<property>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<property>` em uso:

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

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

O elemento `<proxy>` representa as configurações necessárias de um proxy para o seu uso pelo AWS SDK para .NET. Esse elemento pode incluir os seguintes atributos:

**host**  
O nome do host ou endereço IP do servidor de proxy. Esses atributos são mapeados para a propriedade `Amazon.Util.ProxyConfig.Host` da propriedade `Amazon.AWSConfigs.ProxyConfig.Host` no AWS SDK para .NET.

**password**  
A senha para a autenticação com o servidor de proxy. Esses atributos são mapeados para a propriedade `Amazon.Util.ProxyConfig.Password` da propriedade `Amazon.AWSConfigs.ProxyConfig.Password` no AWS SDK para .NET.

**porta**  
O número da porta do proxy. Esses atributos são mapeados para a propriedade `Amazon.Util.ProxyConfig.Port` da propriedade `Amazon.AWSConfigs.ProxyConfig.Port` no AWS SDK para .NET.

**username**  
O nome de usuário para a autenticação com o servidor de proxy. Esses atributos são mapeados para a propriedade `Amazon.Util.ProxyConfig.Username` da propriedade `Amazon.AWSConfigs.ProxyConfig.Username` no AWS SDK para .NET.

O pai do elemento `<proxy>` é o elemento `<aws>`.

O elemento `<proxy>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<proxy>` em uso:

```
<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>

O elemento `<s3>` representa um conjunto de configurações do Amazon S3. Este elemento pode incluir o atributo *useSignatureVersion4*, que especifica se a assinatura do Signature Version4 será usada para todas as solicitações (verdadeiro) ou se ela não será usada para todas as solicitações (falso, o padrão). Esse atributo é mapeado para a propriedade `Amazon.AWSConfigs.S3Config.UseSignatureVersion4` no AWS SDK para .NET.

O pai do elemento `<s3>` é o elemento `<aws>`.

O elemento `<s3>` não contém elementos filho.

Veja a seguir um exemplo do elemento `<s3>` em uso:

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