Pré-requisitos Etapa 1: Instalar as ferramentas necessárias Etapa 2 (Opcional): Instale o. NETCLIextensão para funções Lambda Etapa 3: Crie um. NETprojeto de aplicativo de console Etapa 4: Adicionar código Etapa 5: Compilar e executar o código Etapa 6: Crie e configure um. NETprojeto de aplicativo de console que usa o AWS SDK for .NET Etapa 7: adicionar AWS SDK código Etapa 8: criar e executar o AWS SDK código Etapa 9: Limpar

. NETtutorial para AWS Cloud9

Este tutorial permite que você execute alguns. NETcódigo em um ambiente AWS Cloud9 de desenvolvimento.

Seguir este tutorial e criar essa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como Amazon EC2 e Amazon S3. Para obter mais informações, consulte Amazon EC2 Pricing e Amazon S3 Pricing.

Tópicos

Pré-requisitos
Etapa 1: Instalar as ferramentas necessárias
Etapa 2 (Opcional): Instale o. NETCLIextensão para funções Lambda
Etapa 3: Crie um. NETprojeto de aplicativo de console
Etapa 4: Adicionar código
Etapa 5: Compilar e executar o código
Etapa 6: Crie e configure um. NETprojeto de aplicativo de console que usa o AWS SDK for .NET
Etapa 7: adicionar AWS SDK código
Etapa 8: criar e executar o AWS SDK código
Etapa 9: Limpar

Pré-requisitos

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

Você deve ter um ambiente de AWS Cloud9 EC2 desenvolvimento existente. Este exemplo pressupõe que você já tenha um EC2 ambiente conectado a uma EC2 instância da Amazon que executa o Amazon Linux ou Ubuntu Servidor. 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 obter mais informações, consulte Criando um ambiente em AWS Cloud9.
Você tem o AWS Cloud9 IDE para o ambiente existente já aberto. Quando você abre um ambiente, AWS Cloud9 abre o IDE para esse ambiente em seu navegador da web. Para obter mais informações, consulte Abrir um ambiente no AWS Cloud9.

Etapa 1: Instalar as ferramentas necessárias

Nesta etapa, você instala o. NETSDKem seu ambiente, o que é necessário para executar essa amostra.

