Pré-requisitos Etapa 1: Instalar as ferramentas necessárias Etapa 2 (Opcional): Instalar a extensão da CLI .NET para funções do Lambda Etapa 3: Criar um projeto de aplicação do console do .NET Etapa 4: Adicionar código Etapa 5: Compilar e executar o código Etapa 6: Criar e configurar um projeto de aplicação do console do .NET que usa o AWS SDK for .NET Etapa 7: Adicionar código SDK da AWS Etapa 8: Compilar e executar o código SDK da AWS Etapa 9: Limpar

Tutorial do .NET para AWS Cloud9

Este tutorial permite executar um código .NET em um ambiente de desenvolvimento do AWS Cloud9.

Seguir este tutorial e criar este exemplo pode gerar cobranças em sua conta da AWS. Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte Preço do Amazon EC2 e Preço do Amazon S3.

Tópicos

Pré-requisitos
Etapa 1: Instalar as ferramentas necessárias
Etapa 2 (Opcional): Instalar a extensão da CLI .NET para funções do Lambda
Etapa 3: Criar um projeto de aplicação do console do .NET
Etapa 4: Adicionar código
Etapa 5: Compilar e executar o código
Etapa 6: Criar e configurar um projeto de aplicação do console do .NET que usa o AWS SDK for .NET
Etapa 7: Adicionar código SDK da AWS
Etapa 8: Compilar e executar o código SDK da AWS
Etapa 9: Limpar

Pré-requisitos

Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.

É necessário ter um ambiente existente de desenvolvimento do AWS Cloud9 EC2 Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para ter mais informações, consulte Criar um ambiente no AWS Cloud9.
Você tem o IDE do AWS Cloud9 para o ambiente existente já aberto. Ao abrir um ambiente o AWS Cloud9 abre o IDE para esse ambiente em um navegador da web. Para ter mais informações, consulte Abrir um ambiente no AWS Cloud9.

Etapa 1: Instalar as ferramentas necessárias

Nesta etapa, você instalará o SDK do .NET em seu ambiente, o que é necessário para executar esse exemplo.

Confirme se a versão mais recente do SDK do .NET já está instalada em seu ambiente. Para fazer isso, em uma sessão de terminal no IDE do AWS Cloud9, execute a interface de linha de comando (CLI) do .NET Core com a opção --version .
```
dotnet --version
```
Se a versão das ferramentas de linha de comando do .NET for exibida, e a versão for 2.0 ou superior, avance para Etapa 3: Criar um projeto de aplicação do console do .NET. Se a versão for inferior a 2.0, ou se um erro como bash: dotnet: command not found for exibido, continue a instalar o SDK do .NET.
Para o Amazon Linux, em uma sessão de terminal no IDE do AWS Cloud9, execute os seguintes comandos para ajudar a garantir que as atualizações de segurança e correções de erros mais recentes estejam instaladas, e para instalar um pacote libunwind que o SDK do .NET precisa. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione Janela, Novo terminal.)
```
sudo yum -y update
sudo yum -y install libunwind
```
Para o Ubuntu Server, em uma sessão de terminal no IDE do AWS Cloud9, execute o seguinte comando para ajudar a garantir que as atualizações de segurança e correções de bug mais recentes estejam instaladas. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione Janela, Novo terminal.)
```
sudo apt -y update
```
Baixe o script do instalador do SDK do .NET em seu ambiente executando o comando a seguir.
```
wget https://dot.net/v1/dotnet-install.sh
```
Torne o script do instalador executável pelo usuário atual executando o comando a seguir.
```
sudo chmod u=rx dotnet-install.sh
```
Execute o script do instalador, que baixa e instala o SDK do .NET, executando o comando a seguir.
```
./dotnet-install.sh -c Current
```
Adicione o SDK do .NET ao PATH. Para fazer isso, no perfil de shell do ambiente (por exemplo, o arquivo .bashrc), adicione o subdiretório $HOME/.dotnet à variável PATH para o ambiente, da seguinte forma:
1. Abra o arquivo .bashrc para edição usando o comando vi.
```
vi ~/.bashrc
```
2. Para o Amazon Linux, usando a seta para baixo ou a tecla j, vá até a linha que começa com export PATH.
  
  Para Ubuntu Server, mova para a última linha do arquivo digitando G.
