

O SDK AWS móvel para Xamarin agora está incluído no. AWS SDK para .NET Este guia faz referência à versão arquivada do Mobile SDK para Xamarin.

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

# Configurar o AWS Mobile SDK para .NET e Xamarin
<a name="setup"></a>

Você pode configurar o AWS Mobile SDK para .NET e Xamarin e começar a criar um novo projeto ou integrar o SDK a um projeto existente. Você também pode clonar e executar os [exemplos](https://github.com/awslabs/aws-sdk-net-samples/tree/master/XamarinSamples) para ter uma ideia de como funciona o SDK. Siga estas etapas para configurar e começar a usar o AWS Mobile SDK para .NET e Xamarin.

## Pré-requisitos
<a name="prerequisites"></a>

Antes de usar o AWS Mobile SDK para .NET e Xamarin, você precisa fazer o seguinte:
+ Crie uma [conta da AWS](https://aws.amazon.com/).
+ Instale o [Xamarin](https://docs.microsoft.com/en-us/xamarin/get-started/installation/?pivots=windows).

Após concluir os pré-requisitos:

1. Obtenha credenciais da AWS usando o Amazon Cognito.

1. Defina as permissões necessárias para cada serviço da AWS usado no aplicativo.

1. Crie um novo projeto no IDE.

1. Instale o AWS Mobile SDK para .NET e Xamarin.

1. Configure o AWS Mobile SDK para .NET e Xamarin.

## Etapa 1: Obter as credenciais da AWS
<a name="step-1-obtain-aws-credentials"></a>

Para fazer chamadas para a AWS no aplicativo, primeiro obtenha as credenciais da AWS. Faça isso usando o Amazon Cognito, um serviço da AWS que permite que o aplicativo acesse os serviços do SDK sem precisar incorporar as credenciais privadas da AWS ao aplicativo.

Para começar a usar o Amazon Cognito, é necessário criar um banco de identidades. Um grupo de identidades é um armazenamento de informações específico da sua conta e identificado por um ID de grupo de identidades com a seguinte aparência:

```
"us-east-1:00000000-0000-0000-0000-000000000000"
```

1. Inicie a sessão no [console do Amazon Cognito](https://console.aws.amazon.com/cognito/home), selecione **Manage Federated Identities (Gerenciar identidades federadas)** e selecione **Create new identity pool (Criar grupo de identidades)**.

1. Insira um nome para o grupo de identidades e marque a caixa de seleção para habilitar o acesso a identidades não autenticadas. Selecione **Create Pool (Criar grupo)** para criar o grupo de identidades.

1. Selecione **Allow (Permitir)** para criar as duas funções padrão associadas ao grupo de identidades, uma para usuários não autenticados e outra para usuários autenticados. Esses perfis padrão oferecem ao banco de identidades acesso à sincronização do Amazon Cognito e ao Amazon Mobile Analytics.

Normalmente, você só usa um grupo de identidades por aplicativo.

Após criar o grupo de identidades, você obterá as credenciais da AWS criando um objeto `CognitoAWSCredentials` (inserindo o ID do grupo de identidades) e inserindo-o no construtor de um cliente da AWS, da seguinte forma:

```
CognitoAWSCredentials credentials = new CognitoAWSCredentials (
    "us-east-1:00000000-0000-0000-0000-000000000000", // Your identity pool ID
    RegionEndpoint.USEast1 // Region
);

// Example for |MA|
analyticsManager = MobileAnalyticsManager.GetOrCreateInstance(
  credentials,
  RegionEndpoint.USEast1, // Region
  APP_ID // app id
);
```

## Etapa 2: Definir permissões
<a name="step-2-set-permissions"></a>

Defina permissões para cada serviço da AWS a ser usado no aplicativo. Primeiro, você precisa entender como a AWS visualiza os usuários do aplicativo.

Quando alguém usa o aplicativo e faz chamadas para a AWS, ela atribui uma identidade a esse usuário. O grupo de identidades criado na Etapa 1 é o local onde a AWS armazena essas identidades. Existem dois tipos de identidades: autenticados e não autenticados. As identidades autenticadas pertencem a usuários que serão autenticados por meio de um provedor de login público (por exemplo, Facebook, Amazon, Google). As identidades não autenticadas pertencem a usuários convidados.

Cada identidade está associada a uma AWS Identity and Access Management função. Na Etapa 1, você criou dois perfis do IAM, um para usuários autenticados e outro para usuários não autenticados. Cada perfil do IAM tem uma ou mais políticas anexadas a ele que especificam quais serviços da AWS as identidades atribuídas a esse perfil podem acessar. Por exemplo, a política de exemplo a seguir concede acesso a um bucket do Amazon S3:

```
{
  "Statement": [
    {
      "Action": [
        "s3:AbortMultipartUpload",
        "s3:DeleteObject",
        "s3:GetObject",
        "s3:PutObject"
      ],
      "Effect": "Allow",
      "Resource": "arn:aws:s3:::MYBUCKETNAME/*",
      "Principal": "*"
    }
  ]
}
```

Para definir permissões para os serviços da AWS que você deseja usar no aplicativo, modifique a política anexada aos perfis.

1. Acesse o [console do IAM e selecione Roles (Funções)](https://console.aws.amazon.com/iam/home). Digite o nome do grupo de identidades na caixa de pesquisa. Escolha o perfil do IAM que você deseja configurar. Se o aplicativo permitir usuários autenticados e não autenticados, você precisará conceder permissões para ambas as funções.

1. Clique em **Attach Policy (Associar política)**, selecione a política desejada e clique em **Attach Policy (Associar política)**. As políticas padrão dos perfis do IAM que você criou fornecem acesso ao Amazon Cognito e ao Mobile Analytics.

Para obter mais informações sobre como criar políticas ou escolher um item em uma lista de políticas, consulte [Políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html).

## Etapa 3: Criar um novo projeto da
<a name="step-3-create-a-new-project"></a>

### Windows
<a name="windows"></a>

Você pode usar o Visual Studio para desenvolver seu aplicativo.

### OS X
<a name="os-x"></a>

Você pode usar o Visual Studio para desenvolver aplicativos. O desenvolvimento para iOS usando o Xamarin requer acesso a um Mac para executar o aplicativo. Para obter mais informações, consulte [Como instalar o Xamarin.iOS no Windows](https://docs.microsoft.com/en-us/xamarin/ios/get-started/installation/windows/?pivots=windows).

**nota**  
O IDE [Rider](https://www.jetbrains.com/help/rider/Xamarin.html) comercial multiplataforma da JetBrains inclui suporte ao Xamarin nas plataformas Windows e Mac.

## Etapa 4: Instalar o AWS Mobile SDK para .NET e Xamarin
<a name="step-4-install-the-sdk-xamarin"></a>

### Windows
<a name="id1"></a>

#### Opção 1: Instalar usando o console do Package Manager
<a name="option-1-install-by-using-the-package-manager-console"></a>

O AWS Mobile SDK para .NET e Xamarin consiste em um conjunto de assemblies .NET. Para instalar o AWS Mobile SDK para .NET e Xamarin, execute o comando install-package para cada pacote no console do Package Manager. Por exemplo, para instalar o Cognito Identity, execute o seguinte:

```
Install-Package AWSSDK.CognitoIdentity
```

Os pacotes do AWS Core Runtime e do Amazon Cognito Identity são necessários em todos os projetos. Veja a seguir uma lista completa de nomes de pacotes para cada serviço.


****  

| Serviço | Nome do pacote | 
| --- | --- | 
|  AWS Core Runtime  |  AWSSDK.Núcleo  | 
|  Amazon Cognito Sync  |  AWSSDK.CognitoSync  | 
|  Identidade do Amazon Cognito  |  AWSSDK.CognitoIdentity  | 
|  Amazon DynamoDB  |  AWSSDK.Dínamo DBv2  | 
|  Amazon Mobile Analytics  |  AWSSDK.MobileAnalytics  | 
|  Amazon S3  |  AWSSDK.S3  | 
|  Amazon SNS  |  AWSSDK.SimpleNotificationService  | 

Para incluir um pacote de pré-lançamento, inclua o argumento de linha de comando `-Pre` durante a instalação do pacote, da seguinte forma:

```
Install-Package AWSSDK.CognitoSync -Pre
```

Você pode encontrar uma lista completa dos pacotes de serviços da AWS em Pacotes do [AWS SDK em NuGet ou no](https://www.nuget.org/packages?q=+aws-sdk-v3) [AWS SDK for GitHub](https://github.com/aws/aws-sdk-net#nuget-packages) .NET Repository.

#### Opção 2: Instalar usando o IDE
<a name="option-2-install-by-using-your-ide"></a>

 **No Visual Studio** 

1. Clique com o botão direito do mouse no projeto e, em seguida, clique em **Gerenciar NuGet pacotes**.

1. Procure o nome do pacote que você deseja adicionar ao projeto. Para incluir os NuGet pacotes de pré-lançamento, escolha **Incluir** pré-lançamento. Você pode encontrar uma lista completa dos pacotes de serviços da AWS em Pacotes do [SDK da AWS em NuGet](https://www.nuget.org/packages?q=+aws-sdk-v3).

1. Escolha o pacote e, em seguida, escolha **Install**.

### Mac (OS X)
<a name="mac-os-x"></a>

 **No Visual Studio** 

1. Clique com o botão direito do mouse na pasta de pacotes e clique em **Add Packages (Adicionar pacotes)**.

1. Procure o nome do pacote que você deseja adicionar ao projeto. Para incluir os pacotes de pré-lançamento, escolha **Mostrar NuGet pacotes de pré-lançamento**. Você pode encontrar uma lista completa dos pacotes de serviços da AWS em Pacotes do [SDK da AWS em NuGet](https://www.nuget.org/packages?q=+aws-sdk-v3).

1. Marque a caixa de seleção ao lado do pacote desejado e selecione **Add Package (Adicionar pacote)**.

**Importante**  
Se você estiver desenvolvendo usando uma Biblioteca de Classes Portátil, você também deve adicionar o AWSSDK NuGet pacote.Core a todos os projetos derivados da Biblioteca de Classes Portátil.

## Etapa 5: Configurar o AWS Mobile SDK para .NET e Xamarin
<a name="step-5-configure-the-sdk-xamarin"></a>

### Definição do registro
<a name="set-logging"></a>

Definas as configurações de registro usando as classes `Amazon.AWSConfigs` e `Amazon.Util.LoggingConfig`. Você as encontrará no assembly `AWSSdk.Core`, disponível por meio do Nuget Package Manager no Visual Studio. Insira o código das configurações de registro no método `OnCreate` do arquivo `MainActivity.cs` para aplicativos Android ou do arquivo `AppDelegate.cs` para aplicativos iOS. Você também deve adicionar as instruções `using Amazon` e `using Amazon.Util` aos arquivos .cs.

Defina as configurações de registro da seguinte maneira:

```
var loggingConfig = AWSConfigs.LoggingConfig;
loggingConfig.LogMetrics = true;
loggingConfig.LogResponses = ResponseLoggingOption.Always;
loggingConfig.LogMetricsFormat = LogMetricsFormatOption.JSON;
loggingConfig.LogTo = LoggingOptions.SystemDiagnostics;
```

Quando você faz login SystemDiagnostics, a estrutura imprime internamente a saída no System.Console. Se você deseja registrar respostas HTTP, defina o sinalizador `LogResponses`. Os valores podem ser Sempre, Nunca ou OnError.

Você também pode registrar as métricas de desempenho das solicitações HTTP usando a propriedade `LogMetrics`. O formato do log pode ser especificado através da propriedade `LogMetricsFormat`. Os valores válidos são JSON ou standard.

### Definição do endpoint da região
<a name="set-the-region-endpoint"></a>

Configure a região padrão para todos os clientes do serviço da seguinte maneira:

```
AWSConfigs.AWSRegion="us-east-1";
```

Isso define a região padrão para todos os clientes de serviços no SDK. Você pode substituir essa configuração especificando explicitamente a região no momento da criação de uma instância do cliente de serviço, da seguinte maneira:

```
IAmazonS3 s3Client = new AmazonS3Client(credentials,RegionEndpoint.USEast1);
```

### Definição das configurações de proxy HTTP
<a name="configure-the-http-proxy-settings"></a>

Se a rede estiver atrás de um proxy, você poderá definir as configurações de proxy das solicitações HTTP da seguinte maneira.

```
var proxyConfig = AWSConfigs.ProxyConfig;
proxyConfig.Host = "localhost";
proxyConfig.Port = 80;
proxyConfig.Username = "<username>";
proxyConfig.Password = "<password>";
```

### Correção da distorção do relógio
<a name="correct-for-clock-skew"></a>

Esta propriedade determina se o SDK corrigirá a distorção de relógio do cliente determinando a hora de servidor correta e emitindo novamente a solicitação com a hora correta.

```
AWSConfigs.CorrectForClockSkew = true;
```

Este campo será definido se uma chamada de serviço tiver resultado em uma exceção e o SDK tiver determinado que há uma diferença entre a hora local e a hora do servidor.

```
var offset = AWSConfigs.ClockOffset;
```

Para saber mais sobre distorção de relógio, consulte [Correção de distorção de relógio](https://blogs.aws.amazon.com/net/post/Tx2HM54KL5LMTGI/Clock-skew-correction) no Blog da AWS.

## Próximas etapas
<a name="next-steps"></a>

Agora que configurou o AWS Mobile SDK para .NET e Xamarin, você pode:
+  **Comece a usar.** Leia [Conceitos básicos do AWS Mobile SDK para .NET e Xamarin](getting-started-xamarin.md) para obter instruções de início rápido sobre como usar e configurar os serviços no AWS Mobile SDK para .NET e Xamarin.
+  **Explore os tópicos de serviço.** Saiba mais sobre cada serviço e como ele funciona no AWS Mobile SDK para .NET e Xamarin.
+  **Execute as demonstrações.** Visualize nossos [aplicativos Xamarin de exemplo](https://github.com/awslabs/aws-sdk-net-samples/tree/master/XamarinSamples) que demonstram casos de uso comuns. Para executar os aplicativos de exemplo, configure o AWS Mobile SDK para .NET e Xamarin conforme descrito anteriormente e, depois, siga as instruções contidas nos arquivos README de cada exemplo.
+  **Aprenda APIs o.** Veja o [\$1 sdk-xamarin-ref \$1\$1](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/).
+  **Faça perguntas**: publique perguntas nos [fóruns do AWS Mobile SDK](https://forums.aws.amazon.com/forum.jspa?forumID=88) ou [abra um problema no GitHub](https://github.com/awslabs/aws-sdk-xamarin/issues).