Confirme se a versão mais recente do. NETSDKjá está instalado em seu ambiente. Para fazer isso, em uma sessão de terminal no AWS Cloud9 IDE, execute o. NETInterface de linha de comando principal (CLI) com a --versionopção.
```
dotnet --version
```
Se o. NETA versão das Ferramentas de Linha de Comando é exibida e a versão é 2.0 ou superior, vá paraEtapa 3: Crie um. NETprojeto de aplicativo de console. Se a versão for menor que 2.0 ou se um erro como bash: dotnet: command not found o exibido, continue instalando o. NETSDK.
Para o Amazon Linux, em uma sessão de terminal no AWS Cloud9 IDE, execute os seguintes comandos para ajudar a garantir que as atualizações de segurança e correções de erros mais recentes sejam instaladas e para instalar um libunwind pacote que o. NETSDKnecessidades. (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 AWS Cloud9 IDE, execute o comando a seguir para ajudar a garantir que as atualizações de segurança e correções de erros 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. NETSDKscript de instalação 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. NETSDK, executando o comando a seguir.
```
./dotnet-install.sh -c Current
```
Adicione o. NETSDKpara o seuPATH. 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. NETSDKfornecendo o .bashrc arquivo.
```
. ~/.bashrc
```
Confirme o. NETSDKé carregado ao ser executado. NETCLIcom a --helpopção.
```
dotnet --help
```
Se for bem sucedido, o. NETSDKo número da versão é exibido, com informações adicionais de uso.
Se você não quiser mais manter o. NETSDKscript de instalação em seu ambiente, você pode excluí-lo da seguinte maneira.
```
rm dotnet-install.sh
```

Etapa 2 (Opcional): Instale o. NETCLIextensão para funções Lambda

Embora não seja obrigatório para este tutorial, você pode implantar AWS Lambda funções e AWS Serverless Application Model aplicativos usando o. NETCLIse você também instalar o Amazon.Lambda.Tools pacote.

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: Crie um. NETprojeto de aplicativo de console

Nesta etapa, você usa. NETpara criar um projeto chamadohello. Este projeto contém todos os arquivos que. NETprecisa executar um aplicativo simples a partir do terminal noIDE. O código do aplicativo é gravado em C#.

Crie um. NETprojeto de aplicativo de console. Para fazer isso, execute o. NETCLIcom o newcomando, especificando o tipo de modelo de projeto do aplicativo de 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 Ambiente do AWS Cloud9 IDE, abra o hello/Program.cs arquivo.

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.

NoIDE, crie um construtor para. NETda 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 Program.cs arquivo exibido no editor, escolha Executar, Criar sistema,. 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 pastanetcoreapp3.1,, reflete a versão do. NETSDKusado neste exemplo. Você poderá ver um número diferente no nome da pasta, dependendo da versão instalada.
Crie um corredor para. NETda 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, escolha Runner: Auto e, em seguida, escolha. NET.
3. Na caixa Command (Comando), digite hello 5 9.
4. Escolha Executar.
  
  Por padrão, esse executor instrui. NETpara executar o hello.dll arquivo no hello/bin/Debug/netcoreapp3.1 diretório.
  
  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: Crie e configure um. NETprojeto de aplicativo de console que usa o AWS SDK for .NET

Você pode aprimorar essa amostra para usar o AWS SDK for .NET para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar.

Neste novo projeto, você adiciona uma referência ao AWS SDK for .NET. O AWS SDK for .NET fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu. NETcódigo. Em seguida, você configura o gerenciamento de AWS credenciais em seu ambiente. Eles AWS SDK for .NET precisam dessas credenciais para interagir com os AWS serviços.

Para criar o projeto do

Crie um. NETprojeto de aplicativo de console. Para fazer isso, execute o. NETCLIcom o newcomando, especificando o tipo de modelo de projeto do aplicativo de 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 o. NETCLIcom o add packagecomando, especificando o nome do pacote Amazon S3 em. NuGet (NuGetdefine como os pacotes servem. NETsão criados, hospedados e consumidos e fornecem as ferramentas para cada uma dessas funções.)
```
dotnet add package AWSSDK.S3
```
Quando você adiciona uma referência de projeto ao pacote Amazon S3, NuGet também adiciona uma referência de projeto ao resto do. AWS SDK for .NET

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

Para configurar o gerenciamento de AWS credenciais

Cada vez que você usa o AWS SDK for .NET para chamar um AWS serviço, você deve fornecer um conjunto de AWS credenciais com a chamada. Essas credenciais determinam se ele AWS SDK for .NET tem as permissões apropriadas para fazer 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 Chamando Serviços da AWS de um ambiente em AWS Cloud9 e retorne a este tópico.

Para obter informações adicionais, consulte Configuração de AWS credenciais no Guia do AWS SDK for .NET desenvolvedor.

Etapa 7: adicionar AWS SDK código

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 Ambiente do AWS Cloud9 IDE, abra o s3/Program.cs arquivo. 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: criar e executar o AWS SDK 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.

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, escolha Runner: Auto e, em seguida, escolha. NET.
3. Na caixa Comando, digite o nome do aplicativo, o nome do bucket do Amazon S3 a ser criado e o ID da AWS região na qual criar o bucket (por exemplo,s3 my-test-bucket us-east-2).
4. Escolha Executar.
  
  Por padrão, esse executor instrui. NETpara executar o s3.dll arquivo no s3/bin/Debug/netcoreapp3.1 diretório.
  
  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 AWS conta depois de terminar de usar esse exemplo, você deve excluir 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