La version 4 (V4) du AWS SDK pour .NET est sortie \$1
Pour plus d'informations sur les modifications majeures et la migration de vos applications, consultez la [rubrique relative à la migration](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html).
[https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html)
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS Services d'appel depuis le AWS SDK pour .NET
AWS Services d'appels
Les sections suivantes contiennent des exemples, des didacticiels, des tâches et des guides qui vous montrent comment utiliser les AWS SDK pour .NET AWS services. Ces exemples et didacticiels s'appuient sur une API AWS SDK pour .NET fournie. Pour connaître les classes et les méthodes disponibles dans l'API, consultez la [référence de l'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/).
Si vous êtes nouveau dans le AWS SDK pour .NET domaine, vous voudrez peut-être d'abord consulter le [Création d'une application simple](quick-start.md) sujet. Il vous présente le SDK.
Vous pouvez trouver d'autres exemples de code dans le référentiel d'[exemples de AWS code et dans le référentiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4) [awslabs](https://github.com/awslabs/aws-sdk-net-samples) sur. GitHub
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
**Topics**
+ [Exemples de code guidés](tutorials-examples.md)
+ [AWS Lambda](aws-lambda.md)
+ [Bibliothèques et frameworks de haut niveau](high-level-libraries.md)
+ [Autres services et configuration](other-apis-intro.md)
# Exemples de code guidés pour AWS SDK pour .NET
Exemples de code guidés
Les sections suivantes contiennent des exemples de code et fournissent des conseils pour les exemples. Ils peuvent vous aider à apprendre à utiliser le AWS SDK pour .NET pour utiliser les AWS services. Pour des exemples de code supplémentaires, voir[Exemples de code](csharp_code_examples.md).
**Note**
Des exemples de code spécifiques à la version 3 de AWS SDK pour .NET sont également disponibles. Pour les trouver, consultez les [exemples de code avec des instructions](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/tutorials-examples.html) et les [exemples de code](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/csharp_code_examples.html) dans le guide du développeur AWS SDK pour .NET (V3). Sachez toutefois que si vous utilisez les exemples de code spécifiques à la version 3 avec la version V4 du SDK (la dernière version), vous devrez peut-être effectuer des ajustements en fonction des informations contenues dans. [Migration vers la version 4](net-dg-v4.md)
Si vous êtes nouveau dans le AWS SDK pour .NET domaine, vous voudrez peut-être d'abord consulter le [Création d'une application simple](quick-start.md) sujet. Il vous présente le SDK.
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
**Topics**
+ [CloudFormation](cloudformation-apis-intro.md)
+ [Amazon Cognito](cognito-apis-intro.md)
+ [DynamoDB](dynamodb-intro.md)
+ [Amazon EC2](ec2-apis-intro.md)
+ [IAM](iam-apis-intro.md)
+ [Amazon S3](s3-apis-intro.md)
+ [Amazon SNS](sns-apis-intro.md)
+ [Amazon SQS](sqs-apis-intro.md)
# Accès à CloudFormation l'aide du AWS SDK pour .NET
CloudFormation
Les AWS SDK pour .NET supports [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/), qui créent et provisionnent les déploiements AWS d'infrastructures de manière prévisible et répétée.
## APIs
Les AWS SDK pour .NET offres APIs pour les CloudFormation clients. Ils vous APIs permettent de travailler avec des CloudFormation fonctionnalités telles que les modèles et les piles. Cette section contient un petit nombre d'exemples qui vous montrent les modèles que vous pouvez suivre lorsque vous les utilisez APIs. Pour voir l'ensemble complet de APIs, consultez la [référence de l'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) (et faites défiler la page jusqu'à « Amazon »). CloudFormation«).
Ils AWS CloudFormation APIs sont fournis par le [AWSSDK. CloudFormation](https://www.nuget.org/packages/AWSSDK.CloudFormation/)colis.
## Conditions préalables
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## Rubriques
**Topics**
+ [
## APIs
](#w2aac19c15c15b5)
+ [
## Conditions préalables
](#w2aac19c15c15b7)
+ [
## Rubriques
](#w2aac19c15c15b9)
+ [AWS Ressources relatives à la liste](cfn-list-resources.md)
# Lister AWS les ressources à l'aide AWS CloudFormation
AWS Ressources relatives à la liste
Cet exemple vous montre comment utiliser le AWS SDK pour .NET pour répertorier les ressources par CloudFormation piles. L'exemple utilise l'API de bas niveau. L'application ne prend aucun argument, mais rassemble simplement des informations pour toutes les piles accessibles aux informations d'identification de l'utilisateur, puis affiche des informations sur ces piles.
## Références du SDK
NuGet colis :
+ [AWSSDK.CloudFormation](https://www.nuget.org/packages/AWSSDK.CloudFormation/)
Éléments de programmation :
+ Espace de noms [Amazon. CloudFormation](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/NCloudFormation.html)
Classe [AmazonCloudFormationClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TCloudFormationClient.html)
+ Espace de noms [Amazon. CloudFormation.Modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/NCloudFormationModel.html)
Classe [ICloudFormationPaginatorFactory. DescribeStacks](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/MICloudFormationPaginatorFactoryDescribeStacksDescribeStacksRequest.html)
Classe [DescribeStackResourcesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TDescribeStackResourcesRequest.html)
Classe [DescribeStackResourcesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TDescribeStackResourcesResponse.html)
Class [Stack](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TStack.html)
Classe [StackResource](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TStackResource.html)
[Tag](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudFormation/TTag.html) de classe
```
using Amazon.CloudFormation;
using Amazon.CloudFormation.Model;
using Amazon.Runtime;
namespace CloudFormationActions;
public static class HelloCloudFormation
{
public static IAmazonCloudFormation _amazonCloudFormation;
static async Task Main(string[] args)
{
// Create the CloudFormation client
_amazonCloudFormation = new AmazonCloudFormationClient();
Console.WriteLine($"\nIn Region: {_amazonCloudFormation.Config.RegionEndpoint}");
// List the resources for each stack
await ListResources();
}
///
/// Method to list stack resources and other information.
///
/// True if successful.
public static async Task ListResources()
{
try
{
Console.WriteLine("Getting CloudFormation stack information...");
// Get all stacks using the stack paginator.
var paginatorForDescribeStacks =
_amazonCloudFormation.Paginators.DescribeStacks(
new DescribeStacksRequest());
await foreach (Stack stack in paginatorForDescribeStacks.Stacks)
{
// Basic information for each stack
Console.WriteLine("\n------------------------------------------------");
Console.WriteLine($"\nStack: {stack.StackName}");
Console.WriteLine($" Status: {stack.StackStatus.Value}");
Console.WriteLine($" Created: {stack.CreationTime}");
// The tags of each stack (etc.)
if (stack.Tags.Count > 0)
{
Console.WriteLine(" Tags:");
foreach (Tag tag in stack.Tags)
Console.WriteLine($" {tag.Key}, {tag.Value}");
}
// The resources of each stack
DescribeStackResourcesResponse responseDescribeResources =
await _amazonCloudFormation.DescribeStackResourcesAsync(
new DescribeStackResourcesRequest
{
StackName = stack.StackName
});
if (responseDescribeResources.StackResources.Count > 0)
{
Console.WriteLine(" Resources:");
foreach (StackResource resource in responseDescribeResources
.StackResources)
Console.WriteLine(
$" {resource.LogicalResourceId}: {resource.ResourceStatus}");
}
}
Console.WriteLine("\n------------------------------------------------");
return true;
}
catch (AmazonCloudFormationException ex)
{
Console.WriteLine("Unable to get stack information:\n" + ex.Message);
return false;
}
catch (AmazonServiceException ex)
{
if (ex.Message.Contains("Unable to get IAM security credentials"))
{
Console.WriteLine(ex.Message);
Console.WriteLine("If you are usnig SSO, be sure to install" +
" the AWSSDK.SSO and AWSSDK.SSOOIDC packages.");
}
else
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
return false;
}
catch (ArgumentNullException ex)
{
if (ex.Message.Contains("Options property cannot be empty: ClientName"))
{
Console.WriteLine(ex.Message);
Console.WriteLine("If you are using SSO, have you logged in?");
}
else
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
return false;
}
}
```
# Authentification des utilisateurs avec Amazon Cognito
Amazon Cognito
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
À l'aide d'Amazon Cognito Identity, vous pouvez créer des identités uniques pour vos utilisateurs et les authentifier pour un accès sécurisé à vos AWS ressources telles qu'Amazon S3 ou Amazon DynamoDB. Amazon Cognito Identity prend en charge les fournisseurs d'identité publics tels qu'Amazon, Facebook, Twitter/Digits, Google ou tout autre fournisseur compatible avec OpenID Connect, ainsi que les identités non authentifiées. Amazon Cognito prend également en charge les [identités authentifiées par les développeurs](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities/), qui vous permettent d'enregistrer et d'authentifier les utilisateurs à l'aide de votre propre processus d'authentification principal, tout en utilisant Amazon Cognito Sync pour synchroniser les données utilisateur et accéder aux ressources. AWS
Pour plus d'informations sur [Amazon Cognito](https://aws.amazon.com/cognito/), consultez le guide du développeur [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/).
Les exemples de code suivants montrent comment utiliser facilement Amazon Cognito Identity. L'[Fournisseur d'informations d'identification](cognito-creds-provider.md)exemple montre comment créer et authentifier les identités des utilisateurs. L'[CognitoAuthentication bibliothèque d'extensions](cognito-authentication-extension.md)exemple montre comment utiliser la bibliothèque d' CognitoAuthentication extensions pour authentifier les groupes d'utilisateurs Amazon Cognito.
**Topics**
+ [Fournisseur d'informations d'identification](cognito-creds-provider.md)
+ [CognitoAuthentication bibliothèque d'extensions](cognito-authentication-extension.md)
# Fournisseur d'identifiants Amazon Cognito
Fournisseur d'informations d'identification
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
`Amazon.CognitoIdentity.CognitoAWSCredentials`, qui se trouve dans le [AWSSDK. CognitoIdentity](https://www.nuget.org/packages/AWSSDK.CognitoIdentity/) NuGetpackage, est un objet d'identification qui utilise Amazon Cognito et the AWS Security Token Service (AWS STS) pour récupérer les informations d'identification pour passer AWS des appels.
La première étape de configuration de `CognitoAWSCredentials` consiste à créer un « groupe d'identités ». Un groupe d'identités est un magasin d'informations relatives à l'identité de l'utilisateur qui est 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 application sur un téléphone, puis passe à une tablette, les informations de l'application restent disponibles pour cet utilisateur. Vous pouvez créer un nouveau pool d'identités depuis la console Amazon Cognito. Si vous utilisez la console, 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 votre compte.
+ L'ARN du rôle non authentifié – Un rôle que les utilisateurs non authentifiés assumeront. Par exemple, ce rô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 des autorisations plus étendues à vos données.
## Configurer Cognito AWSCredentials
L'exemple de code suivant montre comment procéder à la configuration`CognitoAWSCredentials`, que vous pouvez ensuite utiliser pour appeler Amazon S3 en tant qu'utilisateur non authentifié. Cela vous permet d'effectuer des appels avec seulement un volume minimum de données requises pour authentifier l'utilisateur. Les autorisations utilisateur sont contrôlées par le rôle. Vous pouvez donc configurer l'accès selon 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();
}
```
## Utiliser AWS en tant qu'utilisateur non authentifié
L'exemple de code suivant montre comment vous pouvez commencer à utiliser en AWS tant qu'utilisateur non authentifié, puis vous authentifier via Facebook et mettre à jour les informations d'identification pour utiliser les informations d'identification Facebook. En utilisant cette approche, vous pouvez accorder différentes capacités aux utilisateurs authentifiés via le rôle authentifié. Par exemple, votre application de téléphone peut autoriser des utilisateurs à afficher un contenu de manière anonyme, mais leur permet de publier s'ils sont connectés avec un ou plusieurs des fournisseurs configurés.
```
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
accountId, identityPoolId,
unAuthRoleArn, // Role for unauthenticated users
authRoleArn, // Role for authenticated users
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 avec l'objet `AmazonCognitoSyncClient` qui fait partie du kit AWS SDK pour .NET. Si vous utilisez les deux `AmazonCognitoSyncClient` et`CognitoAWSCredentials`, vous n'avez pas à spécifier les `IdentityId` propriétés `IdentityPoolId` et lorsque vous passez des appels avec le`AmazonCognitoSyncClient`. Ces propriétés sont automatiquement renseignées à partir de `CognitoAWSCredentials`. L'exemple de code suivant illustre ceci, ainsi qu'un événement qui vous informe chaque fois que `IdentityId` pour `CognitoAWSCredentials` est modifié. `IdentityId` peut changer dans certains cas, par exemple lors du passage d'un utilisateur non authentifié à un utilisateur authentifié.
```
CognitoAWSCredentials credentials = GetCognitoAWSCredentials();
// Log identity changes
credentials.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 bibliothèques d' CognitoAuthentication extensions Amazon
CognitoAuthentication bibliothèque d'extensions
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
La bibliothèque d' CognitoAuthentication extensions, qui se trouve dans le dossier [Amazon.Extensions. CognitoAuthentication](https://www.nuget.org/packages/Amazon.Extensions.CognitoAuthentication/) NuGet package, simplifie le processus d'authentification des groupes d'utilisateurs Amazon Cognito pour les développeurs .NET Core et Xamarin. La bibliothèque repose sur l'API du fournisseur d'identité Amazon Cognito pour créer et envoyer des appels d'API d'authentification utilisateur.
## Utilisation de la bibliothèque d' CognitoAuthentication extensions
Amazon Cognito intègre des `ChallengeName` valeurs `AuthFlow` et des valeurs pour un flux d'authentification standard permettant de valider le nom d'utilisateur et le mot de passe via le Secure Remote Password (SRP). Pour plus d'informations sur le flux d'authentification, consultez [Flux d'authentification du groupe d'utilisateurs Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html).
Les exemples suivant nécessitent ces instructions `using` :
```
// Required for all examples
using System;
using Amazon;
using Amazon.CognitoIdentity;
using Amazon.CognitoIdentityProvider;
using Amazon.Extensions.CognitoAuthentication;
using Amazon.Runtime;
// Required for the GetS3BucketsAsync example
using Amazon.S3;
using Amazon.S3.Model;
```
### Utiliser l'authentification de base
Créez un [AmazonCognitoIdentityProviderClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CognitoIdentityProvider/TCognitoIdentityProviderClient.html)en utilisant [Anonymous AWSCredentials](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Runtime/TAnonymousAWSCredentials.html), qui ne nécessite pas de demandes signées. Vous n'avez pas besoin de fournir une région ; le code sous-jacent appelle `FallbackRegionFactory.GetRegionEndpoint()` si aucune région n'est indiquée. Créez des objets `CognitoUserPool` et `CognitoUser`. Appelez la méthode `StartWithSrpAuthAsync` avec une demande `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;
}
```
### Authentifiez-vous en relevant les défis
Il est également plus simple de poursuivre le flux d'authentification avec NewPasswordRequired des défis tels que l'authentification multifactorielle (MFA). Les seules exigences sont les CognitoAuthentication objets, le mot de passe de l'utilisateur pour le SRP et les informations nécessaires pour le prochain défi, qui sont acquises après avoir invité l'utilisateur à les saisir. Le code suivant montre un moyen de vérifier le type de défi et d'obtenir les réponses appropriées pour le MFA et les NewPasswordRequired défis pendant le flux d'authentification.
Effectuez une authentification de base comme auparavant, et attendez (`await`) une réponse `AuthFlowResponse`. Lorsque la réponse est reçue, parcourez l'objet `AuthenticationResult` renvoyé. Si le type `ChallengeName` est `NEW_PASSWORD_REQUIRED`, appelez la méthode `RespondToNewPasswordRequiredAsync`.
```
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.");
}
}
```
### Utiliser AWS les ressources après l'authentification
Une fois qu'un utilisateur est authentifié à l'aide de la CognitoAuthentication bibliothèque, l'étape suivante consiste à lui permettre d'accéder aux AWS ressources appropriées. Pour ce faire, vous devez créer un pool d'identités via la console Amazon Cognito Federated Identities. En spécifiant le groupe d'utilisateurs Amazon Cognito que vous avez créé en tant que fournisseur, à l'aide de son pool et de son ID client, vous pouvez autoriser les utilisateurs de votre groupe d'utilisateurs Amazon Cognito à accéder aux ressources connectées à votre compte. AWS Vous pouvez également spécifier des rôles différents pour permettre aux utilisateurs non authentifiés et authentifiés d'accéder à des ressources différentes. Vous pouvez modifier ces règles dans la console IAM, où vous pouvez ajouter ou supprimer des autorisations dans le champ **Action** de la stratégie attachée du rôle. Ensuite, en utilisant le groupe d'identités, le groupe d'utilisateurs et les informations utilisateur Amazon Cognito appropriés, vous pouvez passer des appels vers différentes AWS ressources. L'exemple suivant montre un utilisateur authentifié par SRP accédant aux différents compartiments Amazon S3 autorisés par le rôle du pool 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);
}
}
}
```
## Options d'authentification supplémentaires
Outre le SRP et le MFA NewPasswordRequired, CognitoAuthentication la bibliothèque d'extensions facilite le flux d'authentification pour :
+ Personnalisé - Initier avec un appel à `StartWithCustomAuthAsync(InitiateCustomAuthRequest customRequest)`
+ RefreshToken - Commencez par un appel à `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ RefreshTokenSRP - Initiez par un appel à `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ AdminNoSRP - Initiez par un appel à `StartWithAdminNoSrpAuthAsync(InitiateAdminNoSrpAuthRequest adminAuthRequest)`
Appelez la méthode appropriée selon le flux souhaité. Continuez ensuite à interroger l'utilisateur avec des stimulations comme elles sont présentées dans les objets `AuthFlowResponse` de chaque appel de méthode. Appelez également la méthode de réponse appropriée, comme `RespondToSmsMfaAuthAsync` pour les stimulations MFA et `RespondToCustomAuthAsync` pour les stimulations personnalisées.
# Utilisation des bases de données NoSQL Amazon DynamoDB
DynamoDB
**Note**
Les modèles de programmation décrits dans ces rubriques sont présents à la fois dans .NET Framework et .NET (Core), mais les conventions d'appel diffèrent, qu'elles soient synchrones ou asynchrones.
Il AWS SDK pour .NET prend en charge Amazon DynamoDB, un service de base de données NoSQL rapide proposé par. AWS*Le SDK fournit trois modèles de programmation pour communiquer avec DynamoDB : *le modèle de bas niveau, le* modèle de document et *le* modèle de persistance des objets.*
Les informations suivantes présentent ces modèles et les leurs APIs, fournissent des exemples expliquant comment et quand les utiliser, et vous proposent des liens vers des ressources de programmation DynamoDB supplémentaires dans le. AWS SDK pour .NET
## Modèle de bas niveau
Le modèle de programmation de bas niveau englobe les appels directs au service DynamoDB. Vous pouvez accéder à ce modèle via l'espace de noms [Amazon.Dynamo. DBv2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/NDynamoDBv2.html)
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, modifier une table et insérer des éléments dans une table dans DynamoDB.
### Création d'une table
L'exemple suivant utilise la méthode `CreateTable` de la classe `AmazonDynamoDBClient` pour créer une table. La méthode `CreateTable` utilise une instance de la classe `CreateTableRequest`, qui contient des caractéristiques telles que des noms d'attribut d'élément requis, une définition de clé primaire et une capacité de débit. La méthode `CreateTable` renvoie une instance de la classe `CreateTableResponse`.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
Console.WriteLine("Getting list of tables");
List currentTables = client.ListTables().TableNames;
Console.WriteLine("Number of tables: " + currentTables.Count);
if (!currentTables.Contains("AnimalsInventory"))
{
var request = new CreateTableRequest
{
TableName = "AnimalsInventory",
AttributeDefinitions = new List
{
new AttributeDefinition
{
AttributeName = "Id",
// "S" = string, "N" = number, and so on.
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Type",
AttributeType = "S"
}
},
KeySchema = new List
{
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 modification
Pour pouvoir remplacer ou modifier une table, celle-ci doit être prête pour cette opération. L'exemple suivant montre comment utiliser le modèle de bas niveau pour vérifier qu'une table est prête dans DynamoDB. Dans cet exemple, la table cible à vérifier est référencée par l'intermédiaire de la méthode `DescribeTable` de la classe `AmazonDynamoDBClient`. Toutes les cinq secondes, le code vérifie la valeur 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;
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 table
Dans l'exemple suivant, vous utilisez le modèle de bas niveau pour insérer deux éléments dans une table de DynamoDB. Chaque élément est inséré par l'intermédiaire de la méthode `PutItem` de la classe `AmazonDynamoDBClient`, en utilisant une instance de la classe `PutItemRequest`. Chacune des deux instances de la classe `PutItemRequest` prend le nom de la table dans laquelle les éléments seront insé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
{
{ "Id", new AttributeValue { N = "1" }},
{ "Type", new AttributeValue { S = "Dog" }},
{ "Name", new AttributeValue { S = "Fido" }}
}
};
var request2 = new PutItemRequest
{
TableName = "AnimalsInventory",
Item = new Dictionary
{
{ "Id", new AttributeValue { N = "2" }},
{ "Type", new AttributeValue { S = "Cat" }},
{ "Name", new AttributeValue { S = "Patches" }}
}
};
client.PutItem(request1);
client.PutItem(request2);
```
## Modèle de document
Le modèle de programmation de documents permet de travailler plus facilement avec les données dans DynamoDB. Ce modèle est particulièrement conçu pour l'accès aux tables et aux éléments des tables. Vous pouvez accéder à ce modèle par le biais d'[Amazon.Dynamo. DBv2 DocumentModel](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/NDynamoDBv2DocumentModel.html)espace de noms.
Comparé au modèle de programmation de bas niveau, le modèle de document est plus facile à coder à partir des données DynamoDB. Par exemple, il n'est pas nécessaire de convertir autant de types de données .NET en leurs équivalents dans DynamoDB. Toutefois, ce modèle ne donne pas accès à autant de fonctions que le modèle de programmation de bas niveau. Par exemple, vous pouvez utiliser ce modèle pour créer, extraire, mettre à jour et supprimer des éléments dans des tables. Toutefois, pour créer les tables, vous devez utiliser le modèle de bas niveau. Comparé au modèle de persistance des objets, ce modèle nécessite davantage de programmation pour stocker, charger et interroger des objets .NET.
Pour plus d'informations sur le modèle de programmation de documents DynamoDB, [consultez .NET : modèle de document dans le](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html) manuel Amazon [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Developer Guide.
Les sections suivantes fournissent des informations sur la création d'une représentation de la table DynamoDB souhaitée, ainsi que des exemples sur la manière d'utiliser le modèle de document pour insérer des éléments dans des tableaux et obtenir des éléments à partir de tableaux.
### Création d'une représentation de la table
Pour effectuer des opérations sur les données à l'aide du modèle de document, vous devez d'abord créer une instance de la `Table` classe qui représente une table spécifique. Il existe deux méthodes principales pour ce faire.
**LoadTable méthode**
Le premier mécanisme consiste à utiliser l'une des `LoadTable` méthodes statiques de la [https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTable.html](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTable.html)classe, comme dans l'exemple suivant :
```
var client = new AmazonDynamoDBClient();
Table table = Table.LoadTable(client, "Reply");
```
**Note**
Bien que ce mécanisme fonctionne, dans certaines conditions, il peut parfois entraîner une latence supplémentaire ou des blocages en raison des comportements de démarrage à froid et de pool de threads. Pour plus d'informations sur ces comportements, consultez le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET
**TableBuilder**
Un mécanisme alternatif, la [https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTableBuilder.html)classe, a été introduit dans la [version 3.7.203 du package AWSSDK DBv2 NuGet .Dynamo](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203). Ce mécanisme peut remédier aux comportements mentionnés ci-dessus en supprimant certains appels de méthode implicites, en particulier la `DescribeTable` méthode. Ce mécanisme est utilisé de la même manière que dans l'exemple suivant :
```
var client = new AmazonDynamoDBClient();
var table = new TableBuilder(client, "Reply")
.AddHashKey("Id", DynamoDBEntryType.String)
.AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
.AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String, "Message", DynamoDBEntryType.String)
.Build();
```
Pour plus d'informations sur ce mécanisme alternatif, consultez à nouveau le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET
### Insertion d'un élément dans un tableau
Dans l'exemple suivant, une réponse est insérée dans la table Reply via la `PutItemAsync` méthode de la `Table` classe. La méthode `PutItemAsync` prend une instance de la classe `Document` ; la classe `Document` est simplement une collection d'attributs initialisés.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
// Create a representation of the "Reply" table
// by using one of the mechanisms described previously.
// Then, add a reply to the table.
var newReply = new Document();
newReply["Id"] = Guid.NewGuid().ToString();
newReply["ReplyDateTime"] = DateTime.UtcNow;
newReply["PostedBy"] = "Author1";
newReply["Message"] = "Thank you!";
await table.PutItemAsync(newReply);
```
### Obtenir un élément d'une table
Dans l'exemple suivant, une réponse est récupérée via la `GetItemAsync` méthode de la `Table` classe. Pour déterminer la réponse à obtenir, la `GetItemAsync` méthode utilise la clé hash-and-range primaire de la réponse cible.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DocumentModel;
// Create a representation of the "Reply" table
// by using one of the mechanisms described previously.
// Then, get a reply from the table
// where "guid" is the hash key and "datetime" is the range key.
var reply = await table.GetItemAsync(guid, datetime);
Console.WriteLine("Id = " + reply["Id"]);
Console.WriteLine("ReplyDateTime = " + reply["ReplyDateTime"]);
Console.WriteLine("PostedBy = " + reply["PostedBy"]);
Console.WriteLine("Message = " + reply["Message"]);
```
L'exemple précédent convertit implicitement les valeurs de table en chaînes pour la `WriteLine` méthode. Vous pouvez effectuer des conversions explicites en utilisant les différentes méthodes « As [type] » de la `DynamoDBEntry` classe. Par exemple, vous pouvez convertir explicitement la valeur d'un type `Id` de `Primitive` données en GUID par le biais de la `AsGuid()` méthode suivante :
```
var guid = reply["Id"].AsGuid();
```
## Modèle de persistance des objets
Le modèle de programmation de persistance des objets est spécialement conçu pour stocker, charger et interroger des objets .NET dans DynamoDB. Vous pouvez accéder à ce modèle par le biais d'[Amazon.Dynamo. DBv2 DataModel](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/NDynamoDBv2DataModel.html)espace de noms.
Parmi les trois modèles, le modèle de persistance des objets est le plus facile à utiliser pour coder lorsque vous stockez, chargez ou interrogez des données DynamoDB. Par exemple, vous travaillez directement avec les types de données DynamoDB. Toutefois, ce modèle permet d'accéder uniquement aux opérations qui stockent, chargent et interrogent des objets .NET dans DynamoDB. Par exemple, vous pouvez 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 ce modèle pour mapper vos classes .NET avec les tables.
Pour plus d'informations sur le modèle de programmation de persistance des objets DynamoDB, [consultez .NET : modèle de persistance des objets](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html) dans le manuel Amazon [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Developer Guide.
Les exemples suivants montrent comment définir une classe .NET qui représente un élément DynamoDB, utiliser une instance de la classe .NET pour insérer un élément dans une table DynamoDB et utiliser une instance de la classe .NET pour obtenir un élément de la table.
### Définition d'une classe .NET qui représente un élément d'une table
Dans l'exemple suivant de définition de classe, l'`DynamoDBTable`attribut indique le nom de la table, tandis que les `DynamoDBRangeKey` attributs `DynamoDBHashKey` et modélisent la clé hash-and-range primaire de la table. L'`DynamoDBGlobalSecondaryIndexHashKey`attribut est défini de telle sorte qu'une requête de réponses par un auteur spécifique puisse être créée.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
[DynamoDBTable("Reply")]
public class Reply
{
[DynamoDBHashKey]
public string Id { get; set; }
[DynamoDBRangeKey(StoreAsEpoch = false)]
public DateTime ReplyDateTime { get; set; }
[DynamoDBGlobalSecondaryIndexHashKey("PostedBy-Message-Index",
AttributeName ="PostedBy")]
public string Author { get; set; }
[DynamoDBGlobalSecondaryIndexRangeKey("PostedBy-Message-Index")]
public string Message { get; set; }
}
```
### Création d'un contexte pour le modèle de persistance des objets
Pour utiliser le modèle de programmation de persistance des objets pour DynamoDB, vous devez créer un contexte qui fournit une connexion à DynamoDB et vous permet d'accéder à des tables, d'effectuer diverses opérations et d'exécuter des requêtes.
**Contexte de base**
L'exemple suivant montre comment créer le contexte le plus élémentaire.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
```
**Contexte lié à DisableFetchingTableMetadata la propriété**
L'exemple suivant montre comment vous pouvez également définir la `DisableFetchingTableMetadata` propriété de la `DynamoDBContextConfig` classe pour empêcher les appels implicites à la `DescribeTable` méthode.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client, new DynamoDBContextConfig
{
DisableFetchingTableMetadata = true
});
```
Si la `DisableFetchingTableMetadata` propriété est définie sur `false` (valeur par défaut), comme indiqué dans le premier exemple, vous pouvez omettre les attributs décrivant la structure de clé et d'index des éléments de table dans la `Reply` classe. Ces attributs seront plutôt déduits par un appel implicite à la `DescribeTable` méthode. `DisableFetchingTableMetadata`Il est défini sur`true`, comme indiqué dans le deuxième exemple, sur les méthodes du modèle de persistance des objets telles que `SaveAsync` et `QueryAsync` s'appuyant entièrement sur les attributs définis dans la `Reply` classe. Dans ce cas, aucun appel à la `DescribeTable` méthode n'a lieu.
**Note**
Dans certaines conditions, les appels à la `DescribeTable` méthode peuvent parfois entraîner une latence supplémentaire ou des blocages en raison des comportements de démarrage à froid et de pool de threads. Pour cette raison, il est parfois avantageux d'éviter d'avoir recours à cette méthode.
Pour plus d'informations sur ces comportements, consultez le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET
### Utilisation d'une instance de la classe .NET pour insérer un élément dans un tableau
Dans cet exemple, un élément est inséré par le biais de la `SaveAsync` méthode de la `DynamoDBContext` classe, qui prend une instance initialisée de la classe .NET qui représente l'élément.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
// Create an appropriate context for the object persistence programming model,
// examples of which have been described earlier.
// Create an object that represents the new item.
var reply = new Reply()
{
Id = Guid.NewGuid().ToString(),
ReplyDateTime = DateTime.UtcNow,
Author = "Author1",
Message = "Thank you!"
};
// Insert the item into the table.
await context.SaveAsync(reply, new DynamoDBOperationConfig
{
IndexName = "PostedBy-Message-index"
});
```
### Utilisation d'une instance d'une classe .NET pour obtenir des éléments d'une table
Dans cet exemple, une requête est créée pour trouver tous les enregistrements de « Author1" en utilisant la `QueryAsync` méthode de la `DynamoDBContext` classe. Ensuite, les éléments sont récupérés via la `GetNextSetAsync` méthode de la requête.
```
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;
// Create an appropriate context for the object persistence programming model,
// examples of which have been described earlier.
// Construct a query that finds all replies by a specific author.
var query = context.QueryAsync("Author1", new DynamoDBOperationConfig
{
IndexName = "PostedBy-Message-index"
});
// Display the result.
var set = await query.GetNextSetAsync();
foreach (var item in set)
{
Console.WriteLine("Id = " + item.Id);
Console.WriteLine("ReplyDateTime = " + item.ReplyDateTime);
Console.WriteLine("PostedBy = " + item.Author);
Console.WriteLine("Message = " + item.Message);
}
```
### Informations supplémentaires sur le modèle de persistance des objets
Les exemples et explications présentés ci-dessus incluent parfois une propriété de la `DynamoDBContext` classe appelée`DisableFetchingTableMetadata`. Cette propriété, qui a été introduite dans la [version 3.7.203 du DBv2 NuGet package AWSSDK .Dynamo](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203), vous permet d'éviter certaines conditions susceptibles d'entraîner une latence ou des blocages supplémentaires en raison des comportements de démarrage à froid et de pool de threads. Pour plus d'informations, consultez le billet de blog Modèles d'[initialisation DynamoDB améliorés](https://aws.amazon.com/blogs/developer/improved-dynamodb-initialization-patterns-for-the-aws-sdk-for-net/) pour le. AWS SDK pour .NET
Vous trouverez ci-dessous des informations supplémentaires sur cette propriété.
+ Cette propriété peut être définie globalement dans votre `web.config` fichier `app.config` or si vous utilisez .NET Framework.
+ Cette propriété peut être définie globalement à l'aide de la [https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Amazon/TAWSConfigsDynamoDB.html](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Amazon/TAWSConfigsDynamoDB.html)classe, comme illustré dans l'exemple suivant.
```
// Set the DisableFetchingTableMetadata property globally
// before constructing any context objects.
AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
```
+ Dans certains cas, vous ne pouvez pas ajouter d'attributs DynamoDB à une classe .NET, par exemple si la classe est définie dans une dépendance. Dans de tels cas, il est toujours possible de profiter de la `DisableFetchingTableMetadata` propriété. Pour ce faire, utilisez la [https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTableBuilder.html](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/DynamoDBv2/TTableBuilder.html)classe en plus de la `DisableFetchingTableMetadata` propriété. La `TableBuilder` classe a également été introduite dans la [version 3.7.203 du package AWSSDK .Dynamo. DBv2 NuGet ](https://www.nuget.org/packages/AWSSDK.DynamoDBv2/3.7.203)
```
// Set the DisableFetchingTableMetadata property globally
// before constructing any context objects.
AWSConfigsDynamoDB.Context.DisableFetchingTableMetadata = true;
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
var table = new TableBuilder(client, "Reply")
.AddHashKey("Id", DynamoDBEntryType.String)
.AddRangeKey("ReplyDateTime", DynamoDBEntryType.String)
.AddGlobalSecondaryIndex("PostedBy-Message-index", "Author", DynamoDBEntryType.String,
"Message", DynamoDBEntryType.String)
.Build();
// This registers the "Reply" table we constructed via the builder.
context.RegisterTableDefinition(table);
// Now operations like this will work,
// even if the Reply class was not annotated with this index.
var query = context.QueryAsync("Author1", new DynamoDBOperationConfig()
{
IndexName = "PostedBy-Message-index"
});
```
## En savoir plus
**Utilisation du AWS SDK pour .NET pour programmer DynamoDB, informations et exemples**
+ [DynamoDB APIs](http://blogs.aws.amazon.com/net/post/Tx17SQHVEMW8MXC/DynamoDB-APIs)
+ [Lancement de DynamoDB Series](http://blogs.aws.amazon.com/net/post/Tx2XQOCY08QMTKO/DynamoDB-Series-Kickoff)
+ [DynamoDB Series - Modèle de document](http://blogs.aws.amazon.com/net/post/Tx2R0WG46GQI1JI/DynamoDB-Series-Document-Model)
+ [DynamoDB Series - Schémas de conversion](http://blogs.aws.amazon.com/net/post/Tx2TCOGWG7ARUH5/DynamoDB-Series-Conversion-Schemas)
+ [DynamoDB Series - Modèle de persistance des objets](http://blogs.aws.amazon.com/net/post/Tx20L86FLMBW51P/DynamoDB-Series-Object-Persistence-Model)
+ [DynamoDB Series - Expressions](http://blogs.aws.amazon.com/net/post/TxZQM7VA9AUZ9L/DynamoDB-Series-Expressions)
+ [Utilisation d'expressions avec Amazon DynamoDB et AWS SDK pour .NET](dynamodb-expressions.md)
+ [Support JSON dans Amazon DynamoDB](dynamodb-json.md)
**Modèle de bas niveau, informations et exemples**
+ [Utilisation de tables à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetWorkingWithTables.html)
+ [Utilisation d'éléments à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html)
+ [Interrogation de tables à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html)
+ [Numérisation de tables à l'aide de l' AWS SDK pour .NET API de bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html)
+ [Utilisation d'index secondaires locaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html)
+ [Utilisation d'index secondaires globaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html)
**Modèle de document, informations et exemples**
+ [Types de données DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes)
+ [Dynamo DBEntry](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TDynamoDBv2DocumentModelDynamoDBEntry.html)
+ [.NET : Modèle de document](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html)
**Modèle de persistance des objets, informations et exemples**
+ [.NET : modèle de persistance des objets](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html)
**Autres informations utiles**
+ Consultez [Intégration AWS à .NET Aspire](aspire-integrations.md) pour plus d'informations sur le développement avec Amazon DynamoDB local via .NET Aspire.
**Topics**
+ [
## Modèle de bas niveau
](#dynamodb-intro-apis-low-level)
+ [
## Modèle de document
](#dynamodb-intro-apis-document)
+ [
## Modèle de persistance des objets
](#dynamodb-intro-apis-object-persistence)
+ [
## En savoir plus
](#dynamodb-intro-more-info)
+ [Utilisation d’expressions](dynamodb-expressions.md)
+ [Prise en charge JSON](dynamodb-json.md)
# Utilisation d'expressions avec Amazon DynamoDB et AWS SDK pour .NET
Utilisation d’expressions
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
Les exemples de code suivants montrent comment utiliser le AWS SDK pour .NET pour programmer DynamoDB avec des expressions. *Les expressions* indiquent les attributs que vous souhaitez lire à partir d'un élément d'une table DynamoDB. Vous utilisez également des expressions lors de l'écriture d'un élément, pour signaler toutes les conditions qui doivent être satisfaites (aussi appelées *mise à jour conditionnelle*) et pour indiquer comment les attributs doivent être mis à jour. Des exemples de mise à jour remplacent 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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.html).
**Topics**
+ [
## Exemples de données
](#dynamodb-expressions-sample-data)
+ [
## Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions
](#dynamodb-expressions-get-item)
+ [
## Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions
](#dynamodb-expressions-query)
+ [
## Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément
](#dynamodb-expressions-scan)
+ [
## Imprimer un élément
](#dynamodb-expressions-print-item)
+ [
## Créer ou remplacer un élément à l'aide d'expressions
](#dynamodb-expressions-put-item)
+ [
## Mettre à jour un élément à l'aide d'expressions
](#dynamodb-expressions-update-item)
+ [
## Supprimer un élément à l'aide d'expressions
](#dynamodb-expressions-delete-item)
+ [
## Plus d'informations
](#dynamodb-expressions-resources)
## Exemples de données
Les exemples de code présentés dans cette rubrique s'appuient sur les deux exemples d'éléments suivants d'une table DynamoDB nommée. `ProductCatalog` Ces éléments décrivent des informations sur les entrées de produit dans un catalogue de magasin de cycles fictif. Ces éléments sont basés sur l'exemple fourni dans [Case Study : A ProductCatalog Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.CaseStudy.html). Les descripteurs de types de données tels que `BOOL`, `L`, `M`, `N`, `NS`, `S` et `SS` correspondent à ceux de [Format de données JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html).
```
{
"Id": {
"N": "205"
},
"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"
}
}
}
]
},
"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"
}
}
},
{
"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 et d'expressions
L'exemple suivant présente la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.GetItem` et un jeu d'expressions pour obtenir, puis imprimer, l'élément pour lequel `Id` est égal à `205`. Seuls les attributs suivants de l'élément sont renvoyés : `Id`, `Title`, `Description`, `Color`, `RelatedItems`, `Pictures` et `ProductReviews`.
```
// 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
{
{ "#pr", "ProductReviews" },
{ "#ri", "RelatedItems" }
},
Key = new Dictionary
{
{ "Id", new AttributeValue { N = "205" } }
},
};
var response = client.GetItem(request);
// 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ésenter l'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](#dynamodb-expressions-print-item).
## Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions
Les exemples suivants présentent la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.Query` et un jeu d'expressions pour obtenir, puis imprimer, l'élément pour lequel `Id` est égal à `301`, mais uniquement si la valeur de `Price` est supérieure à `150`. Seuls les attributs suivants de l'élément sont renvoyés : `Id`, `Title` et l'ensemble des attributs `ThreeStar` dans `ProductReviews`.
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;
var client = new AmazonDynamoDBClient();
var request = new QueryRequest
{
TableName = "ProductCatalog",
KeyConditions = new Dictionary
{
{ "Id", new Condition()
{
ComparisonOperator = ComparisonOperator.EQ,
AttributeValueList = new List
{
new AttributeValue { N = "301" }
}
}
}
},
ProjectionExpression = "Id, Title, #pr.ThreeStar",
ExpressionAttributeNames = new Dictionary
{
{ "#pr", "ProductReviews" },
{ "#p", "Price" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":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. La propriété `ExpressionAttributeNames` spécifie l'espace réservé `#pr` pour représenter l'attribut `ProductReviews` et l'espace réservé `#p` pour représenter l'attribut `Price`. `#pr.ThreeStar` spécifie de retourner uniquement l'attribut `ThreeStar`. La propriété `ExpressionAttributeValues` spécifie l'espace réservé `:val` pour représenter la valeur `150`. La propriété `FilterExpression` spécifie que `#p` (`Price`) doit être supérieur à `:val` (`150`). L'appel à `PrintItem` fait référence à une fonction personnalisée, comme décrit dans [Imprimer un élément](#dynamodb-expressions-print-item).
## Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément
L'exemple suivant présente la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.Scan` et un jeu d'expressions pour obtenir, puis imprimer, l'ensemble des éléments pour lesquels `ProductCategory` est égal à `Bike`. Seuls les attributs suivants de l'élément sont renvoyés : `Id`, `Title` et l'ensemble des 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
{
{ ":catg", new AttributeValue { S = "Bike" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#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. La propriété `ExpressionAttributeNames` spécifie l'espace réservé `#pr` pour représenter l'attribut `ProductReviews` et l'espace réservé `#pc` pour représenter l'attribut `ProductCategory`. La propriété `ExpressionAttributeValues` spécifie l'espace réservé `:catg` pour représenter la valeur `Bike`. La propriété `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](#dynamodb-expressions-print-item).
## Imprimer un élément
L'exemple suivant présente comment imprimer les attributs et les valeurs d'un élément. Cet exemple est utilisé dans les exemples précédents qui montrent comment [Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions](#dynamodb-expressions-get-item), [Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions](#dynamodb-expressions-query) et [Obtention de plusieurs éléments à l'aide d'expressions et d'autres attributs d'élément](#dynamodb-expressions-scan).
```
// using Amazon.DynamoDBv2.Model;
// Writes out an item's attribute keys and values.
public static void PrintItem(Dictionary attrs)
{
foreach (KeyValuePair 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()));
}
// Otherwise, boolean value.
else
{
Console.Write(value.BOOL);
}
Console.Write("\n");
}
```
Dans l'exemple précédent, chaque valeur d'attribut possède plusieurs data-type-specific propriétés qui peuvent être évaluées afin de déterminer le format correct pour imprimer l'attribut. Ces propriétés incluent `B`, `BOOL`, `BS`, `L`, `M`, `N`, `NS`, `NULL`, `S` et `SS`, qui correspondent à celles du [Format de données JSON](DataFormat.html). Pour des propriétés telles que `B`, `N`, `NULL` et `S`, si la propriété correspondante n'est pas `null`, l'attribut est du type de données non `null` correspondant. Pour les propriétés telles que `BS``L`,`M`,`NS`, et`SS`, si la valeur `Count` est supérieure à zéro, l'attribut est du type de non-zero-value données correspondant. Si toutes les data-type-specific propriétés de l'attribut sont égales à zéro `null` ou sont `Count` égales à zéro, l'attribut correspond au type de `BOOL` données.
## Créer ou remplacer un élément à l'aide d'expressions
L'exemple suivant présente la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.PutItem` et un jeu d'expressions pour mettre à jour l'élément pour lequel `Title` est `18-Bicycle 301`. Si cet élément n'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
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":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é `#title` pour représenter l'attribut `Title`. La propriété `ExpressionAttributeValues` spécifie l'espace réservé `:product` pour représenter la valeur `18-Bicycle 301`. La propriété `ConditionExpression` spécifie que `#title` (`Title`) doit être égal à `:product` (`18-Bicycle 301`). L'appel à `CreateItemData` fait ré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 CreateItemData()
{
var itemData = new Dictionary
{
{ "Id", new AttributeValue { N = "301" } },
{ "Title", new AttributeValue { S = "18\" Girl's Bike" } },
{ "BicycleType", new AttributeValue { S = "Road" } },
{ "Brand" , new AttributeValue { S = "Brand-Company C" } },
{ "Color", new AttributeValue { SS = new List{ "Blue", "Silver" } } },
{ "Description", new AttributeValue { S = "301 description" } },
{ "Gender", new AttributeValue { S = "F" } },
{ "InStock", new AttributeValue { BOOL = true } },
{ "Pictures", new AttributeValue { L = new List{
{ new AttributeValue { M = new Dictionary{
{ "FrontView", new AttributeValue { S = "http://example/products/301_front.jpg" } } } } },
{ new AttributeValue { M = new Dictionary{
{ "RearView", new AttributeValue {S = "http://example/products/301_rear.jpg" } } } } },
{ new AttributeValue { M = new Dictionary{
{ "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{
{ "FiveStar", new AttributeValue { SS = new List{
"My daughter really enjoyed this bike!" } } },
{ "OneStar", new AttributeValue { SS = new List{
"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{ "979", "822", "801" } } }
};
return itemData;
}
```
Dans l'exemple précédent, un exemple d'élément avec des exemples de données est renvoyé au mandataire. Une série d'attributs et de valeurs correspondantes est construite, à l'aide des types de données tels que `BOOL`, `L`, `M`, `N`, `NS`, `S` et `SS`, qui correspondent à ceux du [format de données JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html).
## Mettre à jour un élément à l'aide d'expressions
L'exemple suivant présente la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.UpdateItem` et 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
{
{ "Id", new AttributeValue { N = "301" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":newproduct", new AttributeValue { S = "18\" Girl's Bike" } }
},
UpdateExpression = "SET #title = :newproduct"
};
client.UpdateItem(request);
```
Dans l'exemple précédent, la propriété `ExpressionAttributeNames` spécifie l'espace réservé `#title` pour représenter l'attribut `Title`. La propriété `ExpressionAttributeValues` spécifie l'espace réservé `:newproduct` pour représenter la valeur `18" Girl's Bike`. La propriété `UpdateExpression` spécifie de modifier `#title` (`Title`) en `:newproduct` (`18" Girl's Bike`).
## Supprimer un élément à l'aide d'expressions
L'exemple suivant présente la méthode `Amazon.DynamoDBv2.AmazonDynamoDBClient.DeleteItem` et 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
{
{ "Id", new AttributeValue { N = "301" } }
},
ExpressionAttributeNames = new Dictionary
{
{ "#title", "Title" }
},
ExpressionAttributeValues = new Dictionary
{
{ ":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é `#title` pour représenter l'attribut `Title`. La propriété `ExpressionAttributeValues` spécifie l'espace réservé `:product` pour représenter la valeur `18-Bicycle 301`. La propriété `ConditionExpression` spécifie que `#title` (`Title`) doit être égal à `:product` (`18-Bicycle 301`).
## Plus d'informations
Pour plus d'informations et des exemples de code, consultez :
+ [DynamoDB Series - Expressions](http://blogs.aws.amazon.com/net/post/TxZQM7VA9AUZ9L/DynamoDB-Series-Expressions)
+ [Accès à des attributs d'élément avec des expressions de projections](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
+ [Utilisation d'espaces réservés pour valeurs et noms d'attributs](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html)
+ [Spécification de conditions avec des expressions de condition](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
+ [Modification d'éléments et d'attributs avec des expressions de mises à jour](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html)
+ [Utilisation d'éléments à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetItemCRUD.html)
+ [Interrogation de tables à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetQuerying.html)
+ [Numérisation de tables à l'aide de l' AWS SDK pour .NET API de bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetScanning.html)
+ [Utilisation d'index secondaires locaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSILowLevelDotNet.html)
+ [Utilisation d'index secondaires globaux à l'aide de l'API de AWS SDK pour .NET bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSILowLevelDotNet.html)
# Support JSON dans Amazon DynamoDB
Prise en charge JSON
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
Il AWS SDK pour .NET prend en charge les données JSON lorsque vous travaillez avec Amazon DynamoDB. Cela vous permet d'obtenir plus facilement des données au format JSON à partir de tables DynamoDB et d'y insérer des documents JSON.
**Topics**
+ [
## Obtenir des données à partir d'une table DynamoDB au format JSON
](#dynamodb-json-get-table-data)
+ [
## Insérer des données au format JSON dans une table DynamoDB
](#dynamodb-json-insert-table-data)
+ [
## Conversions des types de données DynamoDB en JSON
](#dynamodb-json-datatypes)
+ [
## Plus d'informations
](#dynamodb-json-more-info)
## Obtenir des données à partir d'une table DynamoDB au format JSON
L'exemple suivant montre 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 en chaîne au format JSON. La méthode `GetItem` de la classe `Table` permet de récupérer cet élément. Pour déterminer l'élément à obtenir, dans cet exemple, la `GetItem` méthode utilise la clé hash-and-range primaire de l'élément cible. Pour déterminer la table à partir de laquelle obtenir l'élément, la `LoadTable` méthode de la `Table` classe utilise une instance de la `AmazonDynamoDBClient` classe et le nom de la table cible dans DynamoDB.
## Insérer des données au format JSON dans une table DynamoDB
L'exemple suivant montre comment utiliser le format JSON pour insérer un élément dans une table DynamoDB :
```
// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.DocumentModel;
var client = new AmazonDynamoDBClient();
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 format JSON en élément. L'élément est inséré dans la table par l'intermédiaire de la méthode `PutItem` de la classe `Table`, qui utilise l'instance de la classe `Document` contenant l'élément. Pour déterminer la table dans laquelle insérer l'élément, la `LoadTable` méthode de la `Table` classe est appelée, en spécifiant une instance de la `AmazonDynamoDBClient` classe et le nom de la table cible dans DynamoDB.
## Conversions des types de données DynamoDB en JSON
Chaque fois que vous appelez la `ToJson` méthode de la `Document` classe, puis que vous appelez la `FromJson` méthode pour reconvertir les données JSON en instance de `Document` classe, certains types de données DynamoDB ne sont pas convertis comme prévu. En particulier :
+ Les ensembles DynamoDB (`SS`les types`NS`, `BS` et) seront convertis en tableaux JSON.
+ Les scalaires et ensembles binaires DynamoDB (`B`les types `BS` et) seront convertis en chaînes JSON codées en base64 ou en listes de chaînes.
Dans ce scénario, il convient d'appeler la méthode `DecodeBase64Attributes` de la classe `Document` pour remplacer les données JSON codées en base64 par la représentation binaire correcte. L'exemple suivant remplace par la représentation binaire correcte un attribut d'élément binary scalar codé en base64 dans une instance d'une classe `Document` nommée `Picture`. Cet exemple procède de même pour un attribut d'élément binary set codé en base64 dans la même instance de la classe `Document` nommée `RelatedPictures` :
```
item.DecodeBase64Attributes("Picture", "RelatedPictures");
```
## Plus d'informations
Pour plus d'informations et des exemples de programmation de JSON avec DynamoDB avec AWS SDK pour .NET le, voir :
+ [Support DynamoDB pour JSON](https://aws.amazon.com/blogs/developer/dynamodb-json-support/)
+ [Mise à jour d'Amazon DynamoDB : JSON, offre gratuite élargie, dimensionnement flexible, éléments plus volumineux](https://aws.amazon.com/blogs/aws/dynamodb-update-json-and-more/)
# Utilisation avec Amazon EC2
Amazon EC2
Il AWS SDK pour .NET prend en charge [Amazon EC2](https://docs.aws.amazon.com/ec2/), un service Web qui fournit une capacité de calcul redimensionnable. Vous utilisez cette capacité de calcul pour créer et héberger vos systèmes logiciels.
## APIs
AWS SDK pour .NET Il fournit des API pour les clients Amazon EC2. Les API vous permettent de travailler avec des fonctionnalités EC2 telles que les groupes de sécurité et les paires de clés. Les API vous permettent également de contrôler les instances Amazon EC2. Cette section contient un petit nombre d'exemples qui vous montrent les modèles que vous pouvez suivre lorsque vous travaillez avec ces outils APIs. Pour voir l'ensemble complet de APIs, consultez la [référence de l'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) (et faites défiler la page jusqu'à « Amazon.ec2 »).
Les Amazon EC2 APIs sont fournis par le package [AWSSDK NuGet .EC2](https://www.nuget.org/packages/AWSSDK.EC2).
## Conditions préalables
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## À propos des exemples
Les exemples présentés dans cette section vous montrent comment travailler avec les clients Amazon EC2 et gérer les instances Amazon EC2.
Le [didacticiel sur les instances Spot EC2](how-to-spot-instances.md) explique comment demander des instances Spot Amazon EC2. Les instances Spot vous permettent d'accéder à de la capacité EC2 inutilisée à un prix inférieur au prix à la demande.
**Topics**
+ [
## APIs
](#w2aac19c15c21b5)
+ [
## Conditions préalables
](#w2aac19c15c21b7)
+ [
## À propos des exemples
](#ec2-apis-intro-about)
+ [Groupes de sécurité](security-groups.md)
+ [Paires de clés](key-pairs.md)
+ [Régions et zones de disponibilité](using-regions-and-availability-zones.md)
+ [Instances EC2](how-to-ec2.md)
+ [Tutoriel Spot Instance](how-to-spot-instances.md)
# Travailler avec des groupes de sécurité dans Amazon EC2
Groupes de sécurité
Dans Amazon EC2, un *groupe de sécurité* agit comme un pare-feu virtuel qui contrôle le trafic réseau pour une ou plusieurs instances EC2. Par défaut, EC2 associe vos instances à un groupe de sécurité qui n'autorise aucun trafic entrant. Vous pouvez créer un groupe de sécurité qui autorise vos instances EC2 à accepter un certain trafic. Par exemple, si vous devez vous connecter à une instance Windows EC2, vous devez configurer le groupe de sécurité afin d'autoriser le trafic RDP.
Pour en savoir plus sur les groupes de sécurité, consultez les groupes de [sécurité Amazon EC2 dans le guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
**Avertissement**
EC2-Classic a été retiré le 15 août 2022. Nous vous recommandons de migrer d'EC2-Classic vers un VPC. Pour plus d'informations, consultez le billet de blog [EC2-Classic Networking is Retiring — Here's How](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) to Prepare.
Pour plus d'informations sur le APIs et les prérequis, consultez la section parent ([Utilisation avec Amazon EC2](ec2-apis-intro.md)).
**Topics**
+ [
# Énumération des groupes de sécurité
](enumerate-security-groups.md)
+ [
# Création de groupes de sécurité
](creating-security-group.md)
+ [
# Mise à jour des groupes de sécurité
](authorize-ingress.md)
# Énumération des groupes de sécurité
Cet exemple montre comment utiliser le pour AWS SDK pour .NET énumérer les groupes de sécurité. Si vous fournissez un [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) ID, l'application énumère les groupes de sécurité pour ce VPC en particulier. Dans le cas contraire, l'application affiche simplement la liste de tous les groupes de sécurité disponibles.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#enum-sec-groups-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Énumérer les groupes de sécurité
](#enum-sec-groups-enum)
+ [
## Code complet
](#enum-sec-groups-complete-code)
+ [
## Considérations supplémentaires
](#enum-sec-groups-additional)
## Énumérer les groupes de sécurité
L'extrait suivant répertorie vos groupes de sécurité. Il énumère tous les groupes ou les groupes d'un VPC en particulier s'il en existe un.
L'exemple [à la fin de cette rubrique](#enum-sec-groups-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to enumerate the security groups
private static async Task EnumerateGroups(IAmazonEC2 ec2Client, string vpcID)
{
// A request object, in case we need it.
var request = new DescribeSecurityGroupsRequest();
// Put together the properties, if needed
if(!string.IsNullOrEmpty(vpcID))
{
// We have a VPC ID. Find the security groups for just that VPC.
Console.WriteLine($"\nGetting security groups for VPC {vpcID}...\n");
request.Filters.Add(new Filter
{
Name = "vpc-id",
Values = new List() { vpcID }
});
}
// Get the list of security groups
DescribeSecurityGroupsResponse response =
await ec2Client.DescribeSecurityGroupsAsync(request);
// Display the list of security groups.
foreach (SecurityGroup item in response.SecurityGroups)
{
Console.WriteLine("Security group: " + item.GroupId);
Console.WriteLine("\tGroupId: " + item.GroupId);
Console.WriteLine("\tGroupName: " + item.GroupName);
Console.WriteLine("\tVpcId: " + item.VpcId);
Console.WriteLine();
}
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Classe [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Filtre](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TFilter.html) de classe
Classe [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TSecurityGroup.html)
### Le code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2EnumerateSecGroups
{
class Program
{
static async Task Main(string[] args)
{
// Parse the command line
string vpcID = string.Empty;
if(args.Length == 0)
{
Console.WriteLine("\nEC2EnumerateSecGroups [vpc_id]");
Console.WriteLine(" vpc_id - The ID of the VPC for which you want to see security groups.");
Console.WriteLine("\nSince you specified no arguments, showing all available security groups.");
}
else
{
vpcID = args[0];
}
if(vpcID.StartsWith("vpc-") || string.IsNullOrEmpty(vpcID))
{
// Create an EC2 client object
var ec2Client = new AmazonEC2Client();
// Enumerate the security groups
await EnumerateGroups(ec2Client, vpcID);
}
else
{
Console.WriteLine("Could not find a valid VPC ID in the command-line arguments:");
Console.WriteLine($"{args[0]}");
}
}
//
// Method to enumerate the security groups
private static async Task EnumerateGroups(IAmazonEC2 ec2Client, string vpcID)
{
// A request object, in case we need it.
var request = new DescribeSecurityGroupsRequest();
// Put together the properties, if needed
if(!string.IsNullOrEmpty(vpcID))
{
// We have a VPC ID. Find the security groups for just that VPC.
Console.WriteLine($"\nGetting security groups for VPC {vpcID}...\n");
request.Filters.Add(new Filter
{
Name = "vpc-id",
Values = new List() { vpcID }
});
}
// Get the list of security groups
DescribeSecurityGroupsResponse response =
await ec2Client.DescribeSecurityGroupsAsync(request);
// Display the list of security groups.
foreach (SecurityGroup item in response.SecurityGroups)
{
Console.WriteLine("Security group: " + item.GroupId);
Console.WriteLine("\tGroupId: " + item.GroupId);
Console.WriteLine("\tGroupName: " + item.GroupName);
Console.WriteLine("\tVpcId: " + item.VpcId);
Console.WriteLine();
}
}
}
}
```
## Considérations supplémentaires
+ Notez que dans le cas d'un VPC, le filtre est construit avec la `Name` partie de la paire nom-valeur définie sur « vpc-id ». Ce nom provient de la description de la `Filters` propriété de la [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)classe.
+ Pour obtenir la liste complète de vos groupes de sécurité, vous pouvez également utiliser [ DescribeSecurityGroupsAsync sans paramètres](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/MEC2DescribeSecurityGroupsAsyncCancellationToken.html).
+ Vous pouvez vérifier les résultats en consultant la liste des groupes de sécurité dans la console [Amazon EC2.](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups)
# Création de groupes de sécurité
Cet exemple montre comment utiliser le AWS SDK pour .NET pour créer un groupe de sécurité. Vous pouvez fournir l'ID d'un VPC existant afin de créer un groupe de sécurité pour EC2 dans un VPC. Si vous ne fournissez pas un tel identifiant, le nouveau groupe de sécurité sera destiné à EC2-Classic si votre AWS compte le permet.
Si vous ne fournissez pas d'identifiant VPC et que votre AWS compte ne prend pas en charge EC2-Classic, le nouveau groupe de sécurité appartiendra au VPC par défaut de votre compte.
**Avertissement**
EC2-Classic a été retiré le 15 août 2022. Nous vous recommandons de migrer d'EC2-Classic vers un VPC. Pour plus d'informations, consultez le billet de blog [EC2-Classic Networking is Retiring — Here's How](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) to Prepare.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#create-sec-groups-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Rechercher des groupes de sécurité existants
](#create-sec-groups-find)
+ [
## Création d’un groupe de sécurité
](#create-sec-groups-enum)
+ [
## Code complet
](#create-sec-groups-complete-code)
## Rechercher des groupes de sécurité existants
L'extrait de code suivant recherche les groupes de sécurité existants portant le nom donné dans le VPC donné.
L'exemple [à la fin de cette rubrique](#create-sec-groups-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to determine if a security group with the specified name
// already exists in the VPC
private static async Task> FindSecurityGroups(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
var request = new DescribeSecurityGroupsRequest();
request.Filters.Add(new Filter{
Name = "group-name",
Values = new List() { groupName }
});
if(!string.IsNullOrEmpty(vpcID))
request.Filters.Add(new Filter{
Name = "vpc-id",
Values = new List() { vpcID }
});
var response = await ec2Client.DescribeSecurityGroupsAsync(request);
return response.SecurityGroups;
}
```
## Création d’un groupe de sécurité
L'extrait suivant crée un nouveau groupe de sécurité si aucun groupe portant ce nom n'existe dans le VPC donné. Si aucun VPC n'est indiqué et qu'un ou plusieurs groupes portant ce nom existent, l'extrait renvoie simplement la liste des groupes.
L'exemple [à la fin de cette rubrique](#create-sec-groups-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to create a new security group (either EC2-Classic or EC2-VPC)
// If vpcID is empty, the security group will be for EC2-Classic
private static async Task> CreateSecurityGroup(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
// See if one or more security groups with that name
// already exist in the given VPC. If so, return the list of them.
var securityGroups = await FindSecurityGroups(ec2Client, groupName, vpcID);
if (securityGroups.Count > 0)
{
Console.WriteLine(
$"\nOne or more security groups with name {groupName} already exist.\n");
return securityGroups;
}
// If the security group doesn't already exists, create it.
var createRequest = new CreateSecurityGroupRequest{
GroupName = groupName
};
if(string.IsNullOrEmpty(vpcID))
{
createRequest.Description = "My .NET example security group for EC2-Classic";
}
else
{
createRequest.VpcId = vpcID;
createRequest.Description = "My .NET example security group for EC2-VPC";
}
CreateSecurityGroupResponse createResponse =
await ec2Client.CreateSecurityGroupAsync(createRequest);
// Return the new security group
DescribeSecurityGroupsResponse describeResponse =
await ec2Client.DescribeSecurityGroupsAsync(new DescribeSecurityGroupsRequest{
GroupIds = new List() { createResponse.GroupId }
});
return describeResponse.SecurityGroups;
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TCreateSecurityGroupRequest.html)
Classe [CreateSecurityGroupResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TCreateSecurityGroupResponse.html)
Classe [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Classe [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Filtre](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TFilter.html) de classe
Classe [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TSecurityGroup.html)
### Le code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2CreateSecGroup
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create a security group
class Program
{
private const int MaxArgs = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
if(parsedArgs.Count > MaxArgs)
CommandLine.ErrorExit("\nThe number of command-line arguments is incorrect." +
"\nRun the command with no arguments to see help.");
// Get the application arguments from the parsed list
var groupName = CommandLine.GetArgument(parsedArgs, null, "-g", "--group-name");
var vpcID = CommandLine.GetArgument(parsedArgs, null, "-v", "--vpc-id");
if(string.IsNullOrEmpty(groupName))
CommandLine.ErrorExit("\nYou must supply a name for the new group." +
"\nRun the command with no arguments to see help.");
if(!string.IsNullOrEmpty(vpcID) && !vpcID.StartsWith("vpc-"))
CommandLine.ErrorExit($"\nNot a valid VPC ID: {vpcID}");
// groupName has a value and vpcID either has a value or is null (which is fine)
// Create the new security group and display information about it
var securityGroups =
await CreateSecurityGroup(new AmazonEC2Client(), groupName, vpcID);
Console.WriteLine("Information about the security group(s):");
foreach(var group in securityGroups)
{
Console.WriteLine($"\nGroupName: {group.GroupName}");
Console.WriteLine($"GroupId: {group.GroupId}");
Console.WriteLine($"Description: {group.Description}");
Console.WriteLine($"VpcId (if any): {group.VpcId}");
}
}
//
// Method to create a new security group (either EC2-Classic or EC2-VPC)
// If vpcID is empty, the security group will be for EC2-Classic
private static async Task> CreateSecurityGroup(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
// See if one or more security groups with that name
// already exist in the given VPC. If so, return the list of them.
var securityGroups = await FindSecurityGroups(ec2Client, groupName, vpcID);
if (securityGroups.Count > 0)
{
Console.WriteLine(
$"\nOne or more security groups with name {groupName} already exist.\n");
return securityGroups;
}
// If the security group doesn't already exists, create it.
var createRequest = new CreateSecurityGroupRequest{
GroupName = groupName
};
if(string.IsNullOrEmpty(vpcID))
{
createRequest.Description = "Security group for .NET code example (no VPC specified)";
}
else
{
createRequest.VpcId = vpcID;
createRequest.Description = "Security group for .NET code example (VPC: " + vpcID + ")";
}
CreateSecurityGroupResponse createResponse =
await ec2Client.CreateSecurityGroupAsync(createRequest);
// Return the new security group
DescribeSecurityGroupsResponse describeResponse =
await ec2Client.DescribeSecurityGroupsAsync(new DescribeSecurityGroupsRequest{
GroupIds = new List() { createResponse.GroupId }
});
return describeResponse.SecurityGroups;
}
//
// Method to determine if a security group with the specified name
// already exists in the VPC
private static async Task> FindSecurityGroups(
IAmazonEC2 ec2Client, string groupName, string vpcID)
{
var request = new DescribeSecurityGroupsRequest();
request.Filters.Add(new Filter{
Name = "group-name",
Values = new List() { groupName }
});
if(!string.IsNullOrEmpty(vpcID))
request.Filters.Add(new Filter{
Name = "vpc-id",
Values = new List() { vpcID }
});
var response = await ec2Client.DescribeSecurityGroupsAsync(request);
return response.SecurityGroups;
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2CreateSecGroup -g [-v ]" +
"\n -g, --group-name: The name you would like the new security group to have." +
"\n -v, --vpc-id: The ID of a VPC to which the new security group will belong." +
"\n If vpc-id isn't present, the security group will be" +
"\n for EC2-Classic (if your AWS account supports this)" +
"\n or will use the default VCP for EC2-VPC.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
# Mise à jour des groupes de sécurité
Cet exemple montre comment utiliser le pour AWS SDK pour .NET ajouter une règle à un groupe de sécurité. En particulier, l'exemple ajoute une règle pour autoriser le trafic entrant sur un port TCP donné, qui peut être utilisée, par exemple, pour les connexions à distance à une instance EC2. L'application prend l'identifiant d'un groupe de sécurité existant, une adresse IP (ou plage d'adresses) au format CIDR et éventuellement un numéro de port TCP. Il ajoute ensuite une règle entrante au groupe de sécurité donné.
**Note**
Pour utiliser cet exemple, vous avez besoin d'une adresse IP (ou d'une plage d'adresses) au format CIDR. Consultez la section **Considérations supplémentaires** à la fin de cette rubrique pour connaître les méthodes permettant d'obtenir l'adresse IP de votre ordinateur local.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#authorize-ingress-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Ajouter une règle de trafic entrant
](#authorize-ingress-add-rule)
+ [
## Code complet
](#authorize-ingress-complete-code)
+ [
## Considérations supplémentaires
](#authorize-ingress-additional)
## Ajouter une règle de trafic entrant
L'extrait suivant ajoute une règle entrante à un groupe de sécurité pour une adresse IP (ou plage) et un port TCP particuliers.
L'exemple [à la fin de cette rubrique](#authorize-ingress-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method that adds a TCP ingress rule to a security group
private static async Task AddIngressRule(
IAmazonEC2 eC2Client, string groupID, string ipAddress, int port)
{
// Create an object to hold the request information for the rule.
// It uses an IpPermission object to hold the IP information for the rule.
var ingressRequest = new AuthorizeSecurityGroupIngressRequest{
GroupId = groupID};
ingressRequest.IpPermissions.Add(new IpPermission{
IpProtocol = "tcp",
FromPort = port,
ToPort = port,
Ipv4Ranges = new List() { new IpRange { CidrIp = ipAddress } }
});
// Create the inbound rule for the security group
AuthorizeSecurityGroupIngressResponse responseIngress =
await eC2Client.AuthorizeSecurityGroupIngressAsync(ingressRequest);
Console.WriteLine($"\nNew RDP rule was written in {groupID} for {ipAddress}.");
Console.WriteLine($"Result: {responseIngress.HttpStatusCode}");
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TAuthorizeSecurityGroupIngressRequest.html)
Classe [AuthorizeSecurityGroupIngressResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TAuthorizeSecurityGroupIngressResponse.html)
Classe [IpPermission](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TIpPermission.html)
Classe [IpRange](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TIpRange.html)
### Le code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2AddRuleForRDP
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to add a rule that allows inbound traffic on TCP a port
class Program
{
private const int DefaultPort = 3389;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
var groupID = CommandLine.GetArgument(parsedArgs, null, "-g", "--group-id");
var ipAddress = CommandLine.GetArgument(parsedArgs, null, "-i", "--ip-address");
var portStr = CommandLine.GetArgument(parsedArgs, DefaultPort.ToString(), "-p", "--port");
if(string.IsNullOrEmpty(ipAddress))
CommandLine.ErrorExit("\nYou must supply an IP address in CIDR format.");
if(string.IsNullOrEmpty(groupID) || !groupID.StartsWith("sg-"))
CommandLine.ErrorExit("\nThe ID for a security group is missing or incorrect.");
if(int.Parse(portStr) == 0)
CommandLine.ErrorExit($"\nThe given TCP port number, {portStr}, isn't allowed.");
// Add a rule to the given security group that allows
// inbound traffic on a TCP port
await AddIngressRule(
new AmazonEC2Client(), groupID, ipAddress, int.Parse(portStr));
}
//
// Method that adds a TCP ingress rule to a security group
private static async Task AddIngressRule(
IAmazonEC2 eC2Client, string groupID, string ipAddress, int port)
{
// Create an object to hold the request information for the rule.
// It uses an IpPermission object to hold the IP information for the rule.
var ingressRequest = new AuthorizeSecurityGroupIngressRequest{
GroupId = groupID};
ingressRequest.IpPermissions.Add(new IpPermission{
IpProtocol = "tcp",
FromPort = port,
ToPort = port,
Ipv4Ranges = new List() { new IpRange { CidrIp = ipAddress } }
});
// Create the inbound rule for the security group
AuthorizeSecurityGroupIngressResponse responseIngress =
await eC2Client.AuthorizeSecurityGroupIngressAsync(ingressRequest);
Console.WriteLine($"\nNew RDP rule was written in {groupID} for {ipAddress}.");
Console.WriteLine($"Result: {responseIngress.HttpStatusCode}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2AddRuleForRDP -g -i [-p ]" +
"\n -g, --group-id: The ID of the security group to which you want to add the inbound rule." +
"\n -i, --ip-address: An IP address or address range in CIDR format." +
"\n -p, --port: The TCP port number. Defaults to 3389.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Si vous ne fournissez pas de numéro de port, l'application utilise par défaut le port 3389. Il s'agit du port pour Windows RDP, qui vous permet de vous connecter à une instance EC2 exécutant Windows. Si vous lancez une instance EC2 exécutant Linux, vous pouvez utiliser le port TCP 22 (SSH) à la place.
+ Notez que l'exemple prend la valeur `IpProtocol` « tcp ». Les valeurs de se `IpProtocol` trouvent dans la description de la `IpProtocol` propriété de la [IpPermission](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TIpPermission.html)classe.
+ Vous aurez peut-être besoin de l'adresse IP de votre ordinateur local lorsque vous utiliserez cet exemple. Voici certains des moyens par lesquels vous pouvez obtenir l'adresse.
+ Si votre ordinateur local (à partir duquel vous allez vous connecter à votre instance EC2) possède une adresse IP publique statique, vous pouvez utiliser un service pour obtenir cette adresse. L'un de ces services est [http://checkip.amazonaws.com/](http://checkip.amazonaws.com/). Pour en savoir plus sur l'autorisation du trafic entrant, consultez les sections [Ajouter des règles à un groupe de sécurité et Règles de groupe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) [de sécurité pour différents cas d'utilisation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
+ Une autre méthode pour obtenir l'adresse IP de votre ordinateur local consiste à utiliser la console [Amazon EC2](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups).
Sélectionnez l'un de vos groupes de sécurité, sélectionnez l'onglet **Règles entrantes**, puis choisissez **Modifier les règles entrantes**. Dans une règle entrante, ouvrez le menu déroulant dans la colonne **Source** et choisissez **Mon adresse IP** pour voir l'adresse IP de votre ordinateur local au format CIDR. Assurez-vous d'**annuler** l'opération.
+ Vous pouvez vérifier les résultats de cet exemple en examinant la liste des groupes de sécurité dans la console [Amazon EC2](https://console.aws.amazon.com/ec2/v2/home#SecurityGroups).
# Utilisation des paires de clés Amazon EC2
Paires de clés
Amazon EC2 utilise le chiffrement à clé publique pour chiffrer et déchiffrer les informations de connexion. Le chiffrement à clé publique utilise une clé publique pour chiffrer les données, puis le destinataire utilise la clé privée pour déchiffrer les données. La clé publique et la clé privée constituent une paire de clés. Si vous souhaitez vous connecter à une instance EC2, vous devez spécifier une paire de clés lorsque vous la lancez, puis fournir la clé privée de la paire lorsque vous vous y connectez.
Lorsque vous lancez une instance EC2, vous pouvez créer une paire de clés pour celle-ci ou utiliser une paire de clés que vous avez déjà utilisée lors du lancement d'autres instances. Pour en savoir plus sur les paires de clés Amazon EC2, consultez la section [Utilisation des paires de clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) dans le guide de l'utilisateur Amazon [EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Pour plus d'informations sur le APIs et les prérequis, consultez la section parent ([Utilisation avec Amazon EC2](ec2-apis-intro.md)).
**Topics**
+ [
# Création et affichage de paires de clés
](create-save-key-pair.md)
+ [
# Supprimer des paires de clés
](delete-key-pairs.md)
# Création et affichage de paires de clés
Création de paires de clés
Cet exemple montre comment utiliser le AWS SDK pour .NET pour créer une paire de clés. L'application prend le nom de la nouvelle paire de clés et le nom d'un fichier PEM (avec une extension « .pem »). Il crée la paire de clés, écrit la clé privée dans le fichier PEM, puis affiche toutes les paires de clés disponibles. Si vous ne fournissez aucun argument de ligne de commande, l'application affiche simplement toutes les paires de clés disponibles.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#create-save-key-pair-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Créer la paire de clés
](#create-save-key-pair-create)
+ [
## Afficher les paires de clés disponibles
](#create-save-key-pair-display)
+ [
## Code complet
](#create-save-key-pair-complete-code)
+ [
## Considérations supplémentaires
](#create-save-key-pair-additional)
## Créer la paire de clés
L'extrait suivant crée une paire de clés, puis stocke la clé privée dans le fichier PEM donné.
L'exemple [à la fin de cette rubrique](#create-save-key-pair-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to create a key pair and save the key material in a PEM file
private static async Task CreateKeyPair(
IAmazonEC2 ec2Client, string keyPairName, string pemFileName)
{
// Create the key pair
CreateKeyPairResponse response =
await ec2Client.CreateKeyPairAsync(new CreateKeyPairRequest{
KeyName = keyPairName
});
Console.WriteLine($"\nCreated new key pair: {response.KeyPair.KeyName}");
// Save the private key in a PEM file
using (var s = new FileStream(pemFileName, FileMode.Create))
using (var writer = new StreamWriter(s))
{
writer.WriteLine(response.KeyPair.KeyMaterial);
}
}
```
## Afficher les paires de clés disponibles
L'extrait suivant affiche la liste des paires de clés disponibles.
L'exemple [à la fin de cette rubrique](#create-save-key-pair-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [CreateKeyPairRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TCreateKeyPairRequest.html)
Classe [CreateKeyPairResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TCreateKeyPairResponse.html)
Classe [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Classe [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TKeyPairInfo.html)
### Le code
```
using System;
using System.Threading.Tasks;
using System.IO;
using Amazon.EC2;
using Amazon.EC2.Model;
using System.Collections.Generic;
namespace EC2CreateKeyPair
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create and store a key pair
class Program
{
static async Task Main(string[] args)
{
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
// In the case of no command-line arguments,
// just show help and the existing key pairs
PrintHelp();
Console.WriteLine("\nNo arguments specified.");
Console.Write(
"Do you want to see a list of the existing key pairs? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await EnumerateKeyPairs(ec2Client);
return;
}
// Get the application arguments from the parsed list
string keyPairName =
CommandLine.GetArgument(parsedArgs, null, "-k", "--keypair-name");
string pemFileName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--pem-filename");
if(string.IsNullOrEmpty(keyPairName))
CommandLine.ErrorExit("\nNo key pair name specified." +
"\nRun the command with no arguments to see help.");
if(string.IsNullOrEmpty(pemFileName) || !pemFileName.EndsWith(".pem"))
CommandLine.ErrorExit("\nThe PEM filename is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the key pair
await CreateKeyPair(ec2Client, keyPairName, pemFileName);
await EnumerateKeyPairs(ec2Client);
}
//
// Method to create a key pair and save the key material in a PEM file
private static async Task CreateKeyPair(
IAmazonEC2 ec2Client, string keyPairName, string pemFileName)
{
// Create the key pair
CreateKeyPairResponse response =
await ec2Client.CreateKeyPairAsync(new CreateKeyPairRequest{
KeyName = keyPairName
});
Console.WriteLine($"\nCreated new key pair: {response.KeyPair.KeyName}");
// Save the private key in a PEM file
using (var s = new FileStream(pemFileName, FileMode.Create))
using (var writer = new StreamWriter(s))
{
writer.WriteLine(response.KeyPair.KeyMaterial);
}
}
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2CreateKeyPair -k -p " +
"\n -k, --keypair-name: The name you want to assign to the key pair." +
"\n -p, --pem-filename: The name of the PEM file to create, with a \".pem\" extension.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Après avoir exécuté l'exemple, vous pouvez voir la nouvelle paire de clés dans la console [Amazon EC2](https://console.aws.amazon.com/ec2/#KeyPairs).
+ Lorsque vous créez une paire de clés, vous devez enregistrer la clé privée renvoyée car vous ne pourrez pas la récupérer ultérieurement.
# Supprimer des paires de clés
Cet exemple montre comment utiliser le AWS SDK pour .NET pour supprimer une paire de clés. L'application prend le nom d'une paire de clés. Il supprime la paire de clés, puis affiche toutes les paires de clés disponibles. Si vous ne fournissez aucun argument de ligne de commande, l'application affiche simplement toutes les paires de clés disponibles.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#delete-key-pairs-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Suppression de la paire de clés
](#delete-key-pairs-create)
+ [
## Afficher les paires de clés disponibles
](#delete-key-pairs-display)
+ [
## Code complet
](#delete-key-pairs-complete-code)
## Suppression de la paire de clés
L'extrait de code suivant supprime une paire de clés.
L'exemple [à la fin de cette rubrique](#delete-key-pairs-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to delete a key pair
private static async Task DeleteKeyPair(IAmazonEC2 ec2Client, string keyName)
{
await ec2Client.DeleteKeyPairAsync(new DeleteKeyPairRequest{
KeyName = keyName});
Console.WriteLine($"\nKey pair {keyName} has been deleted (if it existed).");
}
```
## Afficher les paires de clés disponibles
L'extrait suivant affiche la liste des paires de clés disponibles.
L'exemple [à la fin de cette rubrique](#delete-key-pairs-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [https://docs.aws.amazon.com/sdkfornet/v4/apidocs/](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/)
Classe [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Classe [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TKeyPairInfo.html)
### Le code
```
using System;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2DeleteKeyPair
{
class Program
{
static async Task Main(string[] args)
{
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
if(args.Length == 1)
{
// Delete a key pair (if it exists)
await DeleteKeyPair(ec2Client, args[0]);
// Display the key pairs that are left
await EnumerateKeyPairs(ec2Client);
}
else
{
Console.WriteLine("\nUsage: EC2DeleteKeyPair keypair-name");
Console.WriteLine(" keypair-name - The name of the key pair you want to delete.");
Console.WriteLine("\nNo arguments specified.");
Console.Write(
"Do you want to see a list of the existing key pairs? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await EnumerateKeyPairs(ec2Client);
}
}
//
// Method to delete a key pair
private static async Task DeleteKeyPair(IAmazonEC2 ec2Client, string keyName)
{
await ec2Client.DeleteKeyPairAsync(new DeleteKeyPairRequest{
KeyName = keyName});
Console.WriteLine($"\nKey pair {keyName} has been deleted (if it existed).");
}
//
// Method to show the key pairs that are available
private static async Task EnumerateKeyPairs(IAmazonEC2 ec2Client)
{
DescribeKeyPairsResponse response = await ec2Client.DescribeKeyPairsAsync();
Console.WriteLine("Available key pairs:");
foreach (KeyPairInfo item in response.KeyPairs)
Console.WriteLine($" {item.KeyName}");
}
}
}
```
# Afficher vos régions et zones de disponibilité Amazon EC2
Régions et zones de disponibilité
Amazon EC2 est hébergé sur plusieurs sites dans le monde entier. Ces emplacements sont composés de régions et de zones de disponibilité. Chaque région est une zone géographique distincte qui compte plusieurs emplacements isolés appelés zones de disponibilité.
Pour en savoir plus sur les régions et les zones de disponibilité, consultez [Régions et zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Cet exemple vous montre comment utiliser le pour AWS SDK pour .NET obtenir des informations sur les régions et les zones de disponibilité associées à un client EC2. L'application affiche les listes des régions et des zones de disponibilité disponibles pour un client EC2.
## Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeAvailabilityZonesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeAvailabilityZonesResponse.html)
Classe [DescribeRegionsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeRegionsResponse.html)
Classe [AvailabilityZone](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TAvailabilityZone.html)
[Région](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRegion.html) de classe
```
using System;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2RegionsAndZones
{
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine(
"Finding the Regions and Availability Zones available to an EC2 client...");
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Display the Regions and Availability Zones
await DescribeRegions(ec2Client);
await DescribeAvailabilityZones(ec2Client);
}
//
// Method to display Regions
private static async Task DescribeRegions(IAmazonEC2 ec2Client)
{
Console.WriteLine("\nRegions that are enabled for the EC2 client:");
DescribeRegionsResponse response = await ec2Client.DescribeRegionsAsync();
foreach (Region region in response.Regions)
Console.WriteLine(region.RegionName);
}
//
// Method to display Availability Zones
private static async Task DescribeAvailabilityZones(IAmazonEC2 ec2Client)
{
Console.WriteLine("\nAvailability Zones for the EC2 client's region:");
DescribeAvailabilityZonesResponse response =
await ec2Client.DescribeAvailabilityZonesAsync();
foreach (AvailabilityZone az in response.AvailabilityZones)
Console.WriteLine(az.ZoneName);
}
}
}
```
# Utilisation des instances Amazon EC2
Instances EC2
Vous pouvez utiliser le AWS SDK pour .NET pour contrôler les instances Amazon EC2 à l'aide d'opérations telles que la création, le démarrage et la fin. Les rubriques de cette section fournissent quelques exemples de la manière de procéder. Pour en savoir plus sur les instances EC2, consultez les instances [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Instances.html) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Pour plus d'informations sur le APIs et les prérequis, consultez la section parent ([Utilisation avec Amazon EC2](ec2-apis-intro.md)).
**Topics**
+ [Lancement d'une instance EC2](run-instance.md)
+ [Interruption d'une instance EC2](terminate-instance.md)
# Lancement d'une instance Amazon EC2
Lancement d'une instance EC2
Cet exemple vous montre comment utiliser le AWS SDK pour .NET pour lancer une ou plusieurs instances Amazon EC2 configurées de manière identique à partir de la même Amazon Machine Image (AMI). À l'aide de [plusieurs entrées](#run-instance-gather) que vous fournissez, l'application lance une instance EC2, puis surveille l'instance jusqu'à ce qu'elle sorte de l'état « En attente ».
Lorsque votre instance EC2 est en cours d'exécution, vous pouvez vous y connecter à distance, comme décrit dans[(facultatif) Connectez-vous à l'instance](#connect-to-instance).
**Avertissement**
EC2-Classic a été retiré le 15 août 2022. Nous vous recommandons de migrer d'EC2-Classic vers un VPC. Pour plus d'informations, consultez le billet de blog [EC2-Classic Networking is Retiring — Here's How](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) to Prepare.
Les sections suivantes fournissent des extraits et d'autres informations pour cet exemple. Le [code complet de l'exemple](#run-instance-complete-code) est affiché après les extraits et peut être créé et exécuté tel quel.
**Topics**
+ [
## Rassemblez ce dont vous avez besoin
](#run-instance-gather)
+ [
## Lancer une instance
](#run-instance-launch)
+ [
## Surveiller l'instance
](#run-instance-monitor)
+ [
## Code complet
](#run-instance-complete-code)
+ [
## Considérations supplémentaires
](#run-instance-additional)
+ [
## (facultatif) Connectez-vous à l'instance
](#connect-to-instance)
+ [
## Nettoyage
](#run-instance-cleanup)
## Rassemblez ce dont vous avez besoin
Pour lancer une instance EC2, vous aurez besoin de plusieurs éléments.
+ Un [VPC](https://docs.aws.amazon.com/vpc/latest/userguide/) dans lequel l'instance sera lancée. S'il s'agit d'une instance Windows et que vous vous y connectez via RDP, le VPC aura probablement besoin d'une passerelle Internet attachée, ainsi que d'une entrée pour la passerelle Internet dans la table de routage. Pour plus d’informations, consultez [Passerelles Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) dans le *Guide de l’utilisateur Amazon VPC*.
+ L'ID d'un sous-réseau existant dans le VPC où l'instance sera lancée. Pour le trouver ou le créer facilement, vous pouvez vous connecter à la [console Amazon VPC](https://console.aws.amazon.com/vpc/home#subnets), mais vous pouvez également l'obtenir par programmation en utilisant les méthodes et. [CreateSubnetAsync[DescribeSubnetsAsync](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/MEC2DescribeSubnetsAsyncDescribeSubnetsRequestCancellationToken.html)](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/MEC2CreateSubnetAsyncCreateSubnetRequestCancellationToken.html)
**Note**
Si vous ne fournissez pas ce paramètre, la nouvelle instance est lancée dans le VPC par défaut de votre compte.
+ L'ID d'un groupe de sécurité existant appartenant au VPC où l'instance sera lancée. Pour de plus amples informations, veuillez consulter [Travailler avec des groupes de sécurité dans Amazon EC2](security-groups.md).
+ Si vous souhaitez vous connecter à la nouvelle instance, le groupe de sécurité mentionné précédemment doit disposer d'une règle entrante appropriée autorisant le trafic SSH sur le port 22 (instance Linux) ou le trafic RDP sur le port 3389 (instance Windows). Pour plus d'informations sur la procédure à suivre[Mise à jour des groupes de sécurité](authorize-ingress.md), voir [Considérations supplémentaires](authorize-ingress.md#authorize-ingress-additional) notamment la fin de cette rubrique.
+ L'Amazon Machine Image (AMI) qui sera utilisée pour créer l'instance. Pour plus d'informations AMIs, consultez [Amazon Machine Images (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Consultez notamment les sections [Rechercher une AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) et [Partager AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharing-amis.html).
+ Le nom d'une paire de clés EC2 existante, qui est utilisée pour se connecter à la nouvelle instance. Pour de plus amples informations, veuillez consulter [Utilisation des paires de clés Amazon EC2](key-pairs.md).
+ Nom du fichier PEM qui contient la clé privée de la paire de clés EC2 mentionnée précédemment. Le fichier PEM est utilisé lorsque vous vous [connectez à distance à](#connect-to-instance) l'instance.
## Lancer une instance
L'extrait de code suivant lance une instance EC2.
L'exemple [situé à la fin de cette rubrique](#run-instance-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to launch the instances
// Returns a list with the launched instance IDs
private static async Task> LaunchInstances(
IAmazonEC2 ec2Client, RunInstancesRequest requestLaunch)
{
var instanceIds = new List();
RunInstancesResponse responseLaunch =
await ec2Client.RunInstancesAsync(requestLaunch);
Console.WriteLine("\nNew instances have been created.");
foreach (Instance item in responseLaunch.Reservation.Instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine($" New instance: {item.InstanceId}");
}
return instanceIds;
}
```
## Surveiller l'instance
L'extrait de code suivant surveille l'instance jusqu'à ce qu'elle sorte de l'état « En attente ».
L'exemple [situé à la fin de cette rubrique](#run-instance-complete-code) montre cet extrait en cours d'utilisation.
Consultez la [InstanceState](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstanceState.html)classe pour connaître les valeurs valides de la `Instance.State.Code` propriété.
```
//
// Method to wait until the instances are running (or at least not pending)
private static async Task CheckState(IAmazonEC2 ec2Client, List instanceIds)
{
Console.WriteLine(
"\nWaiting for the instances to start." +
"\nPress any key to stop waiting. (Response might be slightly delayed.)");
int numberRunning;
DescribeInstancesResponse responseDescribe;
var requestDescribe = new DescribeInstancesRequest{
InstanceIds = instanceIds};
// Check every couple of seconds
int wait = 2000;
while(true)
{
// Get and check the status for each of the instances to see if it's past pending.
// Once all instances are past pending, break out.
// (For this example, we are assuming that there is only one reservation.)
Console.Write(".");
numberRunning = 0;
responseDescribe = await ec2Client.DescribeInstancesAsync(requestDescribe);
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
// Check the lower byte of State.Code property
// Code == 0 is the pending state
if((i.State.Code & 255) > 0) numberRunning++;
}
if(numberRunning == responseDescribe.Reservations[0].Instances.Count)
break;
// Wait a bit and try again (unless the user wants to stop waiting)
Thread.Sleep(wait);
if(Console.KeyAvailable)
break;
}
Console.WriteLine("\nNo more instances are pending.");
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
Console.WriteLine($"For {i.InstanceId}:");
Console.WriteLine($" VPC ID: {i.VpcId}");
Console.WriteLine($" Instance state: {i.State.Name}");
Console.WriteLine($" Public IP address: {i.PublicIpAddress}");
Console.WriteLine($" Public DNS name: {i.PublicDnsName}");
Console.WriteLine($" Key pair name: {i.KeyName}");
}
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
Classe [InstanceType](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstanceType.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeInstancesRequest.html)
Classe [DescribeInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeInstancesResponse.html)
[Instance](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstance.html) de classe
Classe [InstanceNetworkInterfaceSpecification](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstanceNetworkInterfaceSpecification.html)
Classe [RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRunInstancesRequest.html)
Classe [RunInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRunInstancesResponse.html)
### Le code
```
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2LaunchInstance
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to launch an EC2 instance
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string groupID =
CommandLine.GetArgument(parsedArgs, null, "-g", "--group-id");
string ami =
CommandLine.GetArgument(parsedArgs, null, "-a", "--ami-id");
string keyPairName =
CommandLine.GetArgument(parsedArgs, null, "-k", "--keypair-name");
string subnetID =
CommandLine.GetArgument(parsedArgs, null, "-s", "--subnet-id");
if( (string.IsNullOrEmpty(groupID) || !groupID.StartsWith("sg-"))
|| (string.IsNullOrEmpty(ami) || !ami.StartsWith("ami-"))
|| (string.IsNullOrEmpty(keyPairName))
|| (!string.IsNullOrEmpty(subnetID) && !subnetID.StartsWith("subnet-")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create an EC2 client
var ec2Client = new AmazonEC2Client();
// Create an object with the necessary properties
RunInstancesRequest request = GetRequestData(groupID, ami, keyPairName, subnetID);
// Launch the instances and wait for them to start running
var instanceIds = await LaunchInstances(ec2Client, request);
await CheckState(ec2Client, instanceIds);
}
//
// Method to put together the properties needed to launch the instance.
private static RunInstancesRequest GetRequestData(
string groupID, string ami, string keyPairName, string subnetID)
{
// Common properties
var groupIDs = new List() { groupID };
var request = new RunInstancesRequest()
{
// The first three of these would be additional command-line arguments or similar.
InstanceType = InstanceType.T1Micro,
MinCount = 1,
MaxCount = 1,
ImageId = ami,
KeyName = keyPairName
};
// Properties specifically for EC2 in a VPC.
if(!string.IsNullOrEmpty(subnetID))
{
request.NetworkInterfaces =
new List() {
new InstanceNetworkInterfaceSpecification() {
DeviceIndex = 0,
SubnetId = subnetID,
Groups = groupIDs,
AssociatePublicIpAddress = true
}
};
}
// Properties specifically for EC2-Classic
else
{
request.SecurityGroupIds = groupIDs;
}
return request;
}
//
// Method to launch the instances
// Returns a list with the launched instance IDs
private static async Task> LaunchInstances(
IAmazonEC2 ec2Client, RunInstancesRequest requestLaunch)
{
var instanceIds = new List();
RunInstancesResponse responseLaunch =
await ec2Client.RunInstancesAsync(requestLaunch);
Console.WriteLine("\nNew instances have been created.");
foreach (Instance item in responseLaunch.Reservation.Instances)
{
instanceIds.Add(item.InstanceId);
Console.WriteLine($" New instance: {item.InstanceId}");
}
return instanceIds;
}
//
// Method to wait until the instances are running (or at least not pending)
private static async Task CheckState(IAmazonEC2 ec2Client, List instanceIds)
{
Console.WriteLine(
"\nWaiting for the instances to start." +
"\nPress any key to stop waiting. (Response might be slightly delayed.)");
int numberRunning;
DescribeInstancesResponse responseDescribe;
var requestDescribe = new DescribeInstancesRequest{
InstanceIds = instanceIds};
// Check every couple of seconds
int wait = 2000;
while(true)
{
// Get and check the status for each of the instances to see if it's past pending.
// Once all instances are past pending, break out.
// (For this example, we are assuming that there is only one reservation.)
Console.Write(".");
numberRunning = 0;
responseDescribe = await ec2Client.DescribeInstancesAsync(requestDescribe);
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
// Check the lower byte of State.Code property
// Code == 0 is the pending state
if((i.State.Code & 255) > 0) numberRunning++;
}
if(numberRunning == responseDescribe.Reservations[0].Instances.Count)
break;
// Wait a bit and try again (unless the user wants to stop waiting)
Thread.Sleep(wait);
if(Console.KeyAvailable)
break;
}
Console.WriteLine("\nNo more instances are pending.");
foreach(Instance i in responseDescribe.Reservations[0].Instances)
{
Console.WriteLine($"For {i.InstanceId}:");
Console.WriteLine($" VPC ID: {i.VpcId}");
Console.WriteLine($" Instance state: {i.State.Name}");
Console.WriteLine($" Public IP address: {i.PublicIpAddress}");
Console.WriteLine($" Public DNS name: {i.PublicDnsName}");
Console.WriteLine($" Key pair name: {i.KeyName}");
}
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2LaunchInstance -g -a -k [-s ]" +
"\n -g, --group-id: The ID of the security group." +
"\n -a, --ami-id: The ID of an Amazon Machine Image." +
"\n -k, --keypair-name - The name of a key pair." +
"\n -s, --subnet-id: The ID of a subnet. Required only for EC2 in a VPC.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Lorsque vous vérifiez l'état d'une instance EC2, vous pouvez ajouter un filtre à la `Filter` propriété de l'[DescribeInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeInstancesRequest.html)objet. Grâce à cette technique, vous pouvez limiter la demande à certaines instances, par exemple les instances dotées d'une balise spécifique spécifiée par l'utilisateur.
+ Par souci de concision, des valeurs typiques ont été attribuées à certaines propriétés. L'une ou l'ensemble de ces propriétés peuvent plutôt être déterminées par programmation ou par saisie par l'utilisateur.
+ Les valeurs que vous pouvez utiliser pour les `MaxCount` propriétés `MinCount` et de l'[RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRunInstancesRequest.html)objet sont déterminées par la zone de disponibilité cible et le nombre maximum d'instances autorisées pour le type d'instance. Pour plus d'informations, consultez la section [Combien d'instances puis-je exécuter dans Amazon EC2](https://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2) dans la FAQ générale d'Amazon EC2.
+ Si vous souhaitez utiliser un type d'instance différent de celui de cet exemple, vous avez le choix entre plusieurs types d'instance. Pour plus d'informations, consultez les [types d'instances Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Consultez également les [détails du type d'instance](https://aws.amazon.com/ec2/instance-types/) [et l'explorateur de types d'instance](https://aws.amazon.com/ec2/instance-explorer/).
+ Vous pouvez également associer un [rôle IAM](net-dg-hosm.md) à une instance lorsque vous la lancez. Pour ce faire, créez un [IamInstanceProfileSpecification](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TIamInstanceProfileSpecification.html)objet dont la `Name` propriété est définie sur le nom d'un rôle IAM. Ajoutez ensuite cet objet à la `IamInstanceProfile` propriété de l'[RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRunInstancesRequest.html)objet.
**Note**
Pour lancer une instance EC2 à laquelle un rôle IAM est attaché, la configuration d'un utilisateur IAM doit inclure certaines autorisations. Pour plus d'informations sur les autorisations requises, consultez la section [Accorder à un utilisateur l'autorisation de transmettre un rôle IAM à une instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#permission-to-pass-iam-roles) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## (facultatif) Connectez-vous à l'instance
Une fois qu'une instance est en cours d'exécution, vous pouvez vous y connecter à distance à l'aide du client distant approprié. Pour les instances Linux et Windows, vous avez besoin de l'adresse IP publique ou du nom DNS public de l'instance. Vous avez également besoin des éléments suivants.
**Pour les instances Linux**
Vous pouvez utiliser un client SSH pour vous connecter à votre instance Linux. Assurez-vous que le groupe de sécurité que vous avez utilisé lorsque vous avez lancé l'instance autorise le trafic SSH sur le port 22, comme décrit dans[Mise à jour des groupes de sécurité](authorize-ingress.md).
Vous avez également besoin de la partie privée de la paire de clés que vous avez utilisée pour lancer l'instance, c'est-à-dire le fichier PEM.
Pour plus d'informations, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) dans le guide de l'utilisateur Amazon EC2.
**Pour les instances Windows**
Vous pouvez utiliser un client RDP pour vous connecter à votre instance. Assurez-vous que le groupe de sécurité que vous avez utilisé lorsque vous avez lancé l'instance autorise le trafic RDP sur le port 3389, comme décrit dans. [Mise à jour des groupes de sécurité](authorize-ingress.md)
Vous avez également besoin du mot de passe administrateur. Vous pouvez l'obtenir en utilisant l'exemple de code suivant, qui nécessite l'ID de l'instance et la partie privée de la paire de clés utilisée pour lancer l'instance, c'est-à-dire le fichier PEM.
Pour plus d'informations, consultez [Connect to your Windows instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connecting_to_windows_instance.html) dans le guide de l'utilisateur Amazon EC2.
**Avertissement**
Cet exemple de code renvoie le mot de passe administrateur en texte brut pour votre instance.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [GetPasswordDataRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TGetPasswordDataRequest.html)
Classe [GetPasswordDataResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TGetPasswordDataResponse.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2GetWindowsPassword
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to get the Administrator password of a Windows EC2 instance
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string instanceID =
CommandLine.GetArgument(parsedArgs, null, "-i", "--instance-id");
string pemFileName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--pem-filename");
if( (string.IsNullOrEmpty(instanceID) || !instanceID.StartsWith("i-"))
|| (string.IsNullOrEmpty(pemFileName) || !pemFileName.EndsWith(".pem")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the EC2 client
var ec2Client = new AmazonEC2Client();
// Get and display the password
string password = await GetPassword(ec2Client, instanceID, pemFileName);
Console.WriteLine($"\nPassword: {password}");
}
//
// Method to get the administrator password of a Windows EC2 instance
private static async Task GetPassword(
IAmazonEC2 ec2Client, string instanceID, string pemFilename)
{
string password = string.Empty;
GetPasswordDataResponse response =
await ec2Client.GetPasswordDataAsync(new GetPasswordDataRequest{
InstanceId = instanceID});
if(response.PasswordData != null)
{
password = response.GetDecryptedPassword(File.ReadAllText(pemFilename));
}
else
{
Console.WriteLine($"\nThe password is not available for instance {instanceID}.");
Console.WriteLine($"If this is a Windows instance, the password might not be ready.");
}
return password;
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: EC2GetWindowsPassword -i -p pem-filename" +
"\n -i, --instance-id: The name of the EC2 instance." +
"\n -p, --pem-filename: The name of the PEM file with the private key.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Nettoyage
Lorsque vous n'avez plus besoin de votre instance EC2, veillez à la mettre hors service, comme décrit dans[Interruption d'une instance Amazon EC2](terminate-instance.md).
# Interruption d'une instance Amazon EC2
Interruption d'une instance EC2
Lorsque vous n'avez plus besoin d'une ou de plusieurs de vos instances Amazon EC2, vous pouvez les résilier.
Cet exemple vous montre comment utiliser le pour mettre fin AWS SDK pour .NET à des instances EC2. Il prend un ID d'instance en entrée.
## Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TTerminateInstancesRequest.html)
Classe [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TTerminateInstancesResponse.html)
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2TerminateInstance
{
class Program
{
static async Task Main(string[] args)
{
if((args.Length == 1) && (args[0].StartsWith("i-")))
{
// Terminate the instance
var ec2Client = new AmazonEC2Client();
await TerminateInstance(ec2Client, args[0]);
}
else
{
Console.WriteLine("\nCommand-line argument missing or incorrect.");
Console.WriteLine("\nUsage: EC2TerminateInstance instance-ID");
Console.WriteLine(" instance-ID - The EC2 instance you want to terminate.");
return;
}
}
//
// Method to terminate an EC2 instance
private static async Task TerminateInstance(IAmazonEC2 ec2Client, string instanceID)
{
var request = new TerminateInstancesRequest{
InstanceIds = new List() { instanceID }};
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List() { instanceID }
});
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine("Terminated instance: " + item.InstanceId);
Console.WriteLine("Instance state: " + item.CurrentState.Name);
}
}
}
}
```
Après avoir exécuté l'exemple, il est conseillé de vous connecter à la [console Amazon EC2](https://console.aws.amazon.com/ec2/) pour vérifier que l'[instance EC2](https://console.aws.amazon.com/ec2/v2/home#Instances) a été résiliée.
# Tutoriel sur les instances Spot Amazon EC2
Tutoriel Spot Instance
Ce didacticiel explique comment utiliser le AWS SDK pour .NET pour gérer les instances Spot Amazon EC2.
## Présentation de
Les instances Spot vous permettent de demander de la capacité Amazon EC2 inutilisée à un prix inférieur au prix à la demande. Cela peut réduire considérablement vos coûts EC2 pour les applications susceptibles d'être interrompues.
Vous trouverez ci-dessous un résumé détaillé de la manière 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.
1. Lorsque la demande est satisfaite, exécutez l'instance comme vous le feriez pour n'importe quelle autre instance Amazon EC2.
1. Exécutez l'instance aussi longtemps que vous le souhaitez, puis mettez-la hors service, sauf si le *prix au comptant* change de telle sorte que l'instance soit résiliée pour vous.
1. 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'un aperçu de très haut niveau des instances Spot. Pour mieux comprendre les instances Spot, consultez la section [Instances Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## À propos de ce didacticiel
Au fur et à mesure que vous suivez ce didacticiel, vous utilisez le AWS SDK pour .NET pour effectuer les opérations suivantes :
+ Créer une demande d’instance Spot
+ Déterminez à quel moment la demande d'instance Spot a été satisfaite
+ Annuler la demande d'instance Spot
+ Résilier les instances associées
Les sections suivantes fournissent des extraits de code et d'autres informations pour cet exemple. Le [code complet de l'exemple](#tutor-spot-net-main) est affiché après les extraits et peut être créé et exécuté tel quel.
**Topics**
+ [
## Présentation de
](#tutor-spot-net-overview)
+ [
## À propos de ce didacticiel
](#about-spot-instances-tutorial)
+ [
## Conditions préalables
](#tutor-spot-net-prereq)
+ [
## Rassemblez ce dont vous avez besoin
](#tutor-spot-net-gather)
+ [
## Création d'une demande d'instance Spot
](#tutor-spot-net-submit)
+ [
## Déterminez l'état de votre demande d'instance Spot
](#tutor-spot-net-request-state)
+ [
## Nettoyez vos demandes d'instance Spot
](#tutor-spot-net-clean-up-request)
+ [
## Nettoyez vos instances Spot
](#tutor-spot-net-clean-up-instance)
+ [
## Code complet
](#tutor-spot-net-main)
+ [
## Considérations supplémentaires
](#tutor-spot-net-additional)
## Conditions préalables
Pour plus d'informations sur le APIs et les prérequis, consultez la section parent ([Utilisation avec Amazon EC2](ec2-apis-intro.md)).
## Rassemblez ce dont vous avez besoin
Pour créer une demande d'instance Spot, vous aurez besoin de plusieurs éléments.
+ Le nombre d'instances et leur type d'instance. Vous avez le choix entre plusieurs types d'instances. Pour plus d'informations, consultez les [types d'instances Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Consultez également les [détails du type d'instance](https://aws.amazon.com/ec2/instance-types/) [et l'explorateur de types d'instance](https://aws.amazon.com/ec2/instance-explorer/).
Le nombre par défaut pour ce didacticiel est 1.
+ L'Amazon Machine Image (AMI) qui sera utilisée pour créer l'instance. Pour plus d'informations AMIs, consultez [Amazon Machine Images (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Consultez notamment les sections [Rechercher une AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) et [Partager AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharing-amis.html).
+ Le prix maximum que vous êtes prêt à payer par heure d'instance. Vous pouvez consulter les prix de tous les types d'instances (pour les instances à la demande et les instances ponctuelles) sur la page de [tarification d'Amazon EC2](https://aws.amazon.com/ec2/pricing/). Le prix par défaut de ce didacticiel est expliqué plus loin.
+ Si vous souhaitez vous connecter à distance à une instance, un groupe de sécurité doté de la configuration et des ressources appropriées. Ceci est décrit dans [Travailler avec des groupes de sécurité dans Amazon EC2](security-groups.md) les informations relatives à la [collecte de ce dont vous avez besoin](run-instance.md#run-instance-gather) et [à la connexion à une instance](run-instance.md#connect-to-instance) dans[Lancement d'une instance Amazon EC2](run-instance.md). Pour des raisons de simplicité, ce didacticiel utilise le groupe de sécurité nommé **default** que possèdent tous les nouveaux AWS comptes.
Il existe de nombreuses façons d'aborder la demande d'instances Spot. Les stratégies les plus courantes sont les suivantes :
+ Faites des demandes qui coûteront certainement moins cher que la tarification à la demande.
+ Effectuez des demandes en fonction de la valeur du calcul obtenu.
+ Faites des demandes afin d'acquérir de la capacité de calcul le plus rapidement possible.
Les explications suivantes font référence à l'[historique des tarifs des instances Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
### Réduisez les coûts en dessous de la demande
Vous avez une tâche de traitement par lot dont l'exécution prendra un certain nombre d'heures ou 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 au comptant pour les types d'instances à l'aide de la console Amazon EC2 ou de l'API Amazon EC2. Une fois que vous avez analysé l'historique des prix pour le type d'instance souhaité dans une zone de disponibilité donnée, deux approches sont possibles pour votre demande :
+ Spécifiez une demande se situant dans la partie supérieure de la fourchette des prix ponctuels, qui sont toujours inférieurs au prix à la demande, en anticipant que votre demande d'instance ponctuelle unique sera probablement satisfaite et exécutée pendant une durée de calcul consécutive suffisante pour terminer le travail.
+ Spécifiez une demande à la limite inférieure de la plage de prix et envisagez de combiner plusieurs instances lancées au fil du temps via une demande persistante. Les instances vont s'exécuter suffisamment longtemps, au total, pour terminer la tâche avec un coût total plus faible.
### Ne payez pas plus que la valeur du résultat
Vous avez une tâche de traitement de données à exécuter. Vous comprenez suffisamment la valeur des résultats du travail pour savoir combien ils valent en termes de coûts informatiques.
Après avoir analysé l'historique des prix au comptant pour votre type d'instance, vous choisissez un prix dont le coût du temps de calcul ne dépasse pas la valeur des résultats de la tâche. Vous créez une demande persistante et faites en sorte qu'elle s'exécute de façon intermittente selon que le prix Spot est égal ou inférieur à votre demande.
### Acquérez rapidement de la capacité informatique
Vous avez un besoin imprévu à court terme de capacité supplémentaire qui n'est pas disponible via les instances à la demande. Après avoir analysé l'historique des prix au comptant pour votre type d'instance, vous choisissez un prix supérieur au prix historique le plus élevé afin d'améliorer considérablement les chances que votre demande soit traitée rapidement et vous poursuivez le calcul jusqu'à ce qu'elle soit complète.
Une fois que vous avez rassemblé ce dont vous avez besoin et que vous avez choisi une stratégie, vous êtes prêt à demander une instance Spot. Pour ce didacticiel, 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 \$1pour ce didacticiel). Fixer le prix de cette manière maximise les chances de satisfaire la demande.
## Création d'une demande d'instance Spot
L'extrait suivant explique comment créer une demande d'instance Spot avec les éléments que vous avez collectés précédemment.
L'exemple [à la fin de cette rubrique](#tutor-spot-net-main) montre cet extrait en cours d'utilisation.
```
//
// Method to create a Spot Instance request
private static async Task CreateSpotInstanceRequest(
IAmazonEC2 ec2Client, string amiId, string securityGroupName,
InstanceType instanceType, string spotPrice, int instanceCount)
{
var launchSpecification = new LaunchSpecification{
ImageId = amiId,
InstanceType = instanceType
};
launchSpecification.SecurityGroups.Add(securityGroupName);
var request = new RequestSpotInstancesRequest{
SpotPrice = spotPrice,
InstanceCount = instanceCount,
LaunchSpecification = launchSpecification
};
RequestSpotInstancesResponse result =
await ec2Client.RequestSpotInstancesAsync(request);
return result.SpotInstanceRequests[0];
}
```
La valeur importante renvoyée par cette méthode est l'ID de demande d'instance Spot, qui est contenu dans le `SpotInstanceRequestId` membre de l'[SpotInstanceRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TSpotInstanceRequest.html)objet renvoyé.
**Note**
Toutes les instances Spot lancées vous seront facturées. Pour éviter des coûts inutiles, veillez à [annuler toutes les demandes](#tutor-spot-net-clean-up-request) et à [mettre fin à toutes les instances](#tutor-spot-net-clean-up-instance).
## Déterminez l'état de votre demande d'instance Spot
L'extrait suivant vous montre comment obtenir des informations sur votre demande d'instance Spot. Vous pouvez utiliser ces informations pour prendre certaines décisions dans votre code, par exemple si vous souhaitez continuer à attendre qu'une demande d'instance Spot soit traitée.
L'exemple [à la fin de cette rubrique](#tutor-spot-net-main) montre cet extrait en cours d'utilisation.
```
//
// Method to get information about a Spot Instance request, including the status,
// instance ID, etc.
// It gets the information for a specific request (as opposed to all requests).
private static async Task GetSpotInstanceRequestInfo(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
return describeResponse.SpotInstanceRequests[0];
}
```
La méthode renvoie des informations sur la demande d'instance Spot, telles que l'ID de l'instance, son état et son code d'état. Pour plus d'informations sur les codes de statut des demandes d'instance Spot, consultez la section [État des demandes Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-bid-status.html#spot-instance-bid-status-understand) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## Nettoyez vos demandes d'instance Spot
Lorsque vous n'avez plus besoin de demander des instances ponctuelles, il est important d'annuler toutes les demandes en suspens afin d'éviter qu'elles ne soient traitées à nouveau. L'extrait suivant explique comment annuler une demande d'instance Spot.
L'exemple [à la fin de cette rubrique](#tutor-spot-net-main) montre cet extrait en cours d'utilisation.
```
//
// Method to cancel a Spot Instance request
private static async Task CancelSpotInstanceRequest(
IAmazonEC2 ec2Client, string requestId)
{
var cancelRequest = new CancelSpotInstanceRequestsRequest();
cancelRequest.SpotInstanceRequestIds.Add(requestId);
await ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest);
}
```
## Nettoyez vos instances Spot
Pour éviter des coûts inutiles, il est important de résilier toutes les instances créées à partir de demandes d'instances Spot ; le simple fait d'annuler les demandes d'instance Spot ne mettra pas fin à vos instances, ce qui signifie qu'elles continueront à vous être facturées. L'extrait suivant explique comment mettre fin à une instance après avoir obtenu l'identifiant d'instance d'une instance Spot active.
L'exemple [à la fin de cette rubrique](#tutor-spot-net-main) montre cet extrait en cours d'utilisation.
```
//
// Method to terminate a Spot Instance
private static async Task TerminateSpotInstance(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
// Retrieve the Spot Instance request to check for running instances.
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
// If there are any running instances, terminate them
if( (describeResponse.SpotInstanceRequests[0].Status.Code
== "request-canceled-and-instance-running")
|| (describeResponse.SpotInstanceRequests[0].State == SpotInstanceState.Active))
{
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List(){
describeResponse.SpotInstanceRequests[0].InstanceId } });
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine($"\n Terminated instance: {item.InstanceId}");
Console.WriteLine($" Instance state: {item.CurrentState.Name}\n");
}
}
}
```
## Code complet
L'exemple de code suivant appelle les méthodes décrites précédemment pour créer et annuler une demande d'instance Spot et mettre fin à une instance Spot.
### Références du SDK
NuGet colis :
+ [AWSSDK.EC2](https://www.nuget.org/packages/AWSSDK.EC2)
Éléments de programmation :
+ [Espace de noms Amazon.ec2](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TEC2Client.html)
Classe [InstanceType](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstanceType.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/NEC2Model.html)
Classe [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TCancelSpotInstanceRequestsRequest.html)
Classe [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSpotInstanceRequestsRequest.html)
Classe [DescribeSpotInstanceRequestsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TDescribeSpotInstanceRequestsResponse.html)
Classe [InstanceStateChange](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TInstanceStateChange.html)
Classe [LaunchSpecification](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TLaunchSpecification.html)
Classe [RequestSpotInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRequestSpotInstancesRequest.html)
Classe [RequestSpotInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TRequestSpotInstancesResponse.html)
Classe [SpotInstanceRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TSpotInstanceRequest.html)
Classe [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TTerminateInstancesRequest.html)
Classe [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/EC2/TTerminateInstancesResponse.html)
### Le code
```
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.EC2;
using Amazon.EC2.Model;
namespace EC2SpotInstanceRequests
{
class Program
{
static async Task Main(string[] args)
{
// Some default values.
// These could be made into command-line arguments instead.
var instanceType = InstanceType.T1Micro;
string securityGroupName = "default";
string spotPrice = "0.003";
int instanceCount = 1;
// Parse the command line arguments
if((args.Length != 1) || (!args[0].StartsWith("ami-")))
{
Console.WriteLine("\nUsage: EC2SpotInstanceRequests ami");
Console.WriteLine(" ami: the Amazon Machine Image to use for the Spot Instances.");
return;
}
// Create the Amazon EC2 client.
var ec2Client = new AmazonEC2Client();
// Create the Spot Instance request and record its ID
Console.WriteLine("\nCreating spot instance request...");
var req = await CreateSpotInstanceRequest(
ec2Client, args[0], securityGroupName, instanceType, spotPrice, instanceCount);
string requestId = req.SpotInstanceRequestId;
// Wait for an EC2 Spot Instance to become active
Console.WriteLine(
$"Waiting for Spot Instance request with ID {requestId} to become active...");
int wait = 1;
var start = DateTime.Now;
while(true)
{
Console.Write(".");
// Get and check the status to see if the request has been fulfilled.
var requestInfo = await GetSpotInstanceRequestInfo(ec2Client, requestId);
if(requestInfo.Status.Code == "fulfilled")
{
Console.WriteLine($"\nSpot Instance request {requestId} " +
$"has been fulfilled by instance {requestInfo.InstanceId}.\n");
break;
}
// Wait a bit and try again, longer each time (1, 2, 4, ...)
Thread.Sleep(wait);
wait = wait * 2;
}
// Show the user how long it took to fulfill the Spot Instance request.
TimeSpan span = DateTime.Now.Subtract(start);
Console.WriteLine($"That took {span.TotalMilliseconds} milliseconds");
// Perform actions here as needed.
// For this example, simply wait for the user to hit a key.
// That gives them a chance to look at the EC2 console to see
// the running instance if they want to.
Console.WriteLine("Press any key to start the cleanup...");
Console.ReadKey(true);
// Cancel the request.
// Do this first to make sure that the request can't be re-fulfilled
// once the Spot Instance has been terminated.
Console.WriteLine("Canceling Spot Instance request...");
await CancelSpotInstanceRequest(ec2Client, requestId);
// Terminate the Spot Instance that's running.
Console.WriteLine("Terminating the running Spot Instance...");
await TerminateSpotInstance(ec2Client, requestId);
Console.WriteLine("Done. Press any key to exit...");
Console.ReadKey(true);
}
//
// Method to create a Spot Instance request
private static async Task CreateSpotInstanceRequest(
IAmazonEC2 ec2Client, string amiId, string securityGroupName,
InstanceType instanceType, string spotPrice, int instanceCount)
{
var launchSpecification = new LaunchSpecification{
ImageId = amiId,
InstanceType = instanceType
};
launchSpecification.SecurityGroups.Add(securityGroupName);
var request = new RequestSpotInstancesRequest{
SpotPrice = spotPrice,
InstanceCount = instanceCount,
LaunchSpecification = launchSpecification
};
RequestSpotInstancesResponse result =
await ec2Client.RequestSpotInstancesAsync(request);
return result.SpotInstanceRequests[0];
}
//
// Method to get information about a Spot Instance request, including the status,
// instance ID, etc.
// It gets the information for a specific request (as opposed to all requests).
private static async Task GetSpotInstanceRequestInfo(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
return describeResponse.SpotInstanceRequests[0];
}
//
// Method to cancel a Spot Instance request
private static async Task CancelSpotInstanceRequest(
IAmazonEC2 ec2Client, string requestId)
{
var cancelRequest = new CancelSpotInstanceRequestsRequest();
cancelRequest.SpotInstanceRequestIds.Add(requestId);
await ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest);
}
//
// Method to terminate a Spot Instance
private static async Task TerminateSpotInstance(
IAmazonEC2 ec2Client, string requestId)
{
var describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.SpotInstanceRequestIds.Add(requestId);
// Retrieve the Spot Instance request to check for running instances.
DescribeSpotInstanceRequestsResponse describeResponse =
await ec2Client.DescribeSpotInstanceRequestsAsync(describeRequest);
// If there are any running instances, terminate them
if( (describeResponse.SpotInstanceRequests[0].Status.Code
== "request-canceled-and-instance-running")
|| (describeResponse.SpotInstanceRequests[0].State == SpotInstanceState.Active))
{
TerminateInstancesResponse response =
await ec2Client.TerminateInstancesAsync(new TerminateInstancesRequest{
InstanceIds = new List(){
describeResponse.SpotInstanceRequests[0].InstanceId } });
foreach (InstanceStateChange item in response.TerminatingInstances)
{
Console.WriteLine($"\n Terminated instance: {item.InstanceId}");
Console.WriteLine($" Instance state: {item.CurrentState.Name}\n");
}
}
}
}
}
```
## Considérations supplémentaires
+ Après avoir exécuté le didacticiel, il est conseillé de vous connecter à la [console Amazon EC2](https://console.aws.amazon.com/ec2/) pour vérifier que la [demande d'instance Spot](https://console.aws.amazon.com/ec2/home#SpotInstances:) a été annulée et que l'[instance Spot](https://console.aws.amazon.com/ec2/v2/home#Instances) a été résiliée.
# Accès Gestion des identités et des accès AWS (IAM) à l'aide du AWS SDK pour .NET
IAM
The AWS SDK pour .NET supports [Gestion des identités et des accès AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/), qui est un service Web qui permet aux AWS clients de gérer les utilisateurs et les autorisations des utilisateurs dans AWS.
Un *utilisateur Gestion des identités et des accès AWS * (IAM) est une entité que vous créez dans AWS. L'entité représente une personne ou une application qui interagit avec AWS. Pour plus d'informations sur les utilisateurs IAM, voir Utilisateurs [IAM et [limites IAM et STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html) dans le Guide de l'utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) IAM.
Vous accordez des autorisations à un utilisateur en créant une *politique* IAM. La politique contient un *document de politique* qui répertorie les actions qu'un utilisateur peut effectuer et les ressources que ces actions peuvent affecter. Pour plus d'informations sur les politiques IAM, consultez la section [Politiques et autorisations](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) du Guide de l'*utilisateur IAM*.
**Avertissement**
Afin d’éviter les risques de sécurité, n’employez pas les utilisateurs IAM pour l’authentification lorsque vous développez des logiciels spécialisés ou lorsque vous travaillez avec des données réelles. Préférez la fédération avec un fournisseur d’identité tel que [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
## APIs
Les AWS SDK pour .NET offres APIs pour les clients IAM. Ils vous APIs permettent de travailler avec les fonctionnalités IAM telles que les utilisateurs, les rôles et les clés d'accès.
Cette section contient un petit nombre d'exemples qui vous montrent les modèles que vous pouvez suivre lorsque vous travaillez avec ces outils APIs. Pour voir l'ensemble complet de APIs, consultez la [référence de l'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) (et faites défiler la page jusqu'à « Amazon »). IdentityManagement«).
Cette section contient également [un exemple](net-dg-hosm.md) qui explique comment associer un rôle IAM aux instances Amazon EC2 afin de faciliter la gestion des informations d'identification.
[Les IAM APIs sont fournis par leAWSSDK. IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement) NuGetcolis.
## Conditions préalables
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## Rubriques
**Topics**
+ [
## APIs
](#w2aac19c15c23c13)
+ [
## Conditions préalables
](#w2aac19c15c23c15)
+ [
## Rubriques
](#w2aac19c15c23c17)
+ [Création de politiques gérées à partir de JSON](iam-policies-create-json.md)
+ [Afficher les documents de politique](iam-policies-display.md)
+ [Octroi d'accès avec un rôle](net-dg-hosm.md)
# Création de politiques gérées par IAM à partir de JSON
Création de politiques gérées à partir de JSON
Cet exemple vous montre comment utiliser le pour créer une [politique gérée par IAM AWS SDK pour .NET](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) à partir d'un document de stratégie donné au format JSON. L'application crée un objet client IAM, lit le document de politique à partir d'un fichier, puis crée la stratégie.
**Note**
Pour un exemple de document de politique au format JSON, consultez les [considérations supplémentaires](#iam-policies-create-json-additional) à la fin de cette rubrique.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#iam-policies-create-json-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Création de la stratégie
](#iam-policies-create-json-create)
+ [
## Code complet
](#iam-policies-create-json-complete-code)
+ [
## Considérations supplémentaires
](#iam-policies-create-json-additional)
## Création de la stratégie
L'extrait de code suivant crée une politique gérée par IAM avec le nom et le document de stratégie indiqués.
L'exemple [à la fin de cette rubrique](#iam-policies-create-json-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to create an IAM policy from a JSON file
private static async Task CreateManagedPolicy(
IAmazonIdentityManagementService iamClient, string policyName, string jsonFilename)
{
return await iamClient.CreatePolicyAsync(new CreatePolicyRequest{
PolicyName = policyName,
PolicyDocument = File.ReadAllText(jsonFilename)});
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)
Éléments de programmation :
+ Espace de noms [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAM.html)
Classe [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TIAMServiceClient.html)
+ Espace de noms [Amazon. IdentityManagement.Modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAMModel.html)
Classe [CreatePolicyRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TCreatePolicyRequest.html)
Classe [CreatePolicyResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TCreatePolicyResponse.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.IdentityManagement;
using Amazon.IdentityManagement.Model;
namespace IamCreatePolicyFromJson
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create an IAM policy with a given policy document
class Program
{
private const int MaxArgs = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if((parsedArgs.Count == 0) || (parsedArgs.Count > MaxArgs))
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string policyName =
CommandLine.GetArgument(parsedArgs, null, "-p", "--policy-name");
string policyFilename =
CommandLine.GetArgument(parsedArgs, null, "-j", "--json-filename");
if( string.IsNullOrEmpty(policyName)
|| (string.IsNullOrEmpty(policyFilename) || !policyFilename.EndsWith(".json")))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create an IAM service client
var iamClient = new AmazonIdentityManagementServiceClient();
// Create the new policy
var response = await CreateManagedPolicy(iamClient, policyName, policyFilename);
Console.WriteLine($"\nPolicy {response.Policy.PolicyName} has been created.");
Console.WriteLine($" Arn: {response.Policy.Arn}");
}
//
// Method to create an IAM policy from a JSON file
private static async Task CreateManagedPolicy(
IAmazonIdentityManagementService iamClient, string policyName, string jsonFilename)
{
return await iamClient.CreatePolicyAsync(new CreatePolicyRequest{
PolicyName = policyName,
PolicyDocument = File.ReadAllText(jsonFilename)});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: IamCreatePolicyFromJson -p -j " +
"\n -p, --policy-name: The name you want the new policy to have." +
"\n -j, --json-filename: The name of the JSON file with the policy document.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Voici un exemple de document de politique que vous pouvez copier dans un fichier JSON et utiliser comme entrée pour cette application :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id" : "DotnetTutorialPolicy",
"Statement" : [
{
"Sid" : "DotnetTutorialPolicyS3",
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : "*"
},
{
"Sid" : "DotnetTutorialPolicyPolly",
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:SynthesizeSpeech"
],
"Resource": "*"
}
]
}
```
------
+ Vous pouvez vérifier que la politique a été créée en consultant la [console IAM.](https://console.aws.amazon.com/iam/home#/policies) Dans la liste déroulante des **politiques de filtrage**, sélectionnez **Géré par le client**. Supprimez la politique lorsque vous n'en avez plus besoin.
+ Pour plus d'informations sur la création de politiques, consultez [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) et la [référence de politique IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) dans le guide de l'utilisateur [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/)
# Afficher le document de politique d'une politique gérée par IAM
Afficher les documents de politique
Cet exemple montre comment utiliser le AWS SDK pour .NET pour afficher un document de politique. L'application crée un objet client IAM, trouve la version par défaut de la politique gérée IAM donnée, puis affiche le document de stratégie au format JSON.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#iam-policies-display-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Trouvez la version par défaut
](#iam-policies-display-version)
+ [
## Afficher le document de politique
](#iam-policies-display-doc)
+ [
## Code complet
](#iam-policies-display-complete-code)
## Trouvez la version par défaut
L'extrait suivant trouve la version par défaut de la politique IAM donnée.
L'exemple [à la fin de cette rubrique](#iam-policies-display-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to determine the default version of an IAM policy
// Returns a string with the version
private static async Task GetDefaultVersion(
IAmazonIdentityManagementService iamClient, string policyArn)
{
// Retrieve all the versions of this policy
string defaultVersion = string.Empty;
ListPolicyVersionsResponse reponseVersions =
await iamClient.ListPolicyVersionsAsync(new ListPolicyVersionsRequest{
PolicyArn = policyArn});
// Find the default version
foreach(PolicyVersion version in reponseVersions.Versions)
{
if(version.IsDefaultVersion)
{
defaultVersion = version.VersionId;
break;
}
}
return defaultVersion;
}
```
## Afficher le document de politique
L'extrait suivant affiche le document de politique au format JSON de la stratégie IAM donnée.
L'exemple [à la fin de cette rubrique](#iam-policies-display-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to retrieve and display the policy document of an IAM policy
private static async Task ShowPolicyDocument(
IAmazonIdentityManagementService iamClient, string policyArn, string defaultVersion)
{
// Retrieve the policy document of the default version
GetPolicyVersionResponse responsePolicy =
await iamClient.GetPolicyVersionAsync(new GetPolicyVersionRequest{
PolicyArn = policyArn,
VersionId = defaultVersion});
// Display the policy document (in JSON)
Console.WriteLine($"Version {defaultVersion} of the policy (in JSON format):");
Console.WriteLine(
$"{HttpUtility.UrlDecode(responsePolicy.PolicyVersion.Document)}");
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.IdentityManagement](https://www.nuget.org/packages/AWSSDK.IdentityManagement)
Éléments de programmation :
+ Espace de noms [Amazon. IdentityManagement](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAM.html)
Classe [AmazonIdentityManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TIAMServiceClient.html)
+ Espace de noms [Amazon. IdentityManagement.Modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/NIAMModel.html)
Classe [GetPolicyVersionRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TGetPolicyVersionRequest.html)
Classe [GetPolicyVersionResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TGetPolicyVersionResponse.html)
Classe [ListPolicyVersionsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TListPolicyVersionsRequest.html)
Classe [ListPolicyVersionsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TListPolicyVersionsResponse.html)
Classe [PolicyVersion](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/IAM/TPolicyVersion.html)
### Le code
```
using System;
using System.Web;
using System.Threading.Tasks;
using Amazon.IdentityManagement;
using Amazon.IdentityManagement.Model;
namespace IamDisplayPolicyJson
{
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
if(args.Length != 1)
{
Console.WriteLine("\nUsage: IamDisplayPolicyJson policy-arn");
Console.WriteLine(" policy-arn: The ARN of the policy to retrieve.");
return;
}
if(!args[0].StartsWith("arn:"))
{
Console.WriteLine("\nCould not find policy ARN in the command-line arguments:");
Console.WriteLine($"{args[0]}");
return;
}
// Create an IAM service client
var iamClient = new AmazonIdentityManagementServiceClient();
// Retrieve and display the policy document of the given policy
string defaultVersion = await GetDefaultVersion(iamClient, args[0]);
if(string.IsNullOrEmpty(defaultVersion))
Console.WriteLine($"Could not find the default version for policy {args[0]}.");
else
await ShowPolicyDocument(iamClient, args[0], defaultVersion);
}
//
// Method to determine the default version of an IAM policy
// Returns a string with the version
private static async Task GetDefaultVersion(
IAmazonIdentityManagementService iamClient, string policyArn)
{
// Retrieve all the versions of this policy
string defaultVersion = string.Empty;
ListPolicyVersionsResponse reponseVersions =
await iamClient.ListPolicyVersionsAsync(new ListPolicyVersionsRequest{
PolicyArn = policyArn});
// Find the default version
foreach(PolicyVersion version in reponseVersions.Versions)
{
if(version.IsDefaultVersion)
{
defaultVersion = version.VersionId;
break;
}
}
return defaultVersion;
}
//
// Method to retrieve and display the policy document of an IAM policy
private static async Task ShowPolicyDocument(
IAmazonIdentityManagementService iamClient, string policyArn, string defaultVersion)
{
// Retrieve the policy document of the default version
GetPolicyVersionResponse responsePolicy =
await iamClient.GetPolicyVersionAsync(new GetPolicyVersionRequest{
PolicyArn = policyArn,
VersionId = defaultVersion});
// Display the policy document (in JSON)
Console.WriteLine($"Version {defaultVersion} of the policy (in JSON format):");
Console.WriteLine(
$"{HttpUtility.UrlDecode(responsePolicy.PolicyVersion.Document)}");
}
}
}
```
# Octroi d'accès à l'aide d'un rôle IAM
Octroi d'accès avec un rôle
Ce didacticiel explique comment utiliser le AWS SDK pour .NET pour activer les rôles IAM sur les instances Amazon EC2.
## Présentation de
Toutes les demandes AWS doivent être signées cryptographiquement à l'aide des informations d'identification émises par AWS. Par conséquent, vous avez besoin d'une stratégie pour gérer les informations d'identification des applications qui s'exécutent sur des instances Amazon EC2. Vous devez distribuer, stocker et faire pivoter ces informations d'identification en toute sécurité, mais également les garder accessibles aux applications.
Les rôles IAM vous permettent de gérer efficacement ces informations d'identification. Vous créez un rôle IAM et vous le configurez avec les autorisations requises par une application, puis vous attachez ce rôle à une instance EC2. Pour en savoir plus sur les avantages de l'utilisation des rôles IAM, consultez la section Rôles [IAM pour Amazon EC2 dans](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) le guide de l'utilisateur Amazon [EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Consultez également les informations sur les [rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) dans le guide de l'utilisateur IAM.
Pour une application créée à l'aide du AWS SDK pour .NET, lorsque l'application construit un objet client pour un AWS service, l'objet recherche des informations d'identification provenant de plusieurs sources potentielles. L'ordre dans lequel la recherche est effectué est indiqué dans[Résolution des informations d'identification et des profils](creds-assign.md).
Si l'objet client ne trouve pas d'informations d'identification provenant d'une autre source, il récupère des informations d'identification temporaires dotées des mêmes autorisations que celles qui ont été configurées dans le rôle IAM et figurent dans les métadonnées de l'instance EC2. Ces informations d'identification sont utilisées pour effectuer des appels AWS depuis l'objet client.
## À propos de ce didacticiel
Au fur et à mesure que vous suivez ce didacticiel, vous utilisez le AWS SDK pour .NET (et d'autres outils) pour lancer une instance Amazon EC2 avec un rôle IAM attaché, puis vous verrez une application sur l'instance utilisant les autorisations du rôle IAM.
**Topics**
+ [
## Présentation de
](#hosm-overview)
+ [
## À propos de ce didacticiel
](#about-hosm-tutorial)
+ [
## Création d'un exemple d'application Amazon S3
](#net-dg-hosm-sample-s3-app)
+ [
## Créer un rôle IAM
](#net-dg-hosm-create-the-role)
+ [
## Lancez une instance EC2 et attachez le rôle IAM
](#net-dg-hosm-launch-ec2-instance)
+ [
## Connectez-vous à l'instance EC2
](#net-dg-hosm-connect)
+ [
## Exécutez l'exemple d'application sur l'instance EC2
](#net-dg-hosm-run-the-app)
+ [
## Nettoyage
](#net-dg-hosm-cleanup)
## Création d'un exemple d'application Amazon S3
Cet exemple d'application récupère un objet depuis Amazon S3. Pour exécuter l'application, vous avez besoin des éléments suivants :
+ Un compartiment Amazon S3 contenant un fichier texte.
+ AWS informations d'identification sur votre machine de développement qui vous permettent d'accéder au bucket.
Pour plus d'informations sur la création d'un compartiment Amazon S3 et le téléchargement d'un objet, consultez le [guide de l'utilisateur d'Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/). Pour plus d'informations sur les AWS informations d'identification, consultez[Authentifier le AWS SDK pour .NET avec AWS](creds-idc.md).
Créez un projet .NET Core avec le code suivant. Testez ensuite l'application sur votre machine de développement.
**Note**
Sur votre machine de développement, le .NET Core Runtime est installé, ce qui vous permet d'exécuter l'application sans la publier. Lorsque vous créerez une instance EC2 ultérieurement dans ce didacticiel, vous pouvez choisir d'installer le .NET Core Runtime sur l'instance. Cela vous donne une expérience similaire et un transfert de fichiers plus réduit.
Toutefois, vous pouvez également choisir de ne pas installer le .NET Core Runtime sur l'instance. Si vous choisissez cette option, vous devez publier l'application afin que toutes les dépendances soient incluses lorsque vous la transférez vers l'instance.
### Références du SDK
NuGet colis :
+ [AWSSDKS.3](https://www.nuget.org/packages/AWSSDK.S3)
Éléments de programmation :
+ [Espace de noms Amazon.S3](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/NS3.html)
Classe : [Amazon S3 Client](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TS3Client.html)
+ [Espace de noms Amazon.S3.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/NS3Model.html)
Classe [GetObjectResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TGetObjectResponse.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
namespace S3GetTextItem
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to retrieve a text file from an S3 bucket and write it to a local file
class Program
{
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string bucket =
CommandLine.GetArgument(parsedArgs, null, "-b", "--bucket-name");
string item =
CommandLine.GetArgument(parsedArgs, null, "-t", "--text-object");
string outFile =
CommandLine.GetArgument(parsedArgs, null, "-o", "--output-filename");
if( string.IsNullOrEmpty(bucket)
|| string.IsNullOrEmpty(item)
|| string.IsNullOrEmpty(outFile))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
// Create the S3 client object and get the file object from the bucket.
var response = await GetObject(new AmazonS3Client(), bucket, item);
// Write the contents of the file object to the given output file.
var reader = new StreamReader(response.ResponseStream);
string contents = reader.ReadToEnd();
using (var s = new FileStream(outFile, FileMode.Create))
using (var writer = new StreamWriter(s))
writer.WriteLine(contents);
}
//
// Method to get an object from an S3 bucket.
private static async Task GetObject(
IAmazonS3 s3Client, string bucket, string item)
{
Console.WriteLine($"Retrieving {item} from bucket {bucket}.");
return await s3Client.GetObjectAsync(bucket, item);
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: S3GetTextItem -b -t -o " +
"\n -b, --bucket-name: The name of the S3 bucket." +
"\n -t, --text-object: The name of the text object in the bucket." +
"\n -o, --output-filename: The name of the file to write the text to.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
Si vous le souhaitez, vous pouvez supprimer temporairement les informations d'identification que vous utilisez sur votre machine de développement pour voir comment l'application répond. (Mais assurez-vous de restaurer les informations d'identification lorsque vous aurez terminé.)
## Créer un rôle IAM
Créez un rôle IAM doté des autorisations appropriées pour accéder à Amazon S3.
1. Ouvrez la [console IAM](https://console.aws.amazon.com/iam/).
1. Dans le volet de navigation, choisissez **Rôles**, puis **Create Role**.
1. Sélectionnez le **AWS service**, recherchez et choisissez **EC2**, puis choisissez **Next : Permissions**.
1. Sous **Joindre les politiques d'autorisation**, recherchez et sélectionnez **AmazonS3 ReadOnlyAccess**. Passez en revue la politique si vous le souhaitez, puis choisissez **Next : Tags**.
1. Ajoutez des balises si vous le souhaitez, puis choisissez **Suivant : Révision**.
1. Tapez un nom et une description pour le rôle, puis choisissez **Créer un rôle**. Conservez bien ce nom, car il vous sera utile lorsque vous lancerez votre instance EC2.
## Lancez une instance EC2 et attachez le rôle IAM
Lancez une instance EC2 avec le rôle IAM que vous avez créé précédemment. Vous pouvez le faire de différentes manières.
+ **Utilisation de la console EC2**
Pour lancer une instance à l'aide de la console EC2, consultez [Lancer une instance à l'aide du nouvel assistant de lancement d'instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Lorsque vous parcourez la page de lancement, vous devez au moins développer le volet **Détails avancés** afin de pouvoir spécifier le rôle IAM que vous avez créé précédemment dans le profil d'**instance IAM**.
+ **En utilisant le AWS SDK pour .NET**
Pour plus d'informations à ce sujet[Lancement d'une instance Amazon EC2](run-instance.md), voir, y compris la [Considérations supplémentaires](run-instance.md#run-instance-additional) fin de cette rubrique.
Pour lancer une instance EC2 à laquelle un rôle IAM est attaché, la configuration d'un utilisateur IAM doit inclure certaines autorisations. Pour plus d'informations sur les autorisations requises, consultez la section [Accorder à un utilisateur l'autorisation de transmettre un rôle IAM à une instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#permission-to-pass-iam-roles) dans le guide de l'utilisateur [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
## Connectez-vous à l'instance EC2
Connectez-vous à l'instance EC2 afin de pouvoir y transférer l'exemple d'application, puis exécuter l'application. Vous aurez besoin du fichier contenant la partie privée de la paire de clés que vous avez utilisée pour lancer l'instance, c'est-à-dire le fichier PEM.
Pour plus d'informations sur la connexion à une instance, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) ou [Connect to your Windows instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/). Lorsque vous vous connectez, faites-le de manière à pouvoir transférer des fichiers de votre machine de développement vers votre instance.
Si vous utilisez Visual Studio sous Windows, vous pouvez également vous connecter à l'instance à l'aide du Toolkit for Visual Studio. Pour plus d'informations, consultez la section [Connexion à une instance Amazon EC2](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/tkv-ec2-ami.html#connect-ec2) dans le guide de l' AWS Toolkit for Visual Studio utilisateur.
## Exécutez l'exemple d'application sur l'instance EC2
1. Copiez les fichiers d'application de votre disque local vers votre instance.
Les fichiers que vous transférez dépendent de la façon dont vous avez créé l'application et de l'installation du .NET Core Runtime sur votre instance. Pour plus d'informations sur le transfert de fichiers vers votre instance, consultez [Connect to your Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) (voir la sous-section appropriée) ou [Transférer des fichiers vers des instances Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instanceWindowsFileTransfer.html) dans le guide de l'[utilisateur Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
1. Lancez l'application et vérifiez qu'elle s'exécute avec les mêmes résultats que sur votre machine de développement.
1. Vérifiez que l'application utilise les informations d'identification fournies par le rôle IAM.
1. Ouvrez la [console Amazon EC2](https://console.aws.amazon.com/ec2/).
1. Sélectionnez l'instance et détachez le rôle IAM via **Actions**, **Paramètres de l'instance**, **Attacher/remplacer** le rôle IAM.
1. Exécutez à nouveau l'application et vérifiez qu'elle renvoie une erreur d'autorisation.
## Nettoyage
Lorsque vous aurez terminé ce didacticiel, et si vous ne souhaitez plus utiliser l'instance EC2 que vous avez créée, veillez à mettre fin à l'instance pour éviter des coûts inutiles. Vous pouvez le faire dans la [console Amazon EC2](https://console.aws.amazon.com/ec2/) ou par programmation, comme décrit dans. [Interruption d'une instance Amazon EC2](terminate-instance.md) Si vous le souhaitez, vous pouvez également supprimer d'autres ressources que vous avez créées pour ce didacticiel. Il peut s'agir d'un rôle IAM, d'une paire de clés EC2 et d'un fichier PEM, d'un groupe de sécurité, etc.
# Utilisation du stockage sur Internet d'Amazon Simple Storage Service
Amazon S3
Il AWS SDK pour .NET prend en charge [Amazon S3](https://aws.amazon.com/s3/), qui est un stockage pour Internet. Il est conçu pour faciliter l'informatique à l'échelle d'Internet pour les développeurs.
## APIs
Les AWS SDK pour .NET offres APIs pour les clients Amazon S3. Ils vous APIs permettent de travailler avec des ressources Amazon S3 telles que des compartiments et des articles. Pour consulter l'ensemble complet APIs de Amazon S3, consultez ce qui suit :
+ [AWS SDK pour .NET Référence d'API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) (et faites défiler la page jusqu'à « Amazon.S3 »).
+ [Amazon.Extensions.S3. Documentation sur](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.html) le chiffrement
Les Amazon S3 APIs sont fournis par les NuGet packages suivants :
+ [AWSSDKS.3](https://www.nuget.org/packages/AWSSDK.S3)
+ [Amazon Extensions.S3. Chiffrement](https://www.nuget.org/packages/Amazon.Extensions.S3.Encryption)
## Conditions préalables
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## Exemples présentés dans ce document
Les rubriques suivantes de ce document vous montrent comment utiliser le AWS SDK pour .NET pour travailler avec Amazon S3.
+ [Utilisation de clés KMS pour le chiffrement S3](kms-keys-s3-encryption.md)
## Exemples dans d'autres documents
Les liens suivants vers le [guide du développeur Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) fournissent des exemples supplémentaires de la façon d'utiliser le AWS SDK pour .NET pour travailler avec Amazon S3.
**Note**
Bien que ces exemples et considérations de programmation supplémentaires aient été créés pour la AWS SDK pour .NET version 3 du .NET Framework, ils sont également viables pour les versions ultérieures AWS SDK pour .NET de .NET Core. De petits ajustements dans le code sont parfois nécessaires.
**Exemples de programmation Amazon S3**
+ [Gérer ACLs](https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-using-dot-net-sdk.html)
+ [Création d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/dev/create-bucket-get-location-example.html#create-bucket-get-location-dotnet)
+ [Chargement d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/UploadObjSingleOpNET.html)
+ [Chargement en plusieurs parties avec l'API de haut niveau ([Amazon.S3.Transfer). TransferUtility](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TTransferUtility.html)](https://docs.aws.amazon.com/AmazonS3/latest/dev/usingHLmpuDotNet.html))
+ [Chargement partitionné avec l'API de bas niveau](https://docs.aws.amazon.com/AmazonS3/latest/dev/usingLLmpuDotNet.html)
+ [Liste des objets](https://docs.aws.amazon.com/AmazonS3/latest/dev/list-obj-version-enabled-bucket.html#list-obj-version-enabled-bucket-sdk-examples)
+ [Etablissement de la liste des clés](https://docs.aws.amazon.com/AmazonS3/latest/dev/ListingObjectKeysUsingNetSDK.html)
+ [Obtention d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/RetrievingObjectUsingNetSDK.html)
+ [Copie d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/CopyingObjectUsingNetSDK.html)
+ [Copie d'un objet grâce à l'API de chargement partitionné](https://docs.aws.amazon.com/AmazonS3/latest/dev/CopyingObjctsUsingLLNetMPUapi.html)
+ [Suppression d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingOneObjectUsingNetSDK.html)
+ [Suppression de plusieurs objets](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingMultipleObjectsUsingNetSDK.html)
+ [Restauration d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/restore-object-dotnet.html)
+ [Configuration des notifications d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/dev/ways-to-add-notification-config-to-bucket.html)
+ [Gestion du cycle de vie d'un objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/manage-lifecycle-using-dot-net.html)
+ [Génération d'une URL d'objet présignée](https://docs.aws.amazon.com/AmazonS3/latest/dev/ShareObjectPreSignedURLDotNetSDK.html)
+ [Gestion de sites web](https://docs.aws.amazon.com/AmazonS3/latest/dev/ConfigWebSiteDotNet.html)
+ [Activation du partage des ressources de plusieurs origines (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/ManageCorsUsingDotNet.html)
**Considérations supplémentaires relatives à la programmation**
+ [Utilisation du AWS SDK pour .NET pour la programmation d'Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingTheMPDotNetAPI.html)
+ [Demandes grâce aux informations d'identification temporaires de l'utilisateur IAM](https://docs.aws.amazon.com/AmazonS3/latest/dev/AuthUsingTempSessionTokenDotNet.html)
+ [Demandes grâce aux informations d'identification de sécurité temporaires de l'utilisateur fédéré](https://docs.aws.amazon.com/AmazonS3/latest/dev/AuthUsingTempFederationTokenDotNet.html)
+ [Spécification du chiffrement côté serveur](https://docs.aws.amazon.com/AmazonS3/latest/dev/SSEUsingDotNetSDK.html)
+ [Spécification du chiffrement côté serveur avec clés de chiffrement fournies par le client](https://docs.aws.amazon.com/AmazonS3/latest/dev/sse-c-using-dot-net-sdk.html)
# Utilisation de AWS KMS clés pour le chiffrement Amazon S3 dans AWS SDK pour .NET
Utilisation de clés KMS pour le chiffrement S3
Cet exemple montre comment utiliser des AWS Key Management Service clés pour chiffrer des objets Amazon S3. L'application crée une clé principale client (CMK) et l'utilise pour créer un objet [AmazonS3 EncryptionClient V2](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html) pour le chiffrement côté client. L'application utilise ce client pour créer un objet chiffré à partir d'un fichier texte donné dans un compartiment Amazon S3 existant. Il déchiffre ensuite l'objet et affiche son contenu.
**Avertissement**
Une classe similaire appelée `AmazonS3EncryptionClient` est obsolète et est moins sécurisée que la `AmazonS3EncryptionClientV2` classe. Pour migrer le code existant qui utilise`AmazonS3EncryptionClient`, voir[Migration du client de chiffrement S3 (V1 vers V2)](s3-encryption-migration-v1-v2.md).
**Topics**
+ [
## Création de matériel de chiffrement
](#kms-s3-enc-mat)
+ [
## Création et chiffrement d'un objet Amazon S3
](#kms-s3-create-ojbect)
+ [
## Code complet
](#kms-s3-complete-code)
+ [
## Considérations supplémentaires
](#kms-s3-additional)
## Création de matériel de chiffrement
L'extrait de code suivant crée un `EncryptionMaterials` objet contenant un ID de clé KMS.
L'exemple [à la fin de cette rubrique](#kms-s3-complete-code) montre cet extrait en cours d'utilisation.
```
// Create a customer master key (CMK) and store the result
CreateKeyResponse createKeyResponse =
await new AmazonKeyManagementServiceClient().CreateKeyAsync(new CreateKeyRequest());
var kmsEncryptionContext = new Dictionary();
var kmsEncryptionMaterials = new EncryptionMaterialsV2(
createKeyResponse.KeyMetadata.KeyId, KmsType.KmsContext, kmsEncryptionContext);
```
## Création et chiffrement d'un objet Amazon S3
L'extrait de code suivant crée un `AmazonS3EncryptionClientV2` objet qui utilise les matériaux de chiffrement créés précédemment. Il utilise ensuite le client pour créer et chiffrer un nouvel objet Amazon S3.
L'exemple [à la fin de cette rubrique](#kms-s3-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to create and encrypt an object in an S3 bucket
static async Task CreateAndRetrieveObjectAsync(
EncryptionMaterialsV2 materials, string bucketName,
string fileName, string itemName)
{
// CryptoStorageMode.ObjectMetadata is required for KMS EncryptionMaterials
var config = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy)
{
StorageMode = CryptoStorageMode.ObjectMetadata
};
var s3EncClient = new AmazonS3EncryptionClientV2(config, materials);
// Create, encrypt, and put the object
await s3EncClient.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = itemName,
ContentBody = File.ReadAllText(fileName)
});
// Get, decrypt, and return the object
return await s3EncClient.GetObjectAsync(new GetObjectRequest
{
BucketName = bucketName,
Key = itemName
});
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [Amazon Extensions.S3. Chiffrement](https://www.nuget.org/packages/Amazon.Extensions.S3.Encryption)
Éléments de programmation :
+ [Espace de noms Amazon.Extensions.S3.Encryption](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.html)
Classe [Amazon S3 V2 EncryptionClient](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html)
Classe [Amazon S3 V2 CryptoConfiguration](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3CryptoConfigurationV2.html)
Classe [CryptoStorageMode](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.CryptoStorageMode.html)
Classe [EncryptionMaterialsV2](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.EncryptionMaterialsV2.html)
+ [Espace de noms Amazon.Extensions.S3.Encryption.Primitives](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.Primitives.html)
Classe [KmsType](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.Primitives.KmsType.html)
+ [Espace de noms Amazon.S3.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/NS3Model.html)
Classe [GetObjectRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TGetObjectRequest.html)
Classe [GetObjectResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TGetObjectResponse.html)
Classe [PutObjectRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/S3/TPutObjectRequest.html)
+ Espace de noms [Amazon. KeyManagementService](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/NKeyManagementService.html)
Classe [AmazonKeyManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/TKeyManagementServiceClient.html)
+ Espace de noms [Amazon. KeyManagementService.Modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/NKeyManagementServiceModel.html)
Classe [CreateKeyRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/TCreateKeyRequest.html)
Classe [CreateKeyResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/TCreateKeyResponse.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Amazon.Extensions.S3.Encryption;
using Amazon.Extensions.S3.Encryption.Primitives;
using Amazon.S3.Model;
using Amazon.KeyManagementService;
using Amazon.KeyManagementService.Model;
namespace KmsS3Encryption
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to store text in an encrypted S3 object.
class Program
{
private const int MaxArgs = 3;
public static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if((parsedArgs.Count == 0) || (parsedArgs.Count > MaxArgs))
{
PrintHelp();
return;
}
// Get the application arguments from the parsed list
string bucketName =
CommandLine.GetArgument(parsedArgs, null, "-b", "--bucket-name");
string fileName =
CommandLine.GetArgument(parsedArgs, null, "-f", "--file-name");
string itemName =
CommandLine.GetArgument(parsedArgs, null, "-i", "--item-name");
if(string.IsNullOrEmpty(bucketName) || (string.IsNullOrEmpty(fileName)))
CommandLine.ErrorExit(
"\nOne or more of the required arguments is missing or incorrect." +
"\nRun the command with no arguments to see help.");
if(!File.Exists(fileName))
CommandLine.ErrorExit($"\nThe given file {fileName} doesn't exist.");
if(string.IsNullOrEmpty(itemName))
itemName = Path.GetFileName(fileName);
// Create a customer master key (CMK) and store the result
CreateKeyResponse createKeyResponse =
await new AmazonKeyManagementServiceClient().CreateKeyAsync(new CreateKeyRequest());
var kmsEncryptionContext = new Dictionary();
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, fileName, itemName);
Stream stream = putObjectResponse.ResponseStream;
StreamReader reader = new StreamReader(stream);
Console.WriteLine(reader.ReadToEnd());
}
//
// Method to create and encrypt an object in an S3 bucket
static async Task CreateAndRetrieveObjectAsync(
EncryptionMaterialsV2 materials, string bucketName,
string fileName, string itemName)
{
// CryptoStorageMode.ObjectMetadata is required for KMS EncryptionMaterials
var config = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2AndLegacy)
{
StorageMode = CryptoStorageMode.ObjectMetadata
};
var s3EncClient = new AmazonS3EncryptionClientV2(config, materials);
// Create, encrypt, and put the object
await s3EncClient.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = itemName,
ContentBody = File.ReadAllText(fileName)
});
// Get, decrypt, and return the object
return await s3EncClient.GetObjectAsync(new GetObjectRequest
{
BucketName = bucketName,
Key = itemName
});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: KmsS3Encryption -b -f [-i ]" +
"\n -b, --bucket-name: The name of an existing S3 bucket." +
"\n -f, --file-name: The name of a text file with content to encrypt and store in S3." +
"\n -i, --item-name: The name you want to use for the item." +
"\n If item-name isn't given, file-name will be used.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Vous pouvez vérifier les résultats de cet exemple. Pour ce faire, accédez à la [console Amazon S3](https://console.aws.amazon.com/s3) et ouvrez le compartiment que vous avez fourni à l'application. Recherchez ensuite le nouvel objet, téléchargez-le et ouvrez-le dans un éditeur de texte.
+ La classe [AmazonS3 EncryptionClient V2](https://aws.github.io/amazon-s3-encryption-client-dotnet/api/Amazon.Extensions.S3.Encryption.AmazonS3EncryptionClientV2.html) implémente la même interface que la classe standard`AmazonS3Client`. Cela facilite le portage de votre code vers la `AmazonS3EncryptionClientV2` classe afin que le chiffrement et le déchiffrement se fassent automatiquement et de manière transparente dans le client.
+ L'un des avantages de l'utilisation d'une AWS KMS clé comme clé principale est que vous n'avez pas besoin de stocker et de gérer vos propres clés principales ; cela se fait par AWS. Un deuxième avantage est que la `AmazonS3EncryptionClientV2` classe du AWS SDK pour .NET est interopérable avec la `AmazonS3EncryptionClientV2` classe du AWS SDK pour Java. Cela signifie que vous pouvez chiffrer avec le AWS SDK pour Java et déchiffrer avec le AWS SDK pour .NET, et vice versa.
**Note**
La `AmazonS3EncryptionClientV2` classe des AWS SDK pour .NET prend en charge les clés principales KMS uniquement lorsqu'elle est exécutée en mode métadonnées. Le mode de fichier d'instructions de la `AmazonS3EncryptionClientV2` classe du AWS SDK pour .NET est incompatible avec la `AmazonS3EncryptionClientV2` classe du AWS SDK pour Java.
+ Pour plus d'informations sur le chiffrement côté client avec cette `AmazonS3EncryptionClientV2` classe et sur le fonctionnement du chiffrement d'enveloppe, consultez la section [Chiffrement des données côté client avec Amazon AWS SDK pour .NET S3](https://aws.amazon.com/blogs/developer/client-side-data-encryption-with-aws-sdk-for-net-and-amazon-s3/).
# Envoyer des notifications depuis le cloud à l'aide d'Amazon Simple Notification Service
Amazon SNS
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
Il AWS SDK pour .NET prend en charge Amazon Simple Notification Service (Amazon SNS), un service Web qui permet aux applications, aux utilisateurs finaux et aux appareils d'envoyer instantanément des notifications depuis le cloud. Pour plus d'informations, consultez [Amazon SNS](https://aws.amazon.com/sns/).
## Répertorier vos rubriques Amazon SNS
L'exemple suivant montre comment répertorier vos rubriques Amazon SNS, les abonnements à chaque rubrique et les attributs de chaque rubrique. Cet exemple utilise la valeur par défaut [AmazonSimpleNotificationServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SNS/TSNSClient.html).
```
// 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));
```
## Envoyer un message à une rubrique Amazon SNS
L'exemple suivant montre comment envoyer un message à une rubrique Amazon SNS. L'exemple prend un argument, l'ARN de la rubrique Amazon SNS.
```
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](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/.dotnet/example_code_legacy/SNS/SnsSendMessage.cs), y compris les informations sur la façon de créer et d'exécuter l'exemple à partir de la ligne de commande, sur GitHub.
## Envoi d'un SMS à un numéro de téléphone
L'exemple suivant montre comment envoyer un SMS à un numéro de téléphone. L'exemple utilise un argument, 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;
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](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/.dotnet/example_code_legacy/SNS/SnsPublish.cs), y compris les informations sur la façon de créer et d'exécuter l'exemple à partir de la ligne de commande, sur GitHub.
# Messagerie à l'aide d'Amazon SQS
Amazon SQS
Il AWS SDK pour .NET prend en charge [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/)), un service de mise en file d'attente de messages qui gère les messages ou les flux de travail entre les composants d'un système.
Les files d'attente Amazon SQS fournissent un mécanisme qui vous permet d'envoyer, de stocker et de recevoir des messages entre des composants logiciels tels que des microservices, des systèmes distribués et des applications sans serveur. Cela vous permet de dissocier ces composants et vous évite de devoir concevoir et exploiter votre propre système de messagerie. Pour plus d'informations sur le fonctionnement des files d'attente et des messages dans Amazon SQS, consultez les didacticiels [Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-other-tutorials.html) et l'[architecture de base d'Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) dans le manuel [Amazon](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/) Simple Queue Service Developer Guide.
**Important**
En raison de la nature distribuée des files d'attente, Amazon SQS ne peut garantir que vous recevrez les messages dans l'ordre précis dans lequel ils sont envoyés. Si vous devez préserver l'ordre des messages, utilisez une file d'attente [FIFO Amazon SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-fifo-queues.html)
## APIs
Les AWS SDK pour .NET offres APIs pour les clients Amazon SQS. Ils vous APIs permettent de travailler avec les fonctionnalités d'Amazon SQS telles que les files d'attente et les messages. Cette section contient un petit nombre d'exemples qui vous montrent les modèles que vous pouvez suivre lorsque vous travaillez avec ces outils APIs. Pour voir l'ensemble complet de APIs, consultez la [référence de l'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) (et faites défiler la page jusqu'à « Amazon.sqs »).
Les Amazon SQS APIs sont fournis par le package [AWSSDK NuGet .SQS](https://www.nuget.org/packages/AWSSDK.SQS).
## Conditions préalables
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## Rubriques
**Topics**
+ [
## APIs
](#w2aac19c15c29b9)
+ [
## Conditions préalables
](#w2aac19c15c29c11)
+ [
## Rubriques
](#w2aac19c15c29c13)
+ [Création de files d'attente](CreateQueue.md)
+ [Mise à jour des files d'attente](UpdateSqsQueue.md)
+ [Supprimer des files d'attente](DeleteSqsQueue.md)
+ [Envoi de messages](SendMessage.md)
+ [Réception de messages](ReceiveMessage.md)
# Création de files d'attente Amazon SQS
Création de files d'attente
Cet exemple vous montre comment utiliser le pour AWS SDK pour .NET créer une file d'attente Amazon SQS. L'application crée une [file d'attente contenant des lettres mortes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) si vous n'en fournissez pas l'ARN. Il crée ensuite une file de messages standard, qui inclut une file de lettres mortes (celle que vous avez fournie ou celle qui a été créée).
Si vous ne fournissez aucun argument de ligne de commande, l'application affiche simplement des informations sur toutes les files d'attente existantes.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#CreateQueue-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Afficher les files d'attente existantes
](#CreateQueue-show-queues)
+ [
## Création de la file d'attente
](#CreateQueue-create-queue)
+ [
## Obtenir l'ARN d'une file d'attente
](#CreateQueue-get-arn)
+ [
## Code complet
](#CreateQueue-complete-code)
+ [
## Considérations supplémentaires
](#CreateQueue-additional)
## Afficher les files d'attente existantes
L'extrait suivant présente une liste des files d'attente existantes dans la région du client SQS et les attributs de chaque file d'attente.
L'exemple [à la fin de cette rubrique](#CreateQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to show a list of the existing queues
private static async Task ShowQueues(IAmazonSQS sqsClient)
{
ListQueuesResponse responseList = await sqsClient.ListQueuesAsync("");
Console.WriteLine();
foreach(string qUrl in responseList.QueueUrls)
{
// Get and show all attributes. Could also get a subset.
await ShowAllAttributes(sqsClient, qUrl);
}
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
var attributes = new List{ QueueAttributeName.All };
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl, attributes);
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
```
## Création de la file d'attente
L'extrait suivant crée une file d'attente. L'extrait inclut l'utilisation d'une file d'attente de lettres mortes, mais une file d'attente de lettres mortes n'est pas nécessairement requise pour vos files d'attente.
L'exemple [à la fin de cette rubrique](#CreateQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to create a queue. Returns the queue URL.
private static async Task CreateQueue(
IAmazonSQS sqsClient, string qName, string deadLetterQueueUrl=null,
string maxReceiveCount=null, string receiveWaitTime=null)
{
var attrs = new Dictionary();
// If a dead-letter queue is given, create a message queue
if(!string.IsNullOrEmpty(deadLetterQueueUrl))
{
attrs.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, receiveWaitTime);
attrs.Add(QueueAttributeName.RedrivePolicy,
$"{{\"deadLetterTargetArn\":\"{await GetQueueArn(sqsClient, deadLetterQueueUrl)}\"," +
$"\"maxReceiveCount\":\"{maxReceiveCount}\"}}");
// Add other attributes for the message queue such as VisibilityTimeout
}
// If no dead-letter queue is given, create one of those instead
//else
//{
// // Add attributes for the dead-letter queue as needed
// attrs.Add();
//}
// Create the queue
CreateQueueResponse responseCreate = await sqsClient.CreateQueueAsync(
new CreateQueueRequest{QueueName = qName, Attributes = attrs});
return responseCreate.QueueUrl;
}
```
## Obtenir l'ARN d'une file d'attente
L'extrait suivant obtient l'ARN de la file d'attente identifiée par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#CreateQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to get the ARN of a queue
private static async Task GetQueueArn(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt = await sqsClient.GetQueueAttributesAsync(
qUrl, new List{QueueAttributeName.QueueArn});
return responseGetAtt.QueueARN;
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Éléments de programmation :
+ [Espace de noms Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQS.html)
Classe [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html)
Classe [QueueAttributeName](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TQueueAttributeName.html)
+ [Espace de noms Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQSModel.html)
Classe [CreateQueueRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TCreateQueueRequest.html)
Classe [CreateQueueResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TCreateQueueResponse.html)
Classe [GetQueueAttributesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TGetQueueAttributesResponse.html)
Classe [ListQueuesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TListQueuesResponse.html)
### Le code
```
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSCreateQueue
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to create a queue
class Program
{
private const string MaxReceiveCount = "10";
private const string ReceiveMessageWaitTime = "2";
private const int MaxArgs = 3;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count > MaxArgs)
CommandLine.ErrorExit(
"\nToo many command-line arguments.\nRun the command with no arguments to see help.");
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// In the case of no command-line arguments, just show help and the existing queues
if(parsedArgs.Count == 0)
{
PrintHelp();
Console.WriteLine("\nNo arguments specified.");
Console.Write("Do you want to see a list of the existing queues? ((y) or n): ");
string response = Console.ReadLine();
if((string.IsNullOrEmpty(response)) || (response.ToLower() == "y"))
await ShowQueues(sqsClient);
return;
}
// Get the application arguments from the parsed list
string queueName =
CommandLine.GetArgument(parsedArgs, null, "-q", "--queue-name");
string deadLetterQueueUrl =
CommandLine.GetArgument(parsedArgs, null, "-d", "--dead-letter-queue");
string maxReceiveCount =
CommandLine.GetArgument(parsedArgs, MaxReceiveCount, "-m", "--max-receive-count");
string receiveWaitTime =
CommandLine.GetArgument(parsedArgs, ReceiveMessageWaitTime, "-w", "--wait-time");
if(string.IsNullOrEmpty(queueName))
CommandLine.ErrorExit(
"\nYou must supply a queue name.\nRun the command with no arguments to see help.");
// If a dead-letter queue wasn't given, create one
if(string.IsNullOrEmpty(deadLetterQueueUrl))
{
Console.WriteLine("\nNo dead-letter queue was specified. Creating one...");
deadLetterQueueUrl = await CreateQueue(sqsClient, queueName + "__dlq");
Console.WriteLine($"Your new dead-letter queue:");
await ShowAllAttributes(sqsClient, deadLetterQueueUrl);
}
// Create the message queue
string messageQueueUrl = await CreateQueue(
sqsClient, queueName, deadLetterQueueUrl, maxReceiveCount, receiveWaitTime);
Console.WriteLine($"Your new message queue:");
await ShowAllAttributes(sqsClient, messageQueueUrl);
}
//
// Method to show a list of the existing queues
private static async Task ShowQueues(IAmazonSQS sqsClient)
{
ListQueuesResponse responseList = await sqsClient.ListQueuesAsync("");
Console.WriteLine();
foreach(string qUrl in responseList.QueueUrls)
{
// Get and show all attributes. Could also get a subset.
await ShowAllAttributes(sqsClient, qUrl);
}
}
//
// Method to create a queue. Returns the queue URL.
private static async Task CreateQueue(
IAmazonSQS sqsClient, string qName, string deadLetterQueueUrl=null,
string maxReceiveCount=null, string receiveWaitTime=null)
{
var attrs = new Dictionary();
// If a dead-letter queue is given, create a message queue
if(!string.IsNullOrEmpty(deadLetterQueueUrl))
{
attrs.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, receiveWaitTime);
attrs.Add(QueueAttributeName.RedrivePolicy,
$"{{\"deadLetterTargetArn\":\"{await GetQueueArn(sqsClient, deadLetterQueueUrl)}\"," +
$"\"maxReceiveCount\":\"{maxReceiveCount}\"}}");
// Add other attributes for the message queue such as VisibilityTimeout
}
// If no dead-letter queue is given, create one of those instead
//else
//{
// // Add attributes for the dead-letter queue as needed
// attrs.Add();
//}
// Create the queue
CreateQueueResponse responseCreate = await sqsClient.CreateQueueAsync(
new CreateQueueRequest{QueueName = qName, Attributes = attrs});
return responseCreate.QueueUrl;
}
//
// Method to get the ARN of a queue
private static async Task GetQueueArn(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt = await sqsClient.GetQueueAttributesAsync(
qUrl, new List{QueueAttributeName.QueueArn});
return responseGetAtt.QueueARN;
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
var attributes = new List{ QueueAttributeName.All };
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl, attributes);
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine(
"\nUsage: SQSCreateQueue -q [-d ]" +
" [-m ] [-w ]" +
"\n -q, --queue-name: The name of the queue you want to create." +
"\n -d, --dead-letter-queue: The URL of an existing queue to be used as the dead-letter queue."+
"\n If this argument isn't supplied, a new dead-letter queue will be created." +
"\n -m, --max-receive-count: The value for maxReceiveCount in the RedrivePolicy of the queue." +
$"\n Default is {MaxReceiveCount}." +
"\n -w, --wait-time: The value for ReceiveMessageWaitTimeSeconds of the queue for long polling." +
$"\n Default is {ReceiveMessageWaitTime}.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Le nom de votre file d'attente doit être composé de caractères alphanumériques, de traits d'union et de traits de soulignement.
+ Les noms et les files d'attente URLs font la distinction majuscules/minuscules
+ Si vous avez besoin de l'URL de la file d'attente mais que vous n'avez que le nom de la file d'attente, utilisez l'une `AmazonSQSClient.GetQueueUrlAsync` des méthodes.
+ Pour plus d'informations sur les différents attributs de file d'attente que vous pouvez définir, consultez [CreateQueueRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TCreateQueueRequest.html)la [référence d'AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/) ou [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)la [référence d'API Amazon Simple Queue Service](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/).
+ Cet exemple indique une longue période d'interrogation pour tous les messages de la file d'attente que vous créez. Cela se fait à l'aide de l'`ReceiveMessageWaitTimeSeconds`attribut.
Vous pouvez également spécifier un long sondage lors d'un appel aux `ReceiveMessageAsync` méthodes de la SQSClient classe [Amazon](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html). Pour de plus amples informations, veuillez consulter [Réception de messages Amazon SQS](ReceiveMessage.md).
Pour plus d'informations sur les sondages courts par rapport aux sondages longs, consultez la section Sondage [court et long](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html) du manuel *Amazon Simple Queue Service Developer Guide*.
+ Une file d'attente de lettres mortes est une file que les autres files d'attente (source) peuvent cibler pour les messages qui ne sont pas traités correctement. Pour plus d'informations, consultez les [files d'attente contenant des lettres mortes Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) dans le guide du développeur Amazon Simple Queue Service.
+ Vous pouvez également consulter la liste des files d'attente et les résultats de cet exemple dans la console [Amazon SQS](https://console.aws.amazon.com/sqs).
# Mise à jour des files d'attente Amazon SQS
Mise à jour des files d'attente
Cet exemple vous montre comment utiliser le pour mettre AWS SDK pour .NET à jour une file d'attente Amazon SQS. Après quelques vérifications, l'application met à jour l'attribut donné avec la valeur donnée, puis affiche tous les attributs de la file d'attente.
Si seule l'URL de la file d'attente est incluse dans les arguments de la ligne de commande, l'application affiche simplement tous les attributs de la file d'attente.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#UpdateSqsQueue-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Afficher les attributs de file d'attente
](#UpdateSqsQueue-show-attributes)
+ [
## Valider le nom d'attribut
](#UpdateSqsQueue-validate-attribute)
+ [
## Mettre à jour l'attribut de file
](#UpdateSqsQueue-update-attribute)
+ [
## Code complet
](#UpdateSqsQueue-complete-code)
+ [
## Considérations supplémentaires
](#UpdateSqsQueue-additional)
## Afficher les attributs de file d'attente
L'extrait suivant montre les attributs de la file d'attente identifiés par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#UpdateSqsQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl,
new List{ QueueAttributeName.All });
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
```
## Valider le nom d'attribut
L'extrait suivant valide le nom de l'attribut mis à jour.
L'exemple [à la fin de cette rubrique](#UpdateSqsQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to check the name of the attribute
private static bool ValidAttribute(string attribute)
{
var attOk = false;
var qAttNameType = typeof(QueueAttributeName);
List qAttNamefields = new List();
foreach(var field in qAttNameType.GetFields())
qAttNamefields.Add(field.Name);
foreach(var name in qAttNamefields)
if(attribute == name) { attOk = true; break; }
return attOk;
}
```
## Mettre à jour l'attribut de file
L'extrait suivant met à jour un attribut de la file d'attente identifié par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#UpdateSqsQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to update a queue attribute
private static async Task UpdateAttribute(
IAmazonSQS sqsClient, string qUrl, string attribute, string value)
{
await sqsClient.SetQueueAttributesAsync(qUrl,
new Dictionary{{attribute, value}});
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Éléments de programmation :
+ [Espace de noms Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQS.html)
Classe [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html)
Classe [QueueAttributeName](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TQueueAttributeName.html)
+ [Espace de noms Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQSModel.html)
Classe [GetQueueAttributesResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TGetQueueAttributesResponse.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSUpdateQueue
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to update a queue
class Program
{
private const int MaxArgs = 3;
private const int InvalidArgCount = 2;
static async Task Main(string[] args)
{
// Parse the command line and show help if necessary
var parsedArgs = CommandLine.Parse(args);
if(parsedArgs.Count == 0)
{
PrintHelp();
return;
}
if((parsedArgs.Count > MaxArgs) || (parsedArgs.Count == InvalidArgCount))
CommandLine.ErrorExit("\nThe number of command-line arguments is incorrect." +
"\nRun the command with no arguments to see help.");
// Get the application arguments from the parsed list
var qUrl = CommandLine.GetArgument(parsedArgs, null, "-q");
var attribute = CommandLine.GetArgument(parsedArgs, null, "-a");
var value = CommandLine.GetArgument(parsedArgs, null, "-v", "--value");
if(string.IsNullOrEmpty(qUrl))
CommandLine.ErrorExit("\nYou must supply at least a queue URL." +
"\nRun the command with no arguments to see help.");
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// In the case of one command-line argument, just show the attributes for the queue
if(parsedArgs.Count == 1)
await ShowAllAttributes(sqsClient, qUrl);
// Otherwise, attempt to update the given queue attribute with the given value
else
{
// Check to see if the attribute is valid
if(ValidAttribute(attribute))
{
// Perform the update and then show all the attributes of the queue
await UpdateAttribute(sqsClient, qUrl, attribute, value);
await ShowAllAttributes(sqsClient, qUrl);
}
else
{
Console.WriteLine($"\nThe given attribute name, {attribute}, isn't valid.");
}
}
}
//
// Method to show all attributes of a queue
private static async Task ShowAllAttributes(IAmazonSQS sqsClient, string qUrl)
{
GetQueueAttributesResponse responseGetAtt =
await sqsClient.GetQueueAttributesAsync(qUrl,
new List{ QueueAttributeName.All });
Console.WriteLine($"Queue: {qUrl}");
foreach(var att in responseGetAtt.Attributes)
Console.WriteLine($"\t{att.Key}: {att.Value}");
}
//
// Method to check the name of the attribute
private static bool ValidAttribute(string attribute)
{
var attOk = false;
var qAttNameType = typeof(QueueAttributeName);
List qAttNamefields = new List();
foreach(var field in qAttNameType.GetFields())
qAttNamefields.Add(field.Name);
foreach(var name in qAttNamefields)
if(attribute == name) { attOk = true; break; }
return attOk;
}
//
// Method to update a queue attribute
private static async Task UpdateAttribute(
IAmazonSQS sqsClient, string qUrl, string attribute, string value)
{
await sqsClient.SetQueueAttributesAsync(qUrl,
new Dictionary{{attribute, value}});
}
//
// Command-line help
private static void PrintHelp()
{
Console.WriteLine("\nUsage: SQSUpdateQueue -q queue_url [-a attribute -v value]");
Console.WriteLine(" -q: The URL of the queue you want to update.");
Console.WriteLine(" -a: The name of the attribute to update.");
Console.WriteLine(" -v, --value: The value to assign to the attribute.");
}
}
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class that represents a command line on the console or terminal.
// (This is the same for all examples. When you have seen it once, you can ignore it.)
static class CommandLine
{
//
// Method to parse a command line of the form: "--key value" or "-k value".
//
// Parameters:
// - args: The command-line arguments passed into the application by the system.
//
// Returns:
// A Dictionary with string Keys and Values.
//
// If a key is found without a matching value, Dictionary.Value is set to the key
// (including the dashes).
// If a value is found without a matching key, Dictionary.Key is set to "--NoKeyN",
// where "N" represents sequential numbers.
public static Dictionary Parse(string[] args)
{
var parsedArgs = new Dictionary();
int i = 0, n = 0;
while(i < args.Length)
{
// If the first argument in this iteration starts with a dash it's an option.
if(args[i].StartsWith("-"))
{
var key = args[i++];
var value = key;
// Check to see if there's a value that goes with this option?
if((i < args.Length) && (!args[i].StartsWith("-"))) value = args[i++];
parsedArgs.Add(key, value);
}
// If the first argument in this iteration doesn't start with a dash, it's a value
else
{
parsedArgs.Add("--NoKey" + n.ToString(), args[i++]);
n++;
}
}
return parsedArgs;
}
//
// Method to get an argument from the parsed command-line arguments
//
// Parameters:
// - parsedArgs: The Dictionary object returned from the Parse() method (shown above).
// - defaultValue: The default string to return if the specified key isn't in parsedArgs.
// - keys: An array of keys to look for in parsedArgs.
public static string GetArgument(
Dictionary parsedArgs, string defaultReturn, params string[] keys)
{
string retval = null;
foreach(var key in keys)
if(parsedArgs.TryGetValue(key, out retval)) break;
return retval ?? defaultReturn;
}
//
// Method to exit the application with an error.
public static void ErrorExit(string msg, int code=1)
{
Console.WriteLine("\nError");
Console.WriteLine(msg);
Environment.Exit(code);
}
}
}
```
## Considérations supplémentaires
+ Pour mettre à jour l'`RedrivePolicy`attribut, vous devez mettre la valeur entière entre guillemets et éviter les guillemets pour les key/value paires, en fonction de votre système d'exploitation.
Sous Windows, par exemple, la valeur est construite de la manière suivante :
```
"{\"deadLetterTargetArn\":\"DEAD_LETTER-QUEUE-ARN\",\"maxReceiveCount\":\"10\"}"
```
# Suppression des files d'attente Amazon SQS
Supprimer des files d'attente
Cet exemple vous montre comment utiliser le pour AWS SDK pour .NET supprimer une file d'attente Amazon SQS. L'application supprime la file d'attente, attend qu'elle disparaisse pendant un certain temps, puis affiche la liste des files d'attente restantes.
Si vous ne fournissez aucun argument de ligne de commande, l'application affiche simplement une liste des files d'attente existantes.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#DeleteSqsQueue-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Supprimer la file d'attente
](#DeleteSqsQueue-delete-queue)
+ [
## Attendez que la file d'attente soit terminée
](#DeleteSqsQueue-wait)
+ [
## Afficher la liste des files d'attente existantes
](#DeleteSqsQueue-list-queues)
+ [
## Code complet
](#DeleteSqsQueue-complete-code)
+ [
## Considérations supplémentaires
](#DeleteSqsQueue-additional)
## Supprimer la file d'attente
L'extrait suivant supprime la file d'attente identifiée par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#DeleteSqsQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to delete an SQS queue
private static async Task DeleteQueue(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"Deleting queue {qUrl}...");
await sqsClient.DeleteQueueAsync(qUrl);
Console.WriteLine($"Queue {qUrl} has been deleted.");
}
```
## Attendez que la file d'attente soit terminée
L'extrait suivant attend la fin du processus de suppression, ce qui peut prendre 60 secondes.
L'exemple [à la fin de cette rubrique](#DeleteSqsQueue-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to wait up to a given number of seconds
private static async Task Wait(
IAmazonSQS sqsClient, int numSeconds, string qUrl)
{
Console.WriteLine($"Waiting for up to {numSeconds} seconds.");
Console.WriteLine("Press any key to stop waiting. (Response might be slightly delayed.)");
for(int i=0; i messages)
{
Console.WriteLine($"\nSending a batch of messages to queue\n {qUrl}");
SendMessageBatchResponse responseSendBatch =
await sqsClient.SendMessageBatchAsync(qUrl, messages);
// Could test responseSendBatch.Failed here
foreach(SendMessageBatchResultEntry entry in responseSendBatch.Successful)
Console.WriteLine($"Message {entry.Id} successfully queued.");
}
```
## Supprimer tous les messages de la file d'attente
L'extrait suivant supprime tous les messages de la file d'attente identifiée par l'URL de file d'attente donnée. Cette opération est également connue sous le nom de *purge de la file d'attente*.
L'exemple [à la fin de cette rubrique](#SendMessage-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to delete all messages from the queue
private static async Task DeleteAllMessages(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"\nPurging messages from queue\n {qUrl}...");
PurgeQueueResponse responsePurge = await sqsClient.PurgeQueueAsync(qUrl);
Console.WriteLine($"HttpStatusCode: {responsePurge.HttpStatusCode}");
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Éléments de programmation :
+ [Espace de noms Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQS.html)
Classe [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html)
+ [Espace de noms Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQSModel.html)
Classe [PurgeQueueResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TPurgeQueueResponse.html)
Classe [SendMessageBatchResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSendMessageBatchResponse.html)
Classe [SendMessageResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSendMessageResponse.html)
Classe [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSendMessageBatchRequestEntry.html)
Classe [SendMessageBatchResultEntry](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSendMessageBatchResultEntry.html)
### Le code
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSSendMessages
{
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
// Class to send messages to a queue
class Program
{
// Some example messages to send to the queue
private const string JsonMessage = "{\"product\":[{\"name\":\"Product A\",\"price\": \"32\"},{\"name\": \"Product B\",\"price\": \"27\"}]}";
private const string XmlMessage = "";
private const string CustomMessage = "||product|Product A|32||product|Product B|27||";
private const string TextMessage = "Just a plain text message.";
static async Task Main(string[] args)
{
// Do some checks on the command-line
if(args.Length == 0)
{
Console.WriteLine("\nUsage: SQSSendMessages queue_url");
Console.WriteLine(" queue_url - The URL of an existing SQS queue.");
return;
}
if(!args[0].StartsWith("https://sqs."))
{
Console.WriteLine("\nThe command-line argument isn't a queue URL:");
Console.WriteLine($"{args[0]}");
return;
}
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// (could verify that the queue exists)
// Send some example messages to the given queue
// A single message
await SendMessage(sqsClient, args[0], JsonMessage);
// A batch of messages
var batchMessages = new List{
new SendMessageBatchRequestEntry("xmlMsg", XmlMessage),
new SendMessageBatchRequestEntry("customeMsg", CustomMessage),
new SendMessageBatchRequestEntry("textMsg", TextMessage)};
await SendMessageBatch(sqsClient, args[0], batchMessages);
// Let the user send their own messages or quit
await InteractWithUser(sqsClient, args[0]);
// Delete all messages that are still in the queue
await DeleteAllMessages(sqsClient, args[0]);
}
//
// Method to put a message on a queue
// Could be expanded to include message attributes, etc., in a SendMessageRequest
private static async Task SendMessage(
IAmazonSQS sqsClient, string qUrl, string messageBody)
{
SendMessageResponse responseSendMsg =
await sqsClient.SendMessageAsync(qUrl, messageBody);
Console.WriteLine($"Message added to queue\n {qUrl}");
Console.WriteLine($"HttpStatusCode: {responseSendMsg.HttpStatusCode}");
}
//
// Method to put a batch of messages on a queue
// Could be expanded to include message attributes, etc.,
// in the SendMessageBatchRequestEntry objects
private static async Task SendMessageBatch(
IAmazonSQS sqsClient, string qUrl, List messages)
{
Console.WriteLine($"\nSending a batch of messages to queue\n {qUrl}");
SendMessageBatchResponse responseSendBatch =
await sqsClient.SendMessageBatchAsync(qUrl, messages);
// Could test responseSendBatch.Failed here
foreach(SendMessageBatchResultEntry entry in responseSendBatch.Successful)
Console.WriteLine($"Message {entry.Id} successfully queued.");
}
//
// Method to get input from the user
// They can provide messages to put in the queue or exit the application
private static async Task InteractWithUser(IAmazonSQS sqsClient, string qUrl)
{
string response;
while (true)
{
// Get the user's input
Console.WriteLine("\nType a message for the queue or \"exit\" to quit:");
response = Console.ReadLine();
if(response.ToLower() == "exit") break;
// Put the user's message in the queue
await SendMessage(sqsClient, qUrl, response);
}
}
//
// Method to delete all messages from the queue
private static async Task DeleteAllMessages(IAmazonSQS sqsClient, string qUrl)
{
Console.WriteLine($"\nPurging messages from queue\n {qUrl}...");
PurgeQueueResponse responsePurge = await sqsClient.PurgeQueueAsync(qUrl);
Console.WriteLine($"HttpStatusCode: {responsePurge.HttpStatusCode}");
}
}
}
```
## Considérations supplémentaires
+ Pour plus d'informations sur les différentes limitations relatives aux messages, y compris les caractères autorisés, consultez la section [Quotas relatifs aux messages](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-quotas.html#quotas-messages) dans le manuel [Amazon Simple Queue Service Developer Guide](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).
+ Les messages restent dans les files d'attente jusqu'à ce qu'ils soient supprimés ou que la file d'attente soit purgée. Lorsqu'un message est reçu par une application, il n'est pas visible dans la file d'attente même s'il existe toujours dans la file d'attente. Pour plus d'informations sur les délais de visibilité, consultez [Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html) Visibility Timeout.
+ Outre le corps du message, vous pouvez également ajouter des attributs aux messages. Pour plus d'informations, consultez la section [Métadonnées des messages](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html).
# Réception de messages Amazon SQS
Réception de messages
[Cet exemple vous montre comment utiliser le AWS SDK pour .NET pour recevoir des messages d'une file d'attente Amazon SQS, que vous pouvez créer par [programmation](CreateQueue.md) ou à l'aide de la console Amazon SQS.](https://console.aws.amazon.com/sqs) L'application lit un seul message dans la file d'attente, traite le message (dans ce cas, affiche le corps du message sur la console), puis le supprime de la file d'attente. L'application répète ces étapes jusqu'à ce que l'utilisateur tape une touche sur le clavier.
Cet exemple et l'[exemple précédent concernant l'envoi de messages](SendMessage.md) peuvent être utilisés conjointement pour voir le flux des messages dans Amazon SQS.
Les sections suivantes fournissent des extraits de cet exemple. Le [code complet de l'exemple](#ReceiveMessage-complete-code) est affiché ensuite et peut être créé et exécuté tel quel.
**Topics**
+ [
## Recevez un message
](#ReceiveMessage-receive)
+ [
## Supprimer un message
](#ReceiveMessage-delete)
+ [
## Code complet
](#ReceiveMessage-complete-code)
+ [
## Considérations supplémentaires
](#ReceiveMessage-additional)
## Recevez un message
L'extrait suivant reçoit un message de la file d'attente identifiée par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#ReceiveMessage-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to read a message from the given queue
// In this example, it gets one message at a time
private static async Task GetMessage(
IAmazonSQS sqsClient, string qUrl, int waitTime=0)
{
return await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest{
QueueUrl=qUrl,
MaxNumberOfMessages=MaxMessages,
WaitTimeSeconds=waitTime
// (Could also request attributes, set visibility timeout, etc.)
});
}
```
## Supprimer un message
L'extrait suivant supprime un message de la file d'attente identifiée par l'URL de file d'attente donnée.
L'exemple [à la fin de cette rubrique](#ReceiveMessage-complete-code) montre cet extrait en cours d'utilisation.
```
//
// Method to delete a message from a queue
private static async Task DeleteMessage(
IAmazonSQS sqsClient, Message message, string qUrl)
{
Console.WriteLine($"\nDeleting message {message.MessageId} from queue...");
await sqsClient.DeleteMessageAsync(qUrl, message.ReceiptHandle);
}
```
## Code complet
Cette section présente les références pertinentes et le code complet de cet exemple.
### Références du SDK
NuGet colis :
+ [AWSSDK.SQS](https://www.nuget.org/packages/AWSSDK.SQS)
Éléments de programmation :
+ [Espace de noms Amazon.sqs](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQS.html)
Classe [Amazon SQSClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html)
+ [Espace de noms Amazon.SQS.Model](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/NSQSModel.html)
Classe [ReceiveMessageRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TReceiveMessageRequest.html)
Classe [ReceiveMessageResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TReceiveMessageResponse.html)
### Le code
```
using System;
using System.Threading.Tasks;
using Amazon.SQS;
using Amazon.SQS.Model;
namespace SQSReceiveMessages
{
class Program
{
private const int MaxMessages = 1;
private const int WaitTime = 2;
static async Task Main(string[] args)
{
// Do some checks on the command-line
if(args.Length == 0)
{
Console.WriteLine("\nUsage: SQSReceiveMessages queue_url");
Console.WriteLine(" queue_url - The URL of an existing SQS queue.");
return;
}
if(!args[0].StartsWith("https://sqs."))
{
Console.WriteLine("\nThe command-line argument isn't a queue URL:");
Console.WriteLine($"{args[0]}");
return;
}
// Create the Amazon SQS client
var sqsClient = new AmazonSQSClient();
// (could verify that the queue exists)
// Read messages from the queue and perform appropriate actions
Console.WriteLine($"Reading messages from queue\n {args[0]}");
Console.WriteLine("Press any key to stop. (Response might be slightly delayed.)");
do
{
var msg = await GetMessage(sqsClient, args[0], WaitTime);
if(msg.Messages.Count != 0)
{
if(ProcessMessage(msg.Messages[0]))
await DeleteMessage(sqsClient, msg.Messages[0], args[0]);
}
} while(!Console.KeyAvailable);
}
//
// Method to read a message from the given queue
// In this example, it gets one message at a time
private static async Task GetMessage(
IAmazonSQS sqsClient, string qUrl, int waitTime=0)
{
return await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest{
QueueUrl=qUrl,
MaxNumberOfMessages=MaxMessages,
WaitTimeSeconds=waitTime
// (Could also request attributes, set visibility timeout, etc.)
});
}
//
// Method to process a message
// In this example, it simply prints the message
private static bool ProcessMessage(Message message)
{
Console.WriteLine($"\nMessage body of {message.MessageId}:");
Console.WriteLine($"{message.Body}");
return true;
}
//
// Method to delete a message from a queue
private static async Task DeleteMessage(
IAmazonSQS sqsClient, Message message, string qUrl)
{
Console.WriteLine($"\nDeleting message {message.MessageId} from queue...");
await sqsClient.DeleteMessageAsync(qUrl, message.ReceiptHandle);
}
}
}
```
## Considérations supplémentaires
+ Pour spécifier un long sondage, cet exemple utilise la `WaitTimeSeconds` propriété pour chaque appel à la `ReceiveMessageAsync` méthode.
Vous pouvez également spécifier un long sondage pour tous les messages d'une file d'attente en utilisant l'`ReceiveMessageWaitTimeSeconds`attribut lors de la [création](CreateQueue.md) ou de la [mise à jour](UpdateSqsQueue.md) de la file d'attente.
Pour plus d'informations sur les sondages courts par rapport aux sondages longs, consultez la section Sondage [court et long](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html) du manuel *Amazon Simple Queue Service Developer Guide*.
+ Pendant le traitement des messages, vous pouvez utiliser le descripteur de réception pour modifier le délai de visibilité des messages. Pour plus d'informations sur la procédure à suivre, consultez les `ChangeMessageVisibilityAsync` méthodes de la SQSClient classe [Amazon](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/SQS/TSQSClient.html).
+ L'appel de la `DeleteMessageAsync` méthode supprime le message de la file d'attente de manière inconditionnelle, quel que soit le paramètre de délai d'expiration de visibilité.
# Utilisation AWS Lambda pour le service de calcul
AWS Lambda
Les AWS SDK pour .NET supports AWS Lambda, qui vous permettent d'exécuter du code sans provisionner ni gérer de serveurs. Pour plus d'informations, consultez la [page AWS Lambda du produit](https://aws.amazon.com/lambda/) et le [guide du AWS Lambda développeur](https://docs.aws.amazon.com/lambda/latest/dg/), en particulier la section consacrée à l'[utilisation de C\$1.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-csharp.html)
## APIs
Le AWS SDK pour .NET APIs prévoit AWS Lambda. [Ils vous APIs permettent d'utiliser les fonctionnalités Lambda telles que les [fonctions, les](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-function)[déclencheurs](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-trigger) et les événements.](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) Pour voir l'ensemble complet de APIs, consultez [Lambda](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Lambda/NLambda.html) dans la référence de l'[AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/).
[Les Lambda APIs sont fournis par NuGet des packages.](https://www.nuget.org/packages?page=2&q=aws%20lambda&sortBy=relevance)
## Prérequis
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
## Informations supplémentaires
Consultez [Intégration AWS à .NET Aspire](aspire-integrations.md) pour plus d'informations sur le développement AWS Lambda avec .NET Aspire.
## Rubriques
**Topics**
+ [
## APIs
](#w2aac19c17b5)
+ [
## Prérequis
](#w2aac19c17b7)
+ [
## Informations supplémentaires
](#w2aac19c17b9)
+ [
## Rubriques
](#w2aac19c17c11)
+ [Annotations Lambda](aws-lambda-annotations.md)
# Utiliser des annotations pour écrire des fonctions AWS Lambda
Annotations Lambda
Lorsque vous écrivez des fonctions Lambda, vous devez parfois écrire une grande quantité de code de gestionnaire et mettre à jour des AWS CloudFormation modèles, entre autres tâches. Lambda Annotations est un framework destiné à alléger ces charges pour les fonctions Lambda de .NET 6, rendant ainsi l'expérience d'écriture Lambda plus naturelle en C\$1.
À titre d'exemple des avantages de l'utilisation du framework Lambda Annotations, considérez les extraits de code suivants qui ajoutent deux nombres.
**Sans annotations Lambda**
```
public class Functions
{
public APIGatewayProxyResponse LambdaMathPlus(APIGatewayProxyRequest request, ILambdaContext context)
{
if (!request.PathParameters.TryGetValue("x", out var xs))
{
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.BadRequest
};
}
if (!request.PathParameters.TryGetValue("y", out var ys))
{
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.BadRequest
};
}
var x = int.Parse(xs);
var y = int.Parse(ys);
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = (x + y).ToString(),
Headers = new Dictionary { { "Content-Type", "text/plain" } }
};
}
}
```
**Avec des annotations Lambda**
```
public class Functions
{
[LambdaFunction]
[RestApi("/plus/{x}/{y}")]
public int Plus(int x, int y)
{
return x + y;
}
}
```
Comme le montre l'exemple, les annotations Lambda peuvent supprimer le besoin d'un certain code de plaque de cuisson.
Pour plus de détails sur l'utilisation du framework ainsi que des informations supplémentaires, consultez les ressources suivantes :
+ Le [GitHub fichier README](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Annotations/README.md) pour la documentation sur les attributs APIs et les attributs des annotations Lambda.
+ L'[article de blog](https://aws.amazon.com/blogs/developer/net-lambda-annotations-framework/) sur les annotations Lambda.
+ Le package [https://www.nuget.org/packages/Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations) NuGet .
+ Le [projet Photo Asset Management](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager) sur GitHub. [Plus précisément, consultez le [PamApiAnnotations](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager/PamApiAnnotations)dossier et les références aux annotations Lambda dans le fichier README du projet.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/dotnetv3/cross-service/PhotoAssetManager/README.md)
**Note**
L'exemple précédent est spécifique à la version 3 du AWS SDK pour .NET. Si vous utilisez l'exemple avec la version V4 du SDK (la dernière version), vous devrez peut-être effectuer des ajustements en fonction des informations contenues dans[Migration vers la version 4](net-dg-v4.md).
# Bibliothèques et frameworks de haut niveau pour AWS SDK pour .NET
Bibliothèques et frameworks de haut niveau
Les sections suivantes contiennent des informations sur les bibliothèques et les frameworks de haut niveau qui ne font pas partie des fonctionnalités principales du SDK. Ces bibliothèques et frameworks utilisent les fonctionnalités de base du SDK pour créer des fonctionnalités qui facilitent certaines tâches.
Si vous êtes nouveau dans le AWS SDK pour .NET domaine, vous voudrez peut-être d'abord consulter le [Création d'une application simple](quick-start.md) sujet. Il vous présente le SDK.
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
**Topics**
+ [Cadre de traitement des messages](msg-proc-fw.md)
+ [Intégration AWS à .NET Aspire](aspire-integrations.md)
# AWS Framework de traitement des messages pour .NET
Cadre de traitement des messagesCadre de traitement des messages
Le cadre de traitement des AWS messages pour .NET est désormais disponible \$1
Le cadre de traitement des AWS messages pour .NET est un framework AWS natif qui simplifie le développement d'applications de traitement de messages .NET utilisant AWS des services tels qu'Amazon Simple Queue Service (SQS), Amazon Simple Notification Service (SNS) et Amazon. EventBridge Le framework réduit la quantité de code standard que les développeurs doivent écrire, ce qui vous permet de vous concentrer sur votre logique métier lors de la publication et de la consommation de messages. Pour plus de détails sur la façon dont le framework peut simplifier votre développement, consultez le billet de blog [Présentation du framework de traitement des AWS messages pour .NET (version préliminaire)](https://aws.amazon.com/blogs/developer/introducing-the-aws-message-processing-framework-for-net-preview/). La première partie en particulier fournit une démonstration qui montre la différence entre l'utilisation d'appels d'API de bas niveau et l'utilisation du framework.
Le cadre de traitement des messages prend en charge les activités et fonctionnalités suivantes :
+ Envoi de messages à SQS et publication d'événements sur SNS et. EventBridge
+ Réception et gestion des messages de SQS à l'aide d'un sondeur de longue durée, généralement utilisé dans les services d'arrière-plan. Cela inclut la gestion du délai de visibilité pendant le traitement d'un message afin d'empêcher d'autres clients de le traiter.
+ Gestion des messages dans AWS Lambda les fonctions.
+ FIFO (first-in-first-out), files d'attente SQS et sujets SNS.
+ OpenTelemetry pour la journalisation.
Pour plus de détails sur ces activités et fonctionnalités, consultez la section **Fonctionnalités** du [billet de blog](https://aws.amazon.com/blogs/developer/introducing-the-aws-message-processing-framework-for-net-preview/) et les sujets répertoriés ci-dessous.
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
**Ressources supplémentaires**
+ Le [https://www.nuget.org/packages/AWS.Messaging/](https://www.nuget.org/packages/AWS.Messaging/)package sur [NuGet.org](https://www.nuget.org/).
+ La [référence de l'API](https://aws.github.io/aws-dotnet-messaging/).
+ Le `README` fichier dans le GitHub dépôt à l'adresse [https://github.com/aws/aws-dotnet-messaging/](https://github.com/aws/aws-dotnet-messaging/)
+ [Injection de dépendances .NET](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) par Microsoft.
+ [.NET Generic Host](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host) de Microsoft.
**Topics**
+ [Mise en route](msg-proc-fw-get-started.md)
+ [Publier des messages](msg-proc-fw-publish.md)
+ [Consommez des messages](msg-proc-fw-consume.md)
+ [FIFO](msg-proc-fw-fifo.md)
+ [Journalisation et télémétrie ouverte](msg-proc-fw-telemetry.md)
+ [Personnalisation](msg-proc-fw-customize.md)
+ [Sécurité](msg-proc-fw-security.md)
# Commencez avec le cadre de traitement des AWS messages pour .NET
Mise en route
Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Consultez également les informations contenues dans[Utilisation de l'SDK](net-dg-sdk-features.md).
Cette rubrique fournit des informations qui vous aideront à commencer à utiliser le cadre de traitement des messages. Outre les informations relatives aux prérequis et à la configuration, un didacticiel est fourni pour vous montrer comment implémenter un scénario courant.
## Prérequis et configuration
+ Les informations d'identification que vous fournissez pour votre application doivent disposer des autorisations appropriées pour le service de messagerie et les opérations qu'il utilise. Pour plus d'informations, consultez les rubriques relatives à la sécurité pour [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html) et [SNS](https://docs.aws.amazon.com/sns/latest/dg/security-iam.html), ainsi que [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-iam.html)dans leurs guides de développement respectifs. Consultez également la partie du fichier [README](https://github.com/aws/aws-dotnet-messaging/) GitHub qui traite des [autorisations](https://github.com/aws/aws-dotnet-messaging/blob/main/README.md#permissions) spécifiques.
+ Pour utiliser le cadre de traitement des AWS messages pour .NET, vous devez ajouter le [https://www.nuget.org/packages/AWS.Messaging](https://www.nuget.org/packages/AWS.Messaging) NuGetpackage à votre projet. Par exemple :
```
dotnet add package AWS.Messaging
```
+ Le framework s'intègre au [conteneur de services d'injection de dépendances (DI) de](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) .NET. Vous pouvez configurer le framework lors du démarrage de votre application en appelant `AddAWSMessageBus` pour l'ajouter au conteneur DI.
```
var builder = WebApplication.CreateBuilder(args);
// Register the AWS Message Processing Framework for .NET
builder.Services.AddAWSMessageBus(builder =>
{
// Register that you'll publish messages of type ChatMessage to an existing queue
builder.AddSQSPublisher("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");
});
```
## didacticiel
Ce didacticiel explique comment utiliser le cadre de traitement des AWS messages pour .NET. Elle crée deux applications : une API ASP.NET Core Minimal qui envoie des messages à une file d'attente Amazon SQS lorsqu'elle reçoit une demande sur un point de terminaison d'API, et une application de console de longue durée qui interroge ces messages et les gère.
+ Les instructions de ce didacticiel privilégient l'interface de ligne de commande .NET, mais vous pouvez exécuter ce didacticiel à l'aide d'outils multiplateformes tels que .NET CLI ou Microsoft Visual Studio. Pour plus d'informations sur les outils, consultez[Installation et configuration de votre chaîne d'outils pour AWS SDK pour .NET](net-dg-dev-env.md).
+ Ce didacticiel part du principe que vous utilisez votre `[default]` profil comme identifiant. Cela suppose également que des informations d'identification à court terme sont disponibles avec les autorisations appropriées pour envoyer et recevoir des messages Amazon SQS. Pour plus d'informations, consultez [Authentifier le AWS SDK pour .NET avec AWS](creds-idc.md) les rubriques relatives à la sécurité relatives à [SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html)
**Note**
L'exécution de ce didacticiel peut entraîner des coûts liés à la messagerie SQS.
### Étapes
+ [Création d'une file d'attente SQS](#mpf-tutorial-queue)
+ [Création et exécution de l'application de publication](#mpf-tutorial-publish)
+ [Création et exécution de l'application de gestion](#mpf-tutorial-handle)
+ [Nettoyage](#mpf-tutorial-cleanup)
### Création d'une file d'attente SQS
Ce didacticiel nécessite une file d'attente SQS pour envoyer et recevoir des messages. Une file d'attente peut être créée à l'aide de l'une des commandes suivantes pour le AWS CLI ou le Outils AWS pour PowerShell. Prenez note de l'URL de la file d'attente renvoyée afin de pouvoir la spécifier dans la configuration du framework qui suit.
------
#### [ AWS CLI ]
```
aws sqs create-queue --queue-name DemoQueue
```
------
#### [ Outils AWS pour PowerShell ]
```
New-SQSQueue -QueueName DemoQueue
```
------
### Création et exécution de l'application de publication
Suivez la procédure ci-dessous pour créer et exécuter l'application de publication.
1. Ouvrez une invite de commande ou un terminal. Recherchez ou créez un dossier de système d'exploitation sous lequel vous pouvez créer un projet .NET.
1. Dans ce dossier, exécutez la commande suivante pour créer le projet .NET.
```
dotnet new webapi --name Publisher
```
1. Accédez au dossier du nouveau projet. Ajoutez une dépendance à l'infrastructure de traitement des AWS messages pour .NET.
```
cd Publisher
dotnet add package AWS.Messaging
```
**Note**
Si vous l'utilisez AWS IAM Identity Center pour l'authentification, veillez également à ajouter `AWSSDK.SSO` et`AWSSDK.SSOOIDC`.
1. Remplacez le code `Program.cs` par le code suivant.
```
using AWS.Messaging;
using Microsoft.AspNetCore.Mvc;
using Publisher;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle.
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Configure the AWS Message Processing Framework for .NET.
builder.Services.AddAWSMessageBus(builder =>
{
// Check for input SQS URL.
// The SQS URL should be passed as a command line argument or set in the Debug launch profile.
if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
{
// Register that you'll publish messages of type GreetingMessage:
// 1. To a specified queue.
// 2. Using the message identifier "greetingMessage", which will be used
// by handlers to route the message to the appropriate handler.
builder.AddSQSPublisher(args[0], "greetingMessage");
}
// You can map additional message types to queues or topics here as well.
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
// Create an API Endpoint that receives GreetingMessage objects
// from the caller and then sends them as an SQS message.
app.MapPost("/greeting", async ([FromServices] IMessagePublisher publisher, Publisher.GreetingMessage message) =>
{
return await PostGreeting(message, publisher);
})
.WithName("SendGreeting")
.WithOpenApi();
app.Run();
public partial class Program
{
///
/// Endpoint for posting a greeting message.
///
/// The greeting message.
/// The message publisher.
/// Async task result.
public static async Task PostGreeting(GreetingMessage greetingMessage,
IMessagePublisher messagePublisher)
{
if (greetingMessage.SenderName == null || greetingMessage.Greeting == null)
{
return Results.BadRequest();
}
// Publish the message to the queue configured above.
await messagePublisher.PublishAsync(greetingMessage);
return Results.Ok();
}
}
namespace Publisher
{
///
/// This class represents the message contents.
///
public class GreetingMessage
{
public string? SenderName { get; set; }
public string? Greeting { get; set; }
}
}
```
1. Exécutez la commande suivante. Cela devrait ouvrir une fenêtre de navigateur avec l'interface utilisateur Swagger, qui vous permettra d'explorer et de tester votre API.
```
dotnet watch run
```
1. Ouvrez le `/greeting` point de terminaison et choisissez **Try it out**.
1. Spécifiez `greeting` les valeurs `senderName` et les valeurs du message, puis choisissez **Execute**. Cela appelle votre API, qui envoie le message SQS.
### Création et exécution de l'application de gestion
Utilisez la procédure suivante pour créer et exécuter l'application de gestion.
1. Ouvrez une invite de commande ou un terminal. Recherchez ou créez un dossier de système d'exploitation sous lequel vous pouvez créer un projet .NET.
1. Dans ce dossier, exécutez la commande suivante pour créer le projet .NET.
```
dotnet new console --name Handler
```
1. Accédez au dossier du nouveau projet. Ajoutez une dépendance à l'infrastructure de traitement des AWS messages pour .NET. Ajoutez également le `Microsoft.Extensions.Hosting` package, qui vous permet de configurer le framework via le [.NET Generic Host](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host).
```
cd Handler
dotnet add package AWS.Messaging
dotnet add package Microsoft.Extensions.Hosting
```
**Note**
Si vous l'utilisez AWS IAM Identity Center pour l'authentification, veillez également à ajouter `AWSSDK.SSO` et`AWSSDK.SSOOIDC`.
1. Remplacez le code `Program.cs` par le code suivant.
```
using AWS.Messaging;
using Handler;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
var builder = Host.CreateDefaultBuilder(args);
builder.ConfigureServices(services =>
{
// Register the AWS Message Processing Framework for .NET.
services.AddAWSMessageBus(builder =>
{
// Check for input SQS URL.
// The SQS URL should be passed as a command line argument or set in the Debug launch profile.
if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
{
// Register you'll poll the following queue.
builder.AddSQSPoller(args[0]);
// And that messages of type "greetingMessage" should be:
// 1. Deserialized as GreetingMessage objects.
// 2. Which are then passed to GreetingMessageHandler.
builder.AddMessageHandler("greetingMessage");
}
// You can add additional message handlers here, using different message types.
});
});
var host = builder.Build();
await host.RunAsync();
namespace Handler
{
///
/// This class represents the message contents.
///
public class GreetingMessage
{
public string? SenderName { get; set; }
public string? Greeting { get; set; }
}
///
/// This handler is invoked each time you receive the message.
///
public class GreetingMessageHandler : IMessageHandler
{
public Task HandleAsync(
MessageEnvelope messageEnvelope,
CancellationToken token = default)
{
Console.WriteLine(
$"Received message {messageEnvelope.Message.Greeting} from {messageEnvelope.Message.SenderName}");
return Task.FromResult(MessageProcessStatus.Success());
}
}
}
```
1. Exécutez la commande suivante. Cela lance un sondage de longue haleine.
```
dotnet run
```
Peu de temps après le démarrage, l'application recevra le message envoyé dans la première partie de ce didacticiel et enregistrera le message suivant :
```
Received message {greeting} from {senderName}
```
1. Appuyez `Ctrl+C` pour arrêter le sondeur.
### Nettoyage
Utilisez l'une des commandes suivantes pour AWS CLI ou pour Outils AWS pour PowerShell supprimer la file d'attente.
------
#### [ AWS CLI ]
```
aws sqs delete-queue --queue-url ""
```
------
#### [ Outils AWS pour PowerShell ]
```
Remove-SQSQueue -QueueUrl ""
```
------
# Publiez des messages avec le AWS cadre de traitement des messages pour .NET
Publier des messages
Le cadre de traitement des AWS messages pour .NET permet de publier un ou plusieurs types de messages, de traiter un ou plusieurs types de messages ou d'effectuer les deux dans la même application.
Le code suivant montre la configuration d'une application qui publie différents types de messages vers différents AWS services.
```
var builder = WebApplication.CreateBuilder(args);
// Register the AWS Message Processing Framework for .NET
builder.Services.AddAWSMessageBus(builder =>
{
// Register that you'll send messages of type ChatMessage to an existing queue
builder.AddSQSPublisher("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");
// Register that you'll publish messages of type OrderInfo to an existing SNS topic
builder.AddSNSPublisher("arn:aws:sns:us-west-2:012345678910:MyAppProd");
// Register that you'll publish messages of type FoodItem to an existing EventBridge bus
builder.AddEventBridgePublisher("arn:aws:events:us-west-2:012345678910:event-bus/default");
});
```
Une fois que vous avez enregistré le framework au démarrage, injectez le générique `IMessagePublisher` dans votre code. Appelez sa `PublishAsync` méthode pour publier l'un des types de messages configurés ci-dessus. L'éditeur générique déterminera la destination vers laquelle acheminer le message en fonction de son type.
Dans l'exemple suivant, un contrôleur ASP.NET MVC reçoit à la fois `ChatMessage` des messages et des `OrderInfo` événements de la part des utilisateurs, puis les publie sur Amazon SQS et Amazon SNS respectivement. Les deux types de messages peuvent être publiés à l'aide de l'éditeur générique configuré ci-dessus.
```
[ApiController]
[Route("[controller]")]
public class PublisherController : ControllerBase
{
private readonly IMessagePublisher _messagePublisher;
public PublisherController(IMessagePublisher messagePublisher)
{
_messagePublisher = messagePublisher;
}
[HttpPost("chatmessage", Name = "Chat Message")]
public async Task PublishChatMessage([FromBody] ChatMessage message)
{
// Perform business and validation logic on the ChatMessage here.
if (message == null)
{
return BadRequest("A chat message was not submitted. Unable to forward to the message queue.");
}
if (string.IsNullOrEmpty(message.MessageDescription))
{
return BadRequest("The MessageDescription cannot be null or empty.");
}
// Send the ChatMessage to SQS, using the generic publisher.
await _messagePublisher.PublishAsync(message);
return Ok();
}
[HttpPost("order", Name = "Order")]
public async Task PublishOrder([FromBody] OrderInfo message)
{
if (message == null)
{
return BadRequest("An order was not submitted.");
}
// Publish the OrderInfo to SNS, using the generic publisher.
await _messagePublisher.PublishAsync(message);
return Ok();
}
}
```
Afin d'acheminer un message vers la logique de traitement appropriée, le framework utilise des métadonnées appelées *identifiant de type de message*. Par défaut, il s'agit du nom complet du type .NET du message, y compris son nom d'assembly. Si vous envoyez et gérez à la fois des messages, ce mécanisme fonctionne bien si vous partagez la définition des objets de vos messages entre différents projets. Toutefois, si les messages sont redéfinis dans différents espaces de noms, ou si vous échangez des messages avec d'autres frameworks ou langages de programmation, vous devrez peut-être remplacer l'identifiant du type de message.
```
var builder = Host.CreateDefaultBuilder(args);
builder.ConfigureServices(services =>
{
// Register the AWS Message Processing Framework for .NET
services.AddAWSMessageBus(builder =>
{
// Register that you'll publish messages of type GreetingMessage to an existing queue
builder.AddSQSPublisher("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", "greetingMessage");
});
});
```
## Éditeurs spécifiques aux services
L'exemple ci-dessus utilise le générique`IMessagePublisher`, qui peut être publié sur n'importe quel AWS service pris en charge en fonction du type de message configuré. Le framework fournit également des éditeurs spécifiques aux services pour Amazon SQS, Amazon SNS et Amazon. EventBridge Ces éditeurs spécifiques présentent des options qui ne s'appliquent qu'à ce service et peuvent être injectées à l'aide des types `ISQSPublisher``ISNSPublisher`, et`IEventBridgePublisher`.
Par exemple, lorsque vous envoyez des messages à une file d'attente FIFO SQS, vous devez définir l'ID de [groupe de messages](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-key-terms.html) approprié. Le code suivant montre à nouveau l'`ChatMessage`exemple, mais utilise maintenant un `ISQSPublisher` pour définir des options spécifiques à SQS.
```
public class PublisherController : ControllerBase
{
private readonly ISQSPublisher _sqsPublisher;
public PublisherController(ISQSPublisher sqsPublisher)
{
_sqsPublisher = sqsPublisher;
}
[HttpPost("chatmessage", Name = "Chat Message")]
public async Task PublishChatMessage([FromBody] ChatMessage message)
{
// Perform business and validation logic on the ChatMessage here
if (message == null)
{
return BadRequest("A chat message was not submitted. Unable to forward to the message queue.");
}
if (string.IsNullOrEmpty(message.MessageDescription))
{
return BadRequest("The MessageDescription cannot be null or empty.");
}
// Send the ChatMessage to SQS using the injected ISQSPublisher, with SQS-specific options
await _sqsPublisher.SendAsync(message, new SQSOptions
{
DelaySeconds = ,
MessageAttributes = ,
MessageDeduplicationId = ,
MessageGroupId =
});
return Ok();
}
}
```
La même chose peut être faite pour les réseaux sociaux et EventBridge, `IEventBridgePublisher` respectivement, en utilisant `ISNSPublisher` et.
```
await _snsPublisher.PublishAsync(message, new SNSOptions
{
Subject = ,
MessageAttributes = ,
MessageDeduplicationId = ,
MessageGroupId =
});
```
```
await _eventBridgePublisher.PublishAsync(message, new EventBridgeOptions
{
DetailType = ,
Resources = ,
Source = ,
Time =