La version 4 (V4) du SDK pour .NET est en avant-première ! Pour obtenir des informations sur cette nouvelle version en avant-première, consultez le guide du développeur AWS SDK pour .NET (version 4).
Veuillez noter que la version V4 du SDK est en cours de prévisualisation, son contenu est donc sujet à modification.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Octroi d'accès à l'aide d'un rôle IAM
Ce didacticiel explique comment utiliser le SDK pour .NET pour activer les rôles IAM sur les EC2 instances Amazon.
Présentation
Toutes les demandes AWS doivent être signées cryptographiquement à l'aide des informations d'identification émises par AWS. Par conséquent, vous avez besoin d'une stratégie pour gérer les informations d'identification des applications qui s'exécutent sur EC2 des instances Amazon. Vous devez distribuer, stocker et faire pivoter ces informations d'identification en toute sécurité, mais également les garder accessibles aux applications.
Les rôles IAM vous permettent de gérer efficacement ces informations d'identification. Vous créez un rôle IAM et vous le configurez avec les autorisations requises par une application, puis vous attachez ce rôle à une EC2 instance. Pour en savoir plus sur les avantages de l'utilisation des rôles IAM, consultez la section Rôles IAM pour Amazon EC2 dans le guide de EC2 l'utilisateur Amazon. Consultez également les informations sur les rôles IAM dans le guide de l'utilisateur IAM.
Pour une application créée à l'aide du SDK pour .NET, lorsque l'application construit un objet client pour un AWS service, l'objet recherche des informations d'identification provenant de plusieurs sources potentielles. L'ordre dans lequel la recherche est effectué est indiqué dansRésolution des informations d'identification et des profils.
Si l'objet client ne trouve pas d'informations d'identification provenant d'une autre source, il récupère des informations d'identification temporaires dotées des mêmes autorisations que celles qui ont été configurées dans le rôle IAM et qui figurent dans les métadonnées de l' EC2 instance. Ces informations d'identification sont utilisées pour effectuer des appels AWS depuis l'objet client.
À propos de ce didacticiel
Au fur et à mesure que vous suivez ce didacticiel, vous utilisez le SDK pour .NET (et d'autres outils) pour lancer une EC2 instance Amazon avec un rôle IAM attaché, puis vous verrez une application sur l'instance utilisant les autorisations du rôle IAM.
Rubriques
Création d'un exemple d'application Amazon S3
Cet exemple d'application récupère un objet depuis Amazon S3. Pour exécuter l'application, vous avez besoin des éléments suivants :
-
Un compartiment Amazon S3 contenant un fichier texte.
-
AWS informations d'identification sur votre machine de développement qui vous permettent d'accéder au bucket.
Pour plus d'informations sur la création d'un compartiment Amazon S3 et le téléchargement d'un objet, consultez le guide de l'utilisateur d'Amazon Simple Storage Service. Pour plus d'informations sur les AWS informations d'identification, consultezConfigurer l'authentification du SDK avec AWS.
Créez un projet .NET Core avec le code suivant. Testez ensuite l'application sur votre machine de développement.
Note
Sur votre machine de développement, le .NET Core Runtime est installé, ce qui vous permet d'exécuter l'application sans la publier. Lorsque vous créerez une EC2 instance ultérieurement dans ce didacticiel, vous pouvez choisir d'installer le .NET Core Runtime sur l'instance. Cela vous donne une expérience similaire et un transfert de fichiers plus réduit.
Toutefois, vous pouvez également choisir de ne pas installer le .NET Core Runtime sur l'instance. Si vous choisissez cette option, vous devez publier l'application afin que toutes les dépendances soient incluses lorsque vous la transférez vers l'instance.
NuGet colis :
Éléments de programmation :
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
namespace S3GetTextItem
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to retrieve a text file from an S3 bucket and write it to a local file
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string bucket =
CommandLine.GetArgument(parsedArgs, null, "-b", "--bucket-name");
string item =
CommandLine.GetArgument(parsedArgs, null, "-t", "--text-object");
string outFile =
CommandLine.GetArgument(parsedArgs, null, "-o", "--output-filename");
if( string.IsNullOrEmpty(bucket)
|| string.IsNullOrEmpty(item)
|| string.IsNullOrEmpty(outFile))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the S3 client object and get the file object from the bucket.
var response = await GetObject(new AmazonS3Client(), bucket, item);
// Write the contents of the file object to the given output file.
var reader = new StreamReader(response.ResponseStream);
string contents = reader.ReadToEnd();
using (var s = new FileStream(outFile, FileMode.Create))
using (var writer = new StreamWriter(s))
writer.WriteLine(contents);
}
//
// Method to get an object from an S3 bucket.
private static async Task<GetObjectResponse> GetObject(
IAmazonS3 s3Client, string bucket, string item)
{
Console.WriteLine($"Retrieving {item} from bucket {bucket}.");
return await s3Client.GetObjectAsync(bucket, item);
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: S3GetTextItem -b <bucket-name> -t <text-object> -o <output-filename>" +
"\n -b, --bucket-name: The name of the S3 bucket." +
"\n -t, --text-object: The name of the text object in the bucket." +
"\n -o, --output-filename: The name of the file to write the text to.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary<string,string> Parse(string[] args)
{
var parsedArgs = new Dictionary<string,string>();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary<string,string> parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
Si vous le souhaitez, vous pouvez supprimer temporairement les informations d'identification que vous utilisez sur votre machine de développement pour voir comment l'application répond. (Mais assurez-vous de restaurer les informations d'identification lorsque vous aurez terminé.)
Créer un rôle IAM
Créez un rôle IAM doté des autorisations appropriées pour accéder à Amazon S3.
-
Ouvrez la console IAM
. -
Dans le volet de navigation, choisissez Rôles, puis Create Role.
-
Sélectionnez le AWS service, recherchez et choisissez EC2, puis cliquez sur Suivant : Autorisations.
-
Sous Joindre les politiques d'autorisation, recherchez et sélectionnez AmazonS3 ReadOnlyAccess. Passez en revue la politique si vous le souhaitez, puis choisissez Next : Tags.
-
Ajoutez des balises si vous le souhaitez, puis choisissez Suivant : Révision.
-
Tapez un nom et une description pour le rôle, puis choisissez Créer un rôle. N'oubliez pas ce nom car vous en aurez besoin lorsque vous lancerez votre EC2 instance.
Lancer une EC2 instance et associer le rôle IAM
Lancez une EC2 instance avec le rôle IAM que vous avez créé précédemment. Vous pouvez le faire de différentes manières.
-
Utilisation de la EC2 console
Pour lancer une instance à l'aide de la EC2 console, consultez Lancer une instance à l'aide du nouvel assistant de lancement d'instance dans le guide de EC2 l'utilisateur Amazon.
Lorsque vous parcourez la page de lancement, vous devez au moins développer le volet Détails avancés afin de pouvoir spécifier le rôle IAM que vous avez créé précédemment dans le profil d'instance IAM.
-
À l'aide du SDK pour .NET
Pour plus d'informations à ce sujetLancement d'une EC2 instance Amazon, voir, y compris la Considérations supplémentaires fin de cette rubrique.
Pour lancer une EC2 instance à laquelle un rôle IAM est attaché, la configuration d'un utilisateur IAM doit inclure certaines autorisations. Pour plus d'informations sur les autorisations requises, consultez la section Accorder à un utilisateur l'autorisation de transmettre un rôle IAM à une instance dans le guide de l' EC2 utilisateur Amazon.
Connect à l' EC2 instance
Connectez-vous à l' EC2 instance afin de pouvoir y transférer l'exemple d'application, puis exécuter l'application. Vous aurez besoin du fichier contenant la partie privée de la paire de clés que vous avez utilisée pour lancer l'instance, c'est-à-dire le fichier PEM.
Pour plus d'informations sur la connexion à une instance, consultez Connect to your Linux instance ou Connect to your Windows Instance dans le guide de EC2 l'utilisateur Amazon. Lorsque vous vous connectez, faites-le de manière à pouvoir transférer des fichiers de votre machine de développement vers votre instance.
Si vous utilisez Visual Studio sous Windows, vous pouvez également vous connecter à l'instance à l'aide du Toolkit for Visual Studio. Pour plus d'informations, consultez la section Connexion à une EC2 instance Amazon dans le guide de AWS Toolkit for Visual Studio l'utilisateur.
Exécutez l'exemple d'application sur l' EC2 instance
-
Copiez les fichiers d'application de votre disque local vers votre instance.
Les fichiers que vous transférez dépendent de la façon dont vous avez créé l'application et de l'installation du .NET Core Runtime sur votre instance. Pour plus d'informations sur le transfert de fichiers vers votre instance, consultez Connect to your Linux (voir la sous-section appropriée) ou Transférer des fichiers vers des instances Windows dans le guide de l' EC2 utilisateur Amazon.
-
Lancez l'application et vérifiez qu'elle s'exécute avec les mêmes résultats que sur votre machine de développement.
-
Vérifiez que l'application utilise les informations d'identification fournies par le rôle IAM.
-
Ouvrez la EC2 console Amazon
. -
Sélectionnez l'instance et détachez le rôle IAM via Actions, Paramètres de l'instance, Attacher/remplacer le rôle IAM.
-
Réexécutez l'application et vérifiez qu'elle renvoie une erreur d'autorisation.
-
Nettoyage
Lorsque vous aurez terminé ce didacticiel, et si vous ne souhaitez plus utiliser l' EC2 instance que vous avez créée, veillez à mettre fin à l'instance pour éviter des coûts inutiles. Vous pouvez le faire dans la EC2 console Amazon