Kit AWS SDKpour .NET (version 3)

Manuel du développeur:

Kit AWS SDK pour .NET (version 3): Manuel du développeur:Copyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

Table of Contents....................................................................................................................................................... vi

Présentation de Kit AWS SDK pour .NET ............................................................................................... 1Outils AWS associés au SDK ....................................................................................................... 1

Outils pour Windows PowerShell et Outils pour PowerShell Core ............................................... 1Toolkit pour VS Code .......................................................................................................... 1Toolkit for Visual Studio ....................................................................................................... 1Toolkit pour Azure DevOps .................................................................................................. 2

Version 3.5 du kit Kit AWS SDK pour .NET .................................................................................... 2Comment utiliser ce manuel ......................................................................................................... 2Services pris en charge et historique des révisions .......................................................................... 3Ressources supplémentaires ........................................................................................................ 3

Démarrage rapide ............................................................................................................................... 5Application multiplateforme simple ................................................................................................. 5

Steps ................................................................................................................................ 5Configuration pour ce didacticiel ........................................................................................... 5Création du projet ............................................................................................................... 7Créer le code ..................................................................................................................... 7Exécutez l'application .......................................................................................................... 9Nettoyage .......................................................................................................................... 9Étapes suivantes ................................................................................................................ 9

Application simple basée sur Windows ......................................................................................... 10Steps .............................................................................................................................. 10Configuration pour ce didacticiel .......................................................................................... 10Création du projet ............................................................................................................. 11Créer le code ................................................................................................................... 12Exécutez l'application ........................................................................................................ 13Nettoyage ........................................................................................................................ 14Étapes suivantes .............................................................................................................. 14

Étapes suivantes ...................................................................................................................... 14Configuration de ............................................................................................................................... 15

Créer un compte AWS et des informations d'identification ............................................................... 15Installer et configurer votre chaîne d’outils .................................................................................... 15

Développement multiplateforme ........................................................................................... 16Windows avec Visual Studio et.NET Core ............................................................................ 16

Installer des assemblies AWSSDK .............................................................................................. 16Installation des packages AWSSDK avec NuGet ................................................................... 17Télécharger et extraire des fichiers ZIP ................................................................................ 18Installation de l'Kit AWS SDK pour .NET sur Windows ............................................................ 19

Démarrer un nouveau projet ....................................................................................................... 19Plateformes prises en charge par le Kit AWS SDK pour .NET .......................................................... 20

.NET Core ....................................................................................................................... 20

.NET Framework 4.5 ......................................................................................................... 20

.NET Framework 3.5 ......................................................................................................... 20Bibliothèque de classes portable ......................................................................................... 20Prise en charge d'Unity ...................................................................................................... 21Plus d'informations ............................................................................................................ 21

Programmation avec le kit SDK .......................................................................................................... 22Configuration de votre application ................................................................................................ 22

Configuration du Kit AWS SDK pour .NET avec .NET Core ...................................................... 23Configuration des informations d'identification AWS ................................................................ 26Sélection d'une région AWS ............................................................................................... 35Configuration d'autres paramètres de l'application .................................................................. 37Référence aux fichiers de configuration pour le Kit AWS SDK pour .NET ................................... 42Activation des Métriques SDK ............................................................................................ 51

iii

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

API asynchrones ....................................................................................................................... 55API asynchrone pour .NET Framework 4.5, Windows Store et Windows Phone 8 ........................ 55API asynchrone pour .NET Framework 3.5 ............................................................................ 56

Nouvelles tentatives et délais d’expiration ..................................................................................... 63Retries ............................................................................................................................ 63Timeouts ......................................................................................................................... 65Example .......................................................................................................................... 65

Paginators ............................................................................................................................... 66Migration vers la version 3 ......................................................................................................... 66

À propos des versions du Kit AWS SDK pour .NET ................................................................ 66Refonte de l'architecture du kit SDK .................................................................................... 66Évolutions ........................................................................................................................ 66

Migration vers la version 3.5 ....................................................................................................... 68Migration à partir de .NET Standard 1.3 ....................................................................................... 68

Exemples de code ............................................................................................................................ 69Affichage des ressources AWS à l’aide de AWS CloudFormation .................................................... 69Authentification d'utilisateurs avec Amazon Cognito ........................................................................ 70

Fournisseur d'informations d'identification Amazon Cognito ..................................................... 71Exemples de la bibliothèque d'extensions Amazon CognitoAuthentication .................................. 72

Utilisation des bases de données NoSQL Amazon DynamoDB ........................................................ 76Modèle de bas niveau ....................................................................................................... 76Modèle de document ......................................................................................................... 79Modèle de persistance des objets ....................................................................................... 80Plus d'informations ............................................................................................................ 81Utilisation d'expressions avec Amazon DynamoDB et le kit Kit AWS SDK pour .NET .................... 82Prise en charge de JSON dans Amazon DynamoDB avec le kit Kit AWS SDK pour .NET .............. 92Gestion de l'état d'une session ASP.NET avec Amazon DynamoDB ......................................... 93

Déploiement d'applications avec Amazon EC2 .............................................................................. 96Exemples d'instances Amazon EC2 ..................................................................................... 97Exemples d'instances ponctuelles Amazon EC2 ................................................................... 115

Stockage de données d'archives avec Amazon S3 Glacier ............................................................ 123Modèles de programmation .............................................................................................. 123

Gestion des utilisateurs avec AWS IAM ...................................................................................... 126Gestion des alias IAM ...................................................................................................... 126Gestion des utilisateurs IAM ............................................................................................ 128Gestion des clés d'accès IAM .......................................................................................... 131Utilisation des stratégies IAM ........................................................................................... 135Utilisation des certificats de serveur IAM ............................................................................ 138Lister des informations de compte IAM ............................................................................... 141Octroi d'accès à l'aide d'un rôle IAM. ................................................................................. 142

Utilisation des clés KMS pour le chiffrement S3 ........................................................................... 146Gestion des ressources du système de noms de domaine (DNS) à l'aide d'Amazon Route 53 .............. 148Utilisation du stockage Internet Amazon Simple Storage Service .................................................... 153Envoi de notifications depuis le cloud avec Amazon Simple Notification Service ................................ 153

Liste de vos rubriques Amazon SNS .................................................................................. 153Envoi d'un message à une rubrique Amazon SNS ................................................................ 154Envoi d'un SMS à un numéro de téléphone ........................................................................ 155

Messagerie avec Amazon SQS ................................................................................................. 156Création d'un client Amazon SQS ..................................................................................... 157Création d'une file d'attente Amazon SQS .......................................................................... 158Construire Amazon SQS URL de file d’attente .................................................................... 158Envoi d’un Amazon SQS Message ................................................................................... 159Envoi d’un Amazon SQS Lot de messages ........................................................................ 159Réception d’un message à partir d’un Amazon SQS File d’attente .......................................... 160Suppression d’un message d’un Amazon SQS File d’attente ................................................. 161Activation de l'attente active de longue durée dans Amazon SQS .......................................... 162Utilisation de Amazon SQS Files d’attente ......................................................................... 163

iv

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

Utilisation de Amazon SQS Files d’attente de lettres mortes .................................................. 165Surveillance de vos ressources AWS à l’aide d’ Amazon CloudWatch ............................................. 165

Description, création et suppression d’alarmes dans Amazon CloudWatch ............................... 166Utilisation des alarmes dans Amazon CloudWatch .............................................................. 168Obtention de métriques à partir d'Amazon CloudWatch ........................................................ 170Envoi d'événements à Amazon CloudWatch Events ............................................................. 171Utilisation des filtres d'abonnements dans Amazon CloudWatch Logs ..................................... 175

Programmation d'AWS OpsWorks pour utiliser les piles et applications ............................................ 177Prise en charge de programmation pour des services AWS supplémentaires .................................... 177

Sécurité ......................................................................................................................................... 178Protection des données ............................................................................................................ 178Identity and Access Management .............................................................................................. 179Compliance Validation .............................................................................................................. 179Resilience .............................................................................................................................. 180Infrastructure Security .............................................................................................................. 180Application de TLS 1.2 ............................................................................................................. 181

.NET Core ...................................................................................................................... 181

.NET Framework ............................................................................................................. 181Outils AWS pour PowerShell ............................................................................................ 182Xamarin ......................................................................................................................... 182Unity ............................................................................................................................. 183Navigateur (pour Blazor WebAssembly) .............................................................................. 183

Migration du client de chiffrement S3 ......................................................................................... 183Aperçu de la migration ..................................................................................................... 183Mettre à jour les clients existants vers les clients de transition V1 pour lire les nouveaux formats ... 184Migrer les clients de transition V1 vers les clients V2 pour écrire de nouveaux formats ................ 184Mettre à jour les clients V2 aux formats V1 de lecture ........................................................... 187

Historique du document ................................................................................................................... 188

v

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

Cette documentation concerne la version 3.0 du Kit AWS SDK pour .NET, qui est principalement centréautour de.NET Framework et ASP.NET 4.x, Windows et Visual Studio.

La dernière version de la documentation à l’adresse https://docs.aws.amazon.com/sdk-pour-net/dernière/guide-de-développeur/ est principalement centré sur.NET Core et ASP.NET Core. En plus de Windows etVisual Studio, il accorde la même importance au développement multiplateforme.

Si nous fournissons une traduction de la version anglaise du guide, la version anglaise du guide aurapréséance en cas de contradiction. La traduction sera une traduction automatique.

vi

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Outils AWS associés au SDK

Présentation de Kit AWS SDKpour .NET

Le Kit AWS SDK pour .NET permet de créer plus facilement des applications .NET qui exploitent desservices AWS rentables, évolutifs et fiables comme Amazon Simple Storage Service (Amazon S3) etAmazon Elastic Compute Cloud (Amazon EC2). Le kit Kit AWS SDK pour .NET prend en charge .NETFramework 3.5, .NET Framework 4.5, .NET Standard 2.0, la bibliothèque de classes portables, Xamarin etUnity.

Sauf indication contraire explicite, toutes les informations contenues dans le présent manuel s'appliquent àtoutes les cibles prises en charge.

(C’est parti ! Je suis prêt pour un du tutoriel (p. 5) ou pour commencer configuration (p. 15).)

Outils AWS associés au SDKOutils pour Windows PowerShell et Outils pourPowerShell CoreLes kits Outils AWS pour Windows PowerShell et Outils AWS pour PowerShell Core sont des modulesPowerShell qui reposent sur les fonctionnalités exposées par le kit Kit AWS SDK pour .NET. Les outilsAWS PowerShell vous permettent de scripter des opérations sur votre AWS à partir de l’invite PowerShell.Bien que les applets de commande soient implémentées à l'aide des méthodes et clients de service à partirdu SDK, les applets de commande fournissent une expérience PowerShell idiomatique pour spécifier lesparamètres et gérer les résultats.

Consultez Outils AWS pour Windows PowerShell pour commencer.

Toolkit pour VS CodeLe AWS Toolkit pour Visual Studio Code est un plugin pour l'éditeur de code Visual Studio (VS Code). Laboîte à outils facilite le développement, le débogage et le déploiement d'applications qui utilisent AWS.

Avec la boîte à outils, vous pouvez faire notamment les choses suivantes :

• Créer des applications sans serveur qui contiennent des fonctions AWS Lambda, puis déployer lesapplications sur une pile AWS CloudFormation.

• Travailler avec des schémas Amazon EventBridge.• Utilisez IntelliSense lorsque vous travaillez avec des fichiers de définition de tâche Amazon ECS.• Visualiser une application AWS Cloud Development Kit (AWS CDK).

Toolkit for Visual StudioAWS Toolkit for Visual Studio est un plug-in pour l'IDE Visual Studio qui vous facilite le développement,le débogage et le déploiement des applications .NET qui utilisent Amazon Web Services. Le Toolkit for

1

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Toolkit pour Azure DevOps

Visual Studio fournit des modèles Visual Studio pour des services comme Lambda et des assistants dedéploiement pour les applications Web et les applications sans serveur. Vous pouvez utiliser le AWSExplorateur à gérer Amazon EC2 instances, utiliser Amazon DynamoDB tables, publier des messagesdans Amazon Simple Notification Service (Amazon SNS) files d’attente, et plus encore, dans Visual Studio.

Consultez Configuration d'AWS Toolkit for Visual Studio pour démarrer.

Toolkit pour Azure DevOpsAWS Toolkit pour Microsoft Azure DevOps ajoute des tâches pour permettre aux pipelines de constructionet de mise à jour d'Azure DevOps et Azure DevOps Server de fonctionner avec les services AWS. Vouspouvez utiliser Amazon S3, AWS Elastic Beanstalk, AWS CodeDeploy, Lambda, AWS CloudFormationAmazon Simple Queue Service (Amazon SQS) et Amazon SNS. Vous pouvez également exécuter descommandes à l'aide du module Windows PowerShell et de l'AWS Command Line Interface (AWS CLI).

Pour débuter avec l'AWS Toolkit pour Azure DevOps, veuillez consulter Guide de l'utilisateur AWS Toolkitpour Microsoft Azure DevOps.

Version 3.5 du kit Kit AWS SDK pour .NETLa version 3.5 du kit Kit AWS SDK pour .NET normalise davantage l'expérience .NET en faisant passer laprise en charge de toutes les variations non-Framework du SDK vers .NET Standard 2.0.

Selon votre environnement et votre base de code, pour tirer parti des fonctionnalités de la version 3.5,vous devrez peut-être effectuer certaines tâches de migration. Pour plus d'informations sur la version3.5 et le travail de migration potentiel, consultez Migration vers la version 3.5 du kit Kit AWS SDKpour .NET (p. 68).

Comment utiliser ce manuelLe Manuel du développeur AWS SDK pour .NET explique comment implémenter des applications pourAWS à l'aide du kit Kit AWS SDK pour .NET, et inclut les sections suivantes :

Démarrez rapidement avec le kit Kit AWS SDK pour .NET. (p. 5)

Pour quelqu'un qui débute dans le développement .NET sur AWS, des didacticiels de base qui vousmontrent quelques scénarios courants, ainsi qu'une configuration minimale pour les prendre en charge.

Configuration du Kit AWS SDK pour .NET (p. 15)

Découvrez comment installer et configurer le connecteur Kit AWS SDK pour .NET. Si vous n'avez pasutilisé le Kit AWS SDK pour .NET auparavant ou si vous avez des problèmes à le configurer, cetteétape constitue un bon point de départ.

Programmation avec le kit AWS SDK pour .NET (p. 22)

Les bases de l'implémentation d'applications avec le Kit AWS SDK pour .NET qui s'appliquent à tousles services AWS. Cette section inclut également des informations sur la migration du code vers ladernière version du Kit AWS SDK pour .NET et décrit les différences entre l'ancienne version et celle-ci.

Exemples de code (p. 69)

Un ensemble de didacticiels, de procédures et d'exemples vous indiquant comment utiliser le KitAWS SDK pour .NET afin de créer des applications pour des services AWS spécifiques. Vous pouvezparcourir les exemples de Kit AWS SDK pour .NET dans le Catalogue d'exemples de code AWS.

2

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Services pris en charge et historique des révisions

Le AWS SDK for .NET API Reference fournit une description détaillée de chaque espace de noms etclasse.

Ressources supplémentaires concernant (p. 3)

Ressources supplémentaires ne faisant pas partie du guide et fournissant des informationsimportantes sur AWS et le Kit AWS SDK pour .NET. Si vous ne connaissez pas bien les services AWS,consultez Présentation d'Amazon Web Services.

Services pris en charge et historique des révisionsLe Kit AWS SDK pour .NET prend en charge la plupart des produits d'infrastructure AWS, et davantage deservices sont ajoutés fréquemment. Pour obtenir la liste des services AWS pris en charge par le kit SDK,consultez le fichier README du kit SDK.

Pour connaître les modifications d'une version particulière, consultez le journal des modifications du kitSDK.

Ressources supplémentairesServices pris en charge et historique des révisions

Le Kit AWS SDK pour .NET prend en charge la plupart des produits d'infrastructure AWS, et davantage deservices sont ajoutés fréquemment. Pour obtenir la liste des services AWS pris en charge par le kit SDK,consultez le fichier README du kit SDK.

Pour connaître les modifications d'une version particulière, consultez le journal des modifications du kitSDK.

Page d’accueil pour le Kit AWS SDK pour .NET

Pour plus d’informations sur le Kit AWS SDK pour .NET, consultez la page d’accueil du kit SDK à l’adressehttps://aws.amazon.com/sdk-for-net/.

Documentation de référence du kit SDK

La documentation de référence du kit SDK vous permet de parcourir et de rechercher dans tout le codeinclus dans le kit SDK. Il fournit une documentation détaillée et des exemples d’utilisation. Pour de plusamples informations, veuillez consulter AWS SDK for .NET API Reference.

Forums AWS

Visitez les forums AWS pour poser des questions ou fournir des commentaires sur AWS. Chaque page dedocumentation a un Aller aux forums en haut de la page qui vous dirige vers le forum associé. AWS lesingénieurs surveillent les forums et répondent aux questions, commentaires et problèmes. Vous pouvezégalement vous abonner aux flux RSS pout tous les forums.

AWS Toolkit for Visual Studio

Si vous utilisez l'IDE Microsoft Visual Studio, vous devez consulter leGuide de l'utilisateur AWS Toolkit forVisual Studio.

Bibliothèques, extensions et outils utiles

Visitez le aws/réseau en points et aws/aws-sdk-réseau sur le site web GitHub pour obtenir des liens versdes bibliothèques, des outils et des ressources que vous pouvez utiliser pour vous aider à créer desapplications et des services.NET sur AWS.

3

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Ressources supplémentaires

Voici quelques points importants concernant le référentiel :

• AWS .NET Configuration Extension for Systems Manager• AWS Extensions .NET Core Setup• AWS Logging .NET• Amazon Cognito Authentication Extension Library• Kit SDK AWS X-Ray pour .NET

4

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Application multiplateforme simple

Démarrez rapidement avec le kit KitAWS SDK pour .NET.

Cette section inclut les étapes de configuration de base et les didacticiels pour les développeurs qui neconnaissent pas le Kit AWS SDK pour .NET.

Pour plus d'informations avancées, consultez Configuration de (p. 15) et Exemples de code pour le KitAWS SDK pour .NET (p. 69).

Rubriques• Application multiplateforme simple à l'aide du kit Kit AWS SDK pour .NET (p. 5)• Application simple basée sur Windows à l'aide du kit Kit AWS SDK pour .NET (p. 10)• Étapes suivantes (p. 14)

Application multiplateforme simple à l'aide du kit KitAWS SDK pour .NET

Ce didacticiel utilise le Kit AWS SDK pour .NET et.NET Core pour le développement multiplateforme.Le didacticiel vous montre comment utiliser le kit SDK pour répertorier les Amazon S3 seaux que vouspossédez et, le cas échéant, créez un compartiment.

Steps• Configuration pour ce didacticiel (p. 5)• Création du projet (p. 7)• Créer le code (p. 7)• Exécutez l'application (p. 9)• Nettoyage (p. 9)

Configuration pour ce didacticielThis section provides the minimal setup needed to complete this tutorial. You shouldn't consider this to be afull setup. For that, see Configuration du Kit AWS SDK pour .NET (p. 15).

Note

If you've already completed any of the following steps through other tutorials or existingconfiguration, skip those steps.

Création d'un compte AWS

To create an AWS account, see How do I create and activate a new Amazon Web Services account?

5

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration pour ce didacticiel

Créer des informations d'identification et un profil AWS

Pour exécuter ces didacticiels, vous devez créer un AWS Identity and Access Management (IAM) etobtenez les informations d’identification pour cet utilisateur. Une fois que vous avez ces informationsd’identification, vous les rendez disponibles pour le kit SDK dans votre environnement de développement.Voici comment procéder.

Pour créer et utiliser des informations d'identification

1. Connectez-vous à la AWS Management Console et ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.

2. Choisissez Users (Utilisateurs), puis Add user (Ajouter un utilisateur).3. Indiquez un nom d'utilisateur. Pour ce didacticiel, nous allons utiliser Dotnet-Tutorial-User.4. En dessous Sélectionner le type d’accès AWS, sélectionnez Accès programmatique, puis choisissez

Suivant : Autorisations5. Choisissez Attacher directement les stratégies existantes.6. dans Rechercher, saisissez s3, puis sélectionnez Accès complet AmazonS3.7. Choisissez Suivant. Balises, Suivant : à revoir, et Créer un utilisateur.8. Enregistrez les informations d'identification pour Dotnet-Tutorial-User. Vous pouvez le faire en

téléchargeant le fichier .csv ou en copiant et collant l'ID de clé d'accès et la clé d’accès secrète.

Warning

Adoptez les mesures de sécurité appropriées pour assurer la sécurité et la rotation de cesinformations d'identification.

9. Créez ou ouvrez le fichier d'informations d'identification AWS partagé. Ce fichier est ~/.aws/credentials sous Linux et macOS et %USERPROFILE%\.aws\credentials sous Windows.

10. Ajoutez le texte suivant au fichier d'informations d'identification AWS partagé, mais remplacez l'IDd'exemple et la clé d'exemple par ceux obtenus précédemment. N'oubliez pas d'enregistrer le fichier.

[dotnet-tutorials]aws_access_key_id = AKIAIOSFODNN7EXAMPLEaws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

La procédure ci-dessus est la plus simple parmi les différentes possibilités d'authentification etd'autorisation. Pour des informations complètes, voir Configuration des informations d'identificationAWS (p. 26).

Installer d'autres outils

Vous allez réaliser ce didacticiel à l'aide d'outils multiplateformes comme l'interface de ligne de commande(CLI) .NET. Pour d’autres façons de configurer votre environnement de développement, consultez Installeret configurer votre chaîne d’outils (p. 15).

Obligatoire pour le développement .NET multiplateforme sous Windows, Linux ou macOS :

• Microsoft .NET Core SDK, version 2.1, 3.1 ou ultérieure, qui inclut l'interface de ligne de commande (CLI)NET (dotnet) et le moteur d'exécution .NET core.

• Un éditeur de code ou un environnement de développement intégré (IDE) adapté à votre systèmed’exploitation et aux exigences. Il s’agit généralement d’une prise en charge de.NET Core.

Exemples : Microsoft Visual Studio Code (VS Code), JetBrains Rider et Microsoft Visual Studio.

6

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Création du projet

Création du projet1. Ouvrez l’invite de commande ou le terminal. Recherchez ou créez un dossier de système d'exploitation

sous lequel vous pouvez créer un projet .NET.2. Dans ce dossier, exécutez la commande suivante pour créer le projet .NET.

dotnet new console --name S3CreateAndList

3. Accédez au dossier S3CreateAndList nouvellement créé et exécutez la commande suivante.

dotnet add package AWSSDK.S3

La commande précédente installe le package NuGet AWSSDK.S3 à partir du gestionnaire de packageNuGet. Comme nous savons exactement de quels packages NuGet nous avons besoin pour cedidacticiel, nous pouvons effectuer cette étape maintenant. Il est également courant que les packagesrequis soient connus pendant le développement. Dans ce cas, une commande similaire peut êtreexécutée à ce moment-là.

4. Ajoutez à l’environnement les variables d'environnement temporaires suivantes.

Linux ou macOS:

AWS_PROFILE='dotnet-tutorials'AWS_REGION='us-west-2'

Windows:

set AWS_PROFILE=dotnet-tutorialsset AWS_REGION=us-west-2

Créer le code1. Dans le dossier S3CreateAndList, recherchez et ouvrez Program.cs dans votre éditeur de code.2. Remplacez le contenu par le code suivant et enregistrez le fichier.

using System;using System.Threading.Tasks;

// To interact with Amazon S3.using Amazon.S3;using Amazon.S3.Model;

namespace S3CreateAndList{ class Program { // Main method static async Task Main(string[] args) { // Before running this app: // - Credentials must be specified in an AWS profile. If you use a profile other than // the [default] profile, also set the AWS_PROFILE environment variable. // - An AWS Region must be specified either in the [default] profile // or by setting the AWS_REGION environment variable.

7

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Créer le code

// Create an S3 client object. var s3Client = new AmazonS3Client();

// Parse the command line arguments for the bucket name. if(GetBucketName(args, out String bucketName)) { // If a bucket name was supplied, create the bucket. // Call the API method directly try { Console.WriteLine($"\nCreating bucket {bucketName}..."); var createResponse = await s3Client.PutBucketAsync(bucketName); Console.WriteLine($"Result: {createResponse.HttpStatusCode.ToString()}"); } catch (Exception e) { Console.WriteLine("Caught exception when creating a bucket:"); Console.WriteLine(e.Message); } }

// List the buckets owned by the user. // Call a class method that calls the API method. Console.WriteLine("\nGetting a list of your buckets..."); var listResponse = await MyListBucketsAsync(s3Client); Console.WriteLine($"Number of buckets: {listResponse.Buckets.Count}"); foreach(S3Bucket b in listResponse.Buckets) { Console.WriteLine(b.BucketName); } }

// // Method to parse the command line. private static Boolean GetBucketName(string[] args, out String bucketName) { Boolean retval = false; bucketName = String.Empty; if (args.Length == 0) { Console.WriteLine("\nNo arguments specified. Will simply list your Amazon S3 buckets." + "\nIf you wish to create a bucket, supply a valid, globally unique bucket name."); bucketName = String.Empty; retval = false; } else if (args.Length == 1) { bucketName = args[0]; retval = true; } else { Console.WriteLine("\nToo many arguments specified." + "\n\ndotnet_tutorials - A utility to list your Amazon S3 buckets and optionally create a new one." + "\n\nUsage: S3CreateAndList [bucket_name]" + "\n - bucket_name: A valid, globally unique bucket name." + "\n - If bucket_name isn't supplied, this utility simply lists your buckets."); Environment.Exit(1); } return retval; }

8

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exécutez l'application

// // Async method to get a list of Amazon S3 buckets. private static async Task<ListBucketsResponse> MyListBucketsAsync(IAmazonS3 s3Client) { return await s3Client.ListBucketsAsync(); }

}}

Exécutez l'application1. Exécutez la commande suivante .

dotnet run

2. Examinez le résultat pour voir le nombre de compartiments Amazon S3 que vous possédez, le caséchéant, et leurs noms.

3. Choisissez un nom pour un nouveau compartiment Amazon S3. Utilisez "dotnet-quickstart-s3-1-cross-"comme base et ajoutez quelque chose d’unique, comme un GUID ou votre nom. Assurez-vous desuivre les règles pour les noms de compartiment, comme décrit dans Règles pour la dénomination descompartiments dans le Amazon Simple Storage Service Manuel du développeur.

4. Exécutez la commande suivante, en remplaçant BUCKET-NAME avec le nom du compartiment quevous avez choisi.

dotnet run BUCKET-NAME

5. Examinez le résultat pour voir le nouveau compartiment créé.

NettoyageLors de l'exécution de ce didacticiel, vous avez créé quelques ressources que vous pouvez décidermaintenant de nettoyer.

• Si vous ne souhaitez pas conserver le compartiment que l’application a créé à une étape précédente,supprimez-le à l’aide de l’ Amazon S3 console à https://console.aws.amazon.com/s3/.

• Si vous ne souhaitez pas conserver l’utilisateur que vous avez créé lors de la configuration dudidacticiel précédemment dans cette rubrique, supprimez-le à l’aide de l’ IAM console à https://console.aws.amazon.com/iam/n° d’accueil/utilisateurs.

Si vous choisissez de supprimer l’utilisateur, vous devez également supprimer le dotnet-tutorialsque vous avez créé dans le profil partagé AWS fichier d’informations d’identification. Vous avez créé ceprofil lors de la configuration du didacticiel plus haut dans cette rubrique.

• Si vous ne souhaitez pas conserver votre projet .NET, supprimez le dossier S3CreateAndList de votreenvironnement de développement.

Étapes suivantesRetournez au menu de démarrage rapide (p. 5) ou passez directement à la fin de ce démarragerapide (p. 14).

9

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Application simple basée sur Windows

Application simple basée sur Windows à l'aide du kitKit AWS SDK pour .NET

Ce didacticiel utilise le Kit AWS SDK pour .NET sur Windows avec Visual Studio et.NET Core. Ledidacticiel vous montre comment utiliser le kit SDK pour répertorier les Amazon S3 seaux que vouspossédez et créez éventuellement un compartiment.

Steps• Configuration pour ce didacticiel (p. 10)• Création du projet (p. 11)• Créer le code (p. 12)• Exécutez l'application (p. 13)• Nettoyage (p. 14)

Configuration pour ce didacticielThis section provides the minimal setup needed to complete this tutorial. You shouldn't consider this to be afull setup. For that, see Configuration du Kit AWS SDK pour .NET (p. 15).

Note

If you've already completed any of the following steps through other tutorials or existingconfiguration, skip those steps.

Création d'un compte AWS

To create an AWS account, see How do I create and activate a new Amazon Web Services account?

Créer des informations d'identification et un profil AWS

Pour exécuter ces didacticiels, vous devez créer un AWS Identity and Access Management (IAM) etobtenez les informations d’identification pour cet utilisateur. Une fois que vous avez ces informationsd’identification, vous les rendez disponibles pour le kit SDK dans votre environnement de développement.Voici comment procéder.

Pour créer et utiliser des informations d'identification

1. Connectez-vous à la AWS Management Console et ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.

2. Choisissez Users (Utilisateurs), puis Add user (Ajouter un utilisateur).3. Indiquez un nom d'utilisateur. Pour ce didacticiel, nous allons utiliser Dotnet-Tutorial-User.4. En dessous Sélectionner le type d’accès AWS, sélectionnez Accès programmatique, puis choisissez

Suivant : Autorisations5. Choisissez Attacher directement les stratégies existantes.6. dans Rechercher, saisissez s3, puis sélectionnez Accès complet AmazonS3.7. Choisissez Suivant. Balises, Suivant : à revoir, et Créer un utilisateur.8. Enregistrez les informations d'identification pour Dotnet-Tutorial-User. Vous pouvez le faire en

téléchargeant le fichier .csv ou en copiant et collant l'ID de clé d'accès et la clé d’accès secrète.

10

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Création du projet

Warning

Adoptez les mesures de sécurité appropriées pour assurer la sécurité et la rotation de cesinformations d'identification.

9. Créez ou ouvrez le fichier d'informations d'identification AWS partagé. Ce fichier est ~/.aws/credentials sous Linux et macOS et %USERPROFILE%\.aws\credentials sous Windows.

10. Ajoutez le texte suivant au fichier d'informations d'identification AWS partagé, mais remplacez l'IDd'exemple et la clé d'exemple par ceux obtenus précédemment. N'oubliez pas d'enregistrer le fichier.

[dotnet-tutorials]aws_access_key_id = AKIAIOSFODNN7EXAMPLEaws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

La procédure ci-dessus est la plus simple parmi les différentes possibilités d'authentification etd'autorisation. Pour des informations complètes, voir Configuration des informations d'identificationAWS (p. 26).

Installer d'autres outilsVous exécuterez ce didacticiel sous Windows avec Visual Studio et .NET Core. Pour d’autres façonsde configurer votre environnement de développement, consultez Installer et configurer votre chaîned’outils (p. 15).

Obligatoire pour le développement sous Windows avec Visual Studio et .NET Core :

• Microsoft Visual Studio

• Microsoft .NET Core 2.1, 3.1 ou version ultérieure

Ceci est généralement inclus par défaut lors de l’installation d’une version récente de Visual Studio.

Création du projet1. Ouvrez Visual Studio et créez un nouveau projet qui utilise la version C # du modèle Console App

(.NET Core) (Application de la console (.NET Core)). Appelez le projet S3CreateAndList.2. Avec le projet nouvellement créé chargé, choisissez Outils, Gestionnaire de package NuGet, Gérer les

packages NuGet pour la solution.3. Recherchez le package NuGet AWSSDK.S3 et installez-le dans le projet.

Ce processus installe le package NuGet AWSSDK.S3 à partir du Gestionnaire de packages NuGet.Comme nous savons exactement de quels packages NuGet nous avons besoin pour ce didacticiel,nous pouvons effectuer cette étape maintenant. Il est également courant que les packages requissoient connus pendant le développement. Dans ce cas, appliquez un processus similaire pour lesinstaller à ce moment-là.

4. Si vous avez l’intention d’exécuter l’application à partir de l’invite de commande, ouvrez une invite decommande maintenant et accédez au dossier qui contiendra la sortie de génération. Cela ressemblegénéralement à cela : S3CreateAndList\S3CreateAndList\bin\Debug\netcoreapp3.1, maistout dépend de notre environnement.

5. Ajoutez à l’environnement les variables d'environnement temporaires suivantes.

Dans l’invite de commande, utilisez l’.

set AWS_PROFILE=dotnet-tutorials

11

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Créer le code

set AWS_REGION=us-west-2

Ou, si vous avez l’intention d’exécuter l’application dans l’IDE, choisissez Projet, PropriétésS3CreateAndList, Débogage et placez-les ici.

Créer le code1. Dans le projet S3CreateAndList, recherchez et ouvrez Program.cs dans l'IDE.2. Remplacez le contenu par le code suivant et enregistrez le fichier.

using System;using System.Threading.Tasks;

// To interact with Amazon S3.using Amazon.S3;using Amazon.S3.Model;

namespace S3CreateAndList{ class Program { // Main method static async Task Main(string[] args) { // Before running this app: // - Credentials must be specified in an AWS profile. If you use a profile other than // the [default] profile, also set the AWS_PROFILE environment variable. // - An AWS Region must be specified either in the [default] profile // or by setting the AWS_REGION environment variable.

// Create an S3 client object. var s3Client = new AmazonS3Client();

// Parse the command line arguments for the bucket name. if(GetBucketName(args, out String bucketName)) { // If a bucket name was supplied, create the bucket. // Call the API method directly try { Console.WriteLine($"\nCreating bucket {bucketName}..."); var createResponse = await s3Client.PutBucketAsync(bucketName); Console.WriteLine($"Result: {createResponse.HttpStatusCode.ToString()}"); } catch (Exception e) { Console.WriteLine("Caught exception when creating a bucket:"); Console.WriteLine(e.Message); } }

// List the buckets owned by the user. // Call a class method that calls the API method. Console.WriteLine("\nGetting a list of your buckets..."); var listResponse = await MyListBucketsAsync(s3Client); Console.WriteLine($"Number of buckets: {listResponse.Buckets.Count}"); foreach(S3Bucket b in listResponse.Buckets) { Console.WriteLine(b.BucketName); }

12

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exécutez l'application

}

// // Method to parse the command line. private static Boolean GetBucketName(string[] args, out String bucketName) { Boolean retval = false; bucketName = String.Empty; if (args.Length == 0) { Console.WriteLine("\nNo arguments specified. Will simply list your Amazon S3 buckets." + "\nIf you wish to create a bucket, supply a valid, globally unique bucket name."); bucketName = String.Empty; retval = false; } else if (args.Length == 1) { bucketName = args[0]; retval = true; } else { Console.WriteLine("\nToo many arguments specified." + "\n\ndotnet_tutorials - A utility to list your Amazon S3 buckets and optionally create a new one." + "\n\nUsage: S3CreateAndList [bucket_name]" + "\n - bucket_name: A valid, globally unique bucket name." + "\n - If bucket_name isn't supplied, this utility simply lists your buckets."); Environment.Exit(1); } return retval; }

// // Async method to get a list of Amazon S3 buckets. private static async Task<ListBucketsResponse> MyListBucketsAsync(IAmazonS3 s3Client) { return await s3Client.ListBucketsAsync(); }

}}

3. Générer l'application

Exécutez l'application1. Exécutez l'application sans arguments de ligne de commande. Effectuez cette opération dans l’invite

de commande (si vous en avez ouvert une précédemment) ou à partir de l’IDE.2. Examinez le résultat pour voir le nombre de compartiments Amazon S3 que vous possédez, le cas

échéant, et leurs noms.3. Choisissez un nom pour un nouveau compartiment Amazon S3. Utilisez "dotnet-quickstart-s3-1-winvs-"

comme base et ajoutez quelque chose d’unique, comme un GUID ou votre nom. Assurez-vous desuivre les règles pour les noms de compartiment, selon la description dans Règles relatives aux nomsde compartiment dans leAmazon Simple Storage Service Manuel du développeur.

13

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Nettoyage

4. Exécutez à nouveau l'application, en fournissant cette fois le nom du compartiment.

Dans la ligne de commande, remplacez BUCKET-NAME dans la commande suivante avec le nom ducompartiment que vous avez choisi.

S3CreateAndList BUCKET-NAME

Ou, si vous exécutez l’application dans l’IDE, choisissez Projet, Propriétés S3CreateAndList,Débogage et entrez le nom du compartiment ici.

5. Examinez le résultat pour voir le nouveau compartiment créé.

NettoyageLors de l'exécution de ce didacticiel, vous avez créé quelques ressources que vous pouvez décidermaintenant de nettoyer.

• Si vous ne souhaitez pas conserver le compartiment que l’application a créé à une étape précédente,supprimez-le à l’aide de l’ Amazon S3 console à https://console.aws.amazon.com/s3/.

• Si vous ne souhaitez pas conserver l’utilisateur que vous avez créé lors de la configuration dudidacticiel précédemment dans cette rubrique, supprimez-le à l’aide de l’ IAM console à https://console.aws.amazon.com/iam/n° d’accueil/utilisateurs.

Si vous choisissez de supprimer l’utilisateur, vous devez également supprimer le dotnet-tutorialsque vous avez créé dans le profil partagé AWS fichier d’informations d’identification. Vous avez créé ceprofil lors de la configuration du didacticiel plus haut dans cette rubrique.

• Si vous ne souhaitez pas conserver votre projet .NET, supprimez le dossier S3CreateAndList de votreenvironnement de développement.

Étapes suivantesRetournez au menu de démarrage rapide (p. 5) ou passez directement à la fin de ce démarragerapide (p. 14).

Étapes suivantesVeillez à nettoyer les ressources restantes que vous avez créées lors de l'exécution de ces didacticiels. Ilpeut s’agir AWS des ressources ou des ressources dans votre environnement de développement, tellesque des fichiers et des dossiers.

Maintenant que vous avez fait le tour du kit Kit AWS SDK pour .NET, vous voudrez peut-être aborder uneconfiguration plus avancée (p. 15).

14

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Créer un compte AWS et des informations d'identification

Configuration du Kit AWS SDKpour .NET

Cette rubrique vous montre comment configurer complètement le kit Kit AWS SDK pour .NET.

Si vous débutez dans le développement .NET sur AWS ou si vous débutez avec le kit Kit AWS SDKpour .NET, consultez d'abord la rubrique Démarrage rapide (p. 5). Il vous donne une introduction au kitSDK.

Rubriques• Créer un compte AWS et des informations d'identification (p. 15)• Installer et configurer votre chaîne d’outils (p. 15)• Installer des assemblies AWSSDK (p. 16)• Démarrer un nouveau projet (p. 19)• Plateformes prises en charge par le Kit AWS SDK pour .NET (p. 20)

Créer un compte AWS et des informationsd'identification

Pour utiliser le Kit AWS SDK pour .NET afin d'accéder aux services AWS, vous avez besoin d'un compteAWS et d'informations d'identification AWS. Pour renforcer la sécurité de votre compte AWS, nous vousrecommandons de recourir à un utilisateur IAM pour fournir les informations d'identification d'accès au lieud'utiliser les informations d'identification de votre compte racine.

• Pour créer un compte AWS, consultez Comment créer et activer un nouveau compte Amazon WebServices ?

• Évitez d'utiliser votre compte d'utilisateur racine (le compte initial que vous créez) pour accéder auxservices. Au lieu de cela, créez un compte d'utilisateur administratif, comme expliqué dans la sectionCréation de votre premier utilisateur et groupe d'administration IAM. Après avoir créé le compted'utilisateur administratif et enregistré les informations de connexion, déconnectez-vous de votre compted'utilisateur racine et reconnectez-vous à l'aide du compte d'administration.

• Pour effectuer plusieurs des tâches et des exemples de ce guide, vous aurez besoin de clés d'accèspour un compte d'utilisateur, afin d’accéder aux services AWS par programmation. Pour créer desclés d'accès pour un utilisateur existant, consultez Gestion des clés d'accès (console). Vous pouvezégalement créer des clés d'accès lorsque vous créez un utilisateur. Lors de la création de l'utilisateur,choisissez un Access type (Type d’accès) de Programmatic access (Accès programmatique) au lieu de(ou en plus de) AWS Management Console access (Accès à l’AWS Management Console).

• Pour fermer votre compte AWS, consultez Clôture d'un compte.

Pour plus d'informations sur la gestion des certificats et de la sécurité, consultez les Meilleures pratiques etcas d'utilisation IAM dans la section IAM Guide de l'utilisateur

Installer et configurer votre chaîne d’outilsPour utiliser le Kit AWS SDK pour .NET, certains outils de développement doivent être installés.

15

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Développement multiplateforme

Note

Si vous avez effectué le démarrage rapide pour le kit SDK (p. 5), certains de ces outils sontpeut-être déjà installés. Si vous n’avez pas effectué le démarrage rapide et que vous n’êtes pasencore familiarisé avec le développement.NET sur AWS, envisagez d’abord de le faire pour uneintroduction à Kit AWS SDK pour .NET.

Développement multiplateformeLes éléments suivants sont requis pour le développement.NET multiplateforme sur Windows, Linux oumacOS :

• Microsoft .NET Core SDK, version 2.1, 3.1 ou ultérieure, qui inclut l'interface de ligne de commande (CLI)NET (dotnet) et le moteur d'exécution .NET core.

• Un éditeur de code ou un environnement de développement intégré (IDE) adapté à votre systèmed’exploitation et aux exigences. Il s’agit généralement d’une prise en charge de.NET Core.

Exemples : Microsoft Visual Studio Code (VS Code), JetBrains Rider et Microsoft Visual Studio.

• (Facultatif) Une boîte à outils AWS si elle est disponible pour l’éditeur que vous avez choisi et votresystème d’exploitation.

Les exemples incluent le Code AWS Toolkit pour Visual Studio, Boîte à outils AWS pour JetBrains, etBoîte à outils AWS pour Visual Studio.

Windows avec Visual Studio et.NET CoreLes éléments suivants sont requis pour le développement sur Windows avec Visual Studio et.NET Core :

• Microsoft Visual Studio

• Microsoft .NET Core 2.1, 3.1 ou version ultérieure

Ceci est généralement inclus par défaut lors de l’installation d’une version récente de Visual Studio.

• (Facultatif) Le AWS Toolkit for Visual Studio, qui est un plug-in qui fournit une interface utilisateur pourla gestion de votre AWS des ressources et des profils locaux à partir de Visual Studio. Pour installer laboîte à outils, voir Configuration d’AWS Toolkit pour Visual Studio.

Pour de plus amples informations, veuillez consulter Guide de l'utilisateur AWS Toolkit for Visual Studio.

Installer des assemblies AWSSDKLes assemblies AWSSDK sont disponibles à partir de NuGet ou via un package d'installation Windows. LeKit AWS SDK pour .NET est également disponible à partir du référentiel aws/aws-sdk-net sur GitHub. Enfin,vous pouvez trouver des informations sur beaucoup de questions liées à AWS .NET dans le référentielaws/dotnet sur GitHub.

16

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Installation des packages AWSSDK avec NuGet

Installation des packages AWSSDK avec NuGetNuGet est un système de gestion des packages pour la plateforme .NET. Avec NuGet, vous pouvezinstaller le Packages AWSSDK, ainsi que plusieurs autres extensions, à votre projet. Pour plusd’informations, consultez le aws/réseau en points sur le site web GitHub.

NuGet dispose toujours des versions les plus récentes des packages AWSSDK, ainsi que des versionsprécédentes. NuGet connaît les dépendances entre les packages et installe automatiquement tous lespackages requis.

Warning

La liste des packages NuGet peut inclure un package nommé simplement « AWSSDK » (sansidentifiant ajouté). N’installez PAS ce package NuGet ; il est hérité et ne doit pas être utilisé pourde nouveaux projets.

Les packages installés avec NuGet sont stockés avec votre projet au lieu de dans un emplacement central.Cela vous permet d'installer des versions d'assemblage spécifiques à une application donnée sans créerde problèmes de compatibilité pour les autres applications. Pour plus d'informations sur NuGet, consultezla documentation NuGet.

Utilisation de NuGet à partir de l’invite de commande ou duterminal1. Allez à la page Packages AWSSDK sur NuGet et déterminez les packages dont vous avez besoin

dans votre projet ; par exemple, pour le protocole AWSSDK.S3.2. Copiez la commande de l’interface de ligne de commande.NET à partir de la page web de ce package,

comme illustré dans l’exemple suivant.

dotnet add package AWSSDK.S3 --version 3.3.110.19

3. Dans le répertoire de votre projet, exécutez cette commande .NET CLI. NuGet installe également lesdépendances, comme AWSSDK.Core.

Note

Si vous souhaitez uniquement la dernière version d’un package NuGet, vous pouvez exclure lesinformations de version de la commande , comme illustré dans l’exemple suivant.dotnet add package AWSSDK.S3

Utilisation de NuGet à partir de Visual Studio Solution Explorer1. Dans l’Solution Explorer (Explorateur de solutions), cliquez avec le bouton droit de la souris sur

votre projet, puis choisissez Manage NuGet Packages (Gérer les packages NuGet) dans le menucontextuel.

2. Dans le volet gauche du NuGet Package Manager (Gestionnaire de packages NuGet), choisissezBrowse (Parcourir). Vous pouvez ensuite rechercher le package que vous souhaitez installer à partirde la zone de recherche.

La figure suivante illustre l’installation du pour le protocole AWSSDK.S3 de l’emballage. NuGet installeégalement les dépendances, comme AWSSDK.Core.

17

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Télécharger et extraire des fichiers ZIP

Utilisation de NuGet à partir de la console du Gestionnaire depackageDans Visual Studio, choisissez Outils, Gestionnaire de package NuGet, Console du gestionnaire depackages.

Vous pouvez installer les packages AWSSDK que vous souhaitez à partir de la console du gestionnaire depackages à l’aide de l’ Install-Package. Par exemple, pour installer AWSSDK.S3, utilisez la commandesuivante.

PM> Install-Package AWSSDK.S3

NuGet installe également les dépendances, comme AWSSDK.Core.

Si vous devez installer une version antérieure d’un package, utilisez le -Version et spécifiez la version depackage que vous souhaitez, comme illustré dans l’exemple suivant.

PM> Install-Package AWSSDK.S3 -Version 3.3.106.6

Pour plus d’informations sur les commandes de la console du gestionnaire de package, consultez leRéférence PowerShell dans le Documentation NuGet.

Télécharger et extraire des fichiers ZIPLa méthode préférée pour installer le Kit AWS SDK pour .NET est d'installer les packages AWSSDK NuGetselon les besoins. Consultez les sections précédentes de cette rubrique (p. 17) pour une description dela méthode.

Si vous ne pouvez pas ou n’êtes pas autorisé à télécharger et installer des packages NuGet par projet,vous pouvez télécharger un fichier ZIP qui contient les assemblages AWSSDK. Si c’est le cas pour vous,procédez comme suit.

18

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Installation de l'Kit AWS SDK pour .NET sur Windows

1. Téléchargez l’un des fichiers ZIP suivants :

• aws-sdk-netstandard2.0.zip• aws-sdk-net45.zip• aws-sdk-net35.zip

2. Extrayez les assemblages dans un dossier de votre système de fichiers. Prenez note de ce dossier.3. Lorsque vous configurez votre projet, copiez les assemblages requis à partir de ce dossier dans votre

zone de projet. Ajoutez ensuite des références dans votre projet aux assemblages que vous avezcopiés.

Installation de l'Kit AWS SDK pour .NET sur WindowsLa méthode préférée pour installer le kit Kit AWS SDK pour .NET consiste à installer les packagesAWSSDK NuGet selon les besoins. Consultez les sections précédentes de cette rubrique (p. 17) pourune description de la méthode.

Vous utilisez NuGet pour installer des assemblies de service AWSSDK individuels et des extensions pourle kit SDK.

Note

Si vous devez installer un MSI au lieu d'utiliser NuGet, vous pouvez trouver le MSI hérité àl’adresse https://sdk-for-net.amazonwebservices.com/latest/AWSToolsAndSDKForNet.msi. Pardéfaut, le kit Kit AWS SDK pour .NET est installé dans le répertoire Program Files, lequelnécessite les privilèges d'administrateur. Pour installer le kit SDK en tant qu'utilisateur autre quel'administrateur, choisissez un autre répertoire d'installation.

Démarrer un nouveau projetIl existe plusieurs techniques que vous pouvez utiliser pour démarrer un nouveau projet afin d’accéderAWS services. Voici quelques-unes de ces techniques :

• Si vous n’êtes pas encore familiarisé avec le développement.NET sur AWS ou au moins nouveau dans leKit AWS SDK pour .NET, vous pouvez voir des exemples complets dans Démarrage rapide (p. 5). Il vousdonne une introduction au kit SDK.

• Vous pouvez démarrer un projet de base à l'aide de l'interface de ligne de commande .NET. Pour voirun exemple de ceci, ouvrez une invite de commande ou un terminal, créez un dossier ou un répertoire etaccédez-y, puis saisissez le suivant.

dotnet new console --name [SOME-NAME]

Un projet vide est créé auquel vous pouvez ajouter du code et des packages NuGet. Pour plusd'informations, consultez le guide .NET Core.

• AWS Toolkit for Visual Studio comprend des modèles de projet C# pour différents services AWS. Aprèsvous installer la boîte à outils dans Visual Studio, vous pouvez accéder aux modèles tout en créant unnouveau projet.

Pour voir cela, rendez-vous sur Utilisation de AWS services dans le Guide de l'utilisateur AWS Toolkit forVisual Studio. Plusieurs exemples de cette section créent de nouveaux projets.

19

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Plateformes prises en charge par le Kit AWS SDK pour .NET

• Si vous développez avec Visual Studio sous Windows mais sans le AWS Toolkit for Visual Studioutilisezvos techniques habituelles pour créer un nouveau projet.

Pour voir un exemple, ouvrez Visual Studio et choisissez Fichier, Nouveau, Projet. Recherchez « .netcore » et choisissez la version C# du Application de console (.NET Core) modèle. Un projet vide est crééauquel vous pouvez ajouter du code et des packages NuGet.

Après avoir créé votre projet, effectuez des tâches supplémentaires appropriées pour configuration de votreprojet (p. 22).

Vous pouvez trouver quelques exemples d’utilisation de AWS services dans Exemples de code (p. 69).

Plateformes prises en charge par le Kit AWS SDKpour .NET

Le Kit AWS SDK pour .NET fournit des groupes d'assemblies pour les développeurs afin de ciblerdifférentes plateformes. Toutefois, toutes les fonctionnalités SDK ne sont pas identiques sur toutes cesplateformes. Cette rubrique aborde les différences de prise en charge pour chaque plateforme.

.NET CoreLe Kit AWS SDK pour .NET prend en charge les applications écrites pour .NET Core. Les clients desservices AWS prennent uniquement en charge les modèles d'appel asynchrones dans .NET Core. Ceciinflue également sur de nombreuses abstractions de haut niveau reposant sur les clients de servicescomme TransferUtility d'Amazon S3 qui prend uniquement en charge les modèles asynchrones dansl'environnement .NET Core. Pour plus d'informations, consultez Configuration du kit AWS SDK pour .NETavec .NET Core (p. 23).

.NET Framework 4.5Cette version du Kit AWS SDK pour .NET est compilée par rapport à .NET Framework 4.5 et fonctionnedans l'environnement d'exécution .NET 4.0. Les clients de services AWS prennent en charge les modèlesd'appel synchrones et asynchrones, et utilisent les mots-clés async et await introduits dans C# 5.0.

.NET Framework 3.5Cette version du Kit AWS SDK pour .NET est compilée par rapport à .NET Framework 3.5 et exécutel'environnement d'exécution .NET 2.0 ou .NET 4.0. Les clients des services AWS prennent en charge lesmodèles d'appel synchrones et asynchrones, et utilisent les anciens modèles Begin et End.

Note

Le Kit AWS SDK pour .NET n'est pas conforme à la norme Federal Information ProcessingStandard (FIPS) en cas d'utilisation par des applications conçues pour la version 2.0 de la CLR.Pour plus d'informations sur la substitution d'une implémentation conforme à la publication FIPSdans cet environnement, reportez-vous à CryptoConfig dans le blog Microsoft et à la classeHMACSHA256 (HMACSHA256Cng) de l'équipe CLR Security dans Security.Cryptography.dll.

Bibliothèque de classes portableLe Kit AWS SDK pour .NET contient également une implémentation de bibliothèque de classes portable.Cette implémentation peut cibler plusieurs plateformes, y compris Universal Windows Platform (UWP) et

20

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Prise en charge d'Unity

Xamarin sur iOS et Android. Pour plus d'informations, reportez-vous au kit SDK AWS Mobile pour .NET etXamarin. Les clients des services AWS prennent uniquement en charge les modèles d'appel asynchrones.

Prise en charge d'UnityLe Kit AWS SDK pour .NET prend en charge la création d'assemblies pour Unity. Pour plus d'informations,consultez le fichier Unity README.

Plus d'informations• Migration vers la version 3 du kit Kit AWS SDK pour .NET (p. 66)• Migration vers la version 3.5 du kit Kit AWS SDK pour .NET (p. 68)

21

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration de votre application

Programmation avec le Kit AWS SDKpour .NET

Cette section fournit des informations générales sur le développement de logiciels avec le Kit AWS SDKpour .NET.

Pour plus d'informations sur le développement de logiciels pour des services AWS spécifiques, consultezExemples de code (p. 69).

Rubriques• Configuration de votre application Kit AWS SDK pour .NET (p. 22)• API asynchrones AWS pour .NET (p. 55)• Nouvelles tentatives et délais d’expiration (p. 63)• Paginators (p. 66)• Migration vers la version 3 du kit Kit AWS SDK pour .NET (p. 66)• Migration vers la version 3.5 du kit Kit AWS SDK pour .NET (p. 68)• Migration à partir de .NET Standard 1.3 (p. 68)

Configuration de votre application Kit AWS SDKpour .NET

Vous pouvez configurer votre application Kit AWS SDK pour .NET pour spécifier des options dejournalisation, des points de terminaison, ou une prise en charge de Signature version 4 avec Amazon S3.

Pour configurer une application, il est recommandé d'utiliser l'élément <aws> dans le fichier App.configou Web.config du projet. L'exemple suivant spécifie les paramètres AWSRegion (p. 38) etAWSLogging (p. 37).

<configuration> <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/> </configSections> <aws region="us-west-2"> <logging logTo="Log4Net"/> </aws></configuration>

Une autre manière de configurer une application consiste à modifier l'élément <appSettings>dans le fichier App.config ou Web.config du projet. L'exemple suivant spécifie les paramètresAWSRegion (p. 38) et AWSLogging (p. 37).

<configuration> <appSettings> <add key="AWSRegion" value="us-west-2"/> <add key="AWSLogging" value="log4net"/> </appSettings></configuration>

Ces paramètres prennent effet uniquement après la reconstruction de l'application.

22

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration du Kit AWS SDK pour .NET avec .NET Core

Bien que vous puissiez configurer une application Kit AWS SDK pour .NET par programmationen définissant des valeurs de propriété dans la classe AWSConfigs, nous vous recommandonsd'utiliser l'élément aws à la place. L'exemple suivant spécifie les paramètres AWSRegion (p. 38) etAWSLogging (p. 37).

AWSConfigs.AWSRegion = "us-west-2";AWSConfigs.Logging = LoggingOptions.Log4Net;

Les paramètres définis par programmation se substituent aux valeurs spécifiées dans un fichierApp.config ou Web.config. Certaines valeurs de paramètre définies par programmation prennent effetimmédiatement ; d'autres prennent effet seulement après que vous avez créé un nouvel objet client.

Rubriques• Configuration du Kit AWS SDK pour .NET avec .NET Core (p. 23)• Configuration des informations d'identification AWS (p. 26)• Sélection d'une région AWS (p. 35)• Configuration d'autres paramètres de l'application (p. 37)• Référence aux fichiers de configuration pour le Kit AWS SDK pour .NET (p. 42)• Activation des Métriques SDK (p. 51)

Configuration du Kit AWS SDK pour .NET avec .NETCoreL’un des plus grands changements dans.NET Core est la suppression de ConfigurationManageret la norme app.config et web.config qui ont été utilisés avec les applications.NET Framework etASP.NET.

La configuration dans.NET Core est basée sur des paires clé-valeur établies par les fournisseurs deconfiguration. Les fournisseurs de configuration lisent les données de configuration en paires clé-valeur àpartir de diverses sources de configuration, y compris des arguments de ligne de commande, des fichiersde répertoire, des variables d'environnement et des fichiers de paramètres.

Note

Pour plus d'informations, consultez Configuration in ASP.NET Core.

Pour faciliter l’utilisation du Kit AWS SDK pour .NET avec.NET Core, vous pouvez utiliser le pourAWSSDK.Extensions.NETCore.Setup Package NuGet. Comme de nombreuses bibliothèques.NETCore, elle ajoute des méthodes d’extension à IConfiguration pour obtenir le AWS de configurationtransparente.

Utilisation d'AWSSDK.Extensions.NETCore.SetupSupposons que vous créiez une application ASP.NET Core Model-View-Controller (MVC), qui peut êtreréalisée avec le Application Web ASP.NET Core modèle dans Visual Studio ou en exécutant dotnet newmvc ... dans l’interface de ligne de commande.NET Core. Lorsque vous créez une telle application,le constructeur pour Startup.cs gère la configuration en lisant les différentes sources d’entrée desfournisseurs de configuration tels que appsettings.json.

public Startup(IConfiguration configuration){ Configuration = configuration;}

23

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration du Kit AWS SDK pour .NET avec .NET Core

Pour utiliser le Configuration pour obtenir le AWS options, ajoutez d’abord leAWSSDK.Extensions.NETCore.Setup Package NuGet. Ensuite, ajoutez vos options au fichier deconfiguration comme décrit ci-dessous.

Les paramètres de configuration suivants présentent des exemples de valeurs que vous pouvez ajouterdans le appsettings.Development.json dans votre projet pour fournir AWS des paramètres.

{ "AWS": { "Profile": "local-test-profile", "Region": "us-west-2" }, "SupportEmail": "TechSupport@example.com"}

Pour accéder à un paramètre dans un du CSHTML utilisez le fichier Configuration de la directive.

@using Microsoft.Extensions.Configuration@inject IConfiguration Configuration

<h1>Contact</h1>

<p> <strong>Support:</strong> <a href='mailto:@Configuration["SupportEmail"]'>@Configuration["SupportEmail"]</a><br /></p>

Pour accéder au AWS options définies dans le fichier à partir du code, appelez le GetAWSOptionsméthode d’extension ajoutée à IConfiguration.

Pour construire un client de service à partir de ces options, appelez CreateServiceClient. L’exemplesuivant montre comment créer un Amazon S3 client de service. (Assurez-vous d’ajouter le pour le protocoleAWSSDK.S3 le package NuGet pour votre projet.)

var options = Configuration.GetAWSOptions();IAmazonS3 client = options.CreateServiceClient<IAmazonS3>();

Vous pouvez également créer plusieurs clients de service avec des paramètres incompatibles en utilisantplusieurs entrées dans le appsettings.Development.json , comme illustré dans les exemplessuivants où la configuration pour service1 inclut le us-west-2 Région et configuration pour service2inclut le point de terminaison spécial URL.

{ "service1": { "Profile": "default", "Region": "us-west-2" }, "service2": { "Profile": "default", "ServiceURL": "URL" }}

Vous pouvez ensuite obtenir les options pour un service spécifique en utilisant l'entrée dans le fichierJSON. Par exemple, pour obtenir les paramètres pour service1 utilisez le suivant.

var options = Configuration.GetAWSOptions("service1");

24

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration du Kit AWS SDK pour .NET avec .NET Core

Valeurs autorisées dans le fichier appsettingsLes valeurs de configuration d'application suivantes peuvent être définies dans le fichierappsettings.Development.json. Les noms de champ doivent utiliser le corps illustré. Pour plus dedétails sur ces paramètres, consultez le Propriété AWS.Runtime.ClientConfig pour classe.

• Région• Profil• ProfilesLocation• SignatureVersion• RegionEndpoint• UseHttp• ServiceURL• AuthenticationRegion• AuthenticationServiceName• MaxErrorRetry• LogResponse• BufferSize• ProgressUpdateInterval• ResignRetries• AllowAutoRedirect• LogMetrics• DisableLogging• UseDualstackEndpoint

Injection de dépendance ASP.NET CoreLe package NuGet AWSSDK.Extensions.NETCore.Setup s'intègre également à un nouveau systèmed'injection de dépendances dans ASP.NET Core. Le ConfigureServices méthode dans la méthodede votre application Startup est l’endroit où les services MVC sont ajoutés. Si l'application utilise EntityFramework, c'est également là que l'initialisation se produit.

public void ConfigureServices(IServiceCollection services){ // Add framework services. services.AddMvc();}

Note

Contexte sur l’injection de dépendance dans.NET Core est disponible sur le site dedocumentation.NET Core.

Le AWSSDK.Extensions.NETCore.Setup Le package NuGet ajoute de nouvelles méthodes d’extensionà IServiceCollection que vous pouvez utiliser pour ajouter AWS vers l’injection de dépendance.Le code suivant vous montre comment ajouter le AWS qui sont lues à partir de IConfiguration pourajouter Amazon S3 et DynamoDB à la liste des services. (Assurez-vous d’ajouter le pour le protocoleAWSSDK.S3 et pour AWSSDK.DynamoDBv2 des packages NuGet pour votre projet.)

public void ConfigureServices(IServiceCollection services){ // Add framework services. services.AddMvc();

25

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

services.AddDefaultAWSOptions(Configuration.GetAWSOptions()); services.AddAWSService<IAmazonS3>(); services.AddAWSService<IAmazonDynamoDB>();}

Désormais, si vos contrôleurs MVC utilisent IAmazonS3 ou IAmazonDynamoDB en tant que paramètresdans leurs constructeurs, le système d'injection de dépendances transmet ces services.

public class HomeController : Controller{ IAmazonS3 S3Client { get; set; }

public HomeController(IAmazonS3 s3Client) { this.S3Client = s3Client; }

...

}

Configuration des informations d'identification AWSVous devez gérer vos informations d'identification AWS de façon sûre et éviter les pratiques susceptiblesd'exposer involontairement vos informations d'identification au public. Dans cette rubrique, nous vousexpliquons comment configurer les informations d'identification AWS de votre application de façon à enassurer la sécurité.

• N'utilisez pas les informations d'identification racine de votre compte pour accéder à vos ressourcesAWS. Ces informations d'identification offrent un accès illimité au compte et sont difficiles à révoquer.

• N'introduisez pas de clés d'accès littérales dans votre application, y compris le fichier App.configou Web.config du projet. Vous risqueriez en effet d'exposer accidentellement vos informationsd'identification si, par exemple, vous chargiez le projet sur un référentiel public.

Note

Nous considérons que vous avez créé un compte AWS et que vous avez accès à vos informationsd'identification. Si ce n'est pas encore le cas, consultez Créer un compte AWS et des informationsd'identification (p. 15).

Voici des recommandations générales pour gérer les informations d'identification de façon sûre :

• Créez des utilisateurs IAM et utilisez leurs informations d'identification d'utilisateur IAM plutôt que votreutilisateur racine AWS. Les informations d'identification d'utilisateur IAM sont plus faciles à révoquer sielles sont compromises. Vous pouvez appliquer une stratégie à chaque utilisateur IAM qui le limite à unensemble déterminé de ressources et d'actions.

• Lors du développement d'application, la méthode à privilégier pour gérer les informations d'identificationconsiste à placer un profil pour chaque ensemble d'informations d'identification d'utilisateur IAM dans leSDK Store. Vous pouvez également utiliser un fichier d'informations d'identification en texte brut pourstocker les profils qui contiennent des informations d'identification. Vous pouvez alors faire référenceà un profil spécifique par programmation au lieu de stocker les informations d'identification dans vosfichiers de projet. Pour limiter le risque d'exposition involontaire d'informations d'identification, stockez leSDK Store ou le fichier d'informations d'identification séparément de vos fichiers de projet.

• Utilisez des Rôles IAM pour les tâches pour les tâches Amazon Elastic Container Service (AmazonECS).

• Utilisez des rôles IAM pour les applications qui s'exécutent sur des instances Amazon EC2.

26

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

• Utilisez des informations d'identification temporaires ou des variables d'environnement pour lesapplications accessibles aux utilisateurs extérieurs à votre organisation.

Les rubriques suivantes expliquent comment gérer les informations d'identification pour une application KitAWS SDK pour .NET. Pour savoir comment gérer en toute sécurité les informations d'identification AWS,consultez Bonnes pratiques en matière de gestion des clés d'accès AWS.

Utilisation du SDK StorePendant le développement de votre application Kit AWS SDK pour .NET, ajoutez un profil au SDKStore pour chaque ensemble d'informations d'identification que vous souhaitez utiliser dans votreapplication. Cela empêche vos informations d'identification AWS d'être exposées accidentellement. LeSDK Store se situe dans le dossier C:\Users\<username>\AppData\Local\AWSToolkit du fichierRegisteredAccounts.json. Le SDK Store offre les avantages suivants :

• Le SDK Store peut contenir plusieurs profils d'un nombre indéterminé de comptes.• Dans le SDK Store, les informations d'identification sont chiffrées, et le SDK Store réside dans le

répertoire de base de l'utilisateur. Cela limite le risque d'exposition accidentelle de vos informationsd'identification.

• Vous faites référence au profil par son nom dans votre application et les informations d'identificationassociées sont référencées au moment de l'exécution. Vos fichiers source ne contiennent jamais lesinformations d'identification.

• Si vous incluez un profil nommé default, le Kit AWS SDK pour .NET utilise ce profil. C'est également lecas si vous ne fournissez pas un autre nom de profil ou si le nom spécifié est introuvable.

• Le SDK Store fournit également les informations d'identification aux Outils AWS pour WindowsPowerShell et à AWS Toolkit for Visual Studio.

Note

Les profils du SDK Store sont propres à un utilisateur donné sur un hôte déterminé. Ils ne peuventpas être copiés sur d'autres hôtes ou d'autres utilisateurs. C'est pour cette raison que vous nepouvez pas utiliser les profils du SDK Store dans des applications de production. Pour plusd'informations, consultez Résolution des informations d'identification et des profils (p. 32).

Vous pouvez gérer les profils dans le SDK Store de différentes manières.

• Utilisez l'interface utilisateur graphique (GUI) d'AWS Toolkit for Visual Studio pour gérer les profils. Pourplus d'informations sur l'ajout d'informations d'identification au SDK Store à l'aide de l'interface utilisateur,consultez Fournir les informations d’identification AWS dans AWS Toolkit for Visual Studio.

• Vous pouvez gérer vos profils à partir de la ligne de commande en utilisant l'applet de commande Set-AWSCredentials dans Outils AWS pour Windows PowerShell. Pour plus d'informations, consultezUtilisation des informations d'identification AWS.

• Vous pouvez créer et gérer vos profils par programmation en utilisant la classeAmazon.Runtime.CredentialManagement.CredentialProfile.

Les exemples suivants montrent comment créer un profil de base et un profil SAML et comment les ajouterau SDK Store à l'aide de la méthode RegisterProfile.

Création d'un profil et enregistrement de celui-ci dans le fichier d'informationsd'identification .NETCréez un objet Amazon.Runtime.CredentialManagement.CredentialProfileOptionset définissez ses propriétés AccessKey et SecretKey. Créez un objetAmazon.Runtime.CredentialManagement.CredentialProfile. Indiquez le nom du profil et l'objet

27

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

CredentialProfileOptions que vous avez créé. Définissez éventuellement la propriété Region duprofil. Instanciez un objet NetSDKCredentialsFile et appelez la méthode RegisterProfile pour inscrire leprofil.

var options = new CredentialProfileOptions{ AccessKey = "access_key", SecretKey = "secret_key"};var profile = new Amazon.Runtime.CredentialManagement.CredentialProfile("basic_profile", options);profile.Region = RegionEndpoint.USWest1;var netSDKFile = new NetSDKCredentialsFile();netSDKFile.RegisterProfile(profile);

La méthode RegisterProfile sert à inscrire un nouveau profil. En règle générale, votre applicationn'appelle cette méthode qu'une seule fois pour chaque profil.

Création d'un SAMLEndpoint et d'un profil associé et enregistrement de celui-cidans le fichier d'informations d'identification .NETCréez un objet Amazon.Runtime.CredentialManagement.SAMLEndpoint.Indiquez le nom et les paramètres d'URI du point de terminaison. Créez un objetAmazon.Runtime.CredentialManagement.SAMLEndpointManager. Appelez laméthode RegisterEndpoint pour inscrire le point de terminaison. Créez un objetAmazon.Runtime.CredentialManagement.CredentialProfileOptions et définissez ses propriétésEndpointName et RoleArn. Créez un objet Amazon.Runtime.CredentialManagement.CredentialProfileet indiquez le nom du profil et l'objet CredentialProfileOptions que vous avez créé. Définissezéventuellement la propriété Region du profil. Instanciez un objet NetSDKCredentialsFile et appelez laméthode RegisterProfile pour inscrire le profil.

var endpoint = new SAMLEndpoint("endpoint1", new Uri("https://some_saml_endpoint"), SAMLAuthenticationType.Kerberos);var endpointManager = new SAMLEndpointManager();endpointManager.RegisterEndpoint(endpoint);options = new CredentialProfileOptions{ EndpointName = "endpoint1", RoleArn = "arn:aws:iam::999999999999:role/some-role"};profile = new CredentialProfile("federated_profile", options);netSDKFile = new NetSDKCredentialsFile();netSDKFile.RegisterProfile(profile);

Utilisation d'un fichier d'informations d'identificationVous pouvez également stocker les profils dans votre fichier d'informations d'identification AWS partagé.Ce fichier peut être utilisé par les autres kits SDK AWS, l'AWS CLI et les Outils AWS pour WindowsPowerShell. Pour réduire le risque d'exposition accidentelle des informations d'identification, stockez lefichier d'informations d'identification séparément des fichiers de projet, généralement dans le dossier debase de l'utilisateur. Sachez que les profils présents dans les fichiers d'informations d'identification sontstockés en texte brut.

Par défaut, ce fichier se trouve dans le .aws dans votre répertoire de base et est nommé credentials.Pour plus d’informations, consultez Où les paramètres de configuration sont-ils stockés ? dans le AWSCommand Line Interface Guide de l'utilisateur.

Vous pouvez gérer les profils dans le fichier d'informations d'identification partagées de deux façonsdifférentes :

28

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

• Vous pouvez utiliser un éditeur de texte. Le fichier est nommé credentials et son emplacementpar défaut se trouve sous votre dossier de base d'utilisateur. Par exemple, si votre nom d'utilisateurest awsuser, le fichier d'informations d'identification se nomme C:\users\awsuser\.aws\credentials.

Voici un exemple de profil dans le fichier d'informations d'identification.

[{profile_name}]aws_access_key_id = {accessKey}aws_secret_access_key = {secretKey}

Pour plus d'informations, consultez Bonnes pratiques en matière de gestion des clés d'accès AWS.Note

Si vous incluez un profil nommé default, le Kit AWS SDK pour .NET utilise ce profil par défauts'il ne parvient pas à trouver le profil spécifié.

Vous pouvez stocker le fichier d’informations d’identification qui contient les profils dans un emplacementque vous choisissez, tel que C:\aws_service_credentials\credentials. Vous spécifiezensuite explicitement le chemin d’accès au fichier dans le champ AWSProfilesLocation dans votreprojet App.config ou Web.config fichier. Pour plus d'informations, consultez Spécification d'unprofil (p. 33).

• Vous pouvez gérer par programmation le fichier d'informations d'identification en utilisant les classes del'espace de noms Amazon.Runtime.CredentialManagement.

Définition d'un autre profil d'informations d'identificationLe Kit AWS SDK pour .NET utilise par défaut le profil default, mais vous pouvez modifier le profil utilisé àpartir du fichier d'informations d'identification à l'aide de la variable d'environnement AWS_Profile.

Par exemple, sous Linux, macOS, or Unix, exécutez la commande suivante pour modifier le profil enmyProfile.

export AWS_PROFILE="myProfile"

Sous Windows, utilisez la commande suivante.

set AWS_PROFILE=myProfile

La définition de la variable d'environnement AWS_PROFILE affecte le chargement des informationsd'identification pour tous les kits SDK et outils AWS officiellement pris en charge, notamment l'interface deligne de commande AWS et l'interface de ligne de commande AWS pour PowerShell.

Note

La variable d'environnement est prioritaire sur la propriété système.

Création d'un profil et enregistrement de celui-ci dans le fichier d'informationsd'identification partagéCréez un objet Amazon.Runtime.CredentialManagement.CredentialProfileOptionset définissez ses propriétés AccessKey et SecretKey. Créez un objetAmazon.Runtime.CredentialManagement.CredentialProfile. Indiquez le nom du profil et l'objetCredentialProfileOptions que vous avez créé. Définissez éventuellement la propriété Region duprofil. Instanciez un objet Amazon.Runtime.CredentialManagement.SharedCredentialsFile et appelez laméthode RegisterProfile pour inscrire le profil.

29

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

options = new CredentialProfileOptions{ AccessKey = "access_key", SecretKey = "secret_key"};profile = new CredentialProfile("shared_profile", options);profile.Region = RegionEndpoint.USWest1;var sharedFile = new SharedCredentialsFile();sharedFile.RegisterProfile(profile);

La méthode RegisterProfile sert à inscrire un nouveau profil. Normalement, votre application n'appellecette méthode qu'une seule fois pour chaque profil.

Création d'un profil source et d'un profil de rôle assumé associé et enregistrementde celui-ci dans le fichier d'informations d'identification

Créez un objet Amazon.Runtime.CredentialManagement.CredentialProfileOptionspour le profil source et définissez ses propriétés AccessKey et SecretKey. Créezun objet Amazon.Runtime.CredentialManagement.CredentialProfile. Indiquezle nom du profil et l'objet CredentialProfileOptions que vous avez créé.Instanciez un objet Amazon.Runtime.CredentialManagement.SharedCredentialsFileet appelez la méthode RegisterProfile pour inscrire le profil. Créez un autre objetAmazon.Runtime.CredentialManagement.CredentialProfileOptions pour le profil de rôleassumé et définissez les propriétés SourceProfile et RoleArn du profil. Créez un objetAmazon.Runtime.CredentialManagement.CredentialProfile pour le rôle assumé. Indiquez le nom du profil etl'objet CredentialProfileOptions que vous avez créé.

// Create the source profile and save it to the shared credentials filevar sourceProfileOptions = new CredentialProfileOptions{ AccessKey = "access_key", SecretKey = "secret_key"};var sourceProfile = new CredentialProfile("source_profile", sourceProfileOptions);sharedFile = new SharedCredentialsFile();sharedFile.RegisterProfile(sourceProfile);

// Create the assume role profile and save it to the shared credentials filevar assumeRoleProfileOptions = new CredentialProfileOptions{ SourceProfile = "source_profile", RoleArn = "arn:aws:iam::999999999999:role/some-role"};var assumeRoleProfile = new CredentialProfile("assume_role_profile", assumeRoleProfileOptions);sharedFile.RegisterProfile(assumeRoleProfile);

Mise à jour d'un profil existant dans le fichier d'informations d'identification partagé

Créez un objet Amazon.Runtime.CredentialManagement.SharedCredentialsFile. Définissez les propriétésRegion, AccessKey et SecretKey pour le profil. Appelez la méthode TryGetProfile. Si le profil existe,utilisez une instance Amazon.Runtime.CredentialManagement.SharedCredentialsFile pour appeler laméthode RegisterProfile et inscrire le profil mis à jour.

sharedFile = new SharedCredentialsFile();CredentialProfile basicProfile;if (sharedFile.TryGetProfile("basicProfile", out basicProfile)){ basicProfile.Region = RegionEndpoint.USEast1;

30

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

basicProfile.Options.AccessKey = "different_access_key"; basicProfile.Options.SecretKey = "different_secret_key";

sharedFile.RegisterProfile(basicProfile);}

Accès aux informations d'identification et aux profils dans uneapplicationVous pouvez facilement localiser les informations d'identification et les profils dans le fichierd'informations d'identification .NET ou dans le fichier d'informations d'identification partagé enutilisant la classe Amazon.Runtime.CredentialManagement.CredentialProfileStoreChain. C'est decette façon que le kit SDK .NET recherche les informations d'identification et les profils. La classeCredentialProfileStoreChain archive automatiquement ces deux fichiers d'informationsd'identification.

Vous pouvez obtenir les informations d'identification ou les profils à l'aide des méthodesTryGetAWSCredentials ou TryGetProfile. La propriété ProfilesLocation détermine le comportement deCredentialsProfileChain, comme suit :

1. Si ProfilesLocation n'a pas la valeur null et n'est pas vide, effectuez une recherche dans le fichierd'informations d'identification indiqué dans le chemin du disque dans la propriété ProfilesLocation.

2. Si ProfilesLocation a la valeur null ou est vide et que la plateforme prend en charge lefichier d'informations d'identification .NET, effectuez une recherche dans le fichier d'informationsd'identification .NET. Si le profil est introuvable, effectuez une recherche dans le fichier d'informationsd'identification partagé à l'emplacement par défaut.

3. Si ProfilesLocation a la valeur null ou est vide et que la plateforme ne prend pas en chargele fichier d'informations d'identification .NET, effectuez une recherche dans le fichier d'informationsd'identification partagé à l'emplacement par défaut.

Obtention d'informations d'identification à partir du fichier d'informationsd'identification du kit SDK ou du fichier d'informations d'identification partagé àl'emplacement par défautCréez un objet CredentialProfileStoreChain et un objet Amazon.Runtime.AWSCredentials. Appelezla méthode TryGetAWSCredentials. Indiquez le nom du profil et l'objet AWSCredentials dans lequelrenvoyer les informations d'identification.

var chain = new CredentialProfileStoreChain();AWSCredentials awsCredentials;if (chain.TryGetAWSCredentials("basic_profile", out awsCredentials)){ // use awsCredentials}

Obtention d'un profil à partir du fichier d'informations d'identification du kit SDK oudu fichier d'informations d'identification partagé à l'emplacement par défautCréez un objet CredentialProfileStoreChain et un objetAmazon.Runtime.CredentialManagement.CredentialProfile. Appelez la méthode TryGetProfileet indiquez le nom du profil et l'objet CredentialProfile dans lequel renvoyer les informationsd'identification.

var chain = new CredentialProfileStoreChain();CredentialProfile basicProfile;

31

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

if (chain.TryGetProfile("basic_profile", out basicProfile)){ // Use basicProfile}

Obtention d'AWSCredentials à partir d'un fichier dans le format de fichierd'informations d'identification partagé à un emplacement de fichierCréez un objet CredentialProfileStoreChain et indiquez le chemin du fichier d'informationsd'identification. Créez un objet AWSCredentials. Appelez la méthode TryGetAWSCredentials.Indiquez le nom du profil et l'objet AWSCredentials dans lequel renvoyer les informations d'identification.

var chain = new CredentialProfileStoreChain("c:\\Users\\sdkuser\\customCredentialsFile.ini");AWSCredentials awsCredentials;if (chain.TryGetAWSCredentials("basic_profile", out awsCredentials)){ // Use awsCredentials}

Création d'un AmazonS3Client à l'aide de la classe SharedCredentialsFileVous pouvez créer un objet AmazonS3Client qui utilise les informations d'identification d'un profil spécifiqueà l'aide de la classe Amazon.Runtime.CredentialManagement.SharedCredentialsFile. Le Kit AWS SDKpour .NET charge automatiquement les informations d'identification contenues dans le profil. Cela peuts'avérer utile si vous souhaitez utiliser un profil déterminé pour un client donné qui est différent de profileque vous spécifiez dans App.Config.

CredentialProfile basicProfile;AWSCredentials awsCredentials;var sharedFile = new SharedCredentialsFile();if (sharedFile.TryGetProfile("basic_profile", out basicProfile) && AWSCredentialsFactory.TryGetAWSCredentials(basicProfile, sharedFile, out awsCredentials)){ using (var client = new AmazonS3Client(awsCredentials, basicProfile.Region)) { var response = client.ListBuckets(); }}

Si vous souhaitez utiliser le profil par défaut et faire en sorte que le Kit AWS SDK pour .NET utiliseautomatiquement vos informations d'identification par défaut pour créer l'objet client, utilisez le codesuivant.

using (var client = new AmazonS3Client(RegionEndpoint.US-West2)){ var response = client.ListBuckets();}

Résolution des informations d'identification et des profilsLe Kit AWS SDK pour .NET recherche les informations d'identification dans l'ordre suivant et utilise lepremier ensemble disponible pour l'application active.

1. Configuration du client ou ce qui est explicitement défini sur le client de service AWS.2. Informations d'identification BasicAWSCredentials créées à partir des valeurs AWSAccessKey et

AWSSecretKey AppConfig, si elles sont disponibles.

32

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

3. Profil d'informations d'identification avec le nom spécifié par une valeur dansAWSConfigs.AWSProfileName (définie explicitement ou dans AppConfig).

4. Profil d'informations d'identification default.5. Informations d'identification SessionAWSCredentials créées à partir des variables d'environnement

AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY et AWS_SESSION_TOKEN, si toutes ne sont pasvides.

6. Informations d'identification BasicAWSCredentials créées à partir des variables d'environnementAWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY, si les deux ne sont pas vides.

7. Rôles IAM pour les tâches pour les tâches Amazon ECS.8. Métadonnées d'instance EC2.

Les profils du SDK Store sont propres à un utilisateur donné sur un hôte déterminé. Vous ne pouvez pasles copier vers d'autres hôtes ou d'autres utilisateurs. C'est pour cette raison que vous ne pouvez pasréutiliser des profils SDK Store qui se trouvent sur votre machine de développement ou d'autres hôtes oumachines de développeur. Si votre application s'exécute sur une instance Amazon EC2, comme dans unenvironnement de production, utilisez un rôle IAM comme indiqué dans Utilisation de rôles IAM pour desinstances EC2 avec le kit AWS SDK pour .NET (p. 142). Sinon, par exemple dans un test en versionpréliminaire, stockez vos informations d'identification dans un fichier d'informations d'identification auquelvotre application web a accès sur le serveur.

Résolution des profils

Avec deux types de fichier d'informations d'identification différents, il est important de savoir commentconfigurer le Kit AWS SDK pour .NET et les Outils AWS pour Windows PowerShell pour les utiliser.AWSConfigs.AWSProfilesLocation (défini explicitement ou dans AppConfig) contrôle la façondont le Kit AWS SDK pour .NET recherche les profils d'informations d'identification. L'argument de lignede commande -ProfileLocation contrôle la façon dont les Outils AWS pour Windows PowerShellrecherchent un profil. Voici comment fonctionne la configuration dans les deux cas.

Valeur de l'emplacement du profil Comportement de résolution du profil

null (non défini) ou vide Dans un premier temps, recherche dans le fichierd'informations d'identification .NET d'un profilavec le nom spécifié. Si le profil n’est pas présent,recherchez %HOME%\.aws\credentials. Si leprofil n’est pas présent, recherchez %HOME%\.aws\config.

Chemin d'un fichier dans le format de fichierd'informations d'identification partagé

Recherche uniquement dans le fichier spécifié unprofil portant le nom spécifié.

Spécification d'un profil

Les profils constituent la méthode privilégiée pour utiliser les informations d'identification dans uneapplication Kit AWS SDK pour .NET. Vous n'avez pas besoin de spécifier l'emplacement de stockage duprofil. Il suffit de faire référence au profil par le nom. Le Kit AWS SDK pour .NET récupère les informationsd'identification correspondantes, comme décrit dans la section précédente.

Le meilleur moyen de spécifier un profil est de définir une valeur AWSProfileName dans la sectionappSettings du fichier App.config ou Web.config de votre application. Les informationsd'identification associées sont incorporées dans l'application pendant le processus de création.

L'exemple suivant spécifie un profil nommé development.

33

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration des informations d'identification AWS

<configuration> <appSettings> <add key="AWSProfileName" value="development"/> </appSettings></configuration>

Cet exemple considère que le profil existe dans le SDK Store ou dans un fichier d'informationsd'identification à l'emplacement par défaut.

Si vos profils sont stockés dans un fichier d'informations d'identification situé à un autre emplacement,spécifiez cet emplacement en ajoutant une valeur d'attribut AWSProfilesLocation dans l'élément<appSettings>. L'exemple suivant spécifie C:\aws_service_credentials\credentials commefichier d'informations d'identification.

<configuration> <appSettings> <add key="AWSProfileName" value="development"/> <add key="AWSProfilesLocation" value="C:\aws_service_credentials\credentials"/> </appSettings></configuration>

L'autre façon obsolète de spécifier un profil est présentée ci-dessous à titre d'information, mais nous ladéconseillons.

<configuration> <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/> </configSections> <aws profileName="development" profilesLocation="C:\aws_service_credentials\credentials"/></configuration>

<configuration> <configSections> <section name="aws" type="Amazon.AWSSection,AWSSDK.Core"/> </configSections> <aws profileName="development" profilesLocation="C:\aws_service_credentials\credentials"/></configuration>

Utilisation d'informations d'identification de compte d'utilisateur fédéréLes applications qui utilisent le Kit AWS SDK pour .NET (AWSSDK.Core version 3.1.6.0 et ultérieures)peuvent accéder aux services web AWS en utilisant des comptes d'utilisateur fédéré via les services defédération Active Directory (AD FS) en utilisant le langage SAML (Security Assertion Markup Language).

La prise en charge de l'accès fédéré signifie que les utilisateurs peuvent s'authentifier en utilisant votreinstance Active Directory. Des informations d'identification temporaires sont automatiquement accordéesà l'utilisateur. Ces informations d'identification temporaires, qui sont valides pendant une heure, sontutilisées au moment où votre application appelle les services web AWS. Le kit SDK se charge de gérerles informations d'identification temporaires. Pour les comptes utilisateur joints à un domaine, si votreapplication effectue un appel mais que les informations d'identification ont expiré, l'utilisateur est denouveau authentifié automatiquement et de nouvelles informations d'identification lui sont octroyées. (Pourles comptes non joints à un domaine, l'utilisateur est invité à entrer des informations d'identification avant lanouvelle authentification.)

Pour profiter de cette prise en charge dans votre application .NET, vous devez d'abord configurer le profilde rôle à l'aide d'une applet de commande PowerShell. Pour savoir comment procéder, consultez ladocumentation des outils AWS pour Windows PowerShell.

34

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Sélection d'une région AWS

Après avoir configuré le profil de rôle, faites référence au profil dans le fichier app.config/web.config devotre application avec la clé AWSProfileName comme vous le feriez avec d'autres profils d'informationsd'identification.

L'assembly SDK Security Token Service (AWSSDK.SecurityToken.dll), qui est chargé au momentde l'exécution, assure une prise en charge du langage SAML pour obtenir les informations d'identificationAWS. Vérifiez que cet assembly est accessible à votre application au moment de l'exécution.

Spécification de rôles ou d'informations d'identification temporaires

Pour les applications qui s'exécutent sur des instances Amazon EC2, le moyen le plus sûr de gérer lesinformations d'identification est d'utiliser des rôles IAM, comme indiqué dans la section relative à l'utilisationde rôles IAM pour des instances EC2 avec le kit AWS SDK pour .NET (p. 142).

Pour les scénarios d'application dans lesquels l'exécutable logiciel est accessible à des utilisateursextérieurs à votre organisation, nous vous recommandons de concevoir le logiciel de façon à utiliser desinformations d'identification de sécurité temporaires. En plus de fournir un accès limité aux ressourcesAWS, ces informations d'identification présentent l'avantage d'expirer au bout d'un certain laps de temps.Pour plus d'informations sur les informations d'identification de sécurité temporaires, consultez lesrubriques suivantes :

• Utilisation de jetons de sécurité pour accorder un accès temporaire à vos ressources AWS• Authentification des utilisateurs des applications mobiles AWS avec un Token Vending Machine.

Bien que le titre du deuxième article fasse précisément référence à des applications mobiles, l'articlecontient des informations utiles pour toute application AWS déployée en dehors de votre organisation.

Utilisation d'informations d'identification de proxy

Si votre logiciel communique avec AWS via un proxy, vous pouvez spécifier des informationsd'identification pour le proxy à l'aide de la propriété ProxyCredentials de la classe AmazonS3Configdu service. Par exemple, pour Amazon S3, vous pouvez utiliser du code similaire à celui qui suit, où {my-username} et {my-password} correspondent au nom d'utilisateur et au mot de passe du proxy spécifiésdans un objet NetworkCredential.

AmazonS3Config config = new AmazonS3Config();config.ProxyCredentials = new NetworkCredential("my-username", "my-password");

Les versions antérieures du kit SDK utilisaient ProxyUsername et ProxyPassword, mais ces propriétéssont obsolètes.

Sélection d'une région AWSLes régions AWS permettent d'accéder à des services AWS qui résident physiquement dans une régiongéographique spécifique. Cela peut être utile pour la redondance et pour conserver vos données et vosapplications en cours d'exécution près de l'endroit où vous et vos utilisateurs y accèderez. Vous pouvezspécifier une région lors de la création d'un client de service AWS à l'aide de la classe RegionEndpoint.

Voici un exemple qui instancie un client Amazon EC2 dans une région spécifique.

AmazonEC2Client ec2Client = new AmazonEC2Client(RegionEndpoint.USEast1);

Les régions sont isolées les unes par rapport aux autres. Par exemple, vous ne pouvez pas accéder auxressources de la région USA Est (Virginie du Nord) si vous utilisez la région Europe (Irlande). Si votre code

35

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Sélection d'une région AWS

doit accéder à plusieurs régions AWS, nous vous recommandons de créer un client distinct pour chaquerégion.

Pour utiliser les services dans la région Chine (Beijing), vous devez posséder un compte et lesinformations d'identification qui sont spécifiques à la région Chine (Beijing). Les comptes et les informationsd'identification pour les autres régions AWS ne fonctionnent pas pour la région Chine (Beijing). De même,les comptes et les informations d'identification pour la région Chine (Beijing) ne fonctionnent pas pour lesautres régions AWS. Pour plus d'informations sur les points de terminaison et les protocoles disponiblesdans la région Chine (Beijing), consultez Région Chine (Beijing).

De nouveaux services AWS peuvent être lancés d'abord dans quelques régions, puis prises en chargedans d'autres régions. Dans ce cas, vous n'avez pas besoin d'installer le kit SDK le plus récent pouraccéder aux nouvelles régions. Vous pouvez spécifier des régions nouvellement ajoutées par client ouglobalement.

Par clientLa définition de la région dans un client est prioritaire sur n'importe quel paramètre global.

Construisez le point de terminaison de la nouvelle région à l'aide de GetBySystemName :

var newRegion = RegionEndpoint.GetBySystemName("us-west-new");using (var ec2Client = new AmazonEC2Client(newRegion)){ // Make a request to EC2 using ec2Client}

Vous pouvez également utiliser la propriété ServiceURL de la classe de configuration du client de servicepour spécifier la région. Cette technique fonctionne même si le point de terminaison de la région ne suit pasle schéma de point de terminaison de région habituel.

var ec2ClientConfig = new AmazonEC2Config{ // Specify the endpoint explicitly ServiceURL = "https://ec2.us-west-new.amazonaws.com"};

using (var ec2Client = new AmazonEC2Client(ec2ClientConfig)){ // Make a request to EC2 using ec2Client}

GloballyIl existe plusieurs façons de spécifier une région pour tous les clients. Le kit Kit AWS SDK pour .NETrecherche une valeur de région dans l'ordre suivant :

Définie en tant que propriété AWSConfigs.AWSRegion.

AWSConfigs.AWSRegion = "us-west-new";using (var ec2Client = new AmazonEC2Client()){ // Make request to Amazon EC2 using ec2Client}

Définie en tant que clé AWSRegion dans la section appSettings du fichier app.config.

<configuration>

36

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration d'autres paramètres de l'application

<appSettings> <add key="AWSRegion" value="us-west-2"/> </appSettings></configuration>

Définie en tant qu'attribut region dans la section aws, comme décrit dans AWSRegion (p. 38).

<aws region="us-west-2"/>

Pour afficher la liste actuelle des régions et des points de terminaison pris en charge pour chaque serviceAWS, consultez Régions et points de terminaison dans le document Référence générale d'Amazon WebServices.

Configuration d'autres paramètres de l'applicationEn plus de la configuration des informations d'identification (p. 26), vous pouvez configurer d'autresparamètres de l'application :

• AWSLogging (p. 37)• AWSLogMetrics (p. 38)• AWSRegion (p. 38)• AWSResponseLogging (p. 39)• AWS.DynamoDBContext.TableNamePrefix (p. 39)• AWS.S3.UseSignatureVersion4 (p. 40)• AWSEndpointDefinition (p. 40)• Points de terminaison générés par les services AWS (p. 41)

Ces paramètres peuvent être configurés dans le fichier App.config ou Web.config de l'application.Bien que vous puissiez aussi les configurer avec l'API Kit AWS SDK pour .NET, nous vous recommandonsd'utiliser le fichier .config de l'application. Les deux approches sont décrites ici.

Pour plus d'informations sur l'utilisation de l'élément <aws> comme décrit plus loin dans cette rubrique,consultez Référence des fichiers de configuration pour AWS SDK pour .NET (p. 42).

AWSLoggingConfigure comment SDK doit consigner les événements, le cas échéant. Par exemple, l'approcherecommandée consiste à utiliser l'élément <logging>, élément enfant de l'élément <aws> :

<aws> <logging logTo="Log4Net"/></aws>

Autrement :

<add key="AWSLogging" value="log4net"/>

Les valeurs possibles sont :

None

Désactivez la journalisation des événements . Il s'agit de l'option par défaut.

37

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration d'autres paramètres de l'application

log4net

Journaliser à l'aide de log4net.SystemDiagnostics

Journaliser à l'aide de la classe System.Diagnostics.

Vous pouvez définir plusieurs valeurs pour l'attribut logTo, séparées par des virgules. L'exemple suivantdéfinit la journalisation log4net et System.Diagnostics dans le fichier .config :

<logging logTo="Log4Net, SystemDiagnostics"/>

Autrement :

<add key="AWSLogging" value="log4net, SystemDiagnostics"/>

Vous pouvez également utiliser l'API Kit AWS SDK pour .NET pour combiner les valeurs de l'énumérationLoggingOptions et définir la propriété AWSConfigs.Logging :

AWSConfigs.Logging = LoggingOptions.Log4Net | LoggingOptions.SystemDiagnostics;

Les modifications apportées à ce paramètre prennent effet uniquement pour les nouvelles instances clientAWS.

AWSLogMetricsSpécifie si SDK doit ou non journaliser les métriques de performance. Pour définir la configuration dejournalisation des métriques dans le fichier .config, définissez la valeur de l'attribut logMetrics dansl'élément <logging>, élément enfant de l'élément <aws> :

<aws> <logging logMetrics="true"/></aws>

Sinon, définissez la clé AWSLogMetrics dans la section <appSettings> :

<add key="AWSLogMetrics" value="true">

Vous pouvez également définir la journalisation des métriques avec l'API Kit AWS SDK pour .NET endéfinissant la propriété AWSConfigs.LogMetrics :

AWSConfigs.LogMetrics = true;

Ce paramètre configure la propriété LogMetrics par défaut pour tous les clients et toutes lesconfigurations. Les modifications apportées à ce paramètre prennent effet uniquement pour les nouvellesinstances client AWS.

AWSRegionConfigure la région AWS par défaut pour les clients qui n'ont pas explicitement spécifié une région. Pourdéfinir la région dans le fichier .config, l'approche recommandée consiste à définir la valeur de l'attributregion dans l'élément aws :

38

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration d'autres paramètres de l'application

<aws region="us-west-2"/>

Sinon, définissez la clé AWSRegion dans la section <appSettings> :

<add key="AWSRegion" value="us-west-2"/>

Vous pouvez également définir la région avec l'API Kit AWS SDK pour .NET en définissant la propriétéAWSConfigs.AWSRegion :

AWSConfigs.AWSRegion = "us-west-2";

Pour plus d'informations sur la création d'un client AWS pour une région spécifique, consultez Sélectiondes régions AWS (p. 35). Les modifications apportées à ce paramètre prennent effet uniquement pourles nouvelles instances client AWS.

AWSResponseLoggingConfigure quand SDK doit journaliser les réponses du service. Les valeurs possibles sont :

Never

Les réponses du service ne sont jamais journalisées. Il s'agit de l'option par défaut.Always

Les réponses du service sont toujours journalisées.OnError

Journaliser les réponses du service uniquement lorsqu'une erreur se produit.

Pour définir la configuration de journalisation de service dans le fichier .config, l'approche recommandéeconsiste à définir la valeur de l'attribut logResponses dans l'élément <logging>, élément enfant del'élément <aws> :

<aws> <logging logResponses="OnError"/></aws>

Sinon, définissez la clé AWSResponseLogging dans la section <appSettings> :

<add key="AWSResponseLogging" value="OnError"/>

Vous pouvez également utiliser l'API Kit AWS SDK pour .NET pour définir la journalisation deservice en affectant à la propriété AWSConfigs.ResponseLogging une des valeurs de l'énumérationResponseLoggingOption :

AWSConfigs.ResponseLogging = ResponseLoggingOption.OnError;

Les modifications apportées à ce paramètre prennent effet immédiatement.

AWS.DynamoDBContext.TableNamePrefixConfigure la valeur par défaut de TableNamePrefix ; DynamoDBContext est utilisé si aucuneconfiguration manuelle n'est effectuée.

39

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration d'autres paramètres de l'application

Pour définir le préfixe du nom de table dans le fichier .config, l'approche recommandée consiste àdéfinir la valeur de l'attribut tableNamePrefix dans l'élément <dynamoDBContext>, élément enfant del'élément <dynamoDB>, lui-même élément enfant de l'élément <aws> :

<dynamoDBContext tableNamePrefix="Test-"/>

Sinon, définissez la clé AWS.DynamoDBContext.TableNamePrefix dans la section <appSettings> :

<add key="AWS.DynamoDBContext.TableNamePrefix" value="Test-"/>

Vous pouvez également définir le préfixe du nom de table avec l'API Kit AWS SDK pour .NET endéfinissant la propriété AWSConfigs.DynamoDBContextTableNamePrefix :

AWSConfigs.DynamoDBContextTableNamePrefix = "Test-";

Les modifications apportées à ce paramètre prennent effet uniquement pour les instances nouvellementconstruites de DynamoDBContextConfig et DynamoDBContext.

AWS.S3.UseSignatureVersion4Configure si le client Amazon S3 doit utiliser ou non la signature Signature version 4 avec les demandes.

Pour définir la signature Signature version 4 pour Amazon S3 dans le fichier .config, l'approcherecommandée consiste à définir l'attribut useSignatureVersion4 de l'élément <s3>, élément enfant del'élément <aws> :

<aws> <s3 useSignatureVersion4="true"/></aws>

Sinon, définissez la clé AWS.S3.UseSignatureVersion4 sur true dans la section <appSettings> :

<add key="AWS.S3.UseSignatureVersion4" value="true"/>

Vous pouvez également définir la signature Signature version 4 avec l'API Kit AWS SDK pour .NET endéfinissant la propriété AWSConfigs.S3UseSignatureVersion4 sur true :

AWSConfigs.S3UseSignatureVersion4 = true;

Par défaut, ce paramètre est false, mais Signature version 4 peut être utilisé par défaut dans certainscas ou avec certaines régions. Lorsque le paramètre est true, Signature version 4 est utilisé pour toutesles demandes. Les modifications apportées à ce paramètre prennent effet uniquement pour les nouvellesinstances client Amazon S3.

AWSEndpointDefinitionConfigure si SDK doit utiliser un fichier de configuration personnalisé qui définit les régions et les points determinaison.

Pour définir le fichier de définition de point de terminaison dans le fichier .config, nous vousrecommandons de définir la valeur de l'attribut endpointDefinition dans l'élément <aws>.

40

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Configuration d'autres paramètres de l'application

<aws endpointDefinition="c:\config\endpoints.json"/>

Sinon, vous pouvez définir la clé AWSEndpointDefinition dans la section <appSettings> :

<add key="AWSEndpointDefinition" value="c:\config\endpoints.json"/>

Vous pouvez également définir le fichier de définition de point de terminaison avec l'API Kit AWS SDKpour .NET en définissant la propriété AWSConfigs.EndpointDefinition :

AWSConfigs.EndpointDefinition = @"c:\config\endpoints.json";

Si vous n'indiquez pas de nom de fichier, aucun fichier de configuration personnalisé ne sera utilisé. Lesmodifications apportées à ce paramètre prennent effet uniquement pour les nouvelles instances clientAWS. Le fichier endpoint.json est disponible à l'adresse https://github.com/aws/aws-sdk-net/blob/master/sdk/src/Core/endpoints.json.

Points de terminaison générés par les services AWSCertains services AWS génèrent leurs propres points de terminaison plutôt que d'utiliser un point determinaison de région. Les clients de ces services utilisent une URL de service spécifique à chaque serviceet à vos ressources. Amazon CloudSearch et AWS IoT sont deux exemples de ces services. Les exemplessuivants illustrent comment obtenir les points de terminaison pour ces services.

Exemple de points de terminaison Amazon CloudSearchLe client Amazon CloudSearch est utilisé pour l'accès au service de configuration Amazon CloudSearch.Vous utilisez le service de configuration Amazon CloudSearch pour créer, configurer et gérer des domainesde recherche. Pour créer un domaine de recherche, créez un objet CreateDomainRequest et indiquezla propriété DomainName. Créez un objet AmazonCloudSearchClient en utilisant l'objet de demande.Appelez la méthode CreateDomain. L'objet CreateDomainResponse renvoyé à partir de l'appel contientune propriété DomainStatus contenant les deux points de terminaison DocService et SearchService.Créez un objet AmazonCloudSearchDomainConfig et utilisez-le pour initialiser les instances DocServiceet SearchService de la classe AmazonCloudSearchDomainClient.

// Create domain and retrieve DocService and SearchService endpointsDomainStatus domainStatus;using (var searchClient = new AmazonCloudSearchClient()){ var request = new CreateDomainRequest { DomainName = "testdomain" }; domainStatus = searchClient.CreateDomain(request).DomainStatus; Console.WriteLine(domainStatus.DomainName + " created");}

// Test the DocService endpointvar docServiceConfig = new AmazonCloudSearchDomainConfig{ ServiceURL = "https://" + domainStatus.DocService.Endpoint};using (var domainDocService = new AmazonCloudSearchDomainClient(docServiceConfig)){ Console.WriteLine("Amazon CloudSearchDomain DocService client instantiated using the DocService endpoint"); Console.WriteLine("DocService endpoint = " + domainStatus.DocService.Endpoint);

using (var docStream = new FileStream(@"C:\doc_source\XMLFile4.xml", FileMode.Open))

41

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

{ var upload = new UploadDocumentsRequest { ContentType = ContentType.ApplicationXml, Documents = docStream }; domainDocService.UploadDocuments(upload); }}

// Test the SearchService endpointvar searchServiceConfig = new AmazonCloudSearchDomainConfig{ ServiceURL = "https://" + domainStatus.SearchService.Endpoint};using (var domainSearchService = new AmazonCloudSearchDomainClient(searchServiceConfig)){ Console.WriteLine("Amazon CloudSearchDomain SearchService client instantiated using the SearchService endpoint"); Console.WriteLine("SearchService endpoint = " + domainStatus.SearchService.Endpoint);

var searchReq = new SearchRequest { Query = "Gambardella", Sort = "_score desc", QueryParser = QueryParser.Simple }; var searchResp = domainSearchService.Search(searchReq);}

Exemple de points de terminaison AWS IoT

Pour obtenir le point de terminaison pour AWS IoT, créez un objet AmazonIoTClient et appelez la méthodeDescribeEndPoint. Le(s) retourné(s) Décrire la réponse du point final contient l’objet EndpointAddress.Créez un Propriété AmazonIotDataConfig pour objet, définissez le ServiceURL et utilisez l’objet pourinstancier le Client de données Amazon Iot classe.

string iotEndpointAddress;using (var iotClient = new AmazonIoTClient()){ var endPointResponse = iotClient.DescribeEndpoint(); iotEndpointAddress = endPointResponse.EndpointAddress;}

var ioTdocServiceConfig = new AmazonIotDataConfig{ ServiceURL = "https://" + iotEndpointAddress};using (var dataClient = new AmazonIotDataClient(ioTdocServiceConfig)){ Console.WriteLine("AWS IoTData client instantiated using the endpoint from the IotClient");}nstantiated using the endpoint from the IoT client");

Référence aux fichiers de configuration pour le KitAWS SDK pour .NETVous pouvez utiliser le fichier App.config ou Web.config d'un projet .NET pour spécifier les paramètresAWS, tels que les informations d'identification AWS, les options de journalisation, les points de terminaisonde service AWS, les régions AWS, ainsi que certains paramètres de services AWS tels que Amazon

42

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

DynamoDB, Amazon EC2 et Amazon S3. Vous trouverez ci-dessous des informations expliquant commentmettre correctement en forme un fichier App.config ou Web.config pour spécifier ces types deparamètres.

Note

Bien que vous puissiez continuer d'utiliser l'élément <appSettings> dans un fichierApp.config ou Web.config pour spécifier les paramètres AWS, nous vous recommandonsd'utiliser les éléments <configSections> et <aws> comme décrit plus loin dans cette rubrique.Pour plus d'informations sur l'élément <appSettings>, consultez les exemples d'élément<appSettings> dans Configuration de votre application AWS SDK pour .NET (p. 22).

Note

Bien que vous puissiez continuer d'utiliser les propriétés de classe AWSConfigs répertoriéesci-dessous dans un fichier de code afin de spécifier les paramètres AWS, ces propriétés sontobsolètes et risquent de ne pas être prises en charge dans les futures versions :

• DynamoDBContextTableNamePrefix

• EC2UseSignatureVersion4

• LoggingOptions

• LogMetrics

• ResponseLoggingOption

• S3UseSignatureVersion4

En règle générale, au lieu de spécifier les paramètres AWS à l'aide des propriétés declasse AWSConfigs dans un fichier de code, nous recommandons d'utiliser les éléments<configSections> et <aws> dans un fichier App.config ou Web.config, commedécrit plus loin dans cette rubrique. Pour plus d'informations sur les propriétés précédentes,consultez les exemples de code AWSConfigs dans Configuration de votre application AWS SDKpour .NET (p. 22).

Rubriques• Déclaration d'une section de paramètres AWS (p. 43)• Éléments autorisés (p. 44)• Informations de référence sur les éléments (p. 44)

Déclaration d'une section de paramètres AWSLes paramètres AWS sont à spécifier dans un fichier App.config ou Web.config au niveau de l'élément<aws>. Avant de commencer à utiliser l'élément <aws>, vous devez créer un élément <section> (qui estun élément enfant de l'élément <configSections>) et affecter à son attribut name la valeur aws et à sonattribut type la valeur Amazon.AWSSection, AWSSDK.Core, comme dans l'exemple suivant :

<?xml version="1.0"?><configuration> ... <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/> </configSections> <aws> <!-- Add your desired AWS settings declarations here. --> </aws> ...</configuration>

43

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

L'éditeur Visual Studio ne propose pas de fonction de saisie de code automatique (IntelliSense) pourl'élément <aws> ou ses éléments enfants.

Pour vous aider à créer une version correctement mise en forme de l'élément <aws>, appelez la méthodeAmazon.AWSConfigs.GenerateConfigTemplate. Celle-ci génère une version canonique de l'élément<aws> sous la forme d'une chaîne bien formée, que vous pouvez adapter à vos besoins. Les sectionssuivantes décrivent les attributs et les éléments enfants de l'élément <aws>.

Éléments autorisésLa liste suivante répertorie les relations logiques entre les éléments autorisés dans une section deparamètres AWS. Vous pouvez générer la dernière version de cette liste en appelant la méthodeAmazon.AWSConfigs.GenerateConfigTemplate, qui génère une version canonique de l'élément<aws> sous la forme d'une chaîne que vous pouvez adapter à vos besoins.

<aws endpointDefinition="string value" region="string value" profileName="string value" profilesLocation="string value"> <logging logTo="None, Log4Net, SystemDiagnostics" logResponses="Never | OnError | Always" logMetrics="true | false" logMetricsFormat="Standard | JSON" logMetricsCustomFormatter="NameSpace.Class, Assembly" /> <dynamoDB conversionSchema="V1 | V2"> <dynamoDBContext tableNamePrefix="string value"> <tableAliases> <alias fromTable="string value" toTable="string value" /> </tableAliases> <map type="NameSpace.Class, Assembly" targetTable="string value"> <property name="string value" attribute="string value" ignore="true | false" version="true | false" converter="NameSpace.Class, Assembly" /> </map> </dynamoDBContext> </dynamoDB> <s3 useSignatureVersion4="true | false" /> <ec2 useSignatureVersion4="true | false" /> <proxy host="string value" port="1234" username="string value" password="string value" /></aws>

Informations de référence sur les élémentsLa liste suivante répertorie les éléments qui sont autorisés dans une section de paramètres AWS. Pourchaque élément, ses attributs autorisés et éléments parents-enfants sont répertoriés.

44

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

Rubriques• alias (p. 45)• aws (p. 45)• dynamoDB (p. 46)• dynamoDBContext (p. 47)• ec2 (p. 47)• logging (p. 47)• map (p. 49)• property (p. 49)• proxy (p. 50)• s3 (p. 50)

alias

L'élément <alias> représente un élément unique dans une collection d'un ou plusieurs mappages entrela table de départ et la table d'arrivée qui spécifie une table différente de celle configurée pour un type.Cet élément est mappé à une instance de la classe Amazon.Util.TableAlias à partir de la propriétéAmazon.AWSConfigs.DynamoDBConfig.Context.TableAliases du Kit AWS SDK pour .NET. Leremappage intervient avant l'application d'un préfixe de nom de table.

Cet élément peut inclure les attributs suivants :

fromTable

Partie « table de départ » du mappage entre la table de départ et la table d'arrivée. Cet attribut estmappé à la propriété Amazon.Util.TableAlias.FromTable du Kit AWS SDK pour .NET.

toTable

Partie « table d'arrivée » du mappage entre la table de départ et la table d'arrivée. Cet attribut estmappé à la propriété Amazon.Util.TableAlias.ToTable du Kit AWS SDK pour .NET.

Le parent de l'élément <alias> est l'élément <tableAliases>.

L'élément <alias> ne contient aucun élément enfant.

Voici un exemple de l'élément <alias> utilisé :

<alias fromTable="Studio" toTable="Studios" />

aws

L'élément <aws> représente l'élément de niveau supérieur dans une section de paramètres AWS. Cetélément peut inclure les attributs suivants :

endpointDefinition

Chemin absolu d'un fichier de configuration personnalisé qui définit les régionsAWS et les points de terminaison à utiliser. Cet attribut est mappé à la propriétéAmazon.AWSConfigs.EndpointDefinition du Kit AWS SDK pour .NET.

45

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

profileName

Nom de profil des informations d'identification AWS stockées qui seront utilisé pour effectuer desappels de service. Cet attribut est mappé à la propriété Amazon.AWSConfigs.AWSProfileName duKit AWS SDK pour .NET.

profilesLocation

Chemin absolu de l'emplacement du fichier d'informations d'identification partagé avec d'autreskits SDK AWS. Par défaut, le fichier d'informations d'identification est stocké dans le répertoire.aws situé dans le répertoire de base de l'utilisateur actif. Cet attribut est mappé à la propriétéAmazon.AWSConfigs.AWSProfilesLocation du Kit AWS SDK pour .NET.

region

ID de région AWS par défaut pour les clients qui n'ont pas explicitement spécifié de région. Cet attributest mappé à la propriété Amazon.AWSConfigs.AWSRegion du Kit AWS SDK pour .NET.

L'élément <aws> n'a pas d'élément parent.

L'élément <aws> peut inclure les éléments enfants suivants :

• <dynamoDB>

• <ec2>

• <logging>

• <proxy>

• <s3>

Voici un exemple de l'élément <aws> utilisé :

<aws endpointDefinition="C:\Configs\endpoints.xml" region="us-west-2" profileName="development" profilesLocation="C:\Configs"> <!-- ... --></aws>

dynamoDB

L'élément <dynamoDB> représente un ensemble de paramètres pour Amazon DynamoDB. Cet élémentpeut inclure l'attribut conversionSchema, qui représente la version à utiliser pour la conversion entre desobjets .NET et des objets DynamoDB. Les valeurs autorisées sont notamment V1 et V2. Cet attribut estmappé à la classe Amazon.DynamoDBv2.DynamoDBEntryConversion du Kit AWS SDK pour .NET.Pour plus d'informations, consultez DynamoDB Series – Conversion Schemas.

Le parent de l'élément <dynamoDB> est l'élément <aws>.

L'élément <dynamoDB> peut inclure l'élément enfant <dynamoDBContext>.

Voici un exemple de l'élément <dynamoDB> utilisé :

<dynamoDB conversionSchema="V2"> <!-- ... --></dynamoDB>

46

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

dynamoDBContext

L'élément <dynamoDBContext> représente un ensemble de paramètres propres au contexte AmazonDynamoDB. Cet élément peut inclure l'attribut tableNamePrefix, qui représente le préfixe de nom de tablepar défaut que le contexte DynamoDB utilise s'il n'est pas configuré manuellement. Cet attribut est mappéà la propriété Amazon.Util.DynamoDBContextConfig.TableNamePrefix à partir de la propriétéAmazon.AWSConfigs.DynamoDBConfig.Context.TableNamePrefix du Kit AWS SDK pour .NET.Pour plus d'informations, consultez Enhancements to the DynamoDB SDK.

Le parent de l'élément <dynamoDBContext> est l'élément <dynamoDB>.

L'élément <dynamoDBContext> peut inclure les éléments enfants suivants :

• <alias> (une ou plusieurs instances)• <map> (une ou plusieurs instances)

Voici un exemple de l'élément <dynamoDBContext> utilisé :

<dynamoDBContext tableNamePrefix="Test-"> <!-- ... --></dynamoDBContext>

ec2

L'élément <ec2> représente un ensemble de paramètres Amazon EC2. Cet élément peut inclurel'attribut useSignatureVersion4, qui indique si la signature Signature version 4 est utilisée pourtoutes les demandes (true) ou si elle ne l'est pas (false, valeur par défaut). Cet attribut est mappéà la propriété Amazon.Util.EC2Config.UseSignatureVersion4 à partir de la propriétéAmazon.AWSConfigs.EC2Config.UseSignatureVersion4 du Kit AWS SDK pour .NET.

Le parent de l'élément <ec2> est l'élément <aws>.

L'élément <ec2> ne contient aucun élément enfant.

Voici un exemple de l'élément <ec2> utilisé :

<ec2 useSignatureVersion4="true" />

logging

L'élément <logging> représente un ensemble de paramètres pour la journalisation des réponses et lajournalisation des métriques de performance. Cet élément peut inclure les attributs suivants :

logMetrics

Indique si les métriques de performance sont journalisées pour tous les clientset toutes les configurations (true) ; sinon, false. Cet attribut est mappé à lapropriété Amazon.Util.LoggingConfig.LogMetrics à partir de la propriétéAmazon.AWSConfigs.LoggingConfig.LogMetrics du Kit AWS SDK pour .NET.

logMetricsCustomFormatter

Type de données et nom d'assembly d'un formateur personnalisé pourles métriques de performance. Cet attribut est mappé à la propriétéAmazon.Util.LoggingConfig.LogMetricsCustomFormatter à partir de la propriété

47

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

Amazon.AWSConfigs.LoggingConfig.LogMetricsCustomFormatter du Kit AWS SDKpour .NET.

logMetricsFormat

Format sous lequel se présentent les métriques de journalisation (mappé à la propriétéAmazon.Util.LoggingConfig.LogMetricsFormat à partir de la propriétéAmazon.AWSConfigs.LoggingConfig.LogMetricsFormat du Kit AWS SDK pour .NET).

Les valeurs autorisées sont les suivantes :JSON

Utilise le format JSON.Standard

Utilise le format par défaut.logResponses

Indique à quel moment les réponses du service sont journalisées (mappé à lapropriété Amazon.Util.LoggingConfig.LogResponses à partir de la propriétéAmazon.AWSConfigs.LoggingConfig.LogResponses du Kit AWS SDK pour .NET).

Les valeurs autorisées sont les suivantes :Always

Les réponses du service sont toujours journalisées.Never

Les réponses du service ne sont jamais journalisées.OnError

Les réponse du service sont journalisées uniquement en cas d'erreur.logTo

Indique l'emplacement de la journalisation (mappé à la propriété LogTo à partir de la propriétéAmazon.AWSConfigs.LoggingConfig.LogTo du Kit AWS SDK pour .NET).

Les valeurs autorisées comprennent une ou plusieurs des valeurs suivantes :Log4Net

Journalisation dans log4net.None

Disable logging (Désactivation de la journalisation).SystemDiagnostics

Journalisation dans System.Diagnostics.

Le parent de l'élément <logging> est l'élément <aws>.

L'élément <logging> ne contient aucun élément enfant.

Voici un exemple de l'élément <logging> utilisé :

<logging logTo="SystemDiagnostics" logResponses="OnError" logMetrics="true"

48

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

logMetricsFormat="JSON" logMetricsCustomFormatter="MyLib.Util.MyMetricsFormatter, MyLib" />

map

L'élément <map> représente un élément unique dans une collection de mappages des types .NETaux tables DynamoDB (mappé à une instance de la classe TypeMapping à partir de la propriétéAmazon.AWSConfigs.DynamoDBConfig.Context.TypeMappings du Kit AWS SDK pour .NET). Pourplus d'informations, consultez Enhancements to the DynamoDB SDK.

Cet élément peut inclure les attributs suivants :

targetTable

Table DynamoDB à laquelle le mappage s'applique. Cet attribut est mappé à la propriétéAmazon.Util.TypeMapping.TargetTable du Kit AWS SDK pour .NET.

type

Type et nom d'assembly auxquels le mappage s'applique. Cet attribut est mappé à la propriétéAmazon.Util.TypeMapping.Type du Kit AWS SDK pour .NET.

Le parent de l'élément <map> est l'élément <dynamoDBContext>.

L'élément <map> peut inclure une ou plusieurs instances de l'élément enfant <property>.

Voici un exemple de l'élément <map> utilisé :

<map type="SampleApp.Models.Movie, SampleDLL" targetTable="Movies"> <!-- ... --></map>

property

L'élément <property> représente une propriété DynamoDB. (Cet élément est mappé à une instance dela classe Amazon.Util.PropertyConfig à partir de la méthode AddProperty du Kit AWS SDK pour .NET).Pour plus d'informations, consultez Enhancements to the DynamoDB SDK et Attributs DynamoDB.

Cet élément peut inclure les attributs suivants :

attribute

Nom d'un attribut de la propriété, par exemple le nom d'une clé de plage. Cet attribut est mappé à lapropriété Amazon.Util.PropertyConfig.Attribute du Kit AWS SDK pour .NET.

converter

Type du convertisseur qui doit être utilisé pour cette propriété. Cet attribut est mappé à la propriétéAmazon.Util.PropertyConfig.Converter du Kit AWS SDK pour .NET.

ignore

Indique si la propriété associée doit être ignorée (true) ; sinon, false. Cet attribut est mappé à lapropriété Amazon.Util.PropertyConfig.Ignore du Kit AWS SDK pour .NET.

name

Nom de la propriété. Cet attribut est mappé à la propriété Amazon.Util.PropertyConfig.Name duKit AWS SDK pour .NET.

49

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Référence aux fichiers de configuration

pour le Kit AWS SDK pour .NET

version

Indique si cette propriété doit stocker le numéro de version de l'élément (true) ; sinon, false. Cet attributest mappé à la propriété Amazon.Util.PropertyConfig.Version du Kit AWS SDK pour .NET.

Le parent de l'élément <property> est l'élément <map>.

L'élément <property> ne contient aucun élément enfant.

Voici un exemple de l'élément <property> utilisé :

<property name="Rating" converter="SampleApp.Models.RatingConverter, SampleDLL" />

proxy

L'élément <proxy> représente les paramètres de configuration d'un proxy pour le Kit AWS SDK pour .NETà utiliser. Cet élément peut inclure les attributs suivants :

.host

Nom d'hôte ou adresse IP du serveur proxy. Cet attribut est mappé à lapropriété Amazon.Util.ProxyConfig.Host à partir de la propriétéAmazon.AWSConfigs.ProxyConfig.Host du Kit AWS SDK pour .NET.

mot de passe

Mot de passe permettant de s'authentifier auprès du serveur proxy. Cet attribut estmappé à la propriété Amazon.Util.ProxyConfig.Password à partir de la propriétéAmazon.AWSConfigs.ProxyConfig.Password du Kit AWS SDK pour .NET.

port

Numéro de port du proxy. Cet attribut est mappé à la propriété Amazon.Util.ProxyConfig.Port àpartir de la propriété Amazon.AWSConfigs.ProxyConfig.Port du Kit AWS SDK pour .NET.

username

Nom d'utilisateur permettant de s'authentifier auprès du serveur proxy. Cet attribut estmappé à la propriété Amazon.Util.ProxyConfig.Username à partir de la propriétéAmazon.AWSConfigs.ProxyConfig.Username du Kit AWS SDK pour .NET.

Le parent de l'élément <proxy> est l'élément <aws>.

L'élément <proxy> ne contient aucun élément enfant.

Voici un exemple de l'élément <proxy> utilisé :

<proxy host="192.0.2.0" port="1234" username="My-Username-Here" password="My-Password-Here" />

s3

L'élément <s3> représente un ensemble de paramètres Amazon S3. Cet élément peut inclure l'attributuseSignatureVersion4, qui indique si la signature Signature version 4 est utilisée pour toutes les

50

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Activation des Métriques SDK

demandes (true) ou si elle ne l'est pas (false, valeur par défaut). Cet attribut est mappé à la propriétéAmazon.AWSConfigs.S3Config.UseSignatureVersion4 du Kit AWS SDK pour .NET.

Le parent de l'élément <s3> est l'élément <aws>.

L'élément <s3> ne contient aucun élément enfant.

Voici un exemple de l'élément <s3> utilisé :

<s3 useSignatureVersion4="true" />

Activation des Métriques SDKKit AWS SDK Metrics for Enterprise Support avec PHP (Métriques SDK) permet aux clients d’entreprisede collecter des métriques à partir de AWS Les kits SDK sur leurs hôtes et clients partagés avec AWSAssistance aux entreprises. Métriques SDK fournit des informations qui permettent d’accélérer la détectionet le diagnostic des problèmes survenant dans les connexions à AWS services pour AWS Clients del’assistance aux entreprises.

La télémétrie étant collectée sur chaque hôte, elle est relayée via UDP vers 127.0.0.1 (hôte local),où l'agent Amazon CloudWatch regroupe les données et les envoie au service Métriques SDK. Parconséquent, pour pouvoir recevoir des métriques, l'agent CloudWatch doit être ajouté à votre instance.

Les étapes suivantes permettant de configurer Métriques SDK s'appliquent à une instance AmazonEC2 exécutant Amazon Linux pour une application cliente qui utilise le kit Kit AWS SDK pour .NET.Métriques SDK est également disponible pour vos environnements de production si vous l'activez pendantla configuration du kit Kit AWS SDK pour .NET.

Pour utiliser Métriques SDK, exécutez la version la plus récente de l'agent CloudWatch. Découvrezcomment configurer l'agent CloudWatch pour SDK Metrics dans le Guide de l'utilisateur AmazonCloudWatch.

Pour configurer Métriques SDK avec le kit Kit AWS SDK pour .NET, procédez comme suit :

1. Créez une application avec un client Kit AWS SDK pour .NET pour utiliser un service AWS.2. Hébergez votre projet sur une instance Amazon EC2 ou dans votre environnement local.3. Installez et utilisez la version la plus récente du Kit AWS SDK pour .NET.4. Installez et configurez un agent CloudWatch sur une instance EC2 ou dans votre environnement local.5. Autorisez Métriques SDK à collecter et envoyer des métriques.6. Activer les métriques du kit SDK pour le kit Kit AWS SDK pour .NET (p. 51).

Pour plus d'informations, consultez ce qui suit :

• Mettre à jour un agent CloudWatch (p. 52)• Désactiver SDK Metrics (p. 53)

Activer Métriques SDK pour le kit Kit AWS SDK pour .NETPar défaut, Métriques SDK est désactivé et le port est défini sur 31000. Les paramètres par défaut sont lessuivants.

//default values [ 'enabled' => false, 'port' => 31000,

51

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Activation des Métriques SDK

]

L'activation de Métriques SDK est indépendant de la configuration de vos informations d'identification pourl'utilisation d'un service AWS.

Vous pouvez activer Métriques SDK en définissant des variables d’environnement ou en utilisant le AWSfichier de configuration partagé.

Option 1 Définir les variables d'environnementSi AWS_CSM_ENABLED n'est pas défini, le kit SDK commence par vérifier le profil spécifié dans la variabled'environnement sous AWS_PROFILE pour déterminer si Métriques SDK est activé. La valeur par défaut estfalse.

Pour activer Métriques SDK, ajoutez les éléments suivants à vos variables d'environnement.

export AWS_CSM_ENABLED=true

D'autres paramètres de configuration (p. 52) sont disponibles.Note

Activation Métriques SDK ne configure pas vos informations d’identification pour utiliser un AWSdu service après-vente.

Option 2 : AWS fichier de configuration partagéSi non Métriques SDK se trouve dans les variables d’environnement, le kit SDK recherche votre valeurpar défaut AWS champ de profil. Si AWS_DEFAULT_PROFILE est défini sur une valeur autre que cellepar défaut, mettez à jour ce profil. Pour activer Métriques SDK, ajoutez csm_enabled au fichier deconfiguration partagée situé sous ~/.aws/config.

[default]csm_enabled = true

[profile aws_csm]csm_enabled = true

D'autres paramètres de configuration (p. 52) sont disponibles.Note

Activation Métriques SDK est indépendant de la configuration de vos informations d’identificationpour utiliser un AWS du service après-vente. Vous pouvez utiliser un profil différent pour vousauthentifier.

Mettre à jour un CloudWatch agentPour apporter des modifications au port, vous devez définir les valeurs, puis redémarrer AWS tâchesactuellement actives.

Option 1 Définir les variables d'environnementLa plupart des services utilisent le port par défaut. Toutefois, si votre service requiert un ID de port unique,ajoutez AWS_CSM_PORT=[numéro_port] aux variables d'environnement de l'hôte.

export AWS_CSM_ENABLED=trueexport AWS_CSM_PORT=1234

52

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Activation des Métriques SDK

Option 2 : AWS fichier de configuration partagéLa plupart des services utilisent le port par défaut. Si votre service requiert un ID de port unique, ajoutezcsm_port=[numéro_port] dans ~/.aws/config.

[default]csm_enabled = falsecsm_port = 1234

[profile aws_csm]csm_enabled = falsecsm_port = 1234

Redémarrer Métriques SDKPour redémarrer une tâche, exécutez les commandes suivantes.

amazon-cloudwatch-agent-ctl –a stop;amazon-cloudwatch-agent-ctl –a start;

Désactiver Métriques SDKPour éteindre Métriques SDK, ensemble csm_activé à faux dans vos variables d’environnement, ou dansvotre AWS fichier de configuration partagé situé à ~/.aws/config. Puis redémarrez votre CloudWatchpour que les modifications puissent prendre effet.

Variables d'environnement.

export AWS_CSM_ENABLED=false

AWS fichier de configuration partagé

Supprimer csm_activé des profils de votre AWS fichier de configuration partagé situé à ~/.aws/config.Note

Les variables d’environnement remplacent AWS fichier de configuration partagé. Si MétriquesSDK est activé dans les variables d'environnement, Métriques SDK reste activé.

[default]csm_enabled = false

[profile aws_csm]csm_enabled = false

Pour désactiver Métriques SDK, utilisez la commande suivante pour arrêter votre CloudWatch de l’agent.

sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a stop &&echo "Done"

Si vous utilisez d'autres fonctions CloudWatch, redémarrez CloudWatch avec la commande suivante.

amazon-cloudwatch-agent-ctl –a start;

Redémarrer Métriques SDKPour redémarrer une tâche, exécutez les commandes suivantes.

53

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Activation des Métriques SDK

amazon-cloudwatch-agent-ctl –a stop;amazon-cloudwatch-agent-ctl –a start;

Définitions pour Métriques SDKVous pouvez utiliser les descriptions suivantes de Métriques SDK pour interpréter vos résultats. Engénéral, ces mesures sont disponibles pour examen avec votre responsable de compte technique lorsdes examens commerciaux réguliers. AWS Les ressources de support et votre responsable de comptetechnique doivent avoir accès aux données SDK Metrics pour vous aider à résoudre les cas, mais sivous découvrez des données qui sont déroutantes ou inattendues, mais qui ne semblent pas avoir unimpact négatif sur les performances de vos applications, il est préférable d’examiner ces données lors desexamens d’activité planifiés.

Métrique CallCount

Définition Nombre total d'appels d'API ayant réussi ouéchoué effectués à partir de votre code auxservices AWS.

Comment l'utiliser Utilisez-la comme base de référence pour établirune corrélation avec d'autres métriques comme leserreurs ou la limitation.

Métrique ClientErrorCount

Définition Nombre d'appels d'API qui ont échoué avec deserreurs client (codes de réponse HTTP 4xx).Exemples : Limitation, Accès refusé, compartimentS3 inexistant et valeur de paramètre non valide.

Comment l'utiliser Sauf dans certains cas liés à la limitation (parexemple, lorsque celle-ci se produit en raison d'unelimite qui doit être augmentée), cette métrique peutsignaler qu'un élément de votre application doit êtrecorrigé.

Métrique ConnectionErrorCount

Définition Nombre d'appels d'API qui échouent en raisond'erreurs de connexion au service. Ceux-ci peuventêtre causés par des problèmes de réseau entrel’application cliente et AWS services, y compris leséquilibreurs de charge, les défaillances DNS, lesfournisseurs de transit. Dans certains cas, AWSpeut entraîner cette erreur.

Comment l'utiliser Utilisez cette métrique pour déterminer si desproblèmes sont spécifiques à votre applicationou causés par l'infrastructure et/ou le réseau.Une valeur ConnectionErrorCount élevéepeut également indiquer des valeurs de délaid'expiration court pour les appels d'API.

54

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrones

Métrique ThrottleCount

Définition Nombre d'appels d'API qui échouent en raison dela limitation par les services AWS.

Comment l'utiliser Utilisez cette métrique pour évaluer si votreapplication a atteint des limites, ainsi que pourdéterminer la cause des nouvelles tentatives et dela latence de l'application. Envisagez de distribuerles appels via une fenêtre plutôt que de les traiterpar lot.

Métrique ServerErrorCount

Définition Nombre d’appels d’API qui échouent en raisond’erreurs de serveur (5xx codes de réponse HTTP)de AWS Services. Ils sont généralement causéspar des services AWS.

Comment l'utiliser Déterminez la cause des nouvelles tentatives dukit SDK ou de la latence. Cette métrique n’indiquepas toujours que les services AWS sont en cause,comme certains AWS Les équipes classent lalatence en tant que réponse HTTP 503.

Métrique EndToEndLatency

Définition Temps total pour que votre application passe unappel à l’aide de l’ AWS Kit SDK , y compris lesnouvelles tentatives. En d'autres termes, le faitqu'un appel aboutisse après plusieurs tentatives ouéchoue en raison d'une erreur irrémédiable n'estpas pris en compte.

Comment l'utiliser Déterminer comment AWS Les appels d’APIcontribuent à la latence globale de votreapplication. Une latence plus élevée que prévupeut être causée par des problèmes liés auréseau ou au pare-feu, à d'autres paramètres deconfiguration, ou par la latence qui résulte desnouvelles tentative du kit SDK.

API asynchrones AWS pour .NETAPI asynchrone pour .NET Framework 4.5, WindowsStore et Windows Phone 8Le Kit AWS SDK pour .NET utilise le nouveau modèle asynchrone basé sur les tâches pour .NETFramework version 4.5, Windows Store et Windows Phone 8. Vous pouvez utiliser les mots clés async etawait pour exécuter et gérer des opérations asynchrones pour tous les produits AWS sans blocage.

55

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

Pour en savoir plus sur le modèle asynchrone basé sur les tâches, consultez Modèle asynchronebasé sur les tâches (TAP) sur docs.microsoft.com. Pour voir comment TAP est utilisé dans le Kit AWSSDK pour .NET, pour les projets.NET Framework 4.5 et.NET Core, consultez le dernière version de ladocumentation.

API asynchrone pour .NET Framework 3.5Le Kit AWS SDK pour .NET prend en charge les versions asynchrones de la plupart des appels deméthode exposés par les classes de client .NET. Les méthodes asynchrones vous permettent d'appelerun service AWS sans que votre code soit suspendu à la réponse du service. Par exemple, vous pouvezformuler une demande d'écriture de données dans Amazon S3 ou DynamoDB tout en laissant votre codepoursuivre une autre tâche pendant que AWS traite les demandes.

Syntaxe des méthodes de demande asynchronesLa formulation d'une demande asynchrone à un service AWS comporte deux phases. La première consisteà appeler la méthode Begin pour la demande. Cette méthode déclenche l'opération asynchrone. Laméthode End correspondante récupère la réponse du service et permet également de traiter les exceptionsqui ont pu se produire pendant l'opération.

Note

L'appel de la méthode End n'est pas obligatoire. Dans l'hypothèse où aucune erreur ne se produit,l'opération asynchrone aboutit, que End soit appelé ou non.

Syntaxe de la méthode BeginEn plus d'accepter un paramètre d'objet de demande, tel que PutItemRequest, les méthodes Beginasynchrones acceptent deux paramètres supplémentaires : une fonction de rappel et un objet d'état. Aulieu de renvoyer un objet de réponse de service, le Begin les méthodes renvoient un résultat de typeIAsyncResult. Pour la définition de ce type, accédez à la page de la documentation Microsoft.

Méthode synchrone

PutItemResponse PutItem( PutItemRequest putItemRequest)

Méthode asynchrone

IAsyncResult BeginPutItem( GetSessionTokenRequest getSessionTokenRequest, {AsyncCallback callback}, {Object state})

Rappel AsyncCallback

La fonction de rappel est appelée une fois que l'opération asynchrone se termine. Lorsqu'elle est appelée,la fonction reçoit un seul paramètre de type IAsyncResult. La fonction de rappel présente la signaturesuivante.

void Callback(IAsyncResult asyncResult)

Objet d'état

Le troisième paramètre, state, est un objet défini par l'utilisateur auquel la fonction de rappel a accèscomme propriété AsyncState du paramètre asyncResult, à savoir asyncResult.AsyncState.

Modèles d'appel

56

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

• Transmission d'une fonction de rappel et d'un objet d'état.• Transmission d'une fonction de rappel, mais transmission d'une valeur null pour l'objet d'état.• Transmission d'une valeur null à la fois pour la fonction de rappel et pour l'objet d'état.

Cette rubrique fournit un exemple de chacun de ces modèles.

Utilisation de la propriété IAsyncResult.AsyncWaitHandle

Dans certaines circonstances, le code qui appelle la méthode Begin peut avoir besoin d'autoriser uneautre méthode qu'il appelle à attendre la fin de l'opération asynchrone. En pareil cas, il peut transmettrela méthode que WaitHandle a renvoyée par la propriété IAsyncResult.AsyncWaitHandle de lavaleur de retour IAsyncResult. La méthode peut alors attendre que l'opération asynchrone se termine enappelant WaitOne sur ce WaitHandle.

ExamplesPour l'exemple de code complet, consultez Exemple complet (p. 59) ci-dessous ou rendez-vous surGitHub.

Tous les exemples ci-dessous s'appuient sur le code d'initialisation suivant.

public static void TestPutObjectAsync(string bucket) { // Create a client AmazonS3Client client = new AmazonS3Client();

PutObjectResponse response; IAsyncResult asyncResult;

// // Create a PutObject request object using the supplied bucket name. // PutObjectRequest request = new PutObjectRequest { BucketName = bucket, Key = "Item0-Synchronous", ContentBody = "Put S3 object synchronously." };

Aucun rappel spécifié

L'exemple de code suivant appelle BeginPutObject, effectue des tâches, puis appelle EndPutObjectpour récupérer la réponse du service. L'appel à EndPutObject est inclus dans un bloc try pourintercepter les exceptions qui ont été éventuellement levées pendant l'opération.

asyncResult = client.BeginPutObject(request, null, null); while (!asyncResult.IsCompleted) { // // Do some work here // } try { response = client.EndPutObject(asyncResult); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:");

57

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

Console.WriteLine(s3Exception); }

Rappel simpleCet exemple part du principe que la fonction de rappel suivante a été définie.

public static void SimpleCallback(IAsyncResult asyncResult) { Console.WriteLine("Finished PutObject operation with simple callback."); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("asyncResult.IsCompleted: {0}\n\n", asyncResult.IsCompleted.ToString()); }

La ligne de code suivante appelle BeginPutObject et spécifie la fonction de rappel ci-dessus. Unefois l'opération PutObject terminée, la fonction de rappel est appelée. L'appel à BeginPutObjectspécifie la valeur null pour le paramètre state, car la fonction de rappel simple n'accède pas à lapropriété AsyncState du paramètre asyncResult. Ni l’indicatif d’appel ni l’appel de la fonction de rappelEndPutObject. Par conséquent, la réponse du service est effectivement ignorée et toutes les exceptionsqui se produisent pendant l’opération sont ignorées.

asyncResult = client.BeginPutObject(request, SimpleCallback, null);

Rappel avec clientCet exemple part du principe que la fonction de rappel suivante a été définie.

public static void CallbackWithClient(IAsyncResult asyncResult) { try { AmazonS3Client s3Client = (AmazonS3Client)asyncResult.AsyncState; PutObjectResponse response = s3Client.EndPutObject(asyncResult); Console.WriteLine("Finished PutObject operation with client callback. Service Version: {0}", s3Client.Config.ServiceVersion); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}\n\n", response.ResponseMetadata.RequestId); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:"); Console.WriteLine(s3Exception); } }

La ligne de code suivante appelle BeginPutObject et spécifie la fonction de rappel précédente. Unefois l'opération PutObject terminée, la fonction de rappel est appelée. Dans cet exemple, l'appel àBeginPutObject spécifie l'objet client Amazon S3 pour le paramètre state. La fonction de rappel sesert du client pour appeler la méthode EndPutObject afin de récupérer la réponse du serveur. Commeles exceptions qui se sont produites pendant l'opération sont reçues pendant que le rappel appelleEndPutObject, cet appel est inséré dans un bloc try.

asyncResult = client.BeginPutObject(request_client, CallbackWithClient, client);

58

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

Rappel avec objet d'étatCet exemple part du principe que la classe et la fonction de rappel suivantes ont été définies.

class ClientState { public AmazonS3Client Client { get; set; } public DateTime Start { get; set; } }

public static void CallbackWithState(IAsyncResult asyncResult) { try { ClientState state = asyncResult.AsyncState as ClientState; AmazonS3Client s3Client = (AmazonS3Client)state.Client; PutObjectResponse response = state.Client.EndPutObject(asyncResult); Console.WriteLine("Finished PutObject operation with state callback that started at {0}", state.Start.ToString()); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}\n\n", response.ResponseMetadata.RequestId); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:"); Console.WriteLine(s3Exception); } }

La ligne de code suivante appelle BeginPutObject et spécifie la fonction de rappel ci-dessus. Unefois l'opération PutObject terminée, la fonction de rappel est appelée. Dans cet exemple, l'appel àBeginPutObject spécifie, pour le paramètre state, une instance de la classe ClientState définieprécédemment. Cette classe incorpore le client Amazon S3, ainsi que l'heure à laquelle BeginPutObjectest appelé. La fonction de rappel utilise l'objet client Amazon S3 pour appeler la méthode EndPutObjectafin de récupérer la réponse du serveur. De plus, le rappel extrait l'heure de début de l'opération et s'ensert pour imprimer la durée totale de l'opération asynchrone.

Comme dans les exemples précédents, les exceptions qui se produisent au cours de l'opération étantreçues quand EndPutObject est appelé, cet appel est inséré dans un bloc try.

asyncResult = client.BeginPutObject(request_state, CallbackWithState, new ClientState { Client = client, Start = DateTime.Now });

Exemple completL'exemple de code suivant présente les modèles que vous pouvez utiliser quand vous appelez lesméthodes de demande asynchrones.

using System;using System.Threading;

using Amazon.S3;using Amazon.S3.Model;

namespace async_aws_net{

59

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

class ClientState { public AmazonS3Client Client { get; set; } public DateTime Start { get; set; } }

class Program { // // Function Main(). // Parse the command line and call the worker function. // public static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("You must supply the name of an existing Amazon S3 bucket."); return; }

TestPutObjectAsync(args[0]); }

// // Function SimpleCallback(). // A very simple callback function. // public static void SimpleCallback(IAsyncResult asyncResult) { Console.WriteLine("Finished PutObject operation with simple callback."); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("asyncResult.IsCompleted: {0}\n\n", asyncResult.IsCompleted.ToString()); }

// // Function CallbackWithClient(). // A callback function that provides access to a given S3 client. // public static void CallbackWithClient(IAsyncResult asyncResult) { try { AmazonS3Client s3Client = (AmazonS3Client)asyncResult.AsyncState; PutObjectResponse response = s3Client.EndPutObject(asyncResult); Console.WriteLine("Finished PutObject operation with client callback. Service Version: {0}", s3Client.Config.ServiceVersion); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}\n\n", response.ResponseMetadata.RequestId); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:"); Console.WriteLine(s3Exception); } }

// // Function CallbackWithState(). // A callback function that provides access to a given S3 client as well as state information. //

60

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

public static void CallbackWithState(IAsyncResult asyncResult) { try { ClientState state = asyncResult.AsyncState as ClientState; AmazonS3Client s3Client = (AmazonS3Client)state.Client; PutObjectResponse response = state.Client.EndPutObject(asyncResult); Console.WriteLine("Finished PutObject operation with state callback that started at {0}", state.Start.ToString()); Console.WriteLine("--------------------------------------------------"); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}\n\n", response.ResponseMetadata.RequestId); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:"); Console.WriteLine(s3Exception); } }

// // Function TestPutObjectAsync(). // Test synchronous and asynchronous variations of PutObject(). // public static void TestPutObjectAsync(string bucket) { // Create a client AmazonS3Client client = new AmazonS3Client();

PutObjectResponse response; IAsyncResult asyncResult;

// // Create a PutObject request object using the supplied bucket name. // PutObjectRequest request = new PutObjectRequest { BucketName = bucket, Key = "Item0-Synchronous", ContentBody = "Put S3 object synchronously." };

// // Perform a synchronous PutObject operation. // Console.WriteLine("-------------------------------------------------------------------------------"); Console.WriteLine("Performing synchronous PutObject operation for {0}.", request.Key); response = client.PutObject(request); Console.WriteLine("Finished PutObject operation for {0}.", request.Key); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}", response.ResponseMetadata.RequestId); Console.Write("\n");

// // Perform an async PutObject operation and wait for the response. // // (Re-use the existing PutObject request object since it isn't being used for another async request.) // request.Key = "Item1-Async-wait";

61

Kit AWS SDK pour .NET (version 3) Manuel du développeur:API asynchrone pour .NET Framework 3.5

request.ContentBody = "Put S3 object asynchronously; wait for response."; Console.WriteLine("-------------------------------------------------------------------------------"); Console.WriteLine("Performing async PutObject operation and waiting for response (Key: {0}).", request.Key);

asyncResult = client.BeginPutObject(request, null, null); while (!asyncResult.IsCompleted) { // // Do some work here // } try { response = client.EndPutObject(asyncResult); } catch (AmazonS3Exception s3Exception) { Console.WriteLine("Caught exception calling EndPutObject:"); Console.WriteLine(s3Exception); }

Console.WriteLine("Finished Async PutObject operation for {0}.", request.Key); Console.WriteLine("Service Response:"); Console.WriteLine("-----------------"); Console.WriteLine("Request ID: {0}\n", response.ResponseMetadata.RequestId);

Console.WriteLine("-------------------------------------------------------------------------------"); Console.WriteLine("Performing the following async PutObject operations:"); Console.WriteLine("\"simple callback\", \"callback with client\", and \"callback with state\"...\n");

// // Perform an async PutObject operation with a simple callback. // // (Re-use the existing PutObject request object since it isn't being used for another async request.) // request.Key = "Item2-Async-simple"; request.ContentBody = "Put S3 object asynchronously; use simple callback.";

Console.WriteLine("PutObject with simple callback (Key: {0}).", request.Key); asyncResult = client.BeginPutObject(request, SimpleCallback, null);

// // Perform an async PutObject operation with a client callback. // // Create a PutObject request object for this call using the supplied bucket name. // PutObjectRequest request_client = new PutObjectRequest { BucketName = bucket, Key = "Item3-Async-client", ContentBody = "Put S3 object asynchronously; use callback with client." };

Console.WriteLine("PutObject with client callback (Key: {0}).", request_client.Key); asyncResult = client.BeginPutObject(request_client, CallbackWithClient, client);

// // Perform an async PutObject operation with a state callback.

62

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Nouvelles tentatives et délais d’expiration

// // Create a PutObject request object for this call using the supplied bucket name. // PutObjectRequest request_state = new PutObjectRequest { BucketName = bucket, Key = "Item3-Async-state", ContentBody = "Put S3 object asynchronously; use callback with state." };

Console.WriteLine("PutObject with state callback (Key: {0}).\n", request_state.Key); asyncResult = client.BeginPutObject(request_state, CallbackWithState, new ClientState { Client = client, Start = DateTime.Now });

// // Finished with async calls. Wait a bit for them to finish. // Thread.Sleep(TimeSpan.FromSeconds(5)); } }}

Vous pouvez également le consulter sur GitHub.

Voir aussi• Configuration du Kit AWS SDK pour .NET (p. 15)• Programmation avec le kit AWS SDK pour .NET (p. 22)

Nouvelles tentatives et délais d’expirationLe Kit AWS SDK pour .NET vous permet de configurer le nombre de nouvelles tentatives et les valeurs dedélai d’attente des requêtes HTTP pour AWS services. Si les valeurs par défaut concernant les nouvellestentatives et les délais d'expiration ne conviennent pas à votre application, vous pouvez les ajuster selonvos besoins spécifiques, mais il est important de comprendre en quoi le comportement de votre applicationen sera affecté.

Pour déterminer quelles valeurs utiliser pour les nouvelles tentatives et les délais d'expiration, prenez encompte les éléments suivants :

• Comment doit-on Kit AWS SDK pour .NET et votre application réagissent lorsque la connectivité réseause dégrade ou AWS est injoignable ? Souhaitez-vous que l'appel échoue rapidement ou est-il indiquéque l'appel continue de faire l'objet de nouvelles tentatives en votre nom ?

• Votre application est-elle une application ou un site web orienté vers l'utilisateur qui doit être réactive ous'agit-il d'une tâche de traitement en arrière plan qui tolère davantage les latences accrues ?

• L’application est-elle déployée sur un réseau fiable à faible latence, ou est-elle déployée à distance avecune connectivité non fiable ?

RetriesOverviewLe Kit AWS SDK pour .NET peut retenter les demandes qui échouent en raison d’une limitation côtéserveur ou de connexions abandonnées. Il existe deux propriétés des classes de configuration de service

63

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Retries

que vous pouvez utiliser pour spécifier le comportement de nouvelle tentative d’un client de service. Lesclasses de configuration de service héritent de ces propriétés de l’abstract Amazon.Exécuter.ConfigClientde la classe de Kit AWS SDK pour .NET API Reference:

• RetryMode spécifie l’un des trois modes de nouvelle tentative, qui sont définis dans leModeRéessaiDemandeAmazon.Exécuter. énumération.

La valeur par défaut de votre application peut être contrôlée à l’aide de l’ AWS_RETRY_MODE variabled’environnement ou la variable mode_réessayer dans le partage AWS fichier de configuration.

• MaxErrorRetry spécifie le nombre de nouvelles tentatives autorisées au niveau du client de service ; lekit SDK réessaie l’opération le nombre de fois spécifié avant d’échouer et de lancer une exception.

La valeur par défaut de votre application peut être contrôlée à l’aide de l’ AWS_MAX_ATTEMPTS variabled’environnement ou la variable max_tentatives dans le partage AWS fichier de configuration.

Des descriptions détaillées de ces propriétés sont disponibles dans le résuméAmazon.Exécuter.ConfigClient de la classe de Kit AWS SDK pour .NET API Reference. Chaque valeur deRetryMode correspond par défaut à une valeur particulière de MaxErrorRetry, comme illustré dans letableau suivant.

RetryMode Corresponding MaxErrorRetry(Amazon DynamoDB)

Corresponding MaxErrorRetry (allothers)

Legacy 10 4

Standard 10 2

Adaptive (experimental) 10 2

BehaviorLorsque votre application démarre

Lorsque votre application démarre, les valeurs par défaut pour RetryMode et MaxErrorRetry sontconfigurés par le kit SDK. Ces valeurs par défaut sont utilisées lorsque vous créez un client de service, saufsi vous spécifiez d’autres valeurs.

• Si les propriétés ne sont pas définies dans votre environnement, la valeur par défaut pour RetryModeest configuré comme Héritage et la valeur par défaut pour MaxErrorRetry est configuré avec la valeurcorrespondante du tableau précédent.

• Si le mode de nouvelle tentative a été défini dans votre environnement, cette valeur est utilisée pardéfaut pour RetryMode. La valeur par défaut pour MaxErrorRetry est configuré avec la valeurcorrespondante de la table précédente, sauf si la valeur du maximum d’erreurs a également été définiedans votre environnement (décrite ci-après).

• Si la valeur du maximum d’erreurs a été définie dans votre environnement, cette valeur est utilisée pardéfaut pour MaxErrorRetry. Amazon DynamoDB est l’exception à cette règle ; la règle par défautDynamoDB valeur pour MaxErrorRetry est toujours la valeur du tableau précédent.

Au fur et à mesure que votre application s’exécute

Lorsque vous créez un client de service, vous pouvez utiliser les valeurs par défaut pour RetryModeet MaxErrorRetry, comme décrit précédemment, ou vous pouvez spécifier d’autres valeurs. Pourspécifier d’autres valeurs, créez et incluez un objet de configuration de service tel que PropriétéAmazonDynamoDBConfig pour ou Configuration AmazonSQS lorsque vous créez le client de service.

64

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Timeouts

Ces valeurs ne peuvent pas être modifiées pour un client de service après sa création.

Considérations :

Lorsqu’une nouvelle tentative se produit, la latence de votre demande augmente. Vous devez configurer lesnouvelles tentatives en fonction des limites de votre application en termes de latence totale des demandeset de taux d'erreur.

TimeoutsLe Kit AWS SDK pour .NET vous permet de configurer les valeurs de délai d’expiration de demande et dedélai d’expiration de lecture/écriture de socket au niveau du client de service. Ces valeurs sont spécifiéesdans le Timeout et le ReadWriteTimeout des propriétés de l’abstract Amazon.Exécuter.ConfigClientclasse. Ces valeurs sont transmises en tant que Timeout et ReadWriteTimeout propriétés du RequêteWebHttp objets créés par le AWS objet client de service. La valeur par défaut de Timeout est de100 secondes et celle de ReadWriteTimeout est de 300 secondes.

Lorsque votre réseau présente une latence élevée ou qu'une opération fait l'objet d'une nouvelle tentativedu fait de certaines conditions, un long délai d'expiration et un nombre élevé de nouvelles tentativespeuvent donner l'impression que certaines opérations du kit SDK ne répondent pas.

Note

La version du Kit AWS SDK pour .NET qui cible la bibliothèque de classes portable (PCL) utilisela classe HttpClient à la place de la classe HttpWebRequest et prend uniquement en charge lapropriété Timeout.

Vous trouverez ci-dessous les exceptions aux valeurs de délai d'expiration par défaut. Ces valeurs sontremplacées lorsque vous définissez explicitement les valeurs de délai d'expiration.

• Timeout et ReadWriteTimeout sont définis sur les valeurs maximales si la méthode appelée chargeun flux, tel que AmazonS3Client.PutObjectAsync(), ClientAmazonS3.UploadPartAsync(), Aynchronisationde l’archive de téléchargement AmazonGlacierClient(), et ainsi de suite sur.

• Les versions du Kit AWS SDK pour .NET que l’ensemble.NET Framework cible Timeout etReadWriteTimeout aux valeurs maximales pour tous Client AmazonS3 et Client AmazonGlacierobjets.

• Les versions du Kit AWS SDK pour .NET qui ciblent la bibliothèque de classe portable (PCL)et l’ensemble.NET Core Timeout à la valeur maximale pour tous Client AmazonS3 et ClientAmazonGlacier objets.

ExampleL’exemple suivant vous montre comment spécifier Standard mode de nouvelle tentative, un maximum de3 nouvelles tentatives, un délai d’expiration de 10 secondes et un délai d’expiration en lecture/écriture de10 secondes (le cas échéant). Le Client AmazonS3 le constructeur reçoit un Configuration AmazonS3objet.

var s3Client = new AmazonS3Client( new AmazonS3Config { Timeout = TimeSpan.FromSeconds(10), // NOTE: The following property is obsolete for // versions of the AWS SDK for .NET that target .NET Core. ReadWriteTimeout = TimeSpan.FromSeconds(10), RetryMode = RequestRetryMode.Standard, MaxErrorRetry = 3 });

65

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Paginators

PaginatorsLes paginateurs fournissent des mécanismes synchrones et asynchrones pour la pagination, ce qui vouspermet d’éviter la surcharge des jetons de continuation. La pagination synchrone est disponible dans lesprojets.NET Framework 4.5 (ou version ultérieure). La pagination asynchrone est disponible dans lesprojets.NET Core.

Des pagineurs ont été ajoutés dans la version 3.5 du Kit AWS SDK pour .NET. Pour savoir commentutiliser les paginateurs, voir Pagineurs dans le dernière version de la documentation.

Migration vers la version 3 du kit Kit AWS SDKpour .NET

Cette rubrique décrit les modifications apportées à la version 3 du Kit AWS SDK pour .NET et expliquecomment migrer votre code vers cette version du kit SDK.

À propos des versions du Kit AWS SDK pour .NETLe Kit AWS SDK pour .NET, initialement lancé en novembre 2009, était conçu pour .NET Framework 2.0.Depuis cette version,.NET s’est amélioré avec.NET Framework 4.0 et.NET Framework 4.5, et a ajouté denouvelles plateformes cibles : WinRT et Windows Phone.

Le Kit AWS SDK pour .NET version 2 a été mis à jour pour tirer parti des nouvelles fonctions de laplateforme .NET et pour cibler WinRT et Windows Phone.

Le Kit AWS SDK pour .NET version 3 a été mis à jour pour rendre les assemblies modulaires.

Refonte de l'architecture du kit SDKLa version 3 du Kit AWS SDK pour .NET a été entièrement repensée pour devenir modulaire. Chaqueservice est désormais implémenté dans son propre assembly, et non dans un seul et même assemblyglobal. Vous n'avez plus besoin d'ajouter l'intégralité du Kit AWS SDK pour .NET à votre application. Vouspouvez désormais ajouter les seuls assemblies qui correspondent aux services AWS utilisés par votreapplication.

ÉvolutionsLes sections suivantes décrivent les modifications apportées à la version 3 du Kit AWS SDK pour .NET.

Suppression d'AWSClientFactoryLa classe Amazon.AWSClientFactory a été supprimée. Désormais, pour créer le client d'un service,utilisez le constructeur correspondant. Par exemple, pour créer un AmazonEC2Client :

var ec2Client = new Amazon.EC2.AmazonEC2Client();

Suppression d'Amazon.Runtime.AssumeRoleAWSCredentialsLa classe Amazon.Runtime.AssumeRoleAWSCredentials a été supprimée car, bien que se trouvantdans un espace de noms de base, elle présentait une dépendance vis-à-vis d'AWS Security Token

66

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Évolutions

Service. Par ailleurs, elle était obsolète dans le kit SDK depuis un certain temps. Utilisez plutôt la classeAmazon.SecurityToken.AssumeRoleAWSCredentials.

Suppression de la méthode SetACL de S3LinkLa classe S3Link fait partie du package Amazon.DynamoDBv2 et sert à stocker dans Amazon S3les objets qui font office de références dans un élément DynamoDB. En dépit de son utilité, nous nevoulions pas que cette fonction crée une dépendance de compilation dans le package Amazon.S3 pourDynamoDB. C'est pourquoi nous avons simplifié les méthodes Amazon.S3 exposées de la classe S3Link,remplaçant la méthode SetACL par la méthode MakeS3ObjectPublic. Pour exercer un plus grandcontrôle sur la liste de contrôle d'accès (ACL) de l'objet, utilisez directement le package Amazon.S3.

Suppression de classes de résultat obsolètesPour la plupart des services sollicités dans les opérations du Kit AWS SDK pour .NET, les opérationsrenvoient un objet de réponse qui contient les métadonnées de l'opération, telles que l'ID de demande et unobjet de résultat. La présence à la fois d'une classe de réponse et d'une classe de résultat était redondanteet exigeait plus de saisies des développeurs. Dans la version 2 du Kit AWS SDK pour .NET, nous avonsintégré toutes les informations de la classe de résultat dans la classe de réponse. De même, nous avonsmarqué les classes de résultat comme étant obsolètes pour dissuader leur utilisation. Dans la version 3 duKit AWS SDK pour .NET, nous avons supprimé ces classes de résultat obsolètes pour contribuer à réduirela taille du kit SDK.

Modifications apportées à la section AWS ConfigIl est possible d'effectuer une configuration avancée du Kit AWS SDK pour .NET via le fichier App.configou Web.config. Cette opération s'effectue via une section de configuration <aws> telle que celle illustréeci-dessous, qui fait référence au nom d'assembly du SDK.

<configuration> <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK"/> </configSections> <aws region="us-west-2"> <logging logTo="Log4Net"/> </aws></configuration>

Dans la version 3 du Kit AWS SDK pour .NET, l'assembly AWSSDK n'existe plus. Nous avons intégréle code commun dans l'assembly AWSSDK.Core. De ce fait, vous devrez remplacer les références àl'assembly AWSSDK dans votre fichier App.config ou Web.config par des références à l'assemblyAWSSDK.Core, comme suit.

<configuration> <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/> </configSections> <aws region="us-west-2"> <logging logTo="Log4Net"/> </aws></configuration>

Vous pouvez également manipuler les paramètres de configuration à l'aide de la classeAmazon.AWSConfigs. Dans la version 3 du Kit AWS SDK pour .NET, nous avons déplacé lesparamètres de configuration de DynamoDB de la classe Amazon.AWSConfigs vers la classeAmazon.AWSConfigsDynamoDB.

67

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Migration vers la version 3.5

Migration vers la version 3.5 du kit Kit AWS SDKpour .NET

La version 3.5 du kit Kit AWS SDK pour .NET normalise davantage l'expérience .NET en faisant passer laprise en charge de toutes les variations non-Framework du SDK vers .NET Standard 2.0.

Pour voir ce qui a changé dans la version 3.5 et le travail possible que vous pourriez avoir besoin de fairepour migrer votre environnement ou votre code à partir de la version 3, consultez le dernière version de ladocumentation.

Migration à partir de .NET Standard 1.3Le 27 juin 2019, Microsoft a mis fin à la prise en charge des versions .NET Core 1.0 et .NET Core 1.1.Suite à cette annonce, AWS mettra fin à la prise en charge de .NET Standard 1.3 sur le kit Kit AWS SDKpour .NET le 31 décembre 2020.

AWS continuera à fournir des mises à jour de service et des correctifs de sécurité sur le kit Kit AWSSDK pour .NET ciblant .NET Standard 1.3 jusqu'au 1er octobre 2020. Après cette date, la cible .NETStandard 1.3 passera en mode Maintenance, ce qui signifie qu'aucune nouvelle mise à jour ne serapubliée ; AWS appliquera uniquement des correctifs de bogues critiques et des correctifs de sécurité.

Le 31 décembre 2020, la prise en charge de .NET Standard 1.3 sur le kit Kit AWS SDK pour .NET prendrafin. Après cette date, aucun correctif de bogue ni correctif de sécurité ne sera appliqué. Les artefacts créésavec cette cible resteront disponibles en téléchargement sur NuGet.

Ce que vous devez savoir

• Si vous exécutez des applications qui utilisent .NET Framework, vous n'êtes pas concerné.

• Si vous exécutez des applications qui utilisent .NET Core 2.0 ou version ultérieure, vous n'êtes pasconcerné.

• Si vous exécutez des applications qui utilisent .NET Core 1.0 ou .NET Core 1.1, migrez vos applicationsvers une version plus récente de .NET Core en suivant les instructions de migration Microsoft. Nousrecommandons au minimum .NET Core 3.1.

• Si vous exécutez des applications métier stratégiques qui ne peuvent pas être mises à niveau pour lemoment, vous pouvez continuer à utiliser votre version actuelle du kit Kit AWS SDK pour .NET.

Si vous avez des questions ou des inquiétudes, contactez le support AWS.

68

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Affichage des ressources AWS

à l’aide de AWS CloudFormation

Exemples de code pour le Kit AWSSDK pour .NET

Les exemples suivants montrent comment utiliser le Kit AWS SDK pour .NET pour travailler avec desservices AWS spécifiques.

Recherchez le code source de ces exemples et d'autres dans le référentiel des exemples de code de ladocumentation AWS sur GitHub. Pour proposer un nouvel exemple de code que l'équipe de documentationAWS pourrait envisager de produire, créez une nouvelle demande. L'équipe cherche à produire desexemples de code qui couvrent des scénarios et des cas d'utilisation plus larges, plutôt que de simplesextraits de code qui couvrent uniquement les appels d'API individuels. Pour obtenir des instructions,consultez la section Proposer de nouveaux exemples de code dans Readme sur GitHub.

D'autres exemples sont disponibles sur GitHub.

Avant de commencer, assurez-vous d'avoir configuré le kit AWS SDK pour .NET (p. 15) et consultezProgrammation avec le kit AWS SDK pour .NET (p. 22).

Rubriques• Affichage des ressources AWS à l’aide de AWS CloudFormation (p. 69)• Authentification d'utilisateurs avec Amazon Cognito (p. 70)• Utilisation des bases de données NoSQL Amazon DynamoDB (p. 76)• Déploiement d'applications avec Amazon EC2 (p. 96)• Stockage de données d'archives avec Amazon S3 Glacier (p. 123)• Gestion des utilisateurs avec AWS Identity and Access Management (IAM) (p. 126)• Utilisation de AWS Key Management Service clés pour Amazon S3 du chiffrement dans le Kit AWS

SDK pour .NET (p. 146)• Gestion des ressources du système de noms de domaine (DNS) à l'aide d'Amazon Route 53 (p. 148)• Utilisation du stockage Internet Amazon Simple Storage Service (p. 153)• Envoi de notifications depuis le cloud avec Amazon Simple Notification Service (p. 153)• Messagerie avec Amazon SQS (p. 156)• Surveillance de vos ressources AWS à l’aide d’ Amazon CloudWatch (p. 165)• Programmation d'AWS OpsWorks pour utiliser les piles et applications (p. 177)• Prise en charge de programmation pour des services AWS supplémentaires (p. 177)

Affichage des ressources AWS à l’aide de AWSCloudFormation

Le kit Kit AWS SDK pour .NET prend en charge AWS CloudFormation, qui crée et alloue des déploiementsd'infrastructure AWS de manière prévisible et répétée. Pour plus d'informations, consultez le guide dedémarrage AWS CloudFormation.

69

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Authentification d'utilisateurs avec Amazon Cognito

L'exemple suivant montre comment utiliser les API de bas niveau pour lister des ressources accessiblesdans AWS CloudFormation.

// using Amazon.CloudFormation;// using Amazon.CloudFormation.Model;

var client = new AmazonCloudFormationClient();var request = new DescribeStacksRequest();var response = client.DescribeStacks(request);

foreach (var stack in response.Stacks){ Console.WriteLine("Stack: {0}", stack.StackName); Console.WriteLine(" Status: {0}", stack.StackStatus); Console.WriteLine(" Created: {0}", stack.CreationTime);

var ps = stack.Parameters;

if (ps.Any()) { Console.WriteLine(" Parameters:");

foreach (var p in ps) { Console.WriteLine(" {0} = {1}", p.ParameterKey, p.ParameterValue); }

} }

Pour accéder à des informations de référence d'API connexes, consultez Amazon.CloudFormation etAmazon.CloudFormation.Model dans le document AWS SDK for .NET API Reference.

Authentification d'utilisateurs avec Amazon CognitoAvec Amazon Cognito Identity, vous pouvez créer des identités uniques pour vos utilisateurs et lesauthentifier pour un accès sécurisé à vos ressources AWS, comme Amazon S3 ou Amazon DynamoDB.Amazon Cognito Identity prend en charge les fournisseurs d'identité publique comme Amazon, Facebook,Twitter/Digits, Google ou tout fournisseur compatible OpenID Connect, ainsi que des identités nonauthentifiées. Amazon Cognito prend également en charge les identités authentifiées par les développeurs,qui vous permettent d'inscrire et d'authentifier les utilisateurs par l'intermédiaire de votre propre processusd'authentification backend, tout en utilisant Amazon Cognito Sync pour synchroniser les données utilisateuret l'accès aux ressources AWS.

Pour plus d'informations sur Amazon Cognito, consultez le Manuel du développeur Amazon Cognito

Les exemples de code suivants montrent comment utiliser facilement Amazon Cognito Identity. L'exemplede fournisseur d'informations d'identification Amazon Cognito montre comment créer et authentifier desidentités utilisateur. L'exemple de la bibliothèque d'extensions Amazon CognitoAuthentication montrecomment utiliser la bibliothèque d'extensions CognitoAuthentication pour authentifier des groupesd'utilisateurs Amazon Cognito.

Rubriques• Fournisseur d'informations d'identification Amazon Cognito (p. 71)• Exemples de la bibliothèque d'extensions Amazon CognitoAuthentication (p. 72)

70

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Fournisseur d'informations d'identification Amazon Cognito

Fournisseur d'informations d'identification AmazonCognitoAmazon.CognitoIdentity.CognitoAWSCredentials est un objet d'informations d'identificationqui utilise Amazon Cognito et AWS Security Token Service (AWS STS) pour récupérer des informationsd'identification afin d'effectuer des appels AWS.

La première étape de configuration de CognitoAWSCredentials consiste à créer un « grouped'identités ». Un groupe d'identités est un magasin d'informations relatives à l'identité de l'utilisateur quiest propre au compte. Les informations peuvent être récupérées quels que soient les plateformes client,appareils et systèmes d'exploitation. Autrement dit, si un utilisateur commence à utiliser votre applicationsur un téléphone, puis passe à une tablette, les informations de l'application restent disponibles pour cetutilisateur. Vous pouvez créer un groupe d'identités dans la console Amazon Cognito. Si vous utilisez laconsole, celle-ci vous fournira également les autres éléments d'information dont vous avez besoin :

• Votre numéro de compte – Un numéro à 12 chiffres, comme 123456789012, qui est unique pour votrecompte.

• L'ARN du rôle non authentifié – Un rôle que les utilisateurs non authentifiés assumeront. Par exemple, cerôle peut fournir des autorisations d'accès en lecture seule à vos données.

• L'ARN du rôle authentifié – Un rôle que les utilisateurs authentifiés assumeront. Ce rôle peut fournir desautorisations plus étendues à vos données.

Configuration de CognitoAWSCredentialsL'exemple de code suivant montre comment configurer CognitoAWSCredentials, que vous pouvezensuite utiliser pour effectuer un appel à Amazon S3 en tant qu'utilisateur non authentifié. Cela vouspermet d'effectuer des appels avec seulement un volume minimum de données requises pour authentifierl'utilisateur. Les autorisations utilisateur sont contrôlées par le rôle. Vous pouvez donc configurer l'accèsselon vos besoins.

CognitoAWSCredentials credentials = new CognitoAWSCredentials( accountId, // Account number identityPoolId, // Identity pool ID unAuthRoleArn, // Role for unauthenticated users null, // Role for authenticated users, not set region);using (var s3Client = new AmazonS3Client(credentials)){ s3Client.ListBuckets();}

Utilisation d'AWS en tant qu'utilisateur non authentifiéL'exemple de code suivant montre comment commencer à utiliser AWS en tant qu'utilisateur nonauthentifié, puis vous authentifier via Facebook et mettre à jour les informations d'identification pourutiliser celles de Facebook. En utilisant cette approche, vous pouvez accorder différentes capacités auxutilisateurs authentifiés via le rôle authentifié. Par exemple, votre application de téléphone peut autoriserdes utilisateurs à afficher un contenu de manière anonyme, mais leur permet de publier s'ils sont connectésavec un ou plusieurs des fournisseurs configurés.

CognitoAWSCredentials credentials = new CognitoAWSCredentials( accountId, identityPoolId, unAuthRoleArn, // Role for unauthenticated users authRoleArn, // Role for authenticated users

71

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples de la bibliothèque d'extensions

Amazon CognitoAuthentication

region);using (var s3Client = new AmazonS3Client(credentials)){ // Initial use will be unauthenticated s3Client.ListBuckets();

// Authenticate user through Facebook string facebookToken = GetFacebookAuthToken();

// Add Facebook login to credentials. This clears the current AWS credentials // and retrieves new AWS credentials using the authenticated role. credentials.AddLogin("graph.facebook.com", facebookAccessToken);

// This call is performed with the authenticated role and credentials s3Client.ListBuckets();}

L'objet CognitoAWSCredentials fournit encore plus de fonctionnalités si vous l'utilisez avecl'objet AmazonCognitoSyncClient qui fait partie du kit Kit AWS SDK pour .NET. Si vousutilisez les deux AmazonCognitoSyncClient et CognitoAWSCredentials, vous n’avez pasbesoin de spécifier le IdentityPoolId et IdentityId lorsque vous passez des appels avecle AmazonCognitoSyncClient. Ces propriétés sont automatiquement renseignées à partir deCognitoAWSCredentials. L’exemple de code suivant illustre cela, ainsi qu’un événement qui vousavertit chaque fois que le IdentityId pour CognitoAWSCredentials des modifications. IdentityIdpeut changer dans certains cas, par exemple lors du passage d'un utilisateur non authentifié à un utilisateurauthentifié.

CognitoAWSCredentials credentials = GetCognitoAWSCredentials();

// Log identity changescredentials.IdentityChangedEvent += (sender, args) =>{ Console.WriteLine("Identity changed: [{0}] => [{1}]", args.OldIdentityId, args.NewIdentityId);};

using (var syncClient = new AmazonCognitoSyncClient(credentials)){ var result = syncClient.ListRecords(new ListRecordsRequest { DatasetName = datasetName // No need to specify these properties //IdentityId = "...", //IdentityPoolId = "..." });}

Exemples de la bibliothèque d'extensions AmazonCognitoAuthenticationLa bibliothèque d'extensions Amazon CognitoAuthentication simplifie le processus d'authentification desgroupes d'utilisateurs Amazon Cognito pour les développeurs .NET Core et Xamarin. La bibliothèquerepose sur l'API Fournisseur d'identité Amazon Cognito pour créer et envoyer des appels d'APId'authentification d'utilisateur. Vous pouvez obtenir Amazon.Extensions.CognitoAuthentication depuis lagalerie NuGet.

72

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples de la bibliothèque d'extensions

Amazon CognitoAuthentication

Utilisation de la bibliothèque d'extensions AmazonCognitoAuthenticationAmazon Cognito intègre certaine valeurs AuthFlow et ChallengeName pour un flux d'authentificationstandard afin de valider le nom d'utilisateur et le mot de passe via le protocole SRP (Secure RemotePassword). Pour plus d'informations sur le flux d'authentification, consultez Flux d'authentification dugroupe d'utilisateurs Amazon Cognito.

Les exemples suivant nécessitent ces instructions using :

// Required for all examplesusing System;using Amazon;using Amazon.CognitoIdentity;using Amazon.CognitoIdentityProvider;using Amazon.Extensions.CognitoAuthentication;using Amazon.Runtime;// Required for the GetS3BucketsAsync exampleusing Amazon.S3;using Amazon.S3.Model;

Utilisation de l'authentification de base

Créez un AmazonCognitoIdentityProviderClient à l'aide de AnonymousAWSCredentials qui ne nécessitepas des demandes signées. Vous n'avez pas besoin de fournir une région ; le code sous-jacent appelleFallbackRegionFactory.GetRegionEndpoint() si aucune région n'est indiquée. Créez desobjets CognitoUserPool et CognitoUser. Appelez la méthode StartWithSrpAuthAsync avec unedemande InitiateSrpAuthRequest qui contient le mot de passe utilisateur.

public static async void GetCredsAsync(){ AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials()); CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider); CognitoUser user = new CognitoUser("username", "clientID", userPool, provider); InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest() { Password = "userPassword" };

AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false); accessToken = authResponse.AuthenticationResult.AccessToken;

}

Authentification avec des stimulations

La poursuite du flux d'authentification avec des stimulations, telles que NewPasswordRequired etMulti-Factor Authentication (MFA), est également plus simple. Les seules exigences sont les objetsCognitoAuthentication, le mot de passe de l'utilisateur pour SRP et les informations nécessaires pourla stimulation suivante qui est acquise en invitant l'utilisateur à la saisir. Le code suivant illustre unefaçon de vérifier le type de stimulation et d'obtenir les réponses appropriées pour les stimulations MFA etNewPasswordRequired lors du flux d'authentification.

Effectuez une demande d’authentification de base comme précédemment, et await unAuthFlowResponse. Lorsque la réponse est reçue, boucler le retour AuthenticationResult

73

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples de la bibliothèque d'extensions

Amazon CognitoAuthentication

objet. Si le type ChallengeName est NEW_PASSWORD_REQUIRED, appelez la méthodeRespondToNewPasswordRequiredAsync.

public static async void GetCredsChallengesAsync(){ AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials()); CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider); CognitoUser user = new CognitoUser("username", "clientID", userPool, provider); InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest(){ Password = "userPassword" };

AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false);

while (authResponse.AuthenticationResult == null) { if (authResponse.ChallengeName == ChallengeNameType.NEW_PASSWORD_REQUIRED) { Console.WriteLine("Enter your desired new password:"); string newPassword = Console.ReadLine();

authResponse = await user.RespondToNewPasswordRequiredAsync(new RespondToNewPasswordRequiredRequest() { SessionID = authResponse.SessionID, NewPassword = newPassword }); accessToken = authResponse.AuthenticationResult.AccessToken; } else if (authResponse.ChallengeName == ChallengeNameType.SMS_MFA) { Console.WriteLine("Enter the MFA Code sent to your device:"); string mfaCode = Console.ReadLine();

AuthFlowResponse mfaResponse = await user.RespondToSmsMfaAuthAsync(new RespondToSmsMfaRequest() { SessionID = authResponse.SessionID, MfaCode = mfaCode

}).ConfigureAwait(false); accessToken = authResponse.AuthenticationResult.AccessToken; } else { Console.WriteLine("Unrecognized authentication challenge."); accessToken = ""; break; } }

if (authResponse.AuthenticationResult != null) { Console.WriteLine("User successfully authenticated."); } else { Console.WriteLine("Error in authentication process."); } }

74

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples de la bibliothèque d'extensions

Amazon CognitoAuthentication

Utilisation de ressources AWS après l'authentification

Une fois qu'un utilisateur est authentifié à l'aide de la bibliothèque CognitoAuthentication, l'étape suivanteconsiste à autoriser l'utilisateur à accéder aux ressources AWS appropriées. Pour ce faire, vous devezcréer un groupe d'identités via la console d'identités fédérées Amazon Cognito. En spécifiant le grouped'utilisateurs Amazon Cognito que vous avez créé comme fournisseur, à l'aide de ses poolID et clientID,vous pouvez autoriser les utilisateurs de votre groupe d'identités Amazon Cognito à accéder auxressources AWS connectées à votre compte. Vous pouvez également spécifier des rôles différents pourpermettre aux utilisateurs non authentifiés et authentifiés d'accéder à des ressources différentes. Vouspouvez modifier ces règles dans la console IAM, où vous pouvez ajouter ou supprimer des autorisationsdans le champ Action de la stratégie attachée du rôle. Ensuite, à l'aide du groupe d'identités, du grouped'utilisateurs et des informations utilisateur Amazon Cognito appropriés, vous pouvez effectuer des appelsà des ressources AWS différentes. L'exemple suivant illustre un utilisateur authentifié avec SRP accédantaux différents compartiments Amazon S3 autorisés par le rôle du groupe d'identités associé

public async void GetS3BucketsAsync(){ var provider = new AmazonCognitoIdentityProviderClient(new AnonymousAWSCredentials()); CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider); CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);

string password = "userPassword";

AuthFlowResponse context = await user.StartWithSrpAuthAsync(new InitiateSrpAuthRequest() { Password = password }).ConfigureAwait(false);

CognitoAWSCredentials credentials = user.GetCognitoAWSCredentials("identityPoolID", RegionEndpoint.< YourIdentityPoolRegion >);

using (var client = new AmazonS3Client(credentials)) { ListBucketsResponse response = await client.ListBucketsAsync(new ListBucketsRequest()).ConfigureAwait(false);

foreach (S3Bucket bucket in response.Buckets) { Console.WriteLine(bucket.BucketName); } }}

Autres options d'authentificationEn plus de SRP, NewPasswordRequired et MFA, la bibliothèque d'extensions CognitoAuthentication offreun flux d'authentification plus simple pour :

• Personnalisé - Initier avec un appel àStartWithCustomAuthAsync(InitiateCustomAuthRequest customRequest)

• RefreshToken - Initier avec un appel àStartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequestrefreshTokenRequest)

• RefreshTokenSRP - Initier avec un appel àStartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequestrefreshTokenRequest)

75

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des bases de données

NoSQL Amazon DynamoDB

• AdminNoSRP - Initier avec un appel àStartWithAdminNoSrpAuthAsync(InitiateAdminNoSrpAuthRequest adminAuthRequest)

Appelez la méthode appropriée selon le flux souhaité. Continuez ensuite à interroger l'utilisateur avecdes stimulations comme elles sont présentées dans les objets AuthFlowResponse de chaque appel deméthode. Appelez également la méthode de réponse appropriée, comme RespondToSmsMfaAuthAsyncpour les stimulations MFA et RespondToCustomAuthAsync pour les stimulations personnalisées.

Utilisation des bases de données NoSQL AmazonDynamoDB

Le kit Kit AWS SDK pour .NET prend en charge Amazon DynamoDB, qui est un service de base dedonnées NoSQL rapide proposé par AWS. Le kit SDK fournit trois modèles de programmation pourcommuniquer avec DynamoDB : le modèle de bas niveau, le modèle de document et le modèle depersistance des objets.

Les informations suivantes présentent ces modèles et leurs API, fournissent des exemples sur commentet quand les utiliser, et proposent des liens vers des ressources de programmation DynamoDBsupplémentaires dans le kit Kit AWS SDK pour .NET.

Rubriques• Modèle de bas niveau (p. 76)• Modèle de document (p. 79)• Modèle de persistance des objets (p. 80)• Plus d'informations (p. 81)• Utilisation d'expressions avec Amazon DynamoDB et le kit Kit AWS SDK pour .NET (p. 82)• Prise en charge de JSON dans Amazon DynamoDB avec le kit Kit AWS SDK pour .NET (p. 92)• Gestion de l'état d'une session ASP.NET avec Amazon DynamoDB (p. 93)

Modèle de bas niveauLe modèle de programmation de bas niveau englobe les appels directs dans le service DynamoDB. Vouspouvez accéder à ce modèle via l'espace de nom Amazon.DynamoDBv2.

Parmi les trois modèles, le modèle de bas niveau est celui qui nécessite le plus de programmation.Par exemple, vous devez convertir les types de données .NET en leurs équivalents dans DynamoDB.Toutefois, ce modèle donne accès à la plupart des fonctions.

Les exemples suivants montrent comment utiliser le modèle de bas niveau pour créer une table, modifierune table et insérer des éléments dans une table dans DynamoDB.

Création d'une tableL'exemple suivant utilise la méthode CreateTable de la classe AmazonDynamoDBClient pour créer unetable. La méthode CreateTable utilise une instance de la classe CreateTableRequest, qui contientdes caractéristiques telles que des noms d'attribut d'élément requis, une définition de clé primaire et unecapacité de débit. La méthode CreateTable renvoie une instance de la classe CreateTableResponse.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

76

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèle de bas niveau

var client = new AmazonDynamoDBClient();

Console.WriteLine("Getting list of tables");List<string> currentTables = client.ListTables().TableNames;Console.WriteLine("Number of tables: " + currentTables.Count);if (!currentTables.Contains("AnimalsInventory")){ var request = new CreateTableRequest { TableName = "AnimalsInventory", AttributeDefinitions = new List<AttributeDefinition> { new AttributeDefinition { AttributeName = "Id", // "S" = string, "N" = number, and so on. AttributeType = "N" }, new AttributeDefinition { AttributeName = "Type", AttributeType = "S" } }, KeySchema = new List<KeySchemaElement> { new KeySchemaElement { AttributeName = "Id", // "HASH" = hash key, "RANGE" = range key. KeyType = "HASH" }, new KeySchemaElement { AttributeName = "Type", KeyType = "RANGE" }, }, ProvisionedThroughput = new ProvisionedThroughput { ReadCapacityUnits = 10, WriteCapacityUnits = 5 }, };

var response = client.CreateTable(request);

Console.WriteLine("Table created with request ID: " + response.ResponseMetadata.RequestId);}

Vérification qu'une table est prête pour modificationPour pouvoir remplacer ou modifier une table, celle-ci doit être prête pour cette opération. L'exemplesuivant montre comment utiliser le modèle de bas niveau pour vérifier qu'une table est prête dansDynamoDB. Dans cet exemple, la table cible à vérifier est référencée par l'intermédiaire de la méthodeDescribeTable de la classe AmazonDynamoDBClient. Toutes les cinq secondes, le code vérifie lavaleur de la propriété TableStatus de la table. Lorsque le statut est défini sur ACTIVE, la table est prêteà être modifiée.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

77

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèle de bas niveau

var client = new AmazonDynamoDBClient(); var status = "";

do{ // Wait 5 seconds before checking (again). System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5)); try { var response = client.DescribeTable(new DescribeTableRequest { TableName = "AnimalsInventory" });

Console.WriteLine("Table = {0}, Status = {1}", response.Table.TableName, response.Table.TableStatus);

status = response.Table.TableStatus; } catch (ResourceNotFoundException) { // DescribeTable is eventually consistent. So you might // get resource not found. }

} while (status != TableStatus.ACTIVE);

Insertion d'un élément dans une tableDans l'exemple suivant, vous utilisez le modèle de bas niveau pour insérer deux éléments dans une tabledans DynamoDB. Chaque élément est inséré par l'intermédiaire de la méthode PutItem de la classeAmazonDynamoDBClient, en utilisant une instance de la classe PutItemRequest. Chacune des deuxinstances de la classe PutItemRequest prend le nom de la table dans laquelle les éléments serontinsérés, avec une série de valeurs d'attribut d'élément.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();

var request1 = new PutItemRequest{ TableName = "AnimalsInventory", Item = new Dictionary<string, AttributeValue> { { "Id", new AttributeValue { N = "1" }}, { "Type", new AttributeValue { S = "Dog" }}, { "Name", new AttributeValue { S = "Fido" }} }};

var request2 = new PutItemRequest{ TableName = "AnimalsInventory", Item = new Dictionary<string, AttributeValue> { { "Id", new AttributeValue { N = "2" }}, { "Type", new AttributeValue { S = "Cat" }}, { "Name", new AttributeValue { S = "Patches" }} }};

78

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèle de document

client.PutItem(request1);client.PutItem(request2);

Modèle de documentLe modèle de programmation de document constitue une manière facile de travailler avec des donnéesdans DynamoDB. Ce modèle est particulièrement conçu pour l'accès aux tables et aux éléments destables. Vous pouvez accéder à ce modèle via l'espace de nom Amazon.DynamoDBv2.DocumentModel.

Comparé au modèle de programmation de bas niveau, le modèle de document est plus facile àprogrammer pour des données DynamoDB. Par exemple, vous n'avez pas à convertir les types dedonnées .NET en leurs équivalents dans DynamoDB. Toutefois, ce modèle ne donne pas accès à autantde fonctions que le modèle de programmation de bas niveau. Par exemple, vous pouvez utiliser ce modèlepour créer, extraire, mettre à jour et supprimer des éléments dans des tables. Toutefois, pour créer lestables, vous devez utiliser le modèle de bas niveau. Comparé au modèle de persistance des objets, cemodèle nécessite davantage de programmation pour stocker, charger et interroger des objets .NET.

Les exemples suivants montrent comment utiliser le modèle de document pour insérer des éléments etobtenir des éléments dans des tables dans DynamoDB.

Insertion d'un élément dans une tableDans l'exemple suivant, un élément est inséré dans la table par l'intermédiaire de la méthode PutItemde la classe Table. La méthode PutItem prend une instance de la classe Document ; la classeDocument est simplement une collection d'attributs initialisés. Pour déterminer la table dans laquelleinsérer l'élément, appelez la méthode LoadTable de la classe Table, en spécifiant une instance de laclasse AmazonDynamoDBClient et le nom de la table cible dans DynamoDB.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DocumentModel;

var client = new AmazonDynamoDBClient();var table = Table.LoadTable(client, "AnimalsInventory");var item = new Document();

item["Id"] = 3;item["Type"] = "Horse";item["Name"] = "Shadow";

table.PutItem(item);

Obtention d'un élément à partir d'une tableDans l'exemple suivant, l'élément est extrait par l'intermédiaire de la méthode GetItem de la classeTable. Pour déterminer l'élément à obtenir, la méthode GetItem utilise la clé primaire de hachage etde plage de l'élément cible. Pour déterminer la table à partir de laquelle obtenir l'élément, la méthodeLoadTable de la classe Table utilise une instance de la classe AmazonDynamoDBClient et le nom dela table cible dans DynamoDB.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DocumentModel;

var client = new AmazonDynamoDBClient();var table = Table.LoadTable(client, "AnimalsInventory");var item = table.GetItem(3, "Horse");

Console.WriteLine("Id = " + item["Id"]);

79

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèle de persistance des objets

Console.WriteLine("Type = " + item["Type"]);Console.WriteLine("Name = " + item["Name"]);

L'exemple précédent convertit de manière implicite les valeurs d'attribut pour Id, Type et Name en chaînespour la méthode WriteLine. Vous pouvez procéder aux conversions explicites en utilisant les différentesméthodes AsType de la classe DynamoDBEntry. Par exemple, vous pouvez convertir de manière explicitela valeur d'attribut pour Id à partir d'un type de données Primitive en un entier par l'intermédiaire de laméthode AsInt :

int id = item["Id"].AsInt();

Vous pouvez également procéder simplement à une conversion de type explicite via(int) :

int id = (int)item["Id"];

Modèle de persistance des objetsLe modèle de programmation de persistance des objets est particulièrement conçu pour stocker, chargeret interroger des objets .NET dans DynamoDB. Vous pouvez accéder à ce modèle via l'espace de nomAmazon.DynamoDBv2.DataModel.

Des trois modèles, le modèle de persistance des objets est le plus facile à programmer lorsque vousstockez, chargez ou interrogez des données DynamoDB. Par exemple, vous travaillez directement avecdes types de données DynamoDB. Toutefois, ce modèle donne accès seulement à des opérations quipermettent de stocker, de charger et d'interroger des objets .NET dans DynamoDB. Par exemple, vouspouvez utiliser ce modèle pour créer, extraire, mettre à jour et supprimer des éléments dans des tables.Toutefois, vous devez tout d'abord créer vos tables à l'aide du modèle de bas niveau, puis utiliser cemodèle pour mapper vos classes .NET avec les tables.

Les exemples suivants présentent comment définir une classe .NET représentant un élément, utiliser uneinstance de la classe .NET pour insérer un élément, et utiliser une instance d'objet .NET pour obtenir unélément à partir d'une table dans DynamoDB.

Définition d'une classe .NET représentant un élément d'une tableDans l'exemple suivant, l'attribut DynamoDBTable spécifie le nom de la table, tandis que les attributsDynamoDBHashKey et DynamoDBRangeKey modélisent la clé primaire de hachage et de plage de la table.

// using Amazon.DynamoDBv2.DataModel;

[DynamoDBTable("AnimalsInventory")]class Item{ [DynamoDBHashKey] public int Id { get; set; } [DynamoDBRangeKey] public string Type { get; set; } public string Name { get; set; }}

Utilisation d'une instance de la classe .NET pour insérer unélément dans une tableDans cet exemple, l'élément est inséré par l'intermédiaire de la méthode Save de la classeDynamoDBContext, qui prend une instance initialisée de la classe .NET représentant l'élément.

80

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Plus d'informations

(L'instance de la classe DynamoDBContextest initialisée avec une instance de la classeAmazonDynamoDBClient.)

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DataModel; var client = new AmazonDynamoDBClient();var context = new DynamoDBContext(client);var item = new Item{ Id = 4, Type = "Fish", Name = "Goldie"};

context.Save(item);

Utilisation d'une instance d'objet .NET pour obtenir un élément àpartir d'une tableDans cet exemple, l'élément est extrait par l'intermédiaire de la méthode Load de la classeDynamoDBContext, qui prend une instance partiellement initialisée de la classe .NET représentant la cléprimaire de hachage et de plage de l'élément à extraire. (Comme présenté précédemment, l'instance de laclasse DynamoDBContext est initialisée avec une instance de la classe AmazonDynamoDBClient.)

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DataModel;

var client = new AmazonDynamoDBClient();var context = new DynamoDBContext(client);var item = context.Load<Item>(4, "Fish");

Console.WriteLine("Id = {0}", item.Id);Console.WriteLine("Type = {0}", item.Type);Console.WriteLine("Name = {0}", item.Name);

Plus d'informationsUtilisation de AWS SDK pour .NET pour la programmation de DynamoDB Informations et exemples**

• API DynamoDB• Lancement de DynamoDB Series• DynamoDB Series - Modèle de document• DynamoDB Series - Schémas de conversion• DynamoDB Series - Modèle de persistance des objets• DynamoDB Series - Expressions• Utilisation d'expressions avec Amazon DynamoDB et AWS SDK pour .NET (p. 82)• Prise en charge de JSON dans Amazon DynamoDB avec AWS SDK pour .NET (p. 92)• Gestion de l'état d'une session ASP.NET avec Amazon DynamoDB (p. 93)

Informations et exemples de modèle de bas niveau.

• Utilisation de tables avec les API de bas niveau d'AWS SDK pour .NET• Utilisation d'éléments avec les API de bas niveau d'AWS SDK pour .NET

81

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

• Interrogation de tables avec les API de bas niveau d'AWS SDK pour .NET• Analyse de tables avec les API de bas niveau d'AWS SDK pour .NET• Utilisation d'index secondaires locaux avec les API de bas niveau d'AWS SDK pour .NET• Utilisation d'index secondaires globaux avec les API de bas niveau d'AWS SDK pour .NET

Informations et exemples de modèle de document

• Types de données DynamoDB• DynamoDBEntry• .NET Modèle de document

Exemples et informations sur le modèle de persistance des objets

• .NET Modèle de persistance d’objet

Utilisation d'expressions avec Amazon DynamoDB etle kit Kit AWS SDK pour .NETLes exemples de code suivants montrent comment utiliser le kit Kit AWS SDK pour .NET pour programmerDynamoDB avec des expressions. Les expressions désignent les attributs que vous souhaitez lire àpartir d'un élément dans une table DynamoDB. Vous utilisez également des expressions lors de l'écritured'un élément, pour signaler toutes les conditions qui doivent être satisfaites (aussi appelées mise à jourconditionnelle) et pour indiquer comment les attributs doivent être mis à jour. Des exemples de mise à jourremplacent l'attribut par une nouvelle valeur, ou ajoutent de nouvelles données à une liste ou une carte.Pour plus d'informations, consultez Lecture et écriture d'éléments à l'aide d'expressions.

Rubriques• Exemples de données (p. 82)• Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions (p. 85)• Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions (p. 86)• Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément (p. 87)• Imprimer un élément (p. 87)• Créer ou remplacer un élément à l'aide d'expressions (p. 89)• Mettre à jour un élément à l'aide d'expressions (p. 90)• Supprimer un élément à l'aide d'expressions (p. 91)• Plus d'informations (p. 91)

Exemples de donnéesLes exemples de code de cette rubrique s’appuient sur les deux exemples d’éléments suivants dans unDynamoDB nom de la table ProductCatalog. Ces éléments décrivent des informations sur les entréesde produits dans un catalogue de magasin de vélos fictif. Ces éléments sont basés sur l’exemple fournidans Étude de cas : Un article du catalogue de produits. Les descripteurs de types de données tels queBOOL, L, M, N, NS, S et SS correspondent à ceux de Format de données JSON.

{ "Id": { "N": "205"

82

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

}, "Title": { "S": "20-Bicycle 205" }, "Description": { "S": "205 description" }, "BicycleType": { "S": "Hybrid" }, "Brand": { "S": "Brand-Company C" }, "Price": { "N": "500" }, "Gender": { "S": "B" }, "Color": { "SS": [ "Red", "Black" ] }, "ProductCategory": { "S": "Bike" }, "InStock": { "BOOL": true }, "QuantityOnHand": { "N": "1" }, "RelatedItems": { "NS": [ "341", "472", "649" ] }, "Pictures": { "L": [ { "M": { "FrontView": { "S": "http://example/products/205_front.jpg" } } }, { "M": { "RearView": { "S": "http://example/products/205_rear.jpg" } } }, { "M": { "SideView": { "S": "http://example/products/205_left_side.jpg" } } } ] },

83

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

"ProductReviews": { "M": { "FiveStar": { "SS": [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a favor and buy this." ] }, "OneStar": { "SS": [ "Terrible product! Do not buy this." ] } } }},{ "Id": { "N": "301" }, "Title": { "S": "18-Bicycle 301" }, "Description": { "S": "301 description" }, "BicycleType": { "S": "Road" }, "Brand": { "S": "Brand-Company C" }, "Price": { "N": "185" }, "Gender": { "S": "F" }, "Color": { "SS": [ "Blue", "Silver" ] }, "ProductCategory": { "S": "Bike" }, "InStock": { "BOOL": true }, "QuantityOnHand": { "N": "3" }, "RelatedItems": { "NS": [ "801", "822", "979" ] }, "Pictures": { "L": [ { "M": { "FrontView": { "S": "http://example/products/301_front.jpg"

84

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

} } }, { "M": { "RearView": { "S": "http://example/products/301_rear.jpg" } } }, { "M": { "SideView": { "S": "http://example/products/301_left_side.jpg" } } } ] }, "ProductReviews": { "M": { "FiveStar": { "SS": [ "My daughter really enjoyed this bike!" ] }, "ThreeStar": { "SS": [ "This bike was okay, but I would have preferred it in my color.", "Fun to ride." ] } } }}

Obtention d'un élément unique à l'aide de sa clé primaire etd'expressionsL’exemple suivant présente le Amazon.DynamoDBv2.AmazonDynamoDBClient.GetItem et unensemble d’expressions pour obtenir et imprimer l’élément qui a un Id sur 205. Seuls les attributssuivants de l’élément sont renvoyés : Id, Title, Description, Color, RelatedItems, Pictures, etProductReviews.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new GetItemRequest{ TableName = "ProductCatalog", ProjectionExpression = "Id, Title, Description, Color, #ri, Pictures, #pr", ExpressionAttributeNames = new Dictionary<string, string> { { "#pr", "ProductReviews" }, { "#ri", "RelatedItems" } }, Key = new Dictionary<string, AttributeValue> { { "Id", new AttributeValue { N = "205" } } },};var response = client.GetItem(request);

85

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

// PrintItem() is a custom function.PrintItem(response.Item);

Dans l'exemple précédent, la propriété ProjectionExpression spécifie l'attribut à renvoyer.La propriété ExpressionAttributeNames spécifie l'espace réservé #pr pour représenterl'attribut ProductReviews et l'espace réservé #ri pour représenter l'attribut RelatedItems.L'appel à PrintItem fait référence à une fonction personnalisée, comme décrit dans Imprimer unélément (p. 87).

Obtention de plusieurs éléments à l'aide de la clé primaire de latable et d'expressionsL’exemple suivant présente le Amazon.DynamoDBv2.AmazonDynamoDBClient.Query et un ensembled’expressions pour obtenir et imprimer l’élément qui a un Id sur 301, mais uniquement si la valeur dePrice est supérieur à 150. Seuls les attributs suivants de l’élément sont renvoyés : Id, Title, et toutesles ThreeStar attributs dans ProductReviews.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new QueryRequest{ TableName = "ProductCatalog", KeyConditions = new Dictionary<string,Condition> { { "Id", new Condition() { ComparisonOperator = ComparisonOperator.EQ, AttributeValueList = new List<AttributeValue> { new AttributeValue { N = "301" } } } } }, ProjectionExpression = "Id, Title, #pr.ThreeStar", ExpressionAttributeNames = new Dictionary<string, string> { { "#pr", "ProductReviews" }, { "#p", "Price" } }, ExpressionAttributeValues = new Dictionary<string,AttributeValue> { { ":val", new AttributeValue { N = "150" } } }, FilterExpression = "#p > :val"};var response = client.Query(request);

foreach (var item in response.Items){ // Write out the first page of an item's attribute keys and values. // PrintItem() is a custom function. PrintItem(item); Console.WriteLine("=====");}

Dans l'exemple précédent, la propriété ProjectionExpression spécifie l'attribut à renvoyer. Lapropriété ExpressionAttributeNames spécifie l'espace réservé #pr pour représenter l'attribut

86

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

ProductReviews et l'espace réservé #p pour représenter l'attribut Price. #pr.ThreeStar spécifie derenvoyer uniquement le ThreeStar attribut. Le ExpressionAttributeValues la propriété spécifiel’espace réservé :val pour représenter la valeur 150. Le FilterExpression spécifie que #p (Price)doit être supérieur à :val (150). L'appel à PrintItem fait référence à une fonction personnalisée, commedécrit dans Imprimer un élément (p. 87).

Obtenir plusieurs éléments par l'intermédiaire d'expressions etd'autres attributs d'élémentL’exemple suivant présente le Amazon.DynamoDBv2.AmazonDynamoDBClient.Scan et un ensembled’expressions pour obtenir et imprimer tous les éléments qui ont un ProductCategory sur Bike. Seulsles attributs suivants de l’élément sont renvoyés : Id, Titleet tous les attributs dans ProductReviews.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new ScanRequest{ TableName = "ProductCatalog", ProjectionExpression = "Id, Title, #pr", ExpressionAttributeValues = new Dictionary<string,AttributeValue> { { ":catg", new AttributeValue { S = "Bike" } } }, ExpressionAttributeNames = new Dictionary<string, string> { { "#pr", "ProductReviews" }, { "#pc", "ProductCategory" } }, FilterExpression = "#pc = :catg", };var response = client.Scan(request);

foreach (var item in response.Items){ // Write out the first page/scan of an item's attribute keys and values. // PrintItem() is a custom function. PrintItem(item); Console.WriteLine("=====");}

Dans l'exemple précédent, la propriété ProjectionExpression spécifie l'attribut à renvoyer. Lapropriété ExpressionAttributeNames spécifie l'espace réservé #pr pour représenter l'attributProductReviews et l'espace réservé #pc pour représenter l'attribut ProductCategory. LeExpressionAttributeValues la propriété spécifie l’espace réservé :catg pour représenter la valeurBike. Le FilterExpression spécifie que #pc (ProductCategory) doit être égal à :catg (Bike).L'appel à PrintItem fait référence à une fonction personnalisée, comme décrit dans Imprimer unélément (p. 87).

Imprimer un élémentL'exemple suivant présente comment imprimer les attributs et les valeurs d'un élément. Cet exemple estutilisé dans les exemples précédents qui montrent comment Obtention d'un élément unique à l'aide desa clé primaire et d'expressions (p. 85), Obtention de plusieurs éléments à l'aide de la clé primaire dela table et d'expressions (p. 86) et Obtention de plusieurs éléments à l'aide d'expressions et d'autresattributs d'élément (p. 87).

// using Amazon.DynamoDBv2.Model;

87

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

// Writes out an item's attribute keys and values.public static void PrintItem(Dictionary<string, AttributeValue> attrs){ foreach (KeyValuePair<string, AttributeValue> kvp in attrs) { Console.Write(kvp.Key + " = "); PrintValue(kvp.Value); }}

// Writes out just an attribute's value.public static void PrintValue(AttributeValue value){ // Binary attribute value. if (value.B != null) { Console.Write("Binary data"); } // Binary set attribute value. else if (value.BS.Count > 0) { foreach (var bValue in value.BS) { Console.Write("\n Binary data"); } } // List attribute value. else if (value.L.Count > 0) { foreach (AttributeValue attr in value.L) { PrintValue(attr); } } // Map attribute value. else if (value.M.Count > 0) { Console.Write("\n"); PrintItem(value.M); } // Number attribute value. else if (value.N != null) { Console.Write(value.N); } // Number set attribute value. else if (value.NS.Count > 0) { Console.Write("{0}", string.Join("\n", value.NS.ToArray())); } // Null attribute value. else if (value.NULL) { Console.Write("Null"); } // String attribute value. else if (value.S != null) { Console.Write(value.S); } // String set attribute value. else if (value.SS.Count > 0) { Console.Write("{0}", string.Join("\n", value.SS.ToArray())); }

88

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

// Otherwise, boolean value. else { Console.Write(value.BOOL); } Console.Write("\n");}

Dans l'exemple précédent, chaque valeur d'attribut a plusieurs propriétés de type de données spécifiquequi peuvent être évaluées pour déterminer le format correct pour l'impression de l'attribut. Ces propriétéscomprennent B, BOOL, BS, L, M, N, NS, NULL, S, et SS, qui correspond à ceux du Format de données JSON.Pour des propriétés telles que B, N, NULL et S, si la propriété correspondante n'est pas null, l'attribut estdu type de données non null correspondant. Pour des propriétés telles que BS, L, M, NS et SS, si Countest supérieur à zéro, l'attribut est du type de données de la valeur différente de zéro correspondante. Sitoutes les propriétés de type de données spécifique de l'attribut sont null ou si Count est égal à zéro,l'attribut correspond au type de données BOOL.

Créer ou remplacer un élément à l'aide d'expressionsL’exemple suivant présente le Amazon.DynamoDBv2.AmazonDynamoDBClient.PutItem et unensemble d’expressions pour mettre à jour l’élément qui a un Title sur 18-Bicycle 301. Si l’élémentn’existe pas déjà, un nouvel élément est ajouté.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new PutItemRequest{ TableName = "ProductCatalog", ExpressionAttributeNames = new Dictionary<string, string> { { "#title", "Title" } }, ExpressionAttributeValues = new Dictionary<string, AttributeValue> { { ":product", new AttributeValue { S = "18-Bicycle 301" } } }, ConditionExpression = "#title = :product", // CreateItemData() is a custom function. Item = CreateItemData()};client.PutItem(request);

Dans l'exemple précédent, la propriété ExpressionAttributeNames spécifie l'espace réservé #titlepour représenter l'attribut Title. Le ExpressionAttributeValues la propriété spécifie l’espaceréservé :product pour représenter la valeur 18-Bicycle 301. Le ConditionExpression spécifieque #title (Title) doit être égal à :product (18-Bicycle 301). L'appel à CreateItemData faitréférence à la fonction personnalisée suivante :

// using Amazon.DynamoDBv2.Model;

// Provides a sample item that can be added to a table.public static Dictionary<string, AttributeValue> CreateItemData(){ var itemData = new Dictionary<string, AttributeValue> { { "Id", new AttributeValue { N = "301" } }, { "Title", new AttributeValue { S = "18\" Girl's Bike" } },

89

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

{ "BicycleType", new AttributeValue { S = "Road" } }, { "Brand" , new AttributeValue { S = "Brand-Company C" } }, { "Color", new AttributeValue { SS = new List<string>{ "Blue", "Silver" } } }, { "Description", new AttributeValue { S = "301 description" } }, { "Gender", new AttributeValue { S = "F" } }, { "InStock", new AttributeValue { BOOL = true } }, { "Pictures", new AttributeValue { L = new List<AttributeValue>{ { new AttributeValue { M = new Dictionary<string,AttributeValue>{ { "FrontView", new AttributeValue { S = "http://example/products/301_front.jpg" } } } } }, { new AttributeValue { M = new Dictionary<string,AttributeValue>{ { "RearView", new AttributeValue {S = "http://example/products/301_rear.jpg" } } } } }, { new AttributeValue { M = new Dictionary<string,AttributeValue>{ { "SideView", new AttributeValue { S = "http://example/products/301_left_side.jpg" } } } } } } } }, { "Price", new AttributeValue { N = "185" } }, { "ProductCategory", new AttributeValue { S = "Bike" } }, { "ProductReviews", new AttributeValue { M = new Dictionary<string,AttributeValue>{ { "FiveStar", new AttributeValue { SS = new List<string>{ "My daughter really enjoyed this bike!" } } }, { "OneStar", new AttributeValue { SS = new List<string>{ "Fun to ride.", "This bike was okay, but I would have preferred it in my color." } } } } } }, { "QuantityOnHand", new AttributeValue { N = "3" } }, { "RelatedItems", new AttributeValue { NS = new List<string>{ "979", "822", "801" } } } };

return itemData;}

Dans l'exemple précédent, un exemple d'élément avec des exemples de données est renvoyé aumandataire. Une série d'attributs et de valeurs correspondantes est construite, à l'aide des types dedonnées tels que BOOL, L, M, N, NS, S et SS, qui correspondent à ceux du format de données JSON.

Mettre à jour un élément à l'aide d'expressionsL'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.UpdateItemet un jeu d'expressions pour modifier Title en 18" Girl's Bike pour l'élément pour lequel Id est égalà 301.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new UpdateItemRequest{ TableName = "ProductCatalog", Key = new Dictionary<string,AttributeValue> { { "Id", new AttributeValue { N = "301" } } }, ExpressionAttributeNames = new Dictionary<string, string> { { "#title", "Title" } }, ExpressionAttributeValues = new Dictionary<string, AttributeValue> { { ":newproduct", new AttributeValue { S = "18\" Girl's Bike" } } }, UpdateExpression = "SET #title = :newproduct"

90

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation d'expressions avec Amazon

DynamoDB et le kit Kit AWS SDK pour .NET

};client.UpdateItem(request);

Dans l'exemple précédent, la propriété ExpressionAttributeNames spécifie l'espace réservé #titlepour représenter l'attribut Title. Le ExpressionAttributeValues la propriété spécifie l’espaceréservé :newproduct pour représenter la valeur 18" Girl's Bike. Le UpdateExpression lapropriété spécifie de modifier #title (Title) à :newproduct (18" Girl's Bike).

Supprimer un élément à l'aide d'expressionsL'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.DeleteItemet un jeu d'expressions pour supprimer les éléments pour lesquels Id est égal à 301 et Title est égal à18-Bicycle 301.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();var request = new DeleteItemRequest{ TableName = "ProductCatalog", Key = new Dictionary<string,AttributeValue> { { "Id", new AttributeValue { N = "301" } } }, ExpressionAttributeNames = new Dictionary<string, string> { { "#title", "Title" } }, ExpressionAttributeValues = new Dictionary<string, AttributeValue> { { ":product", new AttributeValue { S = "18-Bicycle 301" } } }, ConditionExpression = "#title = :product"};client.DeleteItem(request);

Dans l'exemple précédent, la propriété ExpressionAttributeNames spécifie l'espace réservé #titlepour représenter l'attribut Title. Le ExpressionAttributeValues la propriété spécifie l’espaceréservé :product pour représenter la valeur 18-Bicycle 301. Le ConditionExpression spécifieque #title (Title) doit être égal à :product (18-Bicycle 301).

Plus d'informationsPour plus d'informations et des exemples de code, consultez :

• DynamoDB Series - Expressions• Accès à des attributs d'élément avec des expressions de projections• Utilisation d'espaces réservés pour valeurs et noms d'attributs• Spécification de conditions avec des expressions de condition• Modification d'éléments et d'attributs avec des expressions de mises à jour• Utilisation d'éléments avec les API de bas niveau d'AWS SDK pour .NET• Interrogation de tables avec les API de bas niveau d'AWS SDK pour .NET• Analyse de tables avec les API de bas niveau d'AWS SDK pour .NET• Utilisation d'index secondaires locaux avec les API de bas niveau d'AWS SDK pour .NET• Utilisation d'index secondaires globaux avec les API de bas niveau d'AWS SDK pour .NET

91

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Prise en charge de JSON dans Amazon

DynamoDB avec le kit Kit AWS SDK pour .NET

Prise en charge de JSON dans Amazon DynamoDBavec le kit Kit AWS SDK pour .NETLe kit Kit AWS SDK pour .NET prend en charge les données JSON lorsque vous travaillez avec AmazonDynamoDB. Ceci permet d'obtenir plus facilement des données au format JSON des tables DynamoDB etd'insérer plus aisément des documents JSON dans ces tables.

Rubriques• Obtention de données d'une table DynamoDB au format JSON (p. 92)• Insertion de données au format JSON dans une table DynamoDB (p. 92)• Conversions du type de données DynamoDB vers JSON (p. 93)• Plus d'informations (p. 93)

Obtention de données d'une table DynamoDB au format JSONL'exemple suivant indique comment obtenir des données d'une table DynamoDB au format JSON.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DocumentModel;

var client = new AmazonDynamoDBClient();var table = Table.LoadTable(client, "AnimalsInventory");var item = table.GetItem(3, "Horse");

var jsonText = item.ToJson();Console.Write(jsonText); // Output:// {"Name":"Shadow","Type":"Horse","Id":3}

var jsonPrettyText = item.ToJsonPretty();Console.WriteLine(jsonPrettyText); // Output:// {// "Name" : "Shadow",// "Type" : "Horse",// "Id" : 3// }

Dans l'exemple précédent, la méthode ToJson de la classe Document convertit un élément de la table enchaîne au format JSON. La méthode GetItem de la classe Table permet de récupérer cet élément. Pourdéterminer l'élément à obtenir, dans cet exemple, la méthode GetItem utilise la clé primaire de hachageet de plage de l'élément cible. Pour déterminer la table à partir de laquelle obtenir l'élément, la méthodeLoadTable de la classe Table utilise une instance de la classe AmazonDynamoDBClient et le nom dela table cible dans DynamoDB.

Insertion de données au format JSON dans une table DynamoDBL'exemple suivant indique comment utiliser le format JSON pour insérer un élément dans une tableDynamoDB.

// using Amazon.DynamoDBv2;// using Amazon.DynamoDBv2.DocumentModel;

var client = new AmazonDynamoDBClient();

92

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion de l'état d'une session

ASP.NET avec Amazon DynamoDB

var table = Table.LoadTable(client, "AnimalsInventory");var jsonText = "{\"Id\":6,\"Type\":\"Bird\",\"Name\":\"Tweety\"}";var item = Document.FromJson(jsonText);

table.PutItem(item);

Dans l'exemple précédent, la méthode FromJson de la classe Document convertit une chaîne au formatJSON en élément. L'élément est inséré dans la table par l'intermédiaire de la méthode PutItem de laclasse Table, qui utilise l'instance de la classe Document contenant l'élément. Pour déterminer la tabledans laquelle insérer l'élément, appelez la méthode LoadTable de la classe Table, en spécifiant uneinstance de la classe AmazonDynamoDBClient et le nom de la table cible dans DynamoDB.

Conversions du type de données DynamoDB vers JSONLorsque vous appelez la méthode ToJson de la classe Document, puis lorsque sur les données JSONproduites vous appelez la méthode FromJson pour reconvertir les données JSON en instance d'uneclasse Document, certains types de données DynamoDB ne seront pas converties comme prévu. Enparticulier :

• Les ensembles DynamoDB (les types SS, NS et BS) seront convertis en tableaux JSON.• Les ensembles et scalaires binaires DynamoDB (les types B et BS) seront convertis en listes de chaînes

ou en chaînes JSON codées en base64.

Dans ce scénario, il convient d'appeler la méthode DecodeBase64Attributes de la classe Documentpour remplacer les données JSON codées en base64 par la représentation binaire correcte. L'exemplesuivant remplace par la représentation binaire correcte un attribut d'élément binary scalar codé enbase64 dans une instance d'une classe Document nommée Picture. Cet exemple procède de mêmepour un attribut d'élément binary set codé en base64 dans la même instance de la classe Documentnommée RelatedPictures :

item.DecodeBase64Attributes("Picture", "RelatedPictures");

Plus d'informationsPour plus d'informations et d'exemples sur la programmation de JSON avec DynamoDB avec le kit KitAWS SDK pour .NET, consultez :

• Support DynamoDB pour JSON• Mise à jour d'Amazon DynamoDB : JSON, offre gratuite élargie, dimensionnement flexible, éléments plus

volumineux

Gestion de l'état d'une session ASP.NET avecAmazon DynamoDBLes applications ASP.NET stockent souvent des données d'état de session en mémoire. Toutefois,l'évolutivité de cette approche est limitée. Lorsque l'application dépasse le stade du serveur Web unique,l'état de session doit être partagé entre plusieurs serveurs. Une solution courante consiste à définirun serveur d'état de session dédié avec Microsoft SQL Server, mais cette approche a également desinconvénients : vous devez administrer une autre machine, le serveur d'état de session est un point dedéfaillance unique, et il peut devenir un goulot d'étranglement des performances.

DynamoDB, magasin de bases de données NoSQL d'Amazon Web Services (AWS), offre une solutionefficace de partage d'un état de session entre plusieurs serveurs Web qui s'affranchit de ces inconvénients.

93

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion de l'état d'une session

ASP.NET avec Amazon DynamoDB

Note

Quelle que soit la solution que vous choisissez, gardez présent à l'esprit qu'Amazon DynamoDBimpose des limites à la taille d'un élément. Aucun des enregistrement que vous stockez dansDynamoDB ne peut dépasser cette limite. Pour plus d'informations, consultez Limites d'AmazonDynamoDB dans le Amazon DynamoDB Guide du développeur.

Le kit Kit AWS SDK pour .NET inclut AWS.SessionProvider.dll, qui contient un fournisseur d'état desession ASP.NET. Il inclut également le modèle AmazonDynamoDBSessionProviderSample, qui montrecomment utiliser Amazon DynamoDB en tant que fournisseur d'état de session.

Pour plus d’informations sur l’utilisation de l’état de session avec les applications ASP.NET, consultez lasection de la documentation Microsoft.

Créer la table ASP.NET_SessionStateLorsque votre application démarre, elle recherche un Amazon DynamoDB nom de la table, par défaut,ASP.NET_SessionState. Nous vous recommandons de créer cette table avant d’exécuter votreapplication pour la première fois.

Pour créer la table ASP.NET_SessionState

1. Choisissez Créer une table. L'assistant Create Table (Créer une table) s'ouvre.2. Dans la zone de texte Table name (Nom de la table), entrez ASP.NET_SessionState.3. Dans le champ Primary key (Clé primaire), entrez SessionId et définissez le type sur String.4. Lorsque toutes les options sont définies comme vous le souhaitez, choisissez Create (Créer).

La table ASP.NET_SessionState est prête à être utilisée lorsque son état passe de CREATING àACTIVE.

Note

Si vous décidez de ne pas créer la table au préalable, le fournisseur d'état de session le fera lorsde son initialisation. Consultez la liste des options web.config ci-dessous pour connaître lesattributs servant de paramètres de configuration pour la table d'état de session. Si le fournisseurcrée la table, il utilise ces paramètres.

Configurer le fournisseur d'état de sessionPour configurer une application ASP.NET utilisant DynamoDB en tant que serveur d'état de session

1. Ajoutez des références à AWSSDK.dll et AWS.SessionProvider.dll dans votre projet ASP.NETVisual Studio. Ces assemblies sont disponibles en installant le kit AWS SDK pour .NET (p. 19). Vouspouvez également les installer en utilisant NuGet (p. 17).

Dans les versions antérieures du kit SDK, la fonctionnalité du fournisseur d’état de session étaitcontenue dans AWS.Extension.dll. Pour améliorer la facilité d’utilisation, la fonctionnalité a étédéplacée vers AWS.SessionProvider.dll. Pour plus d’informations, consultez le billet de blogRenommage d’extension AWS.

2. Modifiez le fichier Web.config de votre application. Dans l'élément system.web, remplacez l'élémentsessionState existant par le fragment XML suivant :

<sessionState timeout="20" mode="Custom" customProvider="DynamoDBSessionStoreProvider"> <providers> <add name="DynamoDBSessionStoreProvider" type="Amazon.SessionProvider.DynamoDBSessionStateStore" AWSProfileName="{profile_name}"

94

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion de l'état d'une session

ASP.NET avec Amazon DynamoDB

Region="us-west-2" /> </providers></sessionState>

Le profil représente les informations d'identification AWS utilisées pour communiquer avec DynamoDBafin de stocker et d'extraire l'état de session. Si vous utilisez le kit Kit AWS SDK pour .NET et que vousspécifiez un profil dans la section appSettings du fichier Web.config de votre application, il n'est pasnécessaire de spécifier un profil dans la section providers ; le code client .NET AWS le découvrira aumoment de l'exécution. Pour plus d'informations, consultez Configuration de votre application AWS SDKpour .NET (p. 22).

Si le serveur Web est exécuté sur une instance Amazon EC2 configurée pour utiliser des rôles IAMpour instances EC2, il n'est pas nécessaire de spécifier les informations d'identification dans le fichierWeb.config. Dans ce cas, le client .NET AWS utilise les informations d'identification du rôle IAM.Pour de plus amples informations, veuillez consulter Octroi d'accès à l'aide d'un rôle IAM (p. 142) etConsidérations de sécurité (p. 96).

Options Web.configVous pouvez utiliser les attributs de configuration suivants dans la section providers de votre fichierWeb.config :

AWSAccessKey

ID de clé d'accès à utiliser. Cette information peut être définie dans la section providers ouappSettings. Nous vous recommandons de ne pas utiliser ce paramètre. Indiquez plutôt lesinformations d'identification par l'intermédiaire de AWSProfileName pour spécifier un profil.

AWSSecretKey

Clé secrète à utiliser. Cette information peut être définie dans la section providers ouappSettings. Nous vous recommandons de ne pas utiliser ce paramètre. Indiquez plutôt lesinformations d'identification par l'intermédiaire de AWSProfileName pour spécifier un profil.

AWSProfileName

Nom du profil associé aux informations d'identification que vous souhaitez utiliser. Pour plusd'informations, consultez Configuration de votre application AWS SDK pour .NET (p. 22).

Région

Attribut string obligatoire. Région AWS dans laquelle utiliser Amazon DynamoDB. Pour obtenir laliste des régions AWS, consultez Régions et points de terminaison : DynamoDB

Application

Attribut string facultatif. La valeur de l'attribut Application est utilisée pour partitionner lesdonnées de session dans la table, de sorte que cette dernière puisse être utilisée pour plusieursapplications.

Tableau

Attribut string facultatif. Nom de la table utilisée pour stocker les données de session. La valeur pardéfaut est ASP.NET_SessionState.

ReadCapacityUnits

Attribut int facultatif. Unités de capacité de lecture à utiliser si le fournisseur crée la table. La valeurpar défaut est 10.

WriteCapacityUnits

Attribut int facultatif. Unités de capacité d'écriture à utiliser si le fournisseur crée la table. La valeurpar défaut est 5.

95

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Déploiement d'applications avec Amazon EC2

CreateIfNotExist

Attribut boolean facultatif. L'attribut CreateIfNotExist contrôle si le fournisseur créeautomatiquement la table si celle-ci n'existe pas. Par défaut, la valeur est true. Si l'indicateur est définisur « false » et que la table n'existe pas, une exception est déclenchée.

Considérations de sécuritéLorsque la table DynamoDB est créée et l'application configurée, les sessions peuvent être utiliséescomme avec n'importe quel fournisseur de session.

La bonne pratique consiste à exécuter vos applications avec les informations d'identification d'un utilisateurGuide de l'utilisateur IAM. Vous pouvez utiliser IAM Management Console ou AWS Toolkit pour VisualStudio pour créer des utilisateurs IAM et définir des stratégies d'accès.

Le fournisseur d'état de session doit être capable d'appeler les opérations DeleteItem, DescribeTable,GetItem, PutItem et UpdateItem pour la table dans laquelle les données de session sont stockées. Lemodèle de stratégie ci-après peut être utilisé pour restreindre l'utilisateur IAM uniquement aux opérationsrequises par le fournisseur pour une instance DynamoDB exécutée dans la région us-west-2.

{ "Version" : "2012-10-17","Statement" : [ { "Sid" : "1", "Effect" : "Allow", "Action" : [ "dynamodb:DeleteItem", "dynamodb:DescribeTable", "dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem" ], "Resource" : "arn:aws:dynamodb:us-west-2:{<YOUR-AWS-ACCOUNT-ID>}:table/ASP.NET_SessionState" } ]}

Déploiement d'applications avec Amazon EC2Le kit Kit AWS SDK pour .NET prend en charge Amazon EC2, service web offrant une capacité de calculredimensionnable (c'est-à-dire des serveurs dans des centres de données Amazon) qui vous permetde générer et d'héberger vos systèmes logiciels. Les API Amazon EC2 sont fournies par l'assemblyAWSSDK.EC2.

Les exemples d'instances Amazon EC2 (p. 97) visent à vous aider à bien démarrer avec Amazon EC2.

Le Exemples d’instances Spot Amazon EC2 (p. 115) vous montre comment utiliser les instancesSpot, ce qui vous permet d’accéder à la capacité EC2 inutilisée avec une remise allant jusqu’à 90 % parrapport au prix de l’instance à la demande. Amazon EC2 définit les prix des instances Spot et les ajusteprogressivement en fonction des tendances à long terme de l’offre et de la demande pour la capacité desinstances Spot. Vous pouvez spécifier le montant que vous êtes disposé à payer pour une instance Spotsous forme d'un pourcentage du prix d'instance à la demande ; les clients dont les demandes répondent àce montant ou le dépassent ont accès aux instances Spot disponibles.

Pour en savoir plus, consultez Instances Spot dans le Amazon EC2 Guide de l'utilisateur pour les instancesLinux et Instances Spot dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows.

96

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Rubriques• Exemples d'instances Amazon EC2 (p. 97)• Exemples d'instances ponctuelles Amazon EC2 (p. 115)

Exemples d'instances Amazon EC2Vous pouvez accéder aux fonctions Amazon EC2 à l'aide du kit Kit AWS SDK pour .NET. Vous pouvez, parexemple, créer, lancer et arrêter des instances Amazon EC2.

L'exemple de code est écrit en C#, mais il est possible d'employer le Kit AWS SDK pour .NET avecn'importe quel langage compatible. Lorsque vous installez l'AWS Toolkit for Visual Studio, un ensemble demodèles de projet C# est installé. La manière la plus simple de démarrer ce projet consiste à ouvrir VisualStudio, puis à choisir Fichier, Nouveau projet, AWS Sample Projects (Exemples de projets AWS), Computeand Networking (Calcul et mise en réseau), AWS EC2 Sample (Exemple AWS EC2).

Conditions préalables requises

Avant de commencer, assurez-vous d'avoir créé un compte AWS et d'avoir configuré vos informationsd'identification AWS. Pour plus d'informations, consultez Prise en main du kit AWS SDK pour .NET (p. 15).

Exemples :

Rubriques• Création d'un client Amazon EC2 (p. 97)• Création d’un groupe de sécurité dans Amazon EC2 (p. 97)• Utilisation de paires de clés Amazon EC2 (p. 101)• Lancer une instance Amazon EC2 (p. 104)• Résiliation d'une instance Amazon EC2 (p. 109)• Utilisation des régions et des zones de disponibilité avec Amazon EC2 (p. 110)• Utilisation de points de terminaison de VPC avec Amazon EC2 (p. 111)• Utilisation des adresses IP Elastic dans Amazon EC2 (p. 113)

Création d'un client Amazon EC2Vous pouvez créer un client Amazon EC2 pour gérer vos ressources EC2, notamment les instances etles groupes de sécurité. Ce client est représenté par un objet AmazonEC2Client, que vous pouvez créercomme suit.

var ec2Client = new AmazonEC2Client();

Les autorisations de l'objet client sont déterminées par la stratégie attachée au profil que vous avezspécifié dans le fichier App.config. Par défaut, nous utilisons la région spécifiée dans App.config.Pour utiliser une autre région, passez le RégionPoint de terminaison vers le constructeur. Pour de plusamples informations, veuillez consulter Régions et points de terminaison. CE2 dans le Référence généraled'Amazon Web Services.

Création d’un groupe de sécurité dans Amazon EC2Dans Amazon EC2, un groupe de sécurité fonctionne comme un pare-feu virtuel contrôlant le trafic duréseau pour une ou plusieurs instances EC2. Par défaut, Amazon EC2 associe vos instances à un groupede sécurité qui n'autorise aucun trafic entrant. Vous pouvez créer un groupe de sécurité qui autorise vosinstances EC2 à accepter un certain trafic. Par exemple, si vous devez vous connecter à une instance

97

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Windows EC2, vous devez configurer le groupe de sécurité afin d'autoriser le trafic RDP. Vous pouvezcréer un groupe de sécurité à l'aide de la console Amazon EC2 ou du Kit AWS SDK pour .NET.

Vous créez un groupe de sécurité à utiliser dans EC2-Classic ou EC2-VPC. Pour plus d'informations surEC2-Classic et EC2-VPC, consultez la section Plateformes prises en charge du Amazon EC2 Guide del'utilisateur pour les instances Windows.

Vous pouvez aussi utiliser la console Amazon EC2 pour créer un groupe de sécurité. Pour plusd'informations, consultez Groupes de sécurité Amazon EC2 dans le Amazon EC2 Guide de l'utilisateurpour les instances Windows.

Pour plus d'informations sur la création d'un client Amazon EC2, consultez Création d'un client AmazonEC2 (p. 97).

Énumérer vos groupes de sécuritéVous pouvez énumérer vos groupes de sécurité et vérifier si un groupe de sécurité existe.

Pour énumérer vos groupes de sécurité

Obtenez la liste complète de vos groupes de sécurité à l'aide de DescribeSecurityGroups sans aucunparamètre.

L'exemple suivant énumère tous les groupes de sécurité de la région.

static void EnumerateSecurityGroups(AmazonEC2Client ec2Client){ var request = new DescribeSecurityGroupsRequest(); var response = ec2Client.DescribeSecurityGroups(request); List<SecurityGroup> mySGs = response.SecurityGroups; foreach (SecurityGroup item in mySGs) { Console.WriteLine("Security group: " + item.GroupId); Console.WriteLine("\tGroupId: " + item.GroupId); Console.WriteLine("\tGroupName: " + item.GroupName); Console.WriteLine("\tVpcId: " + item.VpcId);

Console.WriteLine(); }}

Pour énumérer vos groupes de sécurité pour un VPC particulier

Utilisez DescribeSecurityGroups avec un filtre.

L'exemple suivant extrait uniquement les groupes de sécurité qui appartiennent au VPC spécifié.

static void EnumerateVpcSecurityGroups(AmazonEC2Client ec2Client, string vpcID){ Filter vpcFilter = new Filter { Name = "vpc-id", Values = new List<string>() { vpcID } };

var request = new DescribeSecurityGroupsRequest(); request.Filters.Add(vpcFilter); var response = ec2Client.DescribeSecurityGroups(request); List<SecurityGroup> mySGs = response.SecurityGroups; foreach (SecurityGroup item in mySGs) { Console.WriteLine("Security group: " + item.GroupId); Console.WriteLine("\tGroupId: " + item.GroupId);

98

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Console.WriteLine("\tGroupName: " + item.GroupName); Console.WriteLine("\tVpcId: " + item.VpcId);

Console.WriteLine(); }}

Créer un groupe de sécuritéSi vous essayez de créer un groupe de sécurité avec le nom d'un groupe de sécurité existant,CreateSecurityGroup génère une exception. Pour éviter cela, les exemples suivants recherchent un groupede sécurité portant le nom spécifié et renvoient l'objet SecurityGroup approprié, le cas échéant.

Pour créer un groupe de sécurité pour EC2-Classic

Créez et initialisez un objet CreateSecurityGroupRequest. Affectez un nom et une descriptionrespectivement aux propriétés GroupName et Description.

La méthode CreateSecurityGroup renvoie un objet CreateSecurityGroupResponse. Vous pouvez obtenirl'identifiant du nouveau groupe de sécurité à partir de la réponse, puis utiliser DescribeSecurityGroups avecl'identifiant du groupe de sécurité pour obtenir l'objet SecurityGroup du groupe de sécurité.

static SecurityGroup CreateEc2SecurityGroup( AmazonEC2Client ec2Client, string secGroupName){ // See if a security group with the specified name already exists Filter nameFilter = new Filter(); nameFilter.Name = "group-name"; nameFilter.Values= new List<string>() { secGroupName };

var describeRequest = new DescribeSecurityGroupsRequest(); describeRequest.Filters.Add(nameFilter); var describeResponse = ec2Client.DescribeSecurityGroups(describeRequest);

// If a match was found, return the SecurityGroup object for the security group if(describeResponse.SecurityGroups.Count > 0) { return describeResponse.SecurityGroups[0]; }

// Create the security group var createRequest = new CreateSecurityGroupRequest(); createRequest.GroupName = secGroupName; createRequest.Description = "My sample security group for EC2-Classic";

var createResponse = ec2Client.CreateSecurityGroup(createRequest);

var Groups = new List<string>() { createResponse.GroupId }; describeRequest = new DescribeSecurityGroupsRequest() { GroupIds = Groups }; describeResponse = ec2Client.DescribeSecurityGroups(describeRequest); return describeResponse.SecurityGroups[0];}

Pour créer un groupe de sécurité pour EC2-VPC

Créez et initialisez un objet CreateSecurityGroupRequest. Affectez des valeurs aux propriétés GroupName,Description et VpcId.

La méthode CreateSecurityGroup renvoie un objet CreateSecurityGroupResponse. Vous pouvez obtenirl'identifiant du nouveau groupe de sécurité à partir de la réponse, puis utiliser DescribeSecurityGroups avecl'identifiant du groupe de sécurité pour obtenir l'objet SecurityGroup du groupe de sécurité.

99

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

static SecurityGroup CreateVpcSecurityGroup( AmazonEC2Client ec2Client, string vpcId, string secGroupName){ // See if a security group with the specified name already exists Filter nameFilter = new Filter(); nameFilter.Name = "group-name"; nameFilter.Values = new List<string>() { secGroupName };

var describeRequest = new DescribeSecurityGroupsRequest(); describeRequest.Filters.Add(nameFilter); var describeResponse = ec2Client.DescribeSecurityGroups(describeRequest);

// If a match was found, return the SecurityGroup object for the security group if (describeResponse.SecurityGroups.Count > 0) { return describeResponse.SecurityGroups[0]; }

// Create the security group var createRequest = new CreateSecurityGroupRequest(); createRequest.GroupName = secGroupName; createRequest.Description = "My sample security group for EC2-VPC"; createRequest.VpcId = vpcId;

var createResponse = ec2Client.CreateSecurityGroup(createRequest);

var Groups = new List<string>() { createResponse.GroupId }; describeRequest = new DescribeSecurityGroupsRequest() { GroupIds = Groups }; describeResponse = ec2Client.DescribeSecurityGroups(describeRequest); return describeResponse.SecurityGroups[0];}

Ajout de règles au groupe de sécuritéUtilisez la procédure suivante pour ajouter une règle de manière à autoriser le trafic entrant sur leport TCP 3389 (RDP). Cela permet de vous connecter à une instance Windows. Si vous lancez uneinstance Linux, utilisez plutôt le port TCP 22(SSH).

Note

Vous pouvez utiliser un service pour obtenir l'adresse IP publique de votre ordinateur local. Parexemple, nous fournissons le service suivant : http://checkip.amazonaws.com/. Pour trouverun autre service qui fournit votre adresse IP, utilisez l'expression de recherche « what is my IPaddress » (quelle est mon adresse IP). Si votre connexion s'effectue via un ISP ou derrière unpare-feu sans adresse IP statique, vous devez déterminer la plage d'adresses IP utilisée par lesordinateurs clients.

Les exemples de cette section constituent la suite de ceux des sections précédentes. Ils supposent qu'ungroupe de sécurité secGroup existe.

Pour ajouter une règle à un groupe de sécurité

1. Créez et initialisez un objet IpPermission.

string ipRange = "1.1.1.1/1";List<string> ranges = new List<string>() { ipRange };

var ipPermission = new IpPermission();ipPermission.IpProtocol = "tcp";ipPermission.FromPort = 3389;

100

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

ipPermission.ToPort = 3389;ipPermission.IpRanges = ranges;

IpProtocol

Le protocole IP.FromPort et ToPort

Le début et la fin de la plage de ports. Cet exemple spécifie un port unique (3389), utilisé pourcommuniquer avec Windows via RDP.

IpRanges

L'adresse IP ou des plages d'adresses, en notation CIDR. Pour plus de commodité, cet exempleutilise 72.21.198.64/24, qui autorise le trafic réseau pour une adresse IP unique. Vous pouvezutiliser http://checkip.amazonaws.com/ pour déterminer votre propre adresse IP.

2. Créez et initialisez un objet AuthorizeSecurityGroupIngressRequest.

var ingressRequest = new AuthorizeSecurityGroupIngressRequest();ingressRequest.GroupId = secGroup.GroupId;ingressRequest.IpPermissions.Add(ipPermission);

GroupId

L'identifiant du groupe de sécurité.IpPermissions

L'objet IpPermission de l'étape 1.3. (Facultatif) Vous pouvez ajouter des règles supplémentaires à la collection IpPermissions avant de

passer à l'étape suivante.4. Transmettez l'objet AuthorizeSecurityGroupIngressRequest à la méthode

AuthorizeSecurityGroupIngress, qui renvoie un objet AuthorizeSecurityGroupIngressResponse. S'ilexiste déjà une règle correspondante, une exception AmazonEC2Exception est générée.

try{ var ingressResponse = ec2Client.AuthorizeSecurityGroupIngress(ingressRequest); Console.WriteLine("New RDP rule for: " + ipRange);}catch (AmazonEC2Exception ex){ // Check the ErrorCode to see if the rule already exists if ("InvalidPermission.Duplicate" == ex.ErrorCode) { Console.WriteLine("An RDP rule for: {0} already exists.", ipRange); } else { // The exception was thrown for another reason, so re-throw the exception throw; }}

Utilisation de paires de clés Amazon EC2Amazon EC2 utilise le chiffrement à clé publique pour chiffrer et déchiffrer les informations de connexion.Le chiffrement à clé publique a recours à une clé publique pour chiffrer les données ; le destinataire utilise

101

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

ensuite la clé privée pour déchiffrer les données. La clé publique et la clé privée constituent une pairede clés. Vous devez indiquer une paire de clés au moment de lancer une instance EC2 et spécifier laclé privée de la paire de clés lorsque vous vous connectez à l'instance. Vous pouvez créer une paire declés ou utiliser une paire utilisée lors du lancement d'autres instances. Pour plus d'informations, consultezPaires de clés Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows. Cetexemple montre comment créer une paire de clés, décrire les paires de clés et supprimer une paire de clésà l'aide des méthodes AmazonEC2Client suivantes :

• CreateKeyPair• DeleteKeyPair• DescribeKeyPairs

Pour plus d'informations sur la création d'un client Amazon EC2, consultez Création d'un client AmazonEC2 (p. 97).

Création d'une paire de clés et enregistrement de la clé privée

Lorsque vous créez une paire de clés, vous devez enregistrer la clé privée qui est renvoyée. Vous nepouvez pas récupérer la clé privée ultérieurement.

Créez et initialisez un objet CreateKeyPairRequest. Affectez à la propriété KeyName le nom de la paire declés.

Transmettez l'objet de demande à la méthode CreateKeyPair, qui renvoie un objetCreateKeyPairResponse. S'il existe déjà une paire de clés portant le nom spécifié, une exceptionAmazonEC2Exception est levée.

L'objet de réponse inclut un objet CreateKeyPairResponse qui contient l'objet KeyPair de la nouvelleclé. La propriété KeyMaterial de l'objet KeyPair contient la clé privée non chiffrée de la paire de clés.Enregistrez la clé privée en tant que .pem à un emplacement sûr. Vous aurez besoin de ce fichier pourvous connecter à votre instance. Cet exemple enregistre la clé privée sous le nom de fichier spécifié.

public static void CreateKeyPair( AmazonEC2Client ec2Client, string keyPairName, string privateKeyFile){ var request = new CreateKeyPairRequest(); request.KeyName = keyPairName;

try { var response = ec2Client.CreateKeyPair(request); Console.WriteLine(); Console.WriteLine("New key: " + keyPairName);

// Save the private key in a .pem file using (FileStream s = new FileStream(privateKeyFile, FileMode.Create)) using (StreamWriter writer = new StreamWriter(s)) { writer.WriteLine(response.KeyPair.KeyMaterial); } } catch (AmazonEC2Exception ex) { // Check the ErrorCode to see if the key already exists if("InvalidKeyPair.Duplicate" == ex.ErrorCode) { Console.WriteLine("The key pair \"{0}\" already exists.", keyPairName);

102

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

} else { // The exception was thrown for another reason, so re-throw the exception. throw; } }}

.. _enumerate-key-pairs:

Énumération de vos paires de clés

Vous pouvez énumérer vos paires de clés et vérifier si une paire de clés existe.

Obtenez la liste complète de vos paires de clés en utilisant la méthode DescribeKeyPairs sans aucunparamètre.

public static void EnumerateKeyPairs(AmazonEC2Client ec2Client){ var request = new DescribeKeyPairsRequest(); var response = ec2Client.DescribeKeyPairs(request);

foreach (KeyPairInfo item in response.KeyPairs) { Console.WriteLine("Existing key pair: " + item.KeyName); }}

.. _delete-key-pairs:

Suppression de paires de clés

Vous pouvez supprimer une paire de clés en appelant la méthode DeleteKeyPair à partir de votre instanceAmazonEC2Client.

Transmettez un objet DeleteKeyPairRequest contenant le nom de la paire de clés à la méthodeDeleteKeyPair de l'objet AmazonEC2Client.

public static void DeleteKeyPair( AmazonEC2Client ec2Client, KeyPair keyPair){ try { // Delete key pair created for sample ec2Client.DeleteKeyPair(new DeleteKeyPairRequest { KeyName = keyPair.KeyName }); } catch (AmazonEC2Exception ex) { // Check the ErrorCode to see if the key already exists if ("InvalidKeyPair.NotFound" == ex.ErrorCode) { Console.WriteLine("The key pair \"{0}\" was not found.", keyPair.KeyName); } else { // The exception was thrown for another reason, so re-throw the exception throw; } }

103

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

}

Lancer une instance Amazon EC2Utilisez la procédure suivante pour lancer une ou plusieurs instances Amazon EC2 configurés de manièreidentique à partir de la même AMI (Amazon Machine Image). Une fois que vous avez créé vos instancesEC2, vous pouvez vérifier leur statut. Lorsque vos instances EC2 sont en cours d'exécution, vous pouvezvous y connecter.

Pour plus d'informations sur la création d'un client Amazon EC2, consultez Création d'un client AmazonEC2 (p. 97).

Lancer une instance EC2 dans EC2-Classic ou dans un VPCVous pouvez lancer une instance dans EC2-Classic ou dans un VPC. Pour plus d'informations surEC2-Classic et EC2-VPC, consultez la section Plateformes prises en charge du Amazon EC2 Guide del'utilisateur pour les instances Windows.

Pour obtenir une liste de vos groupes de sécurité et de leurs propriétés GroupId, consultez Énumérationde vos groupes de sécurité (p. 98).

Pour lancer une instance EC2 dans EC2-Classic

1. Créez et initialisez un objet RunInstancesRequest. Assurez-vous que l'AMI, la paire de clés et legroupe de sécurité que vous spécifiez existent dans la région que vous avez spécifiée lors de lacréation de l'objet client.

string amiID = "ami-e189c8d1";string keyPairName = "my-sample-key";

List<string> groups = new List<string>() { mySG.GroupId };var launchRequest = new RunInstancesRequest(){ ImageId = amiID, InstanceType = InstanceType.T1Micro, MinCount = 1, MaxCount = 1, KeyName = keyPairName, SecurityGroupIds = groups};

ImageId

ID de l'AMI. Pour obtenir la liste des AMI publiques, consultez Amazon Machine Images.InstanceType

Type d'instance compatible avec l'AMI spécifiée. Pour plus d'informations, consultez Typesd'instance dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows.

MinCount

Nombre minimal d'instances EC2 à lancer. Si ce nombre est supérieur au nombre d'instancesqu'Amazon EC2 peut lancer dans la zone de disponibilité cible, Amazon EC2 ne lance aucuneinstance.

MaxCount

Nombre maximal d'instances EC2 à lancer. S’il s’agit de plus d’instances que Amazon EC2 peutêtre lancé dans la zone de disponibilité cible, Amazon EC2 lance le plus grand nombre possibled’instances ci-dessus MinCount. Vous pouvez lancer entre 1 et le nombre maximal d’instancesque vous êtes autorisé pour le type d’instance. Pour plus d'informations, consultez Combien

104

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

d'instances puis-je exécuter dans Amazon EC2 ? dans les questions d'ordre général de la FAQsur Amazon EC2.

KeyName

Nom de la paire de clés EC2. Si vous lancez une instance sans spécifier de paire de clés, vousne pouvez pas vous y connecter. Pour plus d'informations, consultez Utilisation des paires de clésAmazon EC2 (p. 101).

SecurityGroupIds

Identifiant(s) d'un ou de plusieurs groupes de sécurité. Pour plus d'informations, consultezCréation d'un groupe de sécurité dans Amazon EC2 (p. 97).

2. (Facultatif) Pour lancer l'instance avec un rôle IAM (p. 142), spécifiez un profil d'instance IAM dansl'objet RunInstancesRequest.

Un utilisateur IAM ne peut pas lancer d'instance avec un rôle IAM sans les autorisations accordées parla stratégie suivante.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "iam:PassRole", "iam:ListInstanceProfiles", "ec2:*" ], "Resource": "*" }] }

Par exemple, l'extrait de code suivant instancie et configure un objet IamInstanceProfileSpecificationpour un rôle IAM nommé winapp-instance-role-1.

var instanceProfile = new IamInstanceProfile();instanceProfile.Id = "winapp-instance-role-1";

Pour spécifier ce profil d'instance dans l'objet RunInstancesRequest, ajoutez la ligne suivante.

launchRequest.IamInstanceProfile = instanceProfile;

3. Lancez l'instance en transmettant l'objet de demande à la méthode RunInstances. Enregistrez l'ID del'instance, car vous en aurez besoin pour gérer celle-ci.

Utilisez l'objet RunInstancesResponse renvoyé pour obtenir les ID des nouvelles instances. Lapropriété Reservation.Instances contient une liste d'objets Instance, un par instance EC2lancée. Vous pouvez récupérer l'ID de chaque instance à partir de la propriété InstanceId de l'objetInstance.

var launchResponse = ec2Client.RunInstances(launchRequest);var instances = launchResponse.Reservation.Instances;var instanceIds = new List<string>();foreach (Instance item in instances){ instanceIds.Add(item.InstanceId); Console.WriteLine(); Console.WriteLine("New instance: " + item.InstanceId); Console.WriteLine("Instance state: " + item.State.Name);}

105

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Pour lancer une instance EC2 dans un VPC

1. Créez et initialisez une interface réseau Elastic dans un sous-réseau du VPC.

string subnetID = "subnet-cb663da2";

List<string> groups = new List<string>() { mySG.GroupId };var eni = new InstanceNetworkInterfaceSpecification(){ DeviceIndex = 0, SubnetId = subnetID, Groups = groups, AssociatePublicIpAddress = true};List<InstanceNetworkInterfaceSpecification> enis = new List<InstanceNetworkInterfaceSpecification>() {eni};

DeviceIndex

Index du périphérique sur l'instance pour l'attachement d'interface réseau.SubnetId

ID du sous-réseau sur lequel l'instance sera lancée.Groups

Un ou plusieurs groupes de sécurité Pour plus d'informations, consultez Création d'un groupe desécurité dans Amazon EC2 (p. 97).

AssociatePublicIpAddress

Indique s'il convient d'attribuer automatiquement une adresse IP publique à une instance dans unVPC.

2. Créez et initialisez un objet RunInstancesRequest. Assurez-vous que l'AMI, la paire de clés et legroupe de sécurité que vous spécifiez existent dans la région que vous avez spécifiée lors de lacréation de l'objet client.

string amiID = "ami-e189c8d1";string keyPairName = "my-sample-key";

var launchRequest = new RunInstancesRequest(){ ImageId = amiID, InstanceType = InstanceType.T1Micro, MinCount = 1, MaxCount = 1, KeyName = keyPairName, NetworkInterfaces = enis};

ImageId

ID de l'AMI. Pour obtenir la liste des AMI publiques fournies par Amazon, consultez AmazonMachine Images.

InstanceType

Type d'instance compatible avec l'AMI spécifiée. Pour plus d'informations, consultez Typesd'instance dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows.

106

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

MinCount

Nombre minimal d'instances EC2 à lancer. Si ce nombre est supérieur au nombre d'instancesqu'Amazon EC2 peut lancer dans la zone de disponibilité cible, Amazon EC2 ne lance aucuneinstance.

MaxCount

Nombre maximal d'instances EC2 à lancer. S’il s’agit de plus d’instances que Amazon EC2 peutêtre lancé dans la zone de disponibilité cible, Amazon EC2 lance le plus grand nombre possibled’instances ci-dessus MinCount. Vous pouvez lancer entre 1 et le nombre maximal d’instancesque vous êtes autorisé pour le type d’instance. Pour plus d'informations, consultez Combiend'instances puis-je exécuter dans Amazon EC2 ? dans les questions d'ordre général de la FAQsur Amazon EC2.

KeyName

Nom de la paire de clés EC2. Si vous lancez une instance sans spécifier de paire de clés, vousne pouvez pas vous y connecter. Pour plus d'informations, consultez Utilisation des paires de clésAmazon EC2 (p. 101).

NetworkInterfaces

Une ou plusieurs interface(s) réseau.3. (Facultatif) Pour lancer l'instance avec un rôle IAM (p. 142), spécifiez un profil d'instance IAM dans

l'objet RunInstancesRequest.

Un utilisateur IAM ne peut pas lancer d'instance avec un rôle IAM sans les autorisations accordées parla stratégie suivante.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "iam:PassRole", "iam:ListInstanceProfiles", "ec2:*" ], "Resource": "*" }]}

Par exemple, l'extrait de code suivant instancie et configure un objet IamInstanceProfileSpecificationpour un rôle IAM nommé winapp-instance-role-1.

var instanceProfile = new IamInstanceProfileSpecification();instanceProfile.Name = "winapp-instance-role-1";

Pour spécifier ce profil d'instance dans l'objet RunInstancesRequest, ajoutez la ligne suivante.

launchRequest.IamInstanceProfile = instanceProfile;

4. Lancez les instances en transmettant l'objet de demande à la méthode RunInstances. Enregistrez l'IDdes instances, car vous en aurez besoin pour gérer celles-ci.

Utilisez l'objet RunInstancesResponse renvoyé pour obtenir une liste des ID des nouvelles instances.La propriété Reservation.Instances contient une liste d'objets Instance, un par instance EC2lancée. Vous pouvez récupérer l'ID de chaque instance à partir de la propriété InstanceId de l'objetInstance.

107

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

RunInstancesResponse launchResponse = ec2Client.RunInstances(launchRequest);

List<String> instanceIds = new List<string>();foreach (Instance instance in launchResponse.Reservation.Instances){ Console.WriteLine(instance.InstanceId); instanceIds.Add(instance.InstanceId);}

Vérifier l'état de votre instanceUtilisez la procédure suivante pour obtenir l'état actuel de votre instance. Initialement, votre instance est àl'état pending. Lorsque votre instance passe à l'état running, vous pouvez vous y connecter.

1. Créez et configurez un objet DescribeInstancesRequest et affectez l'ID de votre instance à la propriétéInstanceIds. Vous pouvez également utiliser la propriété Filter pour limiter la demande à certainesinstances, par exemple aux instances avec une balise particulière spécifiée par l'utilisateur.

var instanceRequest = new DescribeInstancesRequest();instanceRequest.InstanceIds = new List<string>();instanceRequest.InstanceIds.Add(instanceId);

2. Appelez la méthode DescribeInstances et transmettez-lui l'objet de demande de l'étape 1. La méthoderenvoie un objet DescribeInstancesResponse qui contient des informations sur l'instance.

var response = ec2Client.DescribeInstances(instanceRequest);

3. La propriété DescribeInstancesResponse.Reservations contient une liste des réservations.Dans ce cas, il n'y a qu'une réservation. Chaque réservation contient une liste d'objets Instance.Là encore, dans ce cas, il n'y a qu'une instance. Vous pouvez obtenir l'état de l'instance à partir de lapropriété State.

Console.WriteLine(response.Reservations[0].Instances[0].State.Name);

Vous connecter à votre instance en cours d'exécutionLorsqu'une instance est en cours d'exécution, vous pouvez vous y connecter à distance par l'intermédiairedu client distant approprié.

Pour les instances Linux, utilisez un client SSH. Vous devez vérifier que le port SSH de l'instance (22)est ouvert au trafic. Vous avez besoin de l'adresse IP publique de l'instance ou du nom DNS public etde la partie privée de la paire de clés utilisée pour lancer l'instance. Pour plus d'informations, consultezConnexion à votre instance Linux dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

Pour les instances Windows, utilisez un client RDP. Vous devez vérifier que le port RDP de l'instance(3389) est ouvert au trafic. Vous avez besoin de l'adresse IP publique de l'instance ou du nom DNS publicet du mot de passe administrateur. Vous pouvez obtenir le mot de passe administrateur avec les méthodesGetPasswordData et GetPasswordDataResult.GetDecryptedPassword, qui nécessitent la partie privéede la paire de clés utilisée pour lancer l'instance. Pour plus d'informations, consultez Connexion à votreinstance Windows à l'aide de RDP dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows.L'exemple suivant montre comment obtenir le mot de passe pour une instance Windows.

public static string GetWindowsPassword( AmazonEC2Client ec2Client, string instanceId,

108

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

FileInfo privateKeyFile){ string password = "";

var request = new GetPasswordDataRequest(); request.InstanceId = instanceId;

var response = ec2Client.GetPasswordData(request); if (null != response.PasswordData) { using (StreamReader sr = new StreamReader(privateKeyFile.FullName)) { string privateKeyData = sr.ReadToEnd(); password = response.GetDecryptedPassword(privateKeyData); } } else { Console.WriteLine("The password is not available. The password for " + "instance {0} is either not ready, or it is not a Windows instance.", instanceId); }

return password;}

Lorsque vous n'avez plus besoin de votre instance EC2, consultez Résiliation d'une instance AmazonEC2 (p. 109).

Résiliation d'une instance Amazon EC2Lorsque vous n'avez plus besoin de vos instances Amazon EC2, vous pouvez les résilier.

Pour plus d'informations sur la création d'un client Amazon EC2, consultez Création d'un client AmazonEC2 (p. 97).

Pour mettre une instance EC2 hors service

1. Créez et initialisez un objet TerminateInstancesRequest.2. Affectez à la propriété TerminateInstancesRequest.InstanceIds une liste d'un ou plusieurs ID

d'instance pour les instances à résilier.3. Transmettez l'objet de demande à la méthode TerminateInstances. Si l'instance spécifiée n'existe pas,

une exception AmazonEC2Exception est levée.4. L'objet TerminateInstancesResponse permet de répertorier les instances résiliées, comme suit.

public static void TerminateInstance( AmazonEC2Client ec2Client, string instanceId){ var request = new TerminateInstancesRequest(); request.InstanceIds = new List<string>() { instanceId };

try { var response = ec2Client.TerminateInstances(request); foreach (InstanceStateChange item in response.TerminatingInstances) { Console.WriteLine("Terminated instance: " + item.InstanceId); Console.WriteLine("Instance state: " + item.CurrentState.Name); } }

109

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

catch(AmazonEC2Exception ex) { // Check the ErrorCode to see if the instance does not exist. if ("InvalidInstanceID.NotFound" == ex.ErrorCode) { Console.WriteLine("Instance {0} does not exist.", instanceId); } else { // The exception was thrown for another reason, so re-throw the exception. throw; } }}

Utilisation des régions et des zones de disponibilité avec AmazonEC2Cet exemple .NET explique comment :

• Obtenir des détails sur les zones de disponibilité• Obtenir des détails sur les régions

Scénario

Amazon EC2 est hébergé à plusieurs endroits dans le monde. Ces emplacements sont composés derégions et de zones de disponibilité. Chaque région est une zone géographique distincte qui se composede plusieurs emplacements isolés appelés zones de disponibilité. Amazon EC2 vous offre la possibilité deplacer des instances et des données dans plusieurs emplacements.

Vous pouvez utiliser le Kit AWS SDK pour .NET pour récupérer les détails sur les régions et les zones dedisponibilité en utilisant les méthodes suivantes de la classe AmazonEC2Client :

• DescribeAvailabilityZones• DescribeRegions

Pour en savoir plus sur les régions et les zones de disponibilité, consultez Régions et zones de disponibilitédans le Amazon EC2 Guide de l'utilisateur pour les instances Windows.

Décrire les zones de disponibilité

Créez une instance AmazonEC2Client et appelez la méthode DescribeAvailabilityZones. L'objetDescribeAvailabilityZonesResponse renvoyé contient la liste des zones de disponibilité.

public static void DescribeAvailabilityZones(){ Console.WriteLine("Describe Availability Zones"); AmazonEC2Client client = new AmazonEC2Client(); DescribeAvailabilityZonesResponse response = client.DescribeAvailabilityZones(); var availZones = new List<AvailabilityZone>(); availZones = response.AvailabilityZones; foreach (AvailabilityZone az in availZones) { Console.WriteLine(az.ZoneName); }}

110

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Décrire des régionsCréez une instance AmazonEC2Client et appelez la méthode DescribeRegions. L'objetDescribeRegionsResponse renvoyé contient la liste des régions.

public static void DescribeRegions(){ Console.WriteLine("Describe Regions"); AmazonEC2Client client = new AmazonEC2Client(); DescribeRegionsResponse response = client.DescribeRegions(); var regions = new List<Region>(); regions = response.Regions; foreach (Region region in regions) { Console.WriteLine(region.RegionName); }}

Utilisation de points de terminaison de VPC avec Amazon EC2Cet exemple .NET vous montre comment créer, décrire, modifier et supprimer les points de terminaisond'un VPC.

ScénarioUn point de terminaison vous permet de créer une connexion privée entre votre VPC et un autre serviceAWS de votre compte. Vous pouvez spécifier une stratégie à attacher au point de terminaison en vue decontrôler l'accès au service à partir de votre VPC. Vous pouvez également spécifier les tables de routagedu VPC qui utilisent le point de terminaison.

Cet exemple utilise les méthodes AmazonEC2Client suivantes :

• CreateVpcEndpoint• DescribeVpcEndpoints• ModifyVpcEndpoint• DeleteVpcEndpoints

Création d'un point de terminaison de VPCL'exemple suivant crée un point de terminaison de VPC pour Amazon Simple Storage Service (S3).

Créez une instance AmazonEC2Client. Pour créer un point de terminaison de VPC, vous devez créer unVPC.

Créez un objet CreateVpcRequest en spécifiant un bloc d'adresse CIDR IPv4 comme paramètre de sonconstructeur. En utilisant cet objet CreateVpcRequest, utilisez la méthode CreateVpc pour créer un VPC.Utilisez ce VPC pour instancier un objet CreateVpcEndpointRequest, en spécifiant le nom de service pourle point de terminaison. Utilisez ensuite cet objet de demande pour appeler la méthode CreateVpcEndpointet créer le VpcEndpoint.

public static void CreateVPCEndpoint(){ AmazonEC2Client client = new AmazonEC2Client(); CreateVpcRequest vpcRequest = new CreateVpcRequest("10.32.0.0/16"); CreateVpcResponse vpcResponse = client.CreateVpc(vpcRequest); Vpc vpc = vpcResponse.Vpc; CreateVpcEndpointRequest endpointRequest = new CreateVpcEndpointRequest(); endpointRequest.VpcId = vpc.VpcId; endpointRequest.ServiceName = "com.amazonaws.us-west-2.s3";

111

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

CreateVpcEndpointResponse cVpcErsp = client.CreateVpcEndpoint(endpointRequest); VpcEndpoint vpcEndPoint = cVpcErsp.VpcEndpoint;}

Description d'un point de terminaison de VPCCréez une instance AmazonEC2Client. Créez ensuite un objet DescribeVpcEndpointsRequest et limitez lenombre maximal de résultats à renvoyer à 5. Utilisez cet objet DescribeVpcEndpointsRequest pourappeler la méthode DescribeVpcEndpoints. L'objet DescribeVpcEndpointsResponse renvoyé contient laliste des points de terminaison du VPC.

public static void DescribeVPCEndPoints(){ AmazonEC2Client client = new AmazonEC2Client(); DescribeVpcEndpointsRequest endpointRequest = new DescribeVpcEndpointsRequest(); endpointRequest.MaxResults = 5; DescribeVpcEndpointsResponse endpointResponse = client.DescribeVpcEndpoints(endpointRequest); List<VpcEndpoint> endpointList = endpointResponse.VpcEndpoints; foreach (VpcEndpoint vpc in endpointList) { Console.WriteLine("VpcEndpoint ID = " + vpc.VpcEndpointId); List<string> routeTableIds = vpc.RouteTableIds; foreach (string id in routeTableIds) { Console.WriteLine("\tRoute Table ID = " + id); }

}}

Modification d'un point de terminaison de VPCL'exemple suivant modifie les attributs d'un point de terminaison de VPC spécifié. Vous pouvez modifier lastratégie associée au point de terminaison, de même que vous pouvez ajouter des tables de routage aupoint de terminaison et supprimer celles qui lui sont associées.

Créez une instance AmazonEC2Client. Créez un objet ModifyVpcEndpointRequest en utilisant l'ID du pointde terminaison de VPC et l'ID de la table de routage à ajouter. Appelez la méthode ModifyVpcEndpoint enutilisant l'objet ModifyVpcEndpointRequest. L'objet ModifyVpcEndpointResponse renvoyé contient uncode d'état HTTP indiquant si la demande de modification a abouti.

public static void ModifyVPCEndPoint(){ AmazonEC2Client client = new AmazonEC2Client(); ModifyVpcEndpointRequest modifyRequest = new ModifyVpcEndpointRequest(); modifyRequest.VpcEndpointId = "vpce-17b05a7e"; modifyRequest.AddRouteTableIds = new List<string> { "rtb-c46f15a3" }; ModifyVpcEndpointResponse modifyResponse = client.ModifyVpcEndpoint(modifyRequest); HttpStatusCode status = modifyResponse.HttpStatusCode; if (status.ToString() == "OK") Console.WriteLine("ModifyHostsRequest succeeded"); else Console.WriteLine("ModifyHostsRequest failed");

Suppression d'un point de terminaison de VPCVous pouvez supprimer un ou plusieurs points de terminaison de VPC spécifiés. La suppression d'un pointde terminaison entraîne également celle des routes du point de terminaison contenues dans les tables deroutage associées au point de terminaison.

112

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

Créez une instance AmazonEC2Client. Utilisez la méthode DescribeVpcEndpoints pour répertorierles points de terminaison de VPC associés au client EC2. Servez-vous de cette liste pour créerune liste d'ID des points de terminaison du VPC. Servez-vous de cette liste pour créer un objetDeleteVpcEndpointsRequest qui sera utilisé par la méthode DeleteVpcEndpoints.

private static void DeleteVPCEndPoint(){ AmazonEC2Client client = new AmazonEC2Client(); DescribeVpcEndpointsRequest endpointRequest = new DescribeVpcEndpointsRequest(); endpointRequest.MaxResults = 5; DescribeVpcEndpointsResponse endpointResponse = client.DescribeVpcEndpoints(endpointRequest); List<VpcEndpoint> endpointList = endpointResponse.VpcEndpoints; var vpcEndPointListIds = new List<string>(); foreach (VpcEndpoint vpc in endpointList) { Console.WriteLine("VpcEndpoint ID = " + vpc.VpcEndpointId); vpcEndPointListIds.Add(vpc.VpcEndpointId); } DeleteVpcEndpointsRequest deleteRequest = new DeleteVpcEndpointsRequest(); deleteRequest.VpcEndpointIds = vpcEndPointListIds; client.DeleteVpcEndpoints(deleteRequest);}

Utilisation des adresses IP Elastic dans Amazon EC2Cet exemple .NET explique comment :

• récupérer la description de vos adresses IP Elastic ;• allouer et associer une adresse IP Elastic à une instance Amazon EC2 ;• Libérer une adresse IP Elastic

ScénarioUne EIP est une adresse IP statique conçue pour le cloud computing. Une adresse IP Elastic est associéeà votre compte AWS et constitue une adresse IP publique, accessible depuis Internet.

Si votre instance Amazon EC2 ne dispose pas d'une adresse IP publique, vous pouvez lui associer uneadresse IP Elastic pour permettre la communication avec Internet.

Dans cet exemple, vous utilisez le Kit AWS SDK pour .NET pour gérer les adresses IP Elastic à l'aide desméthodes suivantes de la classe client Amazon EC2 :

• DescribeAddresses• AllocateAddress• AssociateAddress• ReleaseAddress

Pour plus d'informations sur les adresses IP Elastic dans Amazon EC2, consultez Adresses IP Elastic dansle Amazon EC2 Guide de l'utilisateur pour les instances Windows.

Description des adresses IP ElasticCréez un objet AmazonEC2Client. Créez ensuite un objet DescribeAddressesRequest à transmettreen tant que paramètre, en filtrant les adresses renvoyées par celles de votre VPC. Pour récupérer ladescription de toutes vos adresses IP Elastic, il suffit d'omettre le filtre des paramètres. Appelez ensuite laméthode DescribeAddresses de l'objet AmazonEC2Client.

113

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances Amazon EC2

public void DescribeElasticIps(){ using (var client = new AmazonEC2Client(RegionEndpoint.USWest2)) { var addresses = client.DescribeAddresses(new DescribeAddressesRequest { Filters = new List<Filter> { new Filter { Name = "domain", Values = new List<string> { "vpc" } } } }).Addresses;

foreach(var address in addresses) { Console.WriteLine(address.PublicIp); Console.WriteLine("\tAllocation Id: " + address.AllocationId); Console.WriteLine("\tPrivate IP Address: " + address.PrivateIpAddress); Console.WriteLine("\tAssociation Id: " + address.AssociationId); Console.WriteLine("\tInstance Id: " + address.InstanceId); Console.WriteLine("\tNetwork Interface Owner Id: " + address.NetworkInterfaceOwnerId); } }}

Allocation et association d'une adresse IP Elastic

Créez un objet AmazonEC2Client. Créez ensuite un objet AllocateAddressRequest pour le paramètreutilisé afin d'allouer une adresse IP Elastic qui, dans le cas présent, spécifie que le domaine est un VPC.Appelez la méthode AllocateAddress de l'objet AmazonEC2Client.

En cas de réussite, l'objet AllocateAddressResponse renvoyé dispose d'une propriété AllocationId quiidentifie l'adresse IP Elastic allouée.

Créez un objet AssociateAddressRequest pour les paramètres utilisés afin d'associer une adresse IPElastic à une instance Amazon EC2. Incluez l'AllocationId de l'adresse nouvellement allouée etl'InstanceId de l'instance Amazon EC2. Appelez ensuite la méthode AssociateAddress de l'objetAmazonEC2Client.

public void AllocateAndAssociate(string instanceId){ using (var client = new AmazonEC2Client(RegionEndpoint.USWest2)) { var allocationId = client.AllocateAddress(new AllocateAddressRequest { Domain = DomainType.Vpc }).AllocationId;

Console.WriteLine("Allocation Id: " + allocationId);

var associationId = client.AssociateAddress(new AssociateAddressRequest { AllocationId = allocationId, InstanceId = instanceId }).AssociationId;

Console.WriteLine("Association Id: " + associationId); }

114

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

}

Libération d'une adresse IP ElasticCréez un objet AmazonEC2Client. Créez ensuite un objet ReleaseAddressRequest pour les paramètresutilisés afin de libérer une adresse IP Elastic qui, dans le cas présent, spécifie l'AllocationId del'adresse IP Elastic. La libération d'une adresse IP Elastic la dissocie également de toute instance AmazonEC2. Appelez la méthode ReleaseAddress de l'objet de service Amazon EC2.

public void Release(string allocationId){ using (var client = new AmazonEC2Client(RegionEndpoint.USWest2)) { client.ReleaseAddress(new ReleaseAddressRequest { AllocationId = allocationId }); }}

Exemples d'instances ponctuelles Amazon EC2Cette rubrique décrit comment utiliser le kit Kit AWS SDK pour .NET pour créer, annuler et résilier uneinstance Spot Amazon EC2.

Rubriques• Overview (p. 115)• Prerequisites (p. 116)• Définition de vos informations d'identification (p. 116)• Soumission de votre demande Spot (p. 116)• Détermination de l'état de votre demande Spot (p. 118)• Nettoyage de vos demandes et instances Spot (p. 119)• Assemblage de tous les éléments (p. 120)

OverviewLes instances Spot vous permettent de demander des instances inutilisées Amazon EC2 pour moins cherque le prix à la demande. Cela peut réduire considérablement vos coûts EC2 pour les applications quipeuvent être interrompues.

Voici un résumé de haut niveau de la façon dont les instances Spot sont demandées et utilisées.

1. Créez une demande d’instance Spot, en spécifiant le prix maximum que vous êtes prêt à payer.2. Lorsque la demande est satisfaite, exécutez l’instance comme vous le feriez pour n’importe quelle

autre Amazon EC2 instance.3. Exécutez l’instance aussi longtemps que vous le souhaitez, puis résiliez-la, sauf si Prix au comptant

pour que l’instance soit résiliée pour vous.4. Nettoyez la demande d’instance Spot lorsque vous n’en avez plus besoin afin que les instances Spot

ne soient plus créées.

Il s’agit d’une présentation de très haut niveau des instances Spot. Vous pouvez mieux comprendreles instances Spot en les lisant dans le Guide de l’utilisateur EC2 pour Linux ou le Guide de l’utilisateurEC2 pour Windows.

115

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

Ce didacticiel explique comment utiliser l'environnement de programmation .NET pour effectuer lesopérations suivantes.

• Soumettre une demande Spot• Déterminer à quel moment la demande Spot est satisfaite• Annuler la demande Spot• Résilier les instances associées

PrerequisitesCe didacticiel suppose que vous êtes inscrit à AWS, que votre environnement de développement .NET estdéfini et que le Kit AWS SDK pour .NET est installé. Si vous utilisez l'environnement de développementMicrosoft Visual Studio, nous vous recommandons d'installer AWS Toolkit for Visual Studio. Pour obtenirdes instructions pour la configuration de votre environnement, consultez Mise en route avec AWS SDKpour .NET (p. 15).

Définition de vos informations d'identificationPour plus d'informations sur l'utilisation de vos informations d'identification AWS avec le kit SDK, consultezConfiguration des informations d'identification AWS (p. 26).

Soumission de votre demande SpotPour soumettre une demande Spot, vous devez d'abord déterminer le type d'instance, l'Amazon MachineImage (AMI) et la demande maximale que vous souhaitez offrir. Vous devez également inclure un groupede sécurité configuré précédemment, afin de pouvoir vous connecter à l'instance, si vous le souhaitez. Pourplus d'informations sur la création de groupes de sécurité, consultez Création d'un groupe de sécurité dansAmazon EC2 (p. 97).

Il existe plusieurs types d'instances au choix. Consultez Types d'instances Amazon EC2 pour obtenir laliste complète. Pour ce didacticiel, nous utiliserons t1.micro. Vous voudrez également obtenir l’ID d’uneAMI Windows actuelle. Pour plus d'informations, consultez Recherche d'une AMI dans le Amazon EC2Guide de l'utilisateur pour les instances Windows.

Il existe de nombreuses façons d'aborder la demande d'instances Spot. Pour commencer, nous allonsdécrire trois stratégies communes :

• Demande de s'assurer que le coût est inférieur à la tarification à la demande.• Demande basée sur la valeur du calcul résultant.• Demande afin d'acquérir la capacité de calcul le plus rapidement possible.

Réduction du coût sous la tarification à la demande

Vous avez une tâche de traitement par lot dont l'exécution prendra un certain nombre d'heuresou de jours. Toutefois, vous êtes flexible quant aux dates et heures de début et de fin de la tâche.Vous voulez savoir si vous pouvez exécuter cette tâche à un coût inférieur à celui des instancesà la demande. Vous examinez l'historique des prix Spot pour les types d'instances à l'aide de laAWS Management Console ou de l'API Amazon EC2. Pour plus d'informations, consultez la pageAffichage de l'historique des prix Spot. Une fois que vous avez analysé l'historique des prix pour le typed'instance souhaité dans une zone de disponibilité donnée, deux approches sont possibles pour votredemande :• Spécifiez une demande à la limite supérieure de la plage de prix Spot (qui sont toujours inférieurs

au prix à la demande), en anticipant que votre demande d'instance Spot sera très probablementsatisfaite et que vous aurez suffisamment de temps de calcul consécutif pour terminer la tâche.

116

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

• Spécifiez une demande à la limite inférieure de la plage de prix et envisagez de combiner plusieursinstances lancées au fil du temps via une demande persistante. Les instances vont s'exécutersuffisamment longtemps, au total, pour terminer la tâche avec un coût total plus faible. (Nous vousexpliquerons comment automatiser cette tâche plus tard dans ce didacticiel.)

Paiement égal ou inférieur à la valeur des résultats

Vous avez une tâche de traitement de données à exécuter. Vous connaissez la valeur des résultatsde la tâche suffisamment bien pour savoir qu'ils représentent un réel intérêt en termes de coûtsinformatiques. Une fois que vous avez analysé l'historique des prix Spot pour votre type d'instance,vous choisissez une demande pour laquelle le coût du temps de calcul n'est pas supérieur à la valeurdes résultats de la tâche. Vous créez une demande persistante et faites en sorte qu'elle s'exécute defaçon intermittente selon que le prix Spot est égal ou inférieur à votre demande.

Acquisition rapide de capacité de calcul

Vous avez un besoin de capacité supplémentaire imprévu, à court terme, que les instances à lademande ne peuvent pas satisfaire. Une fois que vous avez analysé l'historique des prix Spot pourvotre type d'instance, vous effectuez une demande supérieure au prix historique le plus élevé afind'augmenter fortement la probabilité que votre demande sera satisfaite rapidement et que vouspourrez poursuivre les calculs jusqu'à ce qu'elle soit terminée.

Une fois que vous avez effectué votre analyse, vous êtes prêt à demander une instance Spot. Pour cedidacticiel, le prix maximal d'instance spot par défaut est défini pour être le même que celui à la demande(qui est de 0,003 $pour ce didacticiel). Fixer le prix de cette manière maximise les chances de satisfaire lademande. Vous pouvez déterminer les types d'instances disponibles et les prix à la demande des instancesen accédant à la page Tarification Amazon EC2.

Tout d'abord, spécifiez les espaces de noms .NET utilisés dans l'application.

using System;using System.Collections.Generic;using System.Threading;using Amazon;using Amazon.EC2;using Amazon.EC2.Model;

Pour plus d'informations sur la création d'un client Amazon EC2, consultez Création d'un client AmazonEC2 (p. 97).

Ensuite, pour demander une instance Spot, il vous suffit de créer une demande avec les paramètresspécifiés jusqu'à présent. Commencez par créer un objet RequestSpotInstanceRequest. L'objet de lademande nécessite le montant de la demande et le nombre d'instances que vous voulez démarrer. Deplus, vous devez définir l'élément LaunchSpecification de la demande, qui comprend le type d'instance,l'ID d'AMI et le nom du groupe de sécurité que vous souhaitez utiliser pour les instances Spot. Lorsque lademande est remplie, appelez la méthode RequestSpotInstances pour créer la demande d'instance Spot.L'exemple suivant présente comment demander une instance Spot.

/* Creates a spot instance * * Takes six args: * AmazonEC2Client ec2Client is the EC2 client through which the spot instance request is made * string amiId is the AMI of the instance to request * string securityGroupName is the name of the security group of the instance to request * InstanceType instanceType is the type of the instance to request * string spotPrice is the price of the instance to request * int instanceCount is the number of instances to request *

117

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

* See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2RequestSpotInstancesRequestSpotInstancesRequest.html */ private static SpotInstanceRequest RequestSpotInstance( AmazonEC2Client ec2Client, string amiId, string securityGroupName, InstanceType instanceType, string spotPrice, int instanceCount) { RequestSpotInstancesRequest request = new RequestSpotInstancesRequest { SpotPrice = spotPrice, InstanceCount = instanceCount };

LaunchSpecification launchSpecification = new LaunchSpecification { ImageId = amiId, InstanceType = instanceType };

launchSpecification.SecurityGroups.Add(securityGroupName);

request.LaunchSpecification = launchSpecification;

var result = ec2Client.RequestSpotInstancesAsync(request);

return result.Result.SpotInstanceRequests[0]; }

L'ID de demande Spot est contenu dans le membre SpotInstanceRequestId de l'objetSpotInstanceRequest.

L'exécution de ce code lance une nouvelle demande d'instance Spot.

Note

Vous serez facturé pour toute instance Spot lancée. Veillez donc à annuler toute demande inutileet à résilier toutes les instances que vous lancez afin de réduire les frais associés.

Il existe d'autres options que vous pouvez utiliser pour configurer vos demandes Spot. Pour en savoir plus,consultez RequestSpotInstances dans le Kit AWS SDK pour .NET.

Détermination de l'état de votre demande SpotNous devons attendre que la demande Spot atteigne le statut Active avant de passer à la dernière étape.Pour déterminer l'état de votre demande Spot, nous utilisons la méthode DescribeSpotInstanceRequestspour obtenir l'état de l'ID de la demande Spot qui nous intéresse.

/* Gets the state of a spot instance request. * Takes two args: * AmazonEC2Client ec2Client is the EC2 client through which information about the state of the spot instance is made * string spotRequestId is the ID of the spot instance * * See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2DescribeSpotInstanceRequests.html */ private static SpotInstanceState GetSpotRequestState( AmazonEC2Client ec2Client, string spotRequestId)

118

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

{ // Create the describeRequest object with all of the request ids // to monitor (e.g. that we started). var request = new DescribeSpotInstanceRequestsRequest(); request.SpotInstanceRequestIds.Add(spotRequestId);

// Retrieve the request we want to monitor. var describeResponse = ec2Client.DescribeSpotInstanceRequestsAsync(request);

SpotInstanceRequest req = describeResponse.Result.SpotInstanceRequests[0];

return req.State; }

Nettoyage de vos demandes et instances SpotLa dernière étape consiste à nettoyer les demandes et les instances. Il est important à la fois d'annulertoutes les demandes en cours et de résilier toutes les instances. Si vous annulez simplement vosdemandes, cela ne résiliera pas vos instances, ce qui signifie que vous continuerez à être facturé pourelles. Lorsque vous résiliez vos instances, vos demandes Spot peuvent être annulées, mais dans certainscas, par exemple, si vous utilisez des demandes persistantes, la résiliation de vos instances ne serapas suffisante pour empêcher votre demande d'être à nouveau satisfaite. Par conséquent, annuler lesdemandes actives et résilier en même temps toutes les instances en cours d'exécution constitue une bonnepratique.

Utilisez la méthode CancelSpotInstanceRequests pour annuler une demande Spot. L'exemple suivantprésente comment annuler une demande Spot.

/* Cancels a spot instance request * Takes two args: * AmazonEC2Client ec2Client is the EC2 client through which the spot instance is cancelled * string spotRequestId is the ID of the spot instance * * See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2CancelSpotInstanceRequestsCancelSpotInstanceRequestsRequest.html */ private static void CancelSpotRequest( AmazonEC2Client ec2Client, string spotRequestId) { var cancelRequest = new CancelSpotInstanceRequestsRequest();

cancelRequest.SpotInstanceRequestIds.Add(spotRequestId);

ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest); }

Utilisez la méthode TerminateInstances pour résilier une instance. L'exemple suivant montre commentobtenir l'identifiant d'instance pour une instance Spot active et résilier cette instance.

/* Terminates a spot instance request * Takes two args: * AmazonEC2Client ec2Client is the EC2 client through which the spot instance is terminated * string spotRequestId is the ID of the spot instance * * See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2TerminateInstancesTerminateInstancesRequest.html */ private static void TerminateSpotInstance(

119

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

AmazonEC2Client ec2Client, string spotRequestId) { var describeRequest = new DescribeSpotInstanceRequestsRequest(); describeRequest.SpotInstanceRequestIds.Add(spotRequestId);

// Retrieve the request we want to monitor. var describeResponse = ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);

if (SpotInstanceState.Active == describeResponse.Result.SpotInstanceRequests[0].State) { string instanceId = describeResponse.Result.SpotInstanceRequests[0].InstanceId;

var terminateRequest = new TerminateInstancesRequest(); terminateRequest.InstanceIds = new List<string>() { instanceId };

try { ec2Client.TerminateInstancesAsync(terminateRequest); } catch (AmazonEC2Exception ex) { // Check the ErrorCode to see if the instance does not exist. if ("InvalidInstanceID.NotFound" == ex.ErrorCode) { Console.WriteLine("Instance {0} does not exist.", instanceId); } else { // The exception was thrown for another reason, so re-throw the exception. throw; } } } }

Pour plus d'informations sur la résiliation d'instances actives, consultez Résiliation d'une instance AmazonEC2 (p. 109).

Assemblage de tous les élémentsLa routine principale suivante appelle ces méthodes dans l'ordre indiqué pour créer, annuler et résilier unedemande d'instance Spot. Comme l'indique le commentaire, elle accepte un argument, l'AMI.

/* Creates, cancels, and terminates a spot instance request * * AmazonEC2Client ec2Client is the EC2 client through which the spot instance is manipulated * string spotRequestId is the ID of the spot instance * * See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/MEC2TerminateInstancesTerminateInstancesRequest.html */

// Displays information about the command-line args private static void Usage() { Console.WriteLine(""); Console.WriteLine("Usage:");

120

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

Console.WriteLine(""); Console.WriteLine("Ec2SpotCrud.exe AMI [-s SECURITY_GROUP] [-p SPOT_PRICE] [-c INSTANCE_COUNT] [-h]"); Console.WriteLine(" where:"); Console.WriteLine(" AMI is the AMI to use. No default value. Cannot be an empty string."); Console.WriteLine(" SECURITY_GROUP is the name of a security group. Default is default. Cannot be an empty string."); Console.WriteLine(" SPOT_PRICE is the spot price. Default is 0.003. Must be > 0.001."); Console.WriteLine(" INSTANCE_COUNT is the number of instances. Default is 1. Must be > 0."); Console.WriteLine(" -h displays this message and quits"); Console.WriteLine(); } /* Creates, cancels, and terminates a spot instance request * See Usage() for information about the command-line args */ static void Main(string[] args) { // Values that aren't easy to pass on the command line RegionEndpoint region = RegionEndpoint.USWest2; InstanceType instanceType = InstanceType.T1Micro; // Default values for optional command-line args string securityGroupName = "default"; string spotPrice = "0.003"; int instanceCount = 1;

// Placeholder for the only required command-line arg string amiId = "";

// Parse command-line args int i = 0; while (i < args.Length) { switch (args[i]) { case "-s": i++; securityGroupName = args[i]; if (securityGroupName == "") { Console.WriteLine("The security group name cannot be blank"); Usage(); return; } break; case "-p": i++; spotPrice = args[i]; double price; double.TryParse(spotPrice, out price); if (price < 0.001) { Console.WriteLine("The spot price must be > 0.001"); Usage(); return; } break; case "-c": i++; int.TryParse(args[i], out instanceCount); if (instanceCount < 1) {

121

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Exemples d'instances ponctuelles Amazon EC2

Console.WriteLine("The instance count must be > 0"); Usage(); return; } break; case "-h": Usage(); return; default: amiId = args[i]; break; }

i++; }

// Make sure we have an AMI if (amiId == "") { Console.WriteLine("You must supply an AMI"); Usage(); return; }

AmazonEC2Client ec2Client = new AmazonEC2Client(region: region);

Console.WriteLine("Creating spot instance request");

SpotInstanceRequest req = RequestSpotInstance(ec2Client, amiId, securityGroupName, instanceType, spotPrice, instanceCount);

string id = req.SpotInstanceRequestId;

// Wait for it to become active Console.WriteLine("Waiting for spot instance request with ID " + id + " to become active");

int wait = 1; int totalTime = 0;

while (true) { totalTime += wait; Console.Write(".");

SpotInstanceState state = GetSpotRequestState(ec2Client, id);

if (state == SpotInstanceState.Active) { Console.WriteLine(""); break; }

// wait a bit and try again Thread.Sleep(wait);

// wait longer next time // 1, 2, 4, ... wait = wait * 2; }

// Should be around 1000 (one second) Console.WriteLine("That took " + totalTime + " milliseconds");

// Cancel the request Console.WriteLine("Canceling spot instance request");

122

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Stockage de données d'archives avec Amazon S3 Glacier

CancelSpotRequest(ec2Client, id);

// Clean everything up Console.WriteLine("Terminating spot instance request");

TerminateSpotInstance(ec2Client, id);

Console.WriteLine("Done. Press enter to quit");

Console.ReadLine(); }

Consultez l'exemple complet, notamment des informations sur la façon de générer et d'exécuter l'exempleà partir de la ligne de commande, sur GitHub.

Stockage de données d'archives avec Amazon S3Glacier

Le kit Kit AWS SDK pour .NET prend en charge Amazon S3 Glacier, qui est un service de stockageoptimisé pour les données rarement utilisées, dites données froides. Ce service assure un stockagedurable et très économique tout en offrant des fonctions de sécurité pour la sauvegarde et l'archivage desdonnées. Pour en savoir plus, consultez le manuel du développeur Amazon S3 Glacier.

Vous trouverez ci-dessous une présentation des modèles de programmation S3 Glacier proposés dans lekit Kit AWS SDK pour .NET.

Modèles de programmationLe kit Kit AWS SDK pour .NET propose deux modèles de programmation compatibles avec S3 Glacier.Vous trouverez ci-dessous une description de ces modèles, ainsi que les raisons et la façon de les utiliser.

Rubriques• API de bas niveau (p. 123)• API de haut niveau (p. 125)

API de bas niveauLe kit Kit AWS SDK pour .NET propose des API de bas niveau pour une programmation avec S3 Glacier.Ces API de bas niveau correspondent étroitement à l'API REST sous-jacente prise en charge parS3 Glacier. Pour chaque opération REST S3 Glacier, les API de bas niveau proposent une méthodecorrespondante, un objet de demande vous permettant de fournir des informations de demande, ainsiqu'un objet de réponse vous permettant de traiter la réponse S3 Glacier. Les API de bas niveau constituentl'implémentation la plus complète des opérations S3 Glacier sous-jacentes.

L'exemple suivant montre comment utiliser les API de bas niveau pour dresser la liste des coffresaccessibles dans S3 Glacier.

// using Amazon.Glacier;// using Amazon.Glacier.Model;

var client = new AmazonGlacierClient();var request = new ListVaultsRequest();

123

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèles de programmation

var response = client.ListVaults(request);

foreach (var vault in response.VaultList){ Console.WriteLine("Vault: {0}", vault.VaultName); Console.WriteLine(" Creation date: {0}", vault.CreationDate); Console.WriteLine(" Size in bytes: {0}", vault.SizeInBytes); Console.WriteLine(" Number of archives: {0}", vault.NumberOfArchives); try { var requestNotifications = new GetVaultNotificationsRequest { VaultName = vault.VaultName }; var responseNotifications = client.GetVaultNotifications(requestNotifications);

Console.WriteLine(" Notifications:"); Console.WriteLine(" Topic: {0}", responseNotifications.VaultNotificationConfig.SNSTopic);

var events = responseNotifications.VaultNotificationConfig.Events;

if (events.Any()) { Console.WriteLine(" Events:");

foreach (var e in events) { Console.WriteLine("{0}", e); } } else { Console.WriteLine(" No events set."); } } catch (ResourceNotFoundException) { Console.WriteLine(" No notifications set."); } var requestJobs = new ListJobsRequest{ VaultName = vault.VaultName }; var responseJobs = client.ListJobs(requestJobs); var jobs = responseJobs.JobList; if (jobs.Any()) { Console.WriteLine(" Jobs:");

foreach (var job in jobs) { Console.WriteLine(" For job ID: {0}", job.JobId); Console.WriteLine("Archive ID: {0}", job.ArchiveId); Console.WriteLine("Archive size in bytes: {0}", job.ArchiveSizeInBytes.ToString()); Console.WriteLine("Completed: {0}", job.Completed); Console.WriteLine("Completion date: {0}", job.CompletionDate);

124

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Modèles de programmation

Console.WriteLine("Creation date: {0}", job.CreationDate); Console.WriteLine("Inventory size in bytes: {0}", job.InventorySizeInBytes); Console.WriteLine("Job description: {0}", job.JobDescription); Console.WriteLine("Status code: {0}", job.StatusCode.Value); Console.WriteLine("Status message: {0}", job.StatusMessage); }

} else { Console.WriteLine(" No jobs."); }

}

Pour obtenir plus d'exemples, consultez:

• Utilisation du kit AWS SDK pour .NET• Création d'un coffre• Extraction de métadonnées de coffre• Téléchargement d'un inventaire de coffre• Configuration de notifications de coffre• Suppression d'un coffre• Chargement d'une archive en une seule opération• Chargement d'archives volumineuses en plusieurs parties• Téléchargement d'une archive• Suppression d'une archive

Pour obtenir des informations de référence connexes sur les API, consultez Amazon.Glacier etAmazon.Glacier.

API de haut niveauLe kit Kit AWS SDK pour .NET propose des API de haut niveau pour une programmation avec S3 Glacier.Pour simplifier davantage le développement d'applications, ces API de haut niveau offrent un plus hautniveau d'abstraction pour certaines opérations, notamment quand il s'agit de charger ou de télécharger unearchive ou un inventaire de coffre.

Pour obtenir des exemples, consultez les rubriques suivantes dans le manuel du développeur Amazon S3Glacier :

• Utilisation du kit AWS SDK pour .NET• Création d'un coffre• Suppression d'un coffre• Chargement d'une archive dans un coffre• Chargement d'une archive• Chargement d'archives volumineuses en plusieurs parties• Téléchargement d'une archive à partir d'un coffre• Téléchargement d'une archive

125

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des utilisateurs avec AWS IAM

• Suppression d'une archive d'un coffre• Suppression d'une archive

Pour obtenir des informations de référence connexes sur les API, consultez Amazon.Glacier.Transfer dansle document AWS SDK for .NET API Reference.

Gestion des utilisateurs avec AWS Identity andAccess Management (IAM)

Le Kit AWS SDK pour .NET prend en charge IAM, un service Web qui permet aux clients AWS de gérer lesutilisateurs et les autorisations des utilisateurs dans AWS.

L'exemple de code est écrit en C#, mais il est possible d'employer le Kit AWS SDK pour .NET avecn'importe quel langage compatible. Lorsque vous installez l'AWS Toolkit for Visual Studio, un ensemble demodèles de projet C# est installé. La manière la plus simple de démarrer ce projet consiste donc à ouvrirVisual Studio, puis à choisir Fichier, Nouveau projet, AWS Sample Projects (Exemples de projets AWS),Deployment and Management (Déploiement et gestion), AWS Identity and Access Management User(Utilisateur AWS Identity and Access Management).

Pour obtenir des informations de référence d'API connexes, consultez Amazon.IdentityManagement etAmazon.IdentityManagement.Model.

Conditions préalables requises

Avant de commencer, assurez-vous d'avoir créé un compte AWS et d'avoir configuré vos informationsd'identification AWS. Pour plus d'informations, consultez Configuration du Kit AWS SDK pour .NET (p. 15),

Rubriques• Gestion des alias IAM pour votre ID de compte AWS (p. 126)• Gestion des utilisateurs IAM (p. 128)• Gestion des clés d'accès IAM (p. 131)• Utilisation des stratégies IAM (p. 135)• Utilisation des certificats de serveur IAM (p. 138)• Lister des informations de compte IAM (p. 141)• Octroi d'accès à l'aide d'un rôle IAM. (p. 142)

Gestion des alias IAM pour votre ID de compte AWSCes exemples .NET vous montrent comment :

• Créer un alias de compte pour votre ID de compte AWS• Lister un alias de compte pour votre ID de compte AWS• Supprimer un alias de compte pour votre ID de compte AWS

ScénarioSi vous voulez que l'URL de votre page de connexion contienne le nom de votre entreprise ou tout autreidentifiant convivial au lieu de votre ID de compte AWS, vous pouvez créer un alias pour ce dernier. Si

126

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des alias IAM

vous créez un alias de compte AWS, l'URL de votre page de connexion est modifiée de manière à intégrerl'alias.

Les exemples suivants montrent comment gérer vos alias de compte AWS en utilisant les méthodessuivantes de la classe AmazonIdentityManagementServiceClient :

• CreateAccountAlias• ListAccountAliases• DeleteAccountAlias

Pour plus d'informations sur les alias de compte IAM, consultez Votre ID de compte AWS et son alias dansle IAM Guide de l'utilisateur.

Création d'un alias de compteCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objetCreateAccountAliasRequest contenant le nouvel alias de compte que vous souhaitez utiliser. Appelezla méthode CreateAccountAlias de l'objet AmazonIAMClient. Si l'alias de compte est créé, affichez lenouvel alias sur la console. Si le nom existe déjà, écrivez le message d'exception sur la console.

public static void CreateAccountAlias(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new CreateAccountAliasRequest(); request.AccountAlias = "my-aws-account-alias-2017"; var response = iamClient.CreateAccountAlias(request); if (response.HttpStatusCode.ToString() == "OK") Console.WriteLine(request.AccountAlias + " created."); else Console.WriteLine("HttpStatusCode returned = " + response.HttpStatusCode.ToString()); } catch (Exception e) { Console.WriteLine(e.Message); }}

Lister des alias de compteCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objetListAccountAliasesRequest. Appelez la méthode ListAccountAliases de l'objet AmazonIAMClient. Si unalias de compte existe, affichez-le sur la console.

Si aucun alias de compte n'existe, écrivez le message d'exception sur la console.

Note

Il ne peut y avoir qu'un seul alias de compte.

public static void ListAccountAliases(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new ListAccountAliasesRequest();

127

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des utilisateurs IAM

var response = iamClient.ListAccountAliases(request); List<string> aliases = response.AccountAliases; foreach (string account in aliases) { Console.WriteLine("The account alias is: " + account); } } catch (Exception e) { Console.WriteLine(e.Message); }}

Suppression d'un alias de compteCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objetDeleteAccountAliasRequest contenant l'alias de compte que vous souhaitez supprimer. Appelez laméthode DeleteAccountAlias de l'objet AmazonIAMClient. Si l'alias de compte est supprimé, affichezles informations supprimées sur la console. Si le nom n'existe pas, écrivez le message d'exception sur laconsole.

public static void DeleteAccountAlias(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new DeleteAccountAliasRequest(); request.AccountAlias = "my-aws-account-alias-2017"; var response = iamClient.DeleteAccountAlias(request); if (response.HttpStatusCode.ToString() == "OK") Console.WriteLine(request.AccountAlias + " deleted."); else Console.WriteLine("HttpStatusCode returned = " + response.HttpStatusCode.ToString()); } catch (NoSuchEntityException e) { Console.WriteLine(e.Message); }}

Gestion des utilisateurs IAMCet exemple .NET vous montre comment récupérer une liste d'utilisateurs IAM, créer et supprimer desutilisateurs IAM et mettre à jour un nom d'utilisateur IAM.

Vous pouvez créer et gérer les utilisateurs dans IAM à l'aide des méthodes suivantes de la classeAmazonIdentityManagementServiceClient :

• CreateUser• ListUsers• UpdateUser• GetUser• DeleteUser

Pour plus d'informations sur les utilisateurs IAM, consultez Utilisateurs IAM dans le IAM Guide del'utilisateur.

128

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des utilisateurs IAM

Pour plus d'informations sur les limitations relatives au nombre d'utilisateurs IAM que vous pouvez créer,consultez la section relative aux Limitations des entités IAM dans le IAM Guide de l'utilisateur.

Création d'un utilisateur pour votre compte AWSCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet CreateUserRequestcontenant le nom d'utilisateur que vous souhaitez attribuer au nouvel utilisateur. Appelez la méthodeCreateUser de l'objet AmazonIAMClient. Si le nom d'utilisateur n'existe pas actuellement, affichez le nomet l'ARN de l'utilisateur dans la console. Si le nom existe déjà, écrivez un message à cette fin à destinationde la console.

var client = new AmazonIdentityManagementServiceClient();var request = new CreateUserRequest{ UserName = "DemoUser"};

try{ var response = client.CreateUser(request);

Console.WriteLine("User Name = '{0}', ARN = '{1}'", response.User.UserName, response.User.Arn);}catch (EntityAlreadyExistsException){ Console.WriteLine("User 'DemoUser' already exists.");}

Affichage de la liste des utilisateurs de votre compte AWSCet exemple dresse la liste des utilisateurs IAM qui présentent le préfixe de chemin spécifié. Si aucunpréfixe de chemin n'est spécifié, l'action renvoie tous les utilisateurs du compte AWS. S'il n'existe pasd'utilisateurs, l'action renvoie une liste vide.

Créez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet ListUsersRequestcontenant les paramètres requis pour répertorier vos utilisateurs. Limitez le nombre de résultatsrenvoyés en définissant le paramètre MaxItems sur 10. Appelez la méthode ListUsers de l'objetAmazonIdentityManagementServiceClient. Écrivez le nom et la date de création de chaqueutilisateur dans la console.

public static void ListUsers(){ var iamClient = new AmazonIdentityManagementServiceClient(); var requestUsers = new ListUsersRequest() { MaxItems = 10 }; var responseUsers = iamClient.ListUsers(requestUsers);

foreach (var user in responseUsers.Users) { Console.WriteLine("User " + user.UserName + " Created: " + user.CreateDate.ToShortDateString()); }

}

Mise à jour du nom d'un utilisateurCet exemple montre comment mettre à jour le nom ou le chemin de l'utilisateur IAM spécifié. Veillez àbien comprendre les implications d'une modification du chemin ou du nom d'un utilisateur IAM. Pour

129

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des utilisateurs IAM

plus d'informations, consultez Affectation d'un nouveau nom à un utilisateur IAM dans le IAM Guide del'utilisateur.

Créez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet UpdateUserRequest, enspécifiant à la fois le nom d'utilisateur actuel et le nouveau nom d'utilisateur comme paramètres. Appelez laméthode UpdateUser de l'objet AmazonIdentityManagementServiceClient.

public static void UpdateUser(){ var client = new AmazonIdentityManagementServiceClient(); var request = new UpdateUserRequest { UserName = "DemoUser", NewUserName = "NewUser" };

try { var response = client.UpdateUser(request);

} catch (EntityAlreadyExistsException) { Console.WriteLine("User 'NewUser' already exists."); }}

Obtention d'informations sur un utilisateurCet exemple montre comment récupérer des informations sur l'utilisateur IAM spécifié, notamment la datede création, le chemin, l'ID unique et l'ARN de l'utilisateur. Si vous ne spécifiez pas de nom d'utilisateur,IAM le détermine implicitement d'après l'ID de clé d'accès AWS utilisé pour signer la demande à cette API.

Créez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet GetUserRequestcontenant le nom d'utilisateur à propos duquel vous souhaitez obtenir des informations. Appelezla méthode GetUser de l'objet AmazonIdentityManagementServiceClient pour obtenir lesinformations. Si l'utilisateur n'existe pas, une exception est levée.

public static void GetUser(){ var client = new AmazonIdentityManagementServiceClient(); var request = new GetUserRequest() { UserName = "DemoUser" };

try { var response = client.GetUser(request); Console.WriteLine("Creation date: " + response.User.CreateDate.ToShortDateString()); Console.WriteLine("Password last used: " + response.User.PasswordLastUsed.ToShortDateString()); Console.WriteLine("UserId = " + response.User.UserId);

} catch (NoSuchEntityException) { Console.WriteLine("User 'DemoUser' does not exist."); }}

130

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des clés d'accès IAM

Suppression d'un utilisateurCet exemple montre comment supprimer l'utilisateur IAM spécifié. L'utilisateur ne doit appartenir à aucungroupe ni avoir des clés d'accès, des certificats de signatures ou des stratégies attachées.

Créez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet DeleteUserRequestcontenant le paramètre nécessaire, c'est-à-dire le nom d'utilisateur à supprimer. Appelez la méthodeDeleteUser de l'objet AmazonIdentityManagementServiceClient pour le supprimer. Si l'utilisateurn'existe pas, une exception est levée.

public static void DeleteUser(){ var client = new AmazonIdentityManagementServiceClient(); var request = new DeleteUserRequest() { UserName = "DemoUser" };

try { var response = client.DeleteUser(request);

} catch (NoSuchEntityException) { Console.WriteLine("User DemoUser' does not exist."); }}

Gestion des clés d'accès IAMCes exemples .NET vous montrent comment :

• Créer une clé d'accès pour un utilisateur• Obtenir la date à laquelle une clé d'accès a été utilisée pour la dernière fois• Mettre à jour le statut d'une clé d'accès• Supprimer une clé d'accès

ScénarioPour effectuer des appels par programmation vers AWS à partir du kit Kit AWS SDK pour .NET, lesutilisateurs ont besoin de leurs propres clés d'accès. Pour répondre à cette attente, vous pouvez créer,modifier, afficher ou faire tourner les clés d'accès (ID de clés d'accès et clés d'accès secrètes) pour lesutilisateurs IAM. Lorsque vous créez une clé d'accès, son état est actif par défaut, ce qui signifie quel'utilisateur peut utiliser la clé d'accès pour des appels API.

Le code C# utilise le Kit AWS SDK pour .NET pour gérer les clés d'accès IAM à l'aide des méthodessuivantes de la classe AmazonIdentityManagementServiceClient :

• CreateAccessKey• ListAccessKeys• GetAccessKeyLastUsed• UpdateAccessKey• DeleteAccessKey

131

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des clés d'accès IAM

Pour plus d'informations sur les clés d'accès IAM, consultez Gestion des clés d'accès pour les utilisateursIAM dans le IAM Guide de l'utilisateur.

Création de clés d'accès pour un utilisateurAppelez la méthode CreateAccessKey pour créer une clé d'accès nommée S3UserReadOnlyAccesspour les exemples de clés d'accès IAM. La méthode <code>CreateAccessKey</code> créed'abord un utilisateur nommé <code>S3UserReadOnlyAccess</code> avec droits d'accèsen lecture seule en appelant la méthode <code>CreateUser</code>. Elle crée ensuite l'objetAmazonIdentityManagementServiceClient et un objet CreateAccessKeyRequest contenant le paramètreUserName requis pour créer de nouvelles clés d'accès. La méthode CreateAccessKey de l'objetAmazonIdentityManagementServiceClient est ensuite appelée.

public static void CreateAccessKey(){ try { CreateUser(); var iamClient = new AmazonIdentityManagementServiceClient(); // Create an access key for the IAM user that can be used by the SDK var accessKey = iamClient.CreateAccessKey(new CreateAccessKeyRequest { // Use the user created in the CreateUser example UserName = "S3UserReadOnlyAccess" }).AccessKey;

} catch (LimitExceededException e) { Console.WriteLine(e.Message); }}

public static User CreateUser(){ var iamClient = new AmazonIdentityManagementServiceClient(); try { // Create the IAM user var readOnlyUser = iamClient.CreateUser(new CreateUserRequest { UserName = "S3UserReadOnlyAccess" }).User;

// Assign the read-only policy to the new user iamClient.PutUserPolicy(new PutUserPolicyRequest { UserName = readOnlyUser.UserName, PolicyName = "S3ReadOnlyAccess", PolicyDocument = S3_READONLY_POLICY }); return readOnlyUser; } catch (EntityAlreadyExistsException e) { Console.WriteLine(e.Message); var request = new GetUserRequest() { UserName = "S3UserReadOnlyAccess" };

return iamClient.GetUser(request).User;

132

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des clés d'accès IAM

}}

Constitution de la liste des clés d'accès d'un utilisateurCréez un objet AmazonIdentityManagementServiceClient et un objet ListAccessKeysRequest contenant lesparamètres requis pour récupérer les clés d'accès de l'utilisateur. Cela inclut le nom de l'utilisateur IAM et,si vous le souhaitez, le nombre maximum de paires de clés d'accès que vous voulez faire figurer dans laliste. Appelez la méthode ListAccessKeys de l'objet AmazonIdentityManagementServiceClient.

public static void ListAccessKeys(){

var iamClient = new AmazonIdentityManagementServiceClient(); var requestAccessKeys = new ListAccessKeysRequest { // Use the user created in the CreateAccessKey example UserName = "S3UserReadOnlyAccess", MaxItems = 10 }; var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys); Console.WriteLine(" Access keys:");

foreach (var accessKey in responseAccessKeys.AccessKeyMetadata) { Console.WriteLine(" {0}", accessKey.AccessKeyId); }}

Obtention de la date à laquelle une clé d'accès a été utilisée pourla dernière foisCréez un objet AmazonIdentityManagementServiceClient et un objet ListAccessKeysRequest contenantle paramètre UserName requis pour répertorier les clés d'accès. Appelez la méthode ListAccessKeysde l'objet AmazonIdentityManagementServiceClient. Passez en revue les clés d'accèsrenvoyées, en affichant l'élément AccessKeyId de chaque clé et en l'utilisant pour créer un objetGetAccessKeyLastUsedRequest. Appelez la méthode GetAccessKeyLastUsed et affichez l'heure à laquellela clé a été utilisée pour la dernière fois sur la console.

public static void GetAccessKeysLastUsed(){

var iamClient = new AmazonIdentityManagementServiceClient(); var requestAccessKeys = new ListAccessKeysRequest { // Use the user we created in the CreateUser example UserName = "S3UserReadOnlyAccess" }; var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys); Console.WriteLine(" Access keys:");

foreach (var accessKey in responseAccessKeys.AccessKeyMetadata) { Console.WriteLine(" {0}", accessKey.AccessKeyId); GetAccessKeyLastUsedRequest request = new GetAccessKeyLastUsedRequest() { AccessKeyId = accessKey.AccessKeyId }; var response = iamClient.GetAccessKeyLastUsed(request); Console.WriteLine("Key last used " + response.AccessKeyLastUsed.LastUsedDate.ToLongDateString());

133

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des clés d'accès IAM

}}

Mise à jour du statut d'une clé d'accèsCréez un objet AmazonIdentityManagementServiceClient et un objet ListAccessKeysRequestcontenant le nom d'utilisateur pour lequel répertorier les clés. Dans cet exemple, le nomd'utilisateur est celui créé pour les autres exemples. Appelez le ClésAccèsListe méthode duAmazonIdentityManagementServiceClient. Le Réponse des clés d’accès à la liste qui est renvoyécontient une liste des clés d’accès pour cet utilisateur. Utilisez la première clé d'accès de la liste. Créezun objet UpdateAccessKeyRequest en indiquant les paramètres UserName, AccessKeyId et Status.Appelez la méthode UpdateAccessKey de l'objet AmazonIdentityManagementServiceClient.

public static void UpdateKeyStatus(){ // This example changes the status of the key specified by its index in the list of access keys // Optionally, you could change the keynumber parameter to be an AccessKey ID var iamClient = new AmazonIdentityManagementServiceClient(); var requestAccessKeys = new ListAccessKeysRequest { UserName = "S3UserReadOnlyAccess" }; var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys); UpdateAccessKeyRequest updateRequest = new UpdateAccessKeyRequest { UserName = "S3UserReadOnlyAccess", AccessKeyId = responseAccessKeys.AccessKeyMetadata[0].AccessKeyId, Status = StatusType.Active }; iamClient.UpdateAccessKey(updateRequest); Console.WriteLine(" Access key " + updateRequest.AccessKeyId + " updated");}

Suppression de clés d'accèsCréez un objet AmazonIdentityManagementServiceClient et un objet ListAccessKeysRequestcontenant le nom de l'utilisateur en tant que paramètre. Appelez le ClésAccèsListe méthode duAmazonIdentityManagementServiceClient. Le Réponse des clés d’accès à la liste qui est renvoyécontient une liste des clés d’accès pour cet utilisateur. Supprimez chaque clé d'accès de la liste enappelant la méthode DeleteAccessKey de l'objet AmazonIdentityManagementServiceClient.

public static void DeleteAccessKeys(){// Delete all the access keys created for the examples var iamClient = new AmazonIdentityManagementServiceClient(); var requestAccessKeys = new ListAccessKeysRequest { // Use the user created in the CreateUser example UserName = "S3UserReadOnlyAccess" }; var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys); Console.WriteLine(" Access keys:");

foreach (var accessKey in responseAccessKeys.AccessKeyMetadata) { Console.WriteLine(" {0}", accessKey.AccessKeyId); iamClient.DeleteAccessKey(new DeleteAccessKeyRequest { UserName = "S3UserReadOnlyAccess",

134

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des stratégies IAM

AccessKeyId = accessKey.AccessKeyId }); Console.WriteLine("Access Key " + accessKey.AccessKeyId + " deleted"); }

}

Utilisation des stratégies IAMLes exemples suivants montrent comment procéder pour :

• Créer et supprimer des stratégies IAM• Attacher des stratégies IAM à des rôles et en détacher

ScénarioVous accordez des autorisations à un utilisateur en créant une stratégie, qui est un document qui répertorieles actions qu'un utilisateur peut effectuer et les ressources que ces actions peuvent concerner. Les actionsou ressources qui ne sont pas explicitement autorisées sont refusées par défaut. Vous pouvez créer desstratégies et les attacher à des utilisateurs, à des groupes d'utilisateurs, à des rôles pris en charge par desutilisateurs et à des ressources.

Utilisez le Kit AWS SDK pour .NET pour créer et supprimer des stratégies et pour attacher et détacher desstratégies de rôle à l'aide des méthodes suivantes de la classe AmazonIdentityManagementServiceClient :

• CreatePolicy• GetPolicy• AttachRolePolicy• DetachRolePolicy

Pour plus d’informations sur IAM utilisateurs, voir Présentation de la gestion des accès : Autorisations etstratégies dans le IAM Guide de l'utilisateur.

Création d'une stratégie IAMCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet CreatePolicyRequestcontenant les paramètres nécessaires pour créer une nouvelle stratégie, comprenant le nom que voussouhaitez attribuer à celle-ci et un document de stratégie. Vous créez le document de stratégie enappelant la méthode GenerateRolePolicyDocument fournie. Au retour de l'appel de la méthodeCreatePolicy, CreatePolicyResponse contient l'ARN de stratégie, qui est affiché sur la console. Veuilleznoter cette information dont vous aurez besoin dans les exemples suivants.

public static void CreatePolicyExample(){ var client = new AmazonIdentityManagementServiceClient(); // GenerateRolePolicyDocument is a custom method string policyDoc = GenerateRolePolicyDocument();

var request = new CreatePolicyRequest { PolicyName = "DemoEC2Permissions", PolicyDocument = policyDoc };

try

135

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des stratégies IAM

{ var createPolicyResponse = client.CreatePolicy(request); Console.WriteLine("Make a note, Policy named " + createPolicyResponse.Policy.PolicyName + " has Arn: : " + createPolicyResponse.Policy.Arn); } catch (EntityAlreadyExistsException) { Console.WriteLine ("Policy 'DemoEC2Permissions' already exits."); }

}

public static string GenerateRolePolicyDocument(){ // using Amazon.Auth.AccessControlPolicy;

// Create a policy that looks like this: /* { "Version" : "2012-10-17", "Id" : "DemoEC2Permissions", "Statement" : [ { "Sid" : "DemoEC2PermissionsStatement", "Effect" : "Allow", "Action" : [ "s3:Get*", "s3:List*" ], "Resource" : "*" } ] } */

var actionGet = new ActionIdentifier("s3:Get*"); var actionList = new ActionIdentifier("s3:List*"); var actions = new List<ActionIdentifier>();

actions.Add(actionGet); actions.Add(actionList);

var resource = new Resource("*"); var resources = new List<Resource>();

resources.Add(resource);

var statement = new Amazon.Auth.AccessControlPolicy.Statement(Amazon.Auth.AccessControlPolicy.Statement.StatementEffect.Allow) { Actions = actions, Id = "DemoEC2PermissionsStatement", Resources = resources }; var statements = new List<Amazon.Auth.AccessControlPolicy.Statement>();

statements.Add(statement);

var policy = new Policy { Id = "DemoEC2Permissions", Version = "2012-10-17", Statements = statements };

136

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des stratégies IAM

return policy.ToJson();}

Obtention d'une stratégie IAMCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet GetPolicyRequestcontenant le paramètre nécessaire pour obtenir la stratégie, l'ARN de stratégie, qui a été renvoyé par laméthode CreatePolicy dans l'exemple précédent.

Appelez la méthode GetPolicy.

public static void GetPolicy(){ var client = new AmazonIdentityManagementServiceClient(); var request = new GetPolicyRequest { PolicyArn = "arn:aws:iam::123456789:policy/DemoEC2Permissions" };

try { var response = client.GetPolicy(request); Console.WriteLine("Policy " + response.Policy.PolicyName + "successfully retrieved");

} catch (NoSuchEntityException) { Console.WriteLine ("Policy 'DemoEC2Permissions' does not exist."); }

}

Attacher une stratégie de rôle géréeCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objet AttachRolePolicyRequestcontenant les paramètres nécessaires pour attacher la stratégie au rôle, le nom de rôle et la stratégieJason renvoyée par la méthode GenerateRolePolicyDocument. Assurez-vous d'utiliser un rôle valideparmi les rôles associés à votre compte AWS.

public static void AttachRolePolicy(){ var client = new AmazonIdentityManagementServiceClient(); string policy = GenerateRolePolicyDocument(); CreateRoleRequest roleRequest = new CreateRoleRequest() { RoleName = "tester", AssumeRolePolicyDocument = policy };

var request = new AttachRolePolicyRequest() { PolicyArn = "arn:aws:iam::123456789:policy/DemoEC2Permissions", RoleName = "tester" }; try { var response = client.AttachRolePolicy(request);

137

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des certificats de serveur IAM

Console.WriteLine("Policy DemoEC2Permissions attached to Role TestUser"); } catch (NoSuchEntityException) { Console.WriteLine ("Policy 'DemoEC2Permissions' does not exist"); } catch (InvalidInputException) { Console.WriteLine ("One of the parameters is incorrect"); }}

Détachement d'une stratégie de rôle géréeCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objetDetachRolePolicyRequest contenant les paramètres nécessaires pour attacher la stratégie au rôle, le nomde rôle et la stratégie Jason renvoyée par la méthode GenerateRolePolicyDocument. Assurez-vousd'utilisez le rôle utilisé pour attacher la stratégie dans l'exemple précédent.

public static void DetachRolePolicy(){ var client = new AmazonIdentityManagementServiceClient(); string policy = GenerateRolePolicyDocument(); CreateRoleRequest roleRequest = new CreateRoleRequest() { RoleName = "tester", AssumeRolePolicyDocument = policy };

var request = new DetachRolePolicyRequest() { PolicyArn = "arn:aws:iam::123456789:policy/DemoEC2Permissions", RoleName = "tester" }; try { var response = client.DetachRolePolicy(request); Console.WriteLine("Policy DemoEC2Permissions detached from Role 'tester'"); } catch (NoSuchEntityException e) { Console.WriteLine (e.Message); } catch (InvalidInputException i) { Console.WriteLine (i.Message); }}

Utilisation des certificats de serveur IAMCes exemples .NET vous montrent comment :

• Lister les certificats de serveur• Obtenir des certificats de serveur• Mettre à jour des certificats de serveur

138

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des certificats de serveur IAM

• Supprimer des certificats de serveur

ScénarioCes exemples présentent les tâches de base de gestion des certificats de serveur pour desconnexions HTTPS. Pour autoriser les connexions HTTPS sur votre site web ou une application sur AWS,vous avez besoin d'un certificat de serveur SSL/TLS. Pour utiliser un certificat que vous avez obtenuauprès d'un fournisseur externe avec votre site Web ou votre application sur AWS, vous devez charger lecertificat vers IAM ou l'importer dans AWS Certificate Manager.

Ces exemples utilisent le Kit AWS SDK pour .NET pour envoyer et recevoir des messages à l'aide desméthodes suivantes de la classe AmazonIdentityManagementServiceClient :

• ListServerCertificates• GetServerCertificate• UpdateServerCertificate• DeleteServerCertificate

Pour plus d'informations sur les certificats de serveur, consultez Utilisation des certificats de serveur dansle IAM Guide de l'utilisateur.

Liste des certificats de serveurCréez un objet AmazonIdentityManagementServiceClient. Créez ensuite un objetListServerCertificatesRequest.

Aucun paramètre n'est obligatoire. Appelez la méthode ListServerCertificates de l'objetAmazonIdentityManagementServiceClient.

public static void ListCertificates(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new ListServerCertificatesRequest(); var response = iamClient.ListServerCertificates(request); foreach (KeyValuePair<string, string> kvp in response.ResponseMetadata.Metadata) { Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value); } } catch(Exception e) { Console.WriteLine(e.Message); }}

Obtention d'un certificat de serveurCréez un objet AmazonIdentityManagementServiceClient. Ensuite, créez un Obtenir lademande de certificat de serveur objet, spécification de ServerCertificateName. Appelez leObtenirCertificatServeur méthode du AmazonIdentityManagementServiceClient objet.

public static void GetCertificate()

139

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des certificats de serveur IAM

{ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new GetServerCertificateRequest(); request.ServerCertificateName = "CERTIFICATE_NAME"; var response = iamClient.GetServerCertificate(request); Console.WriteLine("CertificateName = " + response.ServerCertificate.ServerCertificateMetadata.ServerCertificateName); Console.WriteLine("Certificate Arn = " + response.ServerCertificate.ServerCertificateMetadata.Arn); } catch (Exception e) { Console.WriteLine(e.Message); }}

Mise à jour d'un certificat de serveurCréez un objet AmazonIdentityManagementServiceClient. Ensuite, créez un Demande decertificat de serveur de mise à jour objet, spécification de ServerCertificateName et leNewServerCertificateName. Appelez le Certificat de mise à jour du serveur méthode duAmazonIdentityManagementServiceClient objet.

public static void UpdateCertificate(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new UpdateServerCertificateRequest(); request.ServerCertificateName = "CERTIFICATE_NAME"; request.NewServerCertificateName = "NEW_Certificate_NAME"; var response = iamClient.UpdateServerCertificate(request); if (response.HttpStatusCode.ToString() == "OK") Console.WriteLine("Update succesful"); else Console.WriteLine("HTTpStatusCode returned = " + response.HttpStatusCode.ToString()); } catch (Exception e) { Console.WriteLine(e.Message); }

}

Suppression d'un certificat de serveurCréez un objet AmazonIdentityManagementServiceClient. Ensuite, créez un Demande de certificat deserveur de suppression objet, spécification de ServerCertificateName. Appelez le Certificat desuppression de serveur méthode du AmazonIdentityManagementServiceClient objet.

public static void DeleteCertificate(){ try { var iamClient = new AmazonIdentityManagementServiceClient(); var request = new DeleteServerCertificateRequest(); request.ServerCertificateName = "CERTIFICATE_NAME";

140

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Lister des informations de compte IAM

var response = iamClient.DeleteServerCertificate(request); if (response.HttpStatusCode.ToString() == "OK") Console.WriteLine(request.ServerCertificateName + " deleted"); else Console.WriteLine("HTTpStatusCode returned = " + response.HttpStatusCode.ToString()); } catch (Exception e) { Console.WriteLine(e.Message); }}

Lister des informations de compte IAMLe Kit AWS SDK pour .NET prend en charge IAM, un service Web qui permet aux clients AWS de gérer lesutilisateurs et les autorisations des utilisateurs dans AWS.

L'exemple suivant montre comment répertorier les comptes d'utilisateurs accessibles dans IAM. Pourchaque compte utilisateur, ses groupes associés, ses stratégies et ses ID de clé d'accès sont égalementlistés.

public static void ListUsersAndGroups(){ var iamClient = new AmazonIdentityManagementServiceClient(); var requestUsers = new ListUsersRequest(); var responseUsers = iamClient.ListUsers(requestUsers);

foreach (var user in responseUsers.Users) { Console.WriteLine("For user {0}:", user.UserName); Console.WriteLine(" In groups:");

var requestGroups = new ListGroupsForUserRequest { UserName = user.UserName }; var responseGroups = iamClient.ListGroupsForUser(requestGroups);

foreach (var group in responseGroups.Groups) { Console.WriteLine(" {0}", group.GroupName); }

Console.WriteLine(" Policies:");

var requestPolicies = new ListUserPoliciesRequest { UserName = user.UserName }; var responsePolicies = iamClient.ListUserPolicies(requestPolicies);

foreach (var policy in responsePolicies.PolicyNames) { Console.WriteLine(" {0}", policy); }

var requestAccessKeys = new ListAccessKeysRequest { UserName = user.UserName }; var responseAccessKeys = iamClient.ListAccessKeys(requestAccessKeys);

141

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Octroi d'accès à l'aide d'un rôle IAM.

Console.WriteLine(" Access keys:");

foreach (var accessKey in responseAccessKeys.AccessKeyMetadata) { Console.WriteLine(" {0}", accessKey.AccessKeyId); } }}

Pour obtenir des informations de référence d'API connexes, consultez Amazon.IdentityManagement etAmazon.IdentityManagement.Model.

Octroi d'accès à l'aide d'un rôle IAM.Cet exemple .NET explique comment :

• créer un exemple de programme qui récupère un objet dans Amazon S3 ;• Créer un rôle IAM• lancer une instance Amazon EC2 et spécifier le rôle IAM ;• exécuter l'exemple sur l'instance Amazon EC2.

ScénarioToutes les demandes à AWS doivent être signées de manière chiffrée avec des informations d'identificationémises par AWS. Par conséquent, vous avez besoin d'une stratégie pour gérer les informationsd'identification de vos applications qui s'exécutent sur les instances Amazon EC2. Vous devez distribuer,stocker et permuter ces informations d'identification en toute sécurité, mais aussi les garder accessiblespour les logiciels.

Les rôles IAM vous permettent de gérer efficacement les informations d'identification AWS pour les logicielsexécutés sur les instances EC2. Vous créez un rôle IAM et le configurez avec les permissions exigéespar le logiciel. Pour plus d'informations sur les avantages de l'utilisation des rôles IAM, consultez RôlesIAM pour Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Windows et Rôles(délégation et fédération) dans le IAM Guide de l'utilisateur.

Pour utiliser les permissions, le logiciel construit un objet client pour les service AWS. Le constructeurrecherche la chaîne du fournisseur d'informations d'identification pour les informations d'identification.Pour .NET, la chaîne du fournisseur d'informations d'identification comporte les éléments suivants :

• Le fichier App.config• les métadonnées d'instance associées au rôle IAM pour l'instance EC2.

Si le client ne trouve pas les informations d'identification dans App.config, il récupère dans lesmétadonnées d'instance des informations d'identification temporaires qui disposent des mêmesautorisations que celles associées au rôle IAM. Les informations d'identification sont stockées par leconstructeur de la part du logiciel d'application et sont utilisées pour passer des appels à AWS à partir decet objet client. Même si les informations d'identification sont temporaires et finissent par expirer, le clientSDK les actualise régulièrement afin qu'elles continuent à permettre l'accès. Cette actualisation périodiqueest complètement transparente pour le logiciel d'application.

Les exemples suivants montrent un exemple de programme qui récupère un objet d'Amazon S3 aumoyen des informations d'identification AWS que vous configurez. Vous créez un rôle IAM pour fournirles informations d'identification AWS. Vous lancez enfin une instance avec un rôle IAM qui fournit lesinformations d'identification AWS à l'exemple de programme exécuté sur l'instance.

142

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Octroi d'accès à l'aide d'un rôle IAM.

Création d'un exemple de programme qui récupère un objet dansAmazon S3L'exemple de code suivant exige un fichier texte dans un compartiment Amazon S3 auquel vous avezaccès, ainsi que des informations d'identification AWS qui vous permettent d'accéder au compartimentAmazon S3.

Pour plus d'informations sur la création d'un compartiment Amazon S3 et sur le chargement d'un objet,consultez le guide de démarrage d'Amazon S3. Pour plus d'informations sur les informations d'identificationAWS, consultez Configuration des informations d'identification AWS (p. 26).

using System;using System.IO;using System.Threading;using System.Threading.Tasks;

using Amazon;using Amazon.S3;using Amazon.S3.Model;

namespace S3ShowTextItem{ class S3Sample { static async Task<GetObjectResponse> MyGetObjectAsync(string region, string bucket, string item) { RegionEndpoint reg = RegionEndpoint.GetBySystemName(region); AmazonS3Client s3Client = new AmazonS3Client(reg);

Console.WriteLine("Retrieving (GET) an object");

GetObjectResponse response = await s3Client.GetObjectAsync(bucket, item, new CancellationToken());

return response; }

public static void Main(string[] args) { if (args.Length < 4) { Console.WriteLine("You must supply a region, bucket name, text file name, and output file name"); return; }

try { Task<GetObjectResponse> response = MyGetObjectAsync(args[0], args[1], args[2]);

Stream responseStream = response.Result.ResponseStream; StreamReader reader = new StreamReader(responseStream);

string responseBody = reader.ReadToEnd();

using(FileStream s = new FileStream(args[3], FileMode.Create)) using(StreamWriter writer = new StreamWriter(s)) { writer.WriteLine(responseBody); } }

143

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Octroi d'accès à l'aide d'un rôle IAM.

catch (AmazonS3Exception s3Exception) { Console.WriteLine(s3Exception.Message, s3Exception.InnerException); }

Console.WriteLine("Press enter to continue"); Console.ReadLine(); } }}

Pour tester l'exemple de code

1. Ouvrez Visual Studio et créez un projet Console App (.NET Framework) à l'aide de .NETFramework 4.5 ou version ultérieure.

2. Ajoutez le package NuGet AWSSDK.S3 à votre projet.3. Remplacez le code du fichier Program.cs par l'exemple de code.4. Compilez et exécutez l'exemple de programme. En cas de réussite du programme, il affiche le résultat

suivant et crée un fichier sur votre disque local avec le texte récupéré dans le fichier texte d'AmazonS3.

Retrieving (GET) an object

En cas d'échec, assurez-vous d'utiliser des informations d'identification qui vous permettent d'accéderau compartiment.

5. (Facultatif) Transférez l'exemple de programme vers une instance de Windows en exécution surlaquelle vous n'avez pas configuré d'informations d'identification. Exécutez le programme et vérifiez sil'échec provient de l'impossibilité de localiser les informations d'identification.

Création d'un rôle IAMCréez un rôle IAM qui dispose des autorisations nécessaires pour accéder à Amazon S3.

Pour créer le rôle IAM

1. Ouvrez la console IAM.2. Dans le panneau de navigation, choisissez Rôles, puis Créer un rôle.3. Saisissez le nom du rôle, puis choisissez Étape suivante. Conservez bien ce nom, car il vous sera utile

lorsque vous lancerez votre instance EC2.4. Sous Rôles de service AWS, choisissez Amazon EC2. Sous Sélectionner un modèle de stratégie,

choisissez Amazon S3 Read Only Access (Accès en lecture seule à Amazon S3). Vérifiez la stratégie,puis choisissez Étape suivante.

5. Passez en revue les informations du rôle, puis choisissez Créer un rôle.

Lancer une instance EC2 et spécifier le rôle IAMVous pouvez utiliser la console Amazon EC2 ou le Kit AWS SDK pour .NET pour lancer une instance EC2avec un rôle IAM.

• Utilisation de la console Suivez les instructions dans Lancement d’une instance Windows dans leAmazon EC2 Guide de l'utilisateur pour les instances Windows. Lorsque vous atteignez la pageExaminer le lancement de l'instance, choisissez Modifier les détails de l'instance. Dans Rôle IAM,spécifiez le rôle IAM que vous avez créé précédemment. Exécutez la procédure comme indiqué. Vous

144

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Octroi d'accès à l'aide d'un rôle IAM.

devrez créer ou utiliser un groupe de sécurité existant et une paire de clés pour vous connecter àl'instance.

• Utilisation du kit Kit AWS SDK pour .NET. Voir Lancement d’une instance Amazon EC2 (p. 104).

Un utilisateur IAM ne peut pas lancer d'instance avec un rôle IAM sans les autorisations accordées par lastratégie suivante.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "iam:PassRole", "iam:ListInstanceProfiles", "ec2:*" ], "Resource": "*" }]}

Exécution de l'exemple de programme sur l'instance EC2Pour transférer l'exemple de programme vers votre instance EC2, connectez-vous à l'instance au moyende l'AWS Management Console, comme indiqué dans la procédure suivante.

Note

Vous pouvez également vous connecter à l'aide de Toolkit for Visual Studio (consultez Connexionà une instance Amazon EC2 dans AWS Toolkit for Visual Studio), puis copier les fichiers de votredisque local dans l'instance. La session de bureau à distance est automatiquement configurée afinque vos disques locaux soient disponibles pour l'instance.

Pour exécuter l'exemple de programme sur l'instance EC2

1. Ouvrez la console Amazon EC2.2. Obtenez le mot de passe de votre instance EC2 :

a. Dans le panneau de navigation, choisissez Instances. Sélectionnez l'instance, puis choisissezConnexion.

b. Dans la boîte de dialogue Connectez-vous à votre instance, sélectionnez Obtenir le mot de passe.(Cela prend quelques minutes après le lancement de l'instance pour que le mot de passe soitdisponible.)

c. Choisissez Parcourir et accédez au fichier de clé privée que vous avez créé lorsque vous avezlancé l'instance. Sélectionnez le fichier, puis choisissez Ouvrir pour copier le contenu du fichierdans la zone de contenu.

d. Choisissez Déchiffrer le mot de passe. La console affiche le mot de passe administrateur pardéfaut pour l'instance dans la boîte de dialogue Connectez-vous à votre instance, en remplaçantle lien vers Obtenir le mot de passe affiché précédemment par le mot de passe.

e. Enregistrez le mot de passe administrateur par défaut ou copiez-le dans le Presse-papiers. Vousen aurez besoin pour vous connecter à l'instance.

3. Connectez-vous à votre instance  EC2.

a. Sélectionnez Télécharger le fichier Bureau à distance. À l'invite de votre navigateur, enregistrezle fichier .rdp. Lorsque vous avez terminé, vous pouvez choisir Fermer pour quitter la boîte dedialogue Connectez-vous à votre instance.

b. Accédez à votre répertoire de téléchargements, cliquez avec le bouton droit sur le fichier .rdp,puis choisissez Modifier. Sur l'onglet Local Resources (Ressources locales), sous Local devices

145

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des clés KMS pour le chiffrement S3

and resources (Ressources et périphériques locaux), choisissez More (Plus). Choisissez Drives(Disques) pour que votre instance puisse accéder à vos disques locaux. Choisissez ensuite OK.

c. Choisissez Connect (Connexion) pour vous connecter à votre instance. Vous pouvez obtenir unavertissement indiquant que l’éditeur de la connexion à distance est inconnu.

d. Connectez-vous à l'instance lorsque vous y êtes invité, en utilisant le compte Administrateurpar défaut et le mot de passe administrateur par défaut que vous avez enregistré ou copiéprécédemment.

Les opérations de copier et coller du contenu peuvent endommager les données. Si vousrencontrez une erreur de type « Échec du mot de passe » à la connexion, essayez de saisir le motde passe manuellement. Pour plus d'informations, consultez Connexion à votre instance Windowsà l'aide de RDP et Dépannage des problèmes liés aux instances Windows dans le Amazon EC2Guide de l'utilisateur pour les instances Windows.

4. Copiez le programme et les assemblies AWS (AWSSDK.Core.dll et AWSSDK.S3.dll) de votredisque local dans l'instance.

5. Exécutez le programme et vérifiez si tout se déroule normalement avec les informations d'identificationfournies par le rôle IAM.

Retrieving (GET) an object

Utilisation de AWS Key Management Service cléspour Amazon S3 du chiffrement dans le Kit AWSSDK pour .NET

Le ClientChiffrementAmazonS2 met en œuvre la même interface que la norme AmazonS3Client. Celasignifie qu’il est facile de passer au AmazonS3EncryptionClientV2 classe. En fait, le code de votreapplication ignore que le chiffrement et le déchiffrement se produisent automatiquement dans le client.

Vous pouvez utiliser une clé AWS KMS comme clé principale lorsque vous utilisez la classeAmazonS3EncryptionClientV2 pour le chiffrement côté client. Il vous suffit de créer unobjet EncryptionMaterials qui contient un ID de clé KMS. Transmettez ensuite l'objetEncryptionMaterials au constructeur de la classe AmazonS3EncryptionClientV2.

L’un des avantages de l’utilisation d’un AWS KMS comme clé principale est que vous n’avez pas besoinde stocker et de gérer vos propres clés principales ; ceci est effectué par AWS. Un deuxième avantageest que le AmazonS3EncryptionClientV2 de la classe de Kit AWS SDK pour .NET est interopérableavec le AmazonS3EncryptionClientV2 de la classe de AWS SDK for Java. En d'autres termes, vouspouvez chiffrer des données avec le AWS SDK for Java et les déchiffrer avec le Kit AWS SDK pour .NET,et inversement.

Note

Le AmazonS3EncryptionClientV2 de la classe de Kit AWS SDK pour .NET prend en chargeles clés principales KMS uniquement lorsqu’elles sont exécutées en mode métadonnées. Lemode de fichier d’instruction du AmazonS3EncryptionClientV2 de la classe de Kit AWS SDKpour .NET est incompatible avec le AmazonS3EncryptionClientV2 de la classe de AWS SDKfor Java.Warning

Le AmazonS3EncryptionClient de la classe de Kit AWS SDK pour .NET est obsolète et estmoins sécurisé que le AmazonS3EncryptionClientV2 classe. Pour migrer le code existant qu’utilise AmazonS3EncryptionClient, voir Migration du client de chiffrement S3 (p. 183).

146

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des clés KMS pour le chiffrement S3

Pour plus d’informations sur le chiffrement côté client avec l’ AmazonS3EncryptionClientV2 etcomment fonctionne le chiffrement d’enveloppe, voir Chiffrement des données côté client avec le kit SDKAWS pour.NET et Amazon S3.

L’exemple suivant montre comment utiliser AWS KMS avec le AmazonS3EncryptionClientV2 classe.

Créez un nouveau projet de console. Référencez les versions appropriées de ce qui suit Packages NuGet:pour le protocole AWSSDK.S3, Service de gestion de clé AWSSDK, et Cryptage Amazon.Extensions.S3..Lorsque vous exécutez l'application, incluez le code Region, le nom d'un compartiment Amazon S3 existantet le nom du nouvel objet Amazon S3.

L’application crée un objet chiffré dans le compartiment donné, puis déchiffre et affiche le contenu del’objet.

using System;using System.IO;using System.Threading.Tasks;using System.Collections.Generic;

using Amazon;using Amazon.KeyManagementService;using Amazon.KeyManagementService.Model;using Amazon.Extensions.S3.Encryption;using Amazon.Extensions.S3.Encryption.Primitives;using Amazon.S3.Model;

namespace KmsS3Encryption{ class S3Sample { public static async Task Main(string[] args) { if (args.Length != 3) { Console.WriteLine("\nUsage: KmsS3Encryption REGION BUCKET ITEM"); Console.WriteLine(" REGION: The AWS Region (for example, \"us-west-1\")."); Console.WriteLine(" BUCKET: The name of an existing S3 bucket."); Console.WriteLine(" ITEM: The name you want to use for the item."); return; } string regionName = args[0]; string bucketName = args[1]; string itemName = args[2];

// Create a customer master key (CMK) and store the result var createKeyResponse = await MyCreateKeyAsync(regionName); var kmsEncryptionContext = new Dictionary<string, string>(); var kmsEncryptionMaterials = new EncryptionMaterialsV2( createKeyResponse.KeyMetadata.KeyId, KmsType.KmsContext, kmsEncryptionContext);

// Create the object in the bucket, then display the content of the object var putObjectResponse = await CreateAndRetrieveObjectAsync(kmsEncryptionMaterials, bucketName, itemName); Stream stream = putObjectResponse.ResponseStream; StreamReader reader = new StreamReader(stream); Console.WriteLine(reader.ReadToEnd()); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); }

// // Method to create a customer master key static async Task<CreateKeyResponse> MyCreateKeyAsync(string regionName)

147

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des ressources du système de noms

de domaine (DNS) à l'aide d'Amazon Route 53

{ var kmsClient = new AmazonKeyManagementServiceClient( RegionEndpoint.GetBySystemName(regionName)); return await kmsClient.CreateKeyAsync(new CreateKeyRequest()); }

// // Method to create and encrypt an object in an S3 bucket static async Task<GetObjectResponse> CreateAndRetrieveObjectAsync( EncryptionMaterialsV2 materials, string bucketName, string keyName) { // CryptoStorageMode.ObjectMetadata is required for KMS EncryptionMaterials var config = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy) { StorageMode = CryptoStorageMode.ObjectMetadata }; var s3Client = new AmazonS3EncryptionClientV2(config, materials);

// Create, encrypt, and put the object await s3Client.PutObjectAsync(new PutObjectRequest { BucketName = bucketName, Key = keyName, ContentBody = "Object content for KmsS3Encryption example." });

// Get, decrypt, and return the object return await s3Client.GetObjectAsync(new GetObjectRequest { BucketName = bucketName, Key = keyName }); } }}

Gestion des ressources du système de noms dedomaine (DNS) à l'aide d'Amazon Route 53

Le Kit AWS SDK pour .NET prend en charge Amazon Route 53, service Web de système de noms dedomaine (DNS) qui fournit un routage sécurisé et fiable à votre infrastructure pour l'utilisation des produitsAmazon Web Services (AWS) tels qu'Amazon Elastic Compute Cloud (Amazon EC2), Elastic LoadBalancing ou Amazon Simple Storage Service (Amazon S3). Vous pouvez également utiliser Route 53 pouracheminer des utilisateurs vers votre infrastructure hors d'AWS. Cette rubrique décrit comment utiliser le KitAWS SDK pour .NET pour créer une zone hébergée Route 53 : r53-dg <AboutHZWorkingWith> et ajouterun nouveau jeu d'enregistrements de ressources à cette zone.

Note

Cette rubrique part du principe que vous êtes déjà familiarisé avec l'utilisation de Route 53 et quele Kit AWS SDK pour .NET est installé. Pour plus d'informations sur Route 53, consultez le Manueldu développeur Amazon Route 53. Pour plus d'informations sur l'installation du Kit AWS SDKpour .NET, consultez Configuration du Kit AWS SDK pour .NET (p. 15).

La procédure de base est la suivante.

Pour créer une zone hébergée et mettre à jour ses jeux d'enregistrements

1. Créer une zone hébergée

148

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des ressources du système de noms

de domaine (DNS) à l'aide d'Amazon Route 53

2. Créez un lot de modifications contenant un ou plusieurs jeux d'enregistrements et des instructions surl'action à effectuer pour chaque jeu.

3. Envoyez une demande de modification à la zone hébergée contenant le lot de modifications.4. Contrôlez la modification pour vous assurer qu'elle aboutit.

L'exemple utilise une application de console simple qui montre comment utiliser le Kit AWS SDK pour .NETpour implémenter cette procédure pour un jeu d'enregistrements de base.

Pour exécuter cet exemple

1. Dans le menu Fichier de Visual Studio, choisissez Nouveau, puis Projet.2. Choisissez le modèle AWS Empty Project (Projet AWS vide) et spécifiez le nom et l'emplacement du

projet.3. Spécifiez le profil d'informations d'identification par défaut de l'application et la région AWS, de sorte que

ces informations soient ajoutées au fichier App.config du projet. Cet exemple suppose que la régionest définie sur USA Est (Virginie du Nord) et que le profil par défaut est utilisé. Pour plus d'informationssur les profils, consultez Configuration des informations d'identification AWS (p. 26).

4. Ouvrez program.cs et remplacez les déclarations using et le code dans Main par le codecorrespondant à partir de l'exemple suivant. Si vous utilisez votre profil d'informations d'identificationet votre région par défaut, vous pouvez compiler et exécuter l'application en l'état. Sinon, vous devezfournir un profil et une région appropriés, comme mentionné dans les remarques qui suivent l'exemple.

using System;using System.Collections.Generic;using System.Threading;

using Amazon;using Amazon.Route53;using Amazon.Route53.Model;

namespace Route53_RecordSet{ //Create a hosted zone and add a basic record set to it class recordset { public static void Main(string[] args) { string domainName = "www.example.org";

//[1] Create an Amazon Route 53 client object var route53Client = new AmazonRoute53Client();

//[2] Create a hosted zone var zoneRequest = new CreateHostedZoneRequest() { Name = domainName, CallerReference = "my_change_request" };

var zoneResponse = route53Client.CreateHostedZone(zoneRequest);

//[3] Create a resource record set change batch var recordSet = new ResourceRecordSet() { Name = domainName, TTL = 60, Type = RRType.A, ResourceRecords = new List<ResourceRecord> {

149

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des ressources du système de noms

de domaine (DNS) à l'aide d'Amazon Route 53

new ResourceRecord { Value = "192.0.2.235" } } };

var change1 = new Change() { ResourceRecordSet = recordSet, Action = ChangeAction.CREATE };

var changeBatch = new ChangeBatch() { Changes = new List<Change> { change1 } };

//[4] Update the zone's resource record sets var recordsetRequest = new ChangeResourceRecordSetsRequest() { HostedZoneId = zoneResponse.HostedZone.Id, ChangeBatch = changeBatch };

var recordsetResponse = route53Client.ChangeResourceRecordSets(recordsetRequest);

//[5] Monitor the change status var changeRequest = new GetChangeRequest() { Id = recordsetResponse.ChangeInfo.Id };

while (ChangeStatus.PENDING == route53Client.GetChange(changeRequest).ChangeInfo.Status) { Console.WriteLine("Change is pending."); Thread.Sleep(15000); }

Console.WriteLine("Change is complete."); Console.ReadKey(); } }}

Les numéros qui figurent dans les sections suivantes se rapportent aux commentaires de l'exempleprécédent.

[1] Créer un objet client

L'objet doit contenir les informations suivantes :Une région AWS

Lorsque vous appelez une méthode client, la demande HTTP sous-jacente est envoyée à ce pointde terminaison.

Un profil d'informations d'identification

Le profil doit accorder des autorisations pour les actions que vous avez l'intention d'utiliser (lesactions Route 53 dans le cas présent). Les tentatives d'appel d'actions ne disposant pas desautorisations échoueront. Pour plus d'informations, consultez Configuration des informationsd'identification AWS (p. 26).

La classe AmazonRoute53Client prend en charge un jeu de méthodes publiques utilisées pour appelerdes actions Amazon Route 53. Vous créez l'objet client en instanciant une nouvelle instance de laclasse AmazonRoute53Client. Il existe plusieurs constructeurs.

150

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des ressources du système de noms

de domaine (DNS) à l'aide d'Amazon Route 53

[2] Créer une zone hébergée

Une zone hébergée sert le même objectif qu'un fichier de zone DNS traditionnel. Elle représente unecollection de jeux d'enregistrements de ressources gérés ensemble sous un même nom de domaine.

Pour créer une zone hébergée1. Créez un objet CreateHostedZoneRequest et spécifiez les paramètres de demande suivants. Il

existe également deux paramètres facultatifs qui ne sont pas utilisés par cet exemple.Name

(Obligatoire) Le nom de domaine que vous voulez enregistrer, www.example.com pour cetexemple. Ce nom de domaine est destiné uniquement à des exemples. Il ne peut pas êtreenregistré auprès d'un bureau d'enregistrement de noms de domaine, mais vous pouvez l'utiliserpour créer une zone hébergée à des fins d'apprentissage.

CallerReference

(Obligatoire) Une chaîne arbitraire définie par l'utilisateur qui sert d'ID de demande et ne peutpas être utilisée pour relancer des demandes ayant échoué. Si vous exécutez cette applicationplusieurs fois, vous devez modifier la valeur CallerReference.

1. Transmettez l'objet CreateHostedZoneRequest à la méthode CreateHostedZone de l'objet client.La méthode renvoie un objet CreateHostedZoneResponse qui contient des informations sur lademande, notamment la propriété HostedZone.Id qui identifie la zone.

[3] Créer un lot de modifications du jeu d'enregistrements de ressources

Une zone hébergée peut avoir plusieurs jeux d'enregistrements de ressources. Chaque jeu spécifiela manière dont un sous-ensemble du trafic du domaine, par exemple les demandes d'e-mail, doitêtre acheminé. Vous pouvez mettre à jour un jeu d'enregistrements de ressources d'une zone avecune seule demande. La première étape consiste à rassembler toutes les mises à jour dans un objetChangeBatch. Cet exemple spécifie une mise à jour unique, ajoutant un jeu d'enregistrements deressources de base à la zone, mais un objet ChangeBatch peut contenir des mises à jour pourplusieurs jeux d'enregistrements de ressources.

Pour créer un objet ChangeBatch1. Créez un objet ResourceRecordSet pour chaque jeu d'enregistrements de ressources que vous

souhaitez mettre à jour. Le groupe de propriétés que vous spécifiez dépend du type de jeud'enregistrements de ressources. Pour une description complète des propriétés utilisées par lesdifférents jeux d'enregistrements de ressources, consultez Valeurs à spécifier lors de la création oude la modification d'enregistrements Amazon Route 53. L'exemple d'objet ResourceRecordSetreprésente un jeu d'enregistrements de ressources de base, et spécifie les propriétés requisessuivantes.Name

Le nom de domaine ou de sous-domaine, www.example.com pour cet exemple.TTL

La durée, en secondes, pendant laquelle vous voulez que les résolveurs DNS récursifs mettenten cache les informations relatives à ce jeu d'enregistrements de ressources, 60 secondes pourcet exemple.

Type

Le type d'enregistrement DNS, A dans cet exemple. Pour accéder à une liste complète,consultez Types d'enregistrements de ressources DNS pris en charge.

ResourceRecords

Une liste d'un ou plusieurs objets ResourceRecord, chacun d'eux contenant unevaleur d'enregistrement DNS qui dépend du type d'enregistrement DNS. Pour un type

151

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Gestion des ressources du système de noms

de domaine (DNS) à l'aide d'Amazon Route 53

d'enregistrement A, la valeur de l'enregistrement est une adresse IPv4, ce qui correspond, danscet exemple, à un exemple d'adresse standard, 192.0.2.235.

2. Créez un objet Change pour chaque jeu d'enregistrements de ressources, puis définissez lespropriétés suivantes.ResourceRecordSet

L'objet ResourceRecordSet que vous avez créé à l'étape précédente.Action

Action à entreprendre pour cet ensemble d’enregistrements de ressource : CREATE, DELETEouUPSERT. Pour plus d’informations sur ces actions, consultez Éléments. Cet exemple crée unnouveau jeu d'enregistrements de ressources dans la zone hébergée, Action est donc définisur CREATE.

3. Créez un objet ChangeBatch et définissez sa propriété Changes sur une liste d'objets Changecréés lors de l'étape précédente.

[4] Mettre à jour les jeux d'enregistrements de ressources de la zone

Pour mettre à jour les jeux d'enregistrements de ressources, transmettez l'objet ChangeBatch à lazone hébergée comme suit.

Pour mettre à jour des jeux d'enregistrements de ressources d'une zone hébergée1. Créez un objet ChangeResourceRecordSetsRequest avec les paramètres de propriété suivants.

HostedZoneId

L'ID de zone hébergée ; dans l'exemple, cette information correspond à l'ID renvoyé dans l'objetCreateHostedZoneResponse. Pour obtenir l'ID d'une zone hébergée existante, appelezListHostedZones.

ChangeBatch

Un objet ChangeBatch qui contient les mises à jour.2. Transmettez l'objet ChangeResourceRecordSetsRequest à la méthode

ChangeResourceRecordSets de l'objet client. Elle renvoie un objetChangeResourceRecordSetsResponse qui contient un ID de demande que vous pouvez utiliserpour surveiller la progression de la demande.

[5] Surveiller l'état de la mise à jour

La mise à jour d'un jeu d'enregistrements de ressources nécessite environ une minute pour sepropager à travers le système. Vous pouvez surveiller la progression de la mise à jour et vérifier quecelle-ci aboutit de la manière suivante.

Pour surveiller l'état de la mise à jour1. Créez un objet GetChangeRequest et définissez sa propriété Id sur l'ID de demande renvoyé par

ChangeResourceRecordSets.2. Utilisez une boucle d’attente pour appeler périodiquement le ObtenirModification méthode de l’objet

client. GetChange retours PENDING pendant que la mise à jour est en cours et INSYNC une fois lamise à jour terminée. Vous pouvez utiliser le même objet GetChangeRequest pour tous les appelsde méthode.

152

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation du stockage Internet

Amazon Simple Storage Service

Utilisation du stockage Internet Amazon SimpleStorage Service

Le Kit AWS SDK pour .NET prend en charge Amazon Simple Storage Service (Amazon S3), qui est unesolution de stockage pour Internet. Il est conçu pour faciliter l'informatique à l'échelle d'Internet pour lesdéveloppeurs. Pour plus d'informations, consultez Amazon S3.

Les liens suivants fournissent des exemples de programmation d'Amazon S3 avec le Kit AWS SDKpour .NET :

• Utilisation du kit AWS SDK pour .NET pour la programmation d'Amazon S3• Envoi de demandes à l'aide du compte AWS ou des informations d'identification de l'utilisateur IAM• Demandes grâce aux informations d'identification temporaires de l'utilisateur IAM• Demandes grâce aux informations d'identification de sécurité temporaires de l'utilisateur fédéré• Gestion des listes ACL• Création d'un compartiment• Chargement d'un objet• Chargement partitionné avec l'API de haut niveau• Chargement partitionné avec l'API de bas niveau• Liste des objets• Etablissement de la liste des clés• Obtention d'un objet• Copie d'un objet• Copie d'un objet grâce à l'API de chargement partitionné• Supprimer un objet• Suppression de plusieurs objets• Restauration d'un objet• Configuration des notifications d'un compartiment• Gestion du cycle de vie d'un objet• Génération d'une URL d'objet présignée• Gestion de sites web• Activation du partage des ressources de plusieurs origines (CORS)• Spécification du chiffrement côté serveur• Spécification du chiffrement côté serveur avec clés de chiffrement fournies par le client

Envoi de notifications depuis le cloud avec AmazonSimple Notification Service

Le kit Kit AWS SDK pour .NET prend en charge Amazon Simple Notification Service (Amazon SNS),service Web qui permet aux applications, aux utilisateurs finaux et aux périphériques d'envoyerinstantanément des notifications depuis le cloud. Pour plus d'informations, consultez Amazon SNS.

Liste de vos rubriques Amazon SNSL'exemple suivant montre comment répertorier vos rubriques Amazon SNS, les abonnementsà chaque rubrique et les attributs de chaque rubrique. Cet exemple utilise le client

153

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'un message à une rubrique Amazon SNS

AmazonSimpleNotificationServiceClient, par défaut qui charge les informations d'identification à partir devotre configuration par défaut.

// using Amazon.SimpleNotificationService;// using Amazon.SimpleNotificationService.Model;

var client = new AmazonSimpleNotificationServiceClient();var request = new ListTopicsRequest();var response = new ListTopicsResponse();

do{ response = client.ListTopics(request);

foreach (var topic in response.Topics) { Console.WriteLine("Topic: {0}", topic.TopicArn);

var subs = client.ListSubscriptionsByTopic( new ListSubscriptionsByTopicRequest { TopicArn = topic.TopicArn });

var ss = subs.Subscriptions;

if (ss.Any()) { Console.WriteLine(" Subscriptions:");

foreach (var sub in ss) { Console.WriteLine(" {0}", sub.SubscriptionArn); } }

var attrs = client.GetTopicAttributes( new GetTopicAttributesRequest { TopicArn = topic.TopicArn }).Attributes;

if (attrs.Any()) { Console.WriteLine(" Attributes:");

foreach (var attr in attrs) { Console.WriteLine(" {0} = {1}", attr.Key, attr.Value); } }

Console.WriteLine(); }

request.NextToken = response.NextToken;

} while (!string.IsNullOrEmpty(response.NextToken));

Envoi d'un message à une rubrique Amazon SNSL'exemple suivant montre comment envoyer un message à une rubrique Amazon SNS. L'exemple utilise unargument, l'ARN de la rubrique Amazon SNS.

154

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'un SMS à un numéro de téléphone

using System;using System.Linq;using System.Threading.Tasks;

using Amazon;using Amazon.SimpleNotificationService;using Amazon.SimpleNotificationService.Model;

namespace SnsSendMessage{ class Program { static void Main(string[] args) { /* Topic ARNs must be in the correct format: * arn:aws:sns:REGION:ACCOUNT_ID:NAME * * where: * REGION is the region in which the topic is created, such as us-west-2 * ACCOUNT_ID is your (typically) 12-character account ID * NAME is the name of the topic */ string topicArn = args[0]; string message = "Hello at " + DateTime.Now.ToShortTimeString();

var client = new AmazonSimpleNotificationServiceClient(region: Amazon.RegionEndpoint.USWest2);

var request = new PublishRequest { Message = message, TopicArn = topicArn };

try { var response = client.Publish(request);

Console.WriteLine("Message sent to topic:"); Console.WriteLine(message); } catch (Exception ex) { Console.WriteLine("Caught exception publishing request:"); Console.WriteLine(ex.Message); } } }}

Consultez l'exemple complet, notamment des informations sur la façon de générer et d'exécuter l'exempleà partir de la ligne de commande, sur GitHub.

Envoi d'un SMS à un numéro de téléphoneL'exemple suivant montre comment envoyer un SMS à un numéro de téléphone. L'exemple utilise unargument, le numéro de téléphone, qui doit être dans l'un des deux formats décrits dans les commentaires.

using System;using System.Linq;using System.Threading.Tasks;using Amazon;

155

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Messagerie avec Amazon SQS

using Amazon.SimpleNotificationService;using Amazon.SimpleNotificationService.Model;

namespace SnsPublish{ class Program { static void Main(string[] args) { // US phone numbers must be in the correct format: // +1 (nnn) nnn-nnnn OR +1nnnnnnnnnn string number = args[0]; string message = "Hello at " + DateTime.Now.ToShortTimeString();

var client = new AmazonSimpleNotificationServiceClient(region: Amazon.RegionEndpoint.USWest2); var request = new PublishRequest { Message = message, PhoneNumber = number };

try { var response = client.Publish(request);

Console.WriteLine("Message sent to " + number + ":"); Console.WriteLine(message); } catch (Exception ex) { Console.WriteLine("Caught exception publishing request:"); Console.WriteLine(ex.Message); } } }}

Consultez l'exemple complet, notamment des informations sur la façon de générer et d'exécuter l'exempleà partir de la ligne de commande, sur GitHub.

Messagerie avec Amazon SQSLe Kit AWS SDK pour .NET prend en charge Amazon SQS, service de mise en file d'attente de messagesqui gère les messages ou les flux de travail entre les composants d'un système. Pour plus d'informations,consultez Amazon SQS.

Les exemples suivants montrent comment utiliser le Kit AWS SDK pour .NET pour créer et utiliser des filesd'attente Amazon SQS.

L'exemple de code est écrit en C#, mais il est possible d'employer le Kit AWS SDK pour .NET avecn'importe quel langage compatible. Le Kit AWS SDK pour .NET installe un jeu de modèles de projet C#.

Tâches prérequises

Avant de commencer, assurez-vous d'avoir créé un compte AWS et d'avoir configuré vos informationsd'identification AWS. Pour plus d'informations, consultez Configuration du Kit AWS SDK pour .NET (p. 15),

Pour obtenir des informations de référence d'API connexes, consultez Amazon.SQS, Amazon.SQS.Modelet Amazon.SQS.Util dans le document AWS SDK for .NET API Reference.

156

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Création d'un client Amazon SQS

Rubriques• Création d'un client Amazon SQS (p. 157)• Création d'une file d'attente Amazon SQS (p. 158)• Construire Amazon SQS URL de file d’attente (p. 158)• Envoi d’un Amazon SQS Message (p. 159)• Envoi d’un Amazon SQS Lot de messages (p. 159)• Réception d’un message à partir d’un Amazon SQS File d’attente (p. 160)• Suppression d’un message d’un Amazon SQS File d’attente (p. 161)• Activation de l'attente active de longue durée dans Amazon SQS (p. 162)• Utilisation de Amazon SQS Files d’attente (p. 163)• Utilisation de Amazon SQS Files d’attente de lettres mortes (p. 165)

Création d'un client Amazon SQSVous devez disposer d'un client Amazon SQS pour créer et utiliser une file d'attente Amazon SQS.Avant de configurer votre client, vous devez créer un fichier App.Config pour spécifier vos informationsd'identification AWS.

Spécifiez vos informations d'identification en référençant le profil approprié dans la section appSettingsdu fichier.

L’exemple suivant spécifie un profil nommé my_profile. Pour plus d’informations sur les informationsd’identification et les profils, consultez Configuration de votre application AWS SDK pour.NET (p. 22).

<?xml version="1.0"?><configuration> <configSections> <section name="aws" type="Amazon.AWSSection, AWSSDK.Core"/> </configSections> <aws profileName="my_profile"/> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/> </startup></configuration>

Une fois que vous avez créé ce fichier, vous êtes prêt à créer et à initialiser votre client Amazon SQS.

Pour créer et initialiser un client Amazon SQS

1. Créez et initialisez une instance AmazonSQSConfig, puis définissez la propriété ServiceURL avec leprotocole et le point de terminaison de service, comme suit.

var sqsConfig = new AmazonSQSConfig();

sqsConfig.ServiceURL = "http://sqs.us-west-2.amazonaws.com";

2. Utilisez l'instance AmazonSQSConfig pour créer et initialiser une instance AmazonSQSClient, commesuit.

var sqsClient = new AmazonSQSClient(sqsConfig);

Vous pouvez maintenant utiliser le client pour créer une file d'attente Amazon SQS. Pour plusd'informations sur la création d'une file d'attente, consultez Création d'une file d'attente AmazonSQS (p. 158).

157

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Création d'une file d'attente Amazon SQS

Création d'une file d'attente Amazon SQSLa création d'une file d'attente Amazon SQS est une tâche administrative que vous pouvez effectuer àl'aide de SQS Management Console. Cependant, vous pouvez utiliser le Kit AWS SDK pour .NET pourcréer une file d'attente Amazon SQS par programmation.

Pour créer une file d'attente Amazon SQS

1. Créez et initialisez une instance CreateQueueRequest. Indiquez le nom de votre file d'attente etspécifiez un délai de visibilité pour vos messages de file d'attente, comme suit.

var createQueueRequest = new CreateQueueRequest();

createQueueRequest.QueueName = "MySQSQueue";var attrs = new Dictionary<string, string>();attrs.Add(QueueAttributeName.VisibilityTimeout, "10");createQueueRequest.Attributes = attrs;

Le nom de votre file d'attente doit être composé uniquement de caractères alphanumériques, de tiretset de traits de soulignement.

Les messages restent dans la file d'attente jusqu'à ce que le délai de visibilité spécifié soit dépassé.Le délai de visibilité par défaut d'une file d'attente est de 30 secondes. Pour plus d'informations sur lesdélais de visibilité, consultez Délai de visibilité. Pour plus d'informations sur les différents attributs defile d'attente que vous pouvez définir, consultez SetQueueAttributes.

2. Après avoir créé la demande, transmettez-la en tant que paramètre à la méthode CreateQueue. Laméthode renvoie un objet CreateQueueResponse, comme suit.

var createQueueResponse = sqsClient.CreateQueue(createQueueRequest);

Pour plus d'informations sur le fonctionnement des files d'attente dans Amazon SQS, consultezFonctionnement des files d'attente SQS.

Pour plus d'informations sur l'URL de votre file d'attente, consultez Construction d'URL de file d'attenteAmazon SQS (p. 158).

Construire Amazon SQS URL de file d’attenteUne URL de file d'attente permet d'envoyer, de recevoir et d'effacer les messages de file d'attente. Vouspouvez obtenir l'URL de file d'attente à l'aide de la méthode GetQueueUrl.

Note

Pour .NET Core, PCL et Unity, cette opération est uniquement disponible dans le cadre duformulaire asynchrone en utilisant GetQueueUrlAsync.

var client = new AmazonSQSClient();var request = new GetQueueUrlRequest{ QueueName = "MyTestQueue", QueueOwnerAWSAccountId = "80398EXAMPLE"};var response = client.GetQueueUrl(request);Console.WriteLine("Queue URL: " + response.QueueUrl);

Pour trouver votre numéro de compte AWS, accédez à Informations d'identification de sécurité. Votrenuméro de compte figure sous Numéro de compte, dans la partie supérieure droite de la page.

158

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d’un Amazon SQS Message

Pour plus d'informations sur l'envoi d'un message vers une file d'attente, consultez Envoi d'un messageAmazon SQS (p. 159).

Pour plus d'informations sur la réception de messages d'une file d'attente, consultez Réception d'unmessage en provenance d'une file d'attente Amazon SQS (p. 160).

Pour plus d'informations sur la suppression de messages d'une file d'attente, consultez Suppression d'unmessage d'une file d'attente Amazon SQS (p. 161).

Envoi d’un Amazon SQS MessageVous pouvez utiliser le Kit AWS SDK pour .NET pour envoyer un message à une file d'attente AmazonSQS.

Important

En raison de la nature distribuée de la file d'attente, Amazon SQS ne peut garantir que vousrecevrez les messages dans l'ordre exact où ils ont été envoyés. Si vous devez conserver l'ordredes messages, utilisez une file d'attente Amazon SQS FIFO. Pour plus d'informations sur les filesd'attente FIFO, consultez Files d'attente Amazon SQS FIFO (premier entré, premier sorti).

Pour envoyer un message à une file d'attente Amazon SQS

1. Créez et initialisez une instance SendMessageRequest. Spécifiez le nom de la file d'attente et lemessage que vous souhaitez envoyer, comme suit.

sendMessageRequest.QueueUrl = myQueueURL; sendMessageRequest.MessageBody = "{YOUR_QUEUE_MESSAGE}";

Pour plus d'informations sur l'URL de votre file d'attente, consultez Construction d'URL de file d'attenteAmazon SQS (p. 158).

Chaque message de file d'attente doit se composer uniquement de caractères Unicode et sa taillene peut pas dépasser 64 Ko. Pour plus d'informations sur les messages de file d'attente, consultezSendMessage dans le document Amazon Simple Queue Service API Reference.

2. Après avoir créé la demande, transmettez-la en tant que paramètre à la méthode SendMessage. Laméthode renvoie un objet SendMessageResponse, comme suit.

var sendMessageResponse = sqsClient.SendMessage(sendMessageRequest);

Le message envoyé reste dans la file d'attente jusqu'à ce que le délai de visibilité spécifié soit dépasséou qu'il soit supprimé de la file d'attente. Pour plus d'informations sur les délais de visibilité, consultezDélai de visibilité.

Pour plus d'informations sur la suppression de messages de votre file d'attente, consultez Suppression d'unmessage d'une file d'attente Amazon SQS (p. 161).

Pour plus d'informations sur la réception de messages en provenance de votre file d'attente, consultezRéception d'un message en provenance d'une file d'attente Amazon SQS (p. 160).

Envoi d’un Amazon SQS Lot de messagesVous pouvez utiliser le Kit AWS SDK pour .NET pour envoyer des messages par lot à une file d'attenteAmazon SQS. La méthode SendMessageBatch peut remettre jusqu'à 10 messages à la file d'attentespécifiée. Il s'agit d'une version d'envoi par lot de SendMessage.

159

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Réception d’un message à partird’un Amazon SQS File d’attente

Pour une file d'attente FIFO, les différents messages appartenant à un même lot sont mis en file d'attentedans l'ordre de leur envoi.

Pour plus d'informations sur l'envoi de messages par lot, consultez SendMessageBatch dans le documentAmazon Simple Queue Service API Reference.

Pour envoyer des messages par lot à une file d'attente Amazon SQS

1. Créez une instance AmazonSQSClient et initialisez un objet SendMessageBatchRequest. Spécifiez lenom de la file d'attente et le message que vous souhaitez envoyer, comme suit.

AmazonSQSClient client = new AmazonSQSClient();var sendMessageBatchRequest = new SendMessageBatchRequest{ Entries = new List<SendMessageBatchRequestEntry> { new SendMessageBatchRequestEntry("message1", "FirstMessageContent"), new SendMessageBatchRequestEntry("message2", "SecondMessageContent"), new SendMessageBatchRequestEntry("message3", "ThirdMessageContent") }, QueueUrl = "SQS_QUEUE_URL"};

Pour plus d'informations sur l'URL de votre file d'attente, consultez Construction d'URL de file d'attenteAmazon SQS (p. 158).

Chaque message de file d'attente doit se composer uniquement de caractères Unicode et sa taillene peut pas dépasser 64 Ko. Pour plus d'informations sur les messages de file d'attente, consultezSendMessage dans le document Amazon Simple Queue Service API Reference.

2. Après avoir créé la demande, transmettez-la en tant que paramètre à la méthode SendMessageBatch.La méthode renvoie un objet SendMessageBatchResponse, qui contient l'ID unique de chaquemessage, ainsi que le contenu de chaque message envoyé avec succès. Elle renvoie également l'IDdu message, le contenu du message, ainsi qu'un indicateur d'erreur de l'expéditeur en cas d'échecd'envoi du message.

SendMessageBatchResponse response = client.SendMessageBatch(sendMessageBatchRequest);Console.WriteLine("Messages successfully sent:");foreach (var success in response.Successful){ Console.WriteLine(" Message id : {0}", success.MessageId); Console.WriteLine(" Message content MD5 : {0}", success.MD5OfMessageBody);}

Console.WriteLine("Messages failed to send:");foreach (var failed in response.Failed){ Console.WriteLine(" Message id : {0}", failed.Id); Console.WriteLine(" Message content : {0}", failed.Message); Console.WriteLine(" Sender's fault? : {0}", failed.SenderFault);}

Réception d’un message à partir d’un Amazon SQSFile d’attenteVous pouvez utiliser le Kit AWS SDK pour .NET pour recevoir des messages en provenance d'une filed'attente Amazon SQS.

160

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Suppression d’un message d’un Amazon SQS File d’attente

Pour recevoir un message en provenance d'une file d'attente Amazon SQS

1. Créez et initialisez une instance ReceiveMessageRequest. Spécifiez l'URL de la file d'attente, commesuit.

var receiveMessageRequest = new ReceiveMessageRequest();

receiveMessageRequest.QueueUrl = myQueueURL;

Pour plus d'informations sur l'URL de votre file d'attente, consultez URL de votre file d'attente AmazonSQS (p. 158).

2. Transmettez l'objet de demande en tant que paramètre à la méthode ReceiveMessage, comme suit :

var receiveMessageResponse = sqsClient.ReceiveMessage(receiveMessageRequest);

La méthode renvoie une instance ReceiveMessageResponse qui contient la liste des messages de lafile d'attente.

3. La propriété ReceiveMessageResponse.ReceiveMessageResult contient un objetReceiveMessageResponse qui contient une liste des messages reçus. Itérez cette liste et appelez laméthode ProcessMessage pour traiter chaque message.

foreach (var message in result.Messages){ ProcessMessage(message); // Go to a method to process messages.}

La méthode ProcessMessage peut utiliser la propriété ReceiptHandle pour obtenir un descripteurde réception pour le message. Vous pouvez utiliser ce descripteur de réception pour modifier le délaide visibilité du message ou pour supprimer le message de la file d'attente. Pour plus d'informations surla modification du délai de visibilité d'un message, consultez ChangeMessageVisibility.

Pour plus d'informations sur l'envoi d'un message à votre file d'attente, consultez Envoi d'un messageAmazon SQS (p. 159).

Pour plus d'informations sur la suppression d'un message de la file d'attente, consultez Suppression d'unmessage d'une file d'attente Amazon SQS (p. 161).

Suppression d’un message d’un Amazon SQS Filed’attenteVous pouvez utiliser le Kit AWS SDK pour .NET pour supprimer des messages d'une file d'attente AmazonSQS.

Pour supprimer un message d'une file d'attente Amazon SQS

1. Créez et initialisez un objet DeleteMessageRequest. Spécifiez la file d'attente Amazon SQS danslaquelle vous souhaitez supprimer un message, ainsi que le descripteur de réception du message àsupprimer, comme suit.

var deleteMessageRequest = new DeleteMessageRequest();

deleteMessageRequest.QueueUrl = queueUrl;deleteMessageRequest.ReceiptHandle = receiptHandle;

161

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Activation de l'attente active de

longue durée dans Amazon SQS

2. Transmettez l'objet de la demande en tant que paramètre à la méthode DeleteMessage. La méthoderenvoie un objet DeleteMessageResponse, comme suit.

var response = sqsClient.DeleteMessage(deleteMessageRequest);

L'appel de DeleteMessage supprime sans condition le message de la file d'attente, indépendammentdu paramètre de délai de visibilité. Pour plus d'informations sur les délais de visibilité, consultez Délaide visibilité.

Pour plus d'informations sur l'envoi d'un message vers une file d'attente, consultez Envoi d'un messageAmazon SQS (p. 159).

Pour plus d'informations sur la réception de messages d'une file d'attente, consultez Réception d'unmessage en provenance d'une file d'attente Amazon SQS (p. 160).

Activation de l'attente active de longue durée dansAmazon SQSL'attente active de longue durée réduit le nombre de réponses vides en permettant à Amazon SQSd'attendre pendant un temps spécifié qu'un message soit disponible dans la file d'attente avant d'envoyerune réponse. L'attente active de longue durée élimine également les fausses réponses vides eninterrogeant tous les serveurs, et non un échantillon. Pour activer l'attente active de longue durée,vous devez spécifier un temps d'attente différent de zéro pour les messages reçus. Pour ce faire, vousdevez définir le paramètre ReceiveMessageWaitTimeSeconds d'une file d'attente ou le paramètreWaitTimeSeconds sur un message lors de sa réception. Cet exemple .NET explique comment activerl'attente active de longue durée dans Amazon SQS pour une file d'attente nouvelle ou existante, ou lors dela réception d'un message.

Ces exemples utilisent les méthodes suivantes de la classe AmazonSQSClient pour activer l'attente activede longue durée :

• CreateQueue• SetQueueAttributes• ReceiveMessage

Pour plus d'informations sur l'attente active de longue durée, consultez Attente active de longue duréed'Amazon SQS dans le Amazon Simple Queue Service Manuel du développeur.

Activation de l'attente active de longue durée lors de la créationd'une file d'attenteCréez un objet de service AmazonSQSClient. Créez un objet CreateQueueRequest contenant lespropriétés requises pour créer une file d'attente, en spécifiant une valeur différente de zéro pour lapropriété ReceiveMessageWaitTimeSeconds.

Appelez la méthode CreateQueue. L'attente active de longue durée est activée pour la file d'attente.

AmazonSQSClient client = new AmazonSQSClient();var request = new CreateQueueRequest{ QueueName = "SQS_QUEUE_NAME", Attributes = new Dictionary<string, string> { { "ReceiveMessageWaitTimeSeconds", "20"}

162

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation de Amazon SQS Files d’attente

}};var response = client.CreateQueue(request);Console.WriteLine("Created a queue with URL : {0}", response.QueueUrl);

Activation de l'attente active de longue durée sur une file d'attenteexistanteCréez un objet de service AmazonSQSClient. Créez un objet SetQueueAttributesRequest contenant lespropriétés requises pour définir les attributs de la file d'attente, en spécifiant une valeur différente de zéropour la propriété ReceiveMessageWaitTimeSeconds et l'URL de la file d'attente. Appelez la méthodeSetQueueAttributes. L'attente active de longue durée est activée pour la file d'attente.

AmazonSQSClient client = new AmazonSQSClient();

var request = new SetQueueAttributesRequest{ Attributes = new Dictionary<string, string> { { "ReceiveMessageWaitTimeSeconds", "20"} }, QueueUrl = "SQS_QUEUE_URL"};

var response = client.SetQueueAttributes(request);

Recevoir un messageCréez un objet de service AmazonSQSClient. Créez un objet ReceiveMessageRequest contenantles propriétés requises pour recevoir un message, en spécifiant une valeur différente de zéro pour leparamètre WaitTimeSeconds et l'URL de la file d'attente. Appelez la méthode ReceiveMessage.

public void OnMessageReceipt(){ AmazonSQSClient client = new AmazonSQSClient();

var request = new ReceiveMessageRequest { AttributeNames = { "SentTimestamp" }, MaxNumberOfMessages = 1, MessageAttributeNames = { "All" }, QueueUrl = "SQS_QUEUE_URL", WaitTimeSeconds = 20 };

var response = client.ReceiveMessage(request);}

Utilisation de Amazon SQS Files d’attenteDans Amazon SQS, le type de file d'attente par défaut est dénommé standard. Une file d'attente standardvous permet d'avoir un nombre pratiquement illimité de transactions par seconde. Les files d'attentestandard prennent en charge la remise au moins une fois des messages. Cependant, plusieurs copies d'unmême message peuvent parfois être remises dans le désordre. Les files d'attente standard classent aumieux les messages, ce qui signifie qu'ils sont généralement remis dans l'ordre de leur envoi.

Vous pouvez utiliser des files d'attente standard dans de nombreux scénarios, dans la mesure où votreapplication peut traiter les messages qui arrivent plusieurs fois et dans le désordre.

163

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation de Amazon SQS Files d’attente

Cet exemple de code montre comment utiliser les files d'attente à l'aide de ces méthodes de la classeAmazonSQSClient :

• ListQueues Obtient une liste de vos files d’attente de messages• GetQueueUrl Obtient l’URL d’une file d’attente particulière• DeleteQueue Supprime une file d’attente

Pour plus d'informations sur les messages Amazon SQS, consultez Fonctionnement des files d'attenteAmazon SQS dans le Amazon Simple Queue Service Manuel du développeur.

Affichage de la liste de vos files d'attenteCréez un objet ListQueuesRequest contenant les propriétés nécessaires pour répertorier vos filesd'attentes, qui est par défaut un objet vide. Appelez la méthode ListQueues avec ListQueuesRequestcomme paramètre pour récupérer la liste des files d'attente. L'objet ListQueuesResponse renvoyé parl'appel contient les URL de toutes les files d'attente.

AmazonSQSClient client = new AmazonSQSClient();

ListQueuesResponse response = client.ListQueues(new ListQueuesRequest());foreach (var queueUrl in response.QueueUrls){ Console.WriteLine(queueUrl);}

Obtention de l'URL d'une file d'attenteCréez un objet GetQueueUrlRequest contenant les propriétés nécessaires pour identifier votre filed'attente, ce qui doit inclure le nom de la file d'attente dont vous souhaitez obtenir l'URL. Appelez laméthode GetQueueUrl en utilisant l'objet GetQueueUrlRequest comme paramètre. L'appel renvoie unobjet GetQueueUrlResponse contenant l'URL de la file d'attente spécifiée.

AmazonSQSClient client = new AmazonSQSClient();

var request = new GetQueueUrlRequest{ QueueName = "SQS_QUEUE_NAME"};

GetQueueUrlResponse response = client.GetQueueUrl(request);Console.WriteLine("The SQS queue's URL is {1}", response.QueueUrl);

Suppression d'une file d'attenteCréez un objet DeleteQueueRequest contenant l'URL de la file d'attente à supprimer. Appelez la méthodeDeleteQueue avec l'objet DeleteQueueRequest comme paramètre.

AmazonSQSClient client = new AmazonSQSClient();

var request = new DeleteQueueRequest{ QueueUrl = "SQS_QUEUE_URL"};

client.DeleteQueue(request);

164

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation de Amazon SQS Files d’attente de lettres mortes

Utilisation de Amazon SQS Files d’attente de lettresmortesCet exemple présente comment utiliser une file d'attente pour recevoir et mettre en attente des messagesen provenance d'autres files d'attente que celles-ci ne peuvent pas traiter.

Une file d'attente de lettres mortes peut être ciblée par d'autres files d'attente (source) pour les messagesne pouvant pas être traités avec succès. Vous pouvez mettre de côté et isoler ces messages dans la filed’attente de lettres mortes pour déterminer pourquoi leur traitement a échoué. Vous devez configurerindividuellement chaque file d’attente source qui envoie des messages à une file d’attente de lettresmortes. Plusieurs files d'attente peuvent cibler une seule file d'attente de lettres mortes.

Dans cet exemple, un objet AmazonSQSClient utilise la méthode SetQueueAttributesRequest pourconfigurer une file d'attente source afin qu'elle utilise une file d'attente de lettres mortes.

Pour plus d'informations sur les files d'attente de lettres mortes Amazon SQS, consultez Files d'attente delettres mortes d'Amazon SQS dans le Amazon Simple Queue Service Manuel du développeur.

Configurer une file d'attente sourceCet exemple de code suppose que vous avez créé une file d'attente qui servira de file d'attente de lettresmortes. Pour plus d'informations sur la création d'une file d'attente, consultez Création d'une file d'attenteAmazon SQS (p. 158). Après avoir créé la file d'attente de lettres mortes, vous devez configurer lesautres files d'attente de manière à acheminer les messages non traités vers la file d'attente de lettresmortes. Pour ce faire, spécifiez une stratégie de redirection identifiant la file d'attente à utiliser comme filed'attente de lettres mortes, et le nombre maximum de réceptions pour les messages individuels avant queces derniers soient acheminés vers la file d'attente de lettres mortes.

Créez un objet AmazonSQSClient pour définir les attributs de file d'attente. Créer un Demande d’attributsde file d’attente définie objet contenant les propriétés nécessaires pour mettre à jour les attributs de filed’attente, y compris RedrivePolicy propriété qui spécifie à la fois l’Amazon Resource Name (ARN) dela file d’attente de lettres mortes et la valeur de maxReceiveCount. Spécifiez également la file d’attentesource d’URL que vous souhaitez configurer. Appelez la méthode SetQueueAttributes.

AmazonSQSClient client = new AmazonSQSClient();

var setQueueAttributeRequest = new SetQueueAttributesRequest{ Attributes = new Dictionary<string, string> { {"RedrivePolicy", @"{ ""deadLetterTargetArn"" : ""DEAD_LETTER_QUEUE_ARN"", ""maxReceiveCount"" : ""10""}" } }, QueueUrl = "SOURCE_QUEUE_URL"};

client.SetQueueAttributes(setQueueAttributeRequest)

Surveillance de vos ressources AWS à l’aide d’Amazon CloudWatch

Amazon CloudWatch est un service web qui surveille en temps réel vos ressources AWS et les applicationsque vous exécutez sur AWS. Vous pouvez utiliser CloudWatch pour collecter et suivre les métriques,

165

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Description, création et suppression

d’alarmes dans Amazon CloudWatch

qui sont des variables qui vous permettent de mesurer vos ressources et applications. Les alarmesCloudWatch envoient des notifications ou apportent des modifications automatiquement aux ressourcessurveillées, selon les règles que vous définissez.

Le code de ces exemples est écrit en C#, mais il est possible d'employer le Kit AWS SDK pour .NET avecn'importe quel langage compatible. Lorsque vous installez l'AWS Toolkit for Visual Studio, un ensemblede modèles de projet C# est installé. La manière la plus simple de démarrer ce projet consiste à ouvrirVisual Studio, puis à choisir File (Fichier), New Project (Nouveau projet), AWS Sample Projects (Exemplesde projets AWS), Deployment and Management (Déploiement et gestion)., AWS CloudWatch Example(Exemple AWS CloudWatch).

Tâches prérequises

Avant de commencer, assurez-vous d'avoir créé un compte AWS et d'avoir configuré vos informationsd'identification AWS. Pour plus d'informations, consultez Configuration du Kit AWS SDK pour .NET (p. 15),

Rubriques• Description, création et suppression d’alarmes dans Amazon CloudWatch (p. 166)• Utilisation des alarmes dans Amazon CloudWatch (p. 168)• Obtention de métriques à partir d'Amazon CloudWatch (p. 170)• Envoi d'événements à Amazon CloudWatch Events (p. 171)• Utilisation des filtres d'abonnements dans Amazon CloudWatch Logs (p. 175)

Description, création et suppression d’alarmes dansAmazon CloudWatchCet exemple .NET vous montre comment :

• Décrire une alarme CloudWatch• Créer une alarme CloudWatch basée sur une métrique• Supprimer une alarme CloudWatch

ScénarioUne alarme surveille une métrique sur la période que vous spécifiez. Elle réalise une ou plusieurs actionsen fonction de la valeur de la métrique par rapport à un seuil donné sur un certain nombre de périodes.Les exemples suivants présentent comment décrire, créer et supprimer des alarmes dans CloudWatch enutilisant ces méthodes de la classe AmazonCloudWatchClient :

• DescribeAlarms• PutMetricAlarm• DeleteAlarms

Pour plus d'informations sur les alarmes CloudWatch, consultez Création d'alarmes Amazon CloudWatchdans le Guide de l'utilisateur Amazon CloudWatch.

Tâches prérequisesPour configurer et exécuter cet exemple, vous devez d'abord :

166

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Description, création et suppression

d’alarmes dans Amazon CloudWatch

• Préparez-vous à utiliser Amazon CloudWatch.• Configurez le Kit AWS SDK pour .NET. (p. 15)

Description d'une alarmeCréez une instance AmazonCloudWatchClient et un objet DescribeAlarmsRequest, en limitant les alarmesrenvoyées à celles dont le statut est INSUFFICIENT_DATA. Appelez ensuite la méthode DescribeAlarmsde l'objet AmazonCloudWatchClient.

using (var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ var request = new DescribeAlarmsRequest(); request.StateValue = "INSUFFICIENT_DATA"; request.AlarmNames = new List<string> { "Alarm1", "Alarm2" }; do { var response = cloudWatch.DescribeAlarms(request); foreach(var alarm in response.MetricAlarms) { Console.WriteLine(alarm.AlarmName); } request.NextToken = response.NextToken; } while (request.NextToken != null);}

Création d'une alarme basée sur une métriqueCréez une instance AmazonCloudWatchClient et un objet PutMetricAlarmRequest pour les paramètresrequis pour créer une alarme basée sur une métrique, dans ce cas, l'utilisation de l'UC d'une instanceAmazon EC2.

Les paramètres restants sont définis pour déclencher l'alarme lorsque la métrique dépasse un seuil de 70pourcent.

Appelez ensuite la méthode PutMetricAlarm de l'objet AmazonCloudWatchClient.

var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2);client.PutMetricAlarm( new PutMetricAlarmRequest { AlarmName = "Web_Server_CPU_Utilization", ComparisonOperator = ComparisonOperator.GreaterThanThreshold, EvaluationPeriods = 1, MetricName = "CPUUtilization", Namespace = "AWS/EC2", Period = 60, Statistic = Statistic.Average, Threshold = 70.0, ActionsEnabled = true, AlarmActions = new List<string> { "arn:aws:swf:us-west-2:" + "customerAccount" + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" }, AlarmDescription = "Alarm when server CPU exceeds 70%", Dimensions = new List<Dimension> { new Dimension { Name = "InstanceId", Value = "INSTANCE_ID" } }, Unit = StandardUnit.Seconds });

167

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des alarmes dans Amazon CloudWatch

Suppression d'une alarmeCréez une instance AmazonCloudWatchClient et un objet DeleteAlarmsRequest contenant les nomsdes alarmes que vous souhaitez supprimer. Appelez ensuite la méthode DeleteAlarms de l'objetAmazonCloudWatchClient.

using (var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ var response = cloudWatch.DeleteAlarms( new DeleteAlarmsRequest { AlarmNames = new List<string> { "Alarm1", "Alarm2" }; });}

Utilisation des alarmes dans Amazon CloudWatchCet exemple .NET explique comment modifier automatiquement l'état de vos instances Amazon EC2 enfonction d'une alarme CloudWatch.

ScénarioÀ l'aide des actions d'alarme, vous pouvez créer des alarmes qui arrêtent, résilient, redémarrent ourécupèrent vos instances Amazon EC2 automatiquement. Vous pouvez utiliser les actions d'arrêt ou demise hors service quand vous n'avez plus besoin qu'une instance s'exécute. Vous pouvez utiliser lesactions de redémarrage et de récupération pour redémarrer automatiquement ces instances.

Dans cet exemple, .NET est utilisé pour définir, dans CloudWatch, une action d'alarme qui déclenchele redémarrage d'une instance Amazon EC2. Les méthodes utilisent le kit Kit AWS SDK pour .NETpour gérer les instances Amazon EC2 par l'intermédiaire des méthodes suivantes de la classeAmazonCloudWatchClient :

• PutMetricAlarm• EnableAlarmActions• DisableAlarmActions

Pour plus d'informations sur les actions d'alarme CloudWatch, consultez Création d'alarmes qui arrêtent,résilient, redémarrent ou récupèrent une instance dans le Guide de l'utilisateur Amazon CloudWatch.

Tâches prérequisesPour configurer et exécuter cet exemple, vous devez d'abord :

• Préparez-vous à utiliser Amazon CloudWatch.• Configurez le Kit AWS SDK pour .NET. (p. 15)

Création et activation d'actions sur une alarme1. Créez une instance AmazonCloudWatchClient et un objet PutMetricAlarmRequest pour contenir les

paramètres nécessaires à la création d'une alarme, en spécifiant la valeur true pour ActionsEnabledet un ensemble d'ARN pour les actions qui seront déclenchées par l'alarme. Appelez la méthodePutMetricAlarm de l'objet AmazonCloudWatchClient, qui crée l'alarme si elle n'existe pas, ou la met àjour si elle existe.

168

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des alarmes dans Amazon CloudWatch

using (var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ client.PutMetricAlarm(new PutMetricAlarmRequest { AlarmName = "Web_Server_CPU_Utilization", ComparisonOperator = ComparisonOperator.GreaterThanThreshold, EvaluationPeriods = 1, MetricName = "CPUUtilization", Namespace = "AWS/EC2", Period = 60, Statistic = Statistic.Average, Threshold = 70.0, ActionsEnabled = true, AlarmActions = new List<string> { "arn:aws:swf:us-west-2:" + "customerAccount" + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" }, AlarmDescription = "Alarm when server CPU exceeds 70%", Dimensions = new List<Dimension> { new Dimension { Name = "InstanceId", Value = "instanceId" } } });}

2. Lorsque la méthode PutMetricAlarm se termine correctement, créez un objetEnableAlarmActionsRequest contenant le nom de l'alarme CloudWatch. Appelez la méthodeEnableAlarmActions pour activer l'action d'alarme.

client.EnableAlarmActions(new EnableAlarmActionsRequest{ AlarmNames = new List<string> { "Web_Server_CPU_Utilization" }});

3. Créez un objet MetricDatum contenant la métrique personnalisée CPUUtilization. Créez un objetPutMetricDataRequest contenant le paramètre MetricData requis pour envoyer un point de donnéespour la métrique CPUUtilization. Appelez la méthode PutMetricData.

MetricDatum metricDatum = new MetricDatum{ MetricName = "CPUUtilization" };PutMetricDataRequest putMetricDatarequest = new PutMetricDataRequest{ MetricData = new List<MetricDatum> { metricDatum }};client.PutMetricData(putMetricDatarequest);

Désactiver des actions sur une alarmeCréez une instance AmazonCloudWatchClient et un objet DisableAlarmActionsRequest contenant le nomde l'alarme CloudWatch. Appelez la méthode DisableAlarmActions pour désactiver les actions pour cettealarme.

using (var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ client.DisableAlarmActions(new DisableAlarmActionsRequest { AlarmNames = new List<string> { "Web_Server_CPU_Utilization" } });}

169

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Obtention de métriques à partir d'Amazon CloudWatch

Obtention de métriques à partir d'Amazon CloudWatchCet exemple vous montre comment :

• Récupérer une liste de métriques CloudWatch• Publier des métriques personnalisées CloudWatch

ScénarioLes métriques sont des données sur les performances de vos systèmes. Vous pouvez activer lasurveillance détaillée de certaines ressources, telles que vos instances Amazon EC2, ou ajouter vospropres métriques d'applications. Dans cet exemple, vous utilisez .NET pour récupérer une liste demétriques CloudWatch publiées et publier des points de données sur des métriques CloudWatch enutilisant les méthodes suivantes de la classe AmazonCloudWatchClient :

• ListMetrics• PutMetricData

Pour plus d'informations sur les métriques CloudWatch, consultez Utilisation des métriquesAmazon CloudWatch dans le Guide de l'utilisateur Amazon CloudWatch.

Tâches prérequisesPour configurer et exécuter cet exemple, vous devez d'abord :

• Préparez-vous à utiliser Amazon CloudWatch.• Configurez le Kit AWS SDK pour .NET. (p. 15)

Liste de métriquesCréez un objet ListMetricsRequest contenant les paramètres requis pour lister des métriques dans l'espacede nom AWS/Logs. Appelez la méthode ListMetrics à partir d'une instance AmazonCloudWatchClient pourlister la métrique IncomingLogEvents.

var logGroupName = "LogGroupName";DimensionFilter dimensionFilter = new DimensionFilter(){ Name = logGroupName};var dimensionFilterList = new List<DimensionFilter>();dimensionFilterList.Add(dimensionFilter);

var dimension = new Dimension{ Name = "UniquePages", Value = "URLs"};using (var cw = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ var listMetricsResponse = cw.ListMetrics(new ListMetricsRequest { Dimensions = dimensionFilterList, MetricName = "IncomingLogEvents", Namespace = "AWS/Logs" }); Console.WriteLine(listMetricsResponse.Metrics);

170

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'événements à Amazon CloudWatch Events

}

Soumettre des métriques personnaliséesCréez un objet PutMetricDataRequest contenant les paramètres requis pour envoyer un point de donnéespour la métrique personnalisée PAGES_VISITED. Appelez la méthode PutMetricData à partir de l'instanceAmazonCloudWatchClient.

using (var cw = new AmazonCloudWatchClient(RegionEndpoint.USWest2)){ cw.PutMetricData(new PutMetricDataRequest { MetricData = new List<MetricDatum>{new MetricDatum { MetricName = "PagesVisited", Dimensions = new List<Dimension>{dimension}, Unit = "None", Value = 1.0 }}, Namespace = "SITE/TRAFFIC" });}

Envoi d'événements à Amazon CloudWatch EventsCet exemple de code .NET vous montre comment :

• Créer et mettre à jour une règle planifiée pour déclencher un événement• Ajouter une fonction AWS Lambda cible pour répondre à un événement• Envoyer des événements associés à des cibles

ScénarioAmazon CloudWatch Events fournit un flux d'événements système en temps quasi réel qui décriventles modifications apportées aux ressources AWS pour les diverses cibles. À l'aide de règles simples,vous pouvez faire correspondre les événements et les acheminer vers un ou plusieurs flux ou fonctionscibles. Cet exemple .NET présente comment créer et mettre à jour une règle utilisée pour déclencher unévénement, définir une ou plusieurs cibles pour répondre à un événement, et envoyer des événementsassociés à des cibles à traiter.

Le code gère les instances avec ces méthodes de la classe AmazonCloudWatchEventsClient :

• PutRule• PutTargets• PutEvents

Pour plus d'informations sur Amazon CloudWatch Events, consultez Ajout d'événements avec PutEventsdans le Guide de l'utilisateur Amazon CloudWatch Events.

Tâches prérequisesPour configurer et exécuter cet exemple, vous devez d'abord :

• Préparez-vous à utiliser Amazon CloudWatch.• Configurez le Kit AWS SDK pour .NET. (p. 15)

171

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'événements à Amazon CloudWatch Events

• Créer une fonction Lambda en utilisant le plan hello-world comme cible pour les événements. Pour ensavoir plus, consultez Étape 1 : Création d’une fonction AWS Lambda dans le Guide de l'utilisateurAmazon CloudWatch Events.

Créer un rôle IAM pour exécuter les exemplesLes exemples suivants nécessitent un rôle IAM dont la stratégie accorde l'autorisation à CloudWatchEvents et inclut events.amazonaws.com comme entité de confiance. Cet exemple crée un rôle nomméCWEvents, et définit sa relation d'approbation et sa stratégie de rôle.

static void Main(){ var client = new AmazonIdentityManagementServiceClient(); // Create a role and it's trust relationship policy var role = client.CreateRole(new CreateRoleRequest { RoleName = "CWEvents", AssumeRolePolicyDocument = @"{""Statement"":[{""Principal"":{""Service"":[""events.amazonaws.com""]}," + @"""Effect"":""Allow"",""Action"":[""sts:AssumeRole""]}]}" }).Role; // Create a role policy and add it to the role string policy = GenerateRolePolicyDocument(); var request = new CreatePolicyRequest { PolicyName = "DemoCWPermissions", PolicyDocument = policy }; try { var createPolicyResponse = client.CreatePolicy(request); } catch (EntityAlreadyExistsException) { Console.WriteLine ("Policy 'DemoCWPermissions' already exits."); } var request2 = new AttachRolePolicyRequest() { PolicyArn = "arn:aws:iam::192484417122:policy/DemoCWPermissions", RoleName = "CWEvents" }; try { var response = client.AttachRolePolicy(request2); //managedpolicy Console.WriteLine("Policy DemoCWPermissions attached to Role TestUser"); } catch (NoSuchEntityException) { Console.WriteLine ("Policy 'DemoCWPermissions' does not exist"); } catch (InvalidInputException) { Console.WriteLine ("One of the parameters is incorrect"); }

}public static string GenerateRolePolicyDocument(){ /* This method produces the following managed policy: "Version": "2012-10-17",

172

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'événements à Amazon CloudWatch Events

"Statement": [ { "Sid": "CloudWatchEventsFullAccess", "Effect": "Allow", "Action": "events:*", "Resource": "*" }, { "Sid": "IAMPassRoleForCloudWatchEvents", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "arn:aws:iam::*:role/AWS_Events_Invoke_Targets" } ] } */ var actionList = new ActionIdentifier("events:*"); var actions = new List<ActionIdentifier>(); actions.Add(actionList); var resource = new Resource("*"); var resources = new List<Resource>(); resources.Add(resource); var statement = new Amazon.Auth.AccessControlPolicy.Statement (Amazon.Auth.AccessControlPolicy.Statement.StatementEffect.Allow) { Actions = actions, Id = "CloudWatchEventsFullAccess", Resources = resources }; var statements = new List<Amazon.Auth.AccessControlPolicy.Statement>(); statements.Add(statement); var actionList2 = new ActionIdentifier("iam:PassRole"); var actions2 = new List<ActionIdentifier>(); actions2.Add(actionList2); var resource2 = new Resource("arn:aws:iam::*:role/AWS_Events_Invoke_Targets"); var resources2 = new List<Resource>(); resources2.Add(resource2); var statement2 = new Amazon.Auth.AccessControlPolicy.Statement(Amazon.Auth.AccessControlPolicy.Statement.StatementEffect.Allow) { Actions = actions2, Id = "IAMPassRoleForCloudWatchEvents", Resources = resources2 };

statements.Add(statement2); var policy = new Policy { Id = "DemoEC2Permissions", Version = "2012-10-17", Statements = statements }; return policy.ToJson();}

Créer une règle planifiéeCréez une instance AmazonCloudWatchEventsClient et un objet PutRuleRequest contenant lesparamètres requis pour spécifier la nouvelle règle planifiée, qui incluent les éléments suivants :

• Nom de la règle.• ARN du rôle IAM créé précédemment• Une expression pour planifier le déclenchement de la règle toutes les cinq minutes

173

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Envoi d'événements à Amazon CloudWatch Events

Appelez la méthode PutRule pour créer la règle. L’objet PutRuleResponse renvoie l'ARN de la nouvellerègle ou de la règle modifiée.

AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

var putRuleRequest = new PutRuleRequest{ Name = "DEMO_EVENT", RoleArn = "IAM_ROLE_ARN", ScheduleExpression = "rate(5 minutes)", State = RuleState.ENABLED};

var putRuleResponse = client.PutRule(putRuleRequest);Console.WriteLine("Successfully set the rule {0}", putRuleResponse.RuleArn);

Ajouter une fonction Lambda cibleCréez une instance AmazonCloudWatchEventsClient et un objet PutTargetsRequest contenantles paramètres requis pour spécifier la règle à laquelle vous souhaitez attacher la cible, en incluantl'ARN de la fonction Lambda que vous avez créée. Appelez la méthode PutTargets de l'instanceAmazonCloudWatchClient.

AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

var putTargetRequest = new PutTargetsRequest{ Rule = "DEMO_EVENT", Targets = { new Target { Arn = "LAMBDA_FUNCTION_ARN", Id = "myCloudWatchEventsTarget"} }};client.PutTargets(putTargetRequest);

Envoyez des événementsCréez une instance AmazonCloudWatchEventsClient et un objet PutEventsRequest contenant lesparamètres requis pour envoyer des événements. Pour chaque événement, incluez la source del'événement, les ARN des ressources affectées par l'événement et les détails de l'événement. Appelez laméthode PutEvents de l'instance AmazonCloudWatchClient.

AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

var putEventsRequest = new PutEventsRequest{ Entries = new List<PutEventsRequestEntry> { new PutEventsRequestEntry { Detail = @"{ ""key1"" : ""value1"", ""key2"" : ""value2"" }", DetailType = "appRequestSubmitted", Resources = { "RESOURCE_ARN" }, Source = "com.compnay.myapp" } }};

174

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des filtres d'abonnements

dans Amazon CloudWatch Logs

client.PutEvents(putEventsRequest);

Utilisation des filtres d'abonnements dans AmazonCloudWatch LogsCes exemples .NET vous montrent comment :

• Liste des filtres d'abonnement existants dans CloudWatch Logs• Créez un filtre d'abonnement dans CloudWatch Logs• Suppression d'un filtre d'abonnement dans CloudWatch Logs

ScénarioLes abonnements permettent d'accéder à un flux d'événements de journaux en temps réel fourni parCloudWatch Logs et de le transmettre à d'autres services tels qu'Amazon Kinesis Data Streams ou AWSLambda afin d'effectuer une analyse ou un traitement personnalisé, ou pour le charger dans d'autressystèmes. Un filtre d'abonnement définit le modèle à utiliser pour filtrer les événements de journaux quiseront fournis à votre ressource AWS. Cet exemple explique comment lister, créer et supprimer un filtred'abonnement dans CloudWatch Logs. La destination des événements de journaux est une fonctionLambda.

Cet exemple utilise le Kit AWS SDK pour .NET pour gérer les filtres d'abonnement à l'aide des méthodessuivantes de la classe AmazonCloudWatchLogsClient :

• DescribeSubscriptionFilters• PutSubscriptionFilter• DeleteSubscriptionFilter

Pour plus d'informations sur les abonnements CloudWatch Logs, consultez Traitement en temps réel desdonnées de journaux avec les abonnements dans le Amazon CloudWatch Logs User Guide.

Tâches prérequisesPour configurer et exécuter cet exemple, vous devez d'abord :

• Préparez-vous à utiliser Amazon CloudWatch.• Configurez le Kit AWS SDK pour .NET. (p. 15)

Description des filtres d'abonnements existantsCréez un objet AmazonCloudWatchLogsClient. Créez un objet DescribeSubscriptionFiltersRequestcontenant les paramètres requis pour décrire vos filtres existants. Incluez le nom du groupe de journaux etle nombre maximal de filtres à décrire. Appelez la méthode DescribeSubscriptionFilters.

public static void DescribeSubscriptionFilters(){ var client = new AmazonCloudWatchLogsClient(); var request = new Amazon.CloudWatchLogs.Model.DescribeSubscriptionFiltersRequest() { LogGroupName = "GROUP_NAME", Limit = 5 };

175

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Utilisation des filtres d'abonnements

dans Amazon CloudWatch Logs

try { var response = client.DescribeSubscriptionFilters(request); } catch (Amazon.CloudWatchLogs.Model.ResourceNotFoundException e) { Console.WriteLine(e.Message); } finally { client?.Dispose(); }}

Créer un filtre d'abonnementCréez un objet AmazonCloudWatchLogsClient. Créez un objet PutSubscriptionFilterRequest contenant lesparamètres nécessaires à la création d'un filtre, notamment l'ARN de la fonction Lambda de destination,le nom du filtre, le modèle de chaîne à filtrer et le nom du groupe de journaux. Appelez la méthodePutSubscriptionFilter.

public static void PutSubscriptionFilters(){ var client = new AmazonCloudWatchLogsClient(); var request = new Amazon.CloudWatchLogs.Model.PutSubscriptionFilterRequest() { DestinationArn = "LAMBDA_FUNCTION_ARN", FilterName = "FILTER_NAME", FilterPattern = "ERROR", LogGroupName = "Log_Group" }; try { var response = client.PutSubscriptionFilter(request); } catch (InvalidParameterException e) { Console.WriteLine(e.Message); } finally { client?.Dispose(); }}

Suppression d'un filtre d'abonnementCréez un objet AmazonCloudWatchLogsClient. Créez un objet DeleteSubscriptionFilterRequest contenantles paramètres requis pour supprimer un filtre, notamment les noms du filtre et du groupe de journaux.Appelez la méthode DeleteSubscriptionFilter.

public static void DeleteSubscriptionFilter(){ var client = new AmazonCloudWatchLogsClient(); var request = new Amazon.CloudWatchLogs.Model.DeleteSubscriptionFilterRequest() { LogGroupName = "GROUP_NAME", FilterName = "FILTER" }; try {

176

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Programmation d'AWS OpsWorks

pour utiliser les piles et applications

var response = client.DeleteSubscriptionFilter(request); } catch (Amazon.CloudWatchLogs.Model.ResourceNotFoundException e) { Console.WriteLine(e.Message); } finally { client?.Dispose(); }}

Programmation d'AWS OpsWorks pour utiliser lespiles et applications

Le Kit AWS SDK pour .NET prend en charge AWS OpsWorks, qui propose une méthode simple et flexiblepour créer et gérer les piles et les applications. Avec AWS OpsWorks, vous pouvez allouer des ressourcesAWS, gérer leur configuration, déployer des applications sur ces ressources et surveiller leur état. Pourplus d'informations, consultez OpsWorks.

Le kit SDK fournit des API permettant de programmer avec AWS OpsWorks. Ces API se composentgénéralement d'ensembles d'objets de demande et de réponse compatibles qui correspondent à desappels d'API HTTP centrés sur les structures de niveau de service correspondantes.

Pour obtenir des informations de référence d'API connexes, consultez Amazon.OpsWorks etAmazon.OpsWorks.Model dans le document AWS SDK for .NET API Reference.

Prise en charge de programmation pour desservices AWS supplémentaires

Le Kit AWS SDK pour .NET prend en charge la programmation de services AWS, en plus de ceux décritsdans les exemples de code. Pour plus d'informations sur la programmation de services spécifiques avec leKit AWS SDK pour .NET, consultez le document AWS SDK for .NET API Reference.

Outre les espaces de noms pour les services AWS individuels, le Kit AWS SDK pour .NET fournitégalement les API suivantes :

Area Description : Ressources:

AWS Support Accès par programmation auxcas de AWS Support et auxfonctionnalités Trusted Advisor.

Consultez Amazon.AWSSupportet Amazon.AWSSupport.Model.

Général Énumérations et classesd'assistance.

Consultez Amazon etAmazon.Util.

Parmi les autres informations de programmation pour le Kit AWS SDK pour .NET figurent :

• Remplacement des points de terminaison dans le kit AWS SDK pour .NET• Cycle de vie des objets .NET

177

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Protection des données

Sécurité pour this AWS Product orService

Cloud security at Amazon Web Services (AWS) is the highest priority. As an AWS customer, youbenefit from a data center and network architecture that is built to meet the requirements of the mostsecurity-sensitive organizations. Security is a shared responsibility between AWS and you. The SharedResponsibility Model describes this as Security of the Cloud and Security in the Cloud.

Security of the Cloud – AWS is responsible for protecting the infrastructure that runs all of the servicesoffered in the AWS Cloud and providing you with services that you can use securely. Our securityresponsibility is the highest priority at AWS, and the effectiveness of our security is regularly tested andverified by third-party auditors as part of the AWS Compliance Programs.

Security in the Cloud – Your responsibility is determined by the AWS service you are using, and otherfactors including the sensitivity of your data, your organization’s requirements, and applicable laws andregulations.

This AWS product or service follows the shared responsibility model through the specific Amazon WebServices (AWS) services it supports. For AWS service security information, see the AWS service securitydocumentation page and AWS services that are in scope of AWS compliance efforts by complianceprogram.

Rubriques• Protection des données dans this AWS Product or Service (p. 178)• Identity and Access Management for this AWS Product or Service (p. 179)• Compliance Validation for this AWS Product or Service (p. 179)• Resilience for this AWS Product or Service (p. 180)• Infrastructure Security for this AWS Product or Service (p. 180)• Application de TLS 1.2 dans this AWS Product or Service (p. 181)• Amazon S3 Migration du client de chiffrement (p. 183)

Protection des données dans this AWS Product orService

This AWS product or service se conforme au modèle de responsabilité partagée, qui comprend desdirectives et des régulations pour la protection des données. Amazon Web Services (AWS) est responsablede la protection de l'infrastructure globale qui exécute tous les services AWS. AWS conserve le contrôledes données hébergées sur cette infrastructure, y compris les contrôles de configuration de sécurité pourtraiter le contenu et les données personnelles des clients. Les clients AWS et les partenaires APN, qu'ilsagissent en tant que contrôleurs ou responsables du traitement des données, sont responsables de toutesles données personnelles qu'ils mettent sur le cloud AWS.

Pour des raisons de protection des données, nous vous recommandons de protéger vos identifiantsde compte AWS et de configurer des comptes utilisateurs individuels avec AWS Identity and AccessManagement (IAM), afin que chaque utilisateur reçoive uniquement les permissions nécessaires pouraccomplir ses tâches. Nous vous recommandons également de sécuriser vos données de la manièresuivante :

178

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Identity and Access Management

• Utilisation de l'authentification multi-facteurs (MFA) avec chaque compte.• Utilisez SSL/TLS pour communiquer avec des ressources AWS. Pour utiliser une version minimale de

TLS 1.2, consultez Application de TLS 1.2 (p. 181).• Configurez l'API et la journalisation des activités utilisateur avec AWS CloudTrail.• Utilisez des solutions de chiffrement AWS, ainsi que tous les contrôles de sécurité par défaut au sein des

services AWS.• Utilisez des services de sécurité gérés avancés comme Amazon Macie, qui contribuent à la découverte

et à la sécurisation des données personnelles stockées dans Amazon S3.

Nous vous recommandons vivement de ne jamais placer d'informations identifiables sensibles, tellesque les numéros de compte de vos clients, dans des champs de formulaire comme Name (Nom). Celas'applique aussi lorsque vous utilisez this AWS product or service ou d'autres services AWS à l'aide de laconsole, de l'API, de l'AWS CLI ou des kits SDK AWS. Toutes les données que vous entrez dans this AWSproduct or service ou d'autres services peuvent être récupérées, afin d'être insérées dans des journauxde diagnostic. Lorsque vous fournissez une URL à un serveur externe, n'incluez pas les informationsd'identification non chiffrées dans l'URL pour valider votre demande adressée au serveur.

Pour de plus amples informations sur la protection des données, veuillez consulter le billet de blog Modèlede responsabilité partagée d’AWS et RGPD sur le Blog sur la sécurité d’AWS.

Identity and Access Management for this AWSProduct or Service

AWS Identity and Access Management (IAM) is an Amazon Web Services (AWS) service that helpsan administrator securely control access to AWS resources. IAM administrators control who can beauthenticated (signed in) and authorized (have permissions) to use resources in AWS services. IAM is anAWS service that you can use with no additional charge.

To use this AWS product or service to access AWS, you need an AWS account and AWS credentials. Toincrease the security of your AWS account, we recommend that you use an IAM user to provide accesscredentials instead of using your AWS account credentials.

For details about working with IAM, see AWS Identity and Access Management.

For an overview of IAM users and why they are important for the security of your account, see AWSSecurity Credentials in the Amazon Web Services General Reference.

This AWS product or service follows the shared responsibility model through the specific Amazon WebServices (AWS) services it supports. For AWS service security information, see the AWS service securitydocumentation page and AWS services that are in scope of AWS compliance efforts by complianceprogram.

Compliance Validation for this AWS Product orService

This AWS product or service follows the shared responsibility model through the specific Amazon WebServices (AWS) services it supports. For AWS service security information, see the AWS service securitydocumentation page and AWS services that are in scope of AWS compliance efforts by complianceprogram.

179

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Resilience

The security and compliance of AWS services is assessed by third-party auditors as part of multiple AWScompliance programs. These include SOC, PCI, FedRAMP, HIPAA, and others. AWS provides a frequentlyupdated list of AWS services in scope of specific compliance programs at AWS Services in Scope byCompliance Program.

Third-party audit reports are available for you to download using AWS Artifact. For more information, seeDownloading Reports in AWS Artifact.

For more information about AWS compliance programs, see AWS Compliance Programs.

Your compliance responsibility when using this AWS product or service to access an AWS service isdetermined by the sensitivity of your data, your organization’s compliance objectives, and applicable lawsand regulations. If your use of an AWS service is subject to compliance with standards such as HIPAA,PCI, or FedRAMP, AWS provides resources to help:

• Security and Compliance Quick Start Guides – Deployment guides that discuss architecturalconsiderations and provide steps for deploying security-focused and compliance-focused baselineenvironments on AWS.

• Architecting for HIPAA Security and Compliance Whitepaper – A whitepaper that describes howcompanies can use AWS to create HIPAA-compliant applications.

• AWS Compliance Resources – A collection of workbooks and guides that might apply to your industryand location.

• AWS Config – A service that assesses how well your resource configurations comply with internalpractices, industry guidelines, and regulations.

• AWS Security Hub – A comprehensive view of your security state within AWS that helps you check yourcompliance with security industry standards and best practices.

Resilience for this AWS Product or ServiceThe Amazon Web Services (AWS) global infrastructure is built around AWS Regions and AvailabilityZones.

AWS Regions provide multiple physically separated and isolated Availability Zones, which are connectedwith low-latency, high-throughput, and highly redundant networking.

With Availability Zones, you can design and operate applications and databases that automatically fail overbetween Availability Zones without interruption. Availability Zones are more highly available, fault tolerant,and scalable than traditional single or multiple data center infrastructures.

For more information about AWS Regions and Availability Zones, see AWS Global Infrastructure.

This AWS product or service follows the shared responsibility model through the specific Amazon WebServices (AWS) services it supports. For AWS service security information, see the AWS service securitydocumentation page and AWS services that are in scope of AWS compliance efforts by complianceprogram.

Infrastructure Security for this AWS Product orService

This AWS product or service follows the shared responsibility model through the specific Amazon WebServices (AWS) services it supports. For AWS service security information, see the AWS service securitydocumentation page and AWS services that are in scope of AWS compliance efforts by complianceprogram.

180

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Application de TLS 1.2

Application de TLS 1.2 dans this AWS Product orService

Pour augmenter la sécurité lors de la communication avec les services AWS, vous devez configurer thisAWS product or service pour utiliser TLS 1.2 ou une version ultérieure.

Le Kit AWS SDK pour .NET utilise le moteur d'exécution .NET sous-jacent pour déterminer le protocole desécurité à utiliser. Par défaut, les versions actuelles de .NET utilisent le dernier protocole configuré pris encharge par le système d'exploitation. Votre application peut remplacer ce comportement du kit SDK, mais iln'est pas recommandé de le faire.

.NET CorePar défaut, .NET Core utilise le dernier protocole configuré pris en charge par le système d'exploitation. LeKit AWS SDK pour .NET ne fournit pas de mécanisme permettant de remplacer cela.

Si vous utilisez une version .NET Core antérieure à 2.1, nous vous recommandons vivement de mettre àniveau votre version .NET Core.

Pour plus d'informations spécifiques à chaque système d'exploitation, reportez-vous à ce qui suit.

Windows:

Dans les distributions modernes de Windows la prise en charge de TLS 1.2 est activée par défaut. Si voustravaillez sous Windows 7 SP1 ou Windows Server 2008 R2 SP1, vous devez vous assurer que la prise encharge de TLS 1.2 est activée dans le Registre, comme décrit à l'adresse https://docs.microsoft.com/en-us/windows-server/security/tls/tls-registry-settings#tls-12. Si vous exécutez une distribution antérieure, vousdevez mettre à niveau votre système d'exploitation.

macOS

Si vous exécutez .NET Core 2.1 ou version ultérieure, TLS 1.2 est activé par défaut. TLS 1.2 est pris encharge par OS X Mavericks v10.9 ou version ultérieure. .NET Core version 2.1 et versions ultérieuresnécessitent des versions plus récentes de macOS, comme décrit dans https://docs.microsoft.com/en-us/dotnet/core/install/dependencies?tabs=netcore21&pivots=os-macos.

Si vous utilisez .NET Core 1.0, .NET Core utilise OpenSSL sur macOS, une dépendance qui doit êtreinstallée séparément. OpenSSL a ajouté la prise en charge de TLS 1.2 dans la version 1.0.1 (14/03/2012).

Linux*

.NET Core sous Linux nécessite OpenSSL, qui est fourni avec de nombreuses distributions Linux. Mais ilpeut également être installé séparément. OpenSSL a ajouté la prise en charge de TLS 1.2 dans la version1.0.1 (14/03/2012). Si vous utilisez une version moderne de .NET Core (2.1 ou version ultérieure) et quevous avez installé un gestionnaire de paquets, il est probable qu'une version plus moderne d'OpenSSL aété installée pour vous.

Pour être sûr, vous pouvez exécuter openssl version dans un terminal et vérifier que la version estpostérieure à 1.0.1.

.NET FrameworkSi vous exécutez une version moderne de .NET Framework (4.7 ou version ultérieure) et une versionmoderne de Windows (au moins Windows 8 pour les clients, Windows Server 2012 ou version ultérieurepour les serveurs), TLS 1.2 est activé et utilisé par défaut.

Si vous utilisez un moteur d'exécution .NET Framework qui n'utilise pas les paramètres du systèmed'exploitation (.NET Framework 3.5 à 4.5.2), le Kit AWS SDK pour .NET tentera d’ajouter la prise en

181

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Outils AWS pour PowerShell

charge de TLS 1.1 et TLS 1.2 aux protocoles pris en charge. Si vous utilisez .NET Framework 3.5, cela nefonctionnera que si le correctif approprié est installé, comme suit :

• Windows 10 version 1511 et Windows Server 2016 – KB3156421• Windows 8.1 et Windows Server 2012 R2 – KB3154520• Windows Server 2012 – KB3154519• Windows 7 SP1 et Server 2008 R2 SP1 – KB3154518

Si votre application s'exécute sur un .NET Framework plus récent sous Windows 7 SP1 ou WindowsServer 2008 R2 SP1, vous devez vous assurer que la prise en charge de TLS 1.2 est activée dans leRegistre, comme décrit à l'adresse https://docs.microsoft.com/en-us/windows-server/security/tls/tls-registry-settings#tls-12. Dans les versions plus récentes de Windows il est activé par défaut.

Pour en savoir plus sur les meilleures pratiques d'utilisation de TLS avec .NET Framework, consultezl'article Microsoft à l'adresse https://docs.microsoft.com/en-us/dotnet/framework/network-programming/tls.

Outils AWS pour PowerShellOutils AWS pour PowerShell utilise le Kit AWS SDK pour .NET pour tous les appels vers les servicesAWS. Le comportement de votre environnement dépend de la version de Windows PowerShell que vousexécutez, comme ci-dessous.

Windows PowerShell 2.0 à 5.x

Windows PowerShell 2.0 à 5.x s'exécute sur .NET Framework. Vous pouvez vérifier quel moteurd’exécution .NET (2.0 ou 4.0) est utilisé par PowerShell à l'aide de la commande suivante.

$PSVersionTable.CLRVersion

• Lorsque vous utilisez .NET Runtime 2.0, suivez les instructions fournies précédemment concernant le KitAWS SDK pour .NET et .NET Framework 3.5.

• Lorsque vous utilisez .NET Runtime 4.0, suivez les instructions fournies précédemment concernant KitAWS SDK pour .NET et .NET Framework 4+.

Windows PowerShell 6.0

Windows PowerShell 6.0 et versions ultérieures s'exécutent sur .NET Core. Vous pouvez vérifier quelleversion de .NET Core est utilisée en exécutant la commande suivante.

[System.Reflection.Assembly]::GetEntryAssembly().GetCustomAttributes([System.Runtime.Versioning.TargetFrameworkAttribute], $true).FrameworkName

Suivez les instructions fournies précédemment concernant le Kit AWS SDK pour .NET et la versionpertinente de .NET Core.

XamarinPour Xamarin, voir les instructions à l'adresse https://docs.microsoft.com/en-us/xamarin/cross-platform/app-fundamentals/transport-layer-security. Pour résumer :

Pour Android

• Exige Android 5.0 ou version ultérieure.• Propriétés du projet, Options Android: L’implémentation HttpClient doit être définie sur Android et

l’implémentation SSL/TLS définie sur TLS natif 1.2+.

182

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Unity

Pour iOS

• Exige iOS 7 ou version ultérieure.• Propriétés du projet, Version iOS: L’implémentation HttpClient doit être définie sur NSUrlSéance.

Pour macOS

• Exige macOS 10.9 ou version ultérieure.• Options du projet, Construire, Version Mac: L’implémentation HttpClient doit être définie sur

NSUrlSéance.

UnityVous devez utiliser Unity 2018.2 ou version ultérieure et utiliser le runtime de script équivalent .NET4.x. Vous pouvez définir ce dernier dans Project Settings (Paramètres du projet), Configuration,Player (Lecteur), comme décrit à l'adresse https://docs.unity3d.com/2019.1/Documentation/Manual/ScriptingRuntimeUpgrade.html. Le runtime de script équivalent .NET 4.x permet la prise en charge de TLS1.2 sur toutes les plates-formes Unity exécutant Mono ou IL2CPP. Pour plus d'informations, consultezhttps://blogs.unity3d.com/2018/07/11/scripting-runtime-improvements-in-unity-2018-2/.

Navigateur (pour Blazor WebAssembly)WebAssembly ne s'exécute pas dans le serveur, mais dans le navigateur et utilise le ce dernier pourgérer le trafic HTTP. Par conséquent, la prise en charge de TLS est déterminée par la prise en charge dunavigateur.

Blazor WebAssembly, en version préliminaire pour ASP.NET Core 3.1, est pris en charge uniquement dansles navigateurs qui prennent en charge WebAssembly, comme décrit sur https://docs.microsoft.com/en-us/aspnet/core/blazor/supported-platforms. Tous les navigateurs grand public ont pris en charge TLS 1.2avant de prendre en charge WebAssembly. Si tel est le cas pour votre navigateur, alors si votre applications'exécute, elle peut communiquer via TLS 1.2.

Consultez la documentation de votre navigateur pour plus d'informations et de vérifications.

Amazon S3 Migration du client de chiffrementCette rubrique montre comment migrer vos applications à partir de la version 1 (V1) de la Amazon SimpleStorage Service (Amazon S3) client de chiffrement vers la version 2 (V2), et assurez la disponibilité desapplications tout au long du processus de migration.

Les objets chiffrés avec le client V2 ne peuvent pas être déchiffrés avec le client V1. Afin de faciliter lamigration vers le nouveau client sans avoir à rechiffrer tous les objets en même temps, un client « V1-transitional » a été fourni. Ce client peut décrypter les objets chiffrés V1 et V2, mais chiffre aux objetsuniquement au format compatible V1. Le client V2 peut décrypter les objets chiffrés V1 et V2 (lorsqu’ils sontactivés pour les objets V1), mais chiffre aux objets uniquement au format compatible V2.

Aperçu de la migrationCette migration se déroule en trois phases. Ces phases sont présentées ici et décrites en détailultérieurement. Chaque phase doit être terminée pour tous Les clients qui utilisent des objets partagésavant le démarrage de la phase suivante.

1. Mettez à jour les clients existants vers les clients de transition V1 pour lire les nouveaux formats. Toutd’abord, mettez à jour vos applications pour prendre une dépendance sur le client de transition V1 au

183

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Mettre à jour les clients existants vers les clientsde transition V1 pour lire les nouveaux formats

lieu du client V1. Le client de transition V1 permet à votre code existant de déchiffrer les objets écritspar les nouveaux clients V2 et les objets écrits au format compatible V1.

Note

Le client de transition V1 est fourni à des fins de migration uniquement. Passez à la mise àniveau vers le client V2 après être passé au client de transition V1.

2. Migrez les clients de transition V1 vers les clients V2 pour écrire de nouveaux formats. Ensuite,remplacez tous les clients de transition V1 de vos applications par des clients V2 et définissez le profilde sécurité sur V2AndLegacy. La définition de ce profil de sécurité sur les clients V2 permet à cesclients de déchiffrer des objets chiffrés au format compatible V1.

3. Mettez à jour les clients V2 pour ne plus lire les formats V1. Enfin, une fois que tous les clients ont étémigrés vers V2 et que tous les objets ont été chiffrés ou recryptés au format compatible V2, définissezle profil de sécurité V2 sur V2 au lieu de V2AndLegacy. Cela empêche le déchiffrement des objets auformat compatible V1.

Mettre à jour les clients existants vers les clients detransition V1 pour lire les nouveaux formatsLe client de chiffrement V2 utilise des algorithmes de chiffrement que les anciennes versions du clientne prennent pas en charge. La première étape de la migration consiste à mettre à jour vos clients dedéchiffrement V1 afin qu’ils puissent lire le nouveau format.

Le client de transition V1 permet à vos applications de déchiffrer les objets chiffrés V1 et V2. Ce client faitpartie du Cryptage Amazon.Extensions.S3. Package NuGet. Effectuez les étapes suivantes sur chacune devos applications pour utiliser le client de transition V1.

1. Prenez une nouvelle dépendance sur le Cryptage Amazon.Extensions.S3. de l’emballage. Si votreprojet dépend directement de la pour le protocole AWSSDK.S3 ou Service de gestion de clé AWSSDK, vous devez mettre à jour ces dépendances ou les supprimer afin que leurs versions mises à joursoient extraites avec ce nouveau package.

2. Changez les using de l’instruction de Amazon.S3.Encryption àAmazon.Extensions.S3.Encryptioncomme suit :

// using Amazon.S3.Encryption; using Amazon.Extensions.S3.Encryption;

3. Reconstruisez et redéployez votre application.

Le client de transition V1 est entièrement compatible API avec le client V1, aucune autre modification decode n’est donc requise.

Migrer les clients de transition V1 vers les clientsV2 pour écrire de nouveaux formatsLe client V2 fait partie du Cryptage Amazon.Extensions.S3. Package NuGet. Permet à vos applications dedéchiffrer les objets chiffrés V1 et V2 (si cela est configuré), mais chiffre les objets uniquement au formatcompatible V2.

Après avoir mis à jour vos clients existants pour lire le nouveau format de chiffrement, vous pouvezprocéder à la mise à jour sécurisée de vos applications vers les clients de chiffrement et de déchiffrementV2. Effectuez les étapes suivantes sur chacune de vos applications pour utiliser le client V2 :

1. Modifier EncryptionMaterials à EncryptionMaterialsV2.

184

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Migrer les clients de transition V1 vers les

clients V2 pour écrire de nouveaux formats

a. Lorsque vous utilisez KMS :

i. Fournissez un ID de clé KMS.ii. Déclarez la méthode de chiffrement que vous utilisez ; c’est-à-dire, KmsType.KmsContext.iii. Fournissez un contexte de chiffrement à KMS à associer à cette clé de données. Vous

pouvez envoyer un dictionnaire vide (le contexte de chiffrement Amazon sera toujoursfusionné), mais il est recommandé de fournir un contexte supplémentaire.

b. Lors de l’utilisation de méthodes d’encapsulage de clé fournies par l’utilisateur (cryptagesymétrique ou asymétrique) :

i. Fournir un AES ou un RSA instance qui contient les matériaux de chiffrement.ii. Déclarer quel algorithme de chiffrement utiliser ; c’est-à-dire,

SymmetricAlgorithmType.AesGcm ou AsymmetricAlgorithmType.RsaOaepSha1.2. Modifier AmazonS3CryptoConfiguration à AmazonS3CryptoConfigurationV2 avec le

SecurityProfile propriété définie sur SecurityProfile.V2AndLegacy.3. Modifier AmazonS3EncryptionClient à AmazonS3EncryptionClientV2. Ce client prend le

nouveau converti AmazonS3CryptoConfigurationV2 et EncryptionMaterialsV2 des objetsdes étapes précédentes.

Exemple KMS à KMS+ContextePré-migration

using System.Security.Cryptography;using Amazon.S3.Encryption;

var encryptionMaterial = new EncryptionMaterials("1234abcd-12ab-34cd-56ef-1234567890ab");var configuration = new AmazonS3CryptoConfiguration(){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClient(configuration, encryptionMaterial);

Après la migration

using System.Security.Cryptography;using Amazon.Extensions.S3.Encryption;using Amazon.Extensions.S3.Encryption.Primitives;

var encryptionContext = new Dictionary<string, string>();var encryptionMaterial = new EncryptionMaterialsV2("1234abcd-12ab-34cd-56ef-1234567890ab", KmsType.KmsContext, encryptionContext);var configuration = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClientV2(configuration, encryptionMaterial);

Exemple Algorithme symétrique (Encapsulage de clé AES-CBC àAES-GCM)StorageMode peut être soit ObjectMetadata ou InstructionFile.

Pré-migration

185

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Migrer les clients de transition V1 vers les

clients V2 pour écrire de nouveaux formats

using System.Security.Cryptography;using Amazon.S3.Encryption;

var symmetricAlgorithm = Aes.Create();var encryptionMaterial = new EncryptionMaterials(symmetricAlgorithm);var configuration = new AmazonS3CryptoConfiguration(){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClient(configuration, encryptionMaterial);

Après la migration

using System.Security.Cryptography;using Amazon.Extensions.S3.Encryption;using Amazon.Extensions.S3.Encryption.Primitives;

var symmetricAlgorithm = Aes.Create();var encryptionMaterial = new EncryptionMaterialsV2(symmetricAlgorithm, SymmetricAlgorithmType.AesGcm);var configuration = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClientV2(configuration, encryptionMaterial);

Note

Lors du déchiffrement avec AES-GCM, lisez l’objet entier à la fin avant de commencer à utiliserles données déchiffrées. Ceci permet de vérifier que l’objet n’a pas été modifié depuis qu’il a étéchiffré.

Exemple Algorithme asymétrique (Encapsulage de clé RSA àRSA-OAEP-SHA1)StorageMode peut être soit ObjectMetadata ou InstructionFile.

Pré-migration

using System.Security.Cryptography;using Amazon.S3.Encryption;

var asymmetricAlgorithm = RSA.Create();var encryptionMaterial = new EncryptionMaterials(asymmetricAlgorithm);var configuration = new AmazonS3CryptoConfiguration(){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClient(configuration, encryptionMaterial);

Après la migration

using System.Security.Cryptography;using Amazon.Extensions.S3.Encryption;using Amazon.Extensions.S3.Encryption.Primitives;

var asymmetricAlgorithm = RSA.Create();var encryptionMaterial = new EncryptionMaterialsV2(asymmetricAlgorithm, AsymmetricAlgorithmType.RsaOaepSha1);

186

Kit AWS SDK pour .NET (version 3) Manuel du développeur:Mettre à jour les clients V2 aux formats V1 de lecture

var configuration = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy){ StorageMode = CryptoStorageMode.ObjectMetadata};var encryptionClient = new AmazonS3EncryptionClientV2(configuration, encryptionMaterial);

Mettre à jour les clients V2 aux formats V1 de lectureÀ terme, tous les objets auront été chiffrés ou recryptés à l’aide d’un client V2. Une fois cette conversionterminée, vous pouvez désactiver la compatibilité V1 dans les clients V2 en définissant SecurityProfilepropriété à SecurityProfile.V2, comme illustré dans l’extrait suivant.

//var configuration = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy);var configuration = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2);

187

Kit AWS SDK pour .NET (version 3) Manuel du développeur:

Historique du documentLe tableau suivant décrit les modifications importantes apportées depuis la dernière version du manueldu développeur AWS SDK pour .NET. Pour recevoir les notifications concernant les mises à jour de cettedocumentation, abonnez-vous à un flux RSS.

update-history-change update-history-description update-history-date

Version 3.5 du kit SDK AWSpour .NET (p. 68)

Version 3.5 du Kit AWS SDKpour .NET a été publié. Consultezle guide du développeur pourcette version à l’adresse https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/

August 25, 2020

Paginators (p. 66) Ajout de paginateurs à denombreux clients de service,ce qui rend la pagination desrésultats d’API plus pratique.

August 24, 2020

Nouvelles tentatives et délaisd’expiration (p. 63)

Ajout d’informations sur lesmodes de nouvelle tentative.

August 20, 2020

Migration du client de chiffrementS3 (p. 183)

Ajout d’informations sur lamigration de votre Amazon S3clients de chiffrement de V1 à V2.

August 7, 2020

Utilisation des clés KMS pour lechiffrement S3 (p. 146)

Exemple mis à jour pour utiliser laversion 2 du client de chiffrementS3.

August 6, 2020

Migration à partir de .NETStandard 1.3 (p. 68)

Ajout d'informations surl’arrêt de la prise en chargede .NET Standard 1.3 à la finde l’année 2020.

May 18, 2020

Démarrage rapide (p. 5) Ajout d'une section de démarragerapide avec configurationde base et didacticiels pourprésenter le kit Kit AWS SDKpour .NET au lecteur.

March 27, 2020

Application de TLS 1.2 (p. 181) Ajout d'informations sur la façond'appliquer TLS 1.2 dans le SDK.

March 10, 2020

Nouvelle version SDK (p. 188) La version 3 du kit SDK AWSpour .NET est publiée.

July 28, 2015

188