Prerequisiti Fase 1: installare gli strumenti necessari Passaggio 2 (opzionale): installa il. NETCLIestensione per le funzioni Lambda Fase 3: Creare un. NETprogetto di applicazione per console Fase 4: aggiungere un codice Fase 5: costruire ed eseguire il codice Passaggio 6: creare e configurare un. NETprogetto di applicazione per console che utilizza il AWS SDK for .NET Fase 7: Aggiungere codice AWS SDK Fase 8: Compilare ed eseguire il AWS SDK codice Fase 9: Pulizia

. NETtutorial per AWS Cloud9

Questo tutorial ti consente di eseguirne alcuni. NETcodice in un ambiente di AWS Cloud9 sviluppo.

Seguire questo tutorial e creare questo esempio potrebbe comportare addebiti sul tuo AWS account. Questi includono eventuali addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta i prezzi di Amazon e EC2 i prezzi di Amazon S3.

Argomenti

Prerequisiti
Fase 1: installare gli strumenti necessari
Passaggio 2 (opzionale): installa il. NETCLIestensione per le funzioni Lambda
Fase 3: Creare un. NETprogetto di applicazione per console
Fase 4: aggiungere un codice
Fase 5: costruire ed eseguire il codice
Passaggio 6: creare e configurare un. NETprogetto di applicazione per console che utilizza il AWS SDK for .NET
Fase 7: Aggiungere codice AWS SDK
Fase 8: Compilare ed eseguire il AWS SDK codice
Fase 9: Pulizia

Prerequisiti

Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti:

È necessario disporre di un ambiente di AWS Cloud9 EC2 sviluppo esistente. Questo esempio presuppone che tu disponga già di un EC2 ambiente connesso a un'EC2istanza Amazon che esegue 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.
Il file AWS Cloud9 IDE per l'ambiente esistente è già aperto. Quando apri un ambiente, AWS Cloud9 apre il IDE relativo ambiente nel tuo browser web. Per ulteriori informazioni, consulta Apertura di un ambiente in AWS Cloud9.

Fase 1: installare gli strumenti necessari

In questo passaggio, si installa il. NETSDKnel proprio ambiente, necessario per eseguire questo esempio.

Verificare se la versione più recente di. NETSDKè già installato nel tuo ambiente. A tale scopo, in una sessione di terminale in AWS Cloud9 IDE, esegui il. NETInterfaccia principale a riga di comando (CLI) con l'--versionopzione.
```
dotnet --version
```
Se il. NETViene visualizzata la versione Command Line Tools e la versione è 2.0 o successiva, vai avanti aFase 3: Creare un. NETprogetto di applicazione per console. Se la versione è precedente alla 2.0 o se bash: dotnet: command not found viene visualizzato un errore simile, continua con l'installazione di. NETSDK.
Per Amazon Linux, in una sessione terminale in AWS Cloud9 IDE, esegui i seguenti comandi per garantire che siano installati gli aggiornamenti di sicurezza e le correzioni di bug più recenti e per installare un libunwind pacchetto che contenga il. NETSDKesigenze. Per avviare una nuova sessione del terminale, dalla barra dei menu seleziona Window (Finestra), New Terminal (Nuovo terminale).
```
sudo yum -y update
sudo yum -y install libunwind
```
Per Ubuntu Server, in una sessione di terminale in AWS Cloud9 IDE, esegui il seguente comando per garantire che siano installati gli ultimi aggiornamenti di sicurezza e le correzioni dei bug. Per avviare una nuova sessione del terminale, dalla barra dei menu seleziona Window (Finestra), New Terminal (Nuovo terminale).
```
sudo apt -y update
```
Scarica il. NETSDKscript di installazione nel tuo ambiente eseguendo il comando seguente.
```
wget https://dot.net/v1/dotnet-install.sh
```
Rendi lo script del programma di installazione eseguibile dall'utente corrente mediante il comando seguente.
```
sudo chmod u=rx dotnet-install.sh
```
Esegui lo script di installazione, che scarica e installa. NETSDK, eseguendo il comando seguente.
```
./dotnet-install.sh -c Current
```
Aggiungere il. NETSDKal tuoPATH. A questo proposito, nel profilo della shell per l'ambiente (ad esempio, il file .bashrc), aggiungi la sottodirectory $HOME/.dotnet alla variabile PATH per l'ambiente, come descritto di seguito.
1. Apri il file .bashrc per la modifica utilizzando il comando vi .
```
vi ~/.bashrc
```
2. Per Amazon Linux, l'utilizzo del tasto freccia Giù o j consente di spostarsi sulla riga che inizia con export PATH.
  
  Per Ubuntu Server, è possibile spostarsi sull'ultima riga del file digitando G.
3. Utilizzando il tasto freccia Destra o $, spostati al termine di quella riga.
4. Passa alla modalità di inserimento premendo il tasto i (-- INSERT --- apparirà in fondo allo schermo).
5. Per Amazon Linux, aggiungi la sottodirectory $HOME/.dotnet alla variabile PATH digitando :$HOME/.dotnet. Assicurati di includere il carattere di due punti (:). La riga dovrebbe essere ora simile alla seguente.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
  Per Ubuntu Server, premi il tasto freccia Destra, quindi Enter due volte e digita la riga seguente alla fine del file.