3. Usando a seta para a direita ou a tecla $, mova para o final da linha.
4. Alterne para modo de inserção pressionando a tecla i. (-- INSERT --- aparecerá no final da tela.)
5. Para o Amazon Linux, adicione o subdiretório $HOME/.dotnet à variável PATH , digitando :$HOME/.dotnet. Certifique-se de incluir o caractere de dois pontos (:). A linha agora deve ser semelhante à que vem a seguir.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
  Para o Ubuntu Server, pressione a tecla de seta para a direita e pressione Enter duas vezes e digite a seguinte linha no final do arquivo.
```
export PATH=$HOME/.dotnet:$PATH
```
6. Salve o arquivo. Para fazer isso, pressione a tecla Esc (-- INSERT --- desaparecerá do final da tela), digite :wq (para gravar e, em seguida, encerrar o arquivo) e, em seguida, pressione Enter.
Carregue o SDK do .NET após obter o arquivo .bashrc.
```
. ~/.bashrc
```
Confirme o SDK do .NET está carregado executando a CLI do .NET com a opção --help .
```
dotnet --help
```
Se for bem-sucedido, o número da versão do SDK do .NET será exibido, com mais informações de uso.
Se você não quiser mais manter o script do instalador do SDK do .NET em seu ambiente, exclua-o da seguinte forma:
```
rm dotnet-install.sh
```

Etapa 2 (Opcional): Instalar a extensão da CLI .NET para funções do Lambda

Embora não seja necessário para este tutorial, você pode implantar funções do AWS Lambda e aplicações AWS Serverless Application Model usando a CLI do .NET, se você também instalar o pacote Amazon.Lambda.Tools.

Para instalar esse pacote, execute o seguinte comando:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Agora defina as variáveis de ambiente PATH e DOTNET_ROOT apontando para a ferramenta do Lambda instalada. No arquivo .bashrc, localize a seção export PATH e edite-a para que fique semelhante à seguinte (consulte a Etapa 1 para obter detalhes sobre como editar esse arquivo):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```

Etapa 3: Criar um projeto de aplicação do console do .NET

Nesta etapa, use o .NET para criar um projeto chamado hello. Esse projeto contém todos os arquivos que o .NET precisa para executar uma aplicação simples no terminal do IDE. O código do aplicativo é gravado em C#.

Crie um projeto de aplicação do console do .NET. Para fazer isso, execute a CLI do .NET com o comando new , especificando o modelo de projeto de aplicação do console e a linguagem de programação a ser usada (neste exemplo, C#).

A opção -n indica que o projeto tem saída para um novo diretório, hello. Em seguida, navegamos até o diretório.


dotnet new console -lang C# -n hello
cd hello

O comando anterior adiciona um subdiretório chamado obj com vários arquivos, e alguns outros arquivos independentes, ao diretório hello. Observe os dois arquivos de chave a seguir:

O arquivo hello/hello.csproj contém informações sobre o projeto de aplicativo do console.
O arquivo hello/Program.cs contém o código do aplicativo a ser executado.

Etapa 4: Adicionar código

Nesta etapa, você adiciona algum código ao aplicativo.

Na janela Environment (Ambiente) no AWS Cloud9, abra o arquivo hello/Program.cs.

No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo Program.cs.


using System;

namespace hello
{
  class Program
  {
    static void Main(string[] args)
    {
     if (args.Length < 2) {
       Console.WriteLine("Please provide 2 numbers");
       return;
     }

     Console.WriteLine("Hello, World!");

     Console.WriteLine("The sum of 2 and 3 is 5.");

     int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);

     Console.WriteLine("The sum of {0} and {1} is {2}.",
     args[0], args[1], sum);

    }
  }
}

Etapa 5: Compilar e executar o código

Nesta etapa, você criará o projeto e suas dependências em um conjunto de arquivos binários, incluindo um arquivo executável da aplicação. Em seguida, você executa a aplicação.

No IDE, crie um construtor para o .NET da seguinte forma:
1. Na barra de menus, selecione Run (Executar), Build System (Sistema de compilação), New Build System (Novo sistema de compilação).
2. Na guia My Builder.build (Meu Builder.build), substitua o conteúdo da guia pelo código a seguir.
```
{
  "cmd" : ["dotnet", "build"],
  "info" : "Building..."
}
```
3. Selecione Arquivo, Salvar como.
4. Para Nome do arquivo, digite .NET.build.
5. Para Pasta, digite /.c9/builders.
6. Escolha Salvar.
Com o conteúdo do arquivo Program.cs exibido no editor, selecione Executar, Sistema de compilação, .NET. Em seguida, selecione Run, Build (Executar, Compilar).

Esse compilador adiciona um subdiretório chamado bin e adiciona um subdiretório chamado Debug ao subdiretório hello/obj. Observe os três arquivos de chave a seguir.
- O arquivo hello/bin/Debug/netcoreapp3.1/hello.dll é o arquivo executável do aplicativo.
- O arquivo hello/bin/Debug/netcoreapp3.1/hello.deps.json lista as dependências do aplicativo.
- O arquivo hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json especifica o tempo de execução compartilhado e sua versão para o aplicativo.
nota
O nome da pasta, netcoreapp3.1, reflete a versão do SDK do .NET usado neste exemplo. Você poderá ver um número diferente no nome da pasta, dependendo da versão instalada.
Crie um executor para o .NET da seguinte forma.
1. Na barra de menus, escolha Run (Executar), Run With (Executar com), New Runner (Novo executor).
2. Na guia My Runner.run (Meu Runner.run), substitua o conteúdo da guia pelo código a seguir.
```
{
  "cmd" : ["dotnet", "run", "$args"],
  "working_dir": "$file_path",
  "info" : "Running..."
}
```
3. Selecione Arquivo, Salvar como.
4. Para Nome do arquivo, digite .NET.run.
5. Para Pasta, digite /.c9/runners.
6. Escolha Salvar.
Execute o aplicativo com dois números inteiros a serem adicionados (por exemplo, 5 e 9) da seguinte forma.
1. Com o conteúdo do arquivo Program.cs exibido no editor, escolha Run (Executar), Run Configurations (Configurações de execução), New Run Configuration (Nova configuração de execução).
2. Na guia [Novo] – Inativo, selecione Executor: automático e escolha .NET.
3. Na caixa Command (Comando), digite hello 5 9.
4. Escolha Executar.
  
  Por padrão, esse executor instrui o .NET a executar o arquivo hello.dll no diretório hello/bin/Debug/netcoreapp3.1.
  
  Compare o resultado com o seguinte.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```

