Le AWS SDK pour Java 1.x a été atteint end-of-support le 31 décembre 2025. Nous vous recommandons de migrer vers le pour continuer [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)à bénéficier des nouvelles fonctionnalités, des améliorations de disponibilité et des mises à jour de sécurité.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS SDK pour Java Exemples de code
Cette section fournit des didacticiels et des exemples d'utilisation de la AWS SDK pour Java version 1 pour programmer AWS des services.
Trouvez le code source de ces exemples et d'autres dans le [référentiel d'exemples de code de AWS documentation sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples).
Pour proposer un nouvel exemple de code que l'équipe de AWS documentation pourrait envisager de produire, créez une nouvelle demande. L'équipe cherche à produire des exemples de code qui couvrent des scénarios et des cas d'utilisation plus larges, plutôt que de simples extraits de code qui couvrent uniquement les appels d'API individuels. Pour obtenir des instructions, consultez les [directives relatives aux contributions](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md) dans le référentiel d'exemples de code sur... GitHub
## AWS SDK pour Java 2. x
En 2018, AWS a publié le [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html). Ce guide contient des instructions sur l'utilisation du dernier SDK Java ainsi qu'un exemple de code.
**Note**
Consultez [la documentation et les ressources supplémentaires](welcome.md#additional-resources) pour plus d'exemples et de ressources supplémentaires disponibles pour AWS SDK pour Java les développeurs \$1
**Topics**
# CloudWatch Exemples d'utilisation du AWS SDK pour Java
Cette section fournit des exemples de programmation d'[CloudWatch](https://aws.amazon.com/cloudwatch/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
Amazon CloudWatch surveille vos Amazon Web Services (AWS) ressources et les applications que vous utilisez AWS en temps réel. Vous pouvez les utiliser CloudWatch pour collecter et suivre les métriques, qui sont des variables que vous pouvez mesurer pour vos ressources et vos applications. CloudWatch les alarmes envoient des notifications ou modifient automatiquement les ressources que vous surveillez en fonction des règles que vous définissez.
Pour plus d'informations CloudWatch, consultez le [guide de Amazon CloudWatch l'utilisateur](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Obtenir des métriques à partir de CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Publication de données de métriques personnalisées](examples-cloudwatch-publish-custom-metrics.md)
+ [Utilisation des CloudWatch alarmes](examples-cloudwatch-create-alarms.md)
+ [Utilisation des actions d'alarme dans CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Envoi d'événements à CloudWatch](examples-cloudwatch-send-events.md)
# Obtenir des métriques à partir de CloudWatch
## Affichage de la liste des métriques
Pour répertorier CloudWatch les métriques, créez une méthode [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsRequest.html)et appelez AmazonCloudWatchClient la `listMetrics` méthode. Vous pouvez utiliser `ListMetricsRequest` pour filtrer les métriques renvoyées par espace de noms, nom de métrique ou dimension.
**Note**
Une liste des mesures et des dimensions publiées par les AWS services se trouve dans le \$1https---docs-aws-amazon-com- AmazonCloudWatch -latest-monitoring-cw-support-for-AWS-html\$1 [Amazon CloudWatch Metrics and Dimensions Reference] du guide de l'utilisateur. Amazon CloudWatch
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.ListMetricsRequest;
import com.amazonaws.services.cloudwatch.model.ListMetricsResult;
import com.amazonaws.services.cloudwatch.model.Metric;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
ListMetricsRequest request = new ListMetricsRequest()
.withMetricName(name)
.withNamespace(namespace);
boolean done = false;
while(!done) {
ListMetricsResult response = cw.listMetrics(request);
for(Metric metric : response.getMetrics()) {
System.out.printf(
"Retrieved metric %s", metric.getMetricName());
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
Les métriques sont renvoyées dans un [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsResult.html)en appelant sa `getMetrics` méthode. Les résultats peuvent être *paginés*. Pour récupérer le lot suivant de résultats, appelez `setNextToken` sur l'objet de demande d'origine avec la valeur de retour de la méthode `getNextToken` de l'objet `ListMetricsResult`, et retransmettez l'objet de demande modifié vers un autre appel de `listMetrics`.
## En savoir plus
+ [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html)dans la référence de Amazon CloudWatch l'API.
# Publication de données de métriques personnalisées
Un certain nombre de AWS services publient [leurs propres métriques dans des](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) espaces de noms commençant par « `AWS` ». Vous pouvez également publier des données métriques personnalisées en utilisant votre propre espace de noms (à condition qu'il ne commence pas par `AWS` « »).
## Publication de données de métriques personnalisées
Pour publier vos propres données métriques, appelez la `putMetricData` méthode AmazonCloudWatchClient's avec un [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricDataRequest.html). Ils `PutMetricDataRequest` doivent inclure l'espace de noms personnalisé à utiliser pour les données, ainsi que des informations sur le point de données lui-même dans un [MetricDatum](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/MetricDatum.html)objet.
**Note**
Vous ne pouvez pas spécifier un espace de noms commençant par « `AWS` ». Les espaces de noms commençant par « `AWS` » sont réservés à l'usage des Amazon Web Services produits.
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.Dimension;
import com.amazonaws.services.cloudwatch.model.MetricDatum;
import com.amazonaws.services.cloudwatch.model.PutMetricDataRequest;
import com.amazonaws.services.cloudwatch.model.PutMetricDataResult;
import com.amazonaws.services.cloudwatch.model.StandardUnit;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
Dimension dimension = new Dimension()
.withName("UNIQUE_PAGES")
.withValue("URLS");
MetricDatum datum = new MetricDatum()
.withMetricName("PAGES_VISITED")
.withUnit(StandardUnit.None)
.withValue(data_point)
.withDimensions(dimension);
PutMetricDataRequest request = new PutMetricDataRequest()
.withNamespace("SITE/TRAFFIC")
.withMetricData(datum);
PutMetricDataResult response = cw.putMetricData(request);
```
## En savoir plus
+ [Utilisation Amazon CloudWatch des métriques](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) dans le guide de Amazon CloudWatch l'utilisateur.
+ [AWS Espaces de noms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) dans le guide de Amazon CloudWatch l'utilisateur.
+ [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)dans la référence de Amazon CloudWatch l'API.
# Utilisation des CloudWatch alarmes
## Créer une alarme
Pour créer une alarme basée sur une CloudWatch métrique, appelez la `putMetricAlarm` méthode AmazonCloudWatchClient's avec un [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)rempli des conditions d'alarme.
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.ComparisonOperator;
import com.amazonaws.services.cloudwatch.model.Dimension;
import com.amazonaws.services.cloudwatch.model.PutMetricAlarmRequest;
import com.amazonaws.services.cloudwatch.model.PutMetricAlarmResult;
import com.amazonaws.services.cloudwatch.model.StandardUnit;
import com.amazonaws.services.cloudwatch.model.Statistic;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
Dimension dimension = new Dimension()
.withName("InstanceId")
.withValue(instanceId);
PutMetricAlarmRequest request = new PutMetricAlarmRequest()
.withAlarmName(alarmName)
.withComparisonOperator(
ComparisonOperator.GreaterThanThreshold)
.withEvaluationPeriods(1)
.withMetricName("CPUUtilization")
.withNamespace("{AWS}/EC2")
.withPeriod(60)
.withStatistic(Statistic.Average)
.withThreshold(70.0)
.withActionsEnabled(false)
.withAlarmDescription(
"Alarm when server CPU utilization exceeds 70%")
.withUnit(StandardUnit.Seconds)
.withDimensions(dimension);
PutMetricAlarmResult response = cw.putMetricAlarm(request);
```
## Affichage des alarmes
Pour répertorier les CloudWatch alarmes que vous avez créées, appelez la `describeAlarms` méthode AmazonCloudWatchClient's avec un [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsRequest.html)que vous pouvez utiliser pour définir les options du résultat.
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DescribeAlarmsRequest;
import com.amazonaws.services.cloudwatch.model.DescribeAlarmsResult;
import com.amazonaws.services.cloudwatch.model.MetricAlarm;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
boolean done = false;
DescribeAlarmsRequest request = new DescribeAlarmsRequest();
while(!done) {
DescribeAlarmsResult response = cw.describeAlarms(request);
for(MetricAlarm alarm : response.getMetricAlarms()) {
System.out.printf("Retrieved alarm %s", alarm.getAlarmName());
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
La liste des alarmes peut être obtenue `getMetricAlarms` en appelant [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsResult.html)le code renvoyé par`describeAlarms`.
Les résultats peuvent être *paginés*. Pour récupérer le lot suivant de résultats, appelez `setNextToken` sur l'objet de demande d'origine avec la valeur de retour de la méthode `getNextToken` de l'objet `DescribeAlarmsResult`, et retransmettez l'objet de demande modifié vers un autre appel de `describeAlarms`.
**Note**
Vous pouvez également récupérer les alarmes pour une métrique spécifique à l'aide AmazonCloudWatchClient de la `describeAlarmsForMetric` méthode's. Son utilisation est similaire à `describeAlarms`.
## Suppression d'alarmes
Pour supprimer des CloudWatch alarmes, appelez la `deleteAlarms` méthode AmazonCloudWatchClient's [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DeleteAlarmsRequest.html)en indiquant un ou plusieurs noms d'alarmes que vous souhaitez supprimer.
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DeleteAlarmsRequest;
import com.amazonaws.services.cloudwatch.model.DeleteAlarmsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DeleteAlarmsRequest request = new DeleteAlarmsRequest()
.withAlarmNames(alarm_name);
DeleteAlarmsResult response = cw.deleteAlarms(request);
```
## En savoir plus
+ [Création d' Amazon CloudWatch alarmes](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le guide de Amazon CloudWatch l'utilisateur
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)dans la référence de Amazon CloudWatch l'API
+ [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html)dans la référence de Amazon CloudWatch l'API
+ [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DeleteAlarms.html)dans la référence de Amazon CloudWatch l'API
# Utilisation des actions d'alarme dans CloudWatch
À l'aide des actions CloudWatch d'alarme, vous pouvez créer des alarmes qui exécutent des actions telles que l'arrêt automatique, la résiliation, le redémarrage ou la restauration d'instances. Amazon EC2
**Note**
Des actions d'alarme peuvent être ajoutées à une alarme en utilisant la `setAlarmActions` méthode [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)'s lors de la [création d'une alarme](examples-cloudwatch-create-alarms.md).
## Activation d'actions d'alarme
Pour activer les actions d' CloudWatch alarme pour une alarme, appelez les AmazonCloudWatchClient s `enableAlarmActions` avec [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/EnableAlarmActionsRequest.html)un ou plusieurs noms d'alarmes dont vous souhaitez activer les actions.
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.EnableAlarmActionsRequest;
import com.amazonaws.services.cloudwatch.model.EnableAlarmActionsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
EnableAlarmActionsRequest request = new EnableAlarmActionsRequest()
.withAlarmNames(alarm);
EnableAlarmActionsResult response = cw.enableAlarmActions(request);
```
## Désactivation d'actions d'alarme
Pour désactiver les actions d' CloudWatch alarme associées à une alarme, appelez le AmazonCloudWatchClient s [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DisableAlarmActionsRequest.html)contenant un ou plusieurs noms d'alarmes dont vous souhaitez désactiver les actions. `disableAlarmActions`
**Importations**
```
import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.DisableAlarmActionsRequest;
import com.amazonaws.services.cloudwatch.model.DisableAlarmActionsResult;
```
**Code**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DisableAlarmActionsRequest request = new DisableAlarmActionsRequest()
.withAlarmNames(alarmName);
DisableAlarmActionsResult response = cw.disableAlarmActions(request);
```
## En savoir plus
+ [Créez des alarmes pour arrêter, mettre fin, redémarrer ou récupérer une instance](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) dans le guide de Amazon CloudWatch l'utilisateur
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)dans la référence de Amazon CloudWatch l'API
+ [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_EnableAlarmActions.html)dans la référence de Amazon CloudWatch l'API
+ [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DisableAlarmActions.html)dans la référence de Amazon CloudWatch l'API
# Envoi d'événements à CloudWatch
CloudWatch Events fournit un flux d'événements système en temps quasi réel décrivant les modifications apportées aux AWS ressources des Amazon EC2 instances, des Lambda fonctions, des Kinesis flux, Amazon ECS des tâches, des machines d' Step Functions état, des Amazon SNS sujets, des Amazon SQS files d'attente ou des cibles intégrées. À l'aide de règles simples, vous pouvez faire correspondre les événements et les acheminer vers un ou plusieurs flux ou fonctions cibles.
## Ajout d'événements
Pour ajouter CloudWatch des événements personnalisés, appelez la `putEvents` méthode AmazonCloudWatchEventsClient's avec un [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequest.html)objet contenant un ou plusieurs [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequestEntry.html)objets fournissant des détails sur chaque événement. Vous pouvez spécifier plusieurs paramètres pour l'entrée, tels que la source et le type de l'événement, les ressources associées à l'événement, et ainsi de suite.
**Note**
Vous pouvez spécifier un maximum de 10 événements par appel de `putEvents`.
**Importations**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutEventsRequest;
import com.amazonaws.services.cloudwatchevents.model.PutEventsRequestEntry;
import com.amazonaws.services.cloudwatchevents.model.PutEventsResult;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
final String EVENT_DETAILS =
"{ \"key1\": \"value1\", \"key2\": \"value2\" }";
PutEventsRequestEntry request_entry = new PutEventsRequestEntry()
.withDetail(EVENT_DETAILS)
.withDetailType("sampleSubmitted")
.withResources(resource_arn)
.withSource("aws-sdk-java-cloudwatch-example");
PutEventsRequest request = new PutEventsRequest()
.withEntries(request_entry);
PutEventsResult response = cwe.putEvents(request);
```
## Ajout de règles
Pour créer ou mettre à jour une règle, appelez la `putRule` méthode AmazonCloudWatchEventsClient's [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutRuleRequest.html)avec le nom de la règle et des paramètres facultatifs tels que le [modèle d'événement](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), le IAM rôle à associer à la règle et une [expression de planification](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) décrivant la fréquence d'exécution de la règle.
**Importations**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutRuleRequest;
import com.amazonaws.services.cloudwatchevents.model.PutRuleResult;
import com.amazonaws.services.cloudwatchevents.model.RuleState;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
PutRuleRequest request = new PutRuleRequest()
.withName(rule_name)
.withRoleArn(role_arn)
.withScheduleExpression("rate(5 minutes)")
.withState(RuleState.ENABLED);
PutRuleResult response = cwe.putRule(request);
```
## Ajout de cibles
Les cibles sont les ressources appelées lorsqu'une règle est déclenchée. Les exemples de cibles incluent Amazon EC2 les instances, Lambda les fonctions, Kinesis les flux, Amazon ECS les tâches, les machines d' Step Functions état et les cibles intégrées.
Pour ajouter une cible à une règle, appelez la `putTargets` méthode AmazonCloudWatchEventsClient's avec un [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutTargetsRequest.html)contenant la règle à mettre à jour et une liste de cibles à ajouter à la règle.
**Importations**
```
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEvents;
import com.amazonaws.services.cloudwatchevents.AmazonCloudWatchEventsClientBuilder;
import com.amazonaws.services.cloudwatchevents.model.PutTargetsRequest;
import com.amazonaws.services.cloudwatchevents.model.PutTargetsResult;
import com.amazonaws.services.cloudwatchevents.model.Target;
```
**Code**
```
final AmazonCloudWatchEvents cwe =
AmazonCloudWatchEventsClientBuilder.defaultClient();
Target target = new Target()
.withArn(function_arn)
.withId(target_id);
PutTargetsRequest request = new PutTargetsRequest()
.withTargets(target)
.withRule(rule_name);
PutTargetsResult response = cwe.putTargets(request);
```
## En savoir plus
+ [Ajouter des événements PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) dans le guide de Amazon CloudWatch Events l'utilisateur
+ [Expressions de planification pour les règles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) dans le guide de Amazon CloudWatch Events l'utilisateur
+ [Types d'événements pour les CloudWatch événements figurant](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) dans le guide de Amazon CloudWatch Events l'utilisateur
+ [Événements et modèles d'événements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) dans le guide de Amazon CloudWatch Events l'utilisateur
+ [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutEvents.html)dans la référence de Amazon CloudWatch Events l'API
+ [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html)dans la référence de Amazon CloudWatch Events l'API
+ [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutRule.html)dans la référence de Amazon CloudWatch Events l'API
# DynamoDB Exemples d'utilisation du AWS SDK pour Java
Cette section fournit des exemples de programmation d'[DynamoDB](https://aws.amazon.com/dynamodb/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Utiliser des points de AWS terminaison basés sur des comptes](#account-based-endpoint-routing)
+ [Utilisation de tables dans DynamoDB](examples-dynamodb-tables.md)
+ [Utilisation d'éléments dans DynamoDB](examples-dynamodb-items.md)
## Utiliser des points de AWS terminaison basés sur des comptes
DynamoDB [AWS propose des points de terminaison basés sur des comptes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) qui peuvent améliorer les performances en utilisant AWS votre identifiant de compte pour rationaliser le routage des demandes.
Pour bénéficier de cette fonctionnalité, vous devez utiliser la version 1.12.771 ou supérieure de la version 1 de. AWS SDK pour Java La dernière version du SDK est répertoriée dans le référentiel [central de Maven](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom). Une fois qu'une version prise en charge du SDK est active, elle utilise automatiquement les nouveaux points de terminaison.
Si vous souhaitez désactiver le routage basé sur le compte, quatre options s'offrent à vous :
+ Configurez un client de service DynamoDB avec `AccountIdEndpointMode` le paramètre défini sur. `DISABLED`
+ Définissez une variable d'environnement.
+ Définissez une propriété du système JVM.
+ Mettez à jour le paramètre du fichier de AWS configuration partagé.
L'extrait suivant illustre comment désactiver le routage basé sur un compte en configurant un client de service DynamoDB :
```
ClientConfiguration config = new ClientConfiguration()
.withAccountIdEndpointMode(AccountIdEndpointMode.DISABLED);
AWSCredentialsProvider credentialsProvider = new EnvironmentVariableCredentialsProvider();
AmazonDynamoDB dynamodb = AmazonDynamoDBClientBuilder.standard()
.withClientConfiguration(config)
.withCredentials(credentialsProvider)
.withRegion(Regions.US_WEST_2)
.build();
```
Le guide de référence AWS SDKs and Tools fournit plus d'informations sur les [trois dernières options de configuration](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).
# Utilisation de tables dans DynamoDB
Les tables sont les conteneurs de tous les éléments d'une DynamoDB base de données. Avant de pouvoir ajouter ou supprimer des données DynamoDB, vous devez créer une table.
Pour chaque table, vous devez définir :
+ Un *nom* de table unique pour le compte et la région.
+ Une *clé primaire* pour laquelle chaque valeur doit être unique : deux éléments de votre table ne peuvent pas avoir la même valeur de clé primaire.
Une clé primaire peut être *simple*, constituée d'une seule clé de partition (HASH) ou *composite*, constituée d'une partition et d'une clé de tri (RANGE).
Chaque valeur clé est associée à un *type de données*, énuméré par la [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ScalarAttributeType.html)classe. La valeur de la clé peut être binaire (B), numérique (N) ou de type chaîne (S). Pour plus d'informations, consultez la section [Règles de dénomination et types de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) dans le Guide du Amazon DynamoDB développeur.
+ Des valeurs de *débit alloué* qui définissent le nombre d'unités de capacité en lecture/écriture réservées pour la table.
**Note**
Amazon DynamoDB la [tarification](https://aws.amazon.com/dynamodb/pricing/) est basée sur les valeurs de débit provisionnées que vous définissez sur vos tables. Ne réservez donc que la capacité dont vous pensez avoir besoin pour votre table.
Le débit alloué pour une table peut être modifié à tout moment pour que vous puissiez ajuster la capacité si vos besoins évoluent.
## Création d’une table
Utilisez la `createTable` méthode du [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) pour créer une nouvelle DynamoDB table. Vous devez créer des attributs de table et un schéma de table qui sont utilisés pour identifier la clé primaire de votre table. Vous devez également fournir des valeurs initiales de débit alloué et un nom de table. Définissez les attributs clés du tableau uniquement lors de la création de votre DynamoDB tableau.
**Note**
Si une table portant le nom que vous avez choisi existe déjà, une table [AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)est émise.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.CreateTableResult;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
```
### Création d'une table avec une clé primaire simple
Ce code crée une table avec une clé primaire simple ("Name").
**Code**
```
CreateTableRequest request = new CreateTableRequest()
.withAttributeDefinitions(new AttributeDefinition(
"Name", ScalarAttributeType.S))
.withKeySchema(new KeySchemaElement("Name", KeyType.HASH))
.withProvisionedThroughput(new ProvisionedThroughput(
new Long(10), new Long(10)))
.withTableName(table_name);
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
CreateTableResult result = ddb.createTable(request);
System.out.println(result.getTableDescription().getTableName());
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTable.java) sur GitHub.
### Création d'une table avec une clé primaire composite
Ajoutez-en un autre [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeDefinition.html)et [KeySchemaElement](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/KeySchemaElement.html)à [CreateTableRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/CreateTableRequest.html).
**Code**
```
CreateTableRequest request = new CreateTableRequest()
.withAttributeDefinitions(
new AttributeDefinition("Language", ScalarAttributeType.S),
new AttributeDefinition("Greeting", ScalarAttributeType.S))
.withKeySchema(
new KeySchemaElement("Language", KeyType.HASH),
new KeySchemaElement("Greeting", KeyType.RANGE))
.withProvisionedThroughput(
new ProvisionedThroughput(new Long(10), new Long(10)))
.withTableName(table_name);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTableCompositeKey.java) sur GitHub.
## Affichage d'une liste de tables
Vous pouvez répertorier les tables d'une région donnée en appelant la `listTables` méthode du [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ListTablesRequest;
import com.amazonaws.services.dynamodbv2.model.ListTablesResult;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ListTablesRequest request;
boolean more_tables = true;
String last_name = null;
while(more_tables) {
try {
if (last_name == null) {
request = new ListTablesRequest().withLimit(10);
}
else {
request = new ListTablesRequest()
.withLimit(10)
.withExclusiveStartTableName(last_name);
}
ListTablesResult table_list = ddb.listTables(request);
List table_names = table_list.getTableNames();
if (table_names.size() > 0) {
for (String cur_name : table_names) {
System.out.format("* %s\n", cur_name);
}
} else {
System.out.println("No tables found!");
System.exit(0);
}
last_name = table_list.getLastEvaluatedTableName();
if (last_name == null) {
more_tables = false;
}
```
Par défaut, jusqu'à 100 tables sont renvoyées par appel. À utiliser `getLastEvaluatedTableName` sur l'[ListTablesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/model/ListTablesResult.html)objet renvoyé pour obtenir la dernière table évaluée. Vous pouvez utiliser cette valeur pour démarrer la liste après la dernière valeur renvoyée de la liste précédente.
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/ListTables.java) sur GitHub.
## Description d'une table (obtention d'informations sur celle-ci)
Appelez la `describeTable` méthode du [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputDescription;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
TableDescription table_info =
ddb.describeTable(table_name).getTable();
if (table_info != null) {
System.out.format("Table name : %s\n",
table_info.getTableName());
System.out.format("Table ARN : %s\n",
table_info.getTableArn());
System.out.format("Status : %s\n",
table_info.getTableStatus());
System.out.format("Item count : %d\n",
table_info.getItemCount().longValue());
System.out.format("Size (bytes): %d\n",
table_info.getTableSizeBytes().longValue());
ProvisionedThroughputDescription throughput_info =
table_info.getProvisionedThroughput();
System.out.println("Throughput");
System.out.format(" Read Capacity : %d\n",
throughput_info.getReadCapacityUnits().longValue());
System.out.format(" Write Capacity: %d\n",
throughput_info.getWriteCapacityUnits().longValue());
List attributes =
table_info.getAttributeDefinitions();
System.out.println("Attributes");
for (AttributeDefinition a : attributes) {
System.out.format(" %s (%s)\n",
a.getAttributeName(), a.getAttributeType());
}
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DescribeTable.java) sur GitHub.
## Modification (mise à jour) d'une table
Vous pouvez modifier les valeurs de débit provisionnées de votre table à tout moment en appelant la méthode du [DynamoDB`updateTable`client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.AmazonServiceException;
```
**Code**
```
ProvisionedThroughput table_throughput = new ProvisionedThroughput(
read_capacity, write_capacity);
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.updateTable(table_name, table_throughput);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateTable.java) sur GitHub.
## Suppression d'une table
Appelez la `deleteTable` méthode du [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) et transmettez-lui le nom de la table.
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
```
**Code**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.deleteTable(table_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DeleteTable.java) sur GitHub.
## Plus d'informations
+ [Instructions relatives à l'utilisation des tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) dans le guide du Amazon DynamoDB développeur
+ [Utilisation des tableaux DynamoDB dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) le guide du Amazon DynamoDB développeur
# Utilisation d'éléments dans DynamoDB
Dans DynamoDB, un élément est un ensemble d'*attributs*, chacun ayant un *nom* et une *valeur*. Une valeur d'attribut peut être de type scalar, set ou document. Pour plus d'informations, consultez la section [Règles de dénomination et types de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) dans le Guide du Amazon DynamoDB développeur.
## Extraction (Get) d'un élément d'une table
Appelez la `getItem` méthode AmazonDynamo de la base de données et transmettez-lui un [GetItemRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemRequest.html)objet avec le nom de la table et la valeur de la clé primaire de l'élément souhaité. Elle renvoie un [GetItemResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemResult.html)objet.
Vous pouvez utiliser la `getItem()` méthode de l'`GetItemResult`objet renvoyé pour récupérer une [carte](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) des paires clé (chaîne [AttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeValue.html)) et valeur () associées à l'élément.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
```
**Code**
```
HashMap key_to_get =
new HashMap();
key_to_get.put("DATABASE_NAME", new AttributeValue(name));
GetItemRequest request = null;
if (projection_expression != null) {
request = new GetItemRequest()
.withKey(key_to_get)
.withTableName(table_name)
.withProjectionExpression(projection_expression);
} else {
request = new GetItemRequest()
.withKey(key_to_get)
.withTableName(table_name);
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
Map returned_item =
ddb.getItem(request).getItem();
if (returned_item != null) {
Set keys = returned_item.keySet();
for (String key : keys) {
System.out.format("%s: %s\n",
key, returned_item.get(key).toString());
}
} else {
System.out.format("No item found with the key %s!\n", name);
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/GetItem.java) sur GitHub.
## Ajout d'un nouvel élément à une table
Créez un [mappage](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) des paires clé-valeur qui représentent les attributs de l'élément. Elles doivent inclure les valeurs des champs de clé primaire de la table. Si l'élément identifié par la clé primaire existe déjà, ses champs sont *mis à jour* par la demande.
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import java.util.ArrayList;
```
**Code**
```
HashMap item_values =
new HashMap();
item_values.put("Name", new AttributeValue(name));
for (String[] field : extra_fields) {
item_values.put(field[0], new AttributeValue(field[1]));
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.putItem(table_name, item_values);
} catch (ResourceNotFoundException e) {
System.err.format("Error: The table \"%s\" can't be found.\n", table_name);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (AmazonServiceException e) {
System.err.println(e.getMessage());
System.exit(1);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/PutItem.java) sur GitHub.
## Mise à jour d'un élément existant dans une table
Vous pouvez mettre à jour un attribut pour un élément qui existe déjà dans une table en utilisant la `updateItem` méthode de la AmazonDynamo base de données, en fournissant un nom de table, une valeur de clé primaire et une carte des champs à mettre à jour.
**Note**
Si la table nommée n'existe pas pour votre compte et votre région, ou si l'élément identifié par la clé primaire que vous avez transmise n'existe pas, un [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)est généré.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException;
import java.util.ArrayList;
```
**Code**
```
HashMap item_key =
new HashMap();
item_key.put("Name", new AttributeValue(name));
HashMap updated_values =
new HashMap();
for (String[] field : extra_fields) {
updated_values.put(field[0], new AttributeValueUpdate(
new AttributeValue(field[1]), AttributeAction.PUT));
}
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.updateItem(table_name, item_key, updated_values);
} catch (ResourceNotFoundException e) {
System.err.println(e.getMessage());
System.exit(1);
} catch (AmazonServiceException e) {
System.err.println(e.getMessage());
System.exit(1);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateItem.java) sur GitHub.
## Utiliser la classe Dynamo DBMapper
[AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/)fournit une DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html), qui vous permet de mapper vos classes côté client à des tables. Amazon DynamoDB Pour utiliser la DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html), vous définissez la relation entre les éléments d'une DynamoDB table et leurs instances d'objet correspondantes dans votre code à l'aide d'annotations (comme indiqué dans l'exemple de code suivant). La DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) vous permet d'accéder à vos tables, d'effectuer diverses opérations de création, de lecture, de mise à jour et de suppression (CRUD) et d'exécuter des requêtes.
**Note**
La DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) ne vous permet pas de créer, de mettre à jour ou de supprimer des tables.
**Importations**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.model.AmazonDynamoDBException;
```
**Code**
L'exemple de code Java suivant montre comment ajouter du contenu à la table *Music* à l'aide de la DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html). Une fois le contenu ajouté à la table, notez qu'un élément est chargé à l'aide des clés de *partition* et de *tri*. Ensuite, l'élément *Awards* est mis à jour. Pour plus d'informations sur la création de la table *musicale*, voir [Création d'une table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) dans le guide du Amazon DynamoDB développeur.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
MusicItems items = new MusicItems();
try{
// Add new content to the Music table
items.setArtist(artist);
items.setSongTitle(songTitle);
items.setAlbumTitle(albumTitle);
items.setAwards(Integer.parseInt(awards)); //convert to an int
// Save the item
DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(items);
// Load an item based on the Partition Key and Sort Key
// Both values need to be passed to the mapper.load method
String artistName = artist;
String songQueryTitle = songTitle;
// Retrieve the item
MusicItems itemRetrieved = mapper.load(MusicItems.class, artistName, songQueryTitle);
System.out.println("Item retrieved:");
System.out.println(itemRetrieved);
// Modify the Award value
itemRetrieved.setAwards(2);
mapper.save(itemRetrieved);
System.out.println("Item updated:");
System.out.println(itemRetrieved);
System.out.print("Done");
} catch (AmazonDynamoDBException e) {
e.getStackTrace();
}
}
@DynamoDBTable(tableName="Music")
public static class MusicItems {
//Set up Data Members that correspond to columns in the Music table
private String artist;
private String songTitle;
private String albumTitle;
private int awards;
@DynamoDBHashKey(attributeName="Artist")
public String getArtist() {
return this.artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
@DynamoDBRangeKey(attributeName="SongTitle")
public String getSongTitle() {
return this.songTitle;
}
public void setSongTitle(String title) {
this.songTitle = title;
}
@DynamoDBAttribute(attributeName="AlbumTitle")
public String getAlbumTitle() {
return this.albumTitle;
}
public void setAlbumTitle(String title) {
this.albumTitle = title;
}
@DynamoDBAttribute(attributeName="Awards")
public int getAwards() {
return this.awards;
}
public void setAwards(int awards) {
this.awards = awards;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UseDynamoMapping.java) sur GitHub.
## Plus d'informations
+ [Directives relatives à l'utilisation des éléments](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) du guide du Amazon DynamoDB développeur
+ [Utilisation des éléments contenus DynamoDB dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) le guide du Amazon DynamoDB développeur
# Amazon EC2 Exemples d'utilisation du AWS SDK pour Java
Cette section fournit des exemples de programmation [Amazon EC2](https://aws.amazon.com/ec2/)avec AWS SDK pour Java.
**Topics**
+ [Tutoriel : Démarrage d'une EC2 instance](how-to-ec2.md)
+ [Utilisation des rôles IAM pour accorder l'accès aux AWS ressources sur Amazon EC2](java-dg-roles.md)
+ [Tutoriel : Instances Amazon EC2 ponctuelles](tutorial-spot-instances-java.md)
+ [Tutoriel : Gestion avancée des demandes Amazon EC2 ponctuelles](tutorial-spot-adv-java.md)
+ [Gestion des Amazon EC2 instances](examples-ec2-instances.md)
+ [Utilisation d'adresses IP élastiques dans Amazon EC2](examples-ec2-elastic-ip.md)
+ [Utiliser les régions et les zones de disponibilité](examples-ec2-regions-zones.md)
+ [Utilisation de paires Amazon EC2 de clés](examples-ec2-key-pairs.md)
+ [Utilisation de groupes de sécurité dans Amazon EC2](examples-ec2-security-groups.md)
# Tutoriel : Démarrage d'une EC2 instance
Ce didacticiel explique comment utiliser le AWS SDK pour Java pour démarrer une EC2 instance.
**Topics**
+ [Prérequis](#prerequisitesec2)
+ [Création d'un groupe Amazon EC2 de sécurité](create-security-group.md)
+ [Créer une paire de clés](create-key-pair.md)
+ [Exécuter une Amazon EC2 instance](run-instance.md)
## Prérequis
Avant de commencer, assurez-vous d'avoir créé un Compte AWS et d'avoir configuré vos AWS informations d'identification. Pour plus d'informations, consultez [Mise en route avec ](getting-started.md).
# Création d'un groupe Amazon EC2 de sécurité
## EC2-Classic prend sa retraite
**Avertissement**
Nous retirons EC2 -Classic le 15 août 2022. Nous vous recommandons de migrer de EC2 -Classic vers un VPC. Pour plus d'informations, consultez le billet de blog [EC2-Classic-Classic Networking is Retiring — Here's](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) How to Prepare.
Créez un *groupe de sécurité* qui agit comme un pare-feu virtuel contrôlant le trafic réseau pour une ou plusieurs EC2 instances. Amazon EC2 Associe par défaut vos instances à un groupe de sécurité qui n'autorise aucun trafic entrant. Vous pouvez créer un groupe de sécurité qui permet à vos EC2 instances d'accepter un certain trafic. Par exemple, si vous devez vous connecter à une instance Linux, vous devez configurer le groupe de sécurité afin d'autoriser le trafic SSH. Vous pouvez créer un groupe de sécurité à l'aide de la Amazon EC2 console ou du AWS SDK pour Java.
Vous créez un groupe de sécurité à utiliser dans EC2 -Classic ou EC2 -VPC. Pour plus d'informations sur EC2 -Classic et EC2 -VPC, consultez la section [Plateformes prises en charge](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html) dans le Guide de l' Amazon EC2 utilisateur pour les instances Linux.
Pour plus d'informations sur la création d'un groupe de sécurité à l'aide de la Amazon EC2 console, consultez [Amazon EC2 la section Groupes de sécurité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) dans le Guide de Amazon EC2 l'utilisateur pour les instances Linux.
1. Créez et initialisez une [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html)instance. Utilisez la [withGroupName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withGroupName-java.lang.String-)méthode pour définir le nom du groupe de sécurité et la méthode [withDescription](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withDescription-java.lang.String-) pour définir la description du groupe de sécurité, comme suit :
```
CreateSecurityGroupRequest csgr = new CreateSecurityGroupRequest();
csgr.withGroupName("JavaSecurityGroup").withDescription("My security group");
```
Le nom du groupe de sécurité doit être unique dans la AWS région dans laquelle vous initialisez votre Amazon EC2 client. Vous devez utiliser les caractères US-ASCII pour le nom et la description du groupe de sécurité.
1. Transmettez l'objet de demande en tant que paramètre à la [createSecurityGroup](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createSecurityGroup-com.amazonaws.services.ec2.model.CreateSecurityGroupRequest-)méthode. La méthode renvoie un [CreateSecurityGroupResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupResult.html)objet, comme suit :
```
CreateSecurityGroupResult createSecurityGroupResult =
amazonEC2Client.createSecurityGroup(csgr);
```
Si vous essayez de créer un groupe de sécurité portant le même nom qu'un groupe de sécurité existant, `createSecurityGroup` lève une exception.
Par défaut, un nouveau groupe de sécurité n'autorise aucun trafic entrant vers votre Amazon EC2 instance. Pour autoriser le trafic entrant, vous devez permettre explicitement l'entrée de groupe de sécurité. Vous pouvez autoriser l'entrée pour des adresses IP individuelles, pour une plage d'adresses IP, pour un protocole spécifique et pour les ports TCP/UDP.
1. Créez et initialisez une [IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html)instance. Utilisez la méthode [WithIPv4Ranges](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpv4Ranges-java.util.Collection-) pour définir la plage d'adresses IP pour laquelle l'entrée doit être autorisée, et utilisez la [withIpProtocol](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpProtocol-java.lang.String-)méthode pour définir le protocole IP. Utilisez les [withToPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withToPort-java.lang.Integer-)méthodes [withFromPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withFromPort-java.lang.Integer-)et pour spécifier la plage de ports pour lesquels vous souhaitez autoriser l'entrée, comme suit :
```
IpPermission ipPermission =
new IpPermission();
IpRange ipRange1 = new IpRange().withCidrIp("111.111.111.111/32");
IpRange ipRange2 = new IpRange().withCidrIp("150.150.150.150/32");
ipPermission.withIpv4Ranges(Arrays.asList(new IpRange[] {ipRange1, ipRange2}))
.withIpProtocol("tcp")
.withFromPort(22)
.withToPort(22);
```
Toutes les conditions spécifiées dans l'objet `IpPermission` doivent être satisfaites pour que l'entrée soit autorisée.
Spécifiez l'adresse IP à l'aide de la notation CIDR. Si vous spécifiez le protocole comme TCP/UDP, vous devez fournir un port source et un port de destination. Vous ne pouvez autoriser les ports que si vous spécifiez TCP ou UDP.
1. Créez et initialisez une [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html)instance. Utilisez la `withGroupName` méthode pour spécifier le nom du groupe de sécurité et transmettez l'`IpPermission`objet que vous avez initialisé précédemment à la [withIpPermissions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html#withIpPermissions-com.amazonaws.services.ec2.model.IpPermission…-)méthode, comme suit :
```
AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest =
new AuthorizeSecurityGroupIngressRequest();
authorizeSecurityGroupIngressRequest.withGroupName("JavaSecurityGroup")
.withIpPermissions(ipPermission);
```
1. Passez l'objet de requête dans la méthode [authorizeSecurityGroupIngress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-), comme suit :
```
amazonEC2Client.authorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);
```
Si vous appelez `authorizeSecurityGroupIngress` avec des adresses IP pour lesquelles l'entrée est déjà autorisée, la méthode lève une exception. Créez et initialisez un nouvel `IpPermission` objet pour autoriser l'entrée pour différents IPs ports et protocoles avant d'appeler. `AuthorizeSecurityGroupIngress`
Chaque fois que vous appelez les méthodes d'[authorizeSecurityGroupentrée](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-) ou de [authorizeSecurityGroupsortie](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupEgress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupEgressRequest-), une règle est ajoutée à votre groupe de sécurité.
# Créer une paire de clés
Vous devez spécifier une paire de clés lorsque vous lancez une EC2 instance, puis spécifier la clé privée de la paire de clés lorsque vous vous connectez à l'instance. Vous pouvez créer une paire de clés ou utiliser une paire de clés existante que vous avez utilisée lors du lancement d'autres instances. Pour plus d'informations, consultez la section [Paires de Amazon EC2 clés](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux.
1. Créez et initialisez une [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html)instance. Utilisez la [withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html#withKeyName-java.lang.String-)méthode pour définir le nom de la paire de clés, comme suit :
```
CreateKeyPairRequest createKeyPairRequest = new CreateKeyPairRequest();
createKeyPairRequest.withKeyName(keyName);
```
**Important**
Les noms de paire de clés doivent être uniques. Si vous essayez de créer une paire de clés portant le même nom qu'une paire de clés existante, vous obtenez une exception.
1. Transmettez l'objet de la requête à la [createKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createKeyPair-com.amazonaws.services.ec2.model.CreateKeyPairRequest--)méthode. La méthode renvoie une [CreateKeyPairResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html)instance, comme suit :
```
CreateKeyPairResult createKeyPairResult =
amazonEC2Client.createKeyPair(createKeyPairRequest);
```
1. Appelez la [getKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html#getKeyPair--)méthode de l'objet résultat pour obtenir un [KeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html)objet. Appelez la [getKeyMaterial](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html#getKeyMaterial--)méthode de l'`KeyPair`objet pour obtenir la clé privée codée PEM non chiffrée, comme suit :
```
KeyPair keyPair = new KeyPair();
keyPair = createKeyPairResult.getKeyPair();
String privateKey = keyPair.getKeyMaterial();
```
# Exécuter une Amazon EC2 instance
Utilisez la procédure suivante pour lancer une ou plusieurs EC2 instances configurées de manière identique à partir de la même Amazon Machine Image (AMI). Après avoir créé vos EC2 instances, vous pouvez vérifier leur statut. Une fois que vos EC2 instances sont en cours d'exécution, vous pouvez vous y connecter.
1. Créez et initialisez une [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)instance. Assurez-vous que l'AMI, la paire de clés et le groupe de sécurité que vous spécifiez existent dans la région que vous avez spécifiée lors de la création de l'objet client.
```
RunInstancesRequest runInstancesRequest =
new RunInstancesRequest();
runInstancesRequest.withImageId("ami-a9d09ed1")
.withInstanceType(InstanceType.T1Micro)
.withMinCount(1)
.withMaxCount(1)
.withKeyName("my-key-pair")
.withSecurityGroups("my-security-group");
```
[withImageId](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withImageId-java.lang.String-)
+ ID de l'AMI. Pour savoir comment rechercher le public AMIs fourni par Amazon ou créer le vôtre, consultez [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html).
[withInstanceType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withInstanceType-java.lang.String-)
+ Type d'instance compatible avec l'AMI spécifiée. Pour plus d'informations, consultez la section [Types d'instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux.
[withMinCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMinCount-java.lang.Integer-)
+ Le nombre minimum d' EC2 instances à lancer. S'il s'agit d'un nombre d'instances supérieur au nombre d'instances Amazon EC2 pouvant être lancées dans la zone de disponibilité cible, aucune instance ne Amazon EC2 sera lancée.
[withMaxCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMaxCount-java.lang.Integer-)
+ Le nombre maximum d' EC2 instances à lancer. S'il s'agit d'un nombre d'instances supérieur au nombre d'instances Amazon EC2 pouvant être lancées dans la zone de disponibilité cible, Amazon EC2 lance le plus grand nombre possible d'instances ci-dessus`MinCount`. Vous pouvez lancer entre 1 instance et le nombre maximal d'instances auquel vous êtes autorisé pour le type d'instance. Pour plus d'informations, consultez la section Combien d'instances puis-je exécuter Amazon EC2 dans la FAQ Amazon EC2 générale.
[withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withKeyName-java.lang.String-)
+ Le nom de la paire de EC2 clés. Si vous lancez une instance sans spécifier de paire de clés, vous ne pouvez pas vous y connecter. Pour plus d'informations, consultez [Créer une paire de clés](create-key-pair.md).
[withSecurityGroups](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withSecurityGroups-java.util.Collection-)
+ Un ou plusieurs groupes de sécurité. Pour plus d'informations, consultez la section [Création d'un groupe Amazon EC2 de sécurité](create-security-group.md).
1. Lancez les instances en transmettant l'objet de demande à la méthode [runInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#runInstances-com.amazonaws.services.ec2.model.RunInstancesRequest-). La méthode renvoie un [RunInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesResult.html)objet, comme suit :
```
RunInstancesResult result = amazonEC2Client.runInstances(
runInstancesRequest);
```
Une fois que votre instance est en cours d'exécution, vous pouvez vous y connecter à l'aide de votre paire de clés. Pour plus d'informations, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html). dans le guide de l' Amazon EC2 utilisateur pour les instances Linux.
# Utilisation des rôles IAM pour accorder l'accès aux AWS ressources sur Amazon EC2
Toutes les demandes adressées à Amazon Web Services (AWS) doivent être signées de manière cryptographique à l'aide des informations d'identification émises par AWS. Vous pouvez utiliser les *rôles IAM* pour accorder facilement un accès sécurisé aux AWS ressources depuis vos Amazon EC2 instances.
Cette rubrique fournit des informations sur l'utilisation des rôles IAM avec des applications du SDK Java exécutées sur. Amazon EC2 Pour plus d'informations sur les instances IAM, consultez la section [Rôles IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) du Guide Amazon EC2 de l' Amazon EC2 utilisateur pour les instances Linux.
## La chaîne de fournisseurs et les profils d' EC2 instance par défaut
Si votre application crée un AWS client à l'aide du constructeur par défaut, le client recherchera les informations d'identification à l'aide de la *chaîne de fournisseurs d'informations d'identification par défaut*, dans l'ordre suivant :
1. Dans les propriétés système Java : `aws.accessKeyId` et `aws.secretKey`.
1. Dans les variables d'environnement du système : `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY`.
1. Dans le fichier d'informations d'identification par défaut (l'emplacement de ce fichier varie en fonction de la plateforme).
1. Informations d'identification fournies via le service de Amazon EC2 conteneur si la variable d'`AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`environnement est définie et que le responsable de la sécurité est autorisé à accéder à la variable.
1. Dans les *informations d'identification du profil d'instance*, qui existent dans les métadonnées de l'instance associées au rôle IAM de l' EC2 instance.
1. Informations d'identification du jeton d'identité web à partir de l'environnement ou du conteneur.
L'étape des *informations d'identification du profil d'instance* de la chaîne de fournisseurs par défaut n'est disponible que lorsque vous exécutez votre application sur une Amazon EC2 instance, mais elle offre la plus grande facilité d'utilisation et la meilleure sécurité lorsque vous travaillez avec des Amazon EC2 instances. Vous pouvez également transmettre une [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)instance directement au constructeur du client pour obtenir les informations d'identification du profil d'instance sans passer par l'ensemble de la chaîne de fournisseurs par défaut.
Par exemple :
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new InstanceProfileCredentialsProvider(false))
.build();
```
Lorsque vous utilisez cette approche, le SDK récupère les AWS informations d'identification temporaires dotées des mêmes autorisations que celles associées au rôle IAM associé à l' Amazon EC2 instance dans son profil d'instance. Bien que ces informations d'identification soient temporaires et finiront par expirer, elles sont `InstanceProfileCredentialsProvider` régulièrement actualisées pour vous afin que les informations d'identification obtenues continuent à autoriser l'accès à AWS.
**Important**
L'actualisation des informations d'identification a lieu *uniquement* lorsque vous utilisez le constructeur client par défaut, qui crée son propre `InstanceProfileCredentialsProvider` dans le cadre de la chaîne de fournisseur par défaut, ou lorsque vous transmettez une instance `InstanceProfileCredentialsProvider` directement au constructeur client. Si vous utilisez une autre méthode pour obtenir ou transmettre des informations d'identification de profil d'instance, il vous incombe de les vérifier et d'actualiser des informations d'identification expirées.
Si le constructeur du client ne trouve pas les informations d'identification à l'aide de la chaîne de fournisseurs d'informations d'identification, il lancera un [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html).
## Procédure pas à pas : utilisation des rôles IAM pour les instances EC2
La procédure pas à pas suivante explique comment récupérer un objet à l' Amazon S3 aide d'un rôle IAM pour gérer l'accès.
### Créer un rôle IAM
Créez un rôle IAM qui accorde un accès en lecture seule à. Amazon S3
1. Ouvrez la [console IAM](https://console.aws.amazon.com/iam/home).
1. Dans le panneau de navigation, sélectionnez **Rôles**, puis **Créer un rôle**.
1. Saisissez un nom pour le rôle, puis sélectionnez **Étape suivante**. N'oubliez pas ce nom, car vous en aurez besoin lorsque vous lancerez votre Amazon EC2 instance.
1. Sur la page **Sélectionner le type de rôle**, sous ** Service AWS Rôles**, sélectionnez ** Amazon EC2 **.
1. Sur la page **Définir les autorisations**, sous **Sélectionner un modèle de politique**, sélectionnez **Accès en Amazon S3 lecture seule**, puis **Étape suivante**.
1. Sur la page **Vérification**, sélectionnez **Créer un rôle**.
### Lancez une EC2 instance et spécifiez votre rôle IAM
Vous pouvez lancer une Amazon EC2 instance dotée d'un rôle IAM à l'aide de la Amazon EC2 console ou du AWS SDK pour Java.
+ Pour lancer une Amazon EC2 instance à l'aide de la console, suivez les instructions de la section [Getting Started with Amazon EC2 Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) du Guide de Amazon EC2 l'utilisateur pour les instances Linux.
Lorsque vous atteignez la page **Examiner le lancement de l'instance**, sélectionnez **Modifier les détails de l'instance**. Dans Rôle **IAM, choisissez le rôle** IAM que vous avez créé précédemment. Exécutez la procédure comme indiqué.
**Note**
Vous devrez créer ou utiliser un groupe de sécurité existant et une paire de clés pour vous connecter à l'instance.
+ Pour lancer une Amazon EC2 instance avec un rôle IAM à l'aide de AWS SDK pour Java, voir [Exécuter une Amazon EC2 instance](run-instance.md).
### Création de votre application
Créons l'exemple d'application à exécuter sur l' EC2 instance. Tout d'abord, créez un répertoire que vous pouvez utiliser pour stocker les fichiers du didacticiel (par exemple, `GetS3ObjectApp`).
Copiez ensuite les AWS SDK pour Java bibliothèques dans le répertoire que vous venez de créer. Si vous les AWS SDK pour Java avez téléchargés `~/Downloads` dans votre répertoire, vous pouvez les copier à l'aide des commandes suivantes :
```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```
Ouvrez un nouveau fichier, appelez-le `GetS3Object.java` et ajoutez le code suivant :
```
import java.io.*;
import com.amazonaws.auth.*;
import com.amazonaws.services.s3.*;
import com.amazonaws.services.s3.model.*;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
public class GetS3Object {
private static final String bucketName = "text-content";
private static final String key = "text-object.txt";
public static void main(String[] args) throws IOException
{
AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
try {
System.out.println("Downloading an object");
S3Object s3object = s3Client.getObject(
new GetObjectRequest(bucketName, key));
displayTextInputStream(s3object.getObjectContent());
}
catch(AmazonServiceException ase) {
System.err.println("Exception was thrown by the service");
}
catch(AmazonClientException ace) {
System.err.println("Exception was thrown by the client");
}
}
private static void displayTextInputStream(InputStream input) throws IOException
{
// Read one text line at a time and display.
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
while(true)
{
String line = reader.readLine();
if(line == null) break;
System.out.println( " " + line );
}
System.out.println();
}
}
```
Ouvrez un nouveau fichier, appelez-le `build.xml` et ajoutez les lignes suivantes :
```
```
Créez et exécutez le programme modifié. Notez qu'aucune information d'identification n'est stockée dans le programme. Par conséquent, à moins que vous n'ayez déjà spécifié vos AWS informations d'identification, le code sera lancé`AmazonServiceException`. Par exemple :
```
$ ant
Buildfile: /path/to/my/GetS3ObjectApp/build.xml
build:
[javac] Compiling 1 source file to /path/to/my/GetS3ObjectApp
run:
[java] Downloading an object
[java] AmazonServiceException
BUILD SUCCESSFUL
```
### Transférez le programme compilé vers votre EC2 instance
Transférez le programme vers votre Amazon EC2 instance à l'aide de secure copy (**``**), ainsi que les AWS SDK pour Java bibliothèques. La séquence de commandes ressemble à ce qui suit.
```
scp -p -i {my-key-pair}.pem GetS3Object.class ec2-user@{public_dns}:GetS3Object.class
scp -p -i {my-key-pair}.pem build.xml ec2-user@{public_dns}:build.xml
scp -r -p -i {my-key-pair}.pem lib ec2-user@{public_dns}:lib
scp -r -p -i {my-key-pair}.pem third-party ec2-user@{public_dns}:third-party
```
**Note**
En fonction de la distribution Linux que vous avez utilisée, le *nom d'utilisateur* peut être « ec2-user », « root » ou « ubuntu ». Pour obtenir le nom DNS public de votre instance, ouvrez la [EC2 console](https://console.aws.amazon.com/ec2/home) et recherchez la valeur **DNS public** dans l'onglet **Description** (par exemple,`ec2-198-51-100-1.compute-1.amazonaws.com`).
Dans les commandes précédentes :
+ `GetS3Object.class` est votre programme compilé
+ `build.xml` est le fichier ant utilisé pour créer et exécuter votre programme
+ les répertoires `lib` et `third-party` sont les dossiers de bibliothèque correspondants du kit AWS SDK pour Java.
+ Le `-r` commutateur indique qu'`scp`il doit effectuer une copie récursive de tout le contenu des `third-party` répertoires `library` et de la AWS SDK pour Java distribution.
+ Le commutateur `-p` indique que `scp` doit conserver les autorisations des fichiers sources lorsque ceux-ci sont copiés vers la destination.
**Note**
Le `-p` commutateur fonctionne uniquement sous Linux, macOS ou Unix. Si vous copiez des fichiers à partir de Windows, vous devrez peut-être corriger les autorisations de fichiers sur votre instance à l'aide de la commande suivante :
```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```
### Exécutez l'exemple de programme sur l' EC2 instance
Pour exécuter le programme, connectez-vous à votre Amazon EC2 instance. Pour plus d'informations, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux.
Si ** ` ant ` ** n'est pas disponible sur votre instance, installez-le à l'aide de la commande suivante :
```
sudo yum install ant
```
Exécutez ensuite le programme en utilisant `ant` comme suit :
```
ant run
```
Le programme va écrire le contenu de votre Amazon S3 objet dans votre fenêtre de commande.
# Tutoriel : Instances Amazon EC2 ponctuelles
## Présentation
Les instances ponctuelles vous permettent d'enchérir sur une capacité inutilisée Amazon Elastic Compute Cloud (Amazon EC2) jusqu'à 90 % par rapport au prix des instances à la demande et de gérer les instances acquises tant que votre offre dépasse le *prix spot* actuel. Amazon EC2 modifie périodiquement le prix spot en fonction de l'offre et de la demande, et les clients dont les offres l'atteignent ou le dépassent ont accès aux instances ponctuelles disponibles. Tout comme les instances à la demande et les instances réservées, les instances Spot vous offrent une autre possibilité d'obtenir des capacités de calcul supplémentaires.
Les instances Spot peuvent réduire considérablement vos Amazon EC2 coûts de traitement par lots, de recherche scientifique, de traitement d'image, d'encodage vidéo, d'exploration des données et du Web, d'analyse financière et de tests. De plus, les instances Spot vous donnent accès à de grandes quantités de capacité supplémentaire lorsque le besoin de capacité n'est pas urgent.
Pour utiliser des instances Spot, créez une demande d'instance Spot indiquant le prix maximum que vous êtes prêt à payer par heure d'instance. Cette valeur constitue votre offre. Si votre offre est supérieure au prix Spot actuel, votre demande est satisfaite et vos instances s'exécutent jusqu'à ce que vous décidiez de les résilier ou jusqu'à ce que le prix Spot devienne supérieur à votre offre, selon la première échéance.
Veuillez noter les points importants suivants :
+ Vous paierez souvent moins par heure que votre offre. Amazon EC2 ajuste périodiquement le prix au comptant en fonction des demandes reçues et de l'évolution de l'offre disponible. Chacun paie le même prix Spot pour cette période, même si l'offre soumise était supérieure. Par conséquent, vous pouvez payer moins que votre offre, mais vous ne paierez jamais plus que votre offre.
+ Si vous exécutez des instances Spot et que votre offre n'est plus égale au prix Spot actuel ou ne le dépasse plus, vos instances sont résiliées. Cela signifie que vous devez vous assurer que vos charges de travail et applications sont suffisamment flexibles pour tirer parti de cette capacité opportuniste.
Les instances Spot fonctionnent exactement comme les autres Amazon EC2 instances lorsqu'elles sont en cours d'exécution, et comme Amazon EC2 les autres instances, les instances Spot peuvent être résiliées lorsque vous n'en avez plus besoin. Si vous résiliez votre instance, vous êtes facturé pour toute heure d'utilisation partielle (comme c'est le cas pour les instances à la demande et les instances réservées). Toutefois, si le prix spot dépasse votre enchère et que votre instance est résiliée Amazon EC2, aucune heure d'utilisation partielle ne vous sera facturée.
Ce didacticiel montre comment AWS SDK pour Java effectuer les opérations suivantes.
+ Soumettre une demande Spot
+ Déterminer à quel moment la demande Spot est satisfaite
+ Annuler la demande Spot
+ Résilier les instances associées
## Prérequis
Pour utiliser ce didacticiel, vous devez l'avoir AWS SDK pour Java installé et avoir satisfait à ses prérequis d'installation de base. Voir [Configurer le AWS SDK pour Java](setup-install.md) pour plus d'informations.
## Étape 1 : Configurer vos informations d'identification
Pour commencer à utiliser cet exemple de code, vous devez configurer les AWS informations d'identification. Voir [Configurer les AWS informations d'identification et la région pour le développement](setup-credentials.md) pour obtenir des instructions sur la manière de procéder.
**Note**
Nous vous recommandons d'utiliser les informations d'identification d'un utilisateur IAM pour fournir ces valeurs. Pour plus d'informations, voir [Inscription AWS et création d'un utilisateur IAM](signup-create-iam-user.md).
Maintenant que vous avez configuré vos paramètres, vous pouvez commencer à utiliser le code de l'exemple.
## Étape 2 : Configurer un groupe de sécurité
Un *groupe de sécurité* fonctionne comme un pare-feu qui contrôle le trafic autorisé en entrée et en sortie d'un groupe d'instances. Par défaut, une instance est lancée sans aucun groupe de sécurité, ce qui signifie que l'ensemble du trafic IP entrant, sur n'importe quel port TCP, est refusé. Par conséquent, avant de soumettre notre demande Spot, nous allons configurer un groupe de sécurité qui permet le trafic réseau nécessaire. Dans le cadre de ce didacticiel, nous allons créer un nouveau groupe de sécurité appelé « GettingStarted » qui autorise le trafic Secure Shell (SSH) à partir de l'adresse IP à partir de laquelle vous exécutez votre application. Pour configurer un nouveau groupe de sécurité, vous devez inclure ou exécuter l'exemple de code suivant qui configure le groupe de sécurité par programmation.
Après avoir créé un objet `AmazonEC2` client, nous créons un `CreateSecurityGroupRequest` objet portant le nom « GettingStarted » et une description du groupe de sécurité. Ensuite, nous appelons l'API `ec2.createSecurityGroup` pour créer le groupe.
Pour permettre l'accès au groupe, nous créons un objet `ipPermission` avec la plage d'adresses IP définie sur la représentation CIDR du sous-réseau de l'ordinateur local ; le suffixe « /10 » de l'adresse IP indique le sous-réseau de l'adresse IP spécifiée. Nous configurons également l'objet `ipPermission` avec le protocole TCP et le port 22 (SSH). La dernière étape consiste à appeler `ec2.authorizeSecurityGroupIngress` avec le nom de notre groupe de sécurité et l'objet `ipPermission`.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Create a new security group.
try {
CreateSecurityGroupRequest securityGroupRequest = new CreateSecurityGroupRequest("GettingStartedGroup", "Getting Started Security Group");
ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
// Likely this means that the group is already created, so ignore.
System.out.println(ase.getMessage());
}
String ipAddr = "0.0.0.0/0";
// Get the IP of the current host, so that we can limit the Security
// Group by default to the ip range associated with your subnet.
try {
InetAddress addr = InetAddress.getLocalHost();
// Get IP Address
ipAddr = addr.getHostAddress()+"/10";
} catch (UnknownHostException e) {
}
// Create a range that you would like to populate.
ArrayList ipRanges = new ArrayList();
ipRanges.add(ipAddr);
// Open up port 22 for TCP traffic to the associated IP
// from above (e.g. ssh traffic).
ArrayList ipPermissions = new ArrayList ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);
try {
// Authorize the ports to the used.
AuthorizeSecurityGroupIngressRequest ingressRequest =
new AuthorizeSecurityGroupIngressRequest("GettingStartedGroup",ipPermissions);
ec2.authorizeSecurityGroupIngress(ingressRequest);
} catch (AmazonServiceException ase) {
// Ignore because this likely means the zone has
// already been authorized.
System.out.println(ase.getMessage());
}
```
Notez que vous avez uniquement besoin d'exécuter cette application une seule fois pour créer un nouveau groupe de sécurité.
Vous pouvez aussi créer le groupe de sécurité avec AWS Toolkit for Eclipse. Consultez [la section Gestion des groupes de sécurité à partir de AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) pour plus d'informations.
## Étape 3 : Envoyer la demande Spot
Pour soumettre une demande Spot, vous devez d'abord déterminer le type d'instance, l'AMI (Amazon Machine Image) et le prix maximum de l'offre à utiliser. Vous devez également inclure le groupe de sécurité configuré précédemment, afin de pouvoir vous connecter à l'instance, le cas échéant.
Vous avez le choix entre plusieurs types d'instances ; consultez la section Types d' Amazon EC2 instances pour une liste complète. Dans le cadre de ce didacticiel, nous allons utiliser t1.micro, le type d'instance le moins cher disponible. Ensuite, nous allons déterminer le type d'AMI à utiliser. Nous utiliserons ami-a9d09ed1, l'AMI up-to-date Amazon Linux la plus disponible lorsque nous avons écrit ce didacticiel. L'AMI la plus récente peut changer au fil du temps, mais vous pouvez déterminer la dernière version de l'AMI en procédant comme suit :
1. Ouvrez la [Amazon EC2 console](https://console.aws.amazon.com/ec2/home).
1. Choisissez le bouton **Lancer une instance**.
1. La première fenêtre affiche les informations AMIs disponibles. L'ID de l'AMI est répertorié en regard de chaque titre d'AMI. Vous pouvez aussi utiliser l'API `DescribeImages`, mais l'exploitation de cette commande n'entre pas dans le cadre de ce didacticiel.
Il existe de nombreuses façons d'aborder les offres relatives aux instances Spot. Pour obtenir une vue d'ensemble des diverses approches possibles, regardez la vidéo présentant les [offres relatives aux instances Spot](https://www.youtube.com/watch?v=WD9N73F3Fao&feature=player_embedded). Toutefois, pour commencer, nous allons décrire trois stratégies courantes : offre garantissant un coût inférieur à la tarification à la demande, offre basée sur la valeur du calcul résultant et offre visant à acquérir une capacité de calcul aussi vite que possible.
+ *Réduction du coût sous la tarification à la demande* Vous avez une tâche de traitement par lot dont l'exécution prendra un certain nombre d'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 obtenu avec les instances à la demande. Vous examinez l'historique des prix au comptant pour les types d'instances à l'aide de l'API AWS Management Console ou de l' Amazon EC2 API. Pour plus d'informations, consultez [Historique de tarification des instance Spots](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html). 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 :
+ Vous pouvez faire une offre à la limite supérieure de la plage de prix Spot (qui sont toujours inférieurs au prix à la demande), en anticipant que votre demande d'instance Spot sera très probablement satisfaite et que vous aurez suffisamment de temps de calcul consécutifs pour terminer la tâche.
+ Vous pouvez également spécifier le montant que vous êtes disposé à payer pour les instances Spot sous forme de % du prix des instances à la demande et prévoir de combiner de nombreuses instances lancées au fil du temps via une demande persistante. Si le prix spécifié est dépassé, l'instance Spot est résiliée. (Nous vous expliquerons comment automatiser cette tâche plus tard dans ce didacticiel.)
+ *Paiement égal ou inférieur à la valeur du résultat* Vous avez une tâche de traitement de données à exécuter. Vous connaissez la valeur des résultats de la tâche suffisamment bien pour savoir qu'ils représentent un réel intérêt en termes de coûts informatiques. Une fois que vous avez analysé l'historique des prix Spot pour votre type d'instance, vous choisissez un prix d'offre pour lequel le coût du temps de calcul n'est pas supérieur à la valeur des résultats de la tâche. Vous créez une offre 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 offre.
+ *Acquisition rapide de capacité de calcul* Vous avez un besoin de capacité supplémentaire imprévu, à court terme, que les instances à la demande ne peuvent pas satisfaire. Une fois que vous avez analysé l'historique des prix Spot pour votre type d'instance, vous effectuez une offre supérieure au prix historique le plus élevé afin d'être quasiment sûr que votre demande sera satisfaite rapidement et que vous pourrez poursuivre les calculs jusqu'à ce qu'elle soit terminée.
Une fois que vous avez choisi votre prix d'offre, vous êtes prêt à demander une instance Spot. Dans le cadre de ce didacticiel, nous allons faire une offre au prix à la demande (0,03 USD) afin de maximiser les chances que votre offre soit satisfaite. Vous pouvez déterminer les types d'instances disponibles et les prix à la demande pour les instances en vous rendant sur la page de Amazon EC2 tarification. Vous payez le prix Spot en vigueur pendant la durée d'exécution de vos instances Spot. Les prix des instances Spot sont fixés Amazon EC2 et ajustés progressivement en fonction des tendances à long terme de l'offre et de la demande de capacité des instances Spot. Vous pouvez également spécifier le montant que vous êtes disposé à payer pour une instance Spot sous forme de % du prix d'une instance à la demande. Pour demander une instance Spot, il vous suffit de créer votre demande avec les paramètres que vous avez choisis précédemment. Nous allons commencer par créer un objet `RequestSpotInstanceRequest`. L'objet de la demande nécessite le nombre d'instances que vous voulez démarrer et le prix de l'offre. De plus, vous devez définir l'élément `LaunchSpecification` pour la demande, qui comprend le type d'instance, l'ID d'AMI et le groupe de sécurité que vous souhaitez utiliser. Une fois la demande remplie, vous appelez la méthode `requestSpotInstances` sur l'objet `AmazonEC2Client`. L'exemple suivant indique comment demander une instance Spot.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Setup the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specifications to the request.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
```
L'exécution de ce code lance une nouvelle demande d'instance Spot. Il existe d'autres options que vous pouvez utiliser pour configurer vos demandes Spot. Pour en savoir plus, consultez [Tutorial : Advanced Amazon EC2 Spot Request Management](tutorial-spot-adv-java.md) ou la [RequestSpotInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesRequest.html)classe de la référence des AWS SDK pour Java API.
**Note**
Vous serez facturé pour toute instance Spot réellement lancée. Veillez donc à annuler toute demande inutile et à résilier toutes les instances que vous lancez afin de réduire les frais associés.
## Étape 4 : Déterminer l'état de votre demande Spot
Nous voulons créer le code en attendant que la demande Spot atteigne le statut « actif » avant de passer à la dernière étape. Pour déterminer l'état de notre demande Spot, nous interrogeons la méthode [describeSpotInstanceRequests](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#describeSpotInstanceRequests) pour connaître l'état de l'ID de demande Spot que nous voulons surveiller.
L'ID de demande créé à l'étape 2 est intégré dans la réponse à notre demande `requestSpotInstances`. L'exemple de code suivant montre comment recueillir des demandes à IDs partir de la `requestSpotInstances` réponse et les utiliser pour remplir un`ArrayList`.
```
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
List requestResponses = requestResult.getSpotInstanceRequests();
// Setup an arraylist to collect all of the request ids we want to
// watch hit the running state.
ArrayList spotInstanceRequestIds = new ArrayList();
// Add all of the request ids to the hashset, so we can determine when they hit the
// active state.
for (SpotInstanceRequest requestResponse : requestResponses) {
System.out.println("Created Spot Request: "+requestResponse.getSpotInstanceRequestId());
spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
}
```
Pour surveiller votre ID de demande, appelez la méthode `describeSpotInstanceRequests` pour déterminer l'état de la demande. Ensuite, poursuivez la boucle jusqu'à ce que la demande ne soit plus à l'état « ouvert ». Notez que nous recherchons un état autre qu'« ouvert », par exemple « actif », car la demande peut passer directement à l'état « fermé » s'il y a un problème au niveau des arguments de la demande. L'exemple de code suivant décrit comment accomplir cette tâche.
```
// Create a variable that will track whether there are any
// requests still in the open state.
boolean anyOpen;
do {
// Create the describeRequest object with all of the request ids
// to monitor (e.g. that we started).
DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
// Initialize the anyOpen variable to false - which assumes there
// are no requests open unless we find one that is still open.
anyOpen=false;
try {
// Retrieve all of the requests we want to monitor.
DescribeSpotInstanceRequestsResult describeResult = ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses = describeResult.getSpotInstanceRequests();
// Look through each request and determine if they are all in
// the active state.
for (SpotInstanceRequest describeResponse : describeResponses) {
// If the state is open, it hasn't changed since we attempted
// to request it. There is the potential for it to transition
// almost immediately to closed or cancelled so we compare
// against open instead of active.
if (describeResponse.getState().equals("open")) {
anyOpen = true;
break;
}
}
} catch (AmazonServiceException e) {
// If we have an exception, ensure we don't break out of
// the loop. This prevents the scenario where there was
// blip on the wire.
anyOpen = true;
}
try {
// Sleep for 60 seconds.
Thread.sleep(60*1000);
} catch (Exception e) {
// Do nothing because it woke up early.
}
} while (anyOpen);
```
Une fois ce code exécuté, votre demande d'instance Spot est terminée ou a échoué avec une erreur qui s'affiche à l'écran. Dans les deux cas, nous pouvons passer à l'étape suivante pour nettoyer les demandes actives et résilier toutes les instances en cours d'exécution.
## Étape 5 : Nettoyer vos demandes et instances Spot
Nous devons nettoyer nos demandes et instances. Il est important à la fois d'annuler toutes les demandes en cours *et* de résilier toutes les instances. Si vous annulez simplement vos demandes, cela ne résiliera pas vos instances, ce qui signifie que vous continuerez à payer pour elles. Lorsque vous résiliez vos instances, les demandes Spot peuvent être annulées, mais dans certains cas, par exemple si vous utilisez les offres persistantes, la résiliation de vos instances ne sera pas suffisante pour empêcher votre demande d'être à nouveau satisfaite. Par conséquent, annuler les offres actives et résilier en même temps toutes les instances en cours d'exécution constitue une bonne pratique.
Le code suivant montre comment annuler vos demandes.
```
try {
// Cancel requests.
CancelSpotInstanceRequestsRequest cancelRequest =
new CancelSpotInstanceRequestsRequest(spotInstanceRequestIds);
ec2.cancelSpotInstanceRequests(cancelRequest);
} catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error cancelling instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
Pour résilier les instances en attente, vous avez besoin de l'ID d'instance associé à la demande qui les a démarrées. L'exemple de code suivant utilise notre code d'origine pour surveiller les instances et ajoute un élément `ArrayList` dans lequel nous stockons l'ID d'instance associé à la réponse `describeInstance`.
```
// Create a variable that will track whether there are any requests
// still in the open state.
boolean anyOpen;
// Initialize variables.
ArrayList instanceIds = new ArrayList();
do {
// Create the describeRequest with all of the request ids to
// monitor (e.g. that we started).
DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
// Initialize the anyOpen variable to false, which assumes there
// are no requests open unless we find one that is still open.
anyOpen = false;
try {
// Retrieve all of the requests we want to monitor.
DescribeSpotInstanceRequestsResult describeResult =
ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses =
describeResult.getSpotInstanceRequests();
// Look through each request and determine if they are all
// in the active state.
for (SpotInstanceRequest describeResponse : describeResponses) {
// If the state is open, it hasn't changed since we
// attempted to request it. There is the potential for
// it to transition almost immediately to closed or
// cancelled so we compare against open instead of active.
if (describeResponse.getState().equals("open")) {
anyOpen = true; break;
}
// Add the instance id to the list we will
// eventually terminate.
instanceIds.add(describeResponse.getInstanceId());
}
} catch (AmazonServiceException e) {
// If we have an exception, ensure we don't break out
// of the loop. This prevents the scenario where there
// was blip on the wire.
anyOpen = true;
}
try {
// Sleep for 60 seconds.
Thread.sleep(60*1000);
} catch (Exception e) {
// Do nothing because it woke up early.
}
} while (anyOpen);
```
À l'aide de l'instance IDs, stockée dans le`ArrayList`, mettez fin à toutes les instances en cours d'exécution à l'aide de l'extrait de code suivant.
```
try {
// Terminate instances.
TerminateInstancesRequest terminateRequest = new TerminateInstancesRequest(instanceIds);
ec2.terminateInstances(terminateRequest);
} catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Synthèse
Pour réunir tout cela, nous proposons une approche davantage orientée objet qui combine les étapes précédentes que nous avons montrées : initialiser le EC2 client, soumettre la demande ponctuelle, déterminer à quel moment les demandes ponctuelles ne sont plus ouvertes et nettoyer toute demande ponctuelle persistante et les instances associées. Nous créons une classe appelée `Requests` qui effectue toutes ces actions.
Nous créons aussi une classe `GettingStartedApp` qui comporte une méthode principale au niveau de laquelle nous effectuons les appels de fonction de haut niveau. Nous initialisons en particulier l'objet `Requests` décrit précédemment. Nous soumettons la demande d'instance Spot. Nous attendons ensuite que l'état de la demande Spot soit « Actif ». Enfin, nous nettoyons les demandes et les instances.
Le code source complet de cet exemple peut être consulté ou téléchargé à l'adresse [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-GettingStarted).
Félicitations \$1 Vous venez de terminer le didacticiel de mise en route permettant de développer le logiciel d'instances Spot avec le kit AWS SDK pour Java.
## Étapes suivantes
Passez au [didacticiel : Gestion avancée des demandes Amazon EC2 ponctuelles](tutorial-spot-adv-java.md).
# Tutoriel : Gestion avancée des demandes Amazon EC2 ponctuelles
Amazon EC2 Les instances ponctuelles vous permettent d'enchérir sur la Amazon EC2 capacité inutilisée et d'exécuter ces instances tant que votre enchère dépasse le *prix au comptant* actuel. Amazon EC2 modifie périodiquement le prix au comptant en fonction de l'offre et de la demande. Pour plus d'informations sur les instances Spot, consultez la section [Instances Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) dans le Guide de Amazon EC2 l'utilisateur pour les instances Linux.
## Prérequis
Pour utiliser ce didacticiel, vous devez l'avoir AWS SDK pour Java installé et avoir satisfait à ses prérequis d'installation de base. Voir [Configurer le AWS SDK pour Java](setup-install.md) pour plus d'informations.
## Définition de vos informations d'identification
Pour commencer à utiliser cet exemple de code, vous devez configurer les AWS informations d'identification. Voir [Configurer les AWS informations d'identification et la région pour le développement](setup-credentials.md) pour obtenir des instructions sur la manière de procéder.
**Note**
Nous vous recommandons d'utiliser les informations d'identification d'un IAM utilisateur pour fournir ces valeurs. Pour plus d'informations, voir [Inscription AWS et création d'un IAM utilisateur](signup-create-iam-user.md).
Maintenant que vous avez configuré vos paramètres, vous pouvez commencer à utiliser le code de l'exemple.
## Configuration d'un groupe de sécurité
Un groupe de sécurité fonctionne comme un pare-feu qui contrôle le trafic autorisé en entrée et en sortie d'un groupe d'instances. Par défaut, une instance est lancée sans aucun groupe de sécurité, ce qui signifie que l'ensemble du trafic IP entrant, sur n'importe quel port TCP, est refusé. Par conséquent, avant de soumettre notre demande Spot, nous allons configurer un groupe de sécurité qui permet le trafic réseau nécessaire. Dans le cadre de ce didacticiel, nous allons créer un nouveau groupe de sécurité appelé « GettingStarted » qui autorise le trafic Secure Shell (SSH) à partir de l'adresse IP à partir de laquelle vous exécutez votre application. Pour configurer un nouveau groupe de sécurité, vous devez inclure ou exécuter l'exemple de code suivant qui configure le groupe de sécurité par programmation.
Après avoir créé un objet `AmazonEC2` client, nous créons un `CreateSecurityGroupRequest` objet portant le nom « GettingStarted » et une description du groupe de sécurité. Ensuite, nous appelons l'API `ec2.createSecurityGroup` pour créer le groupe.
Pour permettre l'accès au groupe, nous créons un objet `ipPermission` avec la plage d'adresses IP définie sur la représentation CIDR du sous-réseau de l'ordinateur local ; le suffixe « /10 » de l'adresse IP indique le sous-réseau de l'adresse IP spécifiée. Nous configurons également l'objet `ipPermission` avec le protocole TCP et le port 22 (SSH). La dernière étape consiste à appeler `ec2 .authorizeSecurityGroupIngress` avec le nom de notre groupe de sécurité et l'objet `ipPermission`.
(Le code suivant est identique à celui que nous avons utilisé dans le premier didacticiel.)
```
// Create the AmazonEC2Client object so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withCredentials(credentials)
.build();
// Create a new security group.
try {
CreateSecurityGroupRequest securityGroupRequest =
new CreateSecurityGroupRequest("GettingStartedGroup",
"Getting Started Security Group");
ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
// Likely this means that the group is already created, so ignore.
System.out.println(ase.getMessage());
}
String ipAddr = "0.0.0.0/0";
// Get the IP of the current host, so that we can limit the Security Group
// by default to the ip range associated with your subnet.
try {
// Get IP Address
InetAddress addr = InetAddress.getLocalHost();
ipAddr = addr.getHostAddress()+"/10";
}
catch (UnknownHostException e) {
// Fail here...
}
// Create a range that you would like to populate.
ArrayList ipRanges = new ArrayList();
ipRanges.add(ipAddr);
// Open up port 22 for TCP traffic to the associated IP from
// above (e.g. ssh traffic).
ArrayList ipPermissions = new ArrayList ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);
try {
// Authorize the ports to the used.
AuthorizeSecurityGroupIngressRequest ingressRequest =
new AuthorizeSecurityGroupIngressRequest(
"GettingStartedGroup",ipPermissions);
ec2.authorizeSecurityGroupIngress(ingressRequest);
}
catch (AmazonServiceException ase) {
// Ignore because this likely means the zone has already
// been authorized.
System.out.println(ase.getMessage());
}
```
Vous pouvez consulter la totalité de l'exemple de code dans l'exemple de code `advanced.CreateSecurityGroupApp.java`. Notez que vous avez uniquement besoin d'exécuter cette application une seule fois pour créer un nouveau groupe de sécurité.
**Note**
Vous pouvez aussi créer le groupe de sécurité avec AWS Toolkit for Eclipse. Pour plus d'informations, reportez-vous [à la section Gestion des groupes de sécurité AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) dans le guide de l' AWS Toolkit for Eclipse utilisateur.
## Options détaillées de création de demande d'instance Spot
Comme nous l'avons expliqué dans [Tutorial : Amazon EC2 Spot Instances](tutorial-spot-instances-java.md), vous devez créer votre demande à l'aide d'un type d'instance, d'une Amazon Machine Image (AMI) et d'un prix d'offre maximal.
Commençons par créer un objet `RequestSpotInstanceRequest`. L'objet de la demande nécessite le nombre d'instances que vous voulez et le prix de l'offre. De plus, nous devons définir l'élément `LaunchSpecification` pour la demande, laquelle inclut le type d'instance, l'ID de l'AMI et le groupe de sécurité que vous souhaitez utiliser. Une fois la demande remplie, nous appelons la méthode `requestSpotInstances` sur l'objet `AmazonEC2Client`. Voici un exemple de demande d'une instance Spot.
(Le code suivant est identique à celui que nous avons utilisé dans le premier didacticiel.)
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
## Demandes persistantes et demandes Spot
Lors de la création d'une demande Spot, vous pouvez spécifier plusieurs paramètres facultatifs. Le premier indique si votre demande est persistante ou uniquement ponctuelle. Par défaut, il s'agit d'une demande unique. Une demande unique ne peut être traitée qu'une seule fois, et après que les instances demandées sont résiliées, la demande est fermée. Une demande persistante est considérée comme devant être traitée chaque fois qu'il n'y a pas d'instance Spot en cours d'exécution pour la même demande. Pour spécifier le type de demande, vous devez simplement définir le type de la demande Spot. Vous pouvez le faire à l'aide du code suivant.
```
// Retrieves the credentials from an AWSCredentials.properties file.
AWSCredentials credentials = null;
try {
credentials = new PropertiesCredentials(
GettingStartedApp.class.getResourceAsStream("AwsCredentials.properties"));
}
catch (IOException e1) {
System.out.println(
"Credentials were not properly entered into AwsCredentials.properties.");
System.out.println(e1.getMessage());
System.exit(-1);
}
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest =
new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set the type of the bid to persistent.
requestRequest.setType("persistent");
// Set up the specifications of the launch. This includes the
// instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
## Limitation de la durée d'une demande
Vous pouvez aussi, le cas échéant, spécifier la durée pendant laquelle votre demande demeure valide. Vous pouvez spécifier une heure de début et une heure de fin pour cette période. Par défaut, une demande Spot est considérée comme devant être exécutée à partir du moment où elle est créée jusqu'à ce qu'elle soit achevée ou annulée par vous. Cependant, vous pouvez limiter la période de validité si nécessaire. Un exemple de la façon de spécifier cette période est illustré dans le code suivant.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set the valid start time to be two minutes from now.
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MINUTE, 2);
requestRequest.setValidFrom(cal.getTime());
// Set the valid end time to be two minutes and two hours from now.
cal.add(Calendar.HOUR, 2);
requestRequest.setValidUntil(cal.getTime());
// Set up the specifications of the launch. This includes
// the instance type (e.g. t1.micro)
// and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon
// Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType("t1.micro");
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
```
## Regroupement de vos demandes d'instance Amazon EC2 Spot
Vous avez la possibilité de regrouper vos demandes d'instances Spot de différentes façons. Nous allons examiner les avantages de l'utilisation de groupes de lancement, de groupes de zones de disponibilité et de groupes de placement.
Si vous voulez vous assurer que vos instances Spot sont toutes lancées et résiliées ensemble, vous avez la possibilité d'exploiter un groupe de lancement. Un groupe de lancement est une étiquette qui regroupe un ensemble d'offres. Toutes les instances d’un groupe de lancement sont démarrées et mises hors service ensemble. Notez que, si les instances d'un groupe de lancement ont déjà été satisfaites, il n'y a aucune garantie que les nouvelles instances lancées avec le même groupe de lancement le soient également. Un exemple de la façon de définir un groupe de lancement est illustré dans l'exemple de code suivant.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 5 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(5));
// Set the launch group.
requestRequest.setLaunchGroup("ADVANCED-DEMO-LAUNCH-GROUP");
// Set up the specifications of the launch. This includes
// the instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Si vous voulez vous assurer que toutes les instances au sein d'une demande sont lancées dans la même zone de disponibilité, et que vous ne vous préoccupez pas de savoir laquelle, vous pouvez exploiter les groupes de zones de disponibilité. Un groupe de zones de disponibilité est une étiquette qui regroupe un ensemble d'instances dans la même zone de disponibilité. Toutes les instances qui partagent un groupe de zones de disponibilité et qui sont satisfaites en même temps démarrent dans la même zone de disponibilité. Voici un exemple de définition d'un groupe de zones de disponibilité.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 5 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(5));
// Set the availability zone group.
requestRequest.setAvailabilityZoneGroup("ADVANCED-DEMO-AZ-GROUP");
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Vous pouvez spécifier une zone de disponibilité que vous souhaitez pour vos instances Spot. L'exemple de code suivant vous montre comment définir une zone de disponibilité.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Set up the availability zone to use. Note we could retrieve the
// availability zones using the ec2.describeAvailabilityZones() API. For
// this demo we will just use us-east-1a.
SpotPlacement placement = new SpotPlacement("us-east-1b");
launchSpecification.setPlacement(placement);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Enfin, vous pouvez spécifier un *groupe de placement* si vous utilisez des instances Spot de Calcul Haute Performance (HPC), telles que les instances de calcul de cluster ou les instances de cluster GPU. Les groupes de placement vous offrent une latence inférieure et une connexion de bande passante élevée entre les instances. Voici un exemple de définition d'un groupe de placement.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Set up the placement group to use with whatever name you desire.
// For this demo we will just use "ADVANCED-DEMO-PLACEMENT-GROUP".
SpotPlacement placement = new SpotPlacement();
placement.setGroupName("ADVANCED-DEMO-PLACEMENT-GROUP");
launchSpecification.setPlacement(placement);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Tous les paramètres affichés dans cette section sont facultatifs. Il est également important de savoir que la plupart de ces paramètres, à l'exception du fait que votre enchère soit ponctuelle ou persistante, peuvent réduire les chances d'exécution de l'offre. Par conséquent, il est important de n'exploiter ces options que si vous en avez besoin. Tous les exemples de code précédents sont regroupés en un seul exemple de code, disponible dans la classe `com.amazonaws.codesamples.advanced.InlineGettingStartedCodeSampleApp.java`.
## Comment rendre une partition racine permanente après une interruption ou une mise hors service
L'un des moyens les plus simples de gérer les interruptions de vos instances Spot est de veiller à ce que vos données soient transmises à un volume Amazon Elastic Block Store (Amazon Amazon EBS) à une cadence régulière. Grâce à un contrôle régulier, en cas d'interruption, vous perdez uniquement les données créées depuis le dernier point de contrôle (en présumant qu'il n'y ait pas eu d'autres actions non idempotentes exécutées entretemps). Pour faciliter le processus, vous pouvez configurer votre demande Spot afin de vous assurer que votre partition racine ne sera pas supprimée lors de l'interruption ou de la résiliation. Nous avons ajouté un nouveau code dans l'exemple suivant, qui montre comment activer ce scénario.
Dans le code ajouté, nous créons un `BlockDeviceMapping` objet et lui associons Amazon Elastic Block Store (Amazon EBS) un Amazon EBS objet que nous avons configuré pour `not` être supprimé en cas de résiliation de l'instance Spot. Nous l'ajoutons ensuite `BlockDeviceMapping` aux ArrayList mappages que nous incluons dans la spécification de lancement.
```
// Retrieves the credentials from an AWSCredentials.properties file.
AWSCredentials credentials = null;
try {
credentials = new PropertiesCredentials(
GettingStartedApp.class.getResourceAsStream("AwsCredentials.properties"));
}
catch (IOException e1) {
System.out.println(
"Credentials were not properly entered into AwsCredentials.properties.");
System.out.println(e1.getMessage());
System.exit(-1);
}
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Create the block device mapping to describe the root partition.
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping();
blockDeviceMapping.setDeviceName("/dev/sda1");
// Set the delete on termination flag to false.
EbsBlockDevice ebs = new EbsBlockDevice();
ebs.setDeleteOnTermination(Boolean.FALSE);
blockDeviceMapping.setEbs(ebs);
// Add the block device mapping to the block list.
ArrayList blockList = new ArrayList();
blockList.add(blockDeviceMapping);
// Set the block device mapping configuration in the launch specifications.
launchSpecification.setBlockDeviceMappings(blockList);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
En supposant que vous vouliez rattacher ce volume à votre instance au démarrage, vous pouvez également utiliser les paramètres de mappage de périphérique de stockage en mode bloc. Sinon, si vous avez joint une partition non root, vous pouvez spécifier les Amazon EBS volumes Amazon que vous souhaitez associer à votre instance Spot après sa reprise. Pour ce faire, vous devez simplement spécifier un ID d'instantané (snapshot) dans votre `EbsBlockDevice` et un autre nom d'appareil dans vos objets `BlockDeviceMapping`. En tirant parti des mappages de périphérique de stockage en mode bloc, il peut être plus facile d'amorcer votre instance.
L'utilisation de la partition racine pour contrôler vos données critiques est une excellente façon de gérer le risque d'une interruption de vos instances. Pour plus d'informations sur la gestion des risques d'interruption, consultez la vidéo [Gestion des interruptions](https://www.youtube.com/watch?feature=player_embedded&v=wcPNnUo60pc).
## Balisage de vos demandes et instances Spot
L'ajout de balises aux Amazon EC2 ressources peut simplifier l'administration de votre infrastructure cloud. Les balises, sorte de métadonnées, peuvent être utilisées pour créer des noms conviviaux, faciliter les recherches et améliorer la coordination entre plusieurs utilisateurs. Vous pouvez également utiliser des balises pour automatiser les scripts et des parties de vos processus. Pour en savoir plus sur le balisage Amazon EC2 des ressources, consultez la section [Utilisation des balises](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) dans le Guide de Amazon EC2 l'utilisateur pour les instances Linux.
### Balisage des demandes d'
Pour ajouter des balises à vos demandes Spot, vous devez les baliser *après* qu'elles ont été demandées. La valeur renvoyée par vous `requestSpotInstances()` fournit un [RequestSpotInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesResult.html)objet que vous pouvez utiliser pour obtenir la demande ponctuelle IDs pour le balisage :
```
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult = ec2.requestSpotInstances(requestRequest);
List requestResponses = requestResult.getSpotInstanceRequests();
// A list of request IDs to tag
ArrayList spotInstanceRequestIds = new ArrayList();
// Add the request ids to the hashset, so we can determine when they hit the
// active state.
for (SpotInstanceRequest requestResponse : requestResponses) {
System.out.println("Created Spot Request: "+requestResponse.getSpotInstanceRequestId());
spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
}
```
Une fois que vous avez le IDs, vous pouvez étiqueter les demandes en les ajoutant IDs à un [CreateTagsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateTagsRequest.html)et en appelant la `createTags()` méthode du Amazon EC2 client :
```
// The list of tags to create
ArrayList requestTags = new ArrayList();
requestTags.add(new Tag("keyname1","value1"));
// Create the tag request
CreateTagsRequest createTagsRequest_requests = new CreateTagsRequest();
createTagsRequest_requests.setResources(spotInstanceRequestIds);
createTagsRequest_requests.setTags(requestTags);
// Tag the spot request
try {
ec2.createTags(createTagsRequest_requests);
}
catch (AmazonServiceException e) {
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
### Balisage d'instances
Comme pour les demandes Spot elles-mêmes, vous ne pouvez baliser une instance qu'une fois qu'elle a été créée, ce qui se produit quand la demande Spot a été satisfaite (elle n'est plus à l'état *ouvert*).
Vous pouvez vérifier le statut de vos demandes en appelant la `describeSpotInstanceRequests()` méthode du Amazon EC2 client avec un [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsRequest.html)objet. L'[DescribeSpotInstanceRequestsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsResult.html)objet renvoyé contient une liste d'[SpotInstanceRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/SpotInstanceRequest.html)objets que vous pouvez utiliser pour vérifier le statut de vos demandes ponctuelles et obtenir leur instance IDs une fois qu'elles ne sont plus à l'état *ouvert*.
Une fois que la demande Spot n'est plus ouverte, vous pouvez récupérer son ID d'instance à partir de l'objet `SpotInstanceRequest` en appelant sa méthode `getInstanceId()`.
```
boolean anyOpen; // tracks whether any requests are still open
// a list of instances to tag.
ArrayList instanceIds = new ArrayList();
do {
DescribeSpotInstanceRequestsRequest describeRequest =
new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
anyOpen=false; // assume no requests are still open
try {
// Get the requests to monitor
DescribeSpotInstanceRequestsResult describeResult =
ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses =
describeResult.getSpotInstanceRequests();
// are any requests open?
for (SpotInstanceRequest describeResponse : describeResponses) {
if (describeResponse.getState().equals("open")) {
anyOpen = true;
break;
}
// get the corresponding instance ID of the spot request
instanceIds.add(describeResponse.getInstanceId());
}
}
catch (AmazonServiceException e) {
// Don't break the loop due to an exception (it may be a temporary issue)
anyOpen = true;
}
try {
Thread.sleep(60*1000); // sleep 60s.
}
catch (Exception e) {
// Do nothing if the thread woke up early.
}
} while (anyOpen);
```
Maintenant, vous pouvez baliser les instances qui sont renvoyées :
```
// Create a list of tags to create
ArrayList instanceTags = new ArrayList();
instanceTags.add(new Tag("keyname1","value1"));
// Create the tag request
CreateTagsRequest createTagsRequest_instances = new CreateTagsRequest();
createTagsRequest_instances.setResources(instanceIds);
createTagsRequest_instances.setTags(instanceTags);
// Tag the instance
try {
ec2.createTags(createTagsRequest_instances);
}
catch (AmazonServiceException e) {
// Write out any exceptions that may have occurred.
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Annulation des demandes Spot et mise hors service des instances
### Annulation d'une demande Spot
Pour annuler une demande d'instance Spot, appelez `cancelSpotInstanceRequests` le Amazon EC2 client avec un [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CancelSpotInstanceRequestsRequest.html)objet.
```
try {
CancelSpotInstanceRequestsRequest cancelRequest = new CancelSpotInstanceRequestsRequest(spotInstanceRequestIds);
ec2.cancelSpotInstanceRequests(cancelRequest);
} catch (AmazonServiceException e) {
System.out.println("Error cancelling instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
### Mise hors service d'instances Spot
Vous pouvez mettre fin à toutes les instances Spot en cours d'exécution en les transmettant IDs à la `terminateInstances()` méthode du Amazon EC2 client.
```
try {
TerminateInstancesRequest terminateRequest = new TerminateInstancesRequest(instanceIds);
ec2.terminateInstances(terminateRequest);
} catch (AmazonServiceException e) {
System.out.println("Error terminating instances");
System.out.println("Caught Exception: " + e.getMessage());
System.out.println("Reponse Status Code: " + e.getStatusCode());
System.out.println("Error Code: " + e.getErrorCode());
System.out.println("Request ID: " + e.getRequestId());
}
```
## Synthèse
Pour résumer, nous fournissons une approche plus orientée objet qui associe les étapes illustrées dans ce didacticiel en une classe facile à utiliser. Nous instancions une classe appelée `Requests` qui exécute ces actions. Nous créons aussi une classe `GettingStartedApp` qui comporte une méthode principale au niveau de laquelle nous effectuons les appels de fonction de haut niveau.
Le code source complet de cet exemple peut être consulté ou téléchargé à l'adresse [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-Advanced).
Félicitations \$1 Vous venez de terminer le didacticiel sur les fonctionnalités de demande avancées permettant de développer un logiciel d'instances Spot avec le kit AWS SDK pour Java.
# Gestion des Amazon EC2 instances
## Création d'une instance
Créez une nouvelle Amazon EC2 instance en appelant la `runInstances` méthode du EC2 client Amazon, en lui fournissant un [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)contenant l'[Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) à utiliser et un [type d'instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.InstanceType;
import com.amazonaws.services.ec2.model.RunInstancesRequest;
import com.amazonaws.services.ec2.model.RunInstancesResult;
import com.amazonaws.services.ec2.model.Tag;
```
**Code**
```
RunInstancesRequest run_request = new RunInstancesRequest()
.withImageId(ami_id)
.withInstanceType(InstanceType.T1Micro)
.withMaxCount(1)
.withMinCount(1);
RunInstancesResult run_response = ec2.runInstances(run_request);
String reservation_id = run_response.getReservation().getInstances().get(0).getInstanceId();
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateInstance.java).
## Démarrage d'une instance
Pour démarrer une Amazon EC2 instance, appelez la `startInstances` méthode du EC2 client Amazon, en lui fournissant un [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StartInstancesRequest.html)contenant l'ID de l'instance à démarrer.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StartInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StartInstancesRequest request = new StartInstancesRequest()
.withInstanceIds(instance_id);
ec2.startInstances(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Arrêt d'une instance
Pour arrêter une Amazon EC2 instance, appelez la `stopInstances` méthode du EC2 client Amazon, en lui fournissant un [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StopInstancesRequest.html)contenant l'ID de l'instance à arrêter.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StopInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StopInstancesRequest request = new StopInstancesRequest()
.withInstanceIds(instance_id);
ec2.stopInstances(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Redémarrage d'une instance
Pour redémarrer une Amazon EC2 instance, appelez la `rebootInstances` méthode du EC2 client Amazon en lui fournissant un identifiant [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RebootInstancesRequest.html)contenant l'ID de l'instance à redémarrer.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.RebootInstancesRequest;
import com.amazonaws.services.ec2.model.RebootInstancesResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
RebootInstancesRequest request = new RebootInstancesRequest()
.withInstanceIds(instance_id);
RebootInstancesResult response = ec2.rebootInstances(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/RebootInstance.java).
## Description des instances
Pour répertorier vos instances, créez une [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html)et appelez la `describeInstances` méthode du EC2 client Amazon. Il renverra un [DescribeInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesResult.html)objet que vous pourrez utiliser pour répertorier les Amazon EC2 instances de votre compte et de votre région.
Les instances sont regroupées par *réservation*. Chaque réservation correspond à l'appel de `startInstances` qui a lancé l'instance. Pour afficher vos instances, vous devez d'abord appeler la méthode getReservations de la classe `DescribeInstancesResult`, puis appeler la méthode `getReservations' method, and then call `getInstances`getInstances sur chaque objet [Reservation](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Reservation.html) renvoyé.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeInstancesRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesResult;
import com.amazonaws.services.ec2.model.Instance;
import com.amazonaws.services.ec2.model.Reservation;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
boolean done = false;
DescribeInstancesRequest request = new DescribeInstancesRequest();
while(!done) {
DescribeInstancesResult response = ec2.describeInstances(request);
for(Reservation reservation : response.getReservations()) {
for(Instance instance : reservation.getInstances()) {
System.out.printf(
"Found instance with id %s, " +
"AMI %s, " +
"type %s, " +
"state %s " +
"and monitoring state %s",
instance.getInstanceId(),
instance.getImageId(),
instance.getInstanceType(),
instance.getState().getName(),
instance.getMonitoring().getState());
}
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
Les résultats sont paginés ; vous pouvez obtenir plus de résultats en transmettant la valeur renvoyée par la méthode `getNextToken` de l'objet de résultat à la méthode `setNextToken` de l'objet de la demande d'origine, puis en utilisant le même objet de la demande lors de votre prochain appel de `describeInstances`.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeInstances.java).
## Surveillance d'une instance
Vous pouvez surveiller différents aspects de vos Amazon EC2 instances, tels que l'utilisation du processeur et du réseau, la mémoire disponible et l'espace disque restant. Pour en savoir plus sur la surveillance des instances, consultez la section [Surveillance Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux.
Pour commencer à surveiller une instance, vous devez en créer une [MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/MonitorInstancesRequest.html)avec l'ID de l'instance à surveiller et le transmettre à la `monitorInstances` méthode du EC2 client Amazon.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.MonitorInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
MonitorInstancesRequest request = new MonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.monitorInstances(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## Arrêt de la surveillance des instances
Pour arrêter la surveillance d'une instance, créez-en une [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/UnmonitorInstancesRequest.html)avec l'ID de l'instance pour arrêter la surveillance, et transmettez-la à la `unmonitorInstances` méthode du EC2 client Amazon.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.UnmonitorInstancesRequest;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
UnmonitorInstancesRequest request = new UnmonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.unmonitorInstances(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## En savoir plus
+ [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)dans la référence de Amazon EC2 l'API
+ [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)dans la référence de Amazon EC2 l'API
+ [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)dans la référence de Amazon EC2 l'API
+ [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)dans la référence de Amazon EC2 l'API
+ [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)dans la référence de Amazon EC2 l'API
+ [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)dans la référence de Amazon EC2 l'API
+ [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)dans la référence de Amazon EC2 l'API
# Utilisation d'adresses IP élastiques dans Amazon EC2
## EC2-Classic prend sa retraite
**Avertissement**
Nous retirons EC2 -Classic le 15 août 2022. Nous vous recommandons de migrer de EC2 -Classic vers un VPC. Pour plus d'informations, consultez le billet de blog [EC2-Classic-Classic Networking is Retiring — Here's](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) How to Prepare.
## Allocation d'une adresse IP Elastic
Pour utiliser une adresse IP Elastic, commencez par en attribuer une à votre compte, puis associez-la à votre instance ou à une interface réseau.
Pour allouer une adresse IP élastique, appelez la `allocateAddress` méthode du EC2 client Amazon avec un [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressRequest.html)objet contenant le type de réseau (classique EC2 ou VPC).
Le document renvoyé [AllocateAddressResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressResult.html)contient un ID d'allocation que vous pouvez utiliser pour associer l'adresse à une instance, en transmettant l'ID d'allocation et l'ID d'instance dans a [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AssociateAddressRequest.html)à la `associateAddress` méthode du EC2 client Amazon.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.AllocateAddressRequest;
import com.amazonaws.services.ec2.model.AllocateAddressResult;
import com.amazonaws.services.ec2.model.AssociateAddressRequest;
import com.amazonaws.services.ec2.model.AssociateAddressResult;
import com.amazonaws.services.ec2.model.DomainType;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
AllocateAddressRequest allocate_request = new AllocateAddressRequest()
.withDomain(DomainType.Vpc);
AllocateAddressResult allocate_response =
ec2.allocateAddress(allocate_request);
String allocation_id = allocate_response.getAllocationId();
AssociateAddressRequest associate_request =
new AssociateAddressRequest()
.withInstanceId(instance_id)
.withAllocationId(allocation_id);
AssociateAddressResult associate_response =
ec2.associateAddress(associate_request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/AllocateAddress.java).
## Description des adresses IP Elastic
Pour répertorier les adresses IP élastiques attribuées à votre compte, appelez la `describeAddresses` méthode du EC2 client Amazon. Il renvoie un [DescribeAddressesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAddressesResult.html)que vous pouvez utiliser pour obtenir une liste d'objets [Address](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Address.html) qui représentent les adresses IP élastiques de votre compte.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.Address;
import com.amazonaws.services.ec2.model.DescribeAddressesResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DescribeAddressesResult response = ec2.describeAddresses();
for(Address address : response.getAddresses()) {
System.out.printf(
"Found address with public IP %s, " +
"domain %s, " +
"allocation id %s " +
"and NIC id %s",
address.getPublicIp(),
address.getDomain(),
address.getAllocationId(),
address.getNetworkInterfaceId());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAddresses.java).
## Libération d'une adresse IP Elastic
Pour libérer une adresse IP élastique, appelez la `releaseAddress` méthode du EC2 client Amazon en lui transmettant un code [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/ReleaseAddressRequest.html)contenant l'ID d'allocation de l'adresse IP élastique que vous souhaitez libérer.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.ReleaseAddressRequest;
import com.amazonaws.services.ec2.model.ReleaseAddressResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
ReleaseAddressRequest request = new ReleaseAddressRequest()
.withAllocationId(alloc_id);
ReleaseAddressResult response = ec2.releaseAddress(request);
```
Une fois que vous avez publié une adresse IP élastique, elle est publiée dans le pool d'adresses AWS IP et il se peut que vous ne soyez plus disponible par la suite. Veillez à mettre à jour vos enregistrements DNS, ainsi que les serveurs ou les appareils qui communiquent avec l'adresse. Si vous tentez de libérer une adresse IP élastique que vous avez déjà publiée, un *AuthFailure*message d'erreur s'affichera si l'adresse est déjà attribuée à une autre adresse Compte AWS.
Si vous utilisez *EC2-Classic* ou un *VPC par défaut*, la libération d'une adresse IP élastique la dissocie automatiquement de toute instance à laquelle elle est associée. Pour dissocier une adresse IP élastique sans la divulguer, utilisez la `disassociateAddress` méthode du EC2 client Amazon.
Si vous utilisez un VPC autre que par défaut, vous *devez* utiliser `disassociateAddress` pour dissocier l'adresse IP Elastic avant d'essayer de la libérer. Dans le cas contraire, Amazon EC2 renvoie une erreur (*non valide)IPAddress. InUse*).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/ReleaseAddress.java).
## En savoir plus
+ [Adresses IP élastiques](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux
+ [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)dans la référence de Amazon EC2 l'API
+ [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)dans la référence de Amazon EC2 l'API
+ [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)dans la référence de Amazon EC2 l'API
# Utiliser les régions et les zones de disponibilité
## Décrire les régions
Pour répertorier les régions disponibles pour votre compte, appelez la `describeRegions` méthode du EC2 client Amazon. Elle renvoie un [DescribeRegionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeRegionsResult.html). Appelez la méthode `getRegions` de l'objet renvoyé pour obtenir une liste d'objets [Region](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Region.html) qui représentent chaque région.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeRegionsResult;
import com.amazonaws.services.ec2.model.Region;
import com.amazonaws.services.ec2.model.AvailabilityZone;
import com.amazonaws.services.ec2.model.DescribeAvailabilityZonesResult;
```
**Code**
```
DescribeRegionsResult regions_response = ec2.describeRegions();
for(Region region : regions_response.getRegions()) {
System.out.printf(
"Found region %s " +
"with endpoint %s",
region.getRegionName(),
region.getEndpoint());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Décrire les zones de disponibilité
Pour répertorier chaque zone de disponibilité disponible pour votre compte, appelez la `describeAvailabilityZones` méthode du EC2 client Amazon. Elle renvoie un [DescribeAvailabilityZonesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAvailabilityZonesResult.html). Appelez sa `getAvailabilityZones` méthode pour obtenir une liste d'[AvailabilityZone](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AvailabilityZone.html)objets représentant chaque zone de disponibilité.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeRegionsResult;
import com.amazonaws.services.ec2.model.Region;
import com.amazonaws.services.ec2.model.AvailabilityZone;
import com.amazonaws.services.ec2.model.DescribeAvailabilityZonesResult;
```
**Code**
```
DescribeAvailabilityZonesResult zones_response =
ec2.describeAvailabilityZones();
for(AvailabilityZone zone : zones_response.getAvailabilityZones()) {
System.out.printf(
"Found availability zone %s " +
"with status %s " +
"in region %s",
zone.getZoneName(),
zone.getState(),
zone.getRegionName());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Décrire les comptes
Pour décrire votre compte, appelez la `describeAccountAttributes` méthode du EC2 client Amazon. Cette méthode renvoie un [DescribeAccountAttributesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAccountAttributesResult.html)objet. Invoquez cette `getAccountAttributes` méthode d'objets pour obtenir une liste d'[AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)objets. Vous pouvez parcourir la liste pour récupérer un [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)objet.
Vous pouvez obtenir les valeurs d'attribut de votre compte en invoquant la `getAttributeValues` méthode de [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)l'objet. Cette méthode renvoie une liste d'[AccountAttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttributeValue.html)objets. Vous pouvez parcourir cette deuxième liste pour afficher la valeur des attributs (voir l'exemple de code ci-dessous).
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.AccountAttributeValue;
import com.amazonaws.services.ec2.model.DescribeAccountAttributesResult;
import com.amazonaws.services.ec2.model.AccountAttribute;
import java.util.List;
import java.util.ListIterator;
```
**Code**
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
try{
DescribeAccountAttributesResult accountResults = ec2.describeAccountAttributes();
List accountList = accountResults.getAccountAttributes();
for (ListIterator iter = accountList.listIterator(); iter.hasNext(); ) {
AccountAttribute attribute = (AccountAttribute) iter.next();
System.out.print("\n The name of the attribute is "+attribute.getAttributeName());
List values = attribute.getAttributeValues();
//iterate through the attribute values
for (ListIterator iterVals = values.listIterator(); iterVals.hasNext(); ) {
AccountAttributeValue myValue = (AccountAttributeValue) iterVals.next();
System.out.print("\n The value of the attribute is "+myValue.getAttributeValue());
}
}
System.out.print("Done");
}
catch (Exception e)
{
e.getStackTrace();
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAccount.java) sur GitHub.
## En savoir plus
+ [Régions et zones de disponibilité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux
+ [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)dans la référence de Amazon EC2 l'API
+ [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)dans la référence de Amazon EC2 l'API
# Utilisation de paires Amazon EC2 de clés
## Création d'une paire de clés
Pour créer une paire de clés, appelez la `createKeyPair` méthode du EC2 client Amazon avec un [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html)qui contient le nom de la clé.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateKeyPairRequest;
import com.amazonaws.services.ec2.model.CreateKeyPairResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateKeyPairRequest request = new CreateKeyPairRequest()
.withKeyName(key_name);
CreateKeyPairResult response = ec2.createKeyPair(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateKeyPair.java).
## Description de paire de clés
Pour répertorier vos paires de clés ou pour obtenir des informations à leur sujet, appelez la `describeKeyPairs` méthode du EC2 client Amazon. Elle renvoie un [DescribeKeyPairsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeKeyPairsResult.html)que vous pouvez utiliser pour accéder à la liste des paires de clés en appelant sa `getKeyPairs` méthode, qui renvoie une liste d'[KeyPairInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPairInfo.html)objets.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeKeyPairsResult;
import com.amazonaws.services.ec2.model.KeyPairInfo;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DescribeKeyPairsResult response = ec2.describeKeyPairs();
for(KeyPairInfo key_pair : response.getKeyPairs()) {
System.out.printf(
"Found key pair with name %s " +
"and fingerprint %s",
key_pair.getKeyName(),
key_pair.getKeyFingerprint());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeKeyPairs.java).
## Suppression d'une paire de clés
Pour supprimer une paire de clés, appelez la `deleteKeyPair` méthode du EC2 client Amazon en lui transmettant un [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteKeyPairRequest.html)contenant le nom de la paire de clés à supprimer.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DeleteKeyPairRequest;
import com.amazonaws.services.ec2.model.DeleteKeyPairResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteKeyPairRequest request = new DeleteKeyPairRequest()
.withKeyName(key_name);
DeleteKeyPairResult response = ec2.deleteKeyPair(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteKeyPair.java).
## En savoir plus
+ [Amazon EC2 Paires de clés](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux
+ [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)dans la référence de Amazon EC2 l'API
+ [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)dans la référence de Amazon EC2 l'API
+ [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)dans la référence de Amazon EC2 l'API
# Utilisation de groupes de sécurité dans Amazon EC2
## Création d'un groupe de sécurité
Pour créer un groupe de sécurité, appelez la `createSecurityGroup` méthode du EC2 client Amazon avec un [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html)qui contient le nom de la clé.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateSecurityGroupRequest;
import com.amazonaws.services.ec2.model.CreateSecurityGroupResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateSecurityGroupRequest create_request = new
CreateSecurityGroupRequest()
.withGroupName(group_name)
.withDescription(group_desc)
.withVpcId(vpc_id);
CreateSecurityGroupResult create_response =
ec2.createSecurityGroup(create_request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Configuration d'un groupe de sécurité
Un groupe de sécurité peut contrôler à la fois le trafic entrant (entrée) et sortant (sortie) vers vos instances. Amazon EC2
Pour ajouter des règles d'entrée à votre groupe de sécurité, utilisez la `authorizeSecurityGroupIngress` méthode du EC2 client Amazon, en fournissant le nom du groupe de sécurité et les règles d'accès ([IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html)) que vous souhaitez lui attribuer dans un [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupIngressRequest.html)objet. L'exemple suivant montre comment ajouter des autorisations IP à un groupe de sécurité.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.CreateSecurityGroupRequest;
import com.amazonaws.services.ec2.model.CreateSecurityGroupResult;
```
**Code**
```
IpRange ip_range = new IpRange()
.withCidrIp("0.0.0.0/0");
IpPermission ip_perm = new IpPermission()
.withIpProtocol("tcp")
.withToPort(80)
.withFromPort(80)
.withIpv4Ranges(ip_range);
IpPermission ip_perm2 = new IpPermission()
.withIpProtocol("tcp")
.withToPort(22)
.withFromPort(22)
.withIpv4Ranges(ip_range);
AuthorizeSecurityGroupIngressRequest auth_request = new
AuthorizeSecurityGroupIngressRequest()
.withGroupName(group_name)
.withIpPermissions(ip_perm, ip_perm2);
AuthorizeSecurityGroupIngressResult auth_response =
ec2.authorizeSecurityGroupIngress(auth_request);
```
Pour ajouter une règle de sortie au groupe de sécurité, fournissez des données similaires dans une [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html)`authorizeSecurityGroupEgress`méthode du EC2 client Amazon.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Description des groupes de sécurité
Pour décrire vos groupes de sécurité ou obtenir des informations à leur sujet, appelez la `describeSecurityGroups` méthode du EC2 client Amazon. Elle renvoie un [DescribeSecurityGroupsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSecurityGroupsResult.html)que vous pouvez utiliser pour accéder à la liste des groupes de sécurité en appelant sa `getSecurityGroups` méthode, qui renvoie une liste d'[SecurityGroup](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/SecurityGroup.html)objets.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DescribeSecurityGroupsRequest;
import com.amazonaws.services.ec2.model.DescribeSecurityGroupsResult;
```
**Code**
```
final String USAGE =
"To run this example, supply a group id\n" +
"Ex: DescribeSecurityGroups \n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String group_id = args[0];
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeSecurityGroups.java).
## Suppression d'un groupe de sécurité
Pour supprimer un groupe de sécurité, appelez la `deleteSecurityGroup` méthode du EC2 client Amazon en lui transmettant un identifiant [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteSecurityGroupRequest.html)contenant l'ID du groupe de sécurité à supprimer.
**Importations**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.DeleteSecurityGroupRequest;
import com.amazonaws.services.ec2.model.DeleteSecurityGroupResult;
```
**Code**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteSecurityGroupRequest request = new DeleteSecurityGroupRequest()
.withGroupId(group_id);
DeleteSecurityGroupResult response = ec2.deleteSecurityGroup(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteSecurityGroup.java).
## En savoir plus
+ [Amazon EC2 Groupes de sécurité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) dans le guide de Amazon EC2 l'utilisateur pour les instances Linux
+ [Autorisation du trafic entrant pour vos instances Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) dans le guide de l' Amazon EC2 utilisateur pour les instances Linux
+ [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)dans la référence de Amazon EC2 l'API
+ [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)dans la référence de Amazon EC2 l'API
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)dans la référence de Amazon EC2 l'API
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)dans la référence de Amazon EC2 l'API
# Exemples d'IAM utilisant le AWS SDK pour Java
Cette section fournit des exemples de programmation d'[IAM](https://aws.amazon.com/iam/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
Gestion des identités et des accès AWS (IAM) vous permet de contrôler en toute sécurité l'accès aux AWS services et aux ressources pour vos utilisateurs. À l'aide d'IAM, vous pouvez créer et gérer des AWS utilisateurs et des groupes, et utiliser des autorisations pour autoriser ou refuser leur accès aux AWS ressources. Pour un guide complet de l'IAM, consultez le [guide de l'IAM utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Gestion des clés d’accès IAM](examples-iam-access-keys.md)
+ [Gestion des utilisateurs IAM](examples-iam-users.md)
+ [Utilisation des alias de compte IAM](examples-iam-account-aliases.md)
+ [Utilisation des stratégies IAM](examples-iam-policies.md)
+ [Utilisation des certificats de serveur IAM](examples-iam-server-certificates.md)
# Gestion des clés d’accès IAM
## Création d'une clé d'accès
Pour créer une clé d'accès IAM, appelez la AmazonIdentityManagementClient `createAccessKey` méthode avec un [CreateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccessKeyRequest.html)objet.
`CreateAccessKeyRequest`possède deux constructeurs : un qui prend un nom d'utilisateur et un autre sans paramètres. Si vous utilisez la version qui ne prend aucun paramètre, vous devez définir le nom d'utilisateur à l'aide de la méthode setter `withUserName` avant de transmettre celui-ci à la méthode `createAccessKey`.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.CreateAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccessKeyRequest request = new CreateAccessKeyRequest()
.withUserName(user);
CreateAccessKeyResult response = iam.createAccessKey(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccessKey.java) sur GitHub.
## Affichage de la liste des clés d'accès
Pour répertorier les clés d'accès d'un utilisateur donné, créez un [ListAccessKeysRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysRequest.html)objet contenant le nom d'utilisateur pour lequel vous souhaitez répertorier les clés, et transmettez-le à la `listAccessKeys` méthode AmazonIdentityManagementClient's.
**Note**
Si vous ne fournissez pas de nom d'utilisateur à`listAccessKeys`, il tentera de répertorier les clés d'accès associées à celui Compte AWS qui a signé la demande.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.AccessKeyMetadata;
import com.amazonaws.services.identitymanagement.model.ListAccessKeysRequest;
import com.amazonaws.services.identitymanagement.model.ListAccessKeysResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListAccessKeysRequest request = new ListAccessKeysRequest()
.withUserName(username);
while (!done) {
ListAccessKeysResult response = iam.listAccessKeys(request);
for (AccessKeyMetadata metadata :
response.getAccessKeyMetadata()) {
System.out.format("Retrieved access key %s",
metadata.getAccessKeyId());
}
request.setMarker(response.getMarker());
if (!response.getIsTruncated()) {
done = true;
}
}
```
Les résultats de `listAccessKeys` sont paginés par défaut (avec un maximum de 100 enregistrements par appel). Vous pouvez faire appel `getIsTruncated` à l'[ListAccessKeysResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysResult.html)objet renvoyé pour voir si la requête a renvoyé moins de résultats que ceux disponibles. Si tel est le cas, appelez `setMarker` sur l'objet `ListAccessKeysRequest` et retransmettez-le dans le prochain appel de `listAccessKeys`.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccessKeys.java) sur GitHub.
## Récupération de l'heure de la dernière utilisation d'une clé d'accès
Pour connaître l'heure à laquelle une clé d'accès a été utilisée pour la dernière fois, appelez la `getAccessKeyLastUsed` méthode AmazonIdentityManagementClient's avec l'ID de la clé d'accès (qui peut être transmis à l'aide d'un [GetAccessKeyLastUsedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedRequest.html)objet) ou directement à la surcharge qui prend directement l'ID de la clé d'accès.
Vous pouvez ensuite utiliser l'[GetAccessKeyLastUsedResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedResult.html)objet renvoyé pour récupérer la date de dernière utilisation de la clé.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetAccessKeyLastUsedRequest;
import com.amazonaws.services.identitymanagement.model.GetAccessKeyLastUsedResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetAccessKeyLastUsedRequest request = new GetAccessKeyLastUsedRequest()
.withAccessKeyId(access_id);
GetAccessKeyLastUsedResult response = iam.getAccessKeyLastUsed(request);
System.out.println("Access key was last used at: " +
response.getAccessKeyLastUsed().getLastUsedDate());
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AccessKeyLastUsed.java) sur GitHub.
## Activation ou désactivation des clés d'accès
Vous pouvez activer ou désactiver une clé d'accès en créant un [UpdateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateAccessKeyRequest.html)objet, en fournissant l'ID de la clé d'accès, éventuellement le nom d'utilisateur et le [statut](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/StatusType.html) souhaité, puis en transmettant l'objet de la demande à la `updateAccessKey` méthode AmazonIdentityManagementClient's.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.UpdateAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
.withAccessKeyId(access_id)
.withUserName(username)
.withStatus(status);
UpdateAccessKeyResult response = iam.updateAccessKey(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateAccessKey.java) sur GitHub.
## Suppression d'une clé d'accès
Pour supprimer définitivement une clé d'accès, appelez la `deleteKey` méthode AmazonIdentityManagementClient's en lui fournissant un [DeleteAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccessKeyRequest.html)contenant l'identifiant et le nom d'utilisateur de la clé d'accès.
**Note**
Une fois supprimée, une clé ne peut plus être récupérée ou utilisée. Pour désactiver temporairement une clé afin qu'elle puisse être réactivée ultérieurement, utilisez plutôt la [updateAccessKey](#iam-access-keys-update)méthode.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteAccessKeyRequest;
import com.amazonaws.services.identitymanagement.model.DeleteAccessKeyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
.withAccessKeyId(access_key)
.withUserName(username);
DeleteAccessKeyResult response = iam.deleteAccessKey(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccessKey.java) sur GitHub.
## En savoir plus
+ [CreateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)dans la référence de l'API IAM
+ [ListAccessKeys](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccessKeys.html)dans la référence de l'API IAM
+ [GetAccessKeyLastUsed](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetAccessKeyLastUsed.html)dans la référence de l'API IAM
+ [UpdateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAccessKey.html)dans la référence de l'API IAM
+ [DeleteAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html)dans la référence de l'API IAM
# Gestion des utilisateurs IAM
## Création d'un utilisateur
Créez un nouvel utilisateur IAM en fournissant le nom d'utilisateur à la `createUser` méthode AmazonIdentityManagementClient's, soit directement, soit en utilisant un [CreateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateUserRequest.html)objet contenant le nom d'utilisateur.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateUserRequest;
import com.amazonaws.services.identitymanagement.model.CreateUserResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateUserRequest request = new CreateUserRequest()
.withUserName(username);
CreateUserResult response = iam.createUser(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateUser.java) sur GitHub.
## Affichage d'une liste d'utilisateurs
Pour répertorier les utilisateurs IAM associés à votre compte, créez-en un nouveau [ListUsersRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListUsersRequest.html)et passez-le à la `listUsers` méthode AmazonIdentityManagementClient's. Vous pouvez récupérer la liste des utilisateurs en appelant `getUsers` l'[ListUsersResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListUsersResult.html)objet renvoyé.
La liste d'utilisateurs renvoyée par `listUsers` est paginée. Vous pouvez vérifier s'il existe plus de résultats à récupérer en appelant la méthode `getIsTruncated` de l'objet de réponse. Si celle-ci renvoie `true`, appelez la méthode `setMarker()` de l'objet de demande, en lui transmettant la valeur de retour de la méthode `getMarker()` de l'objet de réponse.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListUsersRequest;
import com.amazonaws.services.identitymanagement.model.ListUsersResult;
import com.amazonaws.services.identitymanagement.model.User;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListUsersRequest request = new ListUsersRequest();
while(!done) {
ListUsersResult response = iam.listUsers(request);
for(User user : response.getUsers()) {
System.out.format("Retrieved user %s", user.getUserName());
}
request.setMarker(response.getMarker());
if(!response.getIsTruncated()) {
done = true;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListUsers.java) sur GitHub.
## Mise à jour d'un utilisateur
Pour mettre à jour un utilisateur, appelez la `updateUser` méthode de l' AmazonIdentityManagementClient objet, qui prend un [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)objet que vous pouvez utiliser pour modifier le *nom* ou le *chemin* de l'utilisateur.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateUserRequest;
import com.amazonaws.services.identitymanagement.model.UpdateUserResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateUserRequest request = new UpdateUserRequest()
.withUserName(cur_name)
.withNewUserName(new_name);
UpdateUserResult response = iam.updateUser(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateUser.java) sur GitHub.
## Suppression d'un utilisateur
Pour supprimer un utilisateur, appelez AmazonIdentityManagementClient la `deleteUser` demande avec un [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)objet défini avec le nom d'utilisateur à supprimer.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteConflictException;
import com.amazonaws.services.identitymanagement.model.DeleteUserRequest;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteUserRequest request = new DeleteUserRequest()
.withUserName(username);
try {
iam.deleteUser(request);
} catch (DeleteConflictException e) {
System.out.println("Unable to delete user. Verify user is not" +
" associated with any resources");
throw e;
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteUser.java) sur GitHub.
## En savoir plus
+ [Les utilisateurs d'IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) dans le guide de l' IAM utilisateur
+ [Gestion des utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) dans le guide de l' IAM utilisateur
+ [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html)dans la référence de l'API IAM
+ [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)dans la référence de l'API IAM
+ [UpdateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateUser.html)dans la référence de l'API IAM
+ [DeleteUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUser.html)dans la référence de l'API IAM
# Utilisation des alias de compte IAM
Si vous souhaitez que l'URL de votre page de connexion contienne le nom de votre entreprise ou un autre identifiant convivial au lieu de votre Compte AWS identifiant, vous pouvez créer un alias pour votre Compte AWS.
**Note**
AWS prend en charge exactement un alias de compte par compte.
## Création d'un alias de compte
Pour créer un alias de compte, appelez la `createAccountAlias` méthode AmazonIdentityManagementClient's avec un [CreateAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccountAliasRequest.html)objet contenant le nom de l'alias.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateAccountAliasRequest;
import com.amazonaws.services.identitymanagement.model.CreateAccountAliasResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccountAliasRequest request = new CreateAccountAliasRequest()
.withAccountAlias(alias);
CreateAccountAliasResult response = iam.createAccountAlias(request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccountAlias.java) sur GitHub.
## Liste des alias de compte
Pour répertorier l'alias de votre compte, le cas échéant, appelez la `listAccountAliases` méthode AmazonIdentityManagementClient's.
**Note**
Les méthodes [ListAccountAliasesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListAccountAliasesResult.html)renvoyées sont compatibles avec les mêmes `getMarker` méthodes `getIsTruncated` et que les autres méthodes de AWS SDK pour Java *liste*, mais l'an ne Compte AWS peut avoir qu'*un* seul alias de compte.
**importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListAccountAliasesResult;
```
**code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
ListAccountAliasesResult response = iam.listAccountAliases();
for (String alias : response.getAccountAliases()) {
System.out.printf("Retrieved account alias %s", alias);
}
```
voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccountAliases.java) sur GitHub.
## Suppression d'un alias de compte
Pour supprimer l'alias de votre compte, appelez la `deleteAccountAlias` méthode AmazonIdentityManagementClient's. Lorsque vous supprimez un alias de compte, vous devez fournir son nom à l'aide d'un [DeleteAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccountAliasRequest.html)objet.
**importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteAccountAliasRequest;
import com.amazonaws.services.identitymanagement.model.DeleteAccountAliasResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
.withAccountAlias(alias);
DeleteAccountAliasResult response = iam.deleteAccountAlias(request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccountAlias.java) sur GitHub.
## En savoir plus
+ [Votre identifiant de AWS compte et son alias](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html) dans le guide de IAM l'utilisateur
+ [CreateAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccountAlias.html)dans la référence de l'API IAM
+ [ListAccountAliases](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccountAliases.html)dans la référence de l'API IAM
+ [DeleteAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccountAlias.html)dans la référence de l'API IAM
# Utilisation des stratégies IAM
## Création d'une politique
Pour créer une nouvelle politique, indiquez le nom de la stratégie et un document de politique au format JSON dans la méthode a [CreatePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreatePolicyRequest.html)to the AmazonIdentityManagementClient. `createPolicy`
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreatePolicyRequest;
import com.amazonaws.services.identitymanagement.model.CreatePolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreatePolicyRequest request = new CreatePolicyRequest()
.withPolicyName(policy_name)
.withPolicyDocument(POLICY_DOCUMENT);
CreatePolicyResult response = iam.createPolicy(request);
```
Les documents de politique IAM sont des chaînes JSON dont la syntaxe est [bien documentée](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html). Voici un exemple qui fournit l'accès permettant d'adresser des demandes particulières à DynamoDB.
```
public static final String POLICY_DOCUMENT =
"{" +
" \"Version\": \"2012-10-17\", " +
" \"Statement\": [" +
" {" +
" \"Effect\": \"Allow\"," +
" \"Action\": \"logs:CreateLogGroup\"," +
" \"Resource\": \"%s\"" +
" }," +
" {" +
" \"Effect\": \"Allow\"," +
" \"Action\": [" +
" \"dynamodb:DeleteItem\"," +
" \"dynamodb:GetItem\"," +
" \"dynamodb:PutItem\"," +
" \"dynamodb:Scan\"," +
" \"dynamodb:UpdateItem\"" +
" ]," +
" \"Resource\": \"RESOURCE_ARN\"" +
" }" +
" ]" +
"}";
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreatePolicy.java) sur GitHub.
## Obtention d'une stratégie
Pour récupérer une politique existante, appelez la `getPolicy` méthode AmazonIdentityManagementClient's, en fournissant l'ARN de la politique dans un [GetPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetPolicyRequest.html)objet.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetPolicyRequest;
import com.amazonaws.services.identitymanagement.model.GetPolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetPolicyRequest request = new GetPolicyRequest()
.withPolicyArn(policy_arn);
GetPolicyResult response = iam.getPolicy(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetPolicy.java) sur GitHub.
## Attachement d'une stratégie de rôle
Vous pouvez joindre une politique à un fichier IAMhttp : //docs.aws.amazon. com/IAM/latest/UserGuide/id\$1roles.html [role] en appelant la `attachRolePolicy` méthode AmazonIdentityManagementClient's, en lui fournissant le nom du rôle et l'ARN de la politique dans un [AttachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/AttachRolePolicyRequest.html).
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.AttachRolePolicyRequest;
import com.amazonaws.services.identitymanagement.model.AttachedPolicy;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
AttachRolePolicyRequest attach_request =
new AttachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(POLICY_ARN);
iam.attachRolePolicy(attach_request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) sur GitHub.
## Affichage d'une liste de stratégies de rôle attachées
Répertoriez les politiques associées à un rôle en appelant la `listAttachedRolePolicies` méthode AmazonIdentityManagementClient's. Il faut un [ListAttachedRolePoliciesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesRequest.html)objet contenant le nom du rôle pour répertorier les politiques.
Appelez `getAttachedPolicies` l'[ListAttachedRolePoliciesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesResult.html)objet renvoyé pour obtenir la liste des politiques jointes. Les résultats peuvent être tronqués. Si la méthode `getIsTruncated` de l'objet `ListAttachedRolePoliciesResult` renvoie `true`, appelez la méthode `setMarker` de l'objet `ListAttachedRolePoliciesRequest` et utilisez-la pour appeler à nouveau `listAttachedRolePolicies` afin d'obtenir le lot suivant de résultats.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest;
import com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesResult;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
ListAttachedRolePoliciesRequest request =
new ListAttachedRolePoliciesRequest()
.withRoleName(role_name);
List matching_policies = new ArrayList<>();
boolean done = false;
while(!done) {
ListAttachedRolePoliciesResult response =
iam.listAttachedRolePolicies(request);
matching_policies.addAll(
response.getAttachedPolicies()
.stream()
.filter(p -> p.getPolicyName().equals(role_name))
.collect(Collectors.toList()));
if(!response.getIsTruncated()) {
done = true;
}
request.setMarker(response.getMarker());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) sur GitHub.
## Détachement d'une stratégie de rôle
Pour détacher une politique d'un rôle, appelez la `detachRolePolicy` méthode AmazonIdentityManagementClient's en lui fournissant le nom du rôle et l'ARN de la politique dans un [DetachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DetachRolePolicyRequest.html).
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DetachRolePolicyRequest;
import com.amazonaws.services.identitymanagement.model.DetachRolePolicyResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DetachRolePolicyRequest request = new DetachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(policy_arn);
DetachRolePolicyResult response = iam.detachRolePolicy(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DetachRolePolicy.java) sur GitHub.
## En savoir plus
+ [Présentation des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) dans le guide de l' IAM utilisateur.
+ [AWS Référence à la politique IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) dans le guide de l' IAM utilisateur.
+ [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)dans la référence de l'API IAM
+ [GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html)dans la référence de l'API IAM
+ [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)dans la référence de l'API IAM
+ [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)dans la référence de l'API IAM
+ [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html)dans la référence de l'API IAM
# Utilisation des certificats de serveur IAM
*Pour activer les connexions HTTPS à votre site Web ou à votre application AWS, vous avez besoin d'un certificat de serveur SSL/TLS.* Vous pouvez utiliser un certificat de serveur fourni par AWS Certificate Manager ou un certificat que vous avez obtenu auprès d'un fournisseur externe.
Nous vous recommandons d'utiliser ACM pour provisionner, gérer et déployer vos certificats de serveur. Avec ACM, vous pouvez demander un certificat, le déployer sur vos AWS ressources et laisser ACM gérer les renouvellements de certificats pour vous. Les certificats fournis par ACM sont gratuits. Pour plus d'informations sur ACM, consultez le guide de l'[utilisateur d'ACM](https://docs.aws.amazon.com/acm/latest/userguide/).
## Obtention d'un certificat de serveur
Vous pouvez récupérer un certificat de serveur en appelant la `getServerCertificate` méthode AmazonIdentityManagementClient's et en [GetServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetServerCertificateRequest.html)lui transmettant le nom du certificat.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.GetServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.GetServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetServerCertificateRequest request = new GetServerCertificateRequest()
.withServerCertificateName(cert_name);
GetServerCertificateResult response = iam.getServerCertificate(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetServerCertificate.java) sur GitHub.
## Liste des certificats de serveur
Pour répertorier les certificats de votre serveur, appelez la `listServerCertificates` méthode AmazonIdentityManagementClient's avec un [ListServerCertificatesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesRequest.html). Elle renvoie un [ListServerCertificatesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesResult.html).
Appelez la `getServerCertificateMetadataList` méthode de `ListServerCertificateResult` l'objet renvoyé pour obtenir une liste d'[ServerCertificateMetadata](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ServerCertificateMetadata.html)objets que vous pouvez utiliser pour obtenir des informations sur chaque certificat.
Les résultats peuvent être tronqués. Si la méthode `getIsTruncated` de l'objet `ListServerCertificateResult` renvoie `true`, appelez la méthode `setMarker` de l'objet `ListServerCertificatesRequest` et utilisez-la pour appeler à nouveau `listServerCertificates` afin d'obtenir le lot suivant de résultats.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.ListServerCertificatesRequest;
import com.amazonaws.services.identitymanagement.model.ListServerCertificatesResult;
import com.amazonaws.services.identitymanagement.model.ServerCertificateMetadata;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
boolean done = false;
ListServerCertificatesRequest request =
new ListServerCertificatesRequest();
while(!done) {
ListServerCertificatesResult response =
iam.listServerCertificates(request);
for(ServerCertificateMetadata metadata :
response.getServerCertificateMetadataList()) {
System.out.printf("Retrieved server certificate %s",
metadata.getServerCertificateName());
}
request.setMarker(response.getMarker());
if(!response.getIsTruncated()) {
done = true;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListServerCertificates.java) sur GitHub.
## Mise à jour d'un certificat de serveur
Vous pouvez mettre à jour le nom ou le chemin d'un certificat de serveur en appelant la `updateServerCertificate` méthode AmazonIdentityManagementClient's. Il faut utiliser un ensemble d'[UpdateServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateServerCertificateRequest.html)objets portant le nom actuel du certificat de serveur et un nouveau nom ou un nouveau chemin.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.UpdateServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.UpdateServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateServerCertificateRequest request =
new UpdateServerCertificateRequest()
.withServerCertificateName(cur_name)
.withNewServerCertificateName(new_name);
UpdateServerCertificateResult response =
iam.updateServerCertificate(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateServerCertificate.java) sur GitHub.
## Suppression d'un certificat de serveur
Pour supprimer un certificat de serveur, appelez la `deleteServerCertificate` méthode AmazonIdentityManagementClient's avec un [DeleteServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteServerCertificateRequest.html)contenant le nom du certificat.
**Importations**
```
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.DeleteServerCertificateRequest;
import com.amazonaws.services.identitymanagement.model.DeleteServerCertificateResult;
```
**Code**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteServerCertificateRequest request =
new DeleteServerCertificateRequest()
.withServerCertificateName(cert_name);
DeleteServerCertificateResult response =
iam.deleteServerCertificate(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteServerCertificate.java) sur GitHub.
## En savoir plus
+ [Utilisation des certificats de serveur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) dans le guide de IAM l'utilisateur
+ [GetServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServerCertificate.html)dans la référence de l'API IAM
+ [ListServerCertificates](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListServerCertificates.html)dans la référence de l'API IAM
+ [UpdateServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateServerCertificate.html)dans la référence de l'API IAM
+ [DeleteServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServerCertificate.html)dans la référence de l'API IAM
+ [Guide de l'utilisateur ACM](https://docs.aws.amazon.com/acm/latest/userguide/)
# Lambda Exemples d'utilisation du AWS SDK pour Java
Cette section fournit des exemples de programmation Lambda utilisant le AWS SDK pour Java.
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Opérations de service](examples-lambda.md)
# Invocation, listage et suppression de fonctions Lambda
Cette section fournit des exemples de programmation avec le client Lambda de service à l'aide du AWS SDK pour Java. Pour savoir comment créer une Lambda fonction, voir [Comment créer des AWS Lambda fonctions](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/lambda-tutorial.html).
**Topics**
+ [Invoquer une fonction](#invoke-function)
+ [Répertorier des fonctions](#list-function)
+ [Supprimer une fonction](#delete-function)
## Invoquer une fonction
Vous pouvez invoquer une Lambda fonction en créant un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)objet et en invoquant sa `invoke` méthode. Créez un [InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)objet pour spécifier des informations supplémentaires telles que le nom de la fonction et la charge utile à transmettre à la Lambda fonction. Les noms des fonctions apparaissent sous la forme *arn:aws:lambda:us-east- 1:555556330391:function* :. HelloFunction Vous pouvez récupérer la valeur en consultant la fonction dans le AWS Management Console.
Pour transmettre des données de charge utile à une fonction, appelez la `withPayload` méthode de l'[InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)objet et spécifiez une chaîne au format JSON, comme indiqué dans l'exemple de code suivant.
**Importations**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.services.lambda.model.ServiceException;
import java.nio.charset.StandardCharsets;
```
**Code**
L'exemple de code suivant montre comment invoquer une Lambda fonction.
```
String functionName = args[0];
InvokeRequest invokeRequest = new InvokeRequest()
.withFunctionName(functionName)
.withPayload("{\n" +
" \"Hello \": \"Paris\",\n" +
" \"countryCode\": \"FR\"\n" +
"}");
InvokeResult invokeResult = null;
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
invokeResult = awsLambda.invoke(invokeRequest);
String ans = new String(invokeResult.getPayload().array(), StandardCharsets.UTF_8);
//write out the return value
System.out.println(ans);
} catch (ServiceException e) {
System.out.println(e);
}
System.out.println(invokeResult.getStatusCode());
```
Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/LambdaInvokeFunction.java).
## Répertorier des fonctions
Créez un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)objet et invoquez sa `listFunctions` méthode. Cette méthode renvoie un [ListFunctionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/ListFunctionsResult.html)objet. Vous pouvez invoquer la `getFunctions` méthode de cet objet pour renvoyer une liste d'[FunctionConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/FunctionConfiguration.html)objets. Parcourez la liste pour récupérer des informations sur les fonctions. Par exemple, l'exemple de code Java ci-dessous illustre comment obtenir le nom de chaque fonction.
**Importations**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.FunctionConfiguration;
import com.amazonaws.services.lambda.model.ListFunctionsResult;
import com.amazonaws.services.lambda.model.ServiceException;
import java.util.Iterator;
import java.util.List;
```
**Code**
L'exemple de code Java suivant montre comment récupérer une liste de noms de Lambda fonctions.
```
ListFunctionsResult functionResult = null;
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
functionResult = awsLambda.listFunctions();
List list = functionResult.getFunctions();
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
FunctionConfiguration config = (FunctionConfiguration)iter.next();
System.out.println("The function name is "+config.getFunctionName());
}
} catch (ServiceException e) {
System.out.println(e);
}
```
Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/ListFunctions.java).
## Supprimer une fonction
Créez un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)objet et invoquez sa `deleteFunction` méthode. Créez un [DeleteFunctionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/DeleteFunctionRequest.html)objet et transmettez-le à la `deleteFunction` méthode. Cet objet contient des informations telles que le nom de la fonction à supprimer. Les noms des fonctions apparaissent sous la forme *arn:aws:lambda:us-east- 1:555556330391:function* :. HelloFunction Vous pouvez récupérer la valeur en consultant la fonction dans le AWS Management Console.
**Importations**
```
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.ServiceException;
import com.amazonaws.services.lambda.model.DeleteFunctionRequest;
```
**Code**
Le code Java suivant montre comment supprimer une Lambda fonction.
```
String functionName = args[0];
try {
AWSLambda awsLambda = AWSLambdaClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(Regions.US_WEST_2).build();
DeleteFunctionRequest delFunc = new DeleteFunctionRequest();
delFunc.withFunctionName(functionName);
//Delete the function
awsLambda.deleteFunction(delFunc);
System.out.println("The function is deleted");
} catch (ServiceException e) {
System.out.println(e);
}
```
Consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/DeleteFunction.java).
# Amazon Pinpoint Exemples utilisant le AWS SDK pour Java
Cette section fournit des exemples de programmation d'[Amazon Pinpoint](https://aws.amazon.com/pinpoint/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Création et suppression d'applications dans Amazon Pinpoint](examples-pinpoint-create-app.md)
+ [Création de points de terminaison dans Amazon Pinpoint](examples-pinpoint-create-endpoint.md)
+ [Création de segments dans Amazon Pinpoint](examples-pinpoint-create-segment.md)
+ [Création de campagnes dans Amazon Pinpoint](examples-pinpoint-create-campaign.md)
+ [Mise à jour des chaînes dans Amazon Pinpoint](examples-pinpoint-update-channel.md)
# Création et suppression d'applications dans Amazon Pinpoint
Une application est un Amazon Pinpoint projet dans lequel vous définissez l'audience d'une application distincte, et vous interagissez avec cette audience avec des messages personnalisés. Les exemples de cette page montrent comment créer une application ou comment supprimer une application existante.
## Création d'une application
Créez une nouvelle application en Amazon Pinpoint fournissant un nom d'application à l'[CreateAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateAppRequest.html)objet, puis en transmettant cet objet à la `createApp` méthode AmazonPinpointClient's.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateAppRequest;
import com.amazonaws.services.pinpoint.model.CreateAppResult;
import com.amazonaws.services.pinpoint.model.CreateApplicationRequest;
```
**Code**
```
CreateApplicationRequest appRequest = new CreateApplicationRequest()
.withName(appName);
CreateAppRequest request = new CreateAppRequest();
request.withCreateApplicationRequest(appRequest);
CreateAppResult result = pinpoint.createApp(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) sur GitHub.
## Suppression d'une application
Pour supprimer une application, appelez AmazonPinpointClient la `deleteApp` demande avec un [DeleteAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/DeleteAppRequest.html)objet défini avec le nom de l'application à supprimer.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
```
**Code**
```
DeleteAppRequest deleteRequest = new DeleteAppRequest()
.withApplicationId(appID);
pinpoint.deleteApp(deleteRequest);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/DeleteApp.java) sur GitHub.
## En savoir plus
+ [Apps](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apps.html) dans la référence des Amazon Pinpoint API
+ [Application](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-app.html) dans la référence de Amazon Pinpoint l'API
# Création de points de terminaison dans Amazon Pinpoint
Un point de terminaison identifie de façon unique l'appareil d'un utilisateur auquel vous pouvez envoyer des notifications push avec Amazon Pinpoint. Si votre application est activée avec Amazon Pinpoint support, elle enregistre automatiquement un point de terminaison Amazon Pinpoint lorsqu'un nouvel utilisateur ouvre votre application. L'exemple suivant montre comment ajouter un nouveau point de terminaison par programmation.
## Création d'un point de terminaison
Créez un nouveau point de terminaison en Amazon Pinpoint fournissant les données du point de terminaison dans un [EndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/EndpointRequest.html)objet.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.UpdateEndpointRequest;
import com.amazonaws.services.pinpoint.model.UpdateEndpointResult;
import com.amazonaws.services.pinpoint.model.EndpointDemographic;
import com.amazonaws.services.pinpoint.model.EndpointLocation;
import com.amazonaws.services.pinpoint.model.EndpointRequest;
import com.amazonaws.services.pinpoint.model.EndpointResponse;
import com.amazonaws.services.pinpoint.model.EndpointUser;
import com.amazonaws.services.pinpoint.model.GetEndpointRequest;
import com.amazonaws.services.pinpoint.model.GetEndpointResult;
```
**Code**
```
HashMap> customAttributes = new HashMap<>();
List favoriteTeams = new ArrayList<>();
favoriteTeams.add("Lakers");
favoriteTeams.add("Warriors");
customAttributes.put("team", favoriteTeams);
EndpointDemographic demographic = new EndpointDemographic()
.withAppVersion("1.0")
.withMake("apple")
.withModel("iPhone")
.withModelVersion("7")
.withPlatform("ios")
.withPlatformVersion("10.1.1")
.withTimezone("America/Los_Angeles");
EndpointLocation location = new EndpointLocation()
.withCity("Los Angeles")
.withCountry("US")
.withLatitude(34.0)
.withLongitude(-118.2)
.withPostalCode("90068")
.withRegion("CA");
Map metrics = new HashMap<>();
metrics.put("health", 100.00);
metrics.put("luck", 75.00);
EndpointUser user = new EndpointUser()
.withUserId(UUID.randomUUID().toString());
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'"); // Quoted "Z" to indicate UTC, no timezone offset
String nowAsISO = df.format(new Date());
EndpointRequest endpointRequest = new EndpointRequest()
.withAddress(UUID.randomUUID().toString())
.withAttributes(customAttributes)
.withChannelType("APNS")
.withDemographic(demographic)
.withEffectiveDate(nowAsISO)
.withLocation(location)
.withMetrics(metrics)
.withOptOut("NONE")
.withRequestId(UUID.randomUUID().toString())
.withUser(user);
```
Créez ensuite un [UpdateEndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateEndpointRequest.html)objet avec cet EndpointRequest objet. Enfin, transmettez l' UpdateEndpointRequest objet à la `updateEndpoint` méthode AmazonPinpointClient's.
**Code**
```
UpdateEndpointRequest updateEndpointRequest = new UpdateEndpointRequest()
.withApplicationId(appId)
.withEndpointId(endpointId)
.withEndpointRequest(endpointRequest);
UpdateEndpointResult updateEndpointResponse = client.updateEndpoint(updateEndpointRequest);
System.out.println("Update Endpoint Response: " + updateEndpointResponse.getMessageBody());
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateEndpoint.java) sur GitHub.
## En savoir plus
+ [Ajouter un point de terminaison](https://docs.aws.amazon.com/pinpoint/latest/developerguide/endpoints.html) dans le guide du Amazon Pinpoint développeur
+ Point de [terminaison](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-endpoint.html) dans la référence Amazon Pinpoint d'API
# Création de segments dans Amazon Pinpoint
Un segment d'utilisateurs est un sous-ensemble d'utilisateurs qui présentent des caractéristiques communes. Il peut s'agir de la date à laquelle les utilisateurs ont ouvert votre application pour la dernière fois ou du type d'appareil qu'ils utilisent. L'exemple suivant montre comment définir un segment d'utilisateurs.
## Créer un segment
Créez un nouveau segment en Amazon Pinpoint définissant les dimensions du segment dans un [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)objet.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateSegmentRequest;
import com.amazonaws.services.pinpoint.model.CreateSegmentResult;
import com.amazonaws.services.pinpoint.model.AttributeDimension;
import com.amazonaws.services.pinpoint.model.AttributeType;
import com.amazonaws.services.pinpoint.model.RecencyDimension;
import com.amazonaws.services.pinpoint.model.SegmentBehaviors;
import com.amazonaws.services.pinpoint.model.SegmentDemographics;
import com.amazonaws.services.pinpoint.model.SegmentDimensions;
import com.amazonaws.services.pinpoint.model.SegmentLocation;
import com.amazonaws.services.pinpoint.model.SegmentResponse;
import com.amazonaws.services.pinpoint.model.WriteSegmentRequest;
```
**Code**
```
Pinpoint pinpoint = AmazonPinpointClientBuilder.standard().withRegion(Regions.US_EAST_1).build();
Map segmentAttributes = new HashMap<>();
segmentAttributes.put("Team", new AttributeDimension().withAttributeType(AttributeType.INCLUSIVE).withValues("Lakers"));
SegmentBehaviors segmentBehaviors = new SegmentBehaviors();
SegmentDemographics segmentDemographics = new SegmentDemographics();
SegmentLocation segmentLocation = new SegmentLocation();
RecencyDimension recencyDimension = new RecencyDimension();
recencyDimension.withDuration("DAY_30").withRecencyType("ACTIVE");
segmentBehaviors.setRecency(recencyDimension);
SegmentDimensions dimensions = new SegmentDimensions()
.withAttributes(segmentAttributes)
.withBehavior(segmentBehaviors)
.withDemographic(segmentDemographics)
.withLocation(segmentLocation);
```
Définissez ensuite l'[SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)objet dans un [WriteSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteSegmentRequest.html), qui est à son tour utilisé pour créer un [CreateSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateSegmentRequest.html)objet. Passez ensuite l' CreateSegmentRequest objet à la `createSegment` méthode AmazonPinpointClient's.
**Code**
```
WriteSegmentRequest writeSegmentRequest = new WriteSegmentRequest()
.withName("MySegment").withDimensions(dimensions);
CreateSegmentRequest createSegmentRequest = new CreateSegmentRequest()
.withApplicationId(appId).withWriteSegmentRequest(writeSegmentRequest);
CreateSegmentResult createSegmentResult = client.createSegment(createSegmentRequest);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) sur GitHub.
## En savoir plus
+ [Amazon Pinpoint Segments](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments.html) du guide de Amazon Pinpoint l'utilisateur
+ [Création de segments](https://docs.aws.amazon.com/pinpoint/latest/developerguide/segments.html) dans le guide du Amazon Pinpoint développeur
+ [Segments](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segments.html) de la référence Amazon Pinpoint d'API
+ [Segment](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segment.html) dans la référence de Amazon Pinpoint l'API
# Création de campagnes dans Amazon Pinpoint
Les campagnes vous permettent de renforcer l'implication des utilisateurs vis-à-vis de votre application. Vous pouvez créer une campagne pour toucher un segment particulier d'utilisateurs à l'aide de messages sur mesure ou de promotions spéciales. Cet exemple montre comment créer une campagne standard qui envoie une notification push personnalisée à un segment déterminé.
## Création d'une campagne
Avant de créer une nouvelle campagne, vous devez définir un [calendrier](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Schedule.html) et un [message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Message.html) et définir ces valeurs dans un [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)objet.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateCampaignRequest;
import com.amazonaws.services.pinpoint.model.CreateCampaignResult;
import com.amazonaws.services.pinpoint.model.Action;
import com.amazonaws.services.pinpoint.model.CampaignResponse;
import com.amazonaws.services.pinpoint.model.Message;
import com.amazonaws.services.pinpoint.model.MessageConfiguration;
import com.amazonaws.services.pinpoint.model.Schedule;
import com.amazonaws.services.pinpoint.model.WriteCampaignRequest;
```
**Code**
```
Schedule schedule = new Schedule()
.withStartTime("IMMEDIATE");
Message defaultMessage = new Message()
.withAction(Action.OPEN_APP)
.withBody("My message body.")
.withTitle("My message title.");
MessageConfiguration messageConfiguration = new MessageConfiguration()
.withDefaultMessage(defaultMessage);
WriteCampaignRequest request = new WriteCampaignRequest()
.withDescription("My description.")
.withSchedule(schedule)
.withSegmentId(segmentId)
.withName("MyCampaign")
.withMessageConfiguration(messageConfiguration);
```
Créez ensuite une nouvelle campagne en Amazon Pinpoint [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)fournissant la configuration de campagne à un [CreateCampaignRequest](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/pinpoint/model/CreateCampaignRequest.html)objet. Enfin, transmettez l' CreateCampaignRequest objet à la `createCampaign` méthode AmazonPinpointClient's.
**Code**
```
CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest()
.withApplicationId(appId).withWriteCampaignRequest(request);
CreateCampaignResult result = client.createCampaign(createCampaignRequest);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) sur GitHub.
## En savoir plus
+ [Amazon Pinpoint Campagnes](https://docs.aws.amazon.com/pinpoint/latest/userguide/campaigns.html) dans le guide de Amazon Pinpoint l'utilisateur
+ [Création de campagnes](https://docs.aws.amazon.com/pinpoint/latest/developerguide/campaigns.html) dans le guide du Amazon Pinpoint développeur
+ [Campagnes](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaigns.html) dans l' Amazon Pinpoint API Reference
+ [Campagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign.html) dans la référence de Amazon Pinpoint l'API
+ [Activités de campagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-activities.html) dans la référence de Amazon Pinpoint l'API
+ [Versions de campagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-versions.html) dans la référence de Amazon Pinpoint l'API
+ [Version de la campagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-version.html) dans la référence de Amazon Pinpoint l'API
# Mise à jour des chaînes dans Amazon Pinpoint
Un canal définit les types de plateformes auxquelles vous pouvez envoyer des messages. Cet exemple montre comment utiliser le APNs canal pour envoyer un message.
## Mise à jour d'un canal
Activez une chaîne en Amazon Pinpoint fournissant un identifiant d'application et un objet de demande correspondant au type de chaîne que vous souhaitez mettre à jour. Cet exemple met à jour le APNs canal, qui nécessite l'objet [APNSChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/APNSChannelRequest.html). Définissez-les dans le [UpdateApnsChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateApnsChannelRequest.html)et transmettez cet objet à AmazonPinpointClient la `updateApnsChannel` méthode.
**Importations**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.APNSChannelRequest;
import com.amazonaws.services.pinpoint.model.APNSChannelResponse;
import com.amazonaws.services.pinpoint.model.GetApnsChannelRequest;
import com.amazonaws.services.pinpoint.model.GetApnsChannelResult;
import com.amazonaws.services.pinpoint.model.UpdateApnsChannelRequest;
import com.amazonaws.services.pinpoint.model.UpdateApnsChannelResult;
```
**Code**
```
APNSChannelRequest request = new APNSChannelRequest()
.withEnabled(enabled);
UpdateApnsChannelRequest updateRequest = new UpdateApnsChannelRequest()
.withAPNSChannelRequest(request)
.withApplicationId(appId);
UpdateApnsChannelResult result = client.updateApnsChannel(updateRequest);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/UpdateChannel.java) sur GitHub.
## En savoir plus
+ [Amazon Pinpoint Chaînes figurant](https://docs.aws.amazon.com/pinpoint/latest/userguide/channels.html) dans le guide de Amazon Pinpoint l'utilisateur
+ [Canal ADM](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-adm-channel.html) dans la référence de l' Amazon Pinpoint API
+ [APNs Canal](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-channel.html) dans la référence de Amazon Pinpoint l'API
+ [APNs Sandbox Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-sandbox-channel.html) dans la référence de l' Amazon Pinpoint API
+ [APNs Canal VoIP dans la référence](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-channel.html) de l'API Amazon Pinpoint
+ [APNs Canal VoIP Sandbox](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-sandbox-channel.html) dans la référence de l'API Amazon Pinpoint
+ Le [canal Baidu](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-baidu-channel.html) dans le guide de référence de l' Amazon Pinpoint API
+ [Canal de courrier électronique](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-email-channel.html) dans la référence de Amazon Pinpoint l'API
+ [Canal GCM](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-gcm-channel.html) dans la référence de l' Amazon Pinpoint API
+ [Canal SMS](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-sms-channel.html) dans la référence de Amazon Pinpoint l'API
# Amazon S3 Exemples utilisant le AWS SDK pour Java
Cette section fournit des exemples de programmation d'[Amazon S3](https://aws.amazon.com/s3/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Création, listage et suppression de Amazon S3 buckets](examples-s3-buckets.md)
+ [Exécution d'opérations sur Amazon S3 des objets](examples-s3-objects.md)
+ [Gestion des autorisations Amazon S3 d'accès pour les compartiments et les objets](examples-s3-access-permissions.md)
+ [Gestion de l'accès aux Amazon S3 compartiments à l'aide de politiques relatives aux compartiments](examples-s3-bucket-policies.md)
+ [Utilisation TransferManager pour les Amazon S3 opérations](examples-s3-transfermanager.md)
+ [Configuration d'un Amazon S3 bucket en tant que site Web](examples-s3-website-configuration.md)
+ [Utiliser le Amazon S3 chiffrement côté client](examples-crypto.md)
# Création, listage et suppression de Amazon S3 buckets
Chaque objet (fichier) Amazon S3 doit résider dans un *compartiment*, qui représente une collection (conteneur) d'objets. Chaque compartiment est identifié par une *clé* (nom) qui doit être unique. Pour obtenir des informations détaillées sur les buckets et leur configuration, consultez la section [Utilisation des Amazon S3 buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) dans le Guide de l' Amazon Simple Storage Service utilisateur.
**Note**
Bonne pratique
Nous vous recommandons d'activer la règle du [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)cycle de vie sur vos Amazon S3 buckets.
Cette règle indique Amazon S3 d'abandonner les téléchargements partitionnés qui ne sont pas terminés dans un certain nombre de jours après leur lancement. Lorsque le délai défini est dépassé, le téléchargement est Amazon S3 interrompu, puis les données de téléchargement incomplètes sont supprimées.
Pour plus d'informations, consultez la section [Configuration du cycle de vie d'un bucket avec gestion des versions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) dans le guide de l' Amazon S3 utilisateur.
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
## Création d'un compartiment
Utilisez la méthode du client AmazonS3. `createBucket` Le nouveau [compartiment](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html) est renvoyé. La méthode `createBucket` déclenche une exception si le compartiment existe déjà.
**Note**
Pour vérifier si un compartiment existe déjà avant de tenter d'en créer un avec le même nom, appelez la méthode `doesBucketExist`. Cette méthode renvoie `true` si le compartiment existe et `false` sinon.
**Importations**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import java.util.List;
```
**Code**
```
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("Bucket %s already exists.\n", bucket_name);
b = getBucket(bucket_name);
} else {
try {
b = s3.createBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
return b;
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CreateBucket.java) sur GitHub.
## Etablir une liste des compartiments
Utilisez la méthode du client AmazonS3. `listBucket` En cas de réussite, une liste de [compartiments](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html) est renvoyée.
**Importations**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.Bucket;
import java.util.List;
```
**Code**
```
List buckets = s3.listBuckets();
System.out.println("Your {S3} buckets are:");
for (Bucket b : buckets) {
System.out.println("* " + b.getName());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListBuckets.java) sur GitHub.
## Supprimer un compartiment
Avant de pouvoir supprimer un Amazon S3 compartiment, vous devez vous assurer qu'il est vide, faute de quoi une erreur pourrait se produire. S'il s'agit d'un [compartiment avec gestion des versions](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), vous devez également supprimer tous les objets versionnés associés à celui-ci.
**Note**
L'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) inclut chacune de ces étapes dans l'ordre, fournissant une solution complète pour supprimer un Amazon S3 bucket et son contenu.
**Topics**
+ [Suppression des objets d'un compartiment sans gestion des versions avant sa suppression](#remove-objects-from-an-unversioned-bucket-before-deleting-it)
+ [Suppression des objets d'un compartiment avec gestion des versions avant sa suppression](#remove-objects-from-a-versioned-bucket-before-deleting-it)
+ [Suppression d'un compartiment vide](#delete-an-empty-bucket)
### Suppression des objets d'un compartiment sans gestion des versions avant sa suppression
Utilisez la `listObjects` méthode du client AmazonS3 pour récupérer la liste des objets et `deleteObject` pour supprimer chacun d'entre eux.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" - removing objects from bucket");
ObjectListing object_listing = s3.listObjects(bucket_name);
while (true) {
for (Iterator iterator =
object_listing.getObjectSummaries().iterator();
iterator.hasNext(); ) {
S3ObjectSummary summary = (S3ObjectSummary) iterator.next();
s3.deleteObject(bucket_name, summary.getKey());
}
// more object_listing to retrieve?
if (object_listing.isTruncated()) {
object_listing = s3.listNextBatchOfObjects(object_listing);
} else {
break;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) sur GitHub.
### Suppression des objets d'un compartiment avec gestion des versions avant sa suppression
Si vous utilisez un [compartiment avec gestion des versions](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), vous devez également supprimer toutes les versions stockées des objets du compartiment pour que le compartiment puisse être supprimé.
En utilisant un modèle similaire à celui utilisé lors de la suppression d'objets dans un compartiment, supprimez les objets versionnés en utilisant la `listVersions` méthode du client AmazonS3 pour répertorier tous les objets versionnés, puis `deleteVersion` pour supprimer chacun d'entre eux.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" - removing versions from bucket");
VersionListing version_listing = s3.listVersions(
new ListVersionsRequest().withBucketName(bucket_name));
while (true) {
for (Iterator iterator =
version_listing.getVersionSummaries().iterator();
iterator.hasNext(); ) {
S3VersionSummary vs = (S3VersionSummary) iterator.next();
s3.deleteVersion(
bucket_name, vs.getKey(), vs.getVersionId());
}
if (version_listing.isTruncated()) {
version_listing = s3.listNextBatchOfVersions(
version_listing);
} else {
break;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) sur GitHub.
### Suppression d'un compartiment vide
Une fois que vous avez supprimé les objets d'un compartiment (y compris les objets versionnés), vous pouvez supprimer le compartiment lui-même en utilisant la méthode du client AmazonS3. `deleteBucket`
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.util.Iterator;
```
**Code**
```
System.out.println(" OK, bucket ready to delete!");
s3.deleteBucket(bucket_name);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) sur GitHub.
# Exécution d'opérations sur Amazon S3 des objets
Un Amazon S3 objet représente un *fichier* ou un ensemble de données. Chaque objet doit résider dans un [compartiment](examples-s3-buckets.md).
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
**Topics**
+ [Chargement d'un objet](#upload-object)
+ [Affichage de la liste des objets](#list-objects)
+ [Téléchargement d'un objet](#download-object)
+ [Copie et déplacement d'objets, ou attribution d'un nouveau nom aux objets](#copy-object)
+ [Supprimer un objet](#delete-object)
+ [Suppression simultanée de plusieurs objets](#delete-objects)
## Chargement d'un objet
Utilisez la `putObject` méthode du client AmazonS3, en fournissant le nom du bucket, le nom de la clé et le fichier à télécharger. *Le compartiment doit exister, sans quoi une erreur est générée*.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
System.out.format("Uploading %s to S3 bucket %s...\n", file_path, bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.putObject(bucket_name, key_name, new File(file_path));
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/PutObject.java) sur GitHub.
## Affichage de la liste des objets
Pour obtenir la liste des objets d'un compartiment, utilisez la `listObjects` méthode du client AmazonS3, en fournissant le nom d'un compartiment.
La `listObjects` méthode renvoie un [ObjectListing](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/ObjectListing.html)objet qui fournit des informations sur les objets du compartiment. Pour répertorier les noms d'objets (clés), utilisez la `getObjectSummaries` méthode pour obtenir une liste d'ObjectSummaryobjets [S3](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectSummary.html), chacun représentant un seul objet dans le compartiment. Ensuite, appelez sa méthode `getKey` pour récupérer le nom de l'objet.
**Importations**
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ListObjectsV2Result;
import com.amazonaws.services.s3.model.S3ObjectSummary;
```
**Code**
```
System.out.format("Objects in S3 bucket %s:\n", bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
ListObjectsV2Result result = s3.listObjectsV2(bucket_name);
List objects = result.getObjectSummaries();
for (S3ObjectSummary os : objects) {
System.out.println("* " + os.getKey());
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListObjects.java) sur GitHub.
## Téléchargement d'un objet
Utilisez la `getObject` méthode du client AmazonS3, en lui transmettant le nom du bucket et de l'objet à télécharger. En cas de réussite, la méthode renvoie un objet [S3Object](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3Object.html). *Le compartiment et la clé d'objet spécifiés doivent exister, sans quoi une erreur est générée*.
Vous pouvez obtenir le contenu de l'objet en appelant `getObjectContent` sur l'objet `S3Object`. Cela renvoie un [S3 ObjectInputStream](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectInputStream.html) qui se comporte comme un `InputStream` objet Java standard.
L'exemple suivant télécharge un objet à partir de S3 et enregistre son contenu dans un fichier (en utilisant le même nom que la clé de l'objet).
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.S3Object;
import com.amazonaws.services.s3.model.S3ObjectInputStream;
import java.io.File;
```
**Code**
```
System.out.format("Downloading %s from S3 bucket %s...\n", key_name, bucket_name);
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
S3Object o = s3.getObject(bucket_name, key_name);
S3ObjectInputStream s3is = o.getObjectContent();
FileOutputStream fos = new FileOutputStream(new File(key_name));
byte[] read_buf = new byte[1024];
int read_len = 0;
while ((read_len = s3is.read(read_buf)) > 0) {
fos.write(read_buf, 0, read_len);
}
s3is.close();
fos.close();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
} catch (FileNotFoundException e) {
System.err.println(e.getMessage());
System.exit(1);
} catch (IOException e) {
System.err.println(e.getMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetObject.java) sur GitHub.
## Copie et déplacement d'objets, ou attribution d'un nouveau nom aux objets
Vous pouvez copier un objet d'un compartiment vers un autre en utilisant la méthode du `copyObject` client AmazonS3. Elle récupère le nom du compartiment d'où l'objet est copié, l'objet à copier et le nom du compartiment de destination.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Code**
```
try {
s3.copyObject(from_bucket, object_key, to_bucket, object_key);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
System.out.println("Done!");
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CopyObject.java) sur GitHub.
**Note**
Vous pouvez utiliser `copyObject` avec [deleteObject](#delete-object) pour **déplacer** ou **renommer** un objet, en copiant d'abord l'objet avec un nouveau nom (vous pouvez utiliser le même compartiment comme source et comme destination), puis en supprimant l'objet de son ancien emplacement.
## Supprimer un objet
Utilisez la `deleteObject` méthode du client AmazonS3, en lui transmettant le nom du bucket et de l'objet à supprimer. *Le compartiment et la clé d'objet spécifiés doivent exister, sans quoi une erreur est générée*.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.deleteObject(bucket_name, object_key);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObject.java) sur GitHub.
## Suppression simultanée de plusieurs objets
À l'aide de la `deleteObjects` méthode du client AmazonS3, vous pouvez supprimer plusieurs objets du même compartiment en transmettant leurs noms à la méthode link :sdk-for-java/v1/reference/com/amazonaws/services/s3/model/DeleteObjectsRequest.html. ``
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
DeleteObjectsRequest dor = new DeleteObjectsRequest(bucket_name)
.withKeys(object_keys);
s3.deleteObjects(dor);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObjects.java) sur GitHub.
# Gestion des autorisations Amazon S3 d'accès pour les compartiments et les objets
Vous pouvez utiliser des listes de contrôle d'accès (ACLs) pour les Amazon S3 compartiments et les objets afin de contrôler avec précision vos ressources. Amazon S3
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
## Obtention de la liste de contrôle d'accès pour un compartiment
Pour obtenir l'ACL actuelle d'un bucket, appelez la `getBucketAcl` méthode AmazonS3 en lui transmettant le *nom du bucket à interroger*. Cette méthode renvoie un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)objet. Pour obtenir chaque autorisation d'accès de la liste, appelez sa méthode `getGrantsAsList`, qui renvoie une liste Java standard d'objets [Grant](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html).
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.Grant;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
AccessControlList acl = s3.getBucketAcl(bucket_name);
List grants = acl.getGrantsAsList();
for (Grant grant : grants) {
System.out.format(" %s: %s\n", grant.getGrantee().getIdentifier(),
grant.getPermission().toString());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) sur GitHub.
## Définition de la liste de contrôle d'accès pour un compartiment
Pour ajouter ou modifier des autorisations à une ACL pour un bucket, appelez la méthode d'AmazonS3. `setBucketAcl` Il faut un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)objet contenant une liste de bénéficiaires et de niveaux d'accès pour le définir.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.EmailAddressGrantee;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
// get the current ACL
AccessControlList acl = s3.getBucketAcl(bucket_name);
// set access for the grantee
EmailAddressGrantee grantee = new EmailAddressGrantee(email);
Permission permission = Permission.valueOf(access);
acl.grantPermission(grantee, permission);
s3.setBucketAcl(bucket_name, acl);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
**Note**
Vous pouvez fournir l'identifiant unique du bénéficiaire directement à l'aide de la classe [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html), ou utiliser la [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)classe pour définir le bénéficiaire par e-mail, comme nous l'avons fait ici.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) sur GitHub.
## Obtention de la liste de contrôle d'accès pour un objet
Pour obtenir l'ACL actuelle d'un objet, appelez la `getObjectAcl` méthode d'AmazonS3 en lui transmettant le nom du *bucket et le nom* de *l'objet à interroger*. Par exemple`getBucketAcl`, cette méthode renvoie un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)objet que vous pouvez utiliser pour examiner chaque [subvention](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html).
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.Grant;
```
**Code**
```
try {
AccessControlList acl = s3.getObjectAcl(bucket_name, object_key);
List grants = acl.getGrantsAsList();
for (Grant grant : grants) {
System.out.format(" %s: %s\n", grant.getGrantee().getIdentifier(),
grant.getPermission().toString());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) sur GitHub.
## Définition de la liste de contrôle d'accès pour un objet
Pour ajouter ou modifier des autorisations à une ACL pour un objet, appelez la méthode d'AmazonS3. `setObjectAcl` Il faut un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)objet contenant une liste de bénéficiaires et de niveaux d'accès pour le définir.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AccessControlList;
import com.amazonaws.services.s3.model.EmailAddressGrantee;
```
**Code**
```
try {
// get the current ACL
AccessControlList acl = s3.getObjectAcl(bucket_name, object_key);
// set access for the grantee
EmailAddressGrantee grantee = new EmailAddressGrantee(email);
Permission permission = Permission.valueOf(access);
acl.grantPermission(grantee, permission);
s3.setObjectAcl(bucket_name, object_key, acl);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
}
```
**Note**
Vous pouvez fournir l'identifiant unique du bénéficiaire directement à l'aide de la classe [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html), ou utiliser la [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)classe pour définir le bénéficiaire par e-mail, comme nous l'avons fait ici.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) sur GitHub.
## En savoir plus
+ [GET Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html) dans la référence de Amazon S3 l'API
+ [PUT Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) dans la référence de Amazon S3 l'API
+ [GET Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html) dans la référence de Amazon S3 l'API
+ [PUT Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html) dans la référence de Amazon S3 l'API
# Gestion de l'accès aux Amazon S3 compartiments à l'aide de politiques relatives aux compartiments
Vous pouvez définir, obtenir ou supprimer une *politique de compartiment* pour gérer l'accès à vos Amazon S3 compartiments.
## Définition d'une stratégie de compartiment
Vous pouvez définir la stratégie de compartiment pour un compartiment S3 :
+ Appeler le client AmazonS3 `setBucketPolicy` et lui fournir un [SetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/SetBucketPolicyRequest.html)
+ En définissant la stratégie directement à l'aide de la surcharge `setBucketPolicy` qui prend un nom de compartiment et un texte de stratégie (au format JSON)
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
```
**Code**
```
s3.setBucketPolicy(bucket_name, policy_text);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
### Utilisation de la classe Policy pour générer ou valider une stratégie
Lorsque vous fournissez une stratégie de compartiment à `setBucketPolicy`, vous pouvez effectuer les actions suivantes :
+ Spécifier la stratégie directement sous la forme d'une chaîne de texte au format JSON
+ Créer la stratégie à l'aide de la classe [Policy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/policy/Policy.html)
En utilisant la classe `Policy`, vous n'avez pas à vous soucier de formater correctement votre chaîne de texte. Pour obtenir le texte de stratégie JSON à partir de la classe `Policy`, utilisez sa méthode `toJson`.
**Importations**
```
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.actions.S3Actions;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
new Statement(Statement.Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new Resource(
"{region-arn}s3:::" + bucket_name + "/*")));
return bucket_policy.toJson();
```
La classe `Policy` fournit également une méthode `fromJson` qui peut tenter de créer une stratégie à l'aide d'une chaîne JSON transmise. La méthode valide cette dernière pour s'assurer que le texte peut être transformé en une structure de stratégie valide et échoue avec une exception `IllegalArgumentException` si le texte de la stratégie n'est pas valide.
```
Policy bucket_policy = null;
try {
bucket_policy = Policy.fromJson(file_text.toString());
} catch (IllegalArgumentException e) {
System.out.format("Invalid policy text in file: \"%s\"",
policy_file);
System.out.println(e.getMessage());
}
```
Vous pouvez utiliser cette technique pour prévalider une stratégie que vous lisez à partir d'un fichier ou avec tout autre moyen.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetBucketPolicy.java) sur GitHub.
## Obtention d'une stratégie de compartiment
Pour récupérer la politique d'un Amazon S3 compartiment, appelez la `getBucketPolicy` méthode du client AmazonS3 en lui transmettant le nom du compartiment dont vous souhaitez obtenir la politique.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
try {
BucketPolicy bucket_policy = s3.getBucketPolicy(bucket_name);
policy_text = bucket_policy.getPolicyText();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Si le compartiment nommé n'existe pas, si vous n'y avez pas accès ou s'il n'a pas de stratégie de compartiment, une exception `AmazonServiceException` est levée.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetBucketPolicy.java) sur GitHub.
## Suppression d'une stratégie de compartiment
Pour supprimer une politique de compartiment, appelez le client AmazonS3 en lui fournissant le nom du compartiment. `deleteBucketPolicy`
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Code**
```
try {
s3.deleteBucketPolicy(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Cette méthode aboutit même si le compartiment ne comporte pas encore de stratégie. Si vous spécifiez un nom de compartiment qui n'existe pas ou si vous n'avez pas accès au compartiment, une exception `AmazonServiceException` est levée.
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucketPolicy.java) sur GitHub.
## Plus d'informations
+ [Présentation du langage de la politique d'accès](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) dans le guide de Amazon Simple Storage Service l'utilisateur
+ [Exemples de politiques relatives](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) aux compartiments dans le guide de Amazon Simple Storage Service l'utilisateur
# Utilisation TransferManager pour les Amazon S3 opérations
Vous pouvez utiliser cette AWS SDK pour Java TransferManager classe pour transférer de manière fiable des fichiers de l'environnement local vers Amazon S3 et pour copier des objets d'un emplacement S3 à un autre. `TransferManager`peut suivre la progression d'un transfert et suspendre ou reprendre les chargements et les téléchargements.
**Note**
Bonne pratique
Nous vous recommandons d'activer la règle du [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)cycle de vie sur vos Amazon S3 buckets.
Cette règle indique Amazon S3 d'abandonner les téléchargements partitionnés qui ne sont pas terminés dans un certain nombre de jours après leur lancement. Lorsque le délai défini est dépassé, le téléchargement est Amazon S3 interrompu, puis les données de téléchargement incomplètes sont supprimées.
Pour plus d'informations, consultez la section [Configuration du cycle de vie d'un bucket avec gestion des versions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) dans le guide de l' Amazon S3 utilisateur.
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
## Chargement des fichiers et des répertoires
TransferManager peut télécharger des fichiers, des listes de fichiers et des répertoires dans tous les Amazon S3 compartiments que vous avez [créés précédemment](examples-s3-buckets.md#create-bucket).
**Topics**
+ [Chargement d'un seul fichier](#transfermanager-upload-file)
+ [Chargement d'une liste de fichiers](#transfermanager-upload-file-list)
+ [Charger un répertoire](#transfermanager-upload-directory)
### Chargement d'un seul fichier
`upload`Méthode TransferManager de l'appel, fournissant un nom de Amazon S3 compartiment, un nom de clé (objet) et un objet Java [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) standard qui représente le fichier à télécharger.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Upload xfer = xfer_mgr.upload(bucket_name, key_name, f);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
La méthode `upload` renvoie *immédiatement* un résultat, en fournissant un objet `Upload` à utiliser pour vérifier l'état du transfert ou attendre qu'il se termine.
Voir [Attendre la fin d'un transfert pour](#transfermanager-wait-for-completion) plus d'informations sur l'utilisation `waitForCompletion` de la `shutdownNow` méthode permettant de terminer un transfert avec succès avant TransferManager d'appeler. En attendant que le transfert se termine, vous pouvez interroger ou écouter les mises à jour relatives à son état et à sa progression. Pour plus d'informations, consultez [Obtention de l'état et de la progression du transfert](#transfermanager-get-status-and-progress).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) sur GitHub.
### Chargement d'une liste de fichiers
Pour charger plusieurs fichiers en une seule opération, appelez la méthode `uploadFileList` de TransferManager, en fournissant les éléments suivants :
+ Un nom de Amazon S3 compartiment
+ Un *préfixe de clé* à ajouter devant les noms des objets créés (le chemin au sein du compartiment dans lequel placer les objets)
+ Un objet [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) qui représente le répertoire relatif à partir duquel créer les chemins de fichier
+ Un objet [List](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/List.html) contenant un ensemble d'objets [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) à charger
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
ArrayList files = new ArrayList();
for (String path : file_paths) {
files.add(new File(path));
}
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileUpload xfer = xfer_mgr.uploadFileList(bucket_name,
key_prefix, new File("."), files);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Voir [Attendre la fin d'un transfert pour](#transfermanager-wait-for-completion) plus d'informations sur l'utilisation `waitForCompletion` de la `shutdownNow` méthode permettant de terminer un transfert avec succès avant TransferManager d'appeler. En attendant que le transfert se termine, vous pouvez interroger ou écouter les mises à jour relatives à son état et à sa progression. Pour plus d'informations, consultez [Obtention de l'état et de la progression du transfert](#transfermanager-get-status-and-progress).
L'[MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)objet renvoyé par `uploadFileList` peut être utilisé pour demander l'état ou la progression du transfert. Pour plus d'informations, consultez [les rubriques Sondage de la progression actuelle d'un transfert](#transfermanager-get-progress-polling) [et Obtenir la progression du transfert avec un ProgressListener](#transfermanager-progress-listener).
Vous pouvez aussi utiliser la méthode `MultipleFileUpload` de `getSubTransfers` pour obtenir les objets `Upload` individuels de chaque fichier transféré. Pour plus d'informations, consultez [Obtention de la progression des sous-transferts](#transfermanager-get-subtransfer-progress).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) sur GitHub.
### Charger un répertoire
Vous pouvez utiliser TransferManager la `uploadDirectory` méthode s pour télécharger un répertoire complet de fichiers, avec la possibilité de copier des fichiers dans des sous-répertoires de manière récursive. *Vous fournissez un nom de Amazon S3 compartiment, un préfixe de clé S3, un objet [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) représentant le répertoire local à copier et une `boolean` valeur indiquant si vous souhaitez copier les sous-répertoires de manière récursive (*vrai* ou faux).*
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.MultipleFileUpload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
```
**Code**
```
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileUpload xfer = xfer_mgr.uploadDirectory(bucket_name,
key_prefix, new File(dir_path), recursive);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Voir [Attendre la fin d'un transfert pour](#transfermanager-wait-for-completion) plus d'informations sur l'utilisation `waitForCompletion` de la `shutdownNow` méthode permettant de terminer un transfert avec succès avant TransferManager d'appeler. En attendant que le transfert se termine, vous pouvez interroger ou écouter les mises à jour relatives à son état et à sa progression. Pour plus d'informations, consultez [Obtention de l'état et de la progression du transfert](#transfermanager-get-status-and-progress).
L'[MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)objet renvoyé par `uploadFileList` peut être utilisé pour demander l'état ou la progression du transfert. Pour plus d'informations, consultez [les rubriques Sondage de la progression actuelle d'un transfert](#transfermanager-get-progress-polling) [et Obtenir la progression du transfert avec un ProgressListener](#transfermanager-progress-listener).
Vous pouvez aussi utiliser la méthode `MultipleFileUpload` de `getSubTransfers` pour obtenir les objets `Upload` individuels de chaque fichier transféré. Pour plus d'informations, consultez [Obtention de la progression des sous-transferts](#transfermanager-get-subtransfer-progress).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) sur GitHub.
## Téléchargement de fichiers ou de répertoires
Utilisez la TransferManager classe pour télécharger un seul fichier (Amazon S3 objet) ou un répertoire (un nom de Amazon S3 compartiment suivi d'un préfixe d'objet) depuis Amazon S3.
**Topics**
+ [Téléchargement d'un seul fichier](#transfermanager-download-file)
+ [Téléchargement d'un répertoire](#tranfermanager-download-directory)
### Téléchargement d'un seul fichier
Utilisez la `download` méthode TransferManager's, en fournissant le nom du Amazon S3 compartiment contenant l'objet que vous souhaitez télécharger, le nom de la clé (objet) et un objet [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) qui représente le fichier à créer sur votre système local.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Download;
import com.amazonaws.services.s3.transfer.MultipleFileDownload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import java.io.File;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Download xfer = xfer_mgr.download(bucket_name, key_name, f);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Voir [Attendre la fin d'un transfert pour](#transfermanager-wait-for-completion) plus d'informations sur l'utilisation `waitForCompletion` de la `shutdownNow` méthode permettant de terminer un transfert avec succès avant TransferManager d'appeler. En attendant que le transfert se termine, vous pouvez interroger ou écouter les mises à jour relatives à son état et à sa progression. Pour plus d'informations, consultez [Obtention de l'état et de la progression du transfert](#transfermanager-get-status-and-progress).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) sur GitHub.
### Téléchargement d'un répertoire
Pour télécharger un ensemble de fichiers partageant un préfixe de clé commun (analogue à un répertoire d'un système de fichiers) à partir de Amazon S3, utilisez cette méthode. TransferManager `downloadDirectory` La méthode utilise le nom du Amazon S3 compartiment contenant les objets que vous souhaitez télécharger, le préfixe d'objet partagé par tous les objets et un objet [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) qui représente le répertoire dans lequel télécharger les fichiers sur votre système local. Si le répertoire nommé n'existe pas encore, il est créé.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Download;
import com.amazonaws.services.s3.transfer.MultipleFileDownload;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import java.io.File;
```
**Code**
```
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
MultipleFileDownload xfer = xfer_mgr.downloadDirectory(
bucket_name, key_prefix, new File(dir_path));
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Voir [Attendre la fin d'un transfert pour](#transfermanager-wait-for-completion) plus d'informations sur l'utilisation `waitForCompletion` de la `shutdownNow` méthode permettant de terminer un transfert avec succès avant TransferManager d'appeler. En attendant que le transfert se termine, vous pouvez interroger ou écouter les mises à jour relatives à son état et à sa progression. Pour plus d'informations, consultez [Obtention de l'état et de la progression du transfert](#transfermanager-get-status-and-progress).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) sur GitHub.
## Copie d'objets
Pour copier un objet d'un compartiment S3 vers un autre, utilisez la méthode `copy` de TransferManager.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.transfer.Copy;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
```
**Code**
```
System.out.println("Copying s3 object: " + from_key);
System.out.println(" from bucket: " + from_bucket);
System.out.println(" to s3 object: " + to_key);
System.out.println(" in bucket: " + to_bucket);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Copy xfer = xfer_mgr.copy(from_bucket, from_key, to_bucket, to_key);
// loop with Transfer.isDone()
XferMgrProgress.showTransferProgress(xfer);
// or block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(xfer);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrCopy.java) sur GitHub.
## Attente de la fin d'un transfert
Si votre application (ou thread) peut bloquer jusqu'à ce que le transfert soit terminé, vous pouvez utiliser la `waitForCompletion` méthode de l'interface de [transfert](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html) pour bloquer jusqu'à ce que le transfert soit terminé ou qu'une exception se produise.
```
try {
xfer.waitForCompletion();
} catch (AmazonServiceException e) {
System.err.println("Amazon service error: " + e.getMessage());
System.exit(1);
} catch (AmazonClientException e) {
System.err.println("Amazon client error: " + e.getMessage());
System.exit(1);
} catch (InterruptedException e) {
System.err.println("Transfer interrupted: " + e.getMessage());
System.exit(1);
}
```
Vous pouvez obtenir la progression des transferts si vous interrogez les événements *avant* d'appeler`waitForCompletion`, si vous implémentez un mécanisme de sondage sur un thread distinct ou si vous recevez des mises à jour de progression de manière asynchrone à l'aide d'un. [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) sur GitHub.
## Obtention de l'état et de la progression du transfert
Chacune des classes renvoyées par les `copy` méthodes TransferManager`upload*`,`download*`, et renvoie une instance de l'une des classes suivantes, selon qu'il s'agit d'une opération à fichier unique ou à fichiers multiples.
****
| Classe | Renvoyée par |
| --- | --- |
| [Copy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Copy.html) | `copy` |
| [Download](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Download.html) | `download` |
| [MultipleFileDownload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileDownload.html) | `downloadDirectory` |
| [Charger](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) | `upload` |
| [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html) | `uploadFileList`, `uploadDirectory` |
Toutes ces classes implémentent l'interface [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html). `Transfer` fournit des méthodes utiles pour obtenir la progression d'un transfert, suspendre ou reprendre le transfert, et obtenir l'état actuel ou final du transfert.
**Topics**
+ [Interrogation de la progression en cours d'un transfert](#transfermanager-get-progress-polling)
+ [Suivez la progression du transfert grâce à ProgressListener](#transfermanager-progress-listener)
+ [Obtention de la progression des sous-transferts](#transfermanager-get-subtransfer-progress)
### Interrogation de la progression en cours d'un transfert
Cette boucle imprime la progression d'un transfert, examine sa progression en cours lors de l'exécution et, une fois le transfert terminé, imprime son état final.
**Importations**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
// print the transfer's human-readable description
System.out.println(xfer.getDescription());
// print an empty progress bar...
printProgressBar(0.0);
// update the progress bar while the xfer is ongoing.
do {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
return;
}
// Note: so_far and total aren't used, they're just for
// documentation purposes.
TransferProgress progress = xfer.getProgress();
long so_far = progress.getBytesTransferred();
long total = progress.getTotalBytesToTransfer();
double pct = progress.getPercentTransferred();
eraseProgressBar();
printProgressBar(pct);
} while (xfer.isDone() == false);
// print the final state of the transfer.
TransferState xfer_state = xfer.getState();
System.out.println(": " + xfer_state);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) sur GitHub.
### Suivez la progression du transfert grâce à ProgressListener
Vous pouvez joindre un [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)à n'importe quel transfert en utilisant la `addProgressListener` méthode de l'interface de [transfert](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html).
A ne [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)nécessite qu'une seule méthode`progressChanged`, qui prend un [ProgressEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressEvent.html)objet. Vous pouvez utiliser l'objet pour obtenir le nombre total d'octets de l'opération en appelant sa méthode `getBytes`, ainsi que le nombre d'octets transférés jusqu'à présent en appelant `getBytesTransferred`.
**Importations**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
File f = new File(file_path);
TransferManager xfer_mgr = TransferManagerBuilder.standard().build();
try {
Upload u = xfer_mgr.upload(bucket_name, key_name, f);
// print an empty progress bar...
printProgressBar(0.0);
u.addProgressListener(new ProgressListener() {
public void progressChanged(ProgressEvent e) {
double pct = e.getBytesTransferred() * 100.0 / e.getBytes();
eraseProgressBar();
printProgressBar(pct);
}
});
// block with Transfer.waitForCompletion()
XferMgrProgress.waitForCompletion(u);
// print the final state of the transfer.
TransferState xfer_state = u.getState();
System.out.println(": " + xfer_state);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
xfer_mgr.shutdownNow();
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) sur GitHub.
### Obtention de la progression des sous-transferts
La [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)classe peut renvoyer des informations sur ses sous-transferts en appelant sa `getSubTransfers` méthode. Il renvoie une [collection](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html) non modifiable d'objets [Upload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) qui fournissent le statut individuel du transfert et la progression de chaque sous-transfert.
**Importations**
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.event.ProgressEvent;
import com.amazonaws.event.ProgressListener;
import com.amazonaws.services.s3.transfer.*;
import com.amazonaws.services.s3.transfer.Transfer.TransferState;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
```
**Code**
```
Collection sub_xfers = new ArrayList();
sub_xfers = multi_upload.getSubTransfers();
do {
System.out.println("\nSubtransfer progress:\n");
for (Upload u : sub_xfers) {
System.out.println(" " + u.getDescription());
if (u.isDone()) {
TransferState xfer_state = u.getState();
System.out.println(" " + xfer_state);
} else {
TransferProgress progress = u.getProgress();
double pct = progress.getPercentTransferred();
printProgressBar(pct);
System.out.println();
}
}
// wait a bit before the next update.
try {
Thread.sleep(200);
} catch (InterruptedException e) {
return;
}
} while (multi_upload.isDone() == false);
// print the final state of the transfer.
TransferState xfer_state = multi_upload.getState();
System.out.println("\nMultipleFileUpload " + xfer_state);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) sur GitHub.
## Plus d'informations
+ [Clés d'objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html) dans le guide de Amazon Simple Storage Service l'utilisateur
# Configuration d'un Amazon S3 bucket en tant que site Web
Vous pouvez configurer un Amazon S3 bucket pour qu'il se comporte comme un site Web. Pour ce faire, vous devez définir sa configuration de site web.
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
## Définition de la configuration de site web d'un compartiment
Pour définir la configuration du site Web d'un Amazon S3 bucket, appelez la `setWebsiteConfiguration` méthode AmazonS3 avec le nom du bucket pour lequel définir la configuration et un [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html)objet contenant la configuration du site Web du bucket.
La définition d'un document d'index est *obligatoire* ; tous les autres paramètres sont facultatifs.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketWebsiteConfiguration;
```
**Code**
```
String bucket_name, String index_doc, String error_doc) {
BucketWebsiteConfiguration website_config = null;
if (index_doc == null) {
website_config = new BucketWebsiteConfiguration();
} else if (error_doc == null) {
website_config = new BucketWebsiteConfiguration(index_doc);
} else {
website_config = new BucketWebsiteConfiguration(index_doc, error_doc);
}
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.setBucketWebsiteConfiguration(bucket_name, website_config);
} catch (AmazonServiceException e) {
System.out.format(
"Failed to set website configuration for bucket '%s'!\n",
bucket_name);
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
**Note**
La définition d'une configuration de site web ne modifie pas les autorisations d'accès de votre compartiment. Pour que vos fichiers soient visibles sur le web, vous devez également définir une *stratégie de compartiment* qui autorise l'accès en lecture public aux fichiers du compartiment. Pour plus d'informations, consultez la section [Gestion de l'accès aux Amazon S3 compartiments à l'aide de politiques relatives aux compartiments](examples-s3-bucket-policies.md).
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetWebsiteConfiguration.java) sur GitHub.
## Obtention de la configuration de site web d'un compartiment
Pour obtenir la configuration du site Web d'un Amazon S3 bucket, appelez la `getWebsiteConfiguration` méthode AmazonS3 avec le nom du bucket pour lequel vous souhaitez récupérer la configuration.
La configuration sera renvoyée sous forme d'[BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html)objet. S'il n'y a pas de configuration de site web pour le compartiment, la valeur `null` est renvoyée.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketWebsiteConfiguration;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
BucketWebsiteConfiguration config =
s3.getBucketWebsiteConfiguration(bucket_name);
if (config == null) {
System.out.println("No website configuration found!");
} else {
System.out.format("Index document: %s\n",
config.getIndexDocumentSuffix());
System.out.format("Error document: %s\n",
config.getErrorDocument());
}
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.out.println("Failed to get website configuration!");
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetWebsiteConfiguration.java) sur GitHub.
## Suppression de la configuration de site web d'un compartiment
Pour supprimer la configuration du site Web d'un Amazon S3 compartiment, appelez la `deleteWebsiteConfiguration` méthode d'AmazonS3 avec le nom du compartiment dont vous souhaitez supprimer la configuration.
**Importations**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Code**
```
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
s3.deleteBucketWebsiteConfiguration(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.out.println("Failed to delete website configuration!");
System.exit(1);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteWebsiteConfiguration.java) sur GitHub.
## En savoir plus
+ [Placer le site Web du bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) dans le guide de référence de Amazon S3 l'API
+ [Site Web GET Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) dans le guide de référence de Amazon S3 l'API
+ Le [site Web DELETE Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) dans la référence de Amazon S3 l'API
# Utiliser le Amazon S3 chiffrement côté client
Le chiffrement des données à l'aide du client de Amazon S3 chiffrement est un moyen de fournir un niveau de protection supplémentaire aux informations sensibles que vous stockez. Amazon S3 Les exemples de cette section montrent comment créer et configurer le client de Amazon S3 chiffrement pour votre application.
Si vous débutez dans le domaine de la cryptographie, consultez les principes de [base de la cryptographie](https://docs.aws.amazon.com/kms/latest/developerguide/crypto-intro.html) du guide du développeur AWS KMS pour un aperçu de base des termes et algorithmes de cryptographie. Pour plus d'informations sur la prise en charge globale de la cryptographie AWS SDKs, consultez la section [AWS Support du SDK pour le chiffrement Amazon S3 côté client](https://docs.aws.amazon.com/general/latest/gr/aws_sdk_cryptography.html) dans le manuel de référence général. Amazon Web Services
**Note**
Ces exemples de code supposent que vous comprenez le contenu de la section [Utilisation du AWS SDK pour Java et que vous avez configuré les](basics.md) AWS informations d'identification par défaut à l'aide des informations de [configuration des informations AWS d'identification et de la région pour le développement](setup-credentials.md).
Si vous utilisez la version 1.11.836 ou une version antérieure du AWS SDK pour Java, consultez la section Migration du [client de Amazon S3 chiffrement pour plus d'informations sur la migration](s3-encryption-migration.md) de vos applications vers des versions ultérieures. Si vous ne parvenez pas à effectuer la migration, consultez [cet exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/S3Encrypt.java) sur GitHub.
Sinon, si vous utilisez la version 1.11.837 ou une version ultérieure du AWS SDK pour Java, explorez les exemples de rubriques ci-dessous pour utiliser Amazon S3 le chiffrement côté client.
**Topics**
+ [Amazon S3 chiffrement côté client à l'aide des clés principales du client](examples-crypto-masterkey.md)
+ [Amazon S3 chiffrement côté client avec clés gérées par AWS KMS](examples-crypto-kms.md)
# Amazon S3 chiffrement côté client à l'aide des clés principales du client
Les exemples suivants utilisent la classe [AmazonS3 EncryptionClient V2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) pour créer un Amazon S3 client avec le chiffrement côté client activé. Une fois activé, tous les objets que vous téléchargez à Amazon S3 l'aide de ce client seront chiffrés. Tous les objets que vous obtenez Amazon S3 en utilisant ce client seront automatiquement déchiffrés.
**Note**
Les exemples suivants illustrent l'utilisation du chiffrement Amazon S3 côté client avec des clés principales client gérées par le client. Pour savoir comment utiliser le chiffrement avec des clés gérées par AWS KMS, consultez la section [Chiffrement Amazon S3 côté client avec des clés gérées par AWS KMS](examples-crypto-kms.md).
Lorsque vous activez le chiffrement côté client, vous pouvez choisir entre deux modes de Amazon S3 chiffrement : authentifié strict ou authentifié. Les sections suivantes montrent comment activer chaque type. Pour connaître les algorithmes utilisés par chaque mode, consultez la [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)définition.
## Importations requises
Pour ces exemples, vous devez importer les classes suivantes.
**Importations**
```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3EncryptionClientV2Builder;
import com.amazonaws.services.s3.AmazonS3EncryptionV2;
import com.amazonaws.services.s3.model.CryptoConfigurationV2;
import com.amazonaws.services.s3.model.CryptoMode;
import com.amazonaws.services.s3.model.EncryptionMaterials;
import com.amazonaws.services.s3.model.StaticEncryptionMaterialsProvider;
```
## Chiffrement authentifié strict
Le chiffrement authentifié strict est le mode par défaut si aucun n'`CryptoMode`est spécifié.
Pour activer explicitement ce mode, spécifiez la `StrictAuthenticatedEncryption` valeur dans la `withCryptoConfiguration` méthode.
**Note**
Pour utiliser le chiffrement authentifié côté client, vous devez inclure le dernier fichier [jar Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) dans le chemin de classe de votre application.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.StrictAuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
.build();
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY2, "This is the 2nd content to encrypt");
```
## Mode de chiffrement authentifié
Lorsque vous utilisez le mode `AuthenticatedEncryption`, un algorithme d'encapsulage de clé amélioré est appliqué pendant le chiffrement. Lorsque vous déchiffrez dans ce mode, l'algorithme peut vérifier l'intégrité de l'objet déchiffré et générer une exception si la vérification échoue. Pour plus de détails sur le fonctionnement du chiffrement authentifié, consultez le billet de blog [Amazon S3 sur le chiffrement authentifié côté client](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption).
**Note**
Pour utiliser le chiffrement authentifié côté client, vous devez inclure le dernier fichier [jar Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) dans le chemin de classe de votre application.
Pour activer ce mode, spécifiez la valeur `AuthenticatedEncryption` dans la méthode `withCryptoConfiguration`.
**Code**
```
AmazonS3EncryptionV2 s3EncryptionClientV2 = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.DEFAULT_REGION)
.withClientConfiguration(new ClientConfiguration())
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode(CryptoMode.AuthenticatedEncryption))
.withEncryptionMaterialsProvider(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
.build();
s3EncryptionClientV2.putObject(bucket_name, ENCRYPTED_KEY1, "This is the 1st content to encrypt");
```
# Amazon S3 chiffrement côté client avec clés gérées par AWS KMS
Les exemples suivants utilisent la classe [AmazonS3 EncryptionClient V2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) pour créer un Amazon S3 client avec le chiffrement côté client activé. Une fois configuré, tous les objets que vous téléchargez à Amazon S3 l'aide de ce client seront chiffrés. Tous les objets que vous obtenez en Amazon S3 utilisant ce client sont automatiquement déchiffrés.
**Note**
Les exemples suivants montrent comment utiliser le chiffrement Amazon S3 côté client avec des clés gérées par AWS KMS. Pour savoir comment utiliser le chiffrement avec vos propres clés, consultez la section [Chiffrement Amazon S3 côté client à l'aide des clés principales du client](examples-crypto-masterkey.md).
Lorsque vous activez le chiffrement côté client, vous pouvez choisir entre deux modes de Amazon S3 chiffrement : authentifié strict ou authentifié. Les sections suivantes montrent comment activer chaque type. Pour connaître les algorithmes utilisés par chaque mode, reportez-vous à la [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)définition.
## Importations requises
Pour ces exemples, vous devez importer les classes suivantes.
**Importations**
```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.GenerateDataKeyRequest;
import com.amazonaws.services.kms.model.GenerateDataKeyResult;
import com.amazonaws.services.s3.AmazonS3EncryptionClientV2Builder;
import com.amazonaws.services.s3.AmazonS3EncryptionV2;
import com.amazonaws.services.s3.model.CryptoConfigurationV2;
import com.amazonaws.services.s3.model.CryptoMode;
import com.amazonaws.services.s3.model.EncryptionMaterials;
import com.amazonaws.services.s3.model.KMSEncryptionMaterialsProvider;
```
## Chiffrement authentifié strict
Le chiffrement authentifié strict est le mode par défaut si aucun n'`CryptoMode`est spécifié.
Pour activer explicitement ce mode, spécifiez la `StrictAuthenticatedEncryption` valeur dans la `withCryptoConfiguration` méthode.
**Note**
Pour utiliser le chiffrement authentifié côté client, vous devez inclure le dernier fichier [jar Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) dans le chemin de classe de votre application.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.StrictAuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
Appelez la `putObject` méthode sur le client Amazon S3 de chiffrement pour télécharger des objets.
**Code**
```
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
```
Vous pouvez récupérer l'objet en utilisant le même client. Cet exemple appelle la méthode `getObjectAsString` pour récupérer la chaîne qui a été stockée.
**Code**
```
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
## Mode de chiffrement authentifié
Lorsque vous utilisez le mode `AuthenticatedEncryption`, un algorithme d'encapsulage de clé amélioré est appliqué pendant le chiffrement. Lorsque vous déchiffrez dans ce mode, l'algorithme peut vérifier l'intégrité de l'objet déchiffré et générer une exception si la vérification échoue. Pour plus de détails sur le fonctionnement du chiffrement authentifié, consultez le billet de blog [Amazon S3 sur le chiffrement authentifié côté client](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption).
**Note**
Pour utiliser le chiffrement authentifié côté client, vous devez inclure le dernier fichier [jar Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) dans le chemin de classe de votre application.
Pour activer ce mode, spécifiez la valeur `AuthenticatedEncryption` dans la méthode `withCryptoConfiguration`.
**Code**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
## Configuration du AWS KMS client
Le client de Amazon S3 chiffrement crée un AWS KMS client par défaut, sauf si un client est explicitement spécifié.
Pour définir la région de ce AWS KMS client créé automatiquement, définissez le. `awsKmsRegion`
**Code**
```
Region kmsRegion = Region.getRegion(Regions.AP_NORTHEAST_1);
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withAwsKmsRegion(kmsRegion))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
Vous pouvez également utiliser votre propre AWS KMS client pour initialiser le client de chiffrement.
**Code**
```
AWSKMS kmsClient = AWSKMSClientBuilder.standard()
.withRegion(Regions.US_WEST_2);
.build();
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withKmsClient(kmsClient)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
# Amazon SQS Exemples utilisant le AWS SDK pour Java
Cette section fournit des exemples de programmation d'[Amazon SQS](https://aws.amazon.com/sqs/) à l'aide du kit [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
**Note**
Les exemples incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Utilisation des files d'attente de Amazon SQS messages](examples-sqs-message-queues.md)
+ [Envoyer, recevoir et supprimer Amazon SQS des messages](examples-sqs-messages.md)
+ [Activation des longues interrogations pour les files d'attente de Amazon SQS messages](examples-sqs-long-polling.md)
+ [Configuration du délai de visibilité dans Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Utilisation des files d'attente de lettres mortes dans Amazon SQS](examples-sqs-dead-letter-queues.md)
# Utilisation des files d'attente de Amazon SQS messages
Une *file de messages* est le conteneur logique utilisé pour envoyer des messages de manière fiable Amazon SQS. Il existe deux types de files d'attente : *standard* et *FIFO* (premier entré, premier sorti). Pour en savoir plus sur les files d'attente et les différences entre ces types, consultez le [guide du Amazon SQS développeur](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).
Cette rubrique décrit comment créer, répertorier, supprimer et obtenir l'URL d'une Amazon SQS file d'attente à l'aide du AWS SDK pour Java.
## Création d'une file d'attente
Utilisez la `createQueue` méthode du client AmazonSQS, en fournissant un [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)objet qui décrit les paramètres de la file d'attente.
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
CreateQueueRequest create_request = new CreateQueueRequest(QUEUE_NAME)
.addAttributesEntry("DelaySeconds", "60")
.addAttributesEntry("MessageRetentionPeriod", "86400");
try {
sqs.createQueue(create_request);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
Vous pouvez utiliser la forme simplifiée de `createQueue`, qui nécessite uniquement un nom de file d'attente, pour créer une file d'attente standard.
```
sqs.createQueue("MyQueue" + new Date().getTime());
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) sur GitHub.
## Affichage de la liste des files d'attente
Pour répertorier les Amazon SQS files d'attente pour votre compte, appelez la méthode du client AmazonSQS. `listQueues`
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesResult;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
ListQueuesResult lq_result = sqs.listQueues();
System.out.println("Your SQS Queue URLs:");
for (String url : lq_result.getQueueUrls()) {
System.out.println(url);
}
```
L'utilisation de la surcharge `listQueues` sans aucun paramètre renvoie *toutes les files d'attente*. Vous pouvez filtrer les résultats renvoyés en transmettant un objet `ListQueuesRequest`.
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesRequest;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String name_prefix = "Queue";
lq_result = sqs.listQueues(new ListQueuesRequest(name_prefix));
System.out.println("Queue URLs with prefix: " + name_prefix);
for (String url : lq_result.getQueueUrls()) {
System.out.println(url);
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) sur GitHub.
## Obtention de l'URL d'une file d'attente
Appelez la méthode du client AmazonSQS. `getQueueUrl`
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String queue_url = sqs.getQueueUrl(QUEUE_NAME).getQueueUrl();
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) sur GitHub.
## Suppression d'une file d'attente
Fournissez l'[URL](#sqs-get-queue-url) de la file d'attente à la méthode du client AmazonSQS. `deleteQueue`
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.deleteQueue(queue_url);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) sur GitHub.
## Plus d'informations
+ [Comment fonctionnent les Amazon SQS files d'attente](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) dans le guide du Amazon SQS développeur
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)dans la référence de Amazon SQS l'API
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)dans la référence de Amazon SQS l'API
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)dans la référence de Amazon SQS l'API
+ [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)dans la référence de Amazon SQS l'API
# Envoyer, recevoir et supprimer Amazon SQS des messages
Cette rubrique décrit comment envoyer, recevoir et supprimer Amazon SQS des messages. Les messages sont toujours livrés à l'aide d'une [file d'attente SQS](examples-sqs-message-queues.md).
## Envoi d'un message
Ajoutez un seul message à une Amazon SQS file d'attente en appelant la méthode du client AmazonSQS. `sendMessage` Fournissez un [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageRequest.html)objet contenant l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la file d'attente, le corps du message et la valeur de délai facultative (en secondes).
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.SendMessageRequest;
```
**Code**
```
SendMessageRequest send_msg_request = new SendMessageRequest()
.withQueueUrl(queueUrl)
.withMessageBody("hello world")
.withDelaySeconds(5);
sqs.sendMessage(send_msg_request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) sur GitHub.
### Envoi simultané de plusieurs messages
Vous pouvez envoyer plusieurs message dans une même demande. Pour envoyer plusieurs messages, utilisez la `sendMessageBatch` méthode du client AmazonSQS, qui prend une URL [SendMessageBatchRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequest.html)contenant l'URL de la file d'attente et une liste de messages (chacun a [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequestEntry.html)) à envoyer. Vous pouvez également définir une valeur de délai facultative par message.
**Importations**
```
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
import com.amazonaws.services.sqs.model.SendMessageBatchRequestEntry;
```
**Code**
```
SendMessageBatchRequest send_batch_request = new SendMessageBatchRequest()
.withQueueUrl(queueUrl)
.withEntries(
new SendMessageBatchRequestEntry(
"msg_1", "Hello from message 1"),
new SendMessageBatchRequestEntry(
"msg_2", "Hello from message 2")
.withDelaySeconds(10));
sqs.sendMessageBatch(send_batch_request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) sur GitHub.
## Réception de messages
Récupérez tous les messages actuellement dans la file d'attente en appelant la `receiveMessage` méthode du client AmazonSQS et en lui transmettant l'URL de la file d'attente. Les messages sont renvoyés sous la forme d'une liste d'objets [Message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/Message.html).
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
```
**Code**
```
List messages = sqs.receiveMessage(queueUrl).getMessages();
```
## Suppression des messages après réception
Après avoir reçu un message et traité son contenu, supprimez-le de la file d'attente en envoyant l'identifiant de réception du message et l'URL de la file d'attente à la méthode du `deleteMessage` client AmazonSQS.
**Code**
```
for (Message m : messages) {
sqs.deleteMessage(queueUrl, m.getReceiptHandle());
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) sur GitHub.
## Plus d'informations
+ [Comment fonctionnent les Amazon SQS files d'attente](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) dans le guide du Amazon SQS développeur
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)dans la référence de Amazon SQS l'API
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)dans la référence de Amazon SQS l'API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de Amazon SQS l'API
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)dans la référence de Amazon SQS l'API
# Activation des longues interrogations pour les files d'attente de Amazon SQS messages
Amazon SQS utilise un *court sondage* par défaut, interrogeant uniquement un sous-ensemble des serveurs, sur la base d'une distribution aléatoire pondérée, afin de déterminer si des messages peuvent être inclus dans la réponse.
Les longs sondages permettent de réduire les coûts d'utilisation en Amazon SQS réduisant le nombre de réponses vides lorsqu'aucun message n'est disponible pour répondre à une ReceiveMessage demande envoyée dans une Amazon SQS file d'attente et en éliminant les fausses réponses vides.
**Note**
Vous pouvez définir une fréquence d'interrogation longue comprise entre *1 et 20 secondes.*
## Activation de l'attente active de longue durée lors de la création d'une file d'attente
Pour permettre un long sondage lors de la création Amazon SQS d'une file d'attente, définissez l'`ReceiveMessageWaitTimeSeconds`attribut sur l'[CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)objet avant d'appeler la méthode de la classe `createQueue` AmazonSQS.
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
```
**Code**
```
final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Enable long polling when creating a queue
CreateQueueRequest create_request = new CreateQueueRequest()
.withQueueName(queue_name)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
try {
sqs.createQueue(create_request);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) sur GitHub.
## Activation de l'attente active de longue durée pour une file d'attente existante
En plus de permettre un long sondage lors de la création d'une file d'attente, vous pouvez également l'activer sur une file d'attente existante en activant la `ReceiveMessageWaitTimeSeconds` méthode « [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)avant d'appeler la classe `setQueueAttributes` AmazonSQS ».
**Importations**
```
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Code**
```
SetQueueAttributesRequest set_attrs_request = new SetQueueAttributesRequest()
.withQueueUrl(queue_url)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
sqs.setQueueAttributes(set_attrs_request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) sur GitHub.
## Activation de l'attente active de longue durée pour la réception des messages
Vous pouvez activer les longs sondages lorsque vous recevez un message en définissant le temps d'attente en secondes sur la méthode [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ReceiveMessageRequest.html)que vous indiquez à la classe `receiveMessage` AmazonSQS.
**Note**
Vous devez vous assurer que le délai d'expiration des demandes du AWS client est supérieur à la durée maximale du sondage (20 secondes) afin que vos `receiveMessage` demandes ne soient pas expirées en attendant le prochain événement du sondage \$1
**Importations**
```
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
```
**Code**
```
ReceiveMessageRequest receive_request = new ReceiveMessageRequest()
.withQueueUrl(queue_url)
.withWaitTimeSeconds(20);
sqs.receiveMessage(receive_request);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) sur GitHub.
## Plus d'informations
+ [Amazon SQS Longue interrogation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) dans le guide du Amazon SQS développeur
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)dans la référence de Amazon SQS l'API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de Amazon SQS l'API
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de Amazon SQS l'API
# Configuration du délai de visibilité dans Amazon SQS
Lorsqu'un message est reçu Amazon SQS, il reste dans la file d'attente jusqu'à ce qu'il soit supprimé afin de garantir sa réception. Un message qui a été reçu, mais pas supprimé, est disponible dans les demandes suivantes après un *délai de visibilité* donné afin d'empêcher que le message ne soit reçu plusieurs fois avant d'être traité et supprimé.
**Note**
Lorsque vous utilisez les [files d'attente standard](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), le délai de visibilité n'est pas une garantie que vous ne recevrez pas deux fois un même message. Si vous utilisez une file d'attente standard, assurez-vous que votre code gère le cas où le même message est remis plusieurs fois.
## Définition du délai de visibilité de message pour un seul message
Lorsque vous avez reçu un message, vous pouvez modifier son délai de visibilité en transmettant son identifiant de réception à la [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityRequest.html)méthode de la classe AmazonSQS. `changeMessageVisibility`
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Get the receipt handle for the first message in the queue.
String receipt = sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle();
sqs.changeMessageVisibility(queue_url, receipt, timeout);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) sur GitHub.
## Définition simultanée du délai de visibilité de message pour plusieurs messages
Pour définir le délai de visibilité des messages pour plusieurs messages à la fois, créez une liste d'[ChangeMessageVisibilityBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityBatchRequestEntry.html)objets contenant chacun une chaîne d'identification unique et un identifiant de réception. Transmettez ensuite la liste à la `changeMessageVisibilityBatch` méthode de la classe Amazon SQS client.
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry;
import java.util.ArrayList;
import java.util.List;
```
**Code**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
List entries =
new ArrayList();
entries.add(new ChangeMessageVisibilityBatchRequestEntry(
"unique_id_msg1",
sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle())
.withVisibilityTimeout(timeout));
entries.add(new ChangeMessageVisibilityBatchRequestEntry(
"unique_id_msg2",
sqs.receiveMessage(queue_url)
.getMessages()
.get(0)
.getReceiptHandle())
.withVisibilityTimeout(timeout + 200));
sqs.changeMessageVisibilityBatch(queue_url, entries);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) sur GitHub.
## Plus d'informations
+ [Délai de visibilité indiqué](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) dans le guide du Amazon SQS développeur
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de Amazon SQS l'API
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)dans la référence de Amazon SQS l'API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de Amazon SQS l'API
+ [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)dans la référence de Amazon SQS l'API
+ [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)dans la référence de Amazon SQS l'API
# Utilisation des files d'attente de lettres mortes dans Amazon SQS
Amazon SQS fournit un support pour les *files d'attente de lettres mortes*. Il s'agit d'une file d'attente que peuvent cibler d'autres files d'attente (source) pour les messages qui ne sont pas traités avec succès. Vous pouvez mettre de côté et isoler ces messages dans la file d'attente de lettres mortes pour déterminer pourquoi leur traitement a échoué.
## Création d'une file d'attente de lettres mortes
Une file d'attente de lettres mortes est créée de la même manière qu'une file d'attente normale, mais elle comporte les restrictions suivantes :
+ Une file d'attente de lettres mortes doit avoir le même type de file d'attente (FIFO ou standard) que la file d'attente source.
+ Une file d'attente de lettres mortes doit être créée en utilisant la même région Compte AWS et la même région que la file d'attente source.
Nous créons ici deux Amazon SQS files d'attente identiques, dont l'une servira de file d'attente des lettres mortes :
**Importations**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
```
**Code**
```
final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
// Create source queue
try {
sqs.createQueue(src_queue_name);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
// Create dead-letter queue
try {
sqs.createQueue(dl_queue_name);
} catch (AmazonSQSException e) {
if (!e.getErrorCode().equals("QueueAlreadyExists")) {
throw e;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) sur GitHub.
## Désignation d'une file d'attente de lettres mortes pour une file d'attente source
Pour désigner une file d'attente de lettres mortes, vous devez commencer par créer une *stratégie de redirection*, puis définir la stratégie dans les attributs de la file d'attente. Une stratégie de redirection est spécifiée au format JSON. Elle indique l'ARN de la file d'attente de lettres mortes et le nombre maximum de fois où le message peut être reçu et non traité avant d'être envoyé dans la file d'attente de lettres mortes.
Pour définir la politique de redrive pour votre file d'attente source, appelez la `setQueueAttributes` méthode de la classe AmazonSQS avec un [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)objet dont vous avez défini l'`RedrivePolicy`attribut avec votre politique de redrive JSON.
**Importations**
```
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Code**
```
String dl_queue_url = sqs.getQueueUrl(dl_queue_name)
.getQueueUrl();
GetQueueAttributesResult queue_attrs = sqs.getQueueAttributes(
new GetQueueAttributesRequest(dl_queue_url)
.withAttributeNames("QueueArn"));
String dl_queue_arn = queue_attrs.getAttributes().get("QueueArn");
// Set dead letter queue with redrive policy on source queue.
String src_queue_url = sqs.getQueueUrl(src_queue_name)
.getQueueUrl();
SetQueueAttributesRequest request = new SetQueueAttributesRequest()
.withQueueUrl(src_queue_url)
.addAttributesEntry("RedrivePolicy",
"{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\""
+ dl_queue_arn + "\"}");
sqs.setQueueAttributes(request);
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) sur GitHub.
## Plus d'informations
+ [Utilisation des files d'attente Amazon SQS Dead Letter](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) dans le guide du Amazon SQS développeur
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)dans la référence de Amazon SQS l'API
# Amazon SWF Exemples d'utilisation du AWS SDK pour Java
[Amazon SWF](https://aws.amazon.com/swf/)[est un service de gestion des flux de travail qui aide les développeurs à créer et à faire évoluer des flux de travail distribués qui peuvent comporter des étapes parallèles ou séquentielles comprenant des activités, des flux de travail secondaires ou même des tâches Lambda.](https://aws.amazon.com/lambda/)
Il existe deux manières de travailler avec Amazon SWF le : AWS SDK pour Java en utilisant l'objet *client* SWF ou en utilisant l'objet AWS Flow Framework pour Java. Le AWS Flow Framework for Java est plus difficile à configurer au départ, car il utilise beaucoup d'annotations et repose sur des bibliothèques supplémentaires telles que AspectJ et le Spring Framework. Toutefois, pour les projets complexes ou de grande envergure, vous économiserez du temps de codage en utilisant le AWS Flow Framework pour Java. Pour plus d'informations, consultez le [guide du développeur AWS Flow Framework pour Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
Cette section fournit des exemples de programmation Amazon SWF utilisant directement le AWS SDK pour Java client.
**Topics**
+ [Notions de base sur SWF](swf-basics.md)
+ [Création d'une Amazon SWF application simple](swf-hello.md)
+ [Lambda Tâches](swf-lambda-task.md)
+ [Arrêt normal des travaux d'activité et de flux de travail](swf-graceful-shutdown.md)
+ [Enregistrement de domaines](prog-services-swf-register-domain.md)
+ [Affichage des domaines](prog-services-swf-list-domains.md)
# Notions de base sur SWF
Il s'agit de modèles généraux d' Amazon SWF utilisation du AWS SDK pour Java. Ils sont principalement destinés à servir de référence. Pour un didacticiel d'introduction plus complet, voir [Création d'une Amazon SWF application simple](swf-hello.md).
## Dépendances
Amazon SWF Les applications de base nécessiteront les dépendances suivantes, qui sont incluses dans AWS SDK pour Java :
+ aws-java-sdk-1.12.\$1.jar
+ commons-logging-1.2.\$1.jar
+ httpclient-4.3.\$1.jar
+ httpcore-4.3.\$1.jar
+ jackson-annotations-2.12.\$1.jar
+ jackson-core-2.12.\$1.jar
+ jackson-databind-2.12.\$1.jar
+ joda-time-2.8.\$1.jar
**Note**
Les numéros de version de ces packages varient en fonction de la version du SDK dont vous disposez, mais les versions fournies avec le SDK ont été testées pour en vérifier la compatibilité et sont celles que vous devez utiliser.
AWS Flow Framework pour les applications Java, une configuration supplémentaire *et* des dépendances supplémentaires sont nécessaires. Consultez le [guide du développeur AWS Flow Framework pour Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/) pour plus d'informations sur l'utilisation du framework.
## Importations
En général, vous pouvez utiliser les importations suivantes pour le développement du code :
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
Une bonne pratique consiste néanmoins à importer uniquement les classes dont vous avez besoin. Vous vous retrouverez probablement à spécifier des classes particulières dans l'espace de travail `com.amazonaws.services.simpleworkflow.model` :
```
import com.amazonaws.services.simpleworkflow.model.PollForActivityTaskRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskCompletedRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskFailedRequest;
import com.amazonaws.services.simpleworkflow.model.TaskList;
```
Si vous utilisez le AWS Flow Framework pour Java, vous allez importer des classes depuis l'`com.amazonaws.services.simpleworkflow.flow`espace de travail. Par exemple :
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.flow.ActivityWorker;
```
**Note**
Le AWS Flow Framework for Java a des exigences supplémentaires au-delà de celles de la base AWS SDK pour Java. Pour plus d'informations, consultez le [guide du développeur AWS Flow Framework pour Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Utilisation de la classe client SWF
Votre interface de base Amazon SWF se fait via les [AmazonSimpleWorkflowAsyncClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowAsyncClient.html)classes [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)or. La principale différence entre les deux classes est que la classe `\*AsyncClient` renvoie des objets [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) pour la programmation simultanée (asynchrone).
```
AmazonSimpleWorkflowClient swf = AmazonSimpleWorkflowClientBuilder.defaultClient();
```
# Création d'une Amazon SWF application simple
Cette rubrique vous présentera la programmation d'[Amazon SWF](https://aws.amazon.com/swf/)applications avec le AWS SDK pour Java, tout en présentant quelques concepts importants en cours de route.
## À propos de l'exemple
L'exemple de projet créera un flux de travail avec une seule activité qui accepte les données de flux de travail transmises via le AWS cloud (dans la tradition HelloWorld, ce sera le nom de la personne à saluer), puis imprime un message d'accueil en réponse.
Bien que cela semble très simple à première vue, Amazon SWF les applications se composent d'un certain nombre de parties qui fonctionnent ensemble :
+ Un **domaine**, utilisé comme conteneur logique pour vos données d'exécution de flux de travail.
+ Un ou plusieurs **flux de travail** représentant des composants de code qui définissent l'ordre logique de l'exécution des activités du flux de travail et des flux de travail enfants.
+ Un **travail de flux de travail**, également appelé *décideur*, qui recherche les tâches de décision et planifie des activités ou des flux de travail enfants en réponse.
+ Une ou plusieurs **activités**, chacune représentant une unité de travail dans le flux de travail.
+ Un **travail d'activité** qui recherche les tâches d'activité et exécute des méthodes d'activité en réponse.
+ Une ou plusieurs **listes de tâches**, qui sont des files d'attente maintenues et Amazon SWF utilisées pour envoyer des demandes aux travailleurs du flux de travail et des activités. Les tâches d'une liste de tâches destinées aux travaux de flux de travail sont appelées *tâches de décision*. Celles destinées aux travaux d'activité sont appelées *tâches d'activité*.
+ Un **démarreur de flux de travail** qui démarre l'exécution de votre flux de travail.
Dans les coulisses, Amazon SWF orchestre le fonctionnement de ces composants, coordonne leur flux depuis le AWS cloud, transmet les données entre eux, gère les délais d'expiration et les notifications de pulsation, et enregistre l'historique d'exécution du flux de travail.
## Prérequis
### Environnement de développement
L'environnement de développement utilisé dans ce didacticiel comprend les éléments suivants :
+ La valeur [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/).
+ [Apache Maven](http://maven.apache.org/) (3.3.1).
+ JDK 1.7 ou version ultérieure. Ce didacticiel a été développé et testé à l'aide de JDK 1.8.0.
+ Un éditeur de texte Java efficace (de votre choix).
**Note**
Si vous utilisez un système de compilation différent de Maven, vous pouvez toujours créer un projet en suivant les étapes appropriées à votre environnement et en utilisant les concepts fournis ici pour suivre. Vous trouverez de plus amples informations sur la configuration et l'utilisation du AWS SDK pour Java avec différents systèmes de compilation dans [Getting Started](getting-started.md).
De même, mais avec plus d'efforts, les étapes indiquées ici peuvent être mises en œuvre à l'aide de n'importe laquelle AWS SDKs des étapes prises en charge par Amazon SWF.
Toutes les dépendances externes nécessaires sont incluses dans le AWS SDK pour Java, il n'y a donc rien d'autre à télécharger.
### AWS Accès
Pour suivre correctement ce didacticiel, vous devez avoir accès au portail d' AWS accès, comme [décrit dans la section de configuration de base](signup-create-iam-user.md#signup-create-iam-user-overview) de ce guide.
Les instructions décrivent comment accéder aux informations d'identification temporaires que vous copiez et collez dans votre `credentials` fichier partagé local. Les informations d'identification temporaires que vous collez doivent être associées à un rôle IAM autorisé à accéder à Amazon SWF. AWS IAM Identity Center Après avoir collé les informations d'identification temporaires, votre `credentials` fichier ressemblera à ce qui suit.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
Ces informations d'identification temporaires sont associées au `default` profil.
## Création d'un projet SWF
1. Démarrez un nouveau projet avec Maven :
```
mvn archetype:generate -DartifactId=helloswf \
-DgroupId=aws.example.helloswf -DinteractiveMode=false
```
Cela permet de créer un nouveau projet avec une structure de projet Maven standard :
```
helloswf
├── pom.xml
└── src
├── main
│ └── java
│ └── aws
│ └── example
│ └── helloswf
│ └── App.java
└── test
└── ...
```
Vous pouvez ignorer ou supprimer le répertoire `test` et tout ce qu'il contient, car nous ne l'utiliserons pas pour ce didacticiel. Vous pouvez également supprimer `App.java`, car nous le remplacerons par de nouvelles classes.
1. Modifiez le `pom.xml` fichier du projet et ajoutez le **aws-java-sdk-simpleworkflow**module en ajoutant une dépendance pour celui-ci dans le `` bloc.
```
com.amazonawsaws-java-sdk-simpleworkflow1.11.1000
```
1. *Assurez-vous que Maven génère votre projet avec JDK 1.7 ou version ultérieure*. Ajoutez les éléments suivants à votre projet (avant ou après le bloc ``) dans `pom.xml` :
```
maven-compiler-plugin3.6.11.81.8
```
## Codage du projet
L'exemple de projet est composé de quatre applications distinctes que nous allons examiner une par une :
+ **HelloTypes.java** --contient les données de domaine, d'activité et de type de flux de travail du projet, partagées avec les autres composants. Gère également l'enregistrement de ces types auprès de SWF.
+ **ActivityWorker.java** --contient le gestionnaire d'activité, qui interroge les tâches d'activité et exécute les activités en réponse.
+ **WorkflowWorker.java** --contient le gestionnaire de flux de travail (décideur), qui interroge les tâches de décision et planifie de nouvelles activités.
+ **WorkflowStarter.java** --contient le démarreur du flux de travail, qui lance une nouvelle exécution de flux de travail, ce qui permettra à SWF de commencer à générer des tâches de décision et de flux de travail destinées à vos employés.
### Étapes communes pour tous les fichiers source
Tous les fichiers que vous créez pour héberger vos classes Java présentent quelques points communs. Par souci de concision, ces étapes *sont implicites chaque fois que vous ajoutez un nouveau fichier au projet* :
1. Créez le fichier dans le répertoire `src/main/java/aws/example/helloswf/` du projet.
1. Ajoutez une déclaration `package` au début de chaque fichier pour déclarer son espace de noms. L'exemple de projet utilise :
```
package aws.example.helloswf;
```
1. Ajoutez `import` des déclarations pour la [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe et pour plusieurs classes dans l'espace de `com.amazonaws.services.simpleworkflow.model` noms. Pour simplifier, nous utilisons :
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
### Enregistrement d'un domaine, et de types de flux de travail et d'activité
Nous allons commencer par créer une nouvelle classe exécutable, `HelloTypes.java`. Ce fichier contient des données partagées que les différentes parties de votre flux de travail doivent connaître, comme le nom et la version des types d'activité et de flux de travail, le nom du domaine et le nom de la liste de tâches.
1. Ouvrez votre éditeur de texte et créez le fichier `HelloTypes.java`, en ajoutant une déclaration de package et des déclarations d'importation conformément aux [étapes courantes](#swf-hello-common).
1. Déclarez la classe `HelloTypes` et fournissez-lui des valeurs à utiliser pour vos types d'activité et de flux de travail enregistrés :
```
public static final String DOMAIN = "HelloDomain";
public static final String TASKLIST = "HelloTasklist";
public static final String WORKFLOW = "HelloWorkflow";
public static final String WORKFLOW_VERSION = "1.0";
public static final String ACTIVITY = "HelloActivity";
public static final String ACTIVITY_VERSION = "1.0";
```
Ces valeurs seront utilisées dans l'ensemble du code.
1. Après les déclarations String, créez une instance de la [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe. Il s'agit de l'interface de base des Amazon SWF méthodes fournies par le AWS SDK pour Java.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
L'extrait précédent suppose que des informations d'identification temporaires sont associées au `default` profil. Si vous utilisez un autre profil, modifiez le code ci-dessus comme suit et *profile\$1name * remplacez-le par le nom du profil actuel.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder
.standard()
.withCredentials(new ProfileCredentialsProvider("profile_name"))
.withRegion(Regions.DEFAULT_REGION)
.build();
```
1. Ajoutez une nouvelle fonction pour enregistrer un domaine SWF. Un *domaine* est un conteneur logique pour différents types d'activité et de flux de travail SWF associés. Les composants SWF ne peuvent communiquer entre eux que s'ils sont situés dans le même domaine.
```
try {
System.out.println("** Registering the domain '" + DOMAIN + "'.");
swf.registerDomain(new RegisterDomainRequest()
.withName(DOMAIN)
.withWorkflowExecutionRetentionPeriodInDays("1"));
} catch (DomainAlreadyExistsException e) {
System.out.println("** Domain already exists!");
}
```
Lorsque vous enregistrez un domaine, vous lui attribuez un *nom* (un ensemble de 1 à 256 caractères `:` `/``|`, à l'exception des caractères de contrôle ou de la chaîne littérale « arn ») et une *période de conservation*, qui correspond au nombre de jours pendant lesquels les données d'historique d'exécution de votre flux de travail Amazon SWF seront conservées une fois l'exécution terminée. La période de conservation maximale pour les exécutions de flux de travail est de 90 jours. Pour plus d’informations, consultez [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html).
Si un domaine portant ce nom existe déjà, un [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html)est généré. Comme cela ne pose aucun problème si le domaine a déjà été créé, nous pouvons ignorer cette exception.
**Note**
Ce code illustre un schéma courant lorsque vous travaillez avec des AWS SDK pour Java méthodes. Les données de la méthode sont fournies par une classe de l'`simpleworkflow.model`espace de noms, que vous instanciez et renseignez à l'aide des méthodes chaînables. `0with*`
1. Ajoutez une fonction pour enregistrer un nouveau type d'activité. Une *activité* représente une unité de travail de votre flux de travail.
```
try {
System.out.println("** Registering the activity type '" + ACTIVITY +
"-" + ACTIVITY_VERSION + "'.");
swf.registerActivityType(new RegisterActivityTypeRequest()
.withDomain(DOMAIN)
.withName(ACTIVITY)
.withVersion(ACTIVITY_VERSION)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskScheduleToStartTimeout("30")
.withDefaultTaskStartToCloseTimeout("600")
.withDefaultTaskScheduleToCloseTimeout("630")
.withDefaultTaskHeartbeatTimeout("10"));
} catch (TypeAlreadyExistsException e) {
System.out.println("** Activity type already exists!");
}
```
Un type d'activité est identifié par un *nom* et une *version*, qui sont utilisés pour identifier l'activité de façon unique parmi toutes les autres activités du domaine dans lequel cette activité est enregistrée. Les activités contiennent également différents paramètres facultatifs, comme la liste de tâches par défaut utilisée pour recevoir des tâches et des données provenant de SWF, ainsi que différents délais d'expiration permettant d'appliquer des contraintes quant à la durée de l'exécution de différentes parties de l'activité. Pour plus d’informations, consultez [RegisterActivityTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterActivityTypeRequest.html).
**Note**
Toues les valeurs de délai sont spécifiées en *secondes*. Consultez la section [Types Amazon SWF de délais](https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-timeout-types.html) pour une description complète de l'impact des délais d'expiration sur l'exécution de vos flux de travail.
Si le type d'activité que vous essayez d'enregistrer existe déjà, un [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html)est généré. Ajoutez une fonction pour enregistrer un nouveau type de flux de travail. Un *flux de travail*, également appelé *décideur*, représente la logique de l'exécution de votre flux de travail.
\$1
```
try {
System.out.println("** Registering the workflow type '" + WORKFLOW +
"-" + WORKFLOW_VERSION + "'.");
swf.registerWorkflowType(new RegisterWorkflowTypeRequest()
.withDomain(DOMAIN)
.withName(WORKFLOW)
.withVersion(WORKFLOW_VERSION)
.withDefaultChildPolicy(ChildPolicy.TERMINATE)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskStartToCloseTimeout("30"));
} catch (TypeAlreadyExistsException e) {
System.out.println("** Workflow type already exists!");
}
```
\$1
À l'instar de types d'activité, les types de flux de travail sont identifiés par un *nom* et une *version*, et sont également associés à des délais d'expiration configurables. Pour plus d’informations, consultez [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
\$1
Si le type de flux de travail que vous essayez d'enregistrer existe déjà, un [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html)est généré. Enfin, rendez la classe exécutable en lui fournissant une méthode `main` qui enregistre à son tour le domaine, le type d'activité et le type de flux de travail :
\$1
```
registerDomain();
registerWorkflowType();
registerActivityType();
```
Vous pouvez [créer](#swf-hello-build) et [exécuter](#swf-hello-run-register) l'application maintenant pour exécuter le script d'enregistrement, ou continuer à coder les travaux d'activité et de flux de travail. Une fois le domaine, le flux de travail et l'activité enregistrés, vous n'avez pas besoin de les exécuter à nouveau. Ces types sont conservés jusqu'à ce que vous les désapprouviez vous-même.
### Implémentation du travail d'activité
Une *activité* est l'unité de travail de base d'un flux de travail. Un flux de travail fournit la logique en planifiant les activités à exécuter (ou les autres actions à effectuer) en réponse à des tâches de décision. Un flux de travail classique comporte généralement différentes activités qui peuvent s'exécuter de façon synchrone ou asynchrone, ou avec une combinaison de ces deux modes.
Le *travailleur d'activité* est le bit de code qui interroge les tâches d'activité générées par Amazon SWF en réponse aux décisions du flux de travail. Lorsque ce travail reçoit une tâche d'activité, il exécute l'activité correspondante et renvoie une réponse de réussite/échec au flux de travail.
Nous allons implémenter un travail d'activité simple qui traite une activité unique.
1. Ouvrez votre éditeur de texte et créez le fichier `ActivityWorker.java`, en ajoutant une déclaration de package et des déclarations d'importation conformément aux [étapes courantes](#swf-hello-common).
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
1. Ajoutez la `ActivityWorker` classe au fichier et donnez-lui un membre de données pour contenir un client SWF avec Amazon SWF lequel nous allons interagir :
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Ajoutez la méthode que nous utiliserons comme activité :
```
private static String sayHello(String input) throws Throwable {
return "Hello, " + input + "!";
}
```
L'activité prend simplement une chaîne, la combine en une salutation et renvoie le résultat. Même si les risques que cette activité lève une exception sont minimes, il est judicieux de concevoir des activités qui peuvent générer une erreur en cas de problème.
1. Ajoutez une méthode `main` que nous utiliserons comme méthode d'interrogation des tâches d'activité. Nous démarrons cette méthode en ajoutant du code pour rechercher des tâches d'activité dans la liste des tâches :
```
System.out.println("Polling for an activity task from the tasklist '"
+ HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
ActivityTask task = swf.pollForActivityTask(
new PollForActivityTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(
new TaskList().withName(HelloTypes.TASKLIST)));
String task_token = task.getTaskToken();
```
L'activité reçoit les tâches Amazon SWF en appelant la `pollForActivityTask` méthode du client SWF, en spécifiant le domaine et la liste de tâches à utiliser dans le fichier transmis [PollForActivityTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForActivityTaskRequest.html).
Une fois qu'une tâche est reçue, nous récupérons un identificateur unique pour celle-ci en appelant la méthode `getTaskToken` de la tâche.
1. Ensuite, écrivez du code pour traiter les tâches qui arrivent. Ajoutez ce qui suit à votre méthode `main` juste après le code qui recherche la tâche et récupère son jeton.
```
if (task_token != null) {
String result = null;
Throwable error = null;
try {
System.out.println("Executing the activity task with input '" +
task.getInput() + "'.");
result = sayHello(task.getInput());
} catch (Throwable th) {
error = th;
}
if (error == null) {
System.out.println("The activity task succeeded with result '"
+ result + "'.");
swf.respondActivityTaskCompleted(
new RespondActivityTaskCompletedRequest()
.withTaskToken(task_token)
.withResult(result));
} else {
System.out.println("The activity task failed with the error '"
+ error.getClass().getSimpleName() + "'.");
swf.respondActivityTaskFailed(
new RespondActivityTaskFailedRequest()
.withTaskToken(task_token)
.withReason(error.getClass().getSimpleName())
.withDetails(error.getMessage()));
}
}
```
Si le jeton de la tâche n'est pas `null`, nous pouvons commencer à exécuter la méthode d'activité (`sayHello`) en lui fournissant les données d'entrée qui ont été envoyées avec la tâche.
Si la tâche *a abouti* (aucune erreur n'a été générée), le travailleur répond au SWF en appelant la `respondActivityTaskCompleted` méthode du client SWF avec un [RespondActivityTaskCompletedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskCompletedRequest.html)objet contenant le jeton de tâche et les données de résultat de l'activité.
En revanche, si la tâche *échoue*, nous répondons en appelant la `respondActivityTaskFailed` méthode avec un [RespondActivityTaskFailedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskFailedRequest.html)objet, en lui transmettant le jeton de tâche et les informations relatives à l'erreur.
**Note**
Cette activité ne s'arrêtera pas correctement si elle est supprimée. Même si cela dépasse le cadre de ce didacticiel, une autre implémentation de ce travail d'activité est fournie dans la rubrique connexe [Arrêt normal des travaux d'activité et de flux de travail](swf-graceful-shutdown.md).
### Implémentation du travail de flux de travail
La logique de flux de travail est située dans un élément de code appelé **travail de flux de travail**. Le responsable du flux de travail interroge les tâches décisionnelles envoyées par le domaine, et Amazon SWF dans la liste de tâches par défaut, auprès duquel le type de flux de travail a été enregistré.
Lorsque le travail de flux de travail reçoit une tâche, il prend une décision (il s'agit généralement de décider s'il faut ou non planifier une nouvelle activité) et exécute une action appropriée (par exemple, planifier l'activité).
1. Ouvrez votre éditeur de texte et créez le fichier `WorkflowWorker.java`, en ajoutant une déclaration de package et des déclarations d'importation conformément aux [étapes courantes](#swf-hello-common).
1. Ajoutez quelques déclarations d'importation supplémentaires au fichier :
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
```
1. Déclarez la `WorkflowWorker` classe et créez une instance de la [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe utilisée pour accéder aux méthodes SWF.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Ajoutez la méthode `main`. Cette méthode exécute une boucle continue en recherchant les tâches de décision à l'aide de la méthode `pollForDecisionTask` du client SWF. Le [PollForDecisionTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForDecisionTaskRequest.html)fournit les détails.
```
PollForDecisionTaskRequest task_request =
new PollForDecisionTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(new TaskList().withName(HelloTypes.TASKLIST));
while (true) {
System.out.println(
"Polling for a decision task from the tasklist '" +
HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
DecisionTask task = swf.pollForDecisionTask(task_request);
String taskToken = task.getTaskToken();
if (taskToken != null) {
try {
executeDecisionTask(taskToken, task.getEvents());
} catch (Throwable th) {
th.printStackTrace();
}
}
}
```
Une fois qu'une tâche est reçue, nous appelons sa méthode `getTaskToken` qui renvoie une chaîne permettant d'identifier la tâche. Si le jeton renvoyé ne l'est pas`null`, nous le traitons ensuite dans la `executeDecisionTask` méthode, en lui transmettant le jeton de tâche et la liste des [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)objets envoyés avec la tâche.
1. Ajoutez la méthode `executeDecisionTask`, en prenant le jeton de la tâche (un élément `String`) et la liste `HistoryEvent`.
```
List decisions = new ArrayList();
String workflow_input = null;
int scheduled_activities = 0;
int open_activities = 0;
boolean activity_completed = false;
String result = null;
```
Nous configurons également des membres de données pour suivre des éléments comme :
+ Une liste d'objets [Decision](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) utilisés pour signaler les résultats du traitement de la tâche.
+ Une chaîne pour contenir les entrées du flux de travail fournies par l'événement WorkflowExecutionStarted « »
+ Un comptage des activités planifiées et ouvertes (en cours d'exécution) pour éviter de planifier la même activité lorsque celle-ci a déjà été planifiée ou est en cours d'exécution.
+ Une valeur booléenne pour indiquer que l'activité est terminée.
+ Une chaîne pour stocker les résultats de l'activité, qui sera renvoyée en tant que résultat de notre flux de travail.
1. Ajoutez ensuite du code à `executeDecisionTask` pour traiter les objets `HistoryEvent` qui ont été envoyés avec la tâche, en fonction du type d'événement signalé par la méthode `getEventType`.
```
System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
System.out.println(" " + event);
switch(event.getEventType()) {
case "WorkflowExecutionStarted":
workflow_input =
event.getWorkflowExecutionStartedEventAttributes()
.getInput();
break;
case "ActivityTaskScheduled":
scheduled_activities++;
break;
case "ScheduleActivityTaskFailed":
scheduled_activities--;
break;
case "ActivityTaskStarted":
scheduled_activities--;
open_activities++;
break;
case "ActivityTaskCompleted":
open_activities--;
activity_completed = true;
result = event.getActivityTaskCompletedEventAttributes()
.getResult();
break;
case "ActivityTaskFailed":
open_activities--;
break;
case "ActivityTaskTimedOut":
open_activities--;
break;
}
}
System.out.println("]");
```
Dans le cadre de notre flux de travail, voici les éléments qui présentent le plus d'intérêt pour nous :
+ l'événement « WorkflowExecutionStarted », qui indique que l'exécution du flux de travail a commencé (ce qui signifie généralement que vous devez exécuter la première activité du flux de travail) et qui fournit l'entrée initiale fournie au flux de travail. Dans ce cas, il s'agit de la partie nom de notre salutation. Cet événement est donc enregistré dans une chaîne à utiliser lors de la planification de l'activité à exécuter.
+ l'événement ActivityTaskCompleted « », qui est envoyé une fois l'activité planifiée terminée. Les données d'événement comprennent également la valeur de retour de l'activité terminée. Comme nous n'avons qu'une seule activité, nous utiliserons cette valeur comme résultat de la totalité du flux de travail.
Les autres types d'événement peuvent être utilisés s'ils sont nécessaires pour votre flux de travail. Consultez la description [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)de la classe pour plus d'informations sur chaque type d'événement.
\$1 REMARQUE : Les chaînes de caractères dans `switch` les instructions ont été introduites dans Java 7. Si vous utilisez une version antérieure de Java, vous pouvez utiliser la [EventType](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/model/EventType.html)classe pour convertir le résultat `String` renvoyé par en `history_event.getType()` une valeur enum, puis de nouveau en a `String` si nécessaire :
```
EventType et = EventType.fromValue(event.getEventType());
```
1. Après l'instruction `switch`, ajoutez du code pour répondre avec une *décision* appropriée en fonction de la tâche qui a été reçue.
```
if (activity_completed) {
decisions.add(
new Decision()
.withDecisionType(DecisionType.CompleteWorkflowExecution)
.withCompleteWorkflowExecutionDecisionAttributes(
new CompleteWorkflowExecutionDecisionAttributes()
.withResult(result)));
} else {
if (open_activities == 0 && scheduled_activities == 0) {
ScheduleActivityTaskDecisionAttributes attrs =
new ScheduleActivityTaskDecisionAttributes()
.withActivityType(new ActivityType()
.withName(HelloTypes.ACTIVITY)
.withVersion(HelloTypes.ACTIVITY_VERSION))
.withActivityId(UUID.randomUUID().toString())
.withInput(workflow_input);
decisions.add(
new Decision()
.withDecisionType(DecisionType.ScheduleActivityTask)
.withScheduleActivityTaskDecisionAttributes(attrs));
} else {
// an instance of HelloActivity is already scheduled or running. Do nothing, another
// task will be scheduled once the activity completes, fails or times out
}
}
System.out.println("Exiting the decision task with the decisions " + decisions);
```
+ Si l'activité n'a pas encore été planifiée, nous répondons par une `ScheduleActivityTask` décision qui fournit des informations sous [ScheduleActivityTaskDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleActivityTaskDecisionAttributes.html)forme de structure sur l'activité à planifier ensuite, y compris les Amazon SWF données à envoyer à l'activité. Amazon SWF
+ Si l'activité est terminée, nous considérons que l'ensemble du flux de travail est terminé et répondons par une `CompletedWorkflowExecution` décision, en remplissant une [CompleteWorkflowExecutionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/CompleteWorkflowExecutionDecisionAttributes.html)structure fournissant des détails sur le flux de travail terminé. Dans ce cas, nous renvoyons le résultat de l'activité.
Dans les deux cas, les informations de décision sont ajoutées à la liste `Decision` qui a été déclarée en haut de la méthode.
1. Terminez la tâche de décision en renvoyant la liste des objets `Decision` collectés pendant le traitement de la tâche. Ajoutez ce code à la fin de la méthode `executeDecisionTask` que nous avons écrite :
```
swf.respondDecisionTaskCompleted(
new RespondDecisionTaskCompletedRequest()
.withTaskToken(taskToken)
.withDecisions(decisions));
```
La méthode `respondDecisionTaskCompleted` du client SWF prend le jeton de tâche qui identifie la tâche, ainsi que la liste d'objets `Decision`.
### Implémentation du démarreur de flux de travail
Pour finir, nous allons écrire du code pour démarrer l'exécution du flux de travail.
1. Ouvrez votre éditeur de texte et créez le fichier `WorkflowStarter.java`, en ajoutant une déclaration de package et des déclarations d'importation conformément aux [étapes courantes](#swf-hello-common).
1. Ajoutez la classe `WorkflowStarter` :
```
package aws.example.helloswf;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
public class WorkflowStarter {
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
public static final String WORKFLOW_EXECUTION = "HelloWorldWorkflowExecution";
public static void main(String[] args) {
String workflow_input = "{SWF}";
if (args.length > 0) {
workflow_input = args[0];
}
System.out.println("Starting the workflow execution '" + WORKFLOW_EXECUTION +
"' with input '" + workflow_input + "'.");
WorkflowType wf_type = new WorkflowType()
.withName(HelloTypes.WORKFLOW)
.withVersion(HelloTypes.WORKFLOW_VERSION);
Run run = swf.startWorkflowExecution(new StartWorkflowExecutionRequest()
.withDomain(HelloTypes.DOMAIN)
.withWorkflowType(wf_type)
.withWorkflowId(WORKFLOW_EXECUTION)
.withInput(workflow_input)
.withExecutionStartToCloseTimeout("90"));
System.out.println("Workflow execution started with the run id '" +
run.getRunId() + "'.");
}
}
```
La classe `WorkflowStarter` est constituée d'une seule méthode, `main`, qui prend un argument facultatif transmis dans la ligne de commande en tant que données d'entrée pour le flux de travail.
La méthode client SWF prend un [StartWorkflowExecutionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/StartWorkflowExecutionRequest.html)objet en entrée. `startWorkflowExecution` Ici, en plus de spécifier le domaine et le type de flux de travail à exécuter, nous lui fournissons :
+ un nom d'exécution de flux de travail lisible par l'utilisateur ;
+ des données d'entrée de flux de travail (fournies dans la ligne de commande dans notre exemple) ;
+ une valeur de délai d'expiration qui représente la durée, en secondes, que l'exécution de la totalité du flux de travail doit respecter.
L'objet [Run](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Run.html) qui `startWorkflowExecution` renvoie fournit un *ID d'exécution*, une valeur qui peut être utilisée pour identifier cette exécution de flux de travail particulière dans l'historique Amazon SWF de vos exécutions de flux de travail.
\$1 REMARQUE : L'ID d'exécution est généré par Amazon SWF et *n'est pas* le même que le nom d'exécution du flux de travail que vous transmettez au démarrage de l'exécution du flux de travail.
## Génération de l'exemple
Pour générer l'exemple de projet avec Maven, accédez au répertoire `helloswf` et tapez :
```
mvn package
```
Le fichier `helloswf-1.0.jar` résultant est généré dans le répertoire `target`.
## Exécution de l'exemple
L'exemple est constitué de quatre classes exécutables distinctes qui sont exécutées indépendamment les unes des autres.
**Note**
Si vous utilisez un système Linux, macOS ou Unix, vous pouvez tous les exécuter, l'un après l'autre, dans une seule fenêtre de terminal. Si vous exécutez Windows, vous devez ouvrir deux instances de ligne de commande supplémentaires et accéder au répertoire `helloswf` dans chacune d'entre elles.
### Définition du chemin de classe Java
Bien que Maven ait géré les dépendances pour vous, pour exécuter cet exemple, vous devez fournir la bibliothèque du AWS SDK et ses dépendances sur votre chemin de classe Java. Vous pouvez définir la variable d'`CLASSPATH`environnement sur l'emplacement des bibliothèques de votre AWS SDK et sur le `third-party/lib` répertoire du SDK, qui inclut les dépendances nécessaires :
```
export CLASSPATH='target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/*'
java example.swf.hello.HelloTypes
```
ou utilisez l'`-cp`option de la **` java `**commande pour définir le chemin de classe lors de l'exécution de chaque application.
```
java -cp target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/* \
example.swf.hello.HelloTypes
```
C'est à vous de décider ce que vous souhaitez utiliser. Si vous n'avez eu aucun problème à créer le code, essayez d'exécuter les exemples et obtenez une série d'erreurs « NoClassDefFound », probablement parce que le chemin de classe n'est pas correctement défini.
### Enregistrement du domaine, et des types de flux de travail et d'activité
Avant d'exécuter vos travaux et le démarreur de flux de travail, vous devez enregistrer le domaine, ainsi que vos types de flux de travail et d'activité. Le code pour ce faire a été implémenté dans le [flux de travail et les types d'activité d'enregistrement d'un domaine](#swf-hello-hellotypes).
Après la génération, et si vous avez [défini CLASSPATH](#swf-hello-set-classpath), vous pouvez exécuter le code d'enregistrement en lançant la commande :
```
echo 'Supply the name of one of the example classes as an argument.'
```
### Démarrage des travaux d'activité et de flux de travail
Maintenant que les types ont été enregistrés, vous pouvez démarrer les travaux d'activité et de flux de travail. Ils continueront à s'exécuter et à rechercher des tâches jusqu'à ce qu'elles soient supprimées. Vous devez donc soit les exécuter dans des fenêtres de terminal distinctes, soit, si vous utilisez Linux, macOS ou Unix, vous pouvez utiliser l'`&`opérateur pour que chacun d'eux génère un processus distinct lors de son exécution.
```
echo 'If there are arguments to the class, put them in quotes after the class name.'
exit 1
```
Si vous exécutez ces commandes dans des fenêtres distinctes, omettez l'opérateur `&` final dans chaque ligne.
### Démarrage de l'exécution de flux de travail
Maintenant que vos travaux d'activité et de flux de travail exécutent l'interrogation, vous pouvez démarrer l'exécution du flux de travail. Ce processus s'exécute jusqu'à ce que le flux de travail renvoie un état terminé. Vous devez l'exécuter dans une nouvelle fenêtre de terminal (sauf si vous avez exécuté vos travaux en tant que nouveaux processus générés à l'aide de l'opérateur `&`).
```
fi
```
**Note**
Si vous souhaitez fournir vos propres données d'entrée, qui seront transmises d'abord au flux de travail, puis à l'activité, ajoutez-les à la ligne de commande. Par exemple :
```
echo "## Running $className..."
```
Une fois que vous avez démarré l'exécution du flux de travail, vous devez commencer à voir la sortie fournie par les deux travaux et par l'exécution de flux de travail proprement dite. Lorsque le flux de travail est terminé, sa sortie est affichée à l'écran.
## Exécution de la source pour cet exemple
Vous pouvez parcourir la [source complète](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java/example_code/swf) de cet exemple sur Github dans le *aws-java-developer-guide*référentiel.
## Pour plus d'informations
+ Les travaux présentés ici peuvent entraîner la perte des tâches s'ils sont fermés alors que l'interrogation du flux de travail est encore en cours. Pour découvrir comment fermer correctement les travaux, consultez [Arrêt normal des travaux d'activité et de flux de travail](swf-graceful-shutdown.md).
+ Pour en savoir plus Amazon SWF, rendez-vous sur la page d'[Amazon SWF](https://aws.amazon.com/swf/)accueil ou consultez le [guide du Amazon SWF développeur](https://docs.aws.amazon.com/amazonswf/latest/developerguide/).
+ Vous pouvez utiliser AWS Flow Framework for Java pour écrire des flux de travail plus complexes dans un style Java élégant à l'aide d'annotations. Pour en savoir plus, consultez le [guide du développeur AWS Flow Framework pour Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
# Lambda Tâches
En alternative aux Amazon SWF activités ou en conjonction avec celles-ci, vous pouvez utiliser les fonctions [Lambda](https://aws.amazon.com/lambda/) pour représenter les unités de travail dans vos flux de travail et les planifier de la même manière que les activités.
Cette rubrique explique comment implémenter des Amazon SWF Lambda tâches à l'aide du AWS SDK pour Java. Pour plus d'informations sur Lambda les tâches en général, consultez la section [AWS Lambda Tâches](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html) du guide du Amazon SWF développeur.
## Configuration d'un rôle IAM inter-services pour exécuter votre fonction Lambda
Avant de Amazon SWF pouvoir exécuter votre Lambda fonction, vous devez configurer un rôle IAM pour Amazon SWF autoriser l'exécution de Lambda fonctions en votre nom. Pour obtenir des informations complètes sur la procédure à suivre, consultez la section [AWS Lambda Tâches](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html).
Vous aurez besoin du nom de ressource Amazon (ARN) de ce rôle IAM lorsque vous enregistrez un flux de travail qui utilisera Lambda des tâches.
## Création d'une Lambda fonction
Vous pouvez écrire Lambda des fonctions dans différents langages, y compris Java. Pour obtenir des informations complètes sur la création, le déploiement et l'utilisation Lambda des fonctions, consultez le [guide du AWS Lambda développeur](https://docs.aws.amazon.com/lambda/latest/dg/).
**Note**
Quelle que soit la langue que vous utilisez pour écrire votre Lambda fonction, celle-ci peut être planifiée et exécutée par *n'importe quel* Amazon SWF flux de travail, quelle que soit la langue dans laquelle le code de votre flux de travail est écrit. Amazon SWF gère les détails de l'exécution de la fonction et de la transmission des données depuis et vers celle-ci.
Voici une Lambda fonction simple qui pourrait être utilisée à la place de l'activité de [création d'une Amazon SWF application simple](swf-hello.md).
+ Cette version est écrite et peut être saisie directement à l'aide du [AWS Management Console](https://console.aws.amazon.com/console/home): JavaScript
```
exports.handler = function(event, context) {
context.succeed("Hello, " + event.who + "!");
};
```
+ Voici la même fonction écrite en Java, que vous pouvez également déployer et exécuter sur Lambda :
```
package example.swf.hellolambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.util.json.JSONException;
import com.amazonaws.util.json.JSONObject;
public class SwfHelloLambdaFunction implements RequestHandler {
@Override
public Object handleRequest(Object input, Context context) {
String who = "{SWF}";
if (input != null) {
JSONObject jso = null;
try {
jso = new JSONObject(input.toString());
who = jso.getString("who");
} catch (JSONException e) {
e.printStackTrace();
}
}
return ("Hello, " + who + "!");
}
}
```
**Note**
Pour en savoir plus sur le déploiement de fonctions Java sur Lambda, consultez la section [Création d'un package de déploiement (Java)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html) dans le guide du AWS Lambda développeur. Vous voudrez également consulter la section intitulée [Modèle de programmation pour la création de Lambda fonctions en Java](https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html).
Lambda les fonctions prennent un *événement* ou un objet *d'entrée* comme premier paramètre, et un objet de *contexte* comme second, qui fournit des informations sur la demande d'exécution de la Lambda fonction. Cette fonction particulière attend une entrée au format JSON, avec un champ `who` défini sur le nom utilisé pour créer la salutation.
## Enregistrer un flux de travail à utiliser avec Lambda
Pour qu'un flux de travail Lambda planifie une fonction, vous devez fournir le nom du rôle IAM qui autorise Amazon SWF l'appel de Lambda fonctions. Vous pouvez le définir lors de l'enregistrement du flux de travail en utilisant les `setDefaultLambdaRole` méthodes `withDefaultLambdaRole` ou de [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
```
System.out.println("** Registering the workflow type '" + WORKFLOW + "-" + WORKFLOW_VERSION
+ "'.");
try {
swf.registerWorkflowType(new RegisterWorkflowTypeRequest()
.withDomain(DOMAIN)
.withName(WORKFLOW)
.withDefaultLambdaRole(lambda_role_arn)
.withVersion(WORKFLOW_VERSION)
.withDefaultChildPolicy(ChildPolicy.TERMINATE)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskStartToCloseTimeout("30"));
}
catch (TypeAlreadyExistsException e) {
```
## Planifier une Lambda tâche
Planifier une Lambda tâche est similaire à la planification d'une activité. Vous fournissez une [décision](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) avec un « ScheduleLambdaFunction » [DecisionType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DecisionType.html)et avec [ScheduleLambdaFunctionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleLambdaFunctionDecisionAttributes.html).
```
running_functions == 0 && scheduled_functions == 0) {
AWSLambda lam = AWSLambdaClientBuilder.defaultClient();
GetFunctionConfigurationResult function_config =
lam.getFunctionConfiguration(
new GetFunctionConfigurationRequest()
.withFunctionName("HelloFunction"));
String function_arn = function_config.getFunctionArn();
ScheduleLambdaFunctionDecisionAttributes attrs =
new ScheduleLambdaFunctionDecisionAttributes()
.withId("HelloFunction (Lambda task example)")
.withName(function_arn)
.withInput(workflow_input);
decisions.add(
```
Dans le`ScheduleLambdaFuntionDecisionAttributes`, vous devez fournir un *nom*, qui est l'ARN de la Lambda fonction à appeler, et un *identifiant*, qui est le nom qui Amazon SWF sera utilisé pour identifier la Lambda fonction dans les journaux d'historique.
Vous pouvez également fournir une *entrée* facultative pour la Lambda fonction et définir sa valeur de *délai de début à fin*, qui est le nombre de secondes pendant lesquelles la Lambda fonction est autorisée à s'exécuter avant de générer un `LambdaFunctionTimedOut` événement.
**Note**
Ce code utilise le [AWSLambdaclient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambdaClient.html) pour récupérer l'ARN de la Lambda fonction, en fonction du nom de la fonction. Vous pouvez utiliser cette technique pour éviter de coder en dur l'ARN complet (qui inclut votre Compte AWS identifiant) dans votre code.
## Gérez les événements de la fonction Lambda dans votre décideur
Lambda les tâches génèrent un certain nombre d'événements sur lesquels vous pouvez agir lorsque vous recherchez des tâches décisionnelles dans votre flux de travail, correspondant au cycle de vie de votre Lambda tâche, avec des [EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html)valeurs telles que `LambdaFunctionScheduled``LambdaFunctionStarted`, et`LambdaFunctionCompleted`. Si la Lambda fonction échoue ou prend plus de temps à s'exécuter que le délai d'expiration défini, vous recevrez un type d'`LambdaFunctionTimedOut`événement `LambdaFunctionFailed` ou, respectivement.
```
boolean function_completed = false;
String result = null;
System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
System.out.println(" " + event);
EventType event_type = EventType.fromValue(event.getEventType());
switch(event_type) {
case WorkflowExecutionStarted:
workflow_input =
event.getWorkflowExecutionStartedEventAttributes()
.getInput();
break;
case LambdaFunctionScheduled:
scheduled_functions++;
break;
case ScheduleLambdaFunctionFailed:
scheduled_functions--;
break;
case LambdaFunctionStarted:
scheduled_functions--;
running_functions++;
break;
case LambdaFunctionCompleted:
running_functions--;
function_completed = true;
result = event.getLambdaFunctionCompletedEventAttributes()
.getResult();
break;
case LambdaFunctionFailed:
running_functions--;
break;
case LambdaFunctionTimedOut:
running_functions--;
break;
```
## Recevez le résultat de votre Lambda fonction
Lorsque vous recevez un `LambdaFunctionCompleted`[EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html), you can retrieve your 0 function’s return value by first calling `getLambdaFunctionCompletedEventAttributes` on [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)pour obtenir un [LambdaFunctionCompletedEventAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/LambdaFunctionCompletedEventAttributes.html)objet, puis que vous appelez sa `getResult` méthode pour récupérer le résultat de la Lambda fonction :
```
LambdaFunctionCompleted:
running_functions--;
```
## Exécution de la source pour cet exemple
Vous pouvez parcourir la *source complète : github : `< awsdocs/aws-java-developer-guide/tree/master/doc\$1source/snippets/helloswf \$1lambda/>* pour cet exemple sur Github dans le dépôt. *aws-java-developer-guide*
# Arrêt normal des travaux d'activité et de flux de travail
La rubrique [Création d'une Amazon SWF application simple](swf-hello.md) a fourni une implémentation complète d'une application de flux de travail simple composée d'une application d'enregistrement, d'un gestionnaire d'activité et de flux de travail et d'un démarreur de flux de travail.
Les classes de travailleurs sont conçues pour fonctionner en continu, en interrogeant les tâches envoyées Amazon SWF afin de gérer des activités ou de prendre des décisions. Une fois qu'une demande de sondage est faite, Amazon SWF enregistre le sondeur et tente de lui attribuer une tâche.
Si le travailleur du flux de travail est licencié au cours d'un long sondage, il Amazon SWF peut toujours essayer d'envoyer une tâche au travailleur licencié, ce qui entraîne une perte de tâche (jusqu'à ce que la tâche expire).
Un moyen de gérer cette situation consiste à attendre que toutes les demandes d'interrogation longue envoient un retour avant que le travail ne se termine.
Dans cette rubrique, nous allons réécrire le travail d'activité depuis `helloswf`, à l'aide des hooks d'arrêt de Java afin de tenter un arrêt approprié du travail d'activité.
Voici le code complet :
```
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.ActivityTask;
import com.amazonaws.services.simpleworkflow.model.PollForActivityTaskRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskCompletedRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskFailedRequest;
import com.amazonaws.services.simpleworkflow.model.TaskList;
public class ActivityWorkerWithGracefulShutdown {
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
private static final CountDownLatch waitForTermination = new CountDownLatch(1);
private static volatile boolean terminate = false;
private static String executeActivityTask(String input) throws Throwable {
return "Hello, " + input + "!";
}
public static void main(String[] args) {
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
try {
terminate = true;
System.out.println("Waiting for the current poll request" +
" to return before shutting down.");
waitForTermination.await(60, TimeUnit.SECONDS);
}
catch (InterruptedException e) {
// ignore
}
}
});
try {
pollAndExecute();
}
finally {
waitForTermination.countDown();
}
}
public static void pollAndExecute() {
while (!terminate) {
System.out.println("Polling for an activity task from the tasklist '"
+ HelloTypes.TASKLIST + "' in the domain '" +
HelloTypes.DOMAIN + "'.");
ActivityTask task = swf.pollForActivityTask(new PollForActivityTaskRequest()
.withDomain(HelloTypes.DOMAIN)
.withTaskList(new TaskList().withName(HelloTypes.TASKLIST)));
String taskToken = task.getTaskToken();
if (taskToken != null) {
String result = null;
Throwable error = null;
try {
System.out.println("Executing the activity task with input '"
+ task.getInput() + "'.");
result = executeActivityTask(task.getInput());
}
catch (Throwable th) {
error = th;
}
if (error == null) {
System.out.println("The activity task succeeded with result '"
+ result + "'.");
swf.respondActivityTaskCompleted(
new RespondActivityTaskCompletedRequest()
.withTaskToken(taskToken)
.withResult(result));
}
else {
System.out.println("The activity task failed with the error '"
+ error.getClass().getSimpleName() + "'.");
swf.respondActivityTaskFailed(
new RespondActivityTaskFailedRequest()
.withTaskToken(taskToken)
.withReason(error.getClass().getSimpleName())
.withDetails(error.getMessage()));
}
}
}
}
}
```
Dans cette version, le code d'interrogation qui était dans la fonction `main` de la version d'origine a été déplacé dans sa propre méthode `pollAndExecute`.
La `main` fonction utilise désormais un hook [CountDownLatch](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CountDownLatch.html)en conjonction avec un [hook d'arrêt](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Runtime.html) pour faire attendre jusqu'à 60 secondes après la demande de fin du thread avant de le laisser s'arrêter.
# Enregistrement de domaines
Chaque flux de travail et chaque activité [Amazon SWF](https://aws.amazon.com/swf/)doivent être exécutés dans un *domaine*.
1. Créez un nouvel [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html)objet en lui fournissant au moins le nom de domaine et la période de conservation de l'exécution du flux de travail (ces deux paramètres sont obligatoires).
1. Appelez la méthode [AmazonSimpleWorkflowClient.registerDomain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html#registerDomain-com.amazonaws.services.simpleworkflow.model.RegisterDomainRequest-) avec l'objet. *RegisterDomainRequest*
1. Vérifiez [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html)si le domaine que vous demandez existe déjà (auquel cas, aucune action n'est généralement requise).
Le code suivant illustre la procédure :
```
public void register_swf_domain(AmazonSimpleWorkflowClient swf, String name)
{
RegisterDomainRequest request = new RegisterDomainRequest().withName(name);
request.setWorkflowExecutionRetentionPeriodInDays("10");
try
{
swf.registerDomain(request);
}
catch (DomainAlreadyExistsException e)
{
System.out.println("Domain already exists!");
}
}
```
# Affichage des domaines
Vous pouvez répertorier les [Amazon SWF](https://aws.amazon.com/swf/)domaines associés à votre compte et à votre AWS région par type d'enregistrement.
1. Créez un [ListDomainsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ListDomainsRequest.html)objet et spécifiez le statut d'enregistrement des domaines qui vous intéressent. Cela est obligatoire.
1. Appelez [AmazonSimpleWorkflowClient.ListDomains](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html#listDomains-com.amazonaws.services.simpleworkflow.model.ListDomainsRequest-) avec l'objet. *ListDomainRequest* Les résultats sont fournis dans un [DomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html)objet.
1. Appelez [getDomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html#getDomainInfos--)l'objet renvoyé pour obtenir une liste d'[DomainInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html)objets.
1. Appelez [GetName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html#getName--) sur chaque *DomainInfo*objet pour obtenir son nom.
Le code suivant illustre la procédure :
```
public void list_swf_domains(AmazonSimpleWorkflowClient swf)
{
ListDomainsRequest request = new ListDomainsRequest();
request.setRegistrationStatus("REGISTERED");
DomainInfos domains = swf.listDomains(request);
System.out.println("Current Domains:");
for (DomainInfo di : domains.getDomainInfos())
{
System.out.println(" * " + di.getName());
}
}
```
# Exemples de code inclus dans le SDK
Il AWS SDK pour Java est fourni avec des exemples de code illustrant de nombreuses fonctionnalités du SDK dans des programmes exécutables et constructibles. Vous pouvez les étudier ou les modifier pour implémenter vos propres AWS solutions à l'aide du AWS SDK pour Java.
## Comment obtenir les exemples
Les exemples de AWS SDK pour Java code sont fournis dans le répertoire des *exemples* du SDK. Si vous avez téléchargé et installé le SDK à l'aide des informations de [la section Configurer le AWS SDK pour Java, les](setup-install.md) exemples se trouvent déjà sur votre système.
Vous pouvez également consulter les derniers exemples du AWS SDK pour Java GitHub référentiel, dans le répertoire [src/samples](https://github.com/aws/aws-sdk-java/tree/master/src/samples).
## Génération et exécution d'exemples à l'aide de la ligne de commande
Les exemples incluent les scripts de génération [Ant](http://ant.apache.org/) afin que vous puissiez facilement les générer et les exécuter à partir de la ligne de commande. Chaque exemple contient aussi un fichier README au format HTML, qui comporte des informations propres à chaque exemple.
**Note**
Si vous parcourez l'exemple de code GitHub, cliquez sur le bouton **Raw** dans l'écran du code source lorsque vous consultez le fichier README.html de l'exemple. En mode brut, le code HTML s'affiche comme prévu dans votre navigateur.
### Prérequis
Avant d'exécuter l'un des AWS SDK pour Java exemples, vous devez définir vos AWS informations d'identification dans l'environnement ou avec le AWS CLI, comme indiqué dans [Configurer les AWS informations d'identification et la région pour le développement](setup-credentials.md). Les exemples utilisent le fournisseur d'informations d'identification par défaut chaque fois que possible. En définissant vos informations d'identification de cette manière, vous pouvez éviter la pratique risquée qui consiste à les insérer dans des fichiers du répertoire du code source (où elles peuvent être enregistrées par inadvertance et partagées publiquement). AWS
### Exécution des exemples
1. Accédez au répertoire contenant l'exemple de code. Par exemple, si vous vous trouvez dans le répertoire racine du téléchargement du AWS SDK et que vous souhaitez exécuter l'`AwsConsoleApp`exemple, vous devez taper :
```
cd samples/AwsConsoleApp
```
1. Générez et exécutez l'exemple avec Ant. Comme, par défaut, la cible de génération exécute les deux actions, il vous suffit d'entrer l'instruction suivante :
```
ant
```
L'échantillon imprime les informations sur une sortie standard, par exemple :
```
===========================================
Welcome to the {AWS} Java SDK!
===========================================
You have access to 4 Availability Zones.
You have 0 {EC2} instance(s) running.
You have 13 Amazon SimpleDB domain(s) containing a total of 62 items.
You have 23 {S3} bucket(s), containing 44 objects with a total size of 154767691 bytes.
```
## Génération et exécution des exemples à l'aide de l'IDE Eclipse
Si vous utilisez le AWS Toolkit for Eclipse, vous pouvez également démarrer un nouveau projet dans Eclipse sur la base du SDK AWS SDK pour Java ou ajouter le SDK à un projet Java existant.
### Prérequis
Après l'avoir installé AWS Toolkit for Eclipse, nous vous recommandons de configurer le Toolkit avec vos informations d'identification de sécurité. Vous pouvez le faire à tout moment en choisissant **Préférences** dans le menu **Fenêtre** d'Eclipse, puis en choisissant la section ** AWS Boîte à outils**.
### Exécution des exemples
1. Ouvrez Eclipse.
1. Créez un nouveau projet AWS Java. Dans Eclipse, dans le menu **File (Fichier)**, choisissez **New (Nouveau)**, puis cliquez sur **Project (Projet)**. L'Assistant **New Project (Nouveau projet)** s'ouvre.
1. Développez la ** AWS **catégorie, puis choisissez ** AWS Java Project**.
1. Choisissez **Suivant**. La page des paramètres du projet s'affiche.
1. Entrez un nom dans la zone **Project Name (Nom du projet)**. Le groupe AWS SDK pour Java Samples affiche les exemples disponibles dans le SDK, comme décrit précédemment.
1. Sélectionnez les exemples que vous voulez inclure dans votre projet en cochant chaque case correspondante.
1. Entrez vos AWS informations d'identification. Si vous l'avez déjà configuré AWS Toolkit for Eclipse avec vos informations d'identification, celles-ci sont automatiquement renseignées.
1. Choisissez **Finish** (Terminer). Le projet est créé et ajouté au **Project Explorer (Explorateur de projet)**.
1. Sélectionnez l'exemple de fichier `.java` que vous voulez exécuter. Par exemple, pour l' Amazon S3 échantillon, choisissez`S3Sample.java`.
1. Choisissez **Run (Exécuter)** dans le menu **Run (Exécuter)**.
1. Cliquez avec le bouton droit sur le projet dans **Project Explorer (Explorateur de projet)**, pointez vers **Build Path (Chemin de génération)**, puis choisissez **Add Libraries (Ajouter les bibliothèques)**.
1. Choisissez ** AWS Java SDK**, choisissez **Next**, puis suivez les instructions restantes à l'écran.