

 AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

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

# Tutorial Go para AWS Cloud9
<a name="sample-go"></a>

Este tutorial permite que você execute alguns códigos em Go em um ambiente de AWS Cloud9 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 o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).

**Topics**
+ [Pré-requisitos](#sample-go-prereqs)
+ [Etapa 1: Instalar as ferramentas necessárias](#sample-go-install)
+ [Etapa 2: Adicionar código](#sample-go-code)
+ [Etapa 3: Executar o código](#sample-go-run)
+ [Etapa 4: instalar e configurar o AWS SDK para Go](#sample-go-sdk)
+ [Etapa 5: adicionar código AWS SDK](#sample-go-sdk-code)
+ [Etapa 6: executar o código do AWS SDK](#sample-go-sdk-run)
+ [Etapa 7: limpar](#sample-go-clean-up)

## Pré-requisitos
<a name="sample-go-prereqs"></a>

Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.
+ **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** 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 obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md).
+ **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md).

## Etapa 1: Instalar as ferramentas necessárias
<a name="sample-go-install"></a>

Nesta etapa, instale e configure a Go, necessária para executar esse exemplo.

1. Em uma sessão de terminal no AWS Cloud9 IDE, confirme se o Go já está instalado executando o **`go version`**comando. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) Se for bem-sucedido, a saída deve conter o número da versão Go. Caso contrário, será exibida uma mensagem de erro. Se o Go estiver instalado, avance para [Etapa 2: Adicionar código](#sample-go-code).

1. Execute o comando ** `yum update` ** para Amazon Linux ou o comando ** `apt update` ** para Ubuntu Server a fim de ajudar a garantir que as atualizações de segurança e correções de bug mais recentes sejam instaladas.

   Para Amazon Linux:

   ```
   sudo yum -y update
   ```

   Para Ubuntu Server:

   ```
   sudo apt update
   ```

1. Para instalar a Go, execute esses comandos, um por vez.

   ```
   wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
   sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz              # Install Go.
   rm ./go1.9.3.linux-amd64.tar.gz                                       # Delete the installer.
   ```

   Os comandos anteriores assumem a versão estável mais recente da Go no momento em que este tópico foi escrito. Para obter mais informações, consulte [Downloads](https://golang.org/dl/) no site The Go Programming Language.

1. Adicione o caminho para o binário Go à variável de ambiente `PATH`, da seguinte forma.

   1. Abra o arquivo de perfil de shell (por exemplo, `~/.bashrc`) para edição.

   1. No final dessa linha de código, digite o seguinte, para que o código tenha a seguinte aparência.

      ```
      PATH=$PATH:/usr/local/go/bin
      ```

   1. Salve o arquivo.

1. Extraia o arquivo `~/.bashrc` para que o terminal possa encontrar o binário Go referenciado anteriormente.

   ```
   . ~/.bashrc
   ```

1. Confirme se a Go foi instalada e configurada com sucesso executando o comando ** `go version` **. Se sim, a saída contém o número da versão Go.

## Etapa 2: Adicionar código
<a name="sample-go-code"></a>

No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome`hello.go`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).)

```
package main

import (
  "fmt"
  "os"
  "strconv"
)

func main() {
  fmt.Printf("Hello, World!\n")

  fmt.Printf("The sum of 2 and 3 is 5.\n")

  first, _ := strconv.Atoi(os.Args[1])
  second, _ := strconv.Atoi(os.Args[2])
  sum := first + second

  fmt.Printf("The sum of %s and %s is %s.",
    os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```

## Etapa 3: Executar o código
<a name="sample-go-run"></a>

1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.

1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.
**nota**  
Se **Go** não estiver disponível, crie um executor personalizado para Go.  
Na guia **[New] - Idle ([Novo] – Inativo)**, selecione **Runner: Auto (Executor: automático)** e, em seguida, selecione **New Runner (Novo executor)**.
Na guia **My Runner.run (Meu Runner.run)**, substitua o conteúdo da guia por esse código.  

      ```
      {
        "cmd" : ["go", "run", "$file", "$args"],
        "info" : "Running $project_path$file_name...",
        "selector" : "source.go"
      }
      ```
Selecione **File (Arquivo)**, **Save As (Salvar como)** na barra de menus e salve o arquivo como `Go.run` na pasta `/.c9/runners`.
Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.
Selecione a guia **hello.go** para ativá-la.

1. Em **Comando**, digite `hello.go 5 9`. No código, `5` representa `os.Args[1]` e `9` representa `os.Args[2]`.  
![\[Saída da execução do código Go no AWS Cloud9 IDE\]](http://docs.aws.amazon.com/pt_br/cloud9/latest/user-guide/images/ide-go-simple.png)

1. Selecione o botão **Executar** e compare a sua saída.

   ```
   Hello, World!
   The sum of 2 and 3 is 5.
   The sum of 5 and 9 is 14.
   ```

## Etapa 4: instalar e configurar o AWS SDK para Go
<a name="sample-go-sdk"></a>

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

Nesta etapa, você instala e configura o AWS SDK para Go, que fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código Go. Antes de instalar o AWS SDK para Go, defina a variável de ambiente `GOPATH`. Após instalar o AWS SDK para Go e definir a variável de ambiente `GOPATH`, configure o gerenciamento de credenciais no ambiente. Eles AWS SDK para Go precisam dessas credenciais para interagir com os AWS serviços.

### Para definir a variável de ambiente GOPATH
<a name="sample-go-sdk-set-gopath"></a>

1. Abra o arquivo `~/.bashrc` para edição.

1. Após a última linha no arquivo, digite esse código.

   ```
   GOPATH=~/environment/go
      
   export GOPATH
   ```

1. Salve o arquivo.

1. Extraia o arquivo `~/.bashrc` para que o terminal possa encontrar a variável de ambiente `GOPATH` referenciada anteriormente.

   ```
   . ~/.bashrc
   ```

1. Confirme se a variável de ambiente `GOPATH` foi definida com sucesso executando o comando ** `echo $GOPATH`**. Se tiver êxito, a saída deverá ser `/home/ec2-user/environment/go` ou `/home/ubuntu/environment/go`.

### Para instalar o AWS SDK para Go
<a name="sample-go-sdk-install-sdk"></a>

Execute o **`go get`**comando, especificando a localização da AWS SDK para Go fonte.

```
go get -u github.com/aws/aws-sdk-go/...
```

O Go instala a AWS SDK para Go fonte no local especificado pela variável de `GOPATH` ambiente, que é a `go` pasta em seu ambiente.

### Como configurar o gerenciamento de credenciais no ambiente
<a name="sample-go-sdk-creds"></a>

Cada vez que você usa o AWS SDK para Go para ligar para um AWS serviço, você deve fornecer um conjunto de credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para Go tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará.

Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico.

Para obter mais informações, consulte [Specifying Credentials](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials)(Especificar credenciais) no *Manual do desenvolvedor do AWS SDK para Go *.

## Etapa 5: adicionar código AWS SDK
<a name="sample-go-sdk-code"></a>

Nesta etapa, adicione mais código, dessa vez para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e, excluir o bucket que você acabou de criar. Esse código será executado mais tarde.

No AWS Cloud9 IDE, crie um arquivo com esse conteúdo e salve o arquivo com o nome`s3.go`.

```
package main

import (
	"fmt"
	"os"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/s3"
)

func main() {

	if len(os.Args) < 3 {
		fmt.Printf("Usage: go run s3.go <the bucket name> <the AWS Region to use>\n" +
			"Example: go run s3.go my-test-bucket us-east-2\n")
		os.Exit(1)
	}

	sess := session.Must(session.NewSessionWithOptions(session.Options{
		SharedConfigState: session.SharedConfigEnable,
	}))
	svc := s3.New(sess, &aws.Config{
		Region: aws.String(os.Args[2]),
	})

	listMyBuckets(svc)
	createMyBucket(svc, os.Args[1], os.Args[2])
	listMyBuckets(svc)
	deleteMyBucket(svc, os.Args[1])
	listMyBuckets(svc)
}

// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
	result, err := svc.ListBuckets(nil)

	if err != nil {
		exitErrorf("Unable to list buckets, %v", err)
	}

	fmt.Println("My buckets now are:\n")

	for _, b := range result.Buckets {
		fmt.Printf(aws.StringValue(b.Name) + "\n")
	}

	fmt.Printf("\n")
}

// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
	fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")

	_, err := svc.CreateBucket(&s3.CreateBucketInput{
		Bucket: aws.String(bucketName),
		CreateBucketConfiguration: &s3.CreateBucketConfiguration{
			LocationConstraint: aws.String(region),
		},
	})

	if err != nil {
		exitErrorf("Unable to create bucket, %v", err)
	}

	// Wait until bucket is created before finishing
	fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)

	err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
		Bucket: aws.String(bucketName),
	})
}

// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
	fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")

	_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
		Bucket: aws.String(bucketName),
	})

	if err != nil {
		exitErrorf("Unable to delete bucket, %v", err)
	}

	// Wait until bucket is deleted before finishing
	fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)

	err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
		Bucket: aws.String(bucketName),
	})
}

// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, msg+"\n", args...)
	os.Exit(1)
}
```

## Etapa 6: executar o código do AWS SDK
<a name="sample-go-sdk-run"></a>

1. No AWS Cloud9 IDE, na barra de menu, escolha **Executar**, **Configurações de execução**, **Nova configuração de execução**.

1. Na guia **[Novo] – Inativo**, selecione **Executor: automático** e escolha **Ir**.

1. Em **Command**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, digite, onde ` YOUR_BUCKET_NAME ` está o nome do bucket que você deseja criar e depois excluir, e ` THE_AWS_REGION ` é o ID da AWS região na qual você deseja criar o bucket. Por exemplo, para a região Leste dos EUA (Ohio), use `us-east-2`. Para obter mais informações IDs, consulte [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) no. *Referência geral da Amazon Web Services*
**nota**  
Os nomes dos buckets do Amazon S3 devem ser exclusivos em toda a sua conta, AWS não apenas em sua conta. AWS 

1. Selecione o botão **Executar** e compare a sua saída.

   ```
   My buckets now are:
   
   Creating a new bucket named 'my-test-bucket'...
   
   My buckets now are:
   
   my-test-bucket
   
   Deleting the bucket named 'my-test-bucket'...
   
   My buckets now are:
   ```

## Etapa 7: limpar
<a name="sample-go-clean-up"></a>

Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).