Etapa 6: Criar e configurar um projeto de aplicação do console do .NET que usa o AWS SDK for .NET

Você pode aprimorar este exemplo para usar o AWS SDK for .NET para criar um bucket do Amazon S3, listar os buckets disponíveis e excluir o bucket que acabou de criar.

Neste novo projeto, você adiciona uma referência ao AWS SDK for .NET. O AWS SDK for .NET fornece uma forma conveniente para interagir com os serviços da AWS, como o Amazon S3, no código .NET. Configure então o gerenciamento de credenciais da AWS no seu ambiente. O AWS SDK for .NET precisa dessas credenciais para interagir com os serviços da AWS.

Para criar o projeto do

Crie um projeto de aplicação do console do .NET. Para fazer isso, execute a CLI do .NET com o comando new, especificando o modelo de projeto de aplicação do console e a linguagem de programação a ser usada.

A opção -n indica que o projeto tem saída para um novo diretório, s3. Em seguida, navegamos até o diretório.
```
dotnet new console -lang C# -n s3
cd s3
```
Adicione uma referência de projeto ao pacote do Amazon S3 no AWS SDK for .NET. Para fazer isso, execute a CLI do .NET com o comando add package , especificando o nome do pacote do Amazon S3 no NuGet. (O NuGet define como pacotes para .NET são criados, hospedados e consumidos, e fornece as ferramentas para cada uma dessas funções.)
```
dotnet add package AWSSDK.S3
```
Quando você adiciona uma referência de projeto ao pacote do Amazon S3, o NuGet também adiciona uma referência de projeto ao restante do AWS SDK for .NET.

nota
Para os nomes e as versões de outros pacotes relacionados à AWS no NuGet, consulte Pacotes NuGet marcados com aws-sdk no site do NuGet.

Para configurar o gerenciamento de credenciais da AWS

