

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

# QuickStart: Implante um aplicativo.NET Core no Windows no Elastic Beanstalk
<a name="dotnet-quickstart"></a>

Este QuickStart tutorial mostra o processo de criação de um aplicativo.NET Core no Windows e sua implantação em um AWS Elastic Beanstalk ambiente.

**Não é para uso em produção**  
Os exemplos são destinados apenas para demonstração. Não use aplicações de exemplo na produção.

**Topics**
+ [Suas AWS account](#dotnet-quickstart-aws-account)
+ [Pré-requisitos](#dotnet-quickstart-prereq)
+ [Etapa 1: Criar um aplicação .NET Core no Windows](#dotnet-quickstart-create-app)
+ [Etapa 2: executar a aplicação localmente](#dotnet-quickstart-run-local)
+ [Etapa 3: implantar sua aplicação .NET Core no Windows com a EB CLI](#dotnet-quickstart-deploy)
+ [Etapa 4: executar a aplicação no Elastic Beanstalk](#dotnet-quickstart-run-eb-ap)
+ [Etapa 5: limpar](#go-tutorial-cleanup)
+ [AWS recursos para seu aplicativo](#dotnet-quickstart-eb-resources)
+ [Próximas etapas](#dotnet-quickstart-next-steps)
+ [Implantar com o console do Elastic Beanstalk](#dotnet-quickstart-console)

## Suas AWS account
<a name="dotnet-quickstart-aws-account"></a>

Se você ainda não é AWS cliente, precisa criar uma AWS conta. A inscrição permite que você acesse o Elastic Beanstalk AWS e outros serviços necessários.

Se você já tem uma AWS conta, você pode passar para[Pré-requisitos](#dotnet-quickstart-prereq).

### Crie um AWS account
<a name="dotnet-quickstart-aws-account-procedure"></a>

#### Inscreva-se para um Conta da AWS
<a name="sign-up-for-aws"></a>

Para começar AWS, você precisa de um Conta da AWS. Para obter informações sobre como criar um Conta da AWS, consulte [Introdução a um Conta da AWS](https://docs.aws.amazon.com//accounts/latest/reference/getting-started.html) no *Guia de AWS Gerenciamento de contas referência*.

## Pré-requisitos
<a name="dotnet-quickstart-prereq"></a>

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Os comandos são mostrados em lisetiquetaens precedidas por um símbolo de prompt (>) e o nome do diretório atual, quando apropriado.

```
C:\eb-project> this is a command
this is output
```

### EB CLI
<a name="dotnet-quickstart-prereq.ebcli"></a>

Este tutorial também usa a Interface de Linhas de Comando do Elastic Beanstalk (CLI do EB). Para obter detalhes sobre a instalação e configuração da CLI do EB, consulte [Instalar a EB CLI com script de configuração (recomendado)](eb-cli3.md#eb-cli3-install) e [Configurar a EB CLI](eb-cli3-configuration.md).

### .NET Core no Windows
<a name="dotnet-quickstart-prereq.runtime"></a>

Se não tiver o .NET SDK instalado na máquina local, você poderá instalá-lo seguindo o link [Baixar .NET](https://dotnet.microsoft.com/en-us/download) no site de [Documentação do .NET](https://learn.microsoft.com/en-us/dotnet/).

Verifique sua instalação do .NET SDK executando o comando a seguir.

```
C:\> dotnet --info
```

## Etapa 1: Criar um aplicação .NET Core no Windows
<a name="dotnet-quickstart-create-app"></a>

Crie um diretório do projeto.

```
C:\> mkdir eb-dotnetcore
C:\> cd eb-dotnetcore
```

Em seguida, crie um aplicação de serviço da Web RESTful Hello World de amostra executando os seguintes comandos.

```
C:\eb-dotnetcore> dotnet new web --name HelloElasticBeanstalk
C:\eb-dotnetcore> cd HelloElasticBeanstalk
```

## Etapa 2: executar a aplicação localmente
<a name="dotnet-quickstart-run-local"></a>

Execute o seguinte comando para executar sua aplicação localmente.

```
C:\eb-dotnetcore\HelloElasticBeasntalk> dotnet run
```

A saída deve ser semelhante ao texto a seguir.

```
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: https://localhost:7222
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5228
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\Administrator\eb-dotnetcore\HelloElasticBeanstalk
```

**nota**  
O comando `dotnet` seleciona uma porta aleatoriamente ao executar a aplicação localmente. Neste exemplo, a porta é 5228. Ao implantar a aplicação no ambiente Elastic Beanstalk, ela será executada na porta 5000.

Insira o endereço URL `http://localhost:{{port}}` no navegador. Para este exemplo específico, o comando é `http://localhost:5228`. O navegador deve exibir “Hello World\!”.

## Etapa 3: implantar sua aplicação .NET Core no Windows com a EB CLI
<a name="dotnet-quickstart-deploy"></a>

Execute os seguintes comandos para criar um ambiente Elastic Beanstalk para essa aplicação.

 

**Para criar um ambiente e implantar sua aplicação .NET Core no Windows**

1. Execute os seguintes comandos no diretório `HelloElasticBeanstalk` para publicar e compactar sua aplicação.

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> dotnet publish -o site
   C:\eb-dotnetcore\HelloElasticBeasntalk> cd site
   C:\eb-dotnetcore\HelloElasticBeasntalk\site> Compress-Archive -Path * -DestinationPath ../site.zip
   C:\eb-dotnetcore\HelloElasticBeasntalk\site> cd ..
   ```

1. Crie um novo arquivo no `HelloElasticBeanstalk` chamado `aws-windows-deployment-manifest.json`com o seguinte conteúdo: 

   ```
   {
       "manifestVersion": 1,
       "deployments": {
           "aspNetCoreWeb": [
           {
               "name": "test-dotnet-core",
               "parameters": {
                   "appBundle": "site.zip",
                   "iisPath": "/",
                   "iisWebSite": "Default Web Site"
               }
           }
           ]
       }
   }
   ```

1. Inicialize o repositório da EB CLI com o comando **eb init**:

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> eb init -p iis dotnet-windows-server-tutorial --region {{us-east-2}}
   ```

   Esse comando cria um aplicação chamado `dotnet-windows-server-tutorial`e configura seu repositório local para criar ambientes com a versão mais recente da plataforma do Windows Server.

1. Crie um ambiente e implante o aplicativo nele com **eb create**. O Elastic Beanstalk cria automaticamente um arquivo zip para a aplicação e o inicia na porta 5000.

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> eb create dotnet-windows-server-env
   ```

   O Elastic Beanstalk leva cerca de cinco minutos para criar seu ambiente.

## Etapa 4: executar a aplicação no Elastic Beanstalk
<a name="dotnet-quickstart-run-eb-ap"></a>

Quando o processo de criação de seu ambiente for concluído, abra seu site com **eb open**.

```
C:\eb-dotnetcore\HelloElasticBeasntalk> eb open
```

Parabéns\! Você implantou uma aplicação .NET Core no Windows com o Elastic Beanstalk\! Isso abre uma janela do navegador usando o nome de domínio criado para o seu aplicativo.

## Etapa 5: limpar
<a name="go-tutorial-cleanup"></a>

Você pode encerrar o ambiente quando terminar de trabalhar com a aplicação. O Elastic Beanstalk AWS encerra todos os recursos associados ao seu ambiente.

Para encerrar seu ambiente do Elastic Beanstalk com a CLI do EB, execute o seguinte comando.

```
C:\eb-dotnetcore\HelloElasticBeasntalk> eb terminate
```

## AWS recursos para seu aplicativo
<a name="dotnet-quickstart-eb-resources"></a>

Você acabou de criar uma aplicação de instância única. Ela serve como uma aplicação de exemplo simples com uma única instância do EC2 e, portanto, não requer balanceamento de carga ou ajuste de escala automático. Para aplicativos de instância única, o Elastic Beanstalk cria os seguintes recursos: AWS 
+ **Instância do EC2**: uma máquina virtual do Amazon EC2 configurada para executar aplicações Web na plataforma de sua escolha.

  Cada plataforma executa um conjunto diferente de software, arquivos de configuração e scripts para oferecer suporte a uma versão de linguagem, framework, contêiner da Web específicos ou a uma combinação deles. A maioria das plataformas usa o Apache ou nginx como um proxy reverso que processa tráfego da web na frente do aplicativo web, encaminha solicitações para ele, atende ativos estáticos e gera logs de acesso e de erro.
+ **Grupo de segurança de instância**: um grupo de segurança do Amazon EC2 configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP do load balancer chegue à instância do EC2 que executa seu aplicativo Web. Por padrão, o tráfego não é permitido em outras portas.
+ **Bucket do Amazon S3**: um local de armazenamento do seu código-fonte, logs e outros artefatos criados quando o Elastic Beanstalk é utilizado.
+ ** CloudWatch Alarmes da Amazon** — Dois CloudWatch alarmes que monitoram a carga nas instâncias em seu ambiente e são acionados se a carga for muito alta ou muito baixa. Quando um alarme é acionado, o seu grupo de Auto Scaling pode aumentar ou diminuir.
+ **CloudFormation stack** — O Elastic CloudFormation Beanstalk usa para lançar os recursos em seu ambiente e propagar as alterações de configuração. Os recursos são definidos em um modelo que você pode visualizar no [console do CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome de domínio** — Um nome de domínio que é direcionado para seu aplicativo da web no formulário *{{subdomain}}. {{region}}.elasticbeanstalk.com*. 

O Elastic Beanstalk gerencia todos esses recursos. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele.

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

Depois que um ambiente estiver executando um aplicativo, você poderá implantar uma nova versão do aplicativo ou um aplicativo diferente a qualquer momento. A implantação de uma nova versão do aplicativo é muito rápida, pois não é necessário provisionar ou reiniciar as instâncias do EC2. Também é possível explorar o novo ambiente usando o console do Elastic Beanstalk. Para conhecer as etapas detalhadas, consulte [Explore seu ambiente](GettingStarted.md#GettingStarted.Explore), no capítulo *Primeiros passos* deste guia.

**Explore mais tutoriais**  
Se quiser experimentar outros tutoriais com diferentes aplicações de exemplo, consulte [QuickStart para ASP.NET](aspnet-quickstart.md).

Depois de implantar um ou dois aplicações de amostra e estar pronto para começar a desenvolver e executar aplicações .NET Core no Windows localmente, consulte [Configurar seu ambiente de desenvolvimento .NET](dotnet-devenv.md) 

## Implantar com o console do Elastic Beanstalk
<a name="dotnet-quickstart-console"></a>

Você também pode usar o console do Elastic Beanstalk para iniciar a aplicação de exemplo. Para conhecer as etapas detalhadas, consulte [Criar uma aplicação de exemplo](GettingStarted.md#GettingStarted.CreateApp), no capítulo *Primeiros passos* deste guia.