La AWS SDK per Java 1.x è stata raggiunta end-of-support il 31 dicembre 2025. Ti consigliamo di eseguire la migrazione a per continuare [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)a ricevere nuove funzionalità, miglioramenti della disponibilità e aggiornamenti di sicurezza.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS SDK per Java Codici di esempio
Questa sezione fornisce tutorial ed esempi sull'utilizzo della AWS SDK per Java v1 per programmare i servizi. AWS
Trova il codice sorgente per questi esempi e altri nel repository degli [esempi di codice](https://github.com/awsdocs/aws-doc-sdk-examples) di AWS documentazione su. GitHub
Per proporre un nuovo esempio di codice da far produrre al team addetto alla AWS documentazione, crea una nuova richiesta. Il team sta cercando di produrre esempi di codice che coprano scenari e casi d'uso più ampi rispetto ai semplici frammenti di codice che coprono solo le singole chiamate API. Per istruzioni, consulta le [linee guida per i contributi](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md) nel repository degli esempi di codice su.. GitHub
## AWS SDK per Java 2.x
Nel 2018, AWS ha rilasciato il. [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) Questa guida contiene istruzioni sull'utilizzo dell'SDK Java più recente insieme al codice di esempio.
**Nota**
Consultate [Documentazione e risorse aggiuntive](welcome.md#additional-resources) per altri esempi e risorse aggiuntive disponibili per AWS SDK per Java gli sviluppatori\$1
**Topics**
# CloudWatch Esempi di utilizzo di AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [CloudWatch](https://aws.amazon.com/cloudwatch/) utilizzando [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
Amazon CloudWatch monitora le tue Amazon Web Services (AWS) risorse e le applicazioni su cui esegui AWS in tempo reale. Puoi utilizzarlo CloudWatch per raccogliere e tenere traccia delle metriche, che sono variabili che puoi misurare per le tue risorse e applicazioni. CloudWatch gli allarmi inviano notifiche o apportano automaticamente modifiche alle risorse che stai monitorando in base a regole da te definite.
Per ulteriori informazioni in merito CloudWatch, consulta la [Guida per l'Amazon CloudWatch utente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Ottenere metriche da CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Pubblicazione di dati dei parametri personalizzati](examples-cloudwatch-publish-custom-metrics.md)
+ [Lavorare con gli CloudWatch allarmi](examples-cloudwatch-create-alarms.md)
+ [Utilizzo delle azioni di allarme in CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Invio di eventi a CloudWatch](examples-cloudwatch-send-events.md)
# Ottenere metriche da CloudWatch
## Elencazione dei parametri
Per elencare CloudWatch le metriche, crea un metodo [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsRequest.html)e AmazonCloudWatchClient chiama `listMetrics` il. Puoi utilizzare `ListMetricsRequest` per filtrare i parametri restituiti in base a spazio dei nomi, nome parametro o dimensioni.
**Nota**
Un elenco di metriche e dimensioni pubblicate dai AWS servizi è disponibile nella \$1https---docs-aws-amazon-com- AmazonCloudWatch -Latest-Monitoring-CW-Support-for-AWS-html\$1 [Amazon Metrics and Dimensions Reference] nella Guida per l'utente. CloudWatch Amazon CloudWatch
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
Le [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsResult.html)metriche vengono restituite in un `getMetrics` chiamando il relativo metodo. I risultati possono essere *paginati*. Per recuperare il successivo batch di risultati, chiamate `setNextToken` l'oggetto di richiesta originale con il valore restituito dal `getNextToken` metodo dell'`ListMetricsResult`oggetto e passate l'oggetto di richiesta modificato a un'altra chiamata a. `listMetrics`
## Ulteriori informazioni
+ [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html)nell' Amazon CloudWatch API Reference.
# Pubblicazione di dati dei parametri personalizzati
Alcuni AWS servizi pubblicano [le proprie metriche](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) in namespace che iniziano con "`AWS`" Puoi anche pubblicare dati metrici personalizzati utilizzando il tuo spazio dei nomi (purché non inizi con "«). `AWS`
## Pubblicare dati dei parametri personalizzati
Per pubblicare i tuoi dati metrici, chiama il metodo's con a. AmazonCloudWatchClient `putMetricData` [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricDataRequest.html) `PutMetricDataRequest`Devono includere lo spazio dei nomi personalizzato da utilizzare per i dati e le informazioni sul punto dati stesso in un oggetto. [MetricDatum](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/MetricDatum.html)
**Nota**
Non è possibile specificare uno spazio dei nomi che inizia con "». `AWS` I namespace che iniziano con "`AWS`" sono riservati all'uso da parte dei prodotti. Amazon Web Services
**Importazioni**
```
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;
```
**Codice**
```
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);
```
## Ulteriori informazioni
+ [Utilizzo delle Amazon CloudWatch metriche](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) nella Guida per l'utente. Amazon CloudWatch
+ [AWS Namespace nella Guida per l'utente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html). Amazon CloudWatch
+ [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)nell'API Reference. Amazon CloudWatch
# Lavorare con gli CloudWatch allarmi
## Creazione di un allarme
Per creare un allarme basato su una CloudWatch metrica, chiama il `putMetricAlarm` metodo AmazonCloudWatchClient's [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)compilando le condizioni di allarme.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
## Elencare allarmi
Per elencare gli CloudWatch allarmi che hai creato, chiama il `describeAlarms` metodo AmazonCloudWatchClient's con un [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsRequest.html)che puoi usare per impostare le opzioni relative al risultato.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
L'elenco degli allarmi può essere ottenuto `getMetricAlarms` chiamando il comando [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsResult.html)che viene restituito da. `describeAlarms`
I risultati possono essere *paginati*. Per recuperare il successivo batch di risultati, chiamate `setNextToken` l'oggetto di richiesta originale con il valore restituito dal `getNextToken` metodo dell'`DescribeAlarmsResult`oggetto e passate l'oggetto di richiesta modificato a un'altra chiamata a. `describeAlarms`
**Nota**
Puoi anche recuperare gli allarmi per una metrica specifica utilizzando il metodo's. AmazonCloudWatchClient `describeAlarmsForMetric` L'uso è simile a `describeAlarms`.
## Elimina allarmi
Per eliminare gli CloudWatch allarmi, chiama il `deleteAlarms` metodo AmazonCloudWatchClient's con uno [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DeleteAlarmsRequest.html)o più nomi di allarmi che desideri eliminare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DeleteAlarmsRequest request = new DeleteAlarmsRequest()
.withAlarmNames(alarm_name);
DeleteAlarmsResult response = cw.deleteAlarms(request);
```
## Ulteriori informazioni
+ [Creazione di Amazon CloudWatch allarmi nella Guida](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) per l'utente Amazon CloudWatch
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)nell' Amazon CloudWatch API Reference
+ [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html)nell' Amazon CloudWatch API Reference
+ [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DeleteAlarms.html)nell' Amazon CloudWatch API Reference
# Utilizzo delle azioni di allarme in CloudWatch
Utilizzando le azioni di CloudWatch allarme, è possibile creare allarmi che eseguono azioni come l'arresto automatico, la chiusura, il riavvio o il ripristino delle istanze. Amazon EC2
**Nota**
[Le azioni di allarme possono essere aggiunte a un allarme utilizzando il metodo's durante la [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)creazione di un allarme. `setAlarmActions`](examples-cloudwatch-create-alarms.md)
## Attivare le operazioni di allarme
Per abilitare le azioni di allarme per un CloudWatch allarme, chiama AmazonCloudWatchClient th's `enableAlarmActions` [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/EnableAlarmActionsRequest.html)inserendo uno o più nomi di allarmi di cui desideri abilitare le azioni.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
EnableAlarmActionsRequest request = new EnableAlarmActionsRequest()
.withAlarmNames(alarm);
EnableAlarmActionsResult response = cw.enableAlarmActions(request);
```
## Disattivare le operazioni di allarme
Per disabilitare le azioni di CloudWatch allarme di un allarme, AmazonCloudWatchClient chiama gli avvisi `disableAlarmActions` con [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DisableAlarmActionsRequest.html)uno o più nomi di allarmi di cui desideri disabilitare le azioni.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DisableAlarmActionsRequest request = new DisableAlarmActionsRequest()
.withAlarmNames(alarmName);
DisableAlarmActionsResult response = cw.disableAlarmActions(request);
```
## Ulteriori informazioni
+ [Crea allarmi per interrompere, terminare, riavviare o ripristinare un'istanza](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) nella Guida per l'utente Amazon CloudWatch
+ [PutMetricAlarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html)nel riferimento all'API Amazon CloudWatch
+ [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_EnableAlarmActions.html)nell' Amazon CloudWatch API Reference
+ [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DisableAlarmActions.html)nell' Amazon CloudWatch API Reference
# Invio di eventi a CloudWatch
CloudWatch Events fornisce un flusso quasi in tempo reale di eventi di sistema che descrivono le modifiche AWS delle risorse a Amazon EC2 istanze, Lambda funzioni, Kinesis flussi, Amazon ECS attività, macchine a Step Functions stati, Amazon SNS argomenti, Amazon SQS code o destinazioni integrate. Puoi abbinare gli eventi e instradarli verso una o più funzioni o stream target utilizzando regole semplici.
## Aggiunta di eventi
Per aggiungere CloudWatch eventi personalizzati, chiamate il `putEvents` metodo AmazonCloudWatchEventsClient's con un [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequest.html)oggetto che contiene uno o più [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequestEntry.html)oggetti che forniscono dettagli su ogni evento. Puoi specificare diversi parametri per la voce, ad esempio l'origine e il tipo di evento, le risorse associate all'evento e così via.
**Nota**
Puoi specificare un massimo di 10 eventi per chiamata a `putEvents`.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
## Aggiunta di regole
Per creare o aggiornare una regola, chiamate il `putRule` metodo AmazonCloudWatchEventsClient the's [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutRuleRequest.html)con a con il nome della regola e parametri facoltativi come il [modello di evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), il IAM ruolo da associare alla regola e un'[espressione di pianificazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) che descriva la frequenza di esecuzione della regola.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
## Aggiunta di target
I target sono le risorse che vengono invocate quando una regola viene attivata. Gli obiettivi di esempio includono Amazon EC2 istanze, Lambda funzioni, Kinesis flussi, Amazon ECS attività, macchine a Step Functions stati e destinazioni integrate.
Per aggiungere un obiettivo a una regola, chiama il `putTargets` metodo AmazonCloudWatchEventsClient's [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutTargetsRequest.html)contenente la regola da aggiornare e un elenco di obiettivi da aggiungere alla regola.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
## Ulteriori informazioni
+ [Aggiungere eventi PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) nella Guida per l' Amazon CloudWatch Events utente
+ [Pianifica le espressioni per le regole](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) nella Guida per l' Amazon CloudWatch Events utente
+ [Tipi di CloudWatch eventi per gli eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) indicati nella Guida per l' Amazon CloudWatch Events utente
+ [Eventi e modelli di eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) nella Guida Amazon CloudWatch Events per l'utente
+ [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutEvents.html)nell' Amazon CloudWatch Events API Reference
+ [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html)nell' Amazon CloudWatch Events API Reference
+ [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutRule.html)nell' Amazon CloudWatch Events API Reference
# DynamoDB Esempi di utilizzo di AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [DynamoDB](https://aws.amazon.com/dynamodb/) utilizzando [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Usa AWS endpoint basati su account](#account-based-endpoint-routing)
+ [Lavorare con le tabelle in DynamoDB](examples-dynamodb-tables.md)
+ [Utilizzo degli elementi in DynamoDB](examples-dynamodb-items.md)
## Usa AWS endpoint basati su account
DynamoDB [AWS offre endpoint basati su account](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) che possono migliorare le prestazioni utilizzando l'ID dell'account per semplificare AWS il routing delle richieste.
Per sfruttare questa funzionalità, è necessario utilizzare la versione 1.12.771 o successiva della versione 1 di. AWS SDK per Java[Puoi trovare l'ultima versione dell'SDK elencata nell'archivio centrale di Maven.](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom) Dopo che una versione supportata di SDK è attiva, utilizza automaticamente i nuovi endpoint.
Se desideri disattivare il routing basato sull'account, hai quattro opzioni:
+ Configurare un client di servizio DynamoDB con `AccountIdEndpointMode` l'impostazione su. `DISABLED`
+ Imposta una variabile di ambiente.
+ Imposta una proprietà del sistema JVM.
+ Aggiorna l'impostazione del file di AWS configurazione condiviso.
Il seguente frammento è un esempio di come disabilitare il routing basato su account configurando un client di servizio 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();
```
[La AWS SDKs and Tools Reference Guide fornisce ulteriori informazioni sulle ultime tre opzioni di configurazione.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html)
# Lavorare con le tabelle in DynamoDB
Le tabelle sono i contenitori per tutti gli elementi di un DynamoDB database. Prima di poter aggiungere o rimuovere dati da DynamoDB, è necessario creare una tabella.
Per ogni tabella, devi definire:
+ Un *nome* di tabella univoco per l'account e la regione.
+ Una *chiave primaria* per la quale ogni valore deve essere univoco; due item nella tabella non possono avere lo stesso valore della chiave primaria.
La chiave primaria può essere *semplice*, costituita da una singola chiave di partizione (HASH), o *composita*, costituita da una chiave di partizione e una di ordinamento (RANGE).
A ogni valore chiave è associato un *tipo di dati*, enumerato dalla classe. [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ScalarAttributeType.html) Il valore della chiave può essere binario (B), numerico (N) o una stringa (S). Per ulteriori informazioni, consulta [Regole di denominazione e tipi di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) nella Guida per gli sviluppatori. Amazon DynamoDB
+ Valori di *throughput assegnati* che definiscono il numero di unità di capacità di lettura/scrittura riservate per la tabella.
**Nota**
[Amazon DynamoDB i prezzi](https://aws.amazon.com/dynamodb/pricing/) si basano sui valori di throughput assegnati che imposti sulle tabelle, quindi prenota solo la capacità che ritieni necessaria per la tabella.
Il throughput assegnato per una tabella può essere modificato in qualsiasi momento, in modo da poter regolare la capacità in caso di variazioni delle esigenze.
## Creazione di una tabella
Usa il `createTable` metodo del [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) per creare una nuova DynamoDB tabella. È necessario costruire gli attributi della tabella e uno schema della tabella, entrambi utilizzati per identificare la chiave primaria della tabella. Inoltre, occorre fornire i valori del throughput assegnato iniziali e un nome della tabella. Definisci solo gli attributi chiave della tabella durante la creazione della DynamoDB tabella.
**Nota**
Se esiste già una tabella con il nome scelto, ne [AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)viene generata una.
**Importazioni**
```
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;
```
### Creazione di una tabella con una chiave primaria semplice
Questo codice consente di creare una tabella con una chiave primaria semplice ("Name").
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTable.java) su. GitHub
### Creazione di una tabella con una chiave primaria composita
Aggiungi un altro [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeDefinition.html)e [KeySchemaElement](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/KeySchemaElement.html)a [CreateTableRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/CreateTableRequest.html).
**Codice**
```
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);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTableCompositeKey.java) su GitHub.
## Elencare tabelle
È possibile elencare le tabelle in una particolare regione chiamando il `listTables` metodo del [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generata a.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
```
Per impostazione predefinita, vengono restituite fino a 100 tabelle per chiamata: da utilizzare `getLastEvaluatedTableName` sull'[ListTablesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/model/ListTablesResult.html)oggetto restituito per ottenere l'ultima tabella valutata. Puoi utilizzare questo valore per avviare la visualizzazione dell'elenco dopo l'ultimo valore restituito dalla visualizzazione dell'elenco precedente.
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/ListTables.java) su. GitHub
## Descrizione di (recupero delle informazioni su) una tabella
Chiama il `describeTable` metodo del [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generata a.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DescribeTable.java) su. GitHub
## Modifica (aggiornamento) di una tabella
Puoi modificare i valori di throughput assegnati alla tabella in qualsiasi momento chiamando il metodo del [DynamoDB`updateTable`client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generata a.
**Importazioni**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.AmazonServiceException;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateTable.java) su. GitHub
## Eliminazione di una tabella
Chiama il `deleteTable` metodo del [DynamoDB client](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) e passagli il nome della tabella.
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generata a.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
```
**Codice**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.deleteTable(table_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DeleteTable.java) su. GitHub
## Ulteriori informazioni
+ [Linee guida per l'utilizzo delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) nella Guida per Amazon DynamoDB gli sviluppatori
+ [Utilizzo delle tabelle DynamoDB nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) Guida per gli Amazon DynamoDB sviluppatori
# Utilizzo degli elementi in DynamoDB
In DynamoDB, un elemento è una raccolta di *attributi*, ognuno dei quali ha un *nome* e un *valore*. Un valore attributo può essere un tipo scalare, set o documento. Per ulteriori informazioni, consulta [Regole di denominazione e tipi di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) nella Guida per gli Amazon DynamoDB sviluppatori.
## Recuperare (ottenere) un item da una tabella
Chiama il `getItem` metodo del AmazonDynamo DB e passagli un [GetItemRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemRequest.html)oggetto con il nome della tabella e il valore della chiave primaria dell'elemento che desideri. Restituisce un [GetItemResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemResult.html)oggetto.
È possibile utilizzare il `getItem()` metodo dell'`GetItemResult`oggetto restituito per recuperare una [mappa](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) di coppie chiave (String [AttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeValue.html)) e valore () associate all'elemento.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/GetItem.java) su. GitHub
## Aggiunta di un nuovo item a una tabella
Creare una [mappa](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) di coppie chiave-valore che rappresentino gli attributi della voce. Queste devono includere valori per i campi chiave primaria della tabella. Se l'elemento identificato dalla chiave primaria esiste già, i relativi campi vengono *aggiornati* dalla richiesta.
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generata a.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/PutItem.java) su. GitHub
## Aggiornamento di un item esistente in una tabella
È possibile aggiornare un attributo per un elemento già esistente in una tabella utilizzando il `updateItem` metodo del AmazonDynamo DB, fornendo un nome di tabella, un valore della chiave primaria e una mappa di campi da aggiornare.
**Nota**
Se la tabella denominata non esiste per il tuo account e la tua regione, o se l'elemento identificato dalla chiave primaria che hai passato non esiste, [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html)viene generato a.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateItem.java) su. GitHub
## Usa la classe Dynamo DBMapper
[AWS SDK per Java](https://aws.amazon.com/sdk-for-java/)Fornisce una DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html), che consente di mappare le classi lato client alle tabelle. Amazon DynamoDB Per utilizzare la DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html), definite la relazione tra gli elementi di una DynamoDB tabella e le istanze di oggetto corrispondenti nel codice utilizzando le annotazioni (come mostrato nel seguente esempio di codice). La DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) consente di accedere alle tabelle, eseguire varie operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) ed eseguire query.
**Nota**
La DBMapper classe [Dynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) non consente di creare, aggiornare o eliminare tabelle.
**Importazioni**
```
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;
```
**Codice**
Il seguente esempio di codice Java mostra come aggiungere contenuti alla tabella *Music* utilizzando la classe [DBMapperDynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html). *Dopo aver aggiunto il contenuto alla tabella, notate che un elemento viene caricato utilizzando i *tasti Partition* e Sort.* Quindi la voce *Awards* viene aggiornata. Per informazioni sulla creazione della tabella *Music*, consulta [Create a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) nella Amazon DynamoDB Developer Guide.
```
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;
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UseDynamoMapping.java) su GitHub.
## Ulteriori informazioni
+ [Linee guida per l'utilizzo degli elementi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) nella Guida per gli Amazon DynamoDB sviluppatori
+ [Utilizzo degli elementi contenuti DynamoDB nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) Guida per gli Amazon DynamoDB sviluppatori
# Amazon EC2 Esempi di utilizzo di AWS SDK per Java
Questa sezione fornisce esempi di programmazione [Amazon EC2](https://aws.amazon.com/ec2/)con AWS SDK per Java.
**Topics**
+ [Tutorial: avvio di un' EC2 istanza](how-to-ec2.md)
+ [Utilizzo dei ruoli IAM per concedere l'accesso alle AWS risorse su Amazon EC2](java-dg-roles.md)
+ [Tutorial: istanze Amazon EC2 Spot](tutorial-spot-instances-java.md)
+ [Tutorial: Gestione avanzata delle richieste Amazon EC2 Spot](tutorial-spot-adv-java.md)
+ [Gestione delle Amazon EC2 istanze](examples-ec2-instances.md)
+ [Utilizzo di indirizzi IP elastici in Amazon EC2](examples-ec2-elastic-ip.md)
+ [Usa aree e zone di disponibilità](examples-ec2-regions-zones.md)
+ [Lavorare con coppie di Amazon EC2 chiavi](examples-ec2-key-pairs.md)
+ [Lavorare con i gruppi di sicurezza in Amazon EC2](examples-ec2-security-groups.md)
# Tutorial: avvio di un' EC2 istanza
Questo tutorial mostra come utilizzare per AWS SDK per Java avviare un' EC2 istanza.
**Topics**
+ [Prerequisiti](#prerequisitesec2)
+ [Creare un gruppo Amazon EC2 di sicurezza](create-security-group.md)
+ [Crea una coppia di chiavi](create-key-pair.md)
+ [Esegui un' Amazon EC2 istanza](run-instance.md)
## Prerequisiti
Prima di iniziare, assicurati di aver creato un file Account AWS e di aver impostato AWS le tue credenziali. Per ulteriori informazioni, consulta [Nozioni di base su ](getting-started.md).
# Creare un gruppo Amazon EC2 di sicurezza
## EC2-Classic sta per andare in pensione
**avvertimento**
Ritireremo EC2 -Classic il 15 agosto 2022. Ti consigliamo di migrare da EC2 -Classic a un VPC. Per ulteriori informazioni, consulta il post del blog [EC2-Classic-Classic Networking is Retiring](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) — Ecco come prepararsi.
Crea un *gruppo di sicurezza*, che funge da firewall virtuale che controlla il traffico di rete per una o più istanze. EC2 Per impostazione predefinita, Amazon EC2 associa le istanze a un gruppo di sicurezza che non consente il traffico in entrata. Puoi creare un gruppo di sicurezza che consenta alle EC2 istanze di accettare un determinato traffico. Ad esempio, se è necessario connettersi a un'istanza Linux, è necessario configurare il gruppo di sicurezza per consentire il traffico SSH. È possibile creare un gruppo di sicurezza utilizzando la Amazon EC2 console o il AWS SDK per Java.
È possibile creare un gruppo di sicurezza da utilizzare in EC2 -Classic o EC2 -VPC. Per ulteriori informazioni su EC2 -Classic e EC2 -VPC, consulta [Supported Platforms](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html) nella Amazon EC2 User Guide for Linux Instances.
Per ulteriori informazioni sulla creazione di un gruppo di sicurezza utilizzando la Amazon EC2 console, consulta [Amazon EC2 Security Groups](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) nella Guida Amazon EC2 utente per le istanze Linux.
1. Crea e inizializza un'[CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html)istanza. Utilizzare il [withGroupName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withGroupName-java.lang.String-)metodo per impostare il nome del gruppo di sicurezza e il metodo [WithDescription per impostare la descrizione](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withDescription-java.lang.String-) del gruppo di sicurezza, come segue:
```
CreateSecurityGroupRequest csgr = new CreateSecurityGroupRequest();
csgr.withGroupName("JavaSecurityGroup").withDescription("My security group");
```
Il nome del gruppo di sicurezza deve essere univoco all'interno della AWS regione in cui si inizializza il Amazon EC2 client. È necessario utilizzare caratteri US-ASCII per il nome e la descrizione del gruppo di sicurezza.
1. Passate l'oggetto della richiesta come parametro al [createSecurityGroup](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createSecurityGroup-com.amazonaws.services.ec2.model.CreateSecurityGroupRequest-)metodo. Il metodo restituisce un [CreateSecurityGroupResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupResult.html)oggetto, come segue:
```
CreateSecurityGroupResult createSecurityGroupResult =
amazonEC2Client.createSecurityGroup(csgr);
```
Se si tenta di creare un gruppo di sicurezza con lo stesso nome di un gruppo di sicurezza esistente, `createSecurityGroup` genera un'eccezione.
Per impostazione predefinita, un nuovo gruppo di sicurezza non consente alcun traffico in entrata verso l' Amazon EC2 istanza. Per consentire il traffico in entrata, devi autorizzare esplicitamente l'ingresso del gruppo di sicurezza. È possibile autorizzare l'ingresso per singoli indirizzi IP, per un intervallo di indirizzi IP, per un protocollo specifico e per le porte TCP/UDP.
1. Crea e inizializza un'istanza. [IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html) Utilizzate il metodo [WithIPv4Ranges](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpv4Ranges-java.util.Collection-) per impostare l'intervallo di indirizzi IP per cui autorizzare l'ingresso e utilizzate il metodo per impostare il [withIpProtocol](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpProtocol-java.lang.String-)protocollo IP. Utilizzate i [withToPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withToPort-java.lang.Integer-)metodi [withFromPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withFromPort-java.lang.Integer-)and per specificare l'intervallo di porte per cui autorizzare l'ingresso, come segue:
```
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);
```
Tutte le condizioni specificate nell'`IpPermission`oggetto devono essere soddisfatte per consentire l'ingresso.
Specificare l'indirizzo IP utilizzando la notazione CIDR. Se si specifica il protocollo come TCP/UDP, è necessario fornire una porta di origine e una porta di destinazione. È possibile autorizzare le porte solo se si specifica TCP o UDP.
1. Crea e inizializza un'istanza. [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html) Utilizzate il `withGroupName` metodo per specificare il nome del gruppo di sicurezza e passate al [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…-)metodo l'`IpPermission`oggetto inizializzato in precedenza, come segue:
```
AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest =
new AuthorizeSecurityGroupIngressRequest();
authorizeSecurityGroupIngressRequest.withGroupName("JavaSecurityGroup")
.withIpPermissions(ipPermission);
```
1. Passate l'oggetto della richiesta al metodo [authorizeSecurityGroupIngress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-), come segue:
```
amazonEC2Client.authorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);
```
Se chiamate `authorizeSecurityGroupIngress` con indirizzi IP per i quali l'ingresso è già autorizzato, il metodo genera un'eccezione. Crea e inizializza un nuovo `IpPermission` oggetto per autorizzare l'ingresso per diverse porte e protocolli IPs prima della chiamata. `AuthorizeSecurityGroupIngress`
Ogni volta che chiamate i metodi [authorizeSecurityGroupIngress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-) o [authorizeSecurityGroupEgress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupEgress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupEgressRequest-), viene aggiunta una regola al gruppo di sicurezza.
# Crea una coppia di chiavi
È necessario specificare una coppia di chiavi all'avvio di un' EC2 istanza e quindi specificare la chiave privata della coppia di chiavi quando ci si connette all'istanza. Puoi creare una coppia di chiavi o utilizzare una coppia di chiavi esistente che hai usato per avviare altre istanze. Per ulteriori informazioni, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) nella Guida per l' Amazon EC2 utente delle istanze Linux.
1. Crea e inizializza un'[CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html)istanza. Utilizzate il [withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html#withKeyName-java.lang.String-)metodo per impostare il nome della coppia di key pair, come segue:
```
CreateKeyPairRequest createKeyPairRequest = new CreateKeyPairRequest();
createKeyPairRequest.withKeyName(keyName);
```
**Importante**
I nomi delle coppie di chiavi devono essere univoci. Se tenti di creare una coppia di chiavi con lo stesso nome di una coppia di chiavi esistente, otterrai un'eccezione.
1. Passa l'oggetto della richiesta al [createKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createKeyPair-com.amazonaws.services.ec2.model.CreateKeyPairRequest--)metodo. Il metodo restituisce un'[CreateKeyPairResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html)istanza, come segue:
```
CreateKeyPairResult createKeyPairResult =
amazonEC2Client.createKeyPair(createKeyPairRequest);
```
1. Chiamate il [getKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html#getKeyPair--)metodo dell'oggetto risultato per ottenere un [KeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html)oggetto. Chiamate il [getKeyMaterial](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html#getKeyMaterial--)metodo dell'`KeyPair`oggetto per ottenere la chiave privata non crittografata con codifica PEM, come segue:
```
KeyPair keyPair = new KeyPair();
keyPair = createKeyPairResult.getKeyPair();
String privateKey = keyPair.getKeyMaterial();
```
# Esegui un' Amazon EC2 istanza
Utilizza la seguente procedura per avviare una o più EC2 istanze configurate in modo identico dalla stessa Amazon Machine Image (AMI). Dopo aver creato le EC2 istanze, puoi verificarne lo stato. Dopo l'esecuzione EC2 delle istanze, puoi connetterti ad esse.
1. Crea e inizializza un'[RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)istanza. Assicurati che l'AMI, la key pair e il gruppo di sicurezza che specifichi esistano nella regione specificata quando hai creato l'oggetto 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-)
+ L'ID dell'AMI. Per scoprire come trovare un AMIs servizio pubblico fornito da Amazon o crearne uno personalizzato, consulta [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-)
+ Un tipo di istanza compatibile con l'AMI specificata. Per ulteriori informazioni, consulta [Tipi di istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) nella Guida Amazon EC2 utente per le istanze Linux.
[withMinCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMinCount-java.lang.Integer-)
+ Il numero minimo di EC2 istanze da avviare. Se si tratta di un numero di istanze superiore a quello che è Amazon EC2 possibile avviare nella zona di disponibilità di destinazione, non Amazon EC2 viene avviata alcuna istanza.
[withMaxCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMaxCount-java.lang.Integer-)
+ Il numero massimo di EC2 istanze da avviare. Se si tratta di un numero di istanze superiore a quello che è Amazon EC2 possibile avviare nella zona di disponibilità di destinazione, Amazon EC2 avvia il maggior numero possibile di istanze sopra elencate. `MinCount` È possibile avviare tra 1 e il numero massimo di istanze consentite per il tipo di istanza. Per ulteriori informazioni, consulta Quante istanze posso eseguire Amazon EC2 nelle Domande frequenti generali. Amazon EC2
[withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withKeyName-java.lang.String-)
+ Il nome della EC2 key pair. Se l'istanza viene avviata senza specificare una coppia di chiavi, non potrai connetterti a essa. Per ulteriori informazioni, consultare [Creare una coppia di chiavi](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-)
+ Uno o più gruppi di sicurezza. Per ulteriori informazioni, consulta [Creare un gruppo Amazon EC2 di sicurezza](create-security-group.md).
1. Avvia le istanze passando l'oggetto di richiesta al metodo [RunInstances.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#runInstances-com.amazonaws.services.ec2.model.RunInstancesRequest-) Il metodo restituisce un [RunInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesResult.html)oggetto, come segue:
```
RunInstancesResult result = amazonEC2Client.runInstances(
runInstancesRequest);
```
Una volta che l'istanza è in esecuzione, puoi connetterti ad essa utilizzando la tua key pair. Per ulteriori informazioni, consulta [Connect to Your Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html). nella Guida per l' Amazon EC2 utente delle istanze Linux.
# Utilizzo dei ruoli IAM per concedere l'accesso alle AWS risorse su Amazon EC2
Tutte le richieste a Amazon Web Services (AWS) devono essere firmate crittograficamente utilizzando credenziali emesse da. AWS Puoi utilizzare *i ruoli IAM* per garantire comodamente un accesso sicuro alle AWS risorse delle tue istanze. Amazon EC2
Questo argomento fornisce informazioni su come utilizzare i ruoli IAM con le applicazioni Java SDK in esecuzione. Amazon EC2 Per ulteriori informazioni sulle istanze IAM, consulta [IAM Roles for Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) nella Guida Amazon EC2 utente per le istanze Linux.
## La catena di provider e EC2 i profili di istanza predefiniti
Se l'applicazione crea un AWS client utilizzando il costruttore predefinito, il client cercherà le credenziali utilizzando la *catena di provider di credenziali di default*, nell'ordine seguente:
1. Nelle proprietà del sistema Java: `aws.accessKeyId` e `aws.secretKey`.
1. Nelle variabili di ambiente del sistema: `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY`.
1. Nel file delle credenziali predefinito (il percorso di questo file varia in base alla piattaforma).
1. Credenziali fornite tramite il servizio Amazon EC2 contenitore se la variabile di `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` ambiente è impostata e il responsabile della sicurezza è autorizzato ad accedere alla variabile.
1. Nel *profilo di istanza, le credenziali* presenti nei metadati dell'istanza associati al ruolo IAM per l'istanza. EC2
1. Credenziali Web Identity Token dall'ambiente o dal contenitore.
La fase relativa alle *credenziali del profilo di istanza* nella catena di provider predefinita è disponibile solo quando si esegue l'applicazione su un' Amazon EC2 istanza, ma offre la massima facilità d'uso e la massima sicurezza quando si lavora con Amazon EC2 le istanze. Puoi anche passare un'[InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)istanza direttamente al costruttore del client per ottenere le credenziali del profilo dell'istanza senza procedere attraverso l'intera catena di provider predefinita.
Per esempio:
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new InstanceProfileCredentialsProvider(false))
.build();
```
Quando si utilizza questo approccio, l'SDK recupera AWS credenziali temporanee con le stesse autorizzazioni di quelle associate al ruolo IAM associato all'istanza nel relativo profilo di istanza. Amazon EC2 Sebbene queste credenziali siano temporanee e alla fine scadano, le aggiorna `InstanceProfileCredentialsProvider` periodicamente in modo che le credenziali ottenute continuino a consentire l'accesso a. AWS
**Importante**
L'aggiornamento automatico delle credenziali avviene *solo* quando si utilizza il costruttore client predefinito, che ne crea uno proprio `InstanceProfileCredentialsProvider` come parte della catena di provider predefinita, o quando si passa un'`InstanceProfileCredentialsProvider`istanza direttamente al costruttore del client. Se utilizzi un altro metodo per ottenere o passare le credenziali del profilo dell'istanza, sei responsabile del controllo e dell'aggiornamento delle credenziali scadute.
Se il costruttore del client non riesce a trovare le credenziali utilizzando la catena di fornitori di credenziali, genererà un. [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)
## Procedura dettagliata: utilizzo dei ruoli IAM per le istanze EC2
La seguente procedura dettagliata mostra come recuperare un oggetto Amazon S3 utilizzando un ruolo IAM per gestire l'accesso.
### Creazione di un ruolo IAM
Crea un ruolo IAM che garantisca l'accesso in sola lettura a. Amazon S3
1. Apri la [console IAM](https://console.aws.amazon.com/iam/home).
1. Nel riquadro di navigazione, seleziona **Ruoli**, quindi **Crea** nuovo ruolo.
1. Inserisci un nome per il ruolo, quindi seleziona **Next Step (Fase successiva)**. Ricorda questo nome, poiché ti servirà all'avvio dell' Amazon EC2 istanza.
1. Nella pagina **Seleziona il tipo di ruolo**, in ** Servizio AWS Ruoli**, seleziona ** Amazon EC2 **.
1. Nella pagina **Imposta autorizzazioni**, in **Seleziona modello di policy**, seleziona **Accesso in sola Amazon S3 lettura**, quindi **Passaggio successivo**.
1. Nella pagina di **revisione**, seleziona **Crea ruolo**.
### Avvia un' EC2 istanza e specifica il tuo ruolo IAM
Puoi avviare un' Amazon EC2 istanza con un ruolo IAM utilizzando la Amazon EC2 console o il AWS SDK per Java.
+ Per avviare un' Amazon EC2 istanza utilizzando la console, segui le istruzioni riportate in [Getting Started with Amazon EC2 Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) nella Guida per l' Amazon EC2 utente delle istanze Linux.
Quando raggiungi la pagina **Review Instance Launch (Verifica del lancio dell'istanza)**, seleziona **Edit instance details (Modifica dettagli istanza)**. Nel **ruolo IAM**, scegli il ruolo IAM che hai creato in precedenza. Completa la procedura come descritto.
**Nota**
Dovrai creare o utilizzare un gruppo di sicurezza e una coppia di chiavi esistenti per connetterti all'istanza.
+ Per avviare un' Amazon EC2 istanza con un ruolo IAM utilizzando il AWS SDK per Java, consulta [Run an Amazon EC2 Instance](run-instance.md).
### Crea la tua applicazione
Creiamo l'applicazione di esempio da eseguire sull' EC2 istanza. Per prima cosa, crea una directory che puoi usare per contenere i file del tutorial (ad esempio,`GetS3ObjectApp`).
Quindi, copiate le AWS SDK per Java librerie nella cartella appena creata. Se le hai AWS SDK per Java scaricate nella tua `~/Downloads` directory, puoi copiarle usando i seguenti comandi:
```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```
Aprite un nuovo file, richiamatelo `GetS3Object.java` e aggiungete il seguente codice:
```
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();
}
}
```
Apri un nuovo file, chiamalo `build.xml` e aggiungi le seguenti righe:
```
```
Compila ed esegui il programma modificato. Nota che non ci sono credenziali memorizzate nel programma. Pertanto, a meno che non siano già state specificate AWS le credenziali, il codice verrà generato. `AmazonServiceException` Per esempio:
```
$ 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
```
### Trasferisci il programma compilato sulla tua istanza EC2
Trasferisci il programma sulla tua Amazon EC2 istanza utilizzando secure copy (**``**), insieme alle AWS SDK per Java librerie. La sequenza di comandi è simile alla seguente.
```
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
```
**Nota**
A seconda della distribuzione Linux utilizzata, il *nome utente* potrebbe essere «ec2-user», «root» o «ubuntu». Per ottenere il nome DNS pubblico dell'istanza, apri la [EC2 console](https://console.aws.amazon.com/ec2/home) e cerca il valore **Public DNS** nella scheda **Descrizione** (ad esempio,). `ec2-198-51-100-1.compute-1.amazonaws.com`
Nei comandi precedenti:
+ `GetS3Object.class`è il tuo programma compilato
+ `build.xml`è il file ant utilizzato per creare ed eseguire il programma
+ le `third-party` directory `lib` e sono le cartelle della libreria corrispondenti da. AWS SDK per Java
+ L'`-r`interruttore indica che `scp` dovrebbe fare una copia ricorsiva di tutti i contenuti delle `third-party` directory `library` e della distribuzione. AWS SDK per Java
+ L'`-p`interruttore indica che `scp` deve conservare le autorizzazioni dei file di origine quando li copia nella destinazione.
**Nota**
Lo `-p` switch funziona solo su Linux, macOS o Unix. Se stai copiando file da Windows, potresti dover correggere le autorizzazioni relative ai file sull'istanza utilizzando il seguente comando:
```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```
### Esegui il programma di esempio sull'istanza EC2
Per eseguire il programma, connettiti alla tua Amazon EC2 istanza. Per ulteriori informazioni, consulta [Connect to Your Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella Amazon EC2 User Guide for Linux Instances.
Se non **` ant `**è disponibile sulla tua istanza, installala utilizzando il seguente comando:
```
sudo yum install ant
```
Quindi, esegui il programma `ant` nel modo seguente:
```
ant run
```
Il programma scriverà il contenuto dell' Amazon S3 oggetto nella finestra di comando.
# Tutorial: istanze Amazon EC2 Spot
## Panoramica
*Le istanze Spot consentono di fare offerte sulla capacità inutilizzata Amazon Elastic Compute Cloud (Amazon EC2) fino al 90% rispetto al prezzo delle istanze on demand e di eseguire le istanze acquisite finché l'offerta supera il prezzo Spot corrente.* Amazon EC2 modifica periodicamente il prezzo Spot in base alla domanda e all'offerta e i clienti le cui offerte lo soddisfano o superano ottengono l'accesso alle istanze Spot disponibili. Come le istanze on demand e le istanze riservate, le istanze Spot offrono un'altra opzione per ottenere una maggiore capacità di elaborazione.
Le istanze Spot possono ridurre in modo significativo i Amazon EC2 costi per l'elaborazione in batch, la ricerca scientifica, l'elaborazione delle immagini, la codifica video, la scansione di dati e web, l'analisi finanziaria e i test. Inoltre, le istanze Spot consentono di accedere a grandi quantità di capacità aggiuntiva in situazioni in cui la necessità di tale capacità non è urgente.
Per utilizzare le istanze Spot, farne richiesta specificando il prezzo massimo che si desidera pagare per ora di istanza; questa sarà la tua offerta. Se la tua offerta supera il prezzo Spot corrente, la tua richiesta è soddisfatta e le tue istanze saranno eseguite finché non sceglierai di terminarle o finché il prezzo Spot non supererà nuovamente la tua offerta (a seconda di quale dei due si verifica prima).
È importante notare che:
+ Spesso pagherai meno all'ora rispetto alla tua offerta. Amazon EC2 aggiusta periodicamente il prezzo spot in base all'arrivo delle richieste e alle variazioni dell'offerta disponibile. Tutti devono pagare lo stesso prezzo Spot per quel periodo, indipendentemente dal fatto che la loro offerta fosse più alta. Pertanto, potresti pagare meno, ma non pagherai mai di più rispetto alla tua offerta.
+ Se utilizzi istanze Spot e la tua offerta non soddisfa o supera più il prezzo Spot corrente, le istanze verranno chiuse. Ciò significa che dovrai assicurarti che i tuoi carichi di lavoro e le tue applicazioni siano sufficientemente flessibili da sfruttare questa capacità opportunistica.
Le istanze Spot si comportano esattamente come le altre Amazon EC2 istanze durante l'esecuzione e, come altre Amazon EC2 istanze, le istanze Spot possono essere terminate quando non sono più necessarie. Se termini la tua istanza, paghi per la frazione di ora utilizzata (come faresti per le istanze On demand o Riservate). Tuttavia, se il prezzo Spot supera l'offerta e l'istanza viene chiusa entro il termine Amazon EC2, non ti verrà addebitata alcuna ora parziale di utilizzo.
Questo tutorial mostra come utilizzare per AWS SDK per Java eseguire le seguenti operazioni.
+ Invia una richiesta Spot
+ Stabilisci quando la richiesta Spot viene soddisfatta
+ Annulla la richiesta Spot
+ Terminare le istanze associate
## Prerequisiti
Per utilizzare questo tutorial è necessario averlo AWS SDK per Java installato, oltre a soddisfare i prerequisiti di installazione di base. Per ulteriori informazioni, [consulta Configurare il AWS SDK per Java](setup-install.md).
## Fase 1: Configurazione delle credenziali
Per iniziare a utilizzare questo esempio di codice, è necessario impostare AWS le credenziali. Per istruzioni su come eseguire questa operazione, consulta [Configurare le AWS credenziali e la regione per lo sviluppo](setup-credentials.md).
**Nota**
Ti consigliamo di utilizzare le credenziali di un utente IAM per fornire questi valori. Per ulteriori informazioni, consulta [Registrazione AWS e creazione di un utente IAM](signup-create-iam-user.md).
Ora che hai configurato le impostazioni, puoi iniziare a utilizzare il codice riportato nell'esempio.
## Fase 2: Configurazione di un gruppo di sicurezza
Un *gruppo di sicurezza* funge da firewall che controlla il traffico consentito in entrata e in uscita da un gruppo di istanze. Per impostazione predefinita, un'istanza viene avviata senza alcun gruppo di sicurezza, il che significa che tutto il traffico IP in entrata, su qualsiasi porta TCP, verrà negato. Quindi, prima di inviare la nostra richiesta Spot, creeremo un gruppo di sicurezza che consenta il traffico di rete necessario. Ai fini di questo tutorial, creeremo un nuovo gruppo di sicurezza chiamato "GettingStarted" che consente il traffico Secure Shell (SSH) dall'indirizzo IP da cui viene eseguita l'applicazione. Per configurare un nuovo gruppo di sicurezza, è necessario includere o eseguire il seguente esempio di codice che configura il gruppo di sicurezza a livello di codice.
Dopo aver creato un oggetto `AmazonEC2` client, creiamo un `CreateSecurityGroupRequest` oggetto con il nome "GettingStarted" e una descrizione per il gruppo di sicurezza. Quindi chiamiamo l'`ec2.createSecurityGroup`API per creare il gruppo.
Per consentire l'accesso al gruppo, creiamo un `ipPermission` oggetto con l'intervallo di indirizzi IP impostato sulla rappresentazione CIDR della sottorete per il computer locale; il suffisso «/10" sull'indirizzo IP indica la sottorete per l'indirizzo IP specificato. Configuriamo l'`ipPermission`oggetto anche con il protocollo TCP e la porta 22 (SSH). Il passaggio finale consiste nella chiamata `ec2.authorizeSecurityGroupIngress` con il nome del nostro gruppo di sicurezza e dell'`ipPermission`oggetto.
```
// 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());
}
```
Nota che è necessario eseguire questa applicazione una sola volta per creare un nuovo gruppo di sicurezza.
È inoltre possibile creare il gruppo di sicurezza utilizzando AWS Toolkit for Eclipse. Per ulteriori informazioni, vedere [Gestione dei gruppi AWS Cost Explorer di sicurezza](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) di.
## Fase 3: Invio della richiesta Spot
Per inviare una richiesta Spot, devi prima determinare il tipo di istanza, Amazon Machine Image (AMI) e il prezzo di offerta massimo che desideri utilizzare. Devi anche includere il gruppo di sicurezza che abbiamo configurato in precedenza, in modo da poter accedere all'istanza, se lo desideri.
Esistono diversi tipi di istanze tra cui scegliere; vai a Tipi di Amazon EC2 istanze per un elenco completo. Per questo tutorial, useremo t1.micro, il tipo di istanza più economico disponibile. Successivamente, determineremo il tipo di AMI che vorremmo utilizzare. Useremo ami-a9d09ed1, l'AMI up-to-date Amazon Linux più disponibile quando abbiamo scritto questo tutorial. L'AMI più recente può cambiare nel tempo, ma puoi sempre determinare l'AMI della versione più recente seguendo questi passaggi:
1. Apri la [Amazon EC2 console](https://console.aws.amazon.com/ec2/home).
1. Scegli il pulsante **Launch Instance**.
1. La prima finestra mostra le AMIs opzioni disponibili. L'ID AMI è elencato accanto a ciascun titolo AMI. In alternativa, puoi utilizzare l'`DescribeImages`API, ma l'utilizzo di quel comando non rientra nell'ambito di questo tutorial.
Esistono molti modi per affrontare le offerte per le istanze Spot; per avere un'ampia panoramica dei vari approcci, ti consigliamo di guardare il video [Bidding for](https://www.youtube.com/watch?v=WD9N73F3Fao&feature=player_embedded) Spot Instances. Tuttavia, per iniziare, descriveremo tre strategie comuni: fare un'offerta per garantire che il costo sia inferiore a quello dei prezzi su richiesta; fare un'offerta basata sul valore del calcolo risultante; presentare un'offerta in modo da acquisire capacità di calcolo il più rapidamente possibile.
+ *Riduci i costi al di sotto di quelli su richiesta* Hai un processo di elaborazione in batch che richiederà diverse ore o giorni per essere eseguito. Tuttavia, sei flessibile rispetto a quando inizia e quando viene completato. Vuoi vedere se riesci a completarlo a un costo inferiore rispetto alle istanze on demand. Esamini la cronologia dei prezzi Spot per i tipi di istanza utilizzando l'API Console di gestione AWS o l' Amazon EC2 API. Per ulteriori informazioni, vedi [Visualizzazione della cronologia dei prezzi Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html). Dopo aver analizzato la cronologia dei prezzi per il tipo di istanza desiderato in una determinata zona di disponibilità, hai due approcci alternativi per la tua offerta:
+ Puoi fare un'offerta nella fascia alta della gamma di prezzi Spot (ma comunque inferiore al prezzo on demand), prevedendo che la tua singola richiesta Spot sarà probabilmente soddisfatta ed eseguita per un tempo di elaborazione consecutivo sufficiente a completare il processo.
+ In alternativa, puoi specificare l'importo che sei disposto a pagare per le istanze Spot come percentuale del prezzo delle istanze on demand e pianificare di combinare molte istanze lanciate nel tempo tramite una richiesta persistente. Se il prezzo specificato è superiore, l'istanza Spot viene terminata. (Più avanti nel tutorial spiegheremo come automatizzare questa operazione).
+ *Non pagate più del valore del risultato* Avete un processo di elaborazione dati da eseguire. Conosci abbastanza il valore dei risultati del processo per sapere quando valgono in termini di costi di elaborazione. Dopo aver analizzato la cronologia dei prezzi Spot per il tipo di istanza, scegli un prezzo di offerta al quale il costo del tempo di elaborazione non sia superiore al valore dei risultati del lavoro. Crea un'offerta persistente e impostane l'esecuzione intermittente quando il prezzo Spot raggiunge o scende sotto la tua offerta.
+ *Acquisisci rapidamente la capacità di elaborazione* Hai un bisogno imprevisto e a breve termine di capacità aggiuntiva che non è disponibile tramite le istanze on demand. Dopo aver analizzato la cronologia dei prezzi Spot per il tuo tipo di istanza, fai un'offerta superiore al prezzo storico più alto per avere un'alta probabilità che la tua richiesta venga soddisfatta rapidamente e che continui a essere elaborata fino al completamento.
Dopo aver scelto il prezzo di offerta, sei pronto a richiedere un'istanza Spot. Ai fini di questo tutorial, offriremo il prezzo su richiesta (0,03 USD) per massimizzare le possibilità che l'offerta venga soddisfatta. Puoi determinare i tipi di istanze disponibili e i prezzi su richiesta per le istanze accedendo alla pagina dei prezzi. Amazon EC2 Mentre un'istanza Spot è in esecuzione, paghi il prezzo Spot in vigore per il periodo di funzionamento delle istanze. I prezzi delle istanze Spot vengono fissati Amazon EC2 e adattati gradualmente in base alle tendenze a lungo termine della domanda e dell'offerta di capacità delle istanze Spot. Puoi anche specificare l'importo che sei disposto a pagare per un'istanza Spot come% del prezzo dell'istanza on demand. Per richiedere un'istanza Spot, devi semplicemente creare la tua richiesta con i parametri scelti in precedenza. Iniziamo con la creazione di un oggetto. `RequestSpotInstanceRequest` L'oggetto della richiesta richiede il numero di istanze che desideri avviare e il prezzo dell'offerta. Inoltre, è necessario impostare `LaunchSpecification` per la richiesta, che include il tipo di istanza, l'ID AMI e il gruppo di sicurezza che si desidera utilizzare. Una volta compilata la richiesta, chiamate il `requestSpotInstances` metodo sull'`AmazonEC2Client`oggetto. L'esempio seguente mostra come richiedere un'istanza 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'esecuzione di questo codice avvierà una nuova richiesta di istanza Spot. Esistono altre opzioni che puoi utilizzare per configurare le tue richieste Spot. Per saperne di più, consulta [Tutorial: Advanced Amazon EC2 Spot Request Management](tutorial-spot-adv-java.md) o la [RequestSpotInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesRequest.html)classe nell' AWS SDK per Java API Reference.
**Nota**
Ti verranno addebitati i costi per tutte le istanze Spot effettivamente lanciate, quindi assicurati di annullare tutte le richieste e di chiudere tutte le istanze avviate per ridurre le commissioni associate.
## Fase 4: Determinare lo stato della richiesta Spot
Successivamente, vogliamo creare un codice per attendere che la richiesta Spot raggiunga lo stato «attivo» prima di procedere all'ultimo passaggio. Per determinare lo stato della nostra richiesta Spot, analizziamo il metodo [describeSpotInstanceRequests](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#describeSpotInstanceRequests) in base allo stato dell'ID della richiesta Spot che vogliamo monitorare.
L'ID della richiesta creato nella Fase 2 è incorporato nella risposta alla nostra `requestSpotInstances` richiesta. Il codice di esempio seguente mostra come raccogliere le richieste IDs dalla `requestSpotInstances` risposta e utilizzarle per compilare 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());
}
```
Per monitorare l'ID della richiesta, chiamate il `describeSpotInstanceRequests` metodo per determinare lo stato della richiesta. Quindi ripeti finché la richiesta non si trova nello stato «aperto». Tieni presente che monitoriamo uno stato non «aperto», ma piuttosto uno stato, ad esempio, «attivo», perché la richiesta può passare direttamente a «chiusa» se c'è un problema con gli argomenti della richiesta. Il seguente esempio di codice fornisce i dettagli su come eseguire questa operazione.
```
// 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);
```
Dopo aver eseguito questo codice, la richiesta di istanza Spot sarà stata completata o avrà avuto esito negativo con un errore che verrà visualizzato sullo schermo. In entrambi i casi, possiamo procedere al passaggio successivo per ripulire eventuali richieste attive e terminare tutte le istanze in esecuzione.
## Fase 5: Pulizia delle richieste e delle istanze Spot
Infine, dobbiamo ripulire le nostre richieste e istanze. È importante annullare eventuali richieste in sospeso *e* terminare eventuali istanze. La semplice cancellazione delle richieste non comporterà l'interruzione delle istanze, il che significa che continuerai a pagarle. Se chiudi le istanze, le tue richieste Spot potrebbero essere annullate, ma in alcuni scenari, ad esempio nel caso in cui utilizzi offerte persistenti, la chiusura delle istanze non è sufficiente per impedire che la richiesta venga nuovamente soddisfatta. Pertanto, è consigliabile sia annullare le offerte attive che terminare le istanze in esecuzione.
Il codice seguente mostra come annullare le richieste.
```
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());
}
```
Per terminare le istanze in sospeso, è necessario l'ID dell'istanza associato alla richiesta che le ha avviate. Il seguente esempio di codice prende il nostro codice originale per il monitoraggio delle istanze e ne aggiunge uno `ArrayList` in cui memorizziamo l'ID dell'istanza associato alla risposta. `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);
```
Utilizzando l'istanza IDs, memorizzata in`ArrayList`, terminate tutte le istanze in esecuzione utilizzando il seguente frammento di codice.
```
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());
}
```
## Riunire tutto
Per mettere insieme tutto questo, forniamo un approccio più orientato agli oggetti che combina i passaggi precedenti che abbiamo mostrato: inizializzazione del EC2 client, invio della richiesta Spot, determinazione quando le richieste Spot non sono più nello stato aperto e pulizia di qualsiasi richiesta Spot persistente e delle istanze associate. Creiamo una classe chiamata che esegue queste azioni. `Requests`
Creiamo anche una `GettingStartedApp` classe, che ha un metodo principale in cui eseguiamo le chiamate di funzione di alto livello. In particolare, inizializziamo l'`Requests`oggetto descritto in precedenza. Inoltriamo la richiesta di istanza Spot. Quindi aspettiamo che la richiesta Spot raggiunga lo stato «Attivo». Infine, puliamo le richieste e le istanze.
Il codice sorgente completo di questo esempio può essere visualizzato o scaricato all'indirizzo [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-GettingStarted).
Complimenti\$1 Hai appena completato il tutorial introduttivo per lo sviluppo del software Spot Instance con AWS SDK per Java.
## Fasi successive
Procedi con il [tutorial: Advanced Amazon EC2 Spot Request Management](tutorial-spot-adv-java.md).
# Tutorial: Gestione avanzata delle richieste Amazon EC2 Spot
Amazon EC2 *Le istanze Spot ti consentono di fare offerte sulla Amazon EC2 capacità inutilizzata e di eseguire tali istanze finché l'offerta supera il prezzo spot corrente.* Amazon EC2 modifica periodicamente il prezzo spot in base alla domanda e all'offerta. Per ulteriori informazioni sulle istanze Spot, consulta le [istanze Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) nella Guida per l' Amazon EC2 utente delle istanze Linux.
## Prerequisiti
Per utilizzare questo tutorial è necessario averle AWS SDK per Java installate, oltre a soddisfare i relativi prerequisiti di installazione di base. Per ulteriori informazioni, [consulta Configurare il AWS SDK per Java](setup-install.md).
## Configurazione delle credenziali
Per iniziare a utilizzare questo esempio di codice, è necessario impostare AWS le credenziali. Per istruzioni su come eseguire questa operazione, consulta [Configurare le AWS credenziali e la regione per lo sviluppo](setup-credentials.md).
**Nota**
Ti consigliamo di utilizzare le credenziali di un IAM utente per fornire questi valori. Per ulteriori informazioni, consulta [Registrazione AWS e creazione di un IAM utente](signup-create-iam-user.md).
Dopo aver configurato le impostazioni, puoi iniziare a utilizzare il codice riportato nell'esempio.
## Configurazione di un gruppo di sicurezza
Un gruppo di sicurezza funge da firewall che controlla il traffico consentito in entrata e in uscita da un gruppo di istanze. Per impostazione predefinita, un'istanza viene avviata senza alcun gruppo di sicurezza, il che significa che tutto il traffico IP in entrata, su qualsiasi porta TCP, verrà negato. Quindi, prima di inviare la nostra richiesta Spot, creeremo un gruppo di sicurezza che consenta il traffico di rete necessario. Ai fini di questo tutorial, creeremo un nuovo gruppo di sicurezza chiamato "GettingStarted" che consente il traffico Secure Shell (SSH) dall'indirizzo IP da cui viene eseguita l'applicazione. Per configurare un nuovo gruppo di sicurezza, è necessario includere o eseguire il seguente esempio di codice che configura il gruppo di sicurezza a livello di codice.
Dopo aver creato un oggetto `AmazonEC2` client, creiamo un `CreateSecurityGroupRequest` oggetto con il nome "GettingStarted" e una descrizione per il gruppo di sicurezza. Quindi chiamiamo l'`ec2.createSecurityGroup`API per creare il gruppo.
Per consentire l'accesso al gruppo, creiamo un `ipPermission` oggetto con l'intervallo di indirizzi IP impostato sulla rappresentazione CIDR della sottorete per il computer locale; il suffisso «/10" sull'indirizzo IP indica la sottorete per l'indirizzo IP specificato. Configuriamo l'`ipPermission`oggetto anche con il protocollo TCP e la porta 22 (SSH). Il passaggio finale consiste nella chiamata `ec2 .authorizeSecurityGroupIngress` con il nome del nostro gruppo di sicurezza e dell'`ipPermission`oggetto.
(Il codice seguente è lo stesso che abbiamo usato nel primo tutorial.)
```
// 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());
}
```
È possibile visualizzare l'intero esempio di codice nell'esempio di `advanced.CreateSecurityGroupApp.java` codice. Nota: è necessario eseguire questa applicazione una sola volta per creare un nuovo gruppo di sicurezza.
**Nota**
È inoltre possibile creare il gruppo di sicurezza utilizzando AWS Toolkit for Eclipse. Per ulteriori informazioni, vedere [Gestione dei gruppi di sicurezza AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) nella Guida per AWS Toolkit for Eclipse l'utente.
## Opzioni dettagliate per la creazione di richieste di istanze Spot
Come spiegato in [Tutorial: Amazon EC2 Spot Instances](tutorial-spot-instances-java.md), devi creare la tua richiesta con un tipo di istanza, un'Amazon Machine Image (AMI) e un prezzo di offerta massimo.
Cominciamo con la creazione di un `RequestSpotInstanceRequest` oggetto. L'oggetto della richiesta richiede il numero di istanze desiderate e il prezzo dell'offerta. Inoltre, dobbiamo impostare `LaunchSpecification` per la richiesta, che include il tipo di istanza, l'ID AMI e il gruppo di sicurezza che desideri utilizzare. Dopo che la richiesta è stata compilata, chiamiamo il `requestSpotInstances` metodo sull'`AmazonEC2Client`oggetto. Segue un esempio di come richiedere un'istanza Spot.
(Il codice seguente è lo stesso che abbiamo usato nel primo tutorial.)
```
// 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);
```
## Richieste persistenti o richieste una tantum
Quando si crea una richiesta Spot, è possibile specificare diversi parametri opzionali. Il primo è se la richiesta è una tantum o persistente. Per impostazione predefinita, è una richiesta una tantum. Una richiesta unica può essere soddisfatta una sola volta e, una volta terminate le istanze richieste, la richiesta verrà chiusa. Una richiesta persistente viene presa in considerazione ai fini dell'evasione ogni volta che non è in esecuzione alcuna istanza Spot per la stessa richiesta. Per specificare il tipo di richiesta, è sufficiente impostare il Tipo nella richiesta Spot. Questo può essere fatto con il seguente codice.
```
// 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);
```
## Limitazione della durata di una richiesta
Puoi anche specificare facoltativamente per quanto tempo la tua richiesta rimarrà valida. È possibile specificare sia l'ora di inizio che quella di fine per questo periodo. Per impostazione predefinita, una richiesta Spot viene presa in considerazione per l'evasione dal momento in cui viene creata fino a quando non viene soddisfatta o annullata da te. Tuttavia, puoi limitare il periodo di validità, se necessario. Un esempio di come specificare questo periodo è mostrato nel codice seguente.
```
// 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);
```
## Raggruppamento delle richieste di istanze Amazon EC2 Spot
Hai la possibilità di raggruppare le richieste di istanze Spot in diversi modi. Esamineremo i vantaggi dell'utilizzo di gruppi di lancio, gruppi di zone di disponibilità e gruppi di collocamento.
Se vuoi assicurarti che le tue istanze Spot vengano lanciate e chiuse tutte insieme, hai la possibilità di avvalerti di un gruppo di lancio. Un gruppo di lancio è un'etichetta che raggruppa una serie di offerte. Tutte le istanze in un gruppo di avvio vengono avviate e terminate insieme. Nota: se le istanze di un gruppo di lancio sono già state soddisfatte, non vi è alcuna garanzia che vengano soddisfatte anche le nuove istanze lanciate con lo stesso gruppo di lancio. Un esempio di come impostare un Launch Group è mostrato nel seguente esempio di codice.
```
// 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);
```
Se vuoi assicurarti che tutte le istanze all'interno di una richiesta vengano lanciate nella stessa zona di disponibilità e non ti interessa quale, puoi sfruttare i gruppi di zone di disponibilità. Un gruppo di zone di disponibilità è un'etichetta che raggruppa un insieme di istanze nella stessa zona di disponibilità. Tutte le istanze che condividono un gruppo di zone di disponibilità e vengono gestite contemporaneamente inizieranno nella stessa zona di disponibilità. Segue un esempio di come impostare un gruppo di zone di 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);
```
Puoi specificare una zona di disponibilità che desideri per le tue istanze Spot. Il seguente esempio di codice mostra come impostare una zona di 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);
```
Infine, è possibile specificare un *gruppo di collocamento* se si utilizzano istanze Spot HPC (High Performance Computing), come istanze di calcolo in cluster o istanze GPU in cluster. I gruppi di posizionamento offrono una latenza inferiore e una connettività a larghezza di banda elevata tra le istanze. Segue un esempio di come impostare un gruppo di collocamento.
```
// 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);
```
Tutti i parametri mostrati in questa sezione sono opzionali. È anche importante rendersi conto che la maggior parte di questi parametri, ad eccezione del fatto che l'offerta sia una tantum o permanente, può ridurre la probabilità che l'offerta venga soddisfatta. Pertanto, è importante sfruttare queste opzioni solo se ne hai bisogno. Tutti gli esempi di codice precedenti sono combinati in un unico lungo esempio di codice, che può essere trovato nella `com.amazonaws.codesamples.advanced.InlineGettingStartedCodeSampleApp.java` classe.
## Come rendere persistente una partizione root dopo l'interruzione o la terminazione
Uno dei modi più semplici per gestire l'interruzione delle istanze Spot consiste nell'assicurare che i dati vengano indirizzati a un volume Amazon Elastic Block Store (Amazon Amazon EBS) con cadenza regolare. Effettuando il checkpoint periodicamente, in caso di interruzione perderai solo i dati creati dall'ultimo checkpoint (supponendo che nel frattempo non vengano eseguite altre azioni non idempotenti). Per semplificare questo processo, puoi configurare la tua Spot Request in modo che la partizione root non venga eliminata in caso di interruzione o chiusura. Nell'esempio seguente abbiamo inserito un nuovo codice che mostra come abilitare questo scenario.
Nel codice aggiunto, creiamo un `BlockDeviceMapping` oggetto e impostiamo il relativo oggetto associato Amazon Elastic Block Store (Amazon EBS) su un Amazon EBS oggetto che abbiamo configurato per `not` essere eliminato se l'istanza Spot viene terminata. Lo aggiungiamo quindi `BlockDeviceMapping` alle ArrayList mappature che includiamo nelle specifiche di lancio.
```
// 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);
```
Supponendo che tu voglia ricollegare questo volume alla tua istanza all'avvio, puoi anche utilizzare le impostazioni di mappatura dei dispositivi a blocchi. In alternativa, se hai collegato una partizione non root, puoi specificare i Amazon EBS volumi Amazon che desideri collegare all'istanza Spot dopo la ripresa. Puoi farlo semplicemente specificando un ID di istantanea nel tuo oggetto `EbsBlockDevice` e un nome di dispositivo alternativo negli oggetti. `BlockDeviceMapping` Sfruttando le mappature dei dispositivi a blocchi, può essere più semplice avviare l'istanza.
L'utilizzo della partizione root per il checkpoint dei dati critici è un ottimo modo per gestire il potenziale di interruzione delle istanze. [Per ulteriori metodi di gestione del potenziale di interruzione, guarda il video sulla gestione delle interruzioni.](https://www.youtube.com/watch?feature=player_embedded&v=wcPNnUo60pc)
## Come etichettare le richieste e le istanze spot
L'aggiunta di tag alle Amazon EC2 risorse può semplificare l'amministrazione dell'infrastruttura cloud. I tag, una forma di metadati, possono essere utilizzati per creare nomi intuitivi, migliorare la ricercabilità e migliorare il coordinamento tra più utenti. Puoi anche utilizzare i tag per automatizzare script e parti dei tuoi processi. Per saperne di più sull'etichettatura Amazon EC2 delle risorse, consulta la sezione [Uso dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) nella Guida Amazon EC2 utente per le istanze Linux.
### Tagging delle richieste
Per aggiungere tag alle tue richieste Spot, devi taggarle *dopo* che sono state richieste. Il valore restituito da ti `requestSpotInstances()` fornisce un [RequestSpotInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesResult.html)oggetto che puoi usare per ottenere la richiesta spot IDs per il tagging:
```
// 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());
}
```
Una volta ottenuto il IDs, puoi taggare le richieste aggiungendole IDs a [CreateTagsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateTagsRequest.html)e chiamando il `createTags()` metodo del 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());
}
```
### Taggare le istanze
Analogamente alle richieste spot stesse, puoi taggare un'istanza solo dopo averla creata, cosa che avverrà una volta soddisfatta la richiesta spot (non è più nello stato *aperto*).
Puoi controllare lo stato delle tue richieste chiamando il `describeSpotInstanceRequests()` metodo del Amazon EC2 client con un [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsRequest.html)oggetto. L'[DescribeSpotInstanceRequestsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsResult.html)oggetto restituito contiene un elenco di [SpotInstanceRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/SpotInstanceRequest.html)oggetti che è possibile utilizzare per interrogare lo stato delle richieste Spot e ottenerne l'istanza IDs una volta che non sono più nello stato *aperto*.
Una volta che la richiesta spot non è più aperta, puoi recuperarne l'ID di istanza dall'`SpotInstanceRequest`oggetto chiamandone il `getInstanceId()` metodo.
```
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);
```
Ora puoi taggare le istanze restituite:
```
// 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());
}
```
## Annullamento delle richieste spot e chiusura delle istanze
### Annullamento di una richiesta spot
Per annullare una richiesta di istanza Spot, chiama `cancelSpotInstanceRequests` il Amazon EC2 client con un [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CancelSpotInstanceRequestsRequest.html)oggetto.
```
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());
}
```
### Chiusura delle istanze Spot
Puoi terminare qualsiasi istanza Spot in esecuzione passandola IDs al metodo del Amazon EC2 client. `terminateInstances()`
```
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());
}
```
## Riunire tutto
Per riunire tutto questo, forniamo un approccio più orientato agli oggetti che combina i passaggi mostrati in questo tutorial in un'unica classe facile da usare. Creiamo un'istanza di una classe chiamata `Requests` che esegue queste azioni. Creiamo anche una `GettingStartedApp` classe, che ha un metodo principale in cui eseguiamo le chiamate di funzione di alto livello.
Il codice sorgente completo di questo esempio può essere visualizzato o scaricato all'indirizzo [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-Advanced).
Complimenti\$1 Hai completato il tutorial Advanced Request Features per lo sviluppo del software Spot Instance con AWS SDK per Java.
# Gestione delle Amazon EC2 istanze
## Creazione di un'istanza
Crea una nuova Amazon EC2 istanza chiamando il `runInstances` metodo del EC2 client Amazon, fornendogli una Amazon Machine Image (AMI) [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html)contenente l'[Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) da utilizzare e un [tipo di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateInstance.java).
## Avvio di un'istanza
Per avviare un' Amazon EC2 istanza, chiama il `startInstances` metodo del EC2 client Amazon, fornendogli un codice [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StartInstancesRequest.html)contenente l'ID dell'istanza da avviare.
**Importazioni**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StartInstancesRequest;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StartInstancesRequest request = new StartInstancesRequest()
.withInstanceIds(instance_id);
ec2.startInstances(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Arresto di un'istanza
Per interrompere un' Amazon EC2 istanza, chiama il `stopInstances` metodo del EC2 client Amazon, fornendogli un codice [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StopInstancesRequest.html)contenente l'ID dell'istanza da interrompere.
**Importazioni**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StopInstancesRequest;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StopInstancesRequest request = new StopInstancesRequest()
.withInstanceIds(instance_id);
ec2.stopInstances(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java).
## Riavvio di un'istanza
Per riavviare un' Amazon EC2 istanza, chiama il `rebootInstances` metodo del EC2 client Amazon, fornendogli un file [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RebootInstancesRequest.html)contenente l'ID dell'istanza da riavviare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
RebootInstancesRequest request = new RebootInstancesRequest()
.withInstanceIds(instance_id);
RebootInstancesResult response = ec2.rebootInstances(request);
```
Guarda l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/RebootInstance.java).
## Descrizione di istanze
Per elencare le tue istanze, crea un metodo [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html)e richiama il `describeInstances` metodo del EC2 client Amazon. Restituirà un [DescribeInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesResult.html)oggetto che potrai utilizzare per elencare Amazon EC2 le istanze del tuo account e della tua regione.
Le istanze sono raggruppate in base alla *prenotazione*. Ogni prenotazione corrisponde alla chiamata a `startInstances` che ha avviato l'istanza. [Per elencare le tue istanze, devi prima chiamare la `DescribeInstancesResult` 'classe' `getReservations' method, and then call `getInstances` su ogni oggetto Reservation restituito.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Reservation.html)
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
I risultati vengono visualizzati in una pagina; è possibile ottenere ulteriori risultati passando il valore restituito dal `getNextToken` metodo dell'oggetto risultato al `setNextToken` metodo dell'oggetto di richiesta originale, quindi utilizzando lo stesso oggetto di richiesta nella chiamata successiva a. `describeInstances`
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeInstances.java).
## Monitoraggio di un'istanza
È possibile monitorare vari aspetti delle Amazon EC2 istanze, come l'utilizzo della CPU e della rete, la memoria disponibile e lo spazio rimanente su disco. Per ulteriori informazioni sul monitoraggio delle istanze, consulta [Monitoraggio Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) nella Guida per l' Amazon EC2 utente delle istanze Linux.
Per iniziare a monitorare un'istanza, devi crearne un'[MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/MonitorInstancesRequest.html)con l'ID dell'istanza da monitorare e passarla al `monitorInstances` metodo del EC2 client Amazon.
**Importazioni**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.MonitorInstancesRequest;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
MonitorInstancesRequest request = new MonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.monitorInstances(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## Arresto del monitoraggio delle istanze
Per interrompere il monitoraggio di un'istanza, [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/UnmonitorInstancesRequest.html)creane un'istanza con l'ID dell'istanza per interrompere il monitoraggio e passala al `unmonitorInstances` metodo del EC2 client Amazon.
**Importazioni**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.UnmonitorInstancesRequest;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
UnmonitorInstancesRequest request = new UnmonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.unmonitorInstances(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java).
## Ulteriori informazioni
+ [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)nell' Amazon EC2 API Reference
+ [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)nell' Amazon EC2 API Reference
+ [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)nell' Amazon EC2 API Reference
+ [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)nell' Amazon EC2 API Reference
+ [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html)nell' Amazon EC2 API Reference
+ [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html)nell' Amazon EC2 API Reference
+ [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html)nell' Amazon EC2 API Reference
# Utilizzo di indirizzi IP elastici in Amazon EC2
## EC2-Classic sta per andare in pensione
**avvertimento**
Ritireremo EC2 -Classic il 15 agosto 2022. Ti consigliamo di migrare da EC2 -Classic a un VPC. Per ulteriori informazioni, consulta il post sul blog [EC2-Classic-Classic Networking is Retiring](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/) — Ecco come prepararsi.
## Allocazione di un indirizzo IP elastico
Per utilizzare un indirizzo IP elastico bisogna prima allocarne uno al proprio account e associarlo con la propria istanza o con un'interfaccia di rete.
Per allocare un indirizzo IP elastico, chiama il `allocateAddress` metodo del EC2 client Amazon con un [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressRequest.html)oggetto contenente il tipo di rete (classica EC2 o VPC).
Il file restituito [AllocateAddressResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressResult.html)contiene un ID di allocazione che puoi utilizzare per associare l'indirizzo a un'istanza, passando l'ID di allocazione e l'ID dell'istanza in a [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AssociateAddressRequest.html)al metodo del EC2 `associateAddress` client Amazon.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Guarda l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/AllocateAddress.java).
## Descrizione degli indirizzi IP elastici
Per elencare gli indirizzi IP elastici assegnati al tuo account, chiama il `describeAddresses` metodo di Amazon EC2 Client. Restituisce un valore [DescribeAddressesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAddressesResult.html)che puoi utilizzare per ottenere un elenco di oggetti [Address](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Address.html) che rappresentano gli indirizzi IP elastici del tuo account.
**Importazioni**
```
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;
```
**Codice**
```
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());
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAddresses.java).
## Rilascio di un indirizzo IP elastico
Per rilasciare un indirizzo IP elastico, chiama il `releaseAddress` metodo del EC2 client Amazon, passandogli un indirizzo [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/ReleaseAddressRequest.html)contenente l'ID di allocazione dell'indirizzo IP elastico che desideri rilasciare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
ReleaseAddressRequest request = new ReleaseAddressRequest()
.withAllocationId(alloc_id);
ReleaseAddressResult response = ec2.releaseAddress(request);
```
Dopo aver rilasciato un indirizzo IP elastico, questo viene rilasciato al pool di indirizzi AWS IP e in seguito potrebbe non essere più disponibile. Assicurati di aggiornare i record DNS e gli eventuali server o dispositivi che comunicano con l'indirizzo. Se tenti di rilasciare un indirizzo IP elastico che hai già rilasciato, riceverai un *AuthFailure*errore se l'indirizzo è già assegnato a un altro. Account AWS
Se utilizzi *EC2-Classic* o un *VPC predefinito*, il rilascio di un indirizzo IP elastico lo dissocia automaticamente da qualsiasi istanza a cui è associato. Per dissociare un indirizzo IP elastico senza rilasciarlo, utilizza il metodo di `disassociateAddress` Amazon EC2 Client.
Se utilizzi un VPC non di default, *devi* utilizzare `disassociateAddress` per disassociare l'indirizzo IP elastico prima di provare a rilasciarlo. *Altrimenti, Amazon EC2 restituisce un errore (non valido. IPAddress InUse*).
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/ReleaseAddress.java).
## Ulteriori informazioni
+ [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella Guida per l' Amazon EC2 utente per le istanze Linux
+ [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html)nell' Amazon EC2 API Reference
+ [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)nell' Amazon EC2 API Reference
+ [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html)nell' Amazon EC2 API Reference
# Usa aree e zone di disponibilità
## Descrivere le regioni
Per elencare le regioni disponibili per il tuo account, chiama il `describeRegions` metodo del EC2 cliente Amazon. Restituisce [DescribeRegionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeRegionsResult.html). Chiamare il metodo `getRegions` dell'oggetto restituito per ottenere un elenco di oggetti [Region](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Region.html) che rappresentano ciascuna regione.
**Importazioni**
```
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;
```
**Codice**
```
DescribeRegionsResult regions_response = ec2.describeRegions();
for(Region region : regions_response.getRegions()) {
System.out.printf(
"Found region %s " +
"with endpoint %s",
region.getRegionName(),
region.getEndpoint());
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Descrivere le zone di disponibilità
Per elencare ogni zona di disponibilità disponibile per il tuo account, chiama il `describeAvailabilityZones` metodo del EC2 client Amazon. Restituisce [DescribeAvailabilityZonesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAvailabilityZonesResult.html). Chiama il suo `getAvailabilityZones` metodo per ottenere un elenco di [AvailabilityZone](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AvailabilityZone.html)oggetti che rappresentano ogni zona di disponibilità.
**Importazioni**
```
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;
```
**Codice**
```
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());
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java).
## Descrivere gli account
Per descrivere il tuo account, chiama il `describeAccountAttributes` metodo del EC2 client Amazon. Questo metodo restituisce un [DescribeAccountAttributesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAccountAttributesResult.html)oggetto. Invoca questo `getAccountAttributes` metodo degli oggetti per ottenere un elenco di [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)oggetti. È possibile scorrere l'elenco per recuperare un oggetto. [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)
Puoi ottenere i valori degli attributi del tuo account richiamando il metodo dell'[AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html)oggetto. `getAttributeValues` Questo metodo restituisce un elenco di [AccountAttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttributeValue.html)oggetti. È possibile scorrere questo secondo elenco per visualizzare il valore degli attributi (vedere l'esempio di codice riportato di seguito).
**Importazioni**
```
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;
```
**Codice**
```
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();
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAccount.java) su GitHub.
## Ulteriori informazioni
+ [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella Guida Amazon EC2 utente per le istanze Linux
+ [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html)nel riferimento Amazon EC2 API
+ [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html)nell' Amazon EC2 API Reference
# Lavorare con coppie di Amazon EC2 chiavi
## Creazione di una coppia di chiavi
Per creare una coppia di chiavi, chiama il `createKeyPair` metodo del EC2 client Amazon con un [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html)che contiene il nome della chiave.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateKeyPairRequest request = new CreateKeyPairRequest()
.withKeyName(key_name);
CreateKeyPairResult response = ec2.createKeyPair(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateKeyPair.java).
## Descrizione delle coppie di chiavi
Per elencare le tue coppie di chiavi o per ottenere informazioni su di esse, chiama il `describeKeyPairs` metodo del EC2 client Amazon. Restituisce un [DescribeKeyPairsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeKeyPairsResult.html)comando che puoi usare per accedere all'elenco delle coppie di chiavi chiamando il relativo `getKeyPairs` metodo, che restituisce un elenco di [KeyPairInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPairInfo.html)oggetti.
**Importazioni**
```
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;
```
**Codice**
```
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());
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeKeyPairs.java).
## Eliminazione di una coppia di chiavi
Per eliminare una coppia di chiavi, chiama il `deleteKeyPair` metodo del EC2 client Amazon, passandogli un codice [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteKeyPairRequest.html)contenente il nome della coppia di chiavi da eliminare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteKeyPairRequest request = new DeleteKeyPairRequest()
.withKeyName(key_name);
DeleteKeyPairResult response = ec2.deleteKeyPair(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteKeyPair.java).
## Ulteriori informazioni
+ [Amazon EC2 Coppie di chiavi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) nella Guida per l' Amazon EC2 utente per le istanze Linux
+ [CreateKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html)nel riferimento alle Amazon EC2 API
+ [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html)nell' Amazon EC2 API Reference
+ [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html)nell' Amazon EC2 API Reference
# Lavorare con i gruppi di sicurezza in Amazon EC2
## Creazione di un gruppo di sicurezza
Per creare un gruppo di sicurezza, chiama il `createSecurityGroup` metodo del EC2 client Amazon con un [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html)che contiene il nome della chiave.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Configurazione di un gruppo di sicurezza
Un gruppo di sicurezza può controllare sia il traffico in entrata (ingresso) che quello in uscita (in uscita) verso le tue istanze. Amazon EC2
Per aggiungere regole di ingresso al tuo gruppo di sicurezza, usa il `authorizeSecurityGroupIngress` metodo di Amazon EC2 Client, fornendo il nome del gruppo di sicurezza e le regole di accesso ([IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html)) che desideri assegnargli all'interno di un [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupIngressRequest.html)oggetto. Nell'esempio seguente viene mostrato come aggiungere autorizzazioni IP a un gruppo di sicurezza.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Per aggiungere una regola di uscita al gruppo di sicurezza, fornisci dati simili nel `authorizeSecurityGroupEgress` metodo del EC2 cliente Amazon. [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html)
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java).
## Descrizione di gruppi di sicurezza
Per descrivere i tuoi gruppi di sicurezza o ottenere informazioni su di essi, chiama il `describeSecurityGroups` metodo di Amazon EC2 Client. Restituisce un [DescribeSecurityGroupsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSecurityGroupsResult.html)comando che puoi usare per accedere all'elenco dei gruppi di sicurezza chiamando il relativo `getSecurityGroups` metodo, che restituisce un elenco di [SecurityGroup](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/SecurityGroup.html)oggetti.
**Importazioni**
```
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;
```
**Codice**
```
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];
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeSecurityGroups.java).
## Eliminazione di un gruppo di sicurezza
Per eliminare un gruppo di sicurezza, chiama il `deleteSecurityGroup` metodo del EC2 client Amazon, passandogli un gruppo di sicurezza [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteSecurityGroupRequest.html)che contiene l'ID del gruppo di sicurezza da eliminare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteSecurityGroupRequest request = new DeleteSecurityGroupRequest()
.withGroupId(group_id);
DeleteSecurityGroupResult response = ec2.deleteSecurityGroup(request);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteSecurityGroup.java).
## Ulteriori informazioni
+ [Amazon EC2 Gruppi di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) nella Guida per l' Amazon EC2 utente per le istanze Linux
+ [Autorizzazione del traffico in entrata per le istanze Linux nella Guida per l' Amazon EC2 utente per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) Linux
+ [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)nella guida di riferimento alle API Amazon EC2
+ [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)nell' Amazon EC2 API Reference
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)nell' Amazon EC2 API Reference
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)nell' Amazon EC2 API Reference
# Esempi IAM che utilizzano il AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [IAM](https://aws.amazon.com/iam/) con [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
AWS Identity and Access Management (IAM) consente di controllare in modo sicuro l'accesso ai AWS servizi e alle risorse per gli utenti. Utilizzando IAM, puoi creare e gestire AWS utenti e gruppi e utilizzare le autorizzazioni per consentire e negare il loro accesso alle risorse. AWS Per una guida completa a IAM, consulta la Guida per l'[IAM utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Gestione delle chiavi di accesso IAM](examples-iam-access-keys.md)
+ [Gestione degli utenti IAM](examples-iam-users.md)
+ [Utilizzo di alias dell'account IAM](examples-iam-account-aliases.md)
+ [Lavorare con le policy IAM](examples-iam-policies.md)
+ [Utilizzo dei certificati del server IAM](examples-iam-server-certificates.md)
# Gestione delle chiavi di accesso IAM
## Creazione di una chiave di accesso
Per creare una chiave di accesso IAM, chiama il AmazonIdentityManagementClient `createAccessKey` metodo con un [CreateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccessKeyRequest.html)oggetto.
`CreateAccessKeyRequest`ha due costruttori, uno che richiede un nome utente e l'altro senza parametri. Se utilizzate la versione che non accetta parametri, dovete impostare il nome utente utilizzando il metodo `withUserName` setter prima di passarlo al `createAccessKey` metodo.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccessKeyRequest request = new CreateAccessKeyRequest()
.withUserName(user);
CreateAccessKeyResult response = iam.createAccessKey(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccessKey.java) su. GitHub
## Elencazione delle chiavi di accesso
Per elencare le chiavi di accesso per un determinato utente, create un [ListAccessKeysRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysRequest.html)oggetto che contenga il nome utente per cui elencare le chiavi e passatelo al `listAccessKeys` metodo AmazonIdentityManagementClient's.
**Nota**
Se non fornite un nome utente`listAccessKeys`, tenterà di elencare le chiavi di accesso associate a chi Account AWS ha firmato la richiesta.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
I risultati di `listAccessKeys` sono paginati (con un massimo predefinito di 100 record per chiamata). È possibile richiamare `getIsTruncated` l'[ListAccessKeysResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysResult.html)oggetto restituito per verificare se la query ha restituito un numero inferiore di risultati rispetto a quelli disponibili. In tal caso, chiamate `setMarker` `ListAccessKeysRequest` e passatelo alla successiva invocazione di. `listAccessKeys`
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccessKeys.java) su. GitHub
## Recupero dell'ora ultimo utilizzo di una chiave di accesso
Per sapere l'ora in cui è stata utilizzata l'ultima volta una chiave di accesso, chiamate il `getAccessKeyLastUsed` metodo AmazonIdentityManagementClient's con l'ID della chiave di accesso (che può essere passato utilizzando un [GetAccessKeyLastUsedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedRequest.html)oggetto) o direttamente all'overload che accetta direttamente l'ID della chiave di accesso.
È quindi possibile utilizzare l'[GetAccessKeyLastUsedResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedResult.html)oggetto restituito per recuperare l'ultima ora utilizzata della chiave.
**Importazioni**
```
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;
```
**Codice**
```
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());
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AccessKeyLastUsed.java) su. GitHub
## Attivazione o disattivazione delle chiavi di accesso
È possibile attivare o disattivare una chiave di accesso creando un [UpdateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateAccessKeyRequest.html)oggetto, fornendo l'ID della chiave di accesso, facoltativamente il nome utente e [lo Status](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/StatusType.html) desiderato, quindi passando l'oggetto della richiesta al metodo AmazonIdentityManagementClient's`updateAccessKey`.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
.withAccessKeyId(access_id)
.withUserName(username)
.withStatus(status);
UpdateAccessKeyResult response = iam.updateAccessKey(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateAccessKey.java) su. GitHub
## Eliminazione di una chiave di accesso
Per eliminare definitivamente una chiave di accesso, chiama il `deleteKey` metodo AmazonIdentityManagementClient's, fornendogli un ID e il nome utente [DeleteAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccessKeyRequest.html)contenenti l'ID e il nome utente della chiave di accesso.
**Nota**
Dopo che è stata eliminata, una chiave non può più essere recuperata né utilizzata. Per disattivare temporaneamente una chiave in modo che possa essere riattivata in un secondo momento, usa invece [updateAccessKey](#iam-access-keys-update)method.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
.withAccessKeyId(access_key)
.withUserName(username);
DeleteAccessKeyResult response = iam.deleteAccessKey(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccessKey.java) su. GitHub
## Ulteriori informazioni
+ [CreateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)nel riferimento all'API IAM
+ [ListAccessKeys](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccessKeys.html)nel riferimento all'API IAM
+ [GetAccessKeyLastUsed](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetAccessKeyLastUsed.html)nel riferimento all'API IAM
+ [UpdateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAccessKey.html)nel riferimento all'API IAM
+ [DeleteAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html)nel riferimento all'API IAM
# Gestione degli utenti IAM
## Creazione di un utente
Crea un nuovo utente IAM fornendo il nome utente al `createUser` metodo AmazonIdentityManagementClient's, direttamente o utilizzando un [CreateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateUserRequest.html)oggetto contenente il nome utente.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateUserRequest request = new CreateUserRequest()
.withUserName(username);
CreateUserResult response = iam.createUser(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateUser.java) su GitHub.
## Elencazione di utenti
Per elencare gli utenti IAM del tuo account, creane uno nuovo [ListUsersRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListUsersRequest.html)e passalo al `listUsers` metodo AmazonIdentityManagementClient's. Puoi recuperare l'elenco degli utenti `getUsers` chiamando l'[ListUsersResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListUsersResult.html)oggetto restituito.
L'elenco di utenti restituito da `listUsers` è paginato. È possibile verificare se ci sono più risultati da recuperare chiamando il metodo `getIsTruncated` dell'oggetto di risposta. Se restituisce`true`, chiama il `setMarker()` metodo dell'oggetto di richiesta, passandogli il valore restituito dal `getMarker()` metodo dell'oggetto di risposta.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListUsers.java) su GitHub.
## Aggiornamento di un utente
Per aggiornare un utente, chiamate il `updateUser` metodo dell' AmazonIdentityManagementClient oggetto, che accetta un [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)oggetto che potete usare per modificare il *nome* o il *percorso* dell'utente.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateUserRequest request = new UpdateUserRequest()
.withUserName(cur_name)
.withNewUserName(new_name);
UpdateUserResult response = iam.updateUser(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateUser.java) su GitHub.
## Eliminazione di un utente
Per eliminare un utente, chiama la `deleteUser` richiesta AmazonIdentityManagementClient's con un [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html)oggetto impostato con il nome utente da eliminare.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteUser.java) su GitHub.
## Ulteriori informazioni
+ [Utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) nella Guida IAM per l'utente
+ [Gestione degli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) nella Guida IAM per l'utente
+ [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html)nella guida di riferimento all'API IAM
+ [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)nel riferimento all'API IAM
+ [UpdateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateUser.html)nel riferimento all'API IAM
+ [DeleteUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUser.html)nel riferimento all'API IAM
# Utilizzo di alias dell'account IAM
Se desideri che l'URL della tua pagina di accesso contenga il nome della tua azienda o un altro identificativo descrittivo anziché il tuo Account AWS ID, puoi creare un alias per il tuo. Account AWS
**Nota**
AWS supporta esattamente un alias di account per account.
## Creazione di un alias dell'account
Per creare un alias di account, chiama il `createAccountAlias` metodo AmazonIdentityManagementClient's con un [CreateAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccountAliasRequest.html)oggetto che contiene il nome dell'alias.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccountAliasRequest request = new CreateAccountAliasRequest()
.withAccountAlias(alias);
CreateAccountAliasResult response = iam.createAccountAlias(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccountAlias.java) su. GitHub
## Elencazione di alias dell'account
Per elencare l'alias del tuo account, se esiste, chiama il `listAccountAliases` metodo AmazonIdentityManagementClient's.
**Nota**
Il metodo restituito [ListAccountAliasesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListAccountAliasesResult.html)supporta gli stessi `getMarker` metodi `getIsTruncated` e AWS SDK per Java *degli altri metodi di elenco*, ma Account AWS può avere un *solo* alias di account.
**importazioni**
```
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);
}
```
vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccountAliases.java) su. GitHub
## Eliminazione di un alias dell'account
Per eliminare l'alias del tuo account, chiama il `deleteAccountAlias` metodo AmazonIdentityManagementClient's. Quando si elimina l'alias di un account, è necessario fornirne il nome utilizzando un oggetto. [DeleteAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccountAliasRequest.html)
**importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
.withAccountAlias(alias);
DeleteAccountAliasResult response = iam.deleteAccountAlias(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccountAlias.java) su. GitHub
## Ulteriori informazioni
+ [L'ID AWS dell'account e il relativo alias](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html) nella Guida per l' IAM utente
+ [CreateAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccountAlias.html)nel riferimento all'API IAM
+ [ListAccountAliases](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccountAliases.html)nel riferimento all'API IAM
+ [DeleteAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccountAlias.html)nel riferimento all'API IAM
# Lavorare con le policy IAM
## Creazione di una policy
Per creare una nuova policy, fornisci il nome della policy e un documento di policy in formato JSON utilizzando un [CreatePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreatePolicyRequest.html)metodo to the's. AmazonIdentityManagementClient `createPolicy`
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreatePolicyRequest request = new CreatePolicyRequest()
.withPolicyName(policy_name)
.withPolicyDocument(POLICY_DOCUMENT);
CreatePolicyResult response = iam.createPolicy(request);
```
[I documenti relativi alle policy IAM sono stringhe JSON con una sintassi ben documentata.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html) Nell'esempio che segue viene fornito l'accesso per effettuare richieste particolari a 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\"" +
" }" +
" ]" +
"}";
```
[Vedi l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreatePolicy.java) GitHub
## Recupero di una policy
Per recuperare una policy esistente, chiamate il `getPolicy` metodo AmazonIdentityManagementClient's, fornendo l'ARN della policy all'interno [GetPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetPolicyRequest.html)di un oggetto.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetPolicyRequest request = new GetPolicyRequest()
.withPolicyArn(policy_arn);
GetPolicyResult response = iam.getPolicy(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetPolicy.java) su. GitHub
## Collegamento di una policy del ruolo
Puoi allegare una policy a IAMhttp: //docs.aws.amazon. com/IAM/latest/UserGuide/id\$1roles.html [role] chiamando il `attachRolePolicy` metodo AmazonIdentityManagementClient's, fornendogli il nome del ruolo e l'ARN della policy in un. [AttachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/AttachRolePolicyRequest.html)
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
AttachRolePolicyRequest attach_request =
new AttachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(POLICY_ARN);
iam.attachRolePolicy(attach_request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) su. GitHub
## Elencazione di policy dei ruoli collegate
Elenca le politiche allegate su un ruolo chiamando il `listAttachedRolePolicies` metodo AmazonIdentityManagementClient's. È necessario un [ListAttachedRolePoliciesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesRequest.html)oggetto che contenga il nome del ruolo per cui elencare le politiche.
Richiama `getAttachedPolicies` l'[ListAttachedRolePoliciesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesResult.html)oggetto restituito per ottenere l'elenco delle politiche allegate. I risultati possono essere troncati; se il `getIsTruncated` metodo dell'`ListAttachedRolePoliciesResult`oggetto restituisce`true`, chiama il `setMarker` metodo dell'`ListAttachedRolePoliciesRequest`oggetto e usalo per richiamare `listAttachedRolePolicies` nuovamente per ottenere il successivo batch di risultati.
**Importazioni**
```
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;
```
**Codice**
```
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());
}
```
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) su. GitHub
## Distaccare una policy del ruolo
Per scollegare una policy da un ruolo, chiamate il `detachRolePolicy` metodo AmazonIdentityManagementClient th's, fornendogli il nome del ruolo e l'ARN della policy in a. [DetachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DetachRolePolicyRequest.html)
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DetachRolePolicyRequest request = new DetachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(policy_arn);
DetachRolePolicyResult response = iam.detachRolePolicy(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DetachRolePolicy.java) su. GitHub
## Ulteriori informazioni
+ [Panoramica delle politiche IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) nella Guida IAM per l'utente.
+ [AWS Riferimento alle politiche IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) nella Guida IAM per l'utente.
+ [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)nel riferimento all'API IAM
+ [GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html)nel riferimento all'API IAM
+ [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)nel riferimento all'API IAM
+ [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)nel riferimento all'API IAM
+ [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html)nel riferimento all'API IAM
# Utilizzo dei certificati del server IAM
*Per abilitare le connessioni HTTPS al tuo sito Web o alla tua applicazione AWS, devi disporre di un certificato del server SSL/TLS.* È possibile utilizzare un certificato server fornito da AWS Certificate Manager o uno ottenuto da un provider esterno.
Ti consigliamo di utilizzare ACM per fornire, gestire e distribuire i certificati del server. Con ACM puoi richiedere un certificato, distribuirlo nelle tue AWS risorse e lasciare che ACM gestisca i rinnovi dei certificati per te. I certificati forniti da ACM sono gratuiti. [Per ulteriori informazioni su ACM, consulta la ACM User Guide.](https://docs.aws.amazon.com/acm/latest/userguide/)
## Ottenere un certificato del server
È possibile recuperare un certificato del server chiamando il `getServerCertificate` metodo AmazonIdentityManagementClient's e passandogli un certificato [GetServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetServerCertificateRequest.html)con il nome del certificato.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetServerCertificateRequest request = new GetServerCertificateRequest()
.withServerCertificateName(cert_name);
GetServerCertificateResult response = iam.getServerCertificate(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetServerCertificate.java) su. GitHub
## Elencazione di certificati del server
Per elencare i certificati del tuo server, chiama il `listServerCertificates` metodo AmazonIdentityManagementClient's con un [ListServerCertificatesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesRequest.html). Restituisce [ListServerCertificatesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesResult.html).
Chiama il `getServerCertificateMetadataList` metodo dell'`ListServerCertificateResult`oggetto restituito per ottenere un elenco di [ServerCertificateMetadata](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ServerCertificateMetadata.html)oggetti che puoi utilizzare per ottenere informazioni su ciascun certificato.
I risultati possono essere troncati; se il `getIsTruncated` metodo dell'`ListServerCertificateResult`oggetto restituisce`true`, chiama il `setMarker` metodo dell'`ListServerCertificatesRequest`oggetto e usalo per richiamare `listServerCertificates` nuovamente e ottenere il successivo batch di risultati.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListServerCertificates.java) su. GitHub
## Aggiornamento di un certificato del server
È possibile aggiornare il nome o il percorso di un certificato del server chiamando il `updateServerCertificate` metodo AmazonIdentityManagementClient's. Richiede un [UpdateServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateServerCertificateRequest.html)oggetto impostato con il nome corrente del certificato del server e un nuovo nome o un nuovo percorso da utilizzare.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateServerCertificateRequest request =
new UpdateServerCertificateRequest()
.withServerCertificateName(cur_name)
.withNewServerCertificateName(new_name);
UpdateServerCertificateResult response =
iam.updateServerCertificate(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateServerCertificate.java) su GitHub.
## Eliminazione di un certificato del server
Per eliminare un certificato del server, chiama il `deleteServerCertificate` metodo AmazonIdentityManagementClient's con un [DeleteServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteServerCertificateRequest.html)contenente il nome del certificato.
**Importazioni**
```
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;
```
**Codice**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteServerCertificateRequest request =
new DeleteServerCertificateRequest()
.withServerCertificateName(cert_name);
DeleteServerCertificateResult response =
iam.deleteServerCertificate(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteServerCertificate.java) su GitHub.
## Ulteriori informazioni
+ [Utilizzo dei certificati server](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) nella Guida per l' IAM utente
+ [GetServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServerCertificate.html)nella guida di riferimento all'API IAM
+ [ListServerCertificates](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListServerCertificates.html)nel riferimento all'API IAM
+ [UpdateServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateServerCertificate.html)nel riferimento all'API IAM
+ [DeleteServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServerCertificate.html)nel riferimento all'API IAM
+ [Guida per l'utente di ACM](https://docs.aws.amazon.com/acm/latest/userguide/)
# Lambda Esempi di utilizzo di AWS SDK per Java
Questa sezione fornisce esempi di programmazione Lambda utilizzando AWS SDK per Java.
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Operazioni di servizio](examples-lambda.md)
# Funzioni di richiamo, elenco ed eliminazione Lambda
Questa sezione fornisce esempi di programmazione con il client Lambda di servizio utilizzando. AWS SDK per Java Per informazioni su come creare una Lambda funzione, vedere [Come creare AWS Lambda funzioni](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/lambda-tutorial.html).
**Topics**
+ [Richiamo di una funzione](#invoke-function)
+ [Elencare le funzioni](#list-function)
+ [Eliminare una funzione](#delete-function)
## Richiamo di una funzione
È possibile richiamare una Lambda funzione creando un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)oggetto e richiamando il relativo `invoke` metodo. Create un [InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)oggetto per specificare informazioni aggiuntive come il nome della funzione e il payload da passare alla funzione. Lambda I nomi delle funzioni vengono visualizzati come *arn:aws:lambda:us-east- 1:555556330391:function*:. HelloFunction È possibile recuperare il valore osservando la funzione in. Console di gestione AWS
Per passare i dati del payload a una funzione, richiamate il `withPayload` metodo dell'[InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html)oggetto e specificate una stringa in formato JSON, come illustrato nel seguente esempio di codice.
**Importazioni**
```
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;
```
**Codice**
Il seguente esempio di codice mostra come richiamare una funzione. Lambda
```
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());
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/LambdaInvokeFunction.java) su GitHub.
## Elencare le funzioni
Costruisci un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)oggetto e richiama il suo metodo. `listFunctions` Questo metodo restituisce un [ListFunctionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/ListFunctionsResult.html)oggetto. È possibile richiamare il `getFunctions` metodo di questo oggetto per restituire un elenco di [FunctionConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/FunctionConfiguration.html)oggetti. È possibile scorrere l'elenco per recuperare informazioni sulle funzioni. Il seguente esempio di codice Java mostra come ottenere i nomi di ogni funzione.
**Importazioni**
```
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;
```
**Codice**
Il seguente esempio di codice Java mostra come recuperare un elenco di nomi di Lambda funzioni.
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/ListFunctions.java) su GitHub.
## Eliminare una funzione
Costruisci un [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html)oggetto e invoca il suo metodo. `deleteFunction` Crea un [DeleteFunctionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/DeleteFunctionRequest.html)oggetto e passalo al `deleteFunction` metodo. Questo oggetto contiene informazioni quali il nome della funzione da eliminare. I nomi delle funzioni vengono visualizzati come *arn:aws:lambda:us-east- 1:555556330391:function*:. HelloFunction È possibile recuperare il valore osservando la funzione in. Console di gestione AWS
**Importazioni**
```
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;
```
**Codice**
Il seguente codice Java mostra come eliminare una Lambda funzione.
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/DeleteFunction.java) su GitHub.
# Amazon Pinpoint Esempi di utilizzo di AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [Amazon Pinpoint](https://aws.amazon.com/pinpoint/) utilizzando [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Creazione ed eliminazione di app in Amazon Pinpoint](examples-pinpoint-create-app.md)
+ [Creazione di endpoint in Amazon Pinpoint](examples-pinpoint-create-endpoint.md)
+ [Creazione di segmenti in Amazon Pinpoint](examples-pinpoint-create-segment.md)
+ [Creazione di campagne in Amazon Pinpoint](examples-pinpoint-create-campaign.md)
+ [Aggiornamento dei canali in Amazon Pinpoint](examples-pinpoint-update-channel.md)
# Creazione ed eliminazione di app in Amazon Pinpoint
Un'app è un Amazon Pinpoint progetto in cui definisci il pubblico di un'applicazione distinta e coinvolgi questo pubblico con messaggi personalizzati. Gli esempi in questa pagina mostrano come creare una nuova app o eliminarne una esistente.
## Creare un'app
Crea una nuova app Amazon Pinpoint fornendo un nome di app all'[CreateAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateAppRequest.html)oggetto e quindi passando quell'oggetto al `createApp` metodo AmazonPinpointClient's.
**Importazioni**
```
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;
```
**Codice**
```
CreateApplicationRequest appRequest = new CreateApplicationRequest()
.withName(appName);
CreateAppRequest request = new CreateAppRequest();
request.withCreateApplicationRequest(appRequest);
CreateAppResult result = pinpoint.createApp(request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) su GitHub.
## Eliminare un'app
Per eliminare un'app, AmazonPinpointClient chiama la `deleteApp` richiesta con un [DeleteAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/DeleteAppRequest.html)oggetto impostato con il nome dell'app da eliminare.
**Importazioni**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
```
**Codice**
```
DeleteAppRequest deleteRequest = new DeleteAppRequest()
.withApplicationId(appID);
pinpoint.deleteApp(deleteRequest);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/DeleteApp.java) su GitHub.
## Ulteriori informazioni
+ [App](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apps.html) nell' Amazon Pinpoint API Reference
+ [App](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-app.html) nell' Amazon Pinpoint API Reference
# Creazione di endpoint in Amazon Pinpoint
Un endpoint identifica in modo univoco un dispositivo utente al quale è possibile inviare notifiche push. Amazon Pinpoint Se l'app è abilitata al Amazon Pinpoint supporto, l'app registra automaticamente un endpoint ogni Amazon Pinpoint volta che un nuovo utente apre l'app. L'esempio seguente mostra come aggiungere un nuovo endpoint a livello di codice.
## Creazione di un endpoint
Crea un nuovo endpoint in fornendo i dati dell'endpoint in Amazon Pinpoint un oggetto. [EndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/EndpointRequest.html)
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Quindi crea un [UpdateEndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateEndpointRequest.html)oggetto con quell' EndpointRequest oggetto. Infine, passa l' UpdateEndpointRequest oggetto al `updateEndpoint` metodo AmazonPinpointClient's.
**Codice**
```
UpdateEndpointRequest updateEndpointRequest = new UpdateEndpointRequest()
.withApplicationId(appId)
.withEndpointId(endpointId)
.withEndpointRequest(endpointRequest);
UpdateEndpointResult updateEndpointResponse = client.updateEndpoint(updateEndpointRequest);
System.out.println("Update Endpoint Response: " + updateEndpointResponse.getMessageBody());
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateEndpoint.java) su GitHub.
## Ulteriori informazioni
+ [Aggiungere Endpoint](https://docs.aws.amazon.com/pinpoint/latest/developerguide/endpoints.html) nella Guida per gli Amazon Pinpoint sviluppatori
+ [Endpoint nell'API](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-endpoint.html) Reference Amazon Pinpoint
# Creazione di segmenti in Amazon Pinpoint
Un segmento di utenti rappresenta un sottoinsieme dei tuoi utenti basato su caratteristiche condivise, ad esempio l'ultima volta che un utente ha aperto la tua app o il dispositivo che utilizza. L'esempio seguente mostra come definire un segmento di utenti.
## Creazione di un segmento
Crea un nuovo segmento Amazon Pinpoint definendo le dimensioni del segmento in un [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)oggetto.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Quindi imposta l'[SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html)oggetto in a [WriteSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteSegmentRequest.html), che a sua volta viene utilizzato per creare un [CreateSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateSegmentRequest.html)oggetto. Quindi passa l' CreateSegmentRequest oggetto al `createSegment` metodo AmazonPinpointClient's.
**Codice**
```
WriteSegmentRequest writeSegmentRequest = new WriteSegmentRequest()
.withName("MySegment").withDimensions(dimensions);
CreateSegmentRequest createSegmentRequest = new CreateSegmentRequest()
.withApplicationId(appId).withWriteSegmentRequest(writeSegmentRequest);
CreateSegmentResult createSegmentResult = client.createSegment(createSegmentRequest);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) su GitHub.
## Ulteriori informazioni
+ [Amazon Pinpoint Segmenti](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments.html) nella Guida per l' Amazon Pinpoint utente
+ [Creazione di segmenti nella Guida](https://docs.aws.amazon.com/pinpoint/latest/developerguide/segments.html) per gli sviluppatori Amazon Pinpoint
+ [Segmenti nell'API](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segments.html) Reference Amazon Pinpoint
+ [Segmento](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segment.html) nell' Amazon Pinpoint API Reference
# Creazione di campagne in Amazon Pinpoint
Puoi utilizzare le campagne per aumentare il coinvolgimento tra la tua app e i tuoi utenti. Puoi creare una campagna per raggiungere un determinato segmento di utenti con messaggi personalizzati o promozioni speciali. Questo esempio dimostra come creare una nuova campagna standard che invii una notifica push personalizzata a un segmento specifico.
## Creazione di una campagna
Prima di creare una nuova campagna, devi definire una [pianificazione](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Schedule.html) e un [messaggio](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Message.html) e impostare questi valori in un [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)oggetto.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Quindi crea una nuova campagna Amazon Pinpoint [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html)fornendo la configurazione della campagna a un [CreateCampaignRequest](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/pinpoint/model/CreateCampaignRequest.html)oggetto. Infine, passa l' CreateCampaignRequest oggetto al `createCampaign` metodo AmazonPinpointClient's.
**Codice**
```
CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest()
.withApplicationId(appId).withWriteCampaignRequest(request);
CreateCampaignResult result = client.createCampaign(createCampaignRequest);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) su GitHub.
## Ulteriori informazioni
+ [Amazon Pinpoint Campagne](https://docs.aws.amazon.com/pinpoint/latest/userguide/campaigns.html) nella Guida Amazon Pinpoint per l'utente
+ [Creazione di campagne](https://docs.aws.amazon.com/pinpoint/latest/developerguide/campaigns.html) nella Guida per Amazon Pinpoint gli sviluppatori
+ [Campagne](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaigns.html) nell' Amazon Pinpoint API Reference
+ [Campagna](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign.html) nell' Amazon Pinpoint API Reference
+ [Attività della campagna](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-activities.html) nell' Amazon Pinpoint API Reference
+ [Versioni della campagna](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-versions.html) nell' Amazon Pinpoint API Reference
+ [Versione della campagna](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-version.html) nell' Amazon Pinpoint API Reference
# Aggiornamento dei canali in Amazon Pinpoint
Un canale definisce i tipi di piattaforme a cui è possibile recapitare messaggi. Questo esempio mostra come utilizzare il APNs canale per inviare un messaggio.
## Aggiornare un canale
Abilita l'accesso a un canale Amazon Pinpoint fornendo un ID app e un oggetto di richiesta del tipo di canale che desideri aggiornare. Questo esempio aggiorna il APNs canale, che richiede l'oggetto [APNSChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/APNSChannelRequest.html). Impostateli nel [UpdateApnsChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateApnsChannelRequest.html)e passate l'oggetto al `updateApnsChannel` metodo AmazonPinpointClient's.
**Importazioni**
```
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;
```
**Codice**
```
APNSChannelRequest request = new APNSChannelRequest()
.withEnabled(enabled);
UpdateApnsChannelRequest updateRequest = new UpdateApnsChannelRequest()
.withAPNSChannelRequest(request)
.withApplicationId(appId);
UpdateApnsChannelResult result = client.updateApnsChannel(updateRequest);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/UpdateChannel.java) su GitHub.
## Ulteriori informazioni
+ [Amazon Pinpoint Canali](https://docs.aws.amazon.com/pinpoint/latest/userguide/channels.html) nella Guida Amazon Pinpoint per l'utente
+ [Canale ADM](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-adm-channel.html) nell' Amazon Pinpoint API Reference
+ [APNs Canale](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-channel.html) nell' Amazon Pinpoint API Reference
+ [APNs Sandbox Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-sandbox-channel.html) Amazon Pinpoint API Reference
+ [APNs Canale VoIP nell'API](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-channel.html) Reference Amazon Pinpoint
+ [APNs VoIP Sandbox Channel API Reference](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-sandbox-channel.html) Amazon Pinpoint
+ [Baidu Channel API Reference](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-baidu-channel.html) Amazon Pinpoint
+ [Canale di posta elettronica](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-email-channel.html) nell'API Reference Amazon Pinpoint
+ [Canale GCM](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-gcm-channel.html) nell' Amazon Pinpoint API Reference
+ [Canale SMS](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-sms-channel.html) nell' Amazon Pinpoint API Reference
# Amazon S3 Esempi di utilizzo di AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [Amazon S3](https://aws.amazon.com/s3/) utilizzando [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Creazione, elenco ed eliminazione Amazon S3 di bucket](examples-s3-buckets.md)
+ [Esecuzione di operazioni sugli Amazon S3 oggetti](examples-s3-objects.md)
+ [Gestione delle autorizzazioni di Amazon S3 accesso per bucket e oggetti](examples-s3-access-permissions.md)
+ [Gestione dell'accesso ai Amazon S3 bucket utilizzando le policy dei bucket](examples-s3-bucket-policies.md)
+ [Utilizzo TransferManager per Amazon S3 le operazioni](examples-s3-transfermanager.md)
+ [Configurazione di un Amazon S3 bucket come sito Web](examples-s3-website-configuration.md)
+ [Usa la Amazon S3 crittografia lato client](examples-crypto.md)
# Creazione, elenco ed eliminazione Amazon S3 di bucket
Ogni oggetto (file) contenuto Amazon S3 deve risiedere all'interno di un *bucket*, che rappresenta una raccolta (contenitore) di oggetti. Ogni bucket è conosciuto da una *chiave* (nome), che deve essere univoca. Per informazioni dettagliate sui bucket e sulla loro configurazione, consulta [Lavorare con Amazon S3 i bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) nella Guida per l' Amazon Simple Storage Service utente.
**Nota**
Best practice
Ti consigliamo di abilitare la regola del [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)ciclo di vita sui tuoi bucket. Amazon S3
Questa regola impone di interrompere Amazon S3 i caricamenti in più parti che non vengono completati entro un determinato numero di giorni dall'avvio. Quando viene superato il limite di tempo impostato, Amazon S3 interrompe il caricamento e quindi elimina i dati di caricamento incompleti.
Per ulteriori informazioni, consulta [Lifecycle Configuration for a Bucket with Versioning nella Guida per](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) l'utente. Amazon S3
**Nota**
Questi esempi di codice presuppongono che tu abbia compreso il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che tu abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione delle AWS credenziali](setup-credentials.md) e Area per lo sviluppo.
## Creare un bucket
Utilizza il metodo del client AmazonS3. `createBucket` Il nuovo [Bucket](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html) viene restituito. Il `createBucket` metodo genererà un'eccezione se il bucket esiste già.
**Nota**
Per verificare se esiste già un bucket prima di tentare di crearne uno con lo stesso nome, chiama il metodo. `doesBucketExist` Ritornerà `true` se il bucket esiste e in altro modo. `false`
**Importazioni**
```
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;
```
**Codice**
```
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;
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CreateBucket.java) su. GitHub
## Creazione di un elenco di bucket
Utilizza il metodo del client AmazonS3. `listBucket` In caso di successo, viene restituito un elenco di [Bucket](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html).
**Importazioni**
```
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;
```
**Codice**
```
List buckets = s3.listBuckets();
System.out.println("Your {S3} buckets are:");
for (Bucket b : buckets) {
System.out.println("* " + b.getName());
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListBuckets.java) su. GitHub
## Eliminazione di un bucket
Prima di poter eliminare un Amazon S3 bucket, devi assicurarti che sia vuoto, altrimenti si verificherà un errore. Se si dispone di un [bucket con versione](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), è necessario eliminare anche tutti gli oggetti con versione associati al bucket.
**Nota**
L'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) include ciascuno di questi passaggi in ordine, fornendo una soluzione completa per l'eliminazione di un bucket e del relativo contenuto. Amazon S3
**Topics**
+ [Rimuovi oggetti da un bucket senza versione prima di eliminarlo](#remove-objects-from-an-unversioned-bucket-before-deleting-it)
+ [Rimuovi oggetti da un bucket con versione prima di eliminarlo](#remove-objects-from-a-versioned-bucket-before-deleting-it)
+ [Eliminazione di un bucket vuoto](#delete-an-empty-bucket)
### Rimuovi oggetti da un bucket senza versione prima di eliminarlo
Utilizza il `listObjects` metodo del client AmazonS3 per recuperare l'elenco di oggetti ed eliminarli ciascuno. `deleteObject`
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) GitHub
### Rimuovi oggetti da un bucket con versione prima di eliminarlo
Se utilizzi un [bucket con versione](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), devi anche rimuovere tutte le versioni memorizzate degli oggetti nel bucket prima che il bucket possa essere eliminato.
Utilizzando uno schema simile a quello utilizzato per rimuovere gli oggetti all'interno di un bucket, rimuovi gli oggetti con versione utilizzando il `listVersions` metodo del client AmazonS3 per elencare tutti gli oggetti con versione e quindi eliminarli ciascuno. `deleteVersion`
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) GitHub
### Eliminazione di un bucket vuoto
Dopo aver rimosso gli oggetti da un bucket (compresi gli oggetti con versione), puoi eliminare il bucket stesso utilizzando il metodo del client AmazonS3. `deleteBucket`
**Importazioni**
```
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;
```
**Codice**
```
System.out.println(" OK, bucket ready to delete!");
s3.deleteBucket(bucket_name);
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) GitHub
# Esecuzione di operazioni sugli Amazon S3 oggetti
Un Amazon S3 oggetto rappresenta un *file* o una raccolta di dati. Ogni oggetto deve risiedere all'interno di un [bucket](examples-s3-buckets.md).
**Nota**
Questi esempi di codice presuppongono che l'utente comprenda il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione delle AWS credenziali e](setup-credentials.md) Area per lo sviluppo.
**Topics**
+ [Caricamento di un oggetto](#upload-object)
+ [Elenco di oggetti](#list-objects)
+ [Donwload di un oggetto](#download-object)
+ [Copiare, spostare o rinominare oggetti](#copy-object)
+ [Eliminazione di un oggetto](#delete-object)
+ [Eliminare più oggetti contemporaneamente](#delete-objects)
## Caricamento di un oggetto
Utilizza il `putObject` metodo del client AmazonS3, fornendo un nome di bucket, un nome chiave e un file da caricare. *Il bucket deve esistere* o si verificherà un errore.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/PutObject.java) su. GitHub
## Elenco di oggetti
Per ottenere un elenco di oggetti all'interno di un bucket, utilizza il `listObjects` metodo del client AmazonS3, fornendo il nome di un bucket.
Il `listObjects` metodo restituisce un [ObjectListing](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/ObjectListing.html)oggetto che fornisce informazioni sugli oggetti nel bucket. Per elencare i nomi degli oggetti (chiavi), usa il `getObjectSummaries` metodo per ottenere un elenco di ObjectSummary oggetti [S3](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectSummary.html), ognuno dei quali rappresenta un singolo oggetto nel bucket. Quindi chiama il suo `getKey` metodo per recuperare il nome dell'oggetto.
**Importazioni**
```
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;
```
**Codice**
```
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());
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListObjects.java) su. GitHub
## Donwload di un oggetto
Utilizza il `getObject` metodo del client AmazonS3, passandogli il nome di un bucket e dell'oggetto da scaricare. [In caso di successo, il metodo restituisce un oggetto S3Object.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3Object.html) *Il bucket e la chiave dell'oggetto specificati devono esistere, altrimenti si verificherà un errore*.
È possibile ottenere il contenuto dell'oggetto `getObjectContent` chiamando`S3Object`. Ciò restituisce un [S3 ObjectInputStream](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectInputStream.html) che si comporta come un oggetto Java `InputStream` standard.
L'esempio seguente scarica un oggetto da S3 e ne salva il contenuto in un file (utilizzando lo stesso nome della chiave dell'oggetto).
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetObject.java) su. GitHub
## Copiare, spostare o rinominare oggetti
Puoi copiare un oggetto da un bucket all'altro utilizzando il metodo del client AmazonS3. `copyObject` Richiede il nome del bucket da cui copiare, l'oggetto da copiare e il nome del bucket di destinazione.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Codice**
```
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!");
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CopyObject.java) su. GitHub
**Nota**
È possibile utilizzare [DeleteObject](#delete-object) **per** spostare **o** rinominare un oggetto, copiando prima l'oggetto `copyObject` con un nuovo nome (è possibile utilizzare lo stesso bucket sia come origine che come destinazione) e quindi eliminando l'oggetto dalla sua posizione precedente.
## Eliminazione di un oggetto
Utilizzate il `deleteObject` metodo del client AmazonS3, passandogli il nome di un bucket e dell'oggetto da eliminare. *Il bucket e la chiave dell'oggetto specificati devono esistere, altrimenti* si verificherà un errore.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObject.java) su. GitHub
## Eliminare più oggetti contemporaneamente
Utilizzando il `deleteObjects` metodo del client AmazonS3, puoi eliminare più oggetti dallo stesso bucket passandone i nomi al metodo link:sdk-for-java/.html. v1/reference/com/amazonaws/services/s3/model/DeleteObjectsRequest ``
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Codice**
```
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);
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObjects.java) GitHub
# Gestione delle autorizzazioni di Amazon S3 accesso per bucket e oggetti
È possibile utilizzare gli elenchi di controllo degli accessi (ACLs) per Amazon S3 i bucket e gli oggetti per un controllo dettagliato delle risorse. Amazon S3
**Nota**
Questi esempi di codice presuppongono che l'utente comprenda il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione delle AWS credenziali](setup-credentials.md) e Area per lo sviluppo.
## Ottieni l'elenco di controllo degli accessi per un bucket
*Per ottenere l'ACL corrente per un bucket, chiama il `getBucketAcl` metodo di AmazonS3, passandogli il nome del bucket da interrogare.* Questo metodo restituisce un oggetto. [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html) Per ottenere ogni concessione di accesso nell'elenco, chiama il relativo `getGrantsAsList` metodo, che restituirà un elenco Java standard di oggetti [Grant](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html).
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) su GitHub.
## Imposta l'elenco di controllo degli accessi per un bucket
Per aggiungere o modificare le autorizzazioni a un ACL per un bucket, chiama il metodo di AmazonS3. `setBucketAcl` Richiede un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)oggetto che contenga un elenco di assegnatari e livelli di accesso da impostare.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
**Nota**
Puoi fornire l'identificatore univoco del beneficiario direttamente utilizzando la classe [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) oppure utilizzare la [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)classe per impostare il beneficiario via e-mail, come abbiamo fatto qui.
[Vedi GitHub l'](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java)esempio completo su.
## Ottieni la lista di controllo degli accessi per un oggetto
*Per ottenere l'ACL corrente per un oggetto, chiama il `getObjectAcl` metodo di AmazonS3, passandogli il nome del *bucket e il nome* dell'oggetto da interrogare.* [Ad esempio`getBucketAcl`, questo metodo restituisce un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)oggetto che puoi usare per esaminare ogni Grant.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html)
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) su GitHub.
## Impostare l'elenco di controllo degli accessi per un oggetto
Per aggiungere o modificare le autorizzazioni a un ACL per un oggetto, chiamate il metodo di AmazonS3. `setObjectAcl` Richiede un [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html)oggetto che contenga un elenco di assegnatari e livelli di accesso da impostare.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
**Nota**
Puoi fornire l'identificatore univoco del beneficiario direttamente utilizzando la classe [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) oppure utilizzare la [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html)classe per impostare il beneficiario via e-mail, come abbiamo fatto qui.
[Vedi GitHub l'](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java)esempio completo su.
## Ulteriori informazioni
+ [GET Bucket acl nell'API](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html) Reference Amazon S3
+ [INSERISCI Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) nel riferimento API Amazon S3
+ [GET Object acl nel riferimento](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html) API Amazon S3
+ [INSERISCI Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html) nel riferimento API Amazon S3
# Gestione dell'accesso ai Amazon S3 bucket utilizzando le policy dei bucket
Puoi impostare, ottenere o eliminare una *policy sui bucket* per gestire l'accesso ai tuoi Amazon S3 bucket.
## Imposta una Bucket Policy
Puoi impostare la policy sui bucket per un determinato bucket S3 nei seguenti modi:
+ Chiamando il client AmazonS3 e fornendogli un `setBucketPolicy` [SetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/SetBucketPolicyRequest.html)
+ Impostazione diretta della policy utilizzando l'`setBucketPolicy`overload che richiede il nome del bucket e il testo della policy (in formato JSON)
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
```
**Codice**
```
s3.setBucketPolicy(bucket_name, policy_text);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
### Utilizzate la classe di policy per generare o convalidare una policy
Quando fornisci una policy bucket a`setBucketPolicy`, puoi fare quanto segue:
+ Specificate la policy direttamente come stringa di testo in formato JSON
+ [Crea la politica utilizzando la classe Policy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/policy/Policy.html)
Utilizzando la `Policy` classe, non devi preoccuparti di formattare correttamente la stringa di testo. Per ottenere il testo della policy JSON dalla `Policy` classe, usa il suo `toJson` metodo.
**Importazioni**
```
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;
```
**Codice**
```
new Statement(Statement.Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new Resource(
"{region-arn}s3:::" + bucket_name + "/*")));
return bucket_policy.toJson();
```
La `Policy` classe fornisce anche un `fromJson` metodo che può tentare di creare una politica utilizzando una stringa JSON passata. Il metodo lo convalida per garantire che il testo possa essere trasformato in una struttura di policy valida e fallirà con un `IllegalArgumentException` se il testo della policy non è valido.
```
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());
}
```
È possibile utilizzare questa tecnica per preconvalidare una politica letta da un file o in altri modi.
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetBucketPolicy.java) su. GitHub
## Ottieni una Bucket Policy
Per recuperare la policy relativa a un Amazon S3 bucket, chiama il `getBucketPolicy` metodo del client AmazonS3, passandogli il nome del bucket da cui ottenere la policy.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Codice**
```
try {
BucketPolicy bucket_policy = s3.getBucketPolicy(bucket_name);
policy_text = bucket_policy.getPolicyText();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Se il bucket denominato non esiste, se non hai accesso ad esso o se non ha una politica relativa al bucket, ne viene generata una. `AmazonServiceException`
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetBucketPolicy.java) su. GitHub
## Eliminare una policy del bucket
Per eliminare una policy sui bucket, chiama il client AmazonS3`deleteBucketPolicy`, fornendogli il nome del bucket.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Codice**
```
try {
s3.deleteBucketPolicy(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Questo metodo funziona anche se il bucket non dispone già di una policy. Se specifichi un nome di bucket che non esiste o se non hai accesso al bucket, viene generato un. `AmazonServiceException`
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucketPolicy.java) su. GitHub
## Ulteriori informazioni
+ [Accedi alla panoramica del linguaggio delle politiche](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) nella Guida Amazon Simple Storage Service per l'utente
+ [Esempi di policy relative a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) nella Guida per l' Amazon Simple Storage Service utente
# Utilizzo TransferManager per Amazon S3 le operazioni
È possibile utilizzare la AWS SDK per Java TransferManager classe per trasferire in modo affidabile file dall'ambiente locale Amazon S3 e copiare oggetti da una posizione S3 a un'altra. `TransferManager`può visualizzare lo stato di avanzamento di un trasferimento e mettere in pausa o riprendere i caricamenti e i download.
**Nota**
Best practice
Ti consigliamo di abilitare la regola del [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html)ciclo di vita nei tuoi bucket. Amazon S3
Questa regola impone di interrompere Amazon S3 i caricamenti in più parti che non vengono completati entro un determinato numero di giorni dall'avvio. Quando viene superato il limite di tempo impostato, Amazon S3 interrompe il caricamento e quindi elimina i dati di caricamento incompleti.
Per ulteriori informazioni, consulta [Lifecycle Configuration for a Bucket with Versioning nella Guida per](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) l'utente. Amazon S3
**Nota**
Questi esempi di codice presuppongono che tu abbia compreso il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che tu abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione delle AWS credenziali](setup-credentials.md) e Area per lo sviluppo.
## Carica file e directory
TransferManager [puoi caricare file, elenchi di file e directory in qualsiasi Amazon S3 bucket che hai creato in precedenza.](examples-s3-buckets.md#create-bucket)
**Topics**
+ [Carica un singolo file](#transfermanager-upload-file)
+ [Carica un elenco di file](#transfermanager-upload-file-list)
+ [Carica una directory](#transfermanager-upload-directory)
### Carica un singolo file
TransferManagerIl `upload` metodo di Call, che fornisce un nome di Amazon S3 bucket, un nome di chiave (oggetto) e un oggetto Java [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) standard che rappresenta il file da caricare.
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Il `upload` metodo ritorna *immediatamente*, fornendo un `Upload` oggetto da utilizzare per controllare lo stato del trasferimento o per attendere il completamento.
Vedi [Attendi il completamento di un trasferimento](#transfermanager-wait-for-completion) per informazioni sull'utilizzo del `shutdownNow` metodo `waitForCompletion` per completare correttamente un trasferimento prima TransferManager di chiamare. In attesa del completamento del trasferimento, puoi interrogare o ascoltare gli aggiornamenti sullo stato e sui progressi del trasferimento. Per ulteriori informazioni, consulta [Ottieni lo stato e l'avanzamento del trasferimento](#transfermanager-get-status-and-progress).
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) su GitHub.
### Carica un elenco di file
Per caricare più file in un'unica operazione, chiamate il TransferManager `uploadFileList` metodo, fornendo quanto segue:
+ Un nome di Amazon S3 bucket
+ Un *prefisso chiave* da aggiungere ai nomi degli oggetti creati (il percorso all'interno del bucket in cui posizionare gli oggetti)
+ Un oggetto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) che rappresenta la directory relativa da cui creare i percorsi dei file
+ Un oggetto [List](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/List.html) contenente un set di oggetti [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) da caricare
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi [Attendi il completamento di un trasferimento](#transfermanager-wait-for-completion) per informazioni sull'utilizzo del `shutdownNow` metodo `waitForCompletion` per completare correttamente un trasferimento prima TransferManager di chiamare. In attesa del completamento del trasferimento, puoi interrogare o ascoltare gli aggiornamenti sullo stato e sui progressi del trasferimento. Per ulteriori informazioni, consulta [Ottieni lo stato e l'avanzamento del trasferimento](#transfermanager-get-status-and-progress).
L'[MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)oggetto restituito da `uploadFileList` può essere utilizzato per interrogare lo stato o l'avanzamento del trasferimento. Per ulteriori [informazioni, consulta Esamina lo stato di avanzamento corrente di un trasferimento](#transfermanager-get-progress-polling) [e Ottieni lo stato di avanzamento del trasferimento con](#transfermanager-progress-listener) a. ProgressListener
Puoi anche usare `MultipleFileUpload` il `getSubTransfers` metodo S per ottenere i singoli `Upload` oggetti per ogni file da trasferire. Per ulteriori informazioni, consulta [Get the Progress of Subtransfer](#transfermanager-get-subtransfer-progress).
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) su. GitHub
### Carica una directory
È possibile utilizzare TransferManager il `uploadDirectory` metodo S per caricare un'intera directory di file, con l'opzione di copiare i file nelle sottodirectory in modo ricorsivo. **Fornisci un nome di Amazon S3 bucket, un prefisso chiave S3, [un](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) oggetto File che rappresenta la directory locale da copiare e `boolean` un valore che indica se vuoi copiare le sottodirectory in modo ricorsivo (vero o falso).**
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi [Wait for a Transfer to Complete per informazioni su come utilizzare il metodo To `waitForCompletion` Completare](#transfermanager-wait-for-completion) con successo un trasferimento prima di chiamare. TransferManager `shutdownNow` In attesa del completamento del trasferimento, puoi interrogare o ascoltare gli aggiornamenti sullo stato e sui progressi del trasferimento. Per ulteriori informazioni, consulta [Ottieni lo stato e l'avanzamento del trasferimento](#transfermanager-get-status-and-progress).
L'[MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)oggetto restituito da `uploadFileList` può essere utilizzato per interrogare lo stato o l'avanzamento del trasferimento. Per ulteriori [informazioni, consulta Esamina lo stato di avanzamento corrente di un trasferimento](#transfermanager-get-progress-polling) [e Ottieni lo stato di avanzamento del trasferimento con](#transfermanager-progress-listener) a. ProgressListener
Puoi anche usare `MultipleFileUpload` il `getSubTransfers` metodo S per ottenere i singoli `Upload` oggetti per ogni file da trasferire. Per ulteriori informazioni, consulta [Get the Progress of Subtransfer](#transfermanager-get-subtransfer-progress).
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) su. GitHub
## Scarica file o directory
Usa la TransferManager classe per scaricare un singolo file (Amazon S3 oggetto) o una directory (un nome di Amazon S3 bucket seguito dal prefisso di un oggetto) da. Amazon S3
**Topics**
+ [Scarica un singolo file](#transfermanager-download-file)
+ [Scarica una directory](#tranfermanager-download-directory)
### Scarica un singolo file
Utilizzate il `download` metodo TransferManager's, fornendo il nome del Amazon S3 bucket contenente l'oggetto che desiderate scaricare, il nome della chiave (oggetto) e un oggetto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) che rappresenta il file da creare sul sistema locale.
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi [Wait for a Transfer to Complete](#transfermanager-wait-for-completion) per informazioni sull'utilizzo del `shutdownNow` metodo `waitForCompletion` per completare correttamente un trasferimento prima TransferManager di chiamare. In attesa del completamento del trasferimento, puoi interrogare o ascoltare gli aggiornamenti sullo stato e sui progressi del trasferimento. Per ulteriori informazioni, consulta [Ottieni lo stato e l'avanzamento del trasferimento](#transfermanager-get-status-and-progress).
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) su GitHub.
### Scarica una directory
Per scaricare un set di file che condividono un prefisso di chiave comune (analogo a una directory su un file system) da Amazon S3, utilizzate il metodo. TransferManager `downloadDirectory` Il metodo utilizza il nome del Amazon S3 bucket contenente gli oggetti da scaricare, il prefisso dell'oggetto condiviso da tutti gli oggetti e un oggetto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) che rappresenta la directory in cui scaricare i file sul sistema locale. Se la directory denominata non esiste ancora, verrà creata.
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi [Attendi il completamento di un trasferimento](#transfermanager-wait-for-completion) per informazioni sull'utilizzo del `shutdownNow` metodo `waitForCompletion` per completare correttamente un trasferimento prima TransferManager di chiamare. In attesa del completamento del trasferimento, puoi interrogare o ascoltare gli aggiornamenti sullo stato e sui progressi del trasferimento. Per ulteriori informazioni, consulta [Ottieni lo stato e l'avanzamento del trasferimento](#transfermanager-get-status-and-progress).
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) su GitHub.
## Copia oggetti
Per copiare un oggetto da un bucket S3 a un altro, usa il TransferManager `copy` metodo.
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrCopy.java) su. GitHub
## Attendi il completamento del trasferimento
Se l'applicazione (o il thread) riesce a bloccarsi fino al completamento del trasferimento, puoi utilizzare il `waitForCompletion` metodo dell'interfaccia [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html) per bloccare fino al completamento del trasferimento o al verificarsi di un'eccezione.
```
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);
}
```
È possibile visualizzare l'avanzamento dei trasferimenti se si effettuano sondaggi sugli eventi *prima* della chiamata`waitForCompletion`, si implementa un meccanismo di polling su un thread separato o si ricevono aggiornamenti sullo stato di avanzamento in modo asincrono utilizzando un. [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)
[Vedi l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) GitHub
## Ottieni lo stato e l'avanzamento del trasferimento
Ciascuna delle classi restituite dai `copy` metodi TransferManager `upload*``download*`, e restituisce un'istanza di una delle seguenti classi, a seconda che si tratti di un'operazione a file singolo o multiplo.
****
| Classe | Restituito da |
| --- | --- |
| [Copia](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Copy.html) | `copy` |
| [Scarica](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` |
| [Caricamento](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` |
Tutte queste classi implementano l'interfaccia [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html). `Transfer`fornisce metodi utili per conoscere lo stato di avanzamento di un trasferimento, mettere in pausa o riprendere il trasferimento e ottenere lo stato attuale o finale del trasferimento.
**Topics**
+ [Verifica lo stato di avanzamento attuale di un trasferimento](#transfermanager-get-progress-polling)
+ [Ottieni Transfer Progress con un ProgressListener](#transfermanager-progress-listener)
+ [Ottieni lo stato di avanzamento dei subtrasferimenti](#transfermanager-get-subtransfer-progress)
### Verifica lo stato di avanzamento attuale di un trasferimento
Questo ciclo stampa lo stato di avanzamento di un trasferimento, ne esamina l'avanzamento corrente durante l'esecuzione e, una volta completato, ne stampa lo stato finale.
**Importazioni**
```
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;
```
**Codice**
```
// 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);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) su. GitHub
### Ottieni Transfer Progress con un ProgressListener
Puoi allegare un [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)a qualsiasi trasferimento utilizzando il `addProgressListener` metodo dell'interfaccia di [trasferimento](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html).
A [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html)richiede un solo metodo`progressChanged`, che accetta un [ProgressEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressEvent.html)oggetto. È possibile utilizzare l'oggetto per ottenere i byte totali dell'operazione chiamando il relativo `getBytes` metodo e il numero di byte trasferiti finora mediante la chiamata. `getBytesTransferred`
**Importazioni**
```
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;
```
**Codice**
```
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();
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) su. GitHub
### Ottieni lo stato di avanzamento dei subtrasferimenti
La [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html)classe può restituire informazioni sui suoi subtrasferimenti chiamando il suo `getSubTransfers` metodo. Restituisce una [raccolta](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html) non modificabile di oggetti [Upload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) che forniscono lo stato e l'avanzamento individuali del trasferimento di ogni sottotrasferimento.
**Importazioni**
```
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;
```
**Codice**
```
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);
```
[Vedi l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) GitHub
## Ulteriori informazioni
+ [Object Keys](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html) nella Guida Amazon Simple Storage Service per l'utente
# Configurazione di un Amazon S3 bucket come sito Web
Puoi configurare un Amazon S3 bucket in modo che si comporti come un sito Web. Per fare ciò, è necessario impostare la configurazione del sito Web.
**Nota**
Questi esempi di codice presuppongono che l'utente comprenda il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione AWS delle credenziali e della regione per](setup-credentials.md) lo sviluppo.
## Imposta la configurazione del sito Web di Bucket
Per impostare la configurazione del sito Web di un Amazon S3 bucket, chiama il `setWebsiteConfiguration` metodo di AmazonS3 con il nome del bucket per cui impostare la configurazione e un [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html)oggetto contenente la configurazione del sito Web del bucket.
L'impostazione di un documento indice è *obbligatoria*; tutti gli altri parametri sono facoltativi.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
**Nota**
L'impostazione della configurazione di un sito Web non modifica le autorizzazioni di accesso per il bucket. Per rendere visibili i file sul Web, è inoltre necessario impostare una *policy relativa ai bucket* che consenta l'accesso pubblico in lettura ai file contenuti nel bucket. Per ulteriori informazioni, consulta [Gestione dell'accesso ai Amazon S3 bucket tramite le policy dei bucket](examples-s3-bucket-policies.md).
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetWebsiteConfiguration.java) su. GitHub
## Configurazione del sito Web di Get a Bucket
Per ottenere la configurazione del sito Web di un Amazon S3 bucket, chiama il `getWebsiteConfiguration` metodo di AmazonS3 con il nome del bucket per cui recuperare la configurazione.
La configurazione verrà restituita come oggetto. [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html) Se non esiste una configurazione del sito Web per il bucket, `null` verrà restituita.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetWebsiteConfiguration.java) su. GitHub
## Elimina la configurazione del sito Web di Bucket
Per eliminare la configurazione del sito Web di un Amazon S3 bucket, chiama il `deleteWebsiteConfiguration` metodo di AmazonS3 con il nome del bucket da cui eliminare la configurazione.
**Importazioni**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Codice**
```
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);
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteWebsiteConfiguration.java) GitHub
## Ulteriori informazioni
+ [Sito web PUT Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) nell' Amazon S3 API Reference
+ Il [sito web GET Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) nell'API Reference Amazon S3
+ Il [sito web DELETE Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) nell'API Reference Amazon S3
# Usa la Amazon S3 crittografia lato client
La crittografia dei dati utilizzando il client di Amazon S3 crittografia è un modo per fornire un ulteriore livello di protezione per le informazioni sensibili in cui sono archiviate. Amazon S3 Gli esempi in questa sezione mostrano come creare e configurare il client di Amazon S3 crittografia per l'applicazione.
Se non conosci la crittografia, consulta le [nozioni di base sulla crittografia](https://docs.aws.amazon.com/kms/latest/developerguide/crypto-intro.html) nella Guida per sviluppatori AWS KMS per una panoramica di base dei termini e degli algoritmi di crittografia. Per informazioni sul supporto della crittografia in generale AWS SDKs, consulta [AWS SDK Support for Amazon S3 Client-Side Encryption nella Guida generale](https://docs.aws.amazon.com/general/latest/gr/aws_sdk_cryptography.html). Amazon Web Services
**Nota**
Questi esempi di codice presuppongono che tu abbia compreso il materiale contenuto in [Using the AWS SDK per Java](basics.md) e che tu abbia configurato AWS le credenziali predefinite utilizzando le informazioni contenute in [Configurazione delle AWS credenziali](setup-credentials.md) e Area per lo sviluppo.
Se si utilizza la versione 1.11.836 o precedente di AWS SDK per Java, vedere [Amazon S3 Encryption Client Migration per informazioni sulla migrazione](s3-encryption-migration.md) delle applicazioni alle versioni successive. [Se non riesci a eseguire la migrazione, guarda questo esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/S3Encrypt.java) GitHub
Altrimenti, se utilizzi la versione 1.11.837 o successiva di AWS SDK per Java, esplora gli argomenti di esempio elencati di seguito per utilizzare la crittografia lato client. Amazon S3
**Topics**
+ [Amazon S3 crittografia lato client con chiavi master client](examples-crypto-masterkey.md)
+ [Amazon S3 crittografia lato client con chiavi gestite AWS KMS](examples-crypto-kms.md)
# Amazon S3 crittografia lato client con chiavi master client
Gli esempi seguenti utilizzano la classe [AmazonS3 EncryptionClient V2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) per creare un client con crittografia lato client abilitata. Amazon S3 Una volta abilitata, tutti gli oggetti su cui carichi utilizzando questo client verranno crittografati. Amazon S3 Tutti gli oggetti ottenuti Amazon S3 utilizzando questo client verranno automaticamente decrittografati.
**Nota**
Gli esempi seguenti dimostrano l'utilizzo della crittografia Amazon S3 lato client con chiavi master client gestite dal cliente. Per informazioni su come utilizzare la crittografia con chiavi gestite AWS KMS, consulta la sezione Crittografia lato [Amazon S3 client](examples-crypto-kms.md) con chiavi gestite KMS. AWS
Puoi scegliere tra due modalità di crittografia quando abiliti la Amazon S3 crittografia lato client: autenticata rigorosa o autenticata. Le sezioni seguenti mostrano come abilitare ogni tipo. Per informazioni sugli algoritmi utilizzati da ciascuna modalità, consultate la [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)definizione.
## Importazioni obbligatorie
Importa le seguenti classi per questi esempi.
**Importazioni**
```
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;
```
## Crittografia autenticata rigorosa
La crittografia autenticata rigorosa è la modalità predefinita se non `CryptoMode` viene specificata alcuna.
Per abilitare esplicitamente questa modalità, specificate il `StrictAuthenticatedEncryption` valore nel `withCryptoConfiguration` metodo.
**Nota**
Per utilizzare la crittografia autenticata lato client, è necessario includere il file [jar di Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) più recente nel classpath dell'applicazione.
**Codice**
```
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");
```
## Modalità di crittografia autenticata
Quando si utilizza `AuthenticatedEncryption` la modalità, durante la crittografia viene applicato un algoritmo di key wrapping migliorato. Durante la decrittografia in questa modalità, l'algoritmo può verificare l'integrità dell'oggetto decrittografato e generare un'eccezione se il controllo fallisce. Per ulteriori dettagli su come funziona la crittografia autenticata, consultate il post sul blog [Amazon S3 Client-Side](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption) Authenticated Encryption.
**Nota**
Per utilizzare la crittografia autenticata lato client, è necessario includere il file jar [Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) più recente nel classpath dell'applicazione.
Per abilitare questa modalità, specificate il valore nel metodo. `AuthenticatedEncryption` `withCryptoConfiguration`
**Codice**
```
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 crittografia lato client con chiavi gestite AWS KMS
Gli esempi seguenti utilizzano la classe [AmazonS3 EncryptionClient V2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) per creare un client con crittografia lato client abilitata. Amazon S3 Una volta configurato, tutti gli oggetti su cui carichi utilizzando questo client verranno crittografati. Amazon S3 Tutti gli oggetti ottenuti Amazon S3 utilizzando questo client vengono decrittografati automaticamente.
**Nota**
Gli esempi seguenti mostrano come utilizzare la crittografia Amazon S3 lato client con AWS le chiavi gestite da KMS. Per informazioni su come utilizzare la crittografia con le proprie chiavi, vedere [Crittografia Amazon S3 lato client](examples-crypto-masterkey.md) con chiavi master client.
È possibile scegliere tra due modalità di crittografia quando si abilita la Amazon S3 crittografia lato client: autenticata rigorosa o autenticata. Le sezioni seguenti mostrano come abilitare ogni tipo. Per informazioni sugli algoritmi utilizzati da ciascuna modalità, consultate la [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html)definizione.
## Importazioni obbligatorie
Importa le seguenti classi per questi esempi.
**Importazioni**
```
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;
```
## Crittografia autenticata rigorosa
La crittografia autenticata rigorosa è la modalità predefinita se non `CryptoMode` viene specificata alcuna.
Per abilitare esplicitamente questa modalità, specificate il `StrictAuthenticatedEncryption` valore nel `withCryptoConfiguration` metodo.
**Nota**
Per utilizzare la crittografia autenticata lato client, è necessario includere il file [jar di Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) più recente nel classpath dell'applicazione.
**Codice**
```
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));
```
Richiamate il `putObject` metodo sul client di crittografia per caricare oggetti. Amazon S3
**Codice**
```
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
```
È possibile recuperare l'oggetto utilizzando lo stesso client. Questo esempio chiama il `getObjectAsString` metodo per recuperare la stringa che è stata memorizzata.
**Codice**
```
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
## modalità di crittografia autenticata
Quando si utilizza `AuthenticatedEncryption` la modalità, durante la crittografia viene applicato un algoritmo di key wrapping migliorato. Durante la decrittografia in questa modalità, l'algoritmo può verificare l'integrità dell'oggetto decrittografato e generare un'eccezione se il controllo fallisce. Per ulteriori dettagli su come funziona la crittografia autenticata, consultate il post sul blog [Amazon S3 Client-Side](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption) Authenticated Encryption.
**Nota**
Per utilizzare la crittografia autenticata lato client, è necessario includere il file jar [Bouncy Castle](https://www.bouncycastle.org/download/bouncy-castle-java/) più recente nel classpath dell'applicazione.
Per abilitare questa modalità, specificate il valore nel metodo. `AuthenticatedEncryption` `withCryptoConfiguration`
**Codice**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
## Configurazione del client AWS KMS
Il client di Amazon S3 crittografia crea un AWS KMS client per impostazione predefinita, a meno che non ne venga specificato uno esplicitamente.
Per impostare la regione per questo client creato automaticamente, imposta il AWS KMS . `awsKmsRegion`
**Codice**
```
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();
```
In alternativa, è possibile utilizzare il proprio AWS KMS client per inizializzare il client di crittografia.
**Codice**
```
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 Esempi di utilizzo di AWS SDK per Java
In questa sezione vengono forniti esempi di programmazione di [Amazon SQS](https://aws.amazon.com/sqs/) utilizzando [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
**Nota**
Gli esempi includono solo il codice necessario per dimostrare ogni tecnica. Il [codice di esempio completo è disponibile su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Utilizzo delle code di Amazon SQS messaggi](examples-sqs-message-queues.md)
+ [Invio, ricezione ed eliminazione di Amazon SQS messaggi](examples-sqs-messages.md)
+ [Abilitazione del polling lungo per le code di Amazon SQS messaggi](examples-sqs-long-polling.md)
+ [Impostazione del timeout di visibilità in Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Utilizzo di Dead Letter Queues in Amazon SQS](examples-sqs-dead-letter-queues.md)
# Utilizzo delle code di Amazon SQS messaggi
Una *coda di messaggi* è il contenitore logico utilizzato per inviare messaggi in modo affidabile. Amazon SQS Sono disponibili due tipi di code: *standard* e *first-in, first-out* (FIFO). [Per ulteriori informazioni sulle code e sulle differenze tra questi tipi, consulta la Guida per gli Amazon SQS sviluppatori.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/)
Questo argomento descrive come creare, elencare, eliminare e ottenere l'URL di una Amazon SQS coda utilizzando. AWS SDK per Java
## Creare una coda
Utilizza il `createQueue` metodo del client AmazonSQS, fornendo un [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)oggetto che descrive i parametri della coda.
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
Puoi utilizzare la forma semplificata di`createQueue`, che richiede solo un nome di coda, per creare una coda standard.
```
sqs.createQueue("MyQueue" + new Date().getTime());
```
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) su. GitHub
## Code di elenchi
Per elencare le Amazon SQS code relative al tuo account, chiama il metodo del client AmazonSQS. `listQueues`
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesResult;
```
**Codice**
```
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'utilizzo dell'`listQueues`overload senza parametri restituisce tutte le code.* È possibile filtrare i risultati restituiti passandogli un `ListQueuesRequest` oggetto.
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesRequest;
```
**Codice**
```
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);
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) su GitHub.
## Ottenere l'URL di una coda
Chiama il metodo del client AmazonSQS. `getQueueUrl`
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Codice**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String queue_url = sqs.getQueueUrl(QUEUE_NAME).getQueueUrl();
```
Guarda l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) su. GitHub
## Eliminare una coda
Fornisci l'[URL della coda al metodo](#sqs-get-queue-url) del client AmazonSQS. `deleteQueue`
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Codice**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.deleteQueue(queue_url);
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) GitHub
## Ulteriori informazioni
+ [Come funzionano Amazon SQS le code](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) nella Guida per gli Amazon SQS sviluppatori
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nell' Amazon SQS API Reference
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)nell' Amazon SQS API Reference
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)nell' Amazon SQS API Reference
+ [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html)nell' Amazon SQS API Reference
# Invio, ricezione ed eliminazione di Amazon SQS messaggi
Questo argomento descrive come inviare, ricevere ed eliminare Amazon SQS messaggi. I messaggi vengono sempre distribuiti tramite una [coda SQS](examples-sqs-message-queues.md).
## Inviare un messaggio
Aggiungi un singolo messaggio a una Amazon SQS coda chiamando il metodo del client AmazonSQS. `sendMessage` Fornisci un [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageRequest.html)oggetto che contenga l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) della coda, il corpo del messaggio e il valore di ritardo opzionale (in secondi).
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.SendMessageRequest;
```
**Codice**
```
SendMessageRequest send_msg_request = new SendMessageRequest()
.withQueueUrl(queueUrl)
.withMessageBody("hello world")
.withDelaySeconds(5);
sqs.sendMessage(send_msg_request);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) su. GitHub
### Invia più messaggi contemporaneamente
Puoi inviare più di un messaggio in un'unica richiesta. Per inviare più messaggi, utilizza il `sendMessageBatch` metodo del client AmazonSQS, che richiede un URL [SendMessageBatchRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequest.html)contenente l'URL della coda e un elenco di messaggi (ciascuno uno [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequestEntry.html)a) da inviare. Puoi anche impostare un valore di ritardo opzionale per messaggio.
**Importazioni**
```
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
import com.amazonaws.services.sqs.model.SendMessageBatchRequestEntry;
```
**Codice**
```
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);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) su GitHub.
## Ricevi messaggi
Recupera tutti i messaggi attualmente in coda chiamando il `receiveMessage` metodo del client AmazonSQS e passandogli l'URL della coda. I messaggi vengono restituiti come un elenco di oggetti [Message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/Message.html).
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
```
**Codice**
```
List messages = sqs.receiveMessage(queueUrl).getMessages();
```
## Elimina i messaggi dopo la ricezione
Dopo aver ricevuto un messaggio e averne elaborato il contenuto, eliminalo dalla coda inviando l'handle di ricezione del messaggio e l'URL di coda al metodo del client AmazonSQS. `deleteMessage`
**Codice**
```
for (Message m : messages) {
sqs.deleteMessage(queueUrl, m.getReceiptHandle());
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) GitHub
## Ulteriori informazioni
+ [Come funzionano Amazon SQS le code](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) nella Guida per gli Amazon SQS sviluppatori
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)nell' Amazon SQS API Reference
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)nell' Amazon SQS API Reference
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nell' Amazon SQS API Reference
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)nell' Amazon SQS API Reference
# Abilitazione del polling lungo per le code di Amazon SQS messaggi
Amazon SQS utilizza il *polling breve* per impostazione predefinita, interrogando solo un sottoinsieme di server, sulla base di una distribuzione casuale ponderata, per determinare se sono disponibili messaggi da includere nella risposta.
Il polling prolungato aiuta a ridurre i costi di utilizzo Amazon SQS riducendo il numero di risposte vuote quando non ci sono messaggi disponibili da restituire in risposta a una richiesta inviata a una ReceiveMessage coda ed eliminando le false risposte vuote. Amazon SQS
**Nota**
*È possibile impostare una frequenza di polling lunga da 1 a 20 secondi.*
## Attivazione di sondaggi lunghi durante la creazione di una coda
Per abilitare il polling lungo durante la creazione di una Amazon SQS coda, imposta l'`ReceiveMessageWaitTimeSeconds`attributo sull'[CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html)oggetto prima di chiamare il metodo della classe AmazonSQS. `createQueue`
**Importazioni**
```
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;
```
**Codice**
```
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;
}
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) GitHub
## Abilitazione del long polling su una coda esistente
Oltre ad abilitare il polling lungo durante la creazione di una coda, puoi attivarlo anche su una coda esistente `ReceiveMessageWaitTimeSeconds` impostando il metodo «[SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)before call» della classe AmazonSQS. `setQueueAttributes`
**Importazioni**
```
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Codice**
```
SetQueueAttributesRequest set_attrs_request = new SetQueueAttributesRequest()
.withQueueUrl(queue_url)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
sqs.setQueueAttributes(set_attrs_request);
```
[ GitHubGuarda l'](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java)esempio completo su.
## Abilitazione del long polling alla ricezione del messaggio
Puoi abilitare il polling prolungato quando ricevi un messaggio impostando il tempo di attesa in secondi sul metodo [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ReceiveMessageRequest.html)che fornisci alla classe AmazonSQS. `receiveMessage`
**Nota**
Dovresti assicurarti che il timeout della richiesta del AWS cliente sia superiore al tempo massimo di sondaggio lungo (20 secondi) in modo che `receiveMessage` le tue richieste non scadano in attesa del prossimo evento di sondaggio\$1
**Importazioni**
```
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
```
**Codice**
```
ReceiveMessageRequest receive_request = new ReceiveMessageRequest()
.withQueueUrl(queue_url)
.withWaitTimeSeconds(20);
sqs.receiveMessage(receive_request);
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) GitHub
## Ulteriori informazioni
+ [Amazon SQS Sondaggi lunghi](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) nella Guida per gli Amazon SQS sviluppatori
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nell' Amazon SQS API Reference
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nell' Amazon SQS API Reference
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nell' Amazon SQS API Reference
# Impostazione del timeout di visibilità in Amazon SQS
Quando un messaggio viene ricevuto in Amazon SQS, rimane in coda fino a quando non viene eliminato per garantire la ricezione. Un messaggio ricevuto, ma non eliminato, sarà disponibile nelle richieste successive dopo un determinato *timeout di visibilità* per evitare che il messaggio venga ricevuto più di una volta prima di poter essere elaborato ed eliminato.
**Nota**
Quando si utilizzano [code standard](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), il timeout di visibilità non è una garanzia contro la ricezione di un messaggio due volte. Se utilizzi una coda standard, assicurati che il codice sia in grado di gestire il caso in cui lo stesso messaggio sia stato recapitato più di una volta.
## Impostazione del timeout di visibilità dei messaggi per un singolo messaggio
Quando hai ricevuto un messaggio, puoi modificarne il timeout di visibilità inserendo un codice di ricezione [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityRequest.html)che passi al metodo della classe AmazonSQS. `changeMessageVisibility`
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Codice**
```
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);
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) GitHub
## Impostazione del timeout di visibilità dei messaggi per più messaggi contemporaneamente
Per impostare il timeout di visibilità dei messaggi per più messaggi contemporaneamente, crea un elenco di [ChangeMessageVisibilityBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityBatchRequestEntry.html)oggetti, ciascuno contenente una stringa ID univoca e un handle di ricezione. Quindi, passa l'elenco al metodo della classe Amazon SQS client. `changeMessageVisibilityBatch`
**Importazioni**
```
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;
```
**Codice**
```
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);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) su. GitHub
## Ulteriori informazioni
+ [Visibility Timeout](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) nella Guida per gli Amazon SQS sviluppatori
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nell' Amazon SQS API Reference
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html)nell' Amazon SQS API Reference
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nell' Amazon SQS API Reference
+ [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html)nell' Amazon SQS API Reference
+ [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)nell' Amazon SQS API Reference
# Utilizzo di Dead Letter Queues in Amazon SQS
Amazon SQS fornisce supporto per le code di *lettere morte*. Una coda di lettere morte è una coda che altre code (di origine) possono indirizzare per i messaggi che non possono essere elaborati correttamente. Puoi riservare e isolare questi messaggi nella coda DLQ per determinare perché l'elaborazione non è riuscita.
## Creazione di una coda di lettere morte
Una coda di lettere morte viene creata allo stesso modo di una coda normale, ma presenta le seguenti restrizioni:
+ Una coda di lettere morte deve essere dello stesso tipo di coda (FIFO o standard) della coda di origine.
+ È necessario creare una coda di lettere morte utilizzando la stessa regione Account AWS e della coda di origine.
Qui creiamo due Amazon SQS code identiche, una delle quali fungerà da coda di lettere morte:
**Importazioni**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
```
**Codice**
```
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;
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) su. GitHub
## Designazione di una coda di lettere morte per una coda di origine
Per designare una coda di lettere morte, è necessario innanzitutto creare una politica di *redrive e quindi impostare la politica* negli attributi della coda. Una politica di redrive è specificata in JSON e specifica l'ARN della coda di lettere morte e il numero massimo di volte in cui il messaggio può essere ricevuto e non elaborato prima di essere inviato alla coda di lettere morte.
Per impostare la politica di redrive per la coda di origine, chiama il `setQueueAttributes` metodo della classe AmazonSQS con un [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html)oggetto per il quale hai impostato l'attributo con la tua politica di redrive JSON. `RedrivePolicy`
**Importazioni**
```
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Codice**
```
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);
```
[Guarda](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) l' GitHubesempio completo su.
## Ulteriori informazioni
+ [Utilizzo di Amazon SQS Dead Letter Queues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) nella Guida per gli Amazon SQS sviluppatori
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html)nell' Amazon SQS API Reference
# Amazon SWF Esempi di utilizzo di AWS SDK per Java
[Amazon SWF](https://aws.amazon.com/swf/)[è un servizio di gestione del flusso di lavoro che aiuta gli sviluppatori a creare e scalare flussi di lavoro distribuiti che possono avere fasi parallele o sequenziali costituite da attività, flussi di lavoro secondari o persino attività Lambda.](https://aws.amazon.com/lambda/)
Esistono due modi per utilizzare l' AWS SDK per Java, Amazon SWF utilizzando l'oggetto *client* SWF o utilizzando l'oggetto per Java. AWS Flow Framework Il AWS Flow Framework for Java è inizialmente più difficile da configurare, poiché fa un uso intensivo di annotazioni e si basa su librerie aggiuntive come AspectJ e Spring Framework. Tuttavia, per progetti di grandi dimensioni o complessi, risparmierai tempo di programmazione utilizzando for Java. AWS Flow Framework Per ulteriori informazioni, consulta la [Guida AWS Flow Framework per gli sviluppatori di Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
Questa sezione fornisce esempi di programmazione Amazon SWF utilizzando direttamente il AWS SDK per Java client.
**Topics**
+ [Nozioni di base su SWF](swf-basics.md)
+ [Creazione di un' Amazon SWF applicazione semplice](swf-hello.md)
+ [Lambda Compiti](swf-lambda-task.md)
+ [Chiusura graduale degli addetti alle attività e ai flussi di lavoro](swf-graceful-shutdown.md)
+ [Registrazione di domini](prog-services-swf-register-domain.md)
+ [Elenco di domini](prog-services-swf-list-domains.md)
# Nozioni di base su SWF
Questi sono schemi generali per l' Amazon SWF utilizzo di. AWS SDK per JavaÈ inteso principalmente come riferimento. Per un tutorial introduttivo più completo, vedi [Creazione di un'applicazione semplice Amazon SWF](swf-hello.md).
## Dipendenze
Amazon SWF Le applicazioni di base richiederanno le seguenti dipendenze, incluse in: AWS SDK per Java
+ aws-java-sdk-1.12.\$1.jar
+ commons-logging-1.2.\$1.jar
+ http://client-4.3.\$1.jar
+ http://core-4.3.\$1.jar
+ jackson-annotazioni-2.12.\$1.jar
+ jackson-core-2.12.\$1.jar
+ jackson-databind-2.12.\$1.jar
+ joda-time-2.8.\$1.jar
**Nota**
I numeri di versione di questi pacchetti variano a seconda della versione dell'SDK in uso, ma le versioni fornite con l'SDK sono state testate per verificarne la compatibilità e sono quelle che dovresti usare.
AWS Flow Framework per le applicazioni Java richiedono una configurazione aggiuntiva *e dipendenze* aggiuntive. [AWS Flow Framework Per ulteriori informazioni sull'utilizzo del framework, consulta la Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Importazioni
In generale, è possibile utilizzare le seguenti importazioni per lo sviluppo del codice:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
Tuttavia, è buona norma importare solo le classi necessarie. Probabilmente finirai per specificare classi particolari nell'`com.amazonaws.services.simpleworkflow.model`area di lavoro:
```
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;
```
Se stai usando il AWS Flow Framework per Java, importerai le classi dall'area di lavoro. `com.amazonaws.services.simpleworkflow.flow` Per esempio:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.flow.ActivityWorker;
```
**Nota**
The AWS Flow Framework for Java ha requisiti aggiuntivi oltre a quelli di base AWS SDK per Java. Per ulteriori informazioni, consulta la [Guida AWS Flow Framework per gli sviluppatori di Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Utilizzo della classe client SWF
La vostra interfaccia di base Amazon SWF è tramite le [AmazonSimpleWorkflowAsyncClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowAsyncClient.html)classi [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)or. La differenza principale tra queste è che la `\*AsyncClient` classe restituisce oggetti [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) per la programmazione concorrente (asincrona).
```
AmazonSimpleWorkflowClient swf = AmazonSimpleWorkflowClientBuilder.defaultClient();
```
# Creazione di un' Amazon SWF applicazione semplice
Questo argomento ti introdurrà alla programmazione di [Amazon SWF](https://aws.amazon.com/swf/)applicazioni con AWS SDK per Java, presentando alcuni concetti importanti lungo il percorso.
## Informazioni sull'esempio
Il progetto di esempio creerà un flusso di lavoro con una singola attività che accetta i dati del flusso di lavoro trasferiti attraverso il AWS cloud (nella tradizione HelloWorld, sarà il nome di qualcuno da salutare) e quindi stamperà un messaggio di saluto in risposta.
Anche se a prima vista sembra molto semplice, Amazon SWF le applicazioni sono costituite da una serie di parti che lavorano insieme:
+ Un **dominio**, utilizzato come contenitore logico per i dati di esecuzione del flusso di lavoro.
+ Uno o più **flussi di lavoro** che rappresentano componenti di codice che definiscono l'ordine logico di esecuzione delle attività del flusso di lavoro e dei flussi di lavoro secondari.
+ Un addetto al **flusso di lavoro**, noto anche come *decisore*, che effettua sondaggi sulle attività decisionali e pianifica le attività o i flussi di lavoro per bambini in risposta.
+ Una o più **attività**, ognuna delle quali rappresenta un'unità di lavoro nel flusso di lavoro.
+ Un **addetto alle attività** che analizza le attività svolte ed esegue metodi di attività in risposta.
+ Uno o più **elenchi di attività**, ossia code gestite da chi lavora Amazon SWF per inviare richieste ai lavoratori del flusso di lavoro e delle attività. Le attività presenti in un elenco di attività destinato agli addetti al flusso di lavoro sono denominate *attività decisionali*. Quelle destinate agli addetti alle attività sono chiamate *attività attive*.
+ Un programma **di avvio del flusso di** lavoro che avvia l'esecuzione del flusso di lavoro.
Dietro le quinte, Amazon SWF orchestra il funzionamento di questi componenti, ne coordina il flusso dal AWS cloud, trasferisce i dati tra di loro, gestisce i timeout e le notifiche Heartbeat e registra la cronologia di esecuzione del flusso di lavoro.
## Prerequisiti
### Ambiente di sviluppo
L'ambiente di sviluppo utilizzato in questo tutorial è composto da:
+ Tipo [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/).
+ [Apache Maven](http://maven.apache.org/) (3.3.1).
+ JDK 1.7 o successivo. Questo tutorial è stato sviluppato e testato utilizzando JDK 1.8.0.
+ Un buon editor di testo Java (a tua scelta).
**Nota**
Se utilizzi un sistema di compilazione diverso da Maven, puoi comunque creare un progetto utilizzando i passaggi appropriati per il tuo ambiente e utilizzare i concetti forniti qui per procedere. [Ulteriori informazioni sulla configurazione e l'utilizzo di AWS SDK per Java con vari sistemi di compilazione sono disponibili in Guida introduttiva.](getting-started.md)
Allo stesso modo, ma con maggiore impegno, i passaggi mostrati qui possono essere implementati utilizzando uno qualsiasi dei programmi AWS SDKs con supporto per Amazon SWF.
Tutte le dipendenze esterne necessarie sono incluse in AWS SDK per Java, quindi non c'è altro da scaricare.
### AWS Accesso
Per completare correttamente questo tutorial, è necessario avere accesso al portale di AWS accesso come [descritto nella sezione di configurazione di base](signup-create-iam-user.md#signup-create-iam-user-overview) di questa guida.
Le istruzioni descrivono come accedere alle credenziali temporanee da copiare e incollare nel `credentials` file condiviso locale. Le credenziali temporanee che incolli devono essere associate a un ruolo IAM AWS IAM Identity Center che dispone delle autorizzazioni per accedere ad Amazon SWF. Dopo aver incollato le credenziali temporanee, il `credentials` file avrà un aspetto simile al seguente.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
Queste credenziali temporanee sono associate al profilo. `default`
## Create un progetto SWF
1. Inizia un nuovo progetto con Maven:
```
mvn archetype:generate -DartifactId=helloswf \
-DgroupId=aws.example.helloswf -DinteractiveMode=false
```
Questo creerà un nuovo progetto con una struttura di progetto Maven standard:
```
helloswf
├── pom.xml
└── src
├── main
│ └── java
│ └── aws
│ └── example
│ └── helloswf
│ └── App.java
└── test
└── ...
```
Puoi ignorare o eliminare la `test` directory e tutto ciò che contiene, non la useremo per questo tutorial. Puoi anche eliminarla`App.java`, poiché la sostituiremo con nuove classi.
1. Modifica il `pom.xml` file del progetto e aggiungi il **aws-java-sdk-simpleworkflow**modulo aggiungendone una dipendenza all'interno del `` blocco.
```
com.amazonawsaws-java-sdk-simpleworkflow1.11.1000
```
1. *Assicurati che Maven crei il tuo progetto con il supporto per JDK* 1.7\$1. Aggiungi quanto segue al tuo progetto (prima o dopo il blocco) in: `` `pom.xml`
```
maven-compiler-plugin3.6.11.81.8
```
## Codifica il progetto
Il progetto di esempio sarà composto da quattro applicazioni separate, che esamineremo una per una:
+ **HelloTypes.java** --contiene i dati sul dominio, l'attività e il tipo di flusso di lavoro del progetto, condivisi con gli altri componenti. Gestisce anche la registrazione di questi tipi con SWF.
+ **ActivityWorker.java** --contiene l'activity worker, che analizza le attività da svolgere ed esegue le attività in risposta.
+ **WorkflowWorker.java** --contiene l'operatore del flusso di lavoro (decisore), che effettua sondaggi sulle attività decisionali e pianifica nuove attività.
+ **WorkflowStarter.java** --contiene lo starter del flusso di lavoro, che avvia una nuova esecuzione del flusso di lavoro, che farà sì che SWF inizi a generare attività decisionali e di workflow per i lavoratori.
### Procedure comuni per tutti i file sorgente
Tutti i file creati per ospitare le classi Java avranno alcune cose in comune. Per motivi di tempo, questi passaggi *saranno impliciti ogni volta che aggiungerai un nuovo file al progetto*:
1. Create il file nella `src/main/java/aws/example/helloswf/` cartella del progetto.
1. Aggiungi una `package` dichiarazione all'inizio di ogni file per dichiararne lo spazio dei nomi. Il progetto di esempio utilizza:
```
package aws.example.helloswf;
```
1. Aggiungi `import` dichiarazioni per la [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe e per più classi nel `com.amazonaws.services.simpleworkflow.model` namespace. Per semplificare le cose, useremo:
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
### Registra un dominio, un flusso di lavoro e tipi di attività
Inizieremo creando una nuova classe eseguibile,`HelloTypes.java`. Questo file conterrà dati condivisi che diverse parti del flusso di lavoro dovranno conoscere, come il nome e la versione dell'attività e i tipi di flusso di lavoro, il nome di dominio e il nome dell'elenco delle attività.
1. Apri l'editor di testo e crea il file`HelloTypes.java`, aggiungendo una dichiarazione del pacchetto e le importazioni secondo i [passaggi comuni](#swf-hello-common).
1. Dichiara la `HelloTypes` classe e forniscile i valori da utilizzare per le attività registrate e i tipi di flusso di lavoro:
```
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";
```
Questi valori verranno utilizzati in tutto il codice.
1. Dopo le dichiarazioni String, create un'istanza della [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe. Questa è l'interfaccia di base per i Amazon SWF metodi forniti da. AWS SDK per Java
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
Lo snippet precedente presuppone che le credenziali temporanee siano associate al profilo. `default` Se utilizzi un profilo diverso, modifica il codice precedente come segue e sostituiscilo *profile\$1name * con il nome del nome del profilo effettivo.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder
.standard()
.withCredentials(new ProfileCredentialsProvider("profile_name"))
.withRegion(Regions.DEFAULT_REGION)
.build();
```
1. Aggiungete una nuova funzione per registrare un dominio SWF. Un *dominio* è un contenitore logico per una serie di attività SWF e tipi di workflow correlati. I componenti SWF possono comunicare tra loro solo se esistono all'interno dello stesso dominio.
```
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!");
}
```
Quando registrate un dominio, gli fornite un *nome* (qualsiasi set di 1-256 caratteri esclusi `:` i caratteri di controllo o la stringa letterale '`arn') e un *periodo di conservazione*, ossia il numero di giorni in cui Amazon SWF verranno conservati i dati della cronologia di esecuzione del flusso di lavoro dopo il completamento dell'esecuzione di un flusso di lavoro. `/` `|` Il periodo massimo di conservazione dell'esecuzione del flusso di lavoro è di 90 giorni. Per ulteriori informazioni, consulta [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html).
Se esiste già un dominio con quel nome, [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html)viene generato un. Poiché non ci interessa se il dominio è già stato creato, possiamo ignorare l'eccezione.
**Nota**
Questo codice dimostra uno schema comune quando si lavora con i AWS SDK per Java metodi, i dati per il metodo sono forniti da una classe nel `simpleworkflow.model` namespace, che viene istanziata e compilata utilizzando i metodi concatenabili. `0with*`
1. Aggiungi una funzione per registrare un nuovo tipo di attività. Un'*attività* rappresenta un'unità di lavoro nel flusso di lavoro.
```
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 tipo di attività è identificato da un *nome* e da una *versione*, che vengono utilizzati per identificare in modo univoco l'attività rispetto a qualsiasi altra attività nel dominio in cui è registrata. Le attività contengono anche una serie di parametri opzionali, come l'elenco di attività predefinito utilizzato per ricevere attività e dati da SWF e una serie di timeout diversi che è possibile utilizzare per imporre vincoli sulla durata delle diverse parti dell'attività. Per ulteriori informazioni, consulta [RegisterActivityTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterActivityTypeRequest.html).
**Nota**
*Tutti i valori di timeout sono specificati in secondi.* Vedi [Tipi di Amazon SWF timeout](https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-timeout-types.html) per una descrizione completa di come i timeout influiscono sulle esecuzioni del flusso di lavoro.
Se il tipo di attività che stai cercando di registrare esiste già, viene generato un [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html). Aggiungi una funzione per registrare un nuovo tipo di flusso di lavoro. Un *flusso di lavoro*, noto anche come *decisore*, rappresenta la logica di esecuzione del flusso di lavoro.
\$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
Analogamente ai tipi di attività, i tipi di flusso di lavoro sono identificati da un *nome* e da una *versione* e dispongono anche di timeout configurabili. Per ulteriori informazioni, consulta [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
\$1
Se il tipo di flusso di lavoro che stai cercando di registrare esiste già, [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html)viene generato un. Infine, rendi eseguibile la classe fornendole un `main` metodo che registrerà a turno il dominio, il tipo di attività e il tipo di flusso di lavoro:
\$1
```
registerDomain();
registerWorkflowType();
registerActivityType();
```
Ora puoi [creare](#swf-hello-build) ed [eseguire](#swf-hello-run-register) l'applicazione per eseguire lo script di registrazione o continuare a codificare i lavoratori delle attività e del flusso di lavoro. Una volta registrati il dominio, il flusso di lavoro e l'attività, non sarà necessario eseguirli di nuovo: questi tipi persistono finché non li renderai obsoleti personalmente.
### Implementa l'Activity Worker
Un'*attività* è l'unità di lavoro di base in un flusso di lavoro. Un flusso di lavoro fornisce la logica, la pianificazione delle attività da eseguire (o altre azioni da intraprendere) in risposta alle attività decisionali. Un tipico flusso di lavoro è in genere costituito da una serie di attività che possono essere eseguite in modo sincrono, asincrono o una combinazione di entrambe.
L'*activity worker* è il bit di codice che analizza le attività generate da Amazon SWF in risposta alle decisioni relative al flusso di lavoro. Quando riceve un'attività, esegue l'attività corrispondente e restituisce una risposta di successo/fallimento al flusso di lavoro.
Implementeremo un semplice Activity Worker che gestisca una singola attività.
1. Apri l'editor di testo e crea il file`ActivityWorker.java`, aggiungendo una dichiarazione del pacchetto e importandolo secondo i [passaggi comuni](#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. Aggiungete la `ActivityWorker` classe al file e assegnategli un membro di dati che contenga un client SWF che useremo per interagire con Amazon SWF:
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Aggiungi il metodo che useremo come attività:
```
private static String sayHello(String input) throws Throwable {
return "Hello, " + input + "!";
}
```
L'attività prende semplicemente una stringa, la combina in un saluto e restituisce il risultato. Sebbene ci siano poche possibilità che questa attività generi un'eccezione, è consigliabile progettare attività che possano generare un errore se qualcosa va storto.
1. Aggiungi un `main` metodo che useremo come metodo di polling delle attività. Inizieremo aggiungendo del codice per esaminare l'elenco delle attività relative alle attività:
```
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'attività riceve le attività Amazon SWF richiamando il `pollForActivityTask` metodo del client SWF, specificando il dominio e l'elenco delle attività da utilizzare nel pass-in. [PollForActivityTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForActivityTaskRequest.html)
Una volta ricevuta un'operazione, ne richiamiamo un identificatore univoco richiamando il metodo dell'operazione. `getTaskToken`
1. Quindi, scrivi del codice per elaborare le attività che arrivano. Aggiungi quanto segue al tuo `main` metodo, subito dopo il codice che esegue il sondaggio per l'attività e ne recupera il token di attività.
```
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()));
}
}
```
Se il task token non lo è`null`, allora possiamo iniziare a eseguire il metodo activity (`sayHello`), fornendogli i dati di input inviati con l'attività.
Se l'operazione *ha avuto esito positivo* (non è stato generato alcun errore), l'operatore risponde a SWF chiamando il `respondActivityTaskCompleted` metodo del client SWF con un [RespondActivityTaskCompletedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskCompletedRequest.html)oggetto contenente il token dell'attività e i dati dei risultati dell'attività.
D'altra parte, se l'operazione *ha esito negativo*, rispondiamo chiamando il `respondActivityTaskFailed` metodo con un [RespondActivityTaskFailedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskFailedRequest.html)oggetto, passandogli il token dell'operazione e le informazioni sull'errore.
**Nota**
Questa attività non si interromperà correttamente se interrotta. Sebbene non rientri nello scopo di questo tutorial, un'implementazione alternativa di questo activity worker viene fornita nell'argomento di accompagnamento, [Shutting Down Activity and](swf-graceful-shutdown.md) Workflow Workers Gracefully.
### Implementa il workflow worker
La logica del flusso di lavoro risiede in un pezzo di codice noto come **workflow worker**. L'addetto al flusso di lavoro esegue sondaggi sulle attività decisionali inviate Amazon SWF nel dominio e nell'elenco di attività predefinito con cui è stato registrato il tipo di flusso di lavoro.
Quando l'addetto al flusso di lavoro riceve un'attività, prende una sorta di decisione (in genere se pianificare o meno una nuova attività) e intraprende un'azione appropriata (come la pianificazione dell'attività).
1. Apri l'editor di testo e crea il file`WorkflowWorker.java`, aggiungendo una dichiarazione del pacchetto e le importazioni secondo i [passaggi comuni](#swf-hello-common).
1. Aggiungi alcune importazioni aggiuntive al file:
```
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. Dichiarate la `WorkflowWorker` classe e create un'istanza della [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)classe utilizzata per accedere ai metodi SWF.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Aggiungete il metodo. `main` Il metodo si ripete continuamente, analizzando le attività decisionali utilizzando il metodo del client SWF. `pollForDecisionTask` [PollForDecisionTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForDecisionTaskRequest.html)Fornisce i dettagli.
```
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();
}
}
}
```
Una volta ricevuta un'attività, ne chiamiamo il `getTaskToken` metodo, che restituisce una stringa che può essere utilizzata per identificare l'attività. Se il token restituito non lo è`null`, lo elaboriamo ulteriormente nel `executeDecisionTask` metodo, passandogli il token dell'attività e l'elenco degli [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)oggetti inviati con l'operazione.
1. Aggiungiamo il `executeDecisionTask` metodo, prendendo il task token (a`String`) e l'`HistoryEvent`elenco.
```
List decisions = new ArrayList();
String workflow_input = null;
int scheduled_activities = 0;
int open_activities = 0;
boolean activity_completed = false;
String result = null;
```
Abbiamo anche configurato alcuni membri dei dati per tenere traccia di cose come:
+ Un elenco di oggetti [Decision](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) utilizzati per riportare i risultati dell'elaborazione dell'attività.
+ Una stringa per contenere l'input del flusso di lavoro fornito dall'evento WorkflowExecutionStarted "»
+ un conteggio delle attività pianificate e aperte (in esecuzione) per evitare di pianificare la stessa attività quando è già stata pianificata o è attualmente in esecuzione.
+ un valore booleano per indicare che l'attività è stata completata.
+ Una stringa per contenere i risultati dell'attività, per restituirli come risultato del nostro flusso di lavoro.
1. Quindi, aggiungi del codice `executeDecisionTask` per elaborare gli `HistoryEvent` oggetti inviati con l'attività, in base al tipo di evento riportato dal `getEventType` metodo.
```
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("]");
```
Ai fini del nostro flusso di lavoro, siamo particolarmente interessati a:
+ l'evento WorkflowExecutionStarted "", che indica che l'esecuzione del flusso di lavoro è iniziata (in genere significa che è necessario eseguire la prima attività del flusso di lavoro) e che fornisce l'input iniziale fornito al flusso di lavoro. In questo caso, si tratta della parte relativa al nome del messaggio di saluto, quindi viene salvata in una stringa da utilizzare per pianificare l'esecuzione dell'attività.
+ l'evento "ActivityTaskCompleted", che viene inviato una volta completata l'attività pianificata. I dati dell'evento includono anche il valore restituito dall'attività completata. Poiché abbiamo una sola attività, utilizzeremo quel valore come risultato dell'intero flusso di lavoro.
Gli altri tipi di eventi possono essere utilizzati se il flusso di lavoro li richiede. Vedi la descrizione della [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html)classe per informazioni su ogni tipo di evento.
\$1 NOTA: le stringhe nelle `switch` istruzioni sono state introdotte in Java 7. Se stai utilizzando una versione precedente di Java, puoi utilizzare la [EventType](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/model/EventType.html)classe per convertire il valore `String` restituito da `history_event.getType()` in un valore enum e poi tornare a, `String` se necessario:
```
EventType et = EventType.fromValue(event.getEventType());
```
1. Dopo l'`switch`istruzione, aggiungete altro codice per rispondere con una *decisione* appropriata in base all'attività ricevuta.
```
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);
```
+ Se l'attività non è stata ancora programmata, rispondiamo con una `ScheduleActivityTask` decisione, che fornisce informazioni in una [ScheduleActivityTaskDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleActivityTaskDecisionAttributes.html)struttura sull'attività da programmare successivamente, inclusi anche i dati da Amazon SWF inviare all'attività. Amazon SWF
+ Se l'attività è stata completata, consideriamo completato l'intero flusso di lavoro e rispondiamo con una `CompletedWorkflowExecution` decisione, compilando una [CompleteWorkflowExecutionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/CompleteWorkflowExecutionDecisionAttributes.html)struttura per fornire dettagli sul flusso di lavoro completato. In questo caso, restituiamo il risultato dell'attività.
In entrambi i casi, le informazioni sulla decisione vengono aggiunte all'`Decision`elenco dichiarato all'inizio del metodo.
1. Completa l'attività decisionale restituendo l'elenco degli `Decision` oggetti raccolti durante l'elaborazione dell'attività. Aggiungi questo codice alla fine del `executeDecisionTask` metodo che abbiamo scritto:
```
swf.respondDecisionTaskCompleted(
new RespondDecisionTaskCompletedRequest()
.withTaskToken(taskToken)
.withDecisions(decisions));
```
Il `respondDecisionTaskCompleted` metodo del client SWF utilizza il token task che identifica l'operazione e l'elenco degli `Decision` oggetti.
### Implementate lo starter del workflow
Infine, scriveremo del codice per avviare l'esecuzione del flusso di lavoro.
1. Apri l'editor di testo e crea il file`WorkflowStarter.java`, aggiungendo una dichiarazione del pacchetto e le importazioni secondo i [passaggi comuni](#swf-hello-common).
1. Aggiungi la `WorkflowStarter` classe:
```
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 `WorkflowStarter` classe è costituita da un unico metodo`main`, che accetta un argomento opzionale passato dalla riga di comando come dati di input per il flusso di lavoro.
Il metodo client SWF`startWorkflowExecution`, accetta un [StartWorkflowExecutionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/StartWorkflowExecutionRequest.html)oggetto come input. Qui, oltre a specificare il dominio e il tipo di workflow da eseguire, forniamo:
+ un nome di esecuzione del flusso di lavoro leggibile dall'uomo
+ dati di input del flusso di lavoro (forniti nella riga di comando nel nostro esempio)
+ un valore di timeout che rappresenta il tempo, in secondi, necessario per l'esecuzione dell'intero flusso di lavoro.
L'oggetto [Run](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Run.html) che `startWorkflowExecution` restituisce fornisce un *ID di esecuzione*, un valore che può essere utilizzato per identificare questa particolare esecuzione Amazon SWF del flusso di lavoro nella cronologia delle esecuzioni del flusso di lavoro.
\$1 NOTA: L'ID di esecuzione viene generato da Amazon SWF e *non* è lo stesso nome di esecuzione del flusso di lavoro passato all'avvio dell'esecuzione del flusso di lavoro.
## Crea l'esempio
Per creare il progetto di esempio con Maven, vai alla `helloswf` directory e digita:
```
mvn package
```
Il risultato `helloswf-1.0.jar` verrà generato nella directory. `target`
## Esegui l'esempio
L'esempio è costituito da quattro classi eseguibili separate, che vengono eseguite indipendentemente l'una dall'altra.
**Nota**
Se utilizzi un sistema Linux, macOS o Unix, puoi eseguirli tutti, uno dopo l'altro, in un'unica finestra di terminale. Se utilizzi Windows, dovresti aprire due istanze da riga di comando aggiuntive e accedere alla directory di ciascuna. `helloswf`
### Impostazione del percorso di classe Java
Sebbene Maven abbia gestito le dipendenze per te, per eseguire l'esempio, dovrai fornire la libreria AWS SDK e le relative dipendenze sul tuo classpath Java. Puoi impostare la variabile di `CLASSPATH` ambiente sulla posizione delle librerie SDK e sulla `third-party/lib` directory nell' AWS SDK, che include le dipendenze necessarie:
```
export CLASSPATH='target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/*'
java example.swf.hello.HelloTypes
```
oppure usa l'`-cp`opzione del **` java `**comando per impostare il classpath durante l'esecuzione di ciascuna applicazione.
```
java -cp target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/* \
example.swf.hello.HelloTypes
```
Lo stile che usi dipende da te. Se non avete avuto problemi a compilare il codice, provate entrambi a eseguire gli esempi e ottenete una serie di errori "NoClassDefFound", probabilmente perché il classpath è impostato in modo errato.
### Registra il dominio, il flusso di lavoro e i tipi di attività
Prima di avviare i worker e il workflow starter, dovrai registrare il dominio e i tipi di flusso di lavoro e attività. Il codice per eseguire questa operazione è stato implementato in [Registra un dominio, flussi di lavoro e tipi di attività](#swf-hello-hellotypes).
Dopo la creazione, e se hai [impostato CLASSPATH](#swf-hello-set-classpath), puoi eseguire il codice di registrazione eseguendo il comando:
```
echo 'Supply the name of one of the example classes as an argument.'
```
### Avvia l'attività e i lavoratori del flusso di lavoro
Ora che i tipi sono stati registrati, puoi avviare i lavoratori dell'attività e del flusso di lavoro. Queste continueranno a funzionare e a verificare le attività finché non verranno interrotte, quindi dovresti eseguirle in finestre di terminale separate oppure, se utilizzi Linux, macOS o Unix, puoi usare `&` l'operatore per far sì che ognuna di esse generi un processo separato durante l'esecuzione.
```
echo 'If there are arguments to the class, put them in quotes after the class name.'
exit 1
```
Se esegui questi comandi in finestre separate, ometti l'operatore finale `&` da ogni riga.
### Avviate l'esecuzione del flusso di lavoro
Ora che gli addetti alle attività e al flusso di lavoro stanno effettuando i sondaggi, puoi iniziare l'esecuzione del flusso di lavoro. Questo processo verrà eseguito fino a quando il flusso di lavoro non tornerà allo stato completato. Dovreste eseguirlo in una nuova finestra di terminale (a meno che non abbiate eseguito i worker come nuovi processi generati utilizzando l'`&`operatore).
```
fi
```
**Nota**
Se desideri fornire i tuoi dati di input, che verranno passati prima al flusso di lavoro e poi all'attività, aggiungili alla riga di comando. Per esempio:
```
echo "## Running $className..."
```
Una volta iniziata l'esecuzione del flusso di lavoro, dovresti iniziare a vedere l'output fornito sia dai lavoratori che dall'esecuzione del flusso di lavoro stesso. Quando il flusso di lavoro sarà finalmente completato, il relativo output verrà stampato sullo schermo.
## Fonte completa per questo esempio
Puoi sfogliare il [codice sorgente completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java/example_code/swf) di questo esempio su Github nel *aws-java-developer-guide*repository.
## Ulteriori informazioni
+ I lavoratori qui presentati possono comportare la perdita di attività se vengono fermati mentre è ancora in corso un sondaggio sul flusso di lavoro. Per scoprire come chiudere i dipendenti in modo corretto, consulta [Shutting Down Activity e Workflow Workers Gracefully.](swf-graceful-shutdown.md)
+ [Per saperne di più Amazon SWF, visita la [Amazon SWF](https://aws.amazon.com/swf/)home page o visualizza la Guida per gli sviluppatori.Amazon SWF](https://docs.aws.amazon.com/amazonswf/latest/developerguide/)
+ Puoi usare AWS Flow Framework for Java per scrivere flussi di lavoro più complessi in un elegante stile Java usando le annotazioni. Per ulteriori informazioni, consulta la [AWS Flow Framework Java Developer Guide](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
# Lambda Compiti
In alternativa o in combinazione con Amazon SWF le attività, puoi utilizzare le funzioni [Lambda](https://aws.amazon.com/lambda/) per rappresentare le unità di lavoro nei flussi di lavoro e programmarle in modo simile alle attività.
Questo argomento si concentra su come implementare le Amazon SWF Lambda attività utilizzando. AWS SDK per Java Per ulteriori informazioni sulle Lambda attività in generale, consulta [AWS Lambda Tasks](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html) nella Amazon SWF Developer Guide.
## Configura un ruolo IAM multiservizio per eseguire la tua funzione Lambda
Prima di Amazon SWF poter eseguire la tua Lambda funzione, devi configurare un ruolo IAM che Amazon SWF autorizzi l'esecuzione di Lambda funzioni per tuo conto. Per informazioni complete su come eseguire questa operazione, consulta [AWS Lambda Attività](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html).
Avrai bisogno dell'Amazon Resource Name (ARN) di questo ruolo IAM quando registri un flusso di lavoro che Lambda utilizzerà le attività.
## Crea una funzione Lambda
È possibile scrivere Lambda funzioni in diversi linguaggi, incluso Java. Per informazioni complete su come creare, distribuire e utilizzare Lambda le funzioni, consulta la [Guida per gli AWS Lambda sviluppatori](https://docs.aws.amazon.com/lambda/latest/dg/).
**Nota**
Indipendentemente dalla lingua utilizzata per scrivere la Lambda funzione, questa può essere pianificata ed eseguita da *qualsiasi* Amazon SWF flusso di lavoro, indipendentemente dalla lingua in cui è scritto il codice del flusso di lavoro. Amazon SWF gestisce i dettagli relativi all'esecuzione della funzione e al trasferimento dei dati da e verso di essa.
Ecco una semplice Lambda funzione che potrebbe essere utilizzata al posto dell'attività in [Building a Simple Amazon SWF Application](swf-hello.md).
+ Questa versione è scritta in JavaScript, e può essere inserita direttamente utilizzando [Console di gestione AWS](https://console.aws.amazon.com/console/home):
```
exports.handler = function(event, context) {
context.succeed("Hello, " + event.who + "!");
};
```
+ Ecco la stessa funzione scritta in Java, che puoi anche distribuire ed eseguire su 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 + "!");
}
}
```
**Nota**
Per ulteriori informazioni sulla distribuzione delle funzioni Java in Lambda, [consulta Creating a Deployment Package (Java](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html)) nella AWS Lambda Developer Guide. Ti consigliamo anche di consultare la sezione intitolata [Modello di programmazione per le funzioni di creazione in Java. Lambda](https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html)
Lambda le funzioni accettano un *evento* o un oggetto di *input* come primo parametro e un oggetto di *contesto* come secondo, che fornisce informazioni sulla richiesta di esecuzione della Lambda funzione. Questa particolare funzione prevede che l'input sia in JSON, con un `who` campo impostato sul nome usato per creare il messaggio di saluto.
## Registrare un flusso di lavoro da utilizzare con Lambda
Affinché un flusso di lavoro Lambda pianifichi una funzione, devi fornire il nome del ruolo IAM che fornisce l'autorizzazione Amazon SWF a richiamare Lambda le funzioni. È possibile impostarlo durante la registrazione del flusso di lavoro utilizzando i `setDefaultLambdaRole` metodi `withDefaultLambdaRole` o di [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) {
```
## Pianifica un' Lambda attività
La pianificazione di un' Lambda attività è simile alla pianificazione di un'attività. Fornisci una [decisione](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) con un `ScheduleLambdaFunction` [DecisionType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DecisionType.html)e con [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(
```
In`ScheduleLambdaFuntionDecisionAttributes`, è necessario fornire un *nome*, che è l'ARN della Lambda funzione da chiamare, e un *id*, che è il nome che Amazon SWF verrà utilizzato per identificare la Lambda funzione nei registri cronologici.
È inoltre possibile fornire un *input* opzionale per la Lambda funzione e impostarne il valore di *timeout di inizio e chiusura*, ovvero il numero di secondi in cui la Lambda funzione può essere eseguita prima della generazione di un evento. `LambdaFunctionTimedOut`
**Nota**
Questo codice utilizza il [AWSLambdaClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambdaClient.html) per recuperare l'ARN della funzione, dato Lambda il nome della funzione. Puoi usare questa tecnica per evitare di codificare l'ARN completo (che include il tuo Account AWS ID) nel codice.
## Gestisci gli eventi della funzione Lambda nel tuo decisore
Lambda le attività genereranno una serie di eventi sui quali è possibile intervenire durante la selezione delle attività decisionali del proprio addetto al flusso di lavoro, corrispondenti al ciclo di vita dell' Lambda attività, con [EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html)valori come, e. `LambdaFunctionScheduled` `LambdaFunctionStarted` `LambdaFunctionCompleted` Se la Lambda funzione fallisce o l'esecuzione impiega più tempo rispetto al valore di timeout impostato, riceverai rispettivamente un tipo di `LambdaFunctionTimedOut` evento `LambdaFunctionFailed` o un tipo di evento.
```
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;
```
## Ricevi l'output dalla tua funzione Lambda
Quando ricevete 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)per ottenere un [LambdaFunctionCompletedEventAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/LambdaFunctionCompletedEventAttributes.html)oggetto e poi chiamate il relativo `getResult` metodo per recuperare l'output della Lambda funzione:
```
LambdaFunctionCompleted:
running_functions--;
```
## Fonte completa per questo esempio
Puoi sfogliare la *fonte completa:github: `< awsdocs/aws-java-developer-guide/tree/master/doc\$1source/snippets/helloswf \$1lambda/>* per questo esempio su Github nel repository. *aws-java-developer-guide*
# Chiusura graduale degli addetti alle attività e ai flussi di lavoro
L'argomento [Creazione di un' Amazon SWF applicazione semplice](swf-hello.md) ha fornito un'implementazione completa di una semplice applicazione per il flusso di lavoro composta da un'applicazione di registrazione, un addetto alle attività e ai flussi di lavoro e uno starter del flusso di lavoro.
Le classi di lavoro sono progettate per essere eseguite in modo continuo e consentono di eseguire sondaggi sulle attività inviate Amazon SWF per eseguire attività o restituire decisioni. Una volta effettuata una richiesta di sondaggio, Amazon SWF registra il poller e tenterà di assegnargli un compito.
Se il lavoratore del flusso di lavoro viene licenziato durante un sondaggio prolungato, Amazon SWF può comunque provare a inviare un'attività al lavoratore terminato, con conseguente perdita dell'attività (fino al timeout dell'attività).
Un modo per gestire questa situazione consiste nell'attendere la restituzione di tutte le lunghe richieste di sondaggio prima che il lavoratore termini.
In questo argomento, riscriveremo l'Activity Worker utilizzando gli hook di `helloswf` shutdown di Java per tentare di arrestare correttamente l'activity worker.
Ecco il codice completo:
```
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()));
}
}
}
}
}
```
In questa versione, il codice di polling presente nella `main` funzione nella versione originale è stato spostato nel suo metodo,`pollAndExecute`.
La `main` funzione ora utilizza [CountDownLatch](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CountDownLatch.html)a insieme a un [hook di spegnimento](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Runtime.html) per far attendere il thread fino a 60 secondi dopo la richiesta di terminazione prima di chiudere il thread.
# Registrazione di domini
Ogni flusso di lavoro e attività [Amazon SWF](https://aws.amazon.com/swf/)richiede un *dominio* in cui essere eseguito.
1. Crea un nuovo [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html)oggetto, fornendogli almeno il nome di dominio e il periodo di conservazione dell'esecuzione del flusso di lavoro (entrambi i parametri sono obbligatori).
1. Chiamate il metodo [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-) con l'oggetto. *RegisterDomainRequest*
1. Verifica [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html)se il dominio che stai richiedendo esiste già (nel qual caso, di solito non è richiesta alcuna azione).
Il codice seguente illustra questa procedura:
```
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!");
}
}
```
# Elenco di domini
Puoi elencare i [Amazon SWF](https://aws.amazon.com/swf/)domini associati al tuo account e alla tua AWS regione in base al tipo di registrazione.
1. Crea un [ListDomainsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ListDomainsRequest.html)oggetto e specifica lo stato di registrazione dei domini che ti interessano (questo è obbligatorio).
1. Chiama [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-) con l'oggetto. *ListDomainRequest* I risultati vengono forniti in un oggetto. [DomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html)
1. Richiama [getDomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html#getDomainInfos--)l'oggetto restituito per ottenere un elenco di [DomainInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html)oggetti.
1. Chiama [getName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html#getName--) su ogni *DomainInfo*oggetto per ottenerne il nome.
Il codice seguente illustra questa procedura:
```
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());
}
}
```
# Esempi di codice inclusi nell'SDK
AWS SDK per Java Viene fornito con esempi di codice che illustrano molte delle funzionalità dell'SDK in programmi compilabili ed eseguibili. È possibile studiarli o modificarli per implementare le proprie soluzioni utilizzando il. AWS AWS SDK per Java
## Come ottenere i campioni
Gli esempi di AWS SDK per Java codice sono forniti nella directory *samples* dell'SDK. Se hai scaricato e installato l'SDK utilizzando le informazioni in [Configurazione AWS SDK per Java, gli](setup-install.md) esempi sono già presenti sul tuo sistema.
Puoi anche visualizzare gli esempi più recenti nel AWS SDK per Java GitHub repository, nella directory [src/samples](https://github.com/aws/aws-sdk-java/tree/master/src/samples).
## Creazione ed esecuzione degli esempi utilizzando la riga di comando
Gli esempi includono gli script di compilazione di [Ant](http://ant.apache.org/) in modo da poterli creare ed eseguire facilmente dalla riga di comando. Ogni esempio contiene anche un file README in formato HTML che contiene informazioni specifiche per ogni esempio.
**Nota**
Se stai sfogliando il codice di esempio GitHub, fai clic sul pulsante **Raw** nella visualizzazione del codice sorgente quando visualizzi il file README.html dell'esempio. In modalità raw, il codice HTML verrà visualizzato come previsto nel browser.
### Prerequisiti
Prima di eseguire qualsiasi esempio, AWS SDK per Java è necessario impostare le AWS credenziali nell'ambiente o con AWS CLI, come specificato in [Configurazione delle AWS credenziali e della regione per](setup-credentials.md) lo sviluppo. Gli esempi utilizzano la catena di fornitori di credenziali predefinita quando possibile. Quindi, impostando le credenziali in questo modo, è possibile evitare la pratica rischiosa di inserire AWS le credenziali in file all'interno della directory del codice sorgente (dove potrebbero essere inavvertitamente archiviate e condivise pubblicamente).
### Esecuzione degli esempi
1. Passate alla directory contenente il codice dell'esempio. Ad esempio, se ti trovi nella directory principale del download dell' AWS SDK e desideri eseguire l'`AwsConsoleApp`esempio, devi digitare:
```
cd samples/AwsConsoleApp
```
1. Compila ed esegui l'esempio con Ant. Il target di build predefinito esegue entrambe le azioni, quindi puoi semplicemente inserire:
```
ant
```
L'esempio stampa le informazioni sullo standard output, ad esempio:
```
===========================================
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.
```
## Creazione ed esecuzione degli esempi utilizzando l'IDE Eclipse
Se utilizzi il AWS Toolkit for Eclipse, puoi anche avviare un nuovo progetto in Eclipse basato su AWS SDK per Java o aggiungere l'SDK a un progetto Java esistente.
### Prerequisiti
Dopo aver installato AWS Toolkit for Eclipse, ti consigliamo di configurare il Toolkit con le tue credenziali di sicurezza. **Puoi farlo in qualsiasi momento scegliendo **Preferenze** dal menu **Finestra** di Eclipse, quindi scegliendo la sezione Toolkit. AWS **
### Esecuzione degli esempi
1. Aprire Eclipse
1. Crea un nuovo progetto Java AWS . In Eclipse, nel menu **File**, scegliete **Nuovo**, quindi fate clic su **Progetto**. Si apre la procedura guidata **Nuovo progetto**.
1. Espandi la ** AWS **categoria, quindi scegli ** AWS Java Project**.
1. Scegli **Next (Successivo)**. Viene visualizzata la pagina delle impostazioni del progetto.
1. Immettete un nome nella casella **Nome progetto**. Il gruppo AWS SDK per Java Samples mostra gli esempi disponibili nell'SDK, come descritto in precedenza.
1. Seleziona gli esempi che desideri includere nel progetto selezionando ciascuna casella di controllo.
1. Inserisci le tue AWS credenziali. Se le hai già configurate AWS Toolkit for Eclipse con le tue credenziali, queste vengono compilate automaticamente.
1. Scegli **Fine**. Il progetto viene creato e aggiunto a **Project Explorer**.
1. Scegli il `.java` file di esempio che desideri eseguire. Ad esempio, per l' Amazon S3 esempio, scegli`S3Sample.java`.
1. Scegliete **Esegui** dal menu **Esegui**.
1. Fate clic con il pulsante destro del mouse sul **progetto in Project Explorer**, scegliete **Crea percorso**, quindi **scegliete Aggiungi librerie**.
1. Scegliete ** AWS Java SDK**, scegliete **Avanti**, quindi seguite le restanti istruzioni visualizzate sullo schermo.