La AWS SDK pour .NET V3 est passée en mode maintenance.
Nous vous recommandons de migrer vers la version [AWS SDK pour .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Pour plus de détails et d'informations sur la façon de migrer, veuillez consulter notre [annonce relative au mode de maintenance](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).
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.
# Utilisation avec 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/v3/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 et votre projet](net-dg-config.md). Consultez également les informations contenues dans[Fonctionnalités du 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
](#w2aac19c15c17b5)
+ [
## Conditions préalables
](#w2aac19c15c17b7)
+ [
## À 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
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 montre cet](#enum-sec-groups-complete-code) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Classe [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Filtre](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TFilter.html) de classe
Classe [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v3/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/v3/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/v3/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 suivant recherche les groupes de sécurité existants portant le nom donné dans le VPC donné.
L'exemple [à la fin de cette rubrique montre cet](#create-sec-groups-complete-code) extrait de code 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 montre cet](#create-sec-groups-complete-code) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateSecurityGroupRequest.html)
Classe [CreateSecurityGroupResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateSecurityGroupResponse.html)
Classe [DescribeSecurityGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsRequest.html)
Classe [DescribeSecurityGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSecurityGroupsResponse.html)
[Filtre](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TFilter.html) de classe
Classe [SecurityGroup](https://docs.aws.amazon.com/sdkfornet/v3/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 montre cet](#authorize-ingress-complete-code) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAuthorizeSecurityGroupIngressRequest.html)
Classe [AuthorizeSecurityGroupIngressResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAuthorizeSecurityGroupIngressResponse.html)
Classe [IpPermission](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TIpPermission.html)
Classe [IpRange](https://docs.aws.amazon.com/sdkfornet/v3/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/v3/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
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
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 montre cet](#create-save-key-pair-complete-code) extrait de code 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 montre cet](#create-save-key-pair-complete-code) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [CreateKeyPairRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateKeyPairRequest.html)
Classe [CreateKeyPairResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCreateKeyPairResponse.html)
Classe [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Classe [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v3/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 montre cet](#delete-key-pairs-complete-code) extrait de code 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 montre cet](#delete-key-pairs-complete-code) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/)
Classe [DescribeKeyPairsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeKeyPairsResponse.html)
Classe [KeyPairInfo](https://docs.aws.amazon.com/sdkfornet/v3/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
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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeAvailabilityZonesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeAvailabilityZonesResponse.html)
Classe [DescribeRegionsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeRegionsResponse.html)
Classe [AvailabilityZone](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TAvailabilityZone.html)
[Région](https://docs.aws.amazon.com/sdkfornet/v3/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
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
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/v3/apidocs/items/EC2/MEC2DescribeSubnetsAsyncDescribeSubnetsRequestCancellationToken.html)](https://docs.aws.amazon.com/sdkfornet/v3/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 contenant 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 de code 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 de code en cours d'utilisation.
Consultez la [InstanceState](https://docs.aws.amazon.com/sdkfornet/v3/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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
Classe [InstanceType](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceType.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [DescribeInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeInstancesRequest.html)
Classe [DescribeInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeInstancesResponse.html)
[Instance](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstance.html) de classe
Classe [InstanceNetworkInterfaceSpecification](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceNetworkInterfaceSpecification.html)
Classe [RunInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRunInstancesRequest.html)
Classe [RunInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/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/v3/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/v3/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/v3/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/v3/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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [GetPasswordDataRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TGetPasswordDataRequest.html)
Classe [GetPasswordDataResponse](https://docs.aws.amazon.com/sdkfornet/v3/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
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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesRequest.html)
Classe [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/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
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 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 quand 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 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 montre cet](#tutor-spot-net-main) extrait de code 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/v3/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 montre cet](#tutor-spot-net-main) extrait de code 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 montre cet](#tutor-spot-net-main) extrait de code 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 montre cet](#tutor-spot-net-main) extrait de code 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/v3/apidocs/items/EC2/NEC2.html)
Classe [Amazon EC2 Client](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TEC2Client.html)
Classe [InstanceType](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceType.html)
+ [Espace de noms Amazon.ec2.model](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/NEC2Model.html)
Classe [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TCancelSpotInstanceRequestsRequest.html)
Classe [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSpotInstanceRequestsRequest.html)
Classe [DescribeSpotInstanceRequestsResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TDescribeSpotInstanceRequestsResponse.html)
Classe [InstanceStateChange](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TInstanceStateChange.html)
Classe [LaunchSpecification](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TLaunchSpecification.html)
Classe [RequestSpotInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRequestSpotInstancesRequest.html)
Classe [RequestSpotInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TRequestSpotInstancesResponse.html)
Classe [SpotInstanceRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TSpotInstanceRequest.html)
Classe [TerminateInstancesRequest](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/EC2/TTerminateInstancesRequest.html)
Classe [TerminateInstancesResponse](https://docs.aws.amazon.com/sdkfornet/v3/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.