Prérequis Étape 1 : Installer les outils requis Étape 2 (facultative) : Installer l'extension .NET CLI pour les fonctions Lambda Étape 3 : Création d'un projet d'application de console .NET Étape 4 : Ajouter du code Étape 5 : Créer et exécuter le code Étape 6 : créer et configurer un projet d'application de console .NET qui utiliseAWS SDK for .NET Étape 7 : Ajouter du code SDK AWS Étape 8 : Générer et exécuter le code du kit SDK AWS Étape 9 : Nettoyer

Tutoriel .NET pourAWS Cloud9

Ce didacticiel vous permet d'exécuter du code .NET dans unAWS Cloud9environnement de développement.

Le suivi de ce didacticiel et la création de cet exemple peuvent entraîner des frais pour votreAWScompte. Il peut s'agir de frais pour des services tels qu'Amazon EC2 et Amazon S3. Pour en savoir plus, consultez les sections Tarification Amazon EC2 et Tarification Amazon S3.

Rubriques

Prérequis
Étape 1 : Installer les outils requis
Étape 2 (facultative) : Installer l'extension .NET CLI pour les fonctions Lambda
Étape 3 : Création d'un projet d'application de console .NET
Étape 4 : Ajouter du code
Étape 5 : Créer et exécuter le code
Étape 6 : créer et configurer un projet d'application de console .NET qui utiliseAWS SDK for .NET
Étape 7 : Ajouter du code SDK AWS
Étape 8 : Générer et exécuter le code du kit SDK AWS
Étape 9 : Nettoyer

Prérequis

Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes :

Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant. Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour plus d'informations, veuillez consulter Création d'un environnement dans AWS Cloud9.
L'IDE AWS Cloud9 correspondant à l'environnement existant est déjà ouvert. Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE associé à cet environnement dans votre navigateur web. Pour plus d'informations, veuillez consulter Ouverture d'un environnement dans AWS Cloud9.

Étape 1 : Installer les outils requis

Au cours de cette étape, vous allez installer le SDK .NET dans votre environnement, qui est nécessaire pour exécuter cet exemple.

Vérifiez si la dernière version du SDK .NET est déjà installée dans votre environnement. Pour ce faire, dans une séance de terminal de l'IDE AWS Cloud9, exécutez l'interface de ligne de commande (CLI) .NET Core avec l'option --version .
```
dotnet --version
```
Si la version des outils de ligne de commande .NET s'affiche, et s'il s'agit de la version 2.0 ou ultérieure, passez directement à Étape 3 : Création d'un projet d'application de console .NET. Si la version est inférieure à 2.0, ou si une erreur telle quebash: dotnet: command not founds'affiche, poursuivez l'installation du SDK .NET.
Pour Amazon Linux, lors d'une session de terminal dansAWS Cloud9IDE, exécutez les commandes suivantes pour vous assurer que les dernières mises à jour de sécurité et corrections de bogues sont installées, et pour installer unlibunwindpackage dont le SDK .NET a besoin. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez Fenêtre, nouveau terminal).)
```
sudo yum -y update
sudo yum -y install libunwind
```
Pour Ubuntu Server, dans une séance de terminal de l'IDE AWS Cloud9, exécutez la commande suivante afin d'être sûr que les mises à jour de sécurité et les correctifs les plus récents sont installés. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez Fenêtre, nouveau terminal.)
```
sudo apt -y update
```
Téléchargez le script d'installation du SDK .NET dans votre environnement en exécutant la commande suivante.
```
wget https://dot.net/v1/dotnet-install.sh
```
Autorisez l'exécution du script d'installation par l'utilisateur actuel en exécutant la commande suivante.
```
sudo chmod u=rx dotnet-install.sh
```
Exécutez le script d'installation, qui télécharge et installe le SDK .NET, en exécutant la commande suivante.
```
./dotnet-install.sh -c Current
```
Ajoutez le SDK .NET à votrePATH. Pour ce faire, dans le profil shell de l'environnement (par exemple, le fichier .bashrc), ajoutez le sous-répertoire $HOME/.dotnet à la variable PATH de l'environnement, comme suit.
1. Ouvrez le fichier .bashrc à modifier à l'aide de la commande vi.
```
vi ~/.bashrc
```
2. Pour Amazon Linux, à l'aide de la flèche vers le bas ou de la touche j, passez à la ligne qui commence par export PATH.
  
  Pour Ubuntu Server, passez à la dernière ligne du fichier en tapant G.
