

 AWS Cloud9 non è più disponibile per i nuovi clienti. I clienti esistenti di AWS Cloud9 possono continuare a utilizzare il servizio come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Vai al tutorial per AWS Cloud9
<a name="sample-go"></a>

Questo tutorial ti consente di eseguire del codice Go in un ambiente di AWS Cloud9 sviluppo.

Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).

**Topics**
+ [Prerequisiti](#sample-go-prereqs)
+ [Fase 1: installare gli strumenti necessari](#sample-go-install)
+ [Fase 2: aggiungere un codice](#sample-go-code)
+ [Fase 3: eseguire il codice](#sample-go-run)
+ [Fase 4: Installare e configurare AWS SDK per Go](#sample-go-sdk)
+ [Passaggio 5: Aggiungere AWS il codice SDK](#sample-go-sdk-code)
+ [Passaggio 6: Esegui il codice AWS SDK](#sample-go-sdk-run)
+ [Fase 7: pulire](#sample-go-clean-up)

## Prerequisiti
<a name="sample-go-prereqs"></a>

Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:
+ **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md).
+ **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md).

## Fase 1: installare gli strumenti necessari
<a name="sample-go-install"></a>

In questa fase, viene installato e configurato Go, indispensabile per eseguire l'esempio.

1. In una sessione terminale nell' AWS Cloud9 IDE, verifica se Go è già installato eseguendo il **`go version`**comando. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). In caso di esito positivo, l'output includerà il numero di versione di Go. In caso contrario, verrà prodotto un messaggio di errore. Se Go è installato, passa alla [Fase 2: aggiungere un codice](#sample-go-code).

1. Esegui il comando ** `yum update` ** per (Amazon Linux) o ** `apt update` ** per (Ubuntu Server) per verificare che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug più recenti.

   Per Amazon Linux:

   ```
   sudo yum -y update
   ```

   Per Ubuntu Server:

   ```
   sudo apt update
   ```

1. Per installare Go, esegui questi comandi, uno alla volta.

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

   I comandi precedenti presuppongono l'utilizzo della versione stabile di Go più recente, al momento della redazione di questo argomento. Per ulteriori informazioni, vedi [Download](https://golang.org/dl/) nel sito Web del linguaggio di programmazione Go.

1. Aggiungi il percorso del file binario Go alla variabile di ambiente `PATH`, come indicato di seguito.

   1. Apri il file del profilo shell (ad esempio, `~/.bashrc`) per la modifica.

   1. Alla fine di questa riga di codice, digita quanto segue. Il codice dovrebbe avere questo aspetto.

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

   1. Salvare il file.

1. Indica l'origine del file `~/.bashrc`, in modo che il terminale sia in grado di trovare il file binario GO usato come riferimento.

   ```
   . ~/.bashrc
   ```

1. Conferma che Go è stato installato e configurato correttamente, eseguendo il comando ** `go version` **. In caso di esito positivo, l'output includerà il numero di versione di Go.

## Fase 2: aggiungere un codice
<a name="sample-go-code"></a>

Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il nome`hello.go`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)).

```
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))
}
```

## Fase 3: eseguire il codice
<a name="sample-go-run"></a>

1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.

1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.
**Nota**  
Se **Go** non è disponibile, puoi creare un'esecuzione personalizzata per Go.  
Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **New Runner (Nuova esecuzione)**.
Nella scheda **My Runner.run**, sostituisci i contenuti della scheda con questo codice.  

      ```
      {
        "cmd" : ["go", "run", "$file", "$args"],
        "info" : "Running $project_path$file_name...",
        "selector" : "source.go"
      }
      ```
Nella barra dei menu seleziona **File**, **Save As (Salva con nome)** e salva il file come `Go.run` nella cartella `/.c9/runners`.
Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.
Seleziona la scheda **hello.go** per attivarlo.

1. Per **Command (Comando)**, digitare `hello.go 5 9`. Nel codice, `5` rappresenta `os.Args[1]` e `9` rappresenta `os.Args[2]`.  
![\[Risultato dell'esecuzione del codice Go nell'IDE AWS Cloud9\]](http://docs.aws.amazon.com/it_it/cloud9/latest/user-guide/images/ide-go-simple.png)

1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.

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

## Fase 4: Installare e configurare AWS SDK per Go
<a name="sample-go-sdk"></a>

Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per Go elencare i bucket disponibili e quindi eliminare il bucket appena creato.

In questa fase, installi e configuri il AWS SDK per Go, che fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo codice Go. Prima di installare l' AWS SDK per Go, è necessario impostare la variabile di ambiente `GOPATH`. Dopo avere installato AWS SDK per Go e impostato la variabile di ambiente `GOPATH`, devi configurare la gestione delle credenziali nell'ambiente. AWS SDK per Go Ha bisogno di queste credenziali per interagire con AWS i servizi.

### Per impostare la variabile di ambiente GOPATH
<a name="sample-go-sdk-set-gopath"></a>

1. Apri il file `~/.bashrc` per la modifica.

1. Dopo l'ultima riga del file, digita questo codice.

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

1. Salvare il file.

1. Indica l'origine del file `~/.bashrc` in modo che il terminale sia in grado di trovare la variabile di ambiente `GOPATH` usata come riferimento.

   ```
   . ~/.bashrc
   ```

1. Verifica che l'impostazione della variabile di ambiente `GOPATH` sia corretta eseguendo il comando ** `echo $GOPATH` **. In caso di esito positivo, l'output è `/home/ec2-user/environment/go` o `/home/ubuntu/environment/go`.

### Per installare il AWS SDK per Go
<a name="sample-go-sdk-install-sdk"></a>

Esegui il **`go get`**comando, specificando la posizione della AWS SDK per Go fonte.

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

Go installa la AWS SDK per Go sorgente nella posizione specificata dalla variabile di `GOPATH` ambiente, che è la `go` cartella dell'ambiente.

### Per configurare la gestione delle credenziali nell'ambiente
<a name="sample-go-sdk-creds"></a>

Ogni volta che si utilizza il AWS SDK per Go per chiamare un AWS servizio, è necessario fornire un set di credenziali con la chiamata. Queste credenziali determinano se AWS SDK per Go dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà.

In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento.

Per ulteriori informazioni, consulta [Specifying Credentials](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials) nella *AWS SDK per Go Developer Guide*.

## Passaggio 5: Aggiungere AWS il codice SDK
<a name="sample-go-sdk-code"></a>

In questa fase si aggiunge altro codice, questa volta per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Potrai eseguire questo codice più tardi.

Nell' AWS Cloud9 IDE, crea un file con questo contenuto e salva il file con il 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)
}
```

## Passaggio 6: Esegui il codice AWS SDK
<a name="sample-go-sdk-run"></a>

1. Nell' AWS Cloud9 IDE, nella barra dei menu, scegli **Esegui, Esegui** **configurazioni**, **Nuova configurazione di esecuzione**.

1. Nella scheda **[New] - Idle ([Nuovo] - inattivo)**, seleziona **Runner: Auto (Esecuzione: auto)** e **Go**.

1. In **Comando**`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, digita, dove ` YOUR_BUCKET_NAME ` è il nome del bucket che desideri creare, quindi elimina, ed ` THE_AWS_REGION ` è l'ID della AWS regione in cui desideri creare il bucket. Ad esempio, per la regione Stati Uniti orientali (Ohio) utilizzare `us-east-2`. Per ulteriori informazioni IDs, consulta [Amazon Simple Storage Service (Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)) nel. *Riferimenti generali di Amazon Web Services*
**Nota**  
I nomi dei bucket Amazon S3 devono essere univoci per tutti gli account, AWS non solo per il tuo account. AWS 

1. Seleziona il pulsante **Run (Esegui)** e confronta gli output.

   ```
   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:
   ```

## Fase 7: pulire
<a name="sample-go-clean-up"></a>

Per evitare addebiti continui sul tuo AWS account dopo aver utilizzato questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).