Toda vez que você usar o AWS SDK for .NET para chamar um serviço da AWS, forneça um conjunto de credenciais da AWS com a chamada. Essas credenciais determinam se o AWS SDK for .NET tem as permissões apropriadas para realizar essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.

Para armazenar suas credenciais no ambiente, siga as instruções em Chamar Serviços da AWS em um ambiente no AWS Cloud9 e retorne a este tópico.

Para obter mais informações, consulte Configuring AWS Credentials no Guia do desenvolvedor do AWS SDK for .NET.

Etapa 7: Adicionar código SDK da AWS

Nesta etapa, você adicionará código para interagir com o Amazon S3 para criar um bucket, excluir o bucket que acabou de criar e listar os buckets disponíveis.

Na janela Environment (Ambiente) no AWS Cloud9, abra o arquivo s3/Program.cs. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo Program.cs.


using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
     
namespace s3
{
  class Program
  {
   async static Task Main(string[] args)
   {
    if (args.Length < 2) {
      Console.WriteLine("Usage: <the bucket name> <the AWS Region to use>");
      Console.WriteLine("Example: my-test-bucket us-east-2");
      return;
    }
     
    if (args[1] != "us-east-2") {
      Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
      "'us-east-2'.");
       return;
     }
         
      var bucketRegion = RegionEndpoint.USEast2;
      // Note: You could add more valid AWS Regions above as needed.
     
      using (var s3Client = new AmazonS3Client(bucketRegion)) {
      var bucketName = args[0];
        
      // Create the bucket.
      try
      {
       if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
       {
         Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
         "A bucket named '{0}' already exists.", bucketName);
         return;
       } else {
         Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
         await s3Client.PutBucketAsync(bucketName);
         }
       }
       catch (AmazonS3Exception e)
       {
        Console.WriteLine("Cannot continue. {0}", e.Message);
       }
       catch (Exception e)
       {
        Console.WriteLine("Cannot continue. {0}", e.Message);
       }
        
       // Confirm that the bucket was created.
       if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
       {
          Console.WriteLine("Created the bucket named '{0}'.", bucketName);
       } else {
         Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
       }
        
       // Delete the bucket.
       Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
       await s3Client.DeleteBucketAsync(bucketName);
        
       // Confirm that the bucket was deleted.
       if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
       {
          Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
       } else {
         Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
       };
        
        // List current buckets.
       Console.WriteLine("\nMy buckets now are:");
       var response = await s3Client.ListBucketsAsync();
        
       foreach (var bucket in response.Buckets)
       {
       Console.WriteLine(bucket.BucketName);
       }
      }
    }
  }
}

Etapa 8: Compilar e executar o código SDK da AWS

Nesta etapa, você criará o projeto e suas dependências em um conjunto de arquivos binários, incluindo um arquivo executável da aplicação. Em seguida, você executa a aplicação.

Crie o projeto. Para fazer isso, com o conteúdo do arquivo s3/Program.cs exibido no editor, na barra de menus, selecione Run (Executar), Build (Compilação).
Execute a aplicação com o nome do bucket do Amazon S3 a ser criado e o ID da região da AWS na qual criar o bucket (por exemplo, my-test-bucket e us-east-2) da seguinte forma:
1. Com o conteúdo do arquivo s3/Program.cs ainda exibido no editor, escolha Run (Executar), Run Configurations (Configurações de execução), New Run Configuration (Nova configuração de execução).
2. Na guia [Novo] – Inativo, selecione Executor: automático e escolha .NET.
3. Na caixa Command (Comando), digite o nome da aplicação, o nome do bucket do Amazon S3 a ser criado e o ID da região da AWS na qual criar o bucket (por exemplo, s3 my-test-bucket us-east-2).
4. Escolha Executar.
  
  Por padrão, esse executor instrui o .NET a executar o arquivo s3.dll no diretório s3/bin/Debug/netcoreapp3.1.
  
  Compare os resultados com a seguinte saída.
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.

Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.

My buckets now are:
```

Etapa 9: Limpar

Para evitar cobranças contínuas em sua conta da AWS, ao terminar de usar este exemplo, exclua o ambiente. Para obter instruções, consulte Excluir um ambiente no AWS Cloud9.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutorial do Python

Tutorial Node.js