3. À l'aide de la flèche vers la droite ou de la touche $, passez à la fin de la ligne.
4. Basculer en mode insertion en appuyant sur la i touche. (-- INSERT --- s'affiche à la fin de l'affichage.)
5. Pour Amazon Linux, ajoutez le sous-répertoire $HOME/.dotnet à la variable PATH en tapant :$HOME/.dotnet. Veillez à inclure le caractère deux-points (:). La ligne doit ressembler à ce qui suit.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
  Pour Ubuntu Server, appuyez sur la touche flèche droite, puis appuyez deux fois sur Enter et saisissez la ligne suivante seule à la fin du fichier.
```
export PATH=$HOME/.dotnet:$PATH
```
6. Sauvegardez le fichier. Pour ce faire, appuyez sur la touche Esc (-- INSERT --- disparaît de la fin de l'affichage), tapez :wq (pour écrire sur le fichier, puis le quitter), puis appuyez sur Enter.
Chargez le SDK .NET en vous procurant.bashrcfichier.
```
. ~/.bashrc
```
Vérifiez que le SDK .NET est chargé en exécutant .NET CLI avec --help option.
```
dotnet --help
```
En cas de réussite, le numéro de version du SDK .NET est affiché, avec des informations d'utilisation supplémentaires.
Si vous ne souhaitez plus conserver le script d'installation du SDK .NET dans votre environnement, vous pouvez le supprimer comme suit.
```
rm dotnet-install.sh
```

Étape 2 (facultative) : Installer l'extension .NET CLI pour les fonctions Lambda

Bien que cela ne soit pas obligatoire pour ce didacticiel, vous pouvez déployerAWS Lambdafonctions etAWS Serverless Application Modelapplications utilisant l'interface de ligne de commande .NET si vous installez égalementAmazon.Lambda.Toolscolis.

Pour installer le paquet, exécutez la commande suivante :
```
dotnet tool install -g Amazon.Lambda.Tools
```
Maintenant, définissez le PATH et la variable d'environnement DOTNET_ROOT pour pointer vers l'outil Lambda installé. Dans le fichier .bashrc, recherchez la section export PATH et modifiez-la pour qu'elle apparaisse comme suit (reportez-vous à l'Étape 1 pour plus de détails sur la modification de ce fichier) :
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```

Étape 3 : Création d'un projet d'application de console .NET

Au cours de cette étape, vous utilisez .NET pour créer un projet nomméhello. Ce projet contient tous les fichiers dont .NET a besoin pour exécuter une application simple depuis le terminal dans l'IDE. Le code de l'application est écrit en C#.

Créez un projet d'application de console .NET. Pour ce faire, exécutez l'interface de ligne de commande .NET avec new commande, spécifiant le type de modèle de projet d'application console et le langage de programmation à utiliser (dans cet exemple, C#).

L'option -n indique que le projet est publié dans un nouveau répertoire, hello. Puis accédez à ce répertoire.


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

La commande précédente ajoute un sous-répertoire nommé obj avec plusieurs fichiers, et certains fichiers autonomes supplémentaires, dans le répertoire hello. Notez les deux fichiers clés suivants :

Le fichier hello/hello.csproj contient des informations sur le projet d'application console.
Le fichier hello/Program.cs contient le code de l'application à exécuter.

Étape 4 : Ajouter du code

Dans cette étape, vous ajoutez du code à l'application.

Depuis la fenêtre Environnement de l'IDE AWS Cloud9, ouvrez le fichier hello/Program.cs.

Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier 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);

    }
  }
}

Étape 5 : Créer et exécuter le code

Au cours de cette étape, vous allez créer le projet et ses dépendances dans un ensemble de fichiers binaires, y compris un fichier d'application exécutable. Ensuite, vous exécutez l'application.

Dans l'IDE, créez un générateur pour .NET comme suit.
1. Dans la barre de menu, choisissez Exécuter, Système de création, nouveau système de création).
2. Sous l'onglet My Builder.build, remplacez le contenu de l'onglet par le code suivant.
```
{
  "cmd" : ["dotnet", "build"],
  "info" : "Building..."
}
```
3. Choisissez Fichier, Enregistrer sous).
4. Pour Filename (Nom de fichier), tapez .NET.build.
5. Pour Folder (Dossier), tapez /.c9/builders.
6. Choisissez Save (Enregistrer).
Avec le contenu duProgram.csfichier affiché sous l'éditeur, choisissezExécuter, créer un système, .NET. Pui, choisissez Run, Build (Exécuter, Build).

Ce générateur ajoute un sous-répertoire nommé bin, ainsi qu'un sous-répertoire nommé Debug, au sous-répertoire hello/obj. Notez les trois fichiers clés suivants.
- Le fichier hello/bin/Debug/netcoreapp3.1/hello.dll est le fichier exécutable de l'application.
- Le fichier hello/bin/Debug/netcoreapp3.1/hello.deps.json répertorie les dépendances de l'application.
- Le fichier hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json spécifie le runtime partagé et sa version pour l'application.
Note
Le nom du dossier,netcoreapp3.1, reflète la version du SDK .NET utilisée dans cet exemple. Vous pouvez voir un numéro différent dans le nom du dossier en fonction de la version que vous avez installée.
Créez un runner pour .NET comme suit.
1. Dans la barre de menus, choisissez Run, Run With, New Runner (Exécuter, Exécuter avec, Nouvel exécuteur).
2. Sous l'onglet My Runner.run, remplacez le contenu de l'onglet par le code suivant.
```
{
  "cmd" : ["dotnet", "run", "$args"],
  "working_dir": "$file_path",
  "info" : "Running..."
}
```
3. Choisissez Fichier, Enregistrer sous).
4. Pour Filename (Nom de fichier), tapez .NET.run.
5. Pour Folder (Dossier), tapez /.c9/runners.
6. Choisissez Save (Enregistrer).
Exécutez l'application avec deux nombres entiers à ajouter (par exemple, 5 et 9) comme suit.
1. Avec le contenu du fichier Program.cs affiché dans l'éditeur, choisissez Run, Run Configurations, New Run Configuration (Exécuter, Configurations d'exécution, Nouvelle configuration d'exécution).
2. Dans le[Nouveau] - Inactifonglet, choisissezRunner : Auto, puis choisissez.NET.
3. Dans la zone Command (Commande), entrez hello 5 9.
4. Cliquez sur Run (Exécuter).
  
  Par défaut, cet exécuteur demande à .NET d'exécuter lehello.dllfichier dans lehello/bin/Debug/netcoreapp3.1annuaire.
  
  Comparez le résultat obtenu avec ce qui suit.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```

