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á.

# Usando AWSSDK .Extensions. NETCore.Configuração e interface IConfiguration
AWSSDK.Extensões. NETCore.Configuração e IConfiguration

(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


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


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


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

    ...

}
```