```
export PATH=$HOME/.dotnet:$PATH
```
6. Salvare il file. Per eseguire questa operazione, premi il tasto Esc (-- INSERT --- scomparirà dalla parte bassa dello schermo), scrivi :wq (per scrivere e quindi uscire dal file), quindi premi Enter.
Carica il. NETSDKreperendo il .bashrc file.
```
. ~/.bashrc
```
Conferma il. NETSDKviene caricato eseguendo. NETCLIcon l'--helpopzione.
```
dotnet --help
```
In caso di successo, il. NETSDKviene visualizzato il numero di versione, con informazioni aggiuntive sull'utilizzo.
Se non desideri più conservare il. NETSDKlo script di installazione nel proprio ambiente, è possibile eliminarlo come segue.
```
rm dotnet-install.sh
```

Passaggio 2 (opzionale): installa il. NETCLIestensione per le funzioni Lambda

Sebbene non sia richiesta per questo tutorial, puoi distribuire AWS Lambda funzioni e AWS Serverless Application Model applicazioni utilizzando. NETCLIse installi anche il Amazon.Lambda.Tools pacchetto.

Per installare il pacchetto, esegui il comando seguente:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Ora imposta la variabile di ambiente PATH e DOTNET_ROOT in modo che punti allo strumento Lambda installato. Nel file .bashrc individua la sezione export PATH e modificala in modo che appaia simile a quanto segue (vedi Fase 1 per i dettagli sulla modifica di questo file):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```

Fase 3: Creare un. NETprogetto di applicazione per console

In questo passaggio, si utilizza. NETper creare un progetto denominatohello. Questo progetto contiene tutti i file che. NETdeve eseguire una semplice applicazione dal terminale inIDE. Il codice dell'applicazione è scritto in C#.

Crea un. NETprogetto di applicazione per console. Per fare ciò, esegui il. NETCLIcon il newcomando, specificando il tipo di modello di progetto dell'applicazione console e il linguaggio di programmazione da utilizzare (in questo esempio, C#).

L'opzione -n indica che il progetto viene emesso in una nuova directory, hello. Passiamo quindi a tale directory.


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

Il comando precedente aggiunge una sottodirectory denominata obj con vari file e alcuni file autonomi aggiuntivi alla directory hello. Devi prendere nota dei seguenti due file di chiave:

Il file hello/hello.csproj contiene informazioni sul progetto di applicazione della console.
Il file hello/Program.cs contiene il codice dell'applicazione da eseguire.

Fase 4: aggiungere un codice

In questa fase, aggiungi del codice all'applicazione.

Dalla finestra Ambiente di AWS Cloud9 IDE, apri il hello/Program.cs file.

Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file 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);

    }
  }
}

Fase 5: costruire ed eseguire il codice

In questa fase è necessario creare il progetto e le relative dipendenze in un set di file binari, incluso un file eseguibile dell'applicazione. Quindi esegui l'applicazione.

NellaIDE, crea un generatore per. NETcome segue.
1. Sulla barra dei menu seleziona Run (Esegui), Build System (Compila sistema), New Build System (Nuovo sistema compilazione).
2. Nella scheda My Builder.build, sostituisci i contenuti della scheda con il seguente codice.
```
{
  "cmd" : ["dotnet", "build"],
  "info" : "Building..."
}
```
3. Selezionare File, Save As (File, Salva come).
4. In Filename (Nome file), digita .NET.build.
5. In Folder (Cartella), digita /.c9/builders.
6. Seleziona Salva.
Con il contenuto del Program.cs file visualizzato nell'editor, scegli Esegui, Crea sistema,. NET. Seleziona quindi Run, Build (Esegui, Crea).

Questo generatore aggiunge una sottodirectory denominata bin e aggiunge una sottodirectory denominata Debug alla sottodirectory hello/obj. Prendi nota dei seguenti tre file chiave.
- Il file hello/bin/Debug/netcoreapp3.1/hello.dll è il file eseguibile dell'applicazione.
- Il file hello/bin/Debug/netcoreapp3.1/hello.deps.json elenca le dipendenze dell'applicazione.
- Il file hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json specifica il runtime condiviso e la relativa versione per l'applicazione.
Nota
Il nome della cartellanetcoreapp3.1,, riflette la versione di. NETSDKutilizzato in questo esempio. Potresti visualizzare un numero diverso nel nome della cartella a seconda della versione installata.
Crea un runner per. NETcome segue.
1. Nella barra dei menu scegli Run, Run With, New Runner (Esegui, Esegui con, Nuova esecuzione).
2. Nella scheda My Runner.run, sostituisci i contenuti della scheda con il seguente codice.
```
{
  "cmd" : ["dotnet", "run", "$args"],
  "working_dir": "$file_path",
  "info" : "Running..."
}
```
3. Selezionare File, Save As (File, Salva come).
4. In Filename (Nome file), digita .NET.run.
5. In Folder (Cartella), digita /.c9/runners.
6. Seleziona Salva.
Esegui l'applicazione con due numeri interi da aggiungere (ad esempio, 5 e 9) come descritto di seguito.
1. Con i contenuti del file Program.cs visualizzati nell'editor, scegli Run, Run Configurations, New Run Configuration (Esegui, Configurazioni di esecuzione, Nuova configurazione di esecuzione).
2. Nella scheda [Nuovo] - Inattivo, scegli Runner: Auto, quindi scegli. NET.
3. Nella casella Command (Comando), digita hello 5 9.
4. Seleziona Esegui.
  
  Per impostazione predefinita, questo corridore istruisce. NETper eseguire il hello.dll file nella directory. hello/bin/Debug/netcoreapp3.1
  
  Confronta l'output con quanto segue.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```