Étape 6 : créer et configurer un projet d'application de console .NET qui utiliseAWS SDK for .NET

Vous pouvez améliorer cet exemple afin d'utiliser le kit AWS SDK for .NET pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer.

Dans ce nouveau projet, vous ajoutez une référence au kit AWS SDK for .NET. Le kit AWS SDK for .NET permet d'interagir facilement avec les services AWS, tels qu'Amazon S3, à partir de votre code .NET. Vous pouvez ensuite configurer la gestion des informations d'identification AWS dans votre environnement. Le kit AWS SDK for .NET a besoin de ces informations d'identification pour interagir avec les services AWS.

Pour créer le projet

Créez un projet d'application de console .NET. Pour ce faire, exécutez l'interface de ligne de commande .NET avec new commande, spécifiant le type de modèle de projet d'application console et le langage de programmation à utiliser.

L'option -n indique que le projet est publié dans un nouveau répertoire, s3. Puis accédez à ce répertoire.
```
dotnet new console -lang C# -n s3
cd s3
```
Ajoutez une référence de projet au paquet Amazon S3 dans le AWS SDK for .NET. Pour ce faire, exécutez l'interface de ligne de commande .NET avec add package commande, spécifiant le nom du package Amazon S3 dansNuGet. (NuGetdéfinit la façon dont les packages pour .NET sont créés, hébergés et consommés, et fournit les outils pour chacun de ces rôles.)
```
dotnet add package AWSSDK.S3
```
Lorsque vous ajoutez une référence de projet au package Amazon S3,NuGetajoute également une référence de projet au reste duAWS SDK for .NET.

Note
Pour les noms et les versions d'autresAWSpackages associés dansNuGet, voirNuGetpaquets étiquetés avec aws-sdksur leNuGetsite Web.

Pour configurer la gestion des informations d'identification AWS

Chaque fois que vous utilisez le kit AWS SDK for .NET pour appeler un service AWS, vous devez fournir un ensemble d'informations d'identification AWS avec l'appel. Ces informations d'identification déterminent si le kit AWS SDK for .NET possède les autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue.

Pour stocker vos informations d'identification au sein de l'environnement, suivez les instructions fournies dans la rubrique Appel des services AWS à partir d'un environnement dans AWS Cloud9, puis revenez à cette rubrique.

Pour plus d'informations, consultez Configuration des informations d'identification AWS dans le Guide du développeur AWS SDK for .NET.

Étape 7 : Ajouter du code SDK AWS

Au cours de cette étape, vous allez ajouter du code pour interagir avec Amazon S3 et créer un compartiment, supprimer le compartiment que vous venez de créer et répertorier les compartiments disponibles.

Depuis la fenêtre Environnement de l'IDE AWS Cloud9, ouvrez le fichier s3/Program.cs. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier 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);
       }
      }
    }
  }
}

Étape 8 : Générer et exécuter le code du kit SDK AWS

Au cours de cette étape, vous allez créer le projet et ses dépendances dans un ensemble de fichiers binaires, y compris un fichier d'application exécutable. Ensuite, vous exécutez l'application.

Générez le projet. Pour ce faire, avec le contenu du fichier s3/Program.cs affiché dans l'éditeur, dans la barre de menu, choisissez Run, Build (Exécuter, Build).
Exécutez l'application avec le nom du compartiment Amazon S3 à créer et l'ID de la région AWS dans laquelle créer le compartiment (par exemple my-test-bucket et us-east-2) comme suit.
1. Avec le contenu du fichier s3/Program.cs toujours affiché dans l'éditeur, choisissez Run, Run Configurations, New Run Configuration (Exécuter, Configurations d'exécution, Nouvelle configuration d'exécution).
2. Dans le[Nouveau] - Inactifonglet, choisissezRunner : Auto, puis choisissez.NET.
3. Dans la zone Commande, entrez le nom de l'application, le nom du compartiment Amazon S3 à créer et l'ID de la région AWS dans laquelle créer le compartiment (par exemple s3 my-test-bucket us-east-2).
4. Cliquez sur Run (Exécuter).
  
  Par défaut, cet exécuteur demande à .NET d'exécuter les3.dllfichier dans les3/bin/Debug/netcoreapp3.1annuaire.
  
  Comparez le résultat obtenu à la sortie suivante.
```
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:
```

Étape 9 : Nettoyer

Afin d'éviter des frais permanents sur votre compte AWS une fois que vous avez fini d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, consultez Suppression d'un environnement dans AWS Cloud9.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Tutoriel Python

Tutoriel Node.js