Passaggio 6: creare e configurare un. NETprogetto di applicazione per console che utilizza il AWS SDK for .NET

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

In questo nuovo progetto, aggiungi un riferimento ad AWS SDK for .NET. AWS SDK for .NET Fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo. NETcodice. Quindi configuri la gestione AWS delle credenziali nel tuo ambiente. AWS SDK for .NET Ha bisogno di queste credenziali per interagire con AWS i servizi.

Per creare il progetto

Crea un. NETprogetto di applicazione per console. Per fare ciò, esegui il. NETCLIcon il newcomando, specificando il tipo di modello di progetto dell'applicazione console e il linguaggio di programmazione da utilizzare.

L'opzione -n indica che il progetto viene emesso in una nuova directory, s3. Passiamo quindi a tale directory.
```
dotnet new console -lang C# -n s3
cd s3
```
Aggiungi un riferimento di progetto al pacchetto Amazon S3 nell' AWS SDK for .NET. Per fare ciò, esegui il. NETCLIcon il add packagecomando, specificando il nome del pacchetto Amazon S3 in. NuGet (NuGetdefinisce la modalità di utilizzo dei pacchetti. NETvengono creati, ospitati e utilizzati e forniscono gli strumenti per ciascuno di questi ruoli.)
```
dotnet add package AWSSDK.S3
```
Quando aggiungi un riferimento al progetto al pacchetto Amazon S3, aggiunge NuGet anche un riferimento al progetto al resto del. AWS SDK for .NET

Nota
Per i nomi e le versioni di altri pacchetti AWS correlati in NuGet, consulta i NuGetpacchetti etichettati con aws-sdk sul sito Web. NuGet

Per configurare la gestione delle credenziali AWS

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

Per archiviare le credenziali nell'ambiente, segui le istruzioni riportate in Chiamata Servizi AWS da un ambiente in AWS Cloud9 e torna a questo argomento.

Per ulteriori informazioni, consulta Configurazione delle AWS credenziali nella Guida per gli sviluppatori.AWS SDK for .NET

Fase 7: Aggiungere codice AWS SDK

In questa fase si aggiunge il codice per interagire con Amazon S3 e creare un bucket, eliminare il bucket appena creato ed elencare i bucket disponibili.

Dalla finestra Ambiente di AWS Cloud9 IDE, apri il s3/Program.cs file. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file 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);
       }
      }
    }
  }
}

Fase 8: Compilare ed eseguire il AWS SDK codice

In questa fase è necessario creare il progetto e le relative dipendenze in un set di file binari, incluso un file eseguibile dell'applicazione. Quindi esegui l'applicazione.

Compilare il progetto. Per eseguire questa operazione con i contenuti del file s3/Program.cs visualizzati nell'editor, sulla barra dei menu scegli Run, Build (Esegui, Crea).
Esegui l'applicazione con il nome del bucket Amazon S3 da creare e l'ID della regione AWS in cui creare il bucket (ad esempio my-test-bucket e us-east-2) come descritto di seguito.
1. Con i contenuti del file s3/Program.cs ancora visualizzati nell'editor, scegli Run, Run Configurations, New Run Configuration (Esegui, Configurazioni di esecuzione, Nuova configurazione di esecuzione).
2. Nella scheda [Nuovo] - Inattivo, scegli Runner: Auto, quindi scegli. NET.
3. Nella casella Comando, digita il nome dell'applicazione, il nome del bucket Amazon S3 da creare e l'ID della AWS regione in cui creare il bucket (ad esempio,). s3 my-test-bucket us-east-2
4. Seleziona Esegui.
  
  Per impostazione predefinita, questo runner istruisce. NETper eseguire il s3.dll file nella directory. s3/bin/Debug/netcoreapp3.1
  
  Confronta i tuoi risultati con il seguente output.
```
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:
```

Fase 9: Pulizia

Per evitare addebiti continui AWS sul tuo account dopo aver utilizzato questo esempio, dovresti eliminare l'ambiente. Per istruzioni, consultare Eliminazione di un ambiente in AWS Cloud9.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Tutorial di Python

Tutorial Node.js