La AWS SDK para Java 1.x se alcanzó end-of-support el 31 de diciembre de 2025. Le recomendamos que migre a [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) para seguir recibiendo nuevas características, mejoras de disponibilidad y actualizaciones de seguridad.
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# AWS SDK para JavaEjemplos de código de
En esta sección se proporcionan tutoriales y ejemplos de cómo utilizar AWS SDK para Java v1 para programar servicios de AWS.
Busque el código fuente de estos ejemplos y otros en la documentación de AWS [repositorio de ejemplos de código en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples).
Para proponer un nuevo ejemplo de código para que el equipo de documentación de AWS considere la posibilidad de crearlo, cree una nueva solicitud. El equipo está buscando crear ejemplos de código que abarquen situaciones y casos de uso más amplios, en comparación con fragmentos de código sencillos que tratan solo llamadas a la API individuales. Para obtener instrucciones, consulte las [pautas de contribución](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md) en el repositorio de ejemplos de código en GitHub.
## AWS SDK para Java 2.x
En 2018, AWS lanzó el [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html). Esta guía contiene instrucciones sobre el uso de la versión más reciente del SDK de Java, junto con un código de ejemplo.
**nota**
Consulte [Documentación y recursos adicionales](welcome.md#additional-resources) para obtener más ejemplos y recursos adicionales disponibles para los desarrolladores de AWS SDK para Java.
**Topics**
# Ejemplos de CloudWatch con AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [CloudWatch](https://aws.amazon.com/cloudwatch/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
Amazon CloudWatch monitorea sus recursos Amazon Web Services (AWS) y las aplicaciones que ejecuta en AWS en tiempo real. Puede utilizar CloudWatch para recopilar y hacer un seguimiento de métricas, que son las variables que puede medir en los recursos y aplicaciones. Las alarmas de CloudWatch envían notificaciones o efectúan cambios automáticamente en los recursos que está supervisando basándose en las reglas que defina.
Para obtener más información sobre CloudWatch, consulte la [Guía del usuario de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Obtención de métricas de CloudWatch](examples-cloudwatch-get-metrics.md)
+ [Publicación de datos de métricas personalizadas](examples-cloudwatch-publish-custom-metrics.md)
+ [Uso de alarmas de CloudWatch](examples-cloudwatch-create-alarms.md)
+ [Uso de acciones de alarma en CloudWatch](examples-cloudwatch-use-alarm-actions.md)
+ [Envío de eventos de a CloudWatch](examples-cloudwatch-send-events.md)
# Obtención de métricas de CloudWatch
## Mostrar métricas
Para enumerar las métricas de CloudWatch, cree un objeto [ListMetricsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsRequest.html) y llame al método `listMetrics` del AmazonCloudWatchClient. Puede utilizar el objeto `ListMetricsRequest` para filtrar las métricas devueltas por espacio de nombres, nombre de métrica o dimensiones.
**nota**
Puede encontrar una lista de las métricas y dimensiones publicadas por los servicios de AWS en \$1https://--docs-aws-amazon-com-AmazonCloudWatch-latest-Monitoring-CW-Support-for-AWS-html\$1Referencia de métricas y dimensiones de Amazon CloudWatch] de la Guía del usuario de Amazon CloudWatch.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Las métricas se devuelven en un objeto [ListMetricsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/ListMetricsResult.html) llamando a su método `getMetrics`. Los resultados puede que estén *paginados*. Para recuperar el siguiente lote de resultados, llame a `setNextToken` en el objeto de la solicitud original con el valor devuelto del método `ListMetricsResult` del objeto `getNextToken` y pase el objeto de la solicitud modificado a otra llamada a `listMetrics`.
## Más información
+ [ListMetrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html) en la Referencia de la API de Amazon CloudWatch
# Publicación de datos de métricas personalizadas
Algunos servicios de AWS publican [sus propias métricas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) en espacios de nombres que comienzan por "`AWS`". También puede publicar datos de métricas personalizadas usando su propio espacio de nombres (siempre y cuando no comience por "`AWS`").
## Publicación de datos de métricas personalizadas
Para publicar sus propios datos de métricas, llame al método `putMetricData` de AmazonCloudWatchClient con un objeto [PutMetricDataRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricDataRequest.html). El `PutMetricDataRequest` debe incluir el espacio de nombres personalizado que se va a usar para los datos e información sobre el propio punto de datos en un objeto [MetricDatum](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/MetricDatum.html).
**nota**
No puede especificar un espacio de nombres que comience por "`AWS`". Los espacios de nombres que comienzan por "`AWS`" están reservados para su uso por los productos de Amazon Web Services.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
## Más información
+ [Uso de Métricas de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) en la Guía del usuario de Amazon CloudWatch.
+ [Espacios de nombres de AWS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aws-namespaces.html) en la Guía del usuario de Amazon CloudWatch.
+ [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html) en la Referencia de la API de Amazon CloudWatch.
# Uso de alarmas de CloudWatch
## Crear una alarma
Para crear una alarma basada en una métrica de CloudWatch, llame al método `putMetricAlarm` de AmazonCloudWatchClient con un objeto [PutMetricAlarmRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html) en el que se especifiquen las condiciones de la alarma.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
## Mostrar alarmas
Para mostrar las alarmas de CloudWatch que ha creado, llame al método `describeAlarms` de AmazonCloudWatchClient con un objeto [DescribeAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsRequest.html) que puede utilizar para establecer opciones para el resultado.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
boolean done = false;
DescribeAlarmsRequest request = new DescribeAlarmsRequest();
while(!done) {
DescribeAlarmsResult response = cw.describeAlarms(request);
for(MetricAlarm alarm : response.getMetricAlarms()) {
System.out.printf("Retrieved alarm %s", alarm.getAlarmName());
}
request.setNextToken(response.getNextToken());
if(response.getNextToken() == null) {
done = true;
}
}
```
La lista de alarmas se puede obtener llamando a `getMetricAlarms` en el objeto [DescribeAlarmsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DescribeAlarmsResult.html) que devuelve `describeAlarms`.
Los resultados puede que estén *paginados*. Para recuperar el siguiente lote de resultados, llame a `setNextToken` en el objeto de la solicitud original con el valor devuelto del método `DescribeAlarmsResult` del objeto `getNextToken` y pase el objeto de la solicitud modificado a otra llamada a `describeAlarms`.
**nota**
También puede recuperar alarmas para una métrica específica mediante el método `describeAlarmsForMetric` de AmazonCloudWatchClient. Su uso es similar a `describeAlarms`.
## Eliminar alarmas
Para eliminar alarmas de CloudWatch, llame al método `deleteAlarms` de AmazonCloudWatchClient con un objeto [DeleteAlarmsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DeleteAlarmsRequest.html) que contenga uno o más nombres de alarma que desea eliminar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DeleteAlarmsRequest request = new DeleteAlarmsRequest()
.withAlarmNames(alarm_name);
DeleteAlarmsResult response = cw.deleteAlarms(request);
```
## Más información
+ [Creación de una capa de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) en la Guía del usuario de Amazon CloudWatch
+ [PutMetricalArm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html) en la Referencia de la API de Amazon CloudWatch
+ [DescribeAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html) en la referencia de la API de Amazon CloudWatch
+ [DeleteAlarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DeleteAlarms.html) en la referencia de la API de Amazon CloudWatch
# Uso de acciones de alarma en CloudWatch
Mediante las acciones de alarma, puede crear alarmas que realicen acciones como detener, terminar, reiniciar, o recuperar automáticamente instancias de Amazon EC2.
**nota**
Las acciones de alarma se pueden añadir a una alarma mediante el método [ de ](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/PutMetricAlarmRequest.html)PutMetricAlarmRequest`setAlarmActions` al [crear una alarma](examples-cloudwatch-create-alarms.md).
## Habilitar acciones de alarma
Para habilitar acciones de alarma para una alarma de CloudWatch, llame al `enableAlarmActions` de AmazonCloudWatchClient con un objeto [EnableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/EnableAlarmActionsRequest.html) que contenga uno o varios nombres de alarma cuyas acciones desee habilitar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
EnableAlarmActionsRequest request = new EnableAlarmActionsRequest()
.withAlarmNames(alarm);
EnableAlarmActionsResult response = cw.enableAlarmActions(request);
```
## Deshabilitar acciones de alarma
Para deshabilitar acciones de alarma para una alarma de CloudWatch, llame al `disableAlarmActions` del AmazonCloudWatchClient con un objeto [DisableAlarmActionsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatch/model/DisableAlarmActionsRequest.html) que contenga uno o varios nombres de alarma cuyas acciones desee deshabilitar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonCloudWatch cw =
AmazonCloudWatchClientBuilder.defaultClient();
DisableAlarmActionsRequest request = new DisableAlarmActionsRequest()
.withAlarmNames(alarmName);
DisableAlarmActionsResult response = cw.disableAlarmActions(request);
```
## Más información
+ [Crear alarmas para detener, terminar, reiniciar o recuperar una instancia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) en la Guía del usuario de Amazon CloudWatch
+ [PutMetricalArm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html) en la Referencia de la API de Amazon CloudWatch
+ [EnableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_EnableAlarmActions.html) en la Referencia de la API de Amazon CloudWatch
+ [DisableAlarmActions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DisableAlarmActions.html) en la Referencia de la API de Amazon CloudWatch
# Envío de eventos de a CloudWatch
CloudWatch permite la transmisión casi en tiempo real de eventos del sistema que describen cambios en los recursos de AWS a instancias Amazon EC2, funciones Lambda, secuencias de Kinesis, tareas de Amazon ECS, máquinas de estado de Step Functions, temas de Amazon SNS, colas de Amazon SQS o destinos integrados. Mediante reglas sencillas, puede asignar los eventos y dirigirlos a una o más secuencias o funciones de destino.
## Añadir eventos
Para añadir eventos de CloudWatch personalizados, llame al método `putEvents` del cliente AmazonCloudWatchEventsClient con un objeto [PutEventsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequest.html) que contenga uno o varios objetos [PutEventsRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutEventsRequestEntry.html) que proporcionen detalles sobre cada evento. Puede especificar varios parámetros para la entrada como el origen y el tipo del evento, los recursos asociados con el evento, etc.
**nota**
Puede especificar un máximo de 10 eventos para cada llamada a `putEvents`.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
## Añadir reglas
Para crear o actualizar una regla, llame al método `putRule` de AmazonCloudWatchEventsClient con un objeto [PutRuleRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutRuleRequest.html) con el nombre de la regla y parámetros opcionales como el [patrón del evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html), el rol de IAM que se va a asociar a la regla y una [expresión de programación](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) que describa con qué frecuencia se ejecuta la regla.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
## Añadir destinos
Los destinos son los recursos que se invocan cuando se activa una regla. Algunos destinos de ejemplo son instancias Amazon EC2, funciones Lambda, secuencias de Kinesis, tareas de Amazon ECS, máquinas de estado de Step Functions y destinos integrados.
Para añadir una regla a un destino, llame al método `putTargets` de AmazonCloudWatchEventsClient con un objeto [PutTargetsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/cloudwatchevents/model/PutTargetsRequest.html) que contenga la regla para actualizar y la lista de destinos que se van a añadir a la regla.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
## Más información
+ [Añadir eventos con PutEvents](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/AddEventsPutEvents.html) en la Guía del usuario del Amazon CloudWatch Events
+ [Programar expresiones para reglas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html) en la Guía del usuario del Amazon CloudWatch Events
+ [Tipos de eventos para los eventos de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html) en la Guía del usuario del Amazon CloudWatch Events
+ [Eventos y patrones de eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) en la Guía del usuario del Amazon CloudWatch Events
+ [PutEvents](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutEvents.html) en la Referencia de la API de Amazon CloudWatch Events
+ [PutTargets](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html) en la Referencia de la API de Amazon CloudWatch Events
+ [PutRule](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutRule.html) en la Referencia de la API de Amazon CloudWatch Events
# DynamoDB Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [DynamoDB](https://aws.amazon.com/dynamodb/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Uso de puntos de conexión basados en cuentas de AWS](#account-based-endpoint-routing)
+ [Uso de tablas en DynamoDB](examples-dynamodb-tables.md)
+ [Uso de elementos en DynamoDB](examples-dynamodb-items.md)
## Uso de puntos de conexión basados en cuentas de AWS
DynamoDB ofrece [puntos de conexión basados en cuentas de AWS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) que pueden mejorar el rendimiento al utilizar su ID de cuenta de AWS para optimizar el enrutamiento de solicitudes.
Para aprovechar esta característica, debe utilizar la versión 1.12.771 o superior del versión 1 de AWS SDK para Java. Encontrará la última versión del SDK en el [repositorio central de Maven](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom). Una vez que se active una versión compatible del SDK, utilizará automáticamente los nuevos puntos de conexión.
Si desea desactivar el enrutamiento basado en cuentas, dispone de cuatro opciones:
+ Configure un cliente de servicio de DynamoDB con `AccountIdEndpointMode` establecido como `DISABLED`.
+ Establezca una variable de entorno.
+ Establezca una propiedad del sistema JVM.
+ Actualice el ajuste del archivo de configuración compartido de AWS.
El siguiente fragmento es un ejemplo de cómo deshabilitar el enrutamiento basado en cuentas mediante la configuración de un cliente de servicio de 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 guía de referencia de las herramientas y los SDK de AWS proporciona más información sobre las [tres últimas opciones de configuración](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).
# Uso de tablas en DynamoDB
Las tablas son los contenedores de todos los elementos de una base de datos de DynamoDB. Para poder añadir o eliminar datos de DynamoDB, debe crear una tabla.
Para cada tabla, debe definir:
+ Un *nombre* de tabla que sea único para su cuenta y región.
+ Una *clave principal* para la que cada valor debe ser único; no puede haber dos elementos de la tabla que tengan el mismo valor de clave principal.
Una clave principal puede ser *simple*, formada por una sola clave de partición (HASH) o *compuesta*, formada por una clave de partición y una clave de ordenación (RANGE).
Cada valor de clave tiene un *tipo de datos* asociado enumerado por la clase [ScalarAttributeType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ScalarAttributeType.html). El valor de clave puede ser binario (B), numérico (N) o una cadena (S). Para obtener más información, consulte [Reglas de nomenclatura y tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) en la Guía para desarrolladores de Amazon DynamoDB.
+ Valores de *rendimiento aprovisionado* que definan el número de unidades de capacidad de lectura/escritura reservadas para la tabla.
**nota**
[Los precios de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) se basan en los valores de desempeño aprovisionado que puede definir en sus tablas para que solo se reserve la capacidad que piensa que va a necesitar para la tabla.
El desempeño aprovisionado para una tabla se puede modificar en cualquier momento, por lo que puede ajustar la capacidad si cambian sus necesidades.
## Crear una tabla
Use el método [del cliente de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) para crear una nueva tabla de DynamoDB. Debe crear los atributos de la tabla y un esquema de tabla, que se pueden usar para identificar la clave principal de la tabla. También debe proporcionar los valores iniciales de desempeño aprovisionado y el nombre de una tabla. Defina solo los atributos clave de la tabla al crear su tabla de DynamoDB.
**nota**
Si ya existe una tabla con el nombre elegido, se producirá una excepción [AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html).
**Importaciones**
```
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;
```
### Creación de una tabla con una clave principal simple
Este código crea una tabla con una clave principal simple ("Name").
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTable.java) en GitHub.
### Creación de una tabla con una clave primaria compuesta
Añada otro objeto [AttributeDefinition](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeDefinition.html) y [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).
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/CreateTableCompositeKey.java) en GitHub.
## Mostrar tablas
Puede mostrar las tablas de una región determinada llamando al método `listTables` [del cliente de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**nota**
Si la tabla designada no existe para su cuenta y región, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
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;
```
**Código de**
```
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;
}
```
De forma predeterminada, se devuelve un máximo de 100 tablas para cada llamada: utilice el `getLastEvaluatedTableName` en el objeto [ListTablesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/model/ListTablesResult.html) devuelto para obtener la última tabla que se evaluó. Puede utilizar este valor para iniciar la enumeración después del último valor devuelto de la enumeración anterior.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/ListTables.java) en GitHub.
## Describir una tabla (obtener información de ella)
Llame al método `describeTable` del [cliente de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**nota**
Si la tabla designada no existe para su cuenta y región, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DescribeTable.java) en GitHub.
## Modificar (actualizar) una tabla
Puede modificar los valores de desempeño aprovisionado de la tabla en cualquier momento llamando al método `updateTable` del [cliente de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html).
**nota**
Si la tabla designada no existe para su cuenta y región, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.AmazonServiceException;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateTable.java) en GitHub.
## Eliminar una tabla
Llame al método `deleteTable` [del cliente de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) y pase el nombre de la tabla.
**nota**
Si la tabla designada no existe para su cuenta y región, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
```
**Código de**
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
try {
ddb.deleteTable(table_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/DeleteTable.java) en GitHub.
## Más información
+ [Prácticas recomendadas para trabajar con tablas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForTables.html) en la Guía para desarrolladores de Amazon DynamoDB
+ [Trabajar con tablas en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) en la Guía para desarrolladores de Amazon DynamoDB
# Uso de elementos en DynamoDB
En DynamoDB, un elemento es una colección de *atributos*, cada uno de los cuales tiene un *nombre* y un *valor*. Los valores de los atributos pueden ser escalares, conjuntos o tipos de documentos. Para obtener más información, consulte [Reglas de nomenclatura y tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html) en la Guía para desarrolladores de Amazon DynamoDB.
## Recuperar (obtener) un elemento de una tabla
Llame al método `getItem` de AmazonDynamoDB y pase un objeto [GetItemRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemRequest.html) con el nombre de la tabla y el valor de clave principal del elemento que desee. Este método devuelve un objeto [GetItemResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/GetItemResult.html).
Puede utilizar el método `getItem()` del objeto `GetItemResult` para recuperar un [mapa](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) de pares de clave (cadena) y valor ([AttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/AttributeValue.html)) asociados al elemento.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/GetItem.java) en GitHub.
## Añadir un nuevo elemento a una tabla
Cree un [mapa](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) de pares de clave-valor que represente los atributos del elemento. Estos deben incluir valores para los campos de la clave principal de la tabla. Si el elemento identificado por la clave principal ya existe, la solicitud *actualiza* sus campos.
**nota**
Si la tabla designada no existe para su cuenta y región, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/PutItem.java) en GitHub.
## Actualizar un elemento existente en una tabla
Puede actualizar un atributo de un elemento que ya existe en una tabla mediante el método `updateItem` de AmazonDynamoDB, proporcionando el nombre de la tabla, el valor de clave principal y un mapa de los campos que se van a actualizar.
**nota**
Si la tabla designada no existe para su cuenta y región o si el elemento identificado por la clave principal que ha pasado no existe, se produce una excepción [ResourceNotFoundException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/model/ResourceNotFoundException.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UpdateItem.java) en GitHub.
## Uso de la clase DynamoDBMapper
El [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/) proporciona la clase DynamoDBMapper que permite mapear las clases del cliente a las tablas de Amazon DynamoDB. Para utilizar la clase [DynamoDBMapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html), defina la relación entre los elementos de una tabla de DynamoDB y sus instancias de objeto correspondientes en el código mediante anotaciones (como se muestra en el ejemplo de código siguiente). La clase [DynamoDBMapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) permite obtener acceso a las tablas, realizar varias operaciones de creación, lectura, actualización y eliminación (CRUD, Create, Read, Update and Delete) y ejecutar consultas.
**nota**
La clase [DynamoDBMapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) no permite crear, actualizar o eliminar tablas.
**Importaciones**
```
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;
```
**Código de**
En el siguiente ejemplo de código Java se muestra cómo añadir contenido a la tabla *Music (Música)* mediante la clase [DynamoDBMapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) . Después de agregar el contenido a la tabla, observe que se carga un elemento mediante las claves *Partition (Partición)* y *Sort (Ordenar)* . A continuación, se actualiza el elemento *Awards (Premios)* . Para obtener información sobre la creación de la tabla *Música*, consulte [Crear una tabla](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) en la Guía para desarrolladores de Amazon DynamoDB.
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/dynamodb/src/main/java/aws/example/dynamodb/UseDynamoMapping.java) en GitHub.
## Más información
+ [Prácticas recomendadas para el uso de elementos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GuidelinesForItems.html) en la Guía para desarrolladores de Amazon DynamoDB
+ [Uso de elementos DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html) en la Guía para desarrolladores de Amazon DynamoDB
# Amazon EC2 Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación en [Amazon EC2](https://aws.amazon.com/ec2/) mediante AWS SDK para Java.
**Topics**
+ [Tutorial: Inicio de una instancia EC2](how-to-ec2.md)
+ [Uso de roles de IAM para conceder acceso a recursos de Amazon EC2 en AWS](java-dg-roles.md)
+ [Tutorial: Instancias de spot de Amazon EC2](tutorial-spot-instances-java.md)
+ [Tutorial: Administración avanzada de solicitudes de spot de Amazon EC2](tutorial-spot-adv-java.md)
+ [Administración de instancias de Amazon EC2](examples-ec2-instances.md)
+ [Uso de direcciones IP elásticas en Amazon EC2](examples-ec2-elastic-ip.md)
+ [Usar regiones y zonas de disponibilidad](examples-ec2-regions-zones.md)
+ [Uso de pares de claves de Amazon EC2](examples-ec2-key-pairs.md)
+ [Uso de grupos de seguridad en Amazon EC2](examples-ec2-security-groups.md)
# Tutorial: Inicio de una instancia EC2
Este tutorial muestra cómo utilizar AWS SDK para Java para iniciar una instancia EC2.
**Topics**
+ [Requisitos previos](#prerequisitesec2)
+ [Cree un grupo de seguridad de Amazon EC2](create-security-group.md)
+ [Creación de un par de claves](create-key-pair.md)
+ [Ejecutar una instancia de Amazon EC2](run-instance.md)
## Requisitos previos
Antes de empezar, asegúrese de haber creado una Cuenta de AWS y configurado las credenciales AWS. Para obtener más información, consulte [Introducción](getting-started.md).
# Cree un grupo de seguridad de Amazon EC2
## Retirada de EC2-Classic
**aviso**
Vamos a retirar EC2-Classic el 15 de agosto de 2022. Le recomendamos que migre de EC2-Classic a una VPC. Para obtener más información, consulte la entrada del blog [EC2-Classic-Classic Networking is Retiring – Here's How to Prepare](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/).
Cree un *grupo de seguridad*, que funciona como un firewall virtual que controla el tráfico de red de una o varias instancias EC2. De forma predeterminada, Amazon EC2 asocia sus instancias con un grupo de seguridad que no permite el tráfico entrante. Puede crear un grupo de seguridad que permita a sus instancias EC2 aceptar un tráfico determinado. Por ejemplo, si necesita conectarse a una instancia Linux, debe configurar el grupo de seguridad para permitir el tráfico SSH. Puede crear un grupo de seguridad mediante la consola de Amazon EC2 o AWS SDK para Java.
Puede crear un grupo de seguridad para usarlo en EC2-Classic o en EC2-VPC. Para obtener más información sobre EC2-Classic y EC2-VPC, consulte [Plataformas admitidas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
Para obtener más información sobre los grupos de seguridad, con la consola de Amazon EC2, consulte [Grupos de seguridad de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
1. Cree e inicialice una instancia de [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html). Utilice el método [withGroupName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withGroupName-java.lang.String-) para establecer el nombre del grupo de seguridad y el método [withDescription](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html#withDescription-java.lang.String-) para establecer la descripción del grupo de seguridad, tal y como se indica a continuación:
```
CreateSecurityGroupRequest csgr = new CreateSecurityGroupRequest();
csgr.withGroupName("JavaSecurityGroup").withDescription("My security group");
```
El nombre del grupo de seguridad debe ser único dentro de la región de AWS en la que inicializa el cliente de Amazon EC2. Debe utilizar caracteres US-ASCII para el nombre y la descripción del grupo de seguridad.
1. Pase el objeto de la solicitud como un parámetro al método [createSecurityGroup](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createSecurityGroup-com.amazonaws.services.ec2.model.CreateSecurityGroupRequest-). El método devuelve un objeto [CreateSecurityGroupResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupResult.html), de la manera siguiente:
```
CreateSecurityGroupResult createSecurityGroupResult =
amazonEC2Client.createSecurityGroup(csgr);
```
Si intenta crear un grupo de seguridad con el mismo nombre que un grupo de seguridad existente, se produce una excepción `createSecurityGroup`.
De forma predeterminada, un nuevo grupo de seguridad no permite el tráfico entrante a su instancia Amazon EC2. Para permitir el tráfico entrante, debe autorizarlo de forma explícita en el grupo de seguridad. Puede autorizar el tráfico entrante para direcciones IP individuales, para un intervalo de direcciones IP, para un protocolo específico y para puertos TCP/UDP.
1. Cree e inicialice una instancia de [IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html). Utilice el método [withIpv4Ranges](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpv4Ranges-java.util.Collection-) para definir el intervalo de direcciones IP para el que se autoriza el tráfico entrante y use el método [withIpProtocol](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withIpProtocol-java.lang.String-) para definir el protocolo IP. Utilice los métodos [withFromPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withFromPort-java.lang.Integer-) y [withToPort](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html#withToPort-java.lang.Integer-) para especificar el intervalo de puertos para los que se autoriza el tráfico entrante, como se indica a continuación:
```
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);
```
Todas las condiciones que especifique en el objeto `IpPermission` se deben cumplir para permitir el tráfico entrante.
Especifique la dirección IP con la notación CIDR. Si especifica el protocolo como TCP/UDP, debe proporcionar un puerto de origen y un puerto de destino. Solo puede autorizar puertos si especifica TCP o UDP.
1. Cree e inicialice una instancia de [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html). Utilice el método `withGroupName` para especificar el nombre del grupo de seguridad y pase el objeto `IpPermission` que inicializó anteriormente al método [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…-), como se indica a continuación:
```
AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest =
new AuthorizeSecurityGroupIngressRequest();
authorizeSecurityGroupIngressRequest.withGroupName("JavaSecurityGroup")
.withIpPermissions(ipPermission);
```
1. Pase el objeto de la solicitud al método [authorizeSecurityGroupIngress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#authorizeSecurityGroupIngress-com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest-), de la siguiente manera:
```
amazonEC2Client.authorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);
```
Si llama a `authorizeSecurityGroupIngress` con direcciones IP para las que ya se ha autorizado el tráfico entrante, el método produce una excepción. Cree y inicialice un nuevo objeto `IpPermission` para autorizar el tráfico entrante para diferentes direcciones IP, puertos y protocolos antes de llamar a `AuthorizeSecurityGroupIngress`.
Siempre que llama a los métodos [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-), se añade una regla al grupo de seguridad.
# Creación de un par de claves
Al conectarse a la instancia, debe especificar un par de claves al lanzar una instancia EC2 y la clave privada del par de claves. Puede crear un par de claves o usar un par de claves existente que haya utilizado al lanzar otras instancias. Para obtener más información, consulte [Pares de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
1. Cree e inicialice una instancia de [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html). Utilice el método [withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html#withKeyName-java.lang.String-) para definir el nombre del par de claves, tal y como se indica a continuación:
```
CreateKeyPairRequest createKeyPairRequest = new CreateKeyPairRequest();
createKeyPairRequest.withKeyName(keyName);
```
**importante**
Los nombres de pares de claves deben ser únicos. Si intenta crear un par de claves con el mismo nombre de clave que un par de claves existente, se producirá una excepción.
1. Pase el objeto de solicitud al método [createKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2.html#createKeyPair-com.amazonaws.services.ec2.model.CreateKeyPairRequest--). El método devuelve una instancia de [CreateKeyPairResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html), de la manera siguiente:
```
CreateKeyPairResult createKeyPairResult =
amazonEC2Client.createKeyPair(createKeyPairRequest);
```
1. Llame al método [getKeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairResult.html#getKeyPair--) del objeto resultante para obtener un objeto [KeyPair](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html). Llame al método [getKeyMaterial](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPair.html#getKeyMaterial--) del objeto `KeyPair` para obtener la clave privada codificada en PEM descifrada, como se indica a continuación:
```
KeyPair keyPair = new KeyPair();
keyPair = createKeyPairResult.getKeyPair();
String privateKey = keyPair.getKeyMaterial();
```
# Ejecutar una instancia de Amazon EC2
Use el siguiente procedimiento para lanzar una o más instancias EC2 con la misma configuración de la misma Imagen de máquina de Amazon (AMI). Después de crear las instancias EC2, puede comprobar sus estados. Una vez que las instancias EC2 se están ejecutando, puede conectarse a ellas.
1. Cree e inicialice una instancia de [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html). Asegúrese de que la AMI, el par de claves y el grupo de seguridad que especifique existen en la región indicada al crear el objeto de cliente.
```
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-)
+ Es el ID de la AMI. Para obtener más información sobre cómo buscar una AMI pública proporcionada por Amazon o crear la suya, consulte [Imagen de máquina de Amazon (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-)
+ Se trata de un tipo de instancia que es compatible con la AMI especificada. Para obtener más información, consulte [Tipos de instancias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
[withMinCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMinCount-java.lang.Integer-)
+ Se trata del número mínimo de instancias EC2 que se van a lanzar. Si hay más instancias de las que Amazon EC2 puede lanzar en la zona de disponibilidad de destino, Amazon EC2 no lanzará ninguna instancia.
[withMaxCount](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withMaxCount-java.lang.Integer-)
+ Se trata del número máximo de instancias EC2 que se van a lanzar. Si hay más instancias de las que Amazon EC2 puede lanzar en la zona de disponibilidad de destino, Amazon EC2 lanzará el mayor número posible de instancias por encima del `MinCount`. Puede lanzar entre una y el número máximo de instancias permitido para el tipo de instancia. Para obtener más información, consulte ¿Cuántas instancias puedo ejecutar en Amazon EC2? en las preguntas frecuentes de Amazon EC2.
[withKeyName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html#withKeyName-java.lang.String-)
+ Se trata del nombre del par de claves de EC2. Si lanza una instancia sin especificar un par de claves, no podrá conectarse a ella. Para obtener más información, consulte la sección [Crear un par de claves](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 varios grupos de seguridad. Para obtener más información, consulte [Crear de un grupo de seguridad de Amazon EC2](create-security-group.md).
1. Lance las instancias pasando el objeto solicitado al método [runInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#runInstances-com.amazonaws.services.ec2.model.RunInstancesRequest-). El método devuelve un objeto [RunInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesResult.html), de la manera siguiente:
```
RunInstancesResult result = amazonEC2Client.runInstances(
runInstancesRequest);
```
Una vez ejecutada la instancia, puede conectarse a ella usando el par de claves. Para obtener más información, consulte [Conexión con su instancia de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
# Uso de roles de IAM para conceder acceso a recursos de Amazon EC2 en AWS
Todas las solicitudes a Amazon Web Services (AWS) deben firmarse criptográficamente mediante credenciales emitidas por AWS. Puede utilizar *roles de IAM* como un método sencillo para conceder acceso seguro a los recursos de AWS desde sus instancias de Amazon EC2.
En este tema se proporciona información acerca de cómo utilizar los roles de con aplicaciones del SDK de Java que se ejecutan en Amazon EC2. Para obtener más información sobre los roles de IAM consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
## Cadena predeterminada de proveedores y perfiles de instancias EC2
Si su aplicación crea un cliente de AWS utilizando el constructor predeterminado, el cliente buscará las credenciales mediante la *cadena predeterminada de proveedores de credenciales*, en el orden siguiente:
1. En las propiedades del sistema Java: `aws.accessKeyId` y `aws.secretKey`.
1. En las variables de entorno del sistema: `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY`.
1. En el archivo de credenciales (la ubicación de este archivo varía en función de la plataforma).
1. Las credenciales entregadas a través del servicio de contenedor de Amazon EC2 si se establece la variable de entorno `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` y el administrador de seguridad tiene permiso para acceder a la variable.
1. En las *credenciales del perfil de la instancia*, que residen en los metadatos de la instancia asociadas con la función de IAM para la instancia EC2.
1. Credenciales de Web Identity Token del entorno o contenedor.
El paso *credenciales del perfil de la instancia* en la cadena predeterminada de proveedores solo está disponible cuando la aplicación se ejecuta en una instancia Amazon EC2, pero es el método más sencillo y más seguro cuando se trabaja con instancias Amazon EC2. También puede pasar una instancia de [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html) directamente al constructor del cliente para obtener las credenciales del perfil de la instancia sin recorrer toda la cadena predeterminada de proveedores.
Por ejemplo:
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new InstanceProfileCredentialsProvider(false))
.build();
```
Cuando se utiliza este enfoque, el SDK recupera las credenciales temporales de AWS que tienen los mismos permisos que los asociados al rol de IAM asociado a la instancia Amazon EC2 en su perfil de instancia. Aunque estas credenciales son temporales y acaban caducando, `InstanceProfileCredentialsProvider` las actualiza periódicamente para que sigan permitiendo el acceso a AWS.
**importante**
La actualización automática de las credenciales *solo* se realiza cuando utiliza el constructor del cliente predeterminado, que crea su propio `InstanceProfileCredentialsProvider` como parte de la cadena predeterminada de proveedores, o cuando pasa una instancia de `InstanceProfileCredentialsProvider` directamente al constructor del cliente. Si utiliza otro método para obtener o pasar credenciales del perfil de la instancia, usted es responsable de comprobar y actualizar las credenciales que hayan caducado.
Si el constructor del cliente no encuentra las credenciales con la cadena de proveedores de credenciales, produce una excepción [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html).
## Tutorial: Uso de roles de IAM para instancias EC2
El siguiente tutorial muestra cómo recuperar un objeto de Amazon S3 mediante un rol de IAM para administrar el acceso.
### Creación de un rol de IAM
Cree un rol de IAM que conceda acceso de solo lectura a Amazon S3.
1. Abra la [consola de IAM](https://console.aws.amazon.com/iam/home).
1. En el panel de navegación, seleccione **Roles** y después **Create New Role (Crear nuevo rol)**.
1. Escriba un nombre para la función y, a continuación, seleccione **Next Step (Paso siguiente)**. Recuerde este nombre, ya que lo necesitará cuando lance su instancia Amazon EC2.
1. En la página **Seleccionar tipo de rol**, en **Roles de Servicio de AWS**, seleccione **Amazon EC2**.
1. En la página **Definir permisos**, bajo **Seleccionar plantilla de política**, seleccione **Acceso de solo lectura de Amazon S3** y después **Siguiente paso**.
1. En la página **Review (Revisar)**, seleccione **Create Role (Crear rol)**.
### Lanzar una instancia EC2 y especificar el rol de IAM
Puede lanzar una instancia de Amazon EC2 con un rol de IAM mediante la consola de Amazon EC2 o el AWS SDK para Java.
+ Para lanzar una instancia de Amazon EC2 mediante la consola, siga las instrucciones de [Introducción a las instancias de Linux de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) en la Guía del usuario de instancias de Linux.
Cuando llegue a la página **Revisar lanzamiento de instancia**, seleccione **Editar detalles de la instancia**. En **Rol de IAM**, elija el rol de IAM que creó anteriormente. Complete el procedimiento siguiendo las instrucciones.
**nota**
Deberá crear o usar un grupo de seguridad y un par de claves existentes para conectarse a la instancia.
+ Para lanzar una instancia de Amazon EC2 con un rol de IAM mediante el AWS SDK para Java, consulte Amazon EC2Ejecución de una instancia de .
### Creación de una aplicación
Vamos a compilar la aplicación de ejemplo para que se ejecute en la instancia EC2. En primer lugar, cree el directorio que va a usar para almacenar los archivos del tutorial (por ejemplo, `GetS3ObjectApp`).
A continuación, copie las bibliotecas de AWS SDK para Java en el directorio recién creado. Si ha descargado AWS SDK para Java en su directorio `~/Downloads`, puede copiarlos utilizando los siguientes comandos:
```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```
Abra un nuevo archivo, llámelo `GetS3Object.java`y añada el siguiente código:
```
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();
}
}
```
Abra un nuevo archivo, llámelo `build.xml`y añada las líneas siguientes:
```
```
Compile y ejecute el programa modificado. Tenga en cuenta que no hay credenciales almacenadas en el programa. Por lo tanto, a menos que ya haya especificado las credenciales de AWS, el código producirá una `AmazonServiceException`. Por ejemplo:
```
$ 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
```
### Transferir el programa compilado a la instancia EC2
Transfiera el programa a su instancia Amazon EC2 mediante la copia segura (** `` **), junto con las bibliotecas de AWS SDK para Java. La secuencia de comandos debe ser similar a la siguiente.
```
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**
En función de la distribución Linux que haya utilizado, el *nombre de usuario* podría ser "ec2-user", "root" o "ubuntu". Para obtener el nombre DNS público de la instancia, abra la [consola de EC2](https://console.aws.amazon.com/ec2/home) y busque el valor de **Public DNS (DNS público)** en la pestaña **Description (Descripción)** (por ejemplo, `ec2-198-51-100-1.compute-1.amazonaws.com`).
En los comandos anteriores:
+ `GetS3Object.class` es el programa compilado
+ `build.xml` es el archivo ant que se utiliza para compilar y ejecutar el programa
+ los directorios `lib` y `third-party` son las carpetas de las bibliotecas de AWS SDK para Java correspondientes.
+ El modificador `-r` indica que `scp` debe realizar una copia recursiva de todo el contenido de los directorios `library` y `third-party` en la distribución de AWS SDK para Java.
+ El modificador `-p` indica que `scp` deben conservar los permisos de los archivos de código fuente cuando se copien en el destino.
**nota**
El conmutador `-p` solo funciona en Linux, macOS o Unix. Si va a copiar archivos de Windows, es posible que tenga que corregir los permisos del archivo en su instancia mediante el siguiente comando:
```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```
### Ejecutar el programa de ejemplo en la instancia EC2
Para ejecutar el programa, conéctese a la instancia Amazon EC2. Para obtener más información, consulte [Conexión con su instancia de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
Si ** ` ant ` ** no está disponible en la instancia, instálelo con el siguiente comando:
```
sudo yum install ant
```
A continuación, ejecute el programa mediante `ant` del siguiente modo:
```
ant run
```
El programa escribirá el contenido del objeto de Amazon S3 en la ventana de comandos.
# Tutorial: Instancias de spot de Amazon EC2
## Descripción general
Las instancias de spot permiten pujar por capacidad de Amazon Elastic Compute Cloud (Amazon EC2) sin utilizar hasta el 90 % frente al precio de instancia bajo demanda y ejecutar las instancias adquiridas, siempre y cuando su puja sea superior al *precio de spot* actual. Amazon EC2 cambia periódicamente el precio de spot en función de la oferta y la demanda; los clientes cuyas pujas igualen o superen este precio tendrán acceso a las instancias de spot disponibles. Al igual que las instancias bajo demanda y las instancias reservadas, las instancias de spot proporcionan otra opción para obtener una mayor capacidad de cómputo.
Las instancias de spot pueden reducir de forma significativa los costos de Amazon EC2 del procesamiento por lotes, la investigación científica, el procesamiento de imágenes, la codificación de vídeo, el rastreo web y de datos, el análisis financiero y la realización de pruebas. Además, las instancias de spot le permiten obtener acceso a una gran cantidad de capacidad adicional en aquellas situaciones en las que la necesidad de esa capacidad no es urgente.
Para usar instancias de spot, coloque una solicitud de instancia de spot que especifique el precio máximo que está dispuesto a pagar por hora de instancia; esta es su puja. Si el importe de su puja es mayor que el precio de spot actual, se atenderá su solicitud y sus instancias se ejecutarán hasta que decida terminarlas o hasta que el precio de spot sea mayor que su puja (lo que suceda antes).
Es importante tener en cuenta lo siguiente:
+ Con frecuencia pagará por hora un importe inferior al de su puja. Amazon EC2 ajusta el precio de spot periódicamente a medida que llegan las solicitudes y que cambia la oferta disponible. Todo el mundo paga el mismo precio de spot para ese período independientemente de que su puja fuera más alta. Por lo tanto, puede pagar un importe inferior al de su puja, pero nunca pagará un importe superior al de esta.
+ Si ejecuta instancias de spot y su puja ya no coincide con el precio de spot actual ni lo supera, se terminarán sus instancias. Esto significa que querrá asegurarse de que sus cargas de trabajo y aplicaciones son lo suficientemente flexibles para aprovechar esta oportunista capacidad.
Las instancias de spot funcionan exactamente igual que otras instancias Amazon EC2 mientras se ejecutan y, al igual que otras instancias Amazon EC2, se pueden terminar cuando ya no las necesita. Si termina su instancia, pagará por las horas parciales empleadas (como lo haría en el caso de las instancias bajo demanda o reservadas). Sin embargo, si el precio de spot es superior al importe de su puja y Amazon EC2 termina su instancia, no se le cobrará por las horas de uso parciales.
Este tutorial muestra cómo utilizar AWS SDK para Java para realizar las siguientes tareas.
+ Enviar una solicitud de spot
+ Determinar cuándo se atiende la solicitud de spot
+ Cancelar la solicitud de spot
+ Terminar las instancias asociadas
## Requisitos previos
Para utilizar este tutorial, debe tener AWS SDK para Java instalado, así como los requisitos previos de instalación básicos. Para obtener más información, consulte [Configuración de AWS SDK para Java](setup-install.md).
## Paso 1: Configuración de las credenciales
Para empezar a usar este ejemplo de código, debe configurar las credenciales de AWS. Consulte [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md) para ver instrucciones sobre cómo hacerlo.
**nota**
Le recomendamos que utilice las credenciales de un usuario de IAM para proporcionar estos valores. Para obtener más información, consulte [Inscripción en AWS y creación de un usuario de IAM](signup-create-iam-user.md).
Ahora que ha configurado sus opciones, puede empezar a utilizar el código del ejemplo.
## Paso 2: Configuración de un grupo de seguridad
Un *grupo de seguridad* funciona como un firewall que controla el tráfico permitido de entrada y salida de un grupo de instancias. De forma predeterminada, una instancia se inicia sin ningún grupo de seguridad, lo que significa que se denegará todo el tráfico IP entrante, en cualquier puerto TCP. Por lo tanto, antes de enviar una solicitud de spot, vamos a configurar un grupo de seguridad que permita el tráfico de red necesario. A efectos de este tutorial, vamos a crear un nuevo grupo de seguridad llamado "GettingStarted" que permita el tráfico Secure Shell (SSH) desde la dirección IP en la que se ejecuta su aplicación. Para configurar un nuevo grupo de seguridad, debe incluir o ejecutar el siguiente ejemplo de código, que configura el grupo de seguridad mediante programación.
Después, creamos un objeto cliente `AmazonEC2` y un objeto `CreateSecurityGroupRequest` con el nombre, "GettingStarted" y una descripción para el grupo de seguridad. A continuación, llamamos a la API `ec2.createSecurityGroup` para crear el grupo.
Para habilitar el acceso al grupo, creamos un objeto `ipPermission` con el intervalo de direcciones IP establecido en la representación CIDR de la subred del equipo local; el sufijo "/10" en la dirección IP indica la subred de la dirección IP especificada. También configuramos el objeto `ipPermission` con el protocolo TCP y el puerto 22 (SSH). El último paso consiste en llamar a `ec2.authorizeSecurityGroupIngress` con el nombre de nuestro grupo de seguridad y el objeto `ipPermission`.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Create a new security group.
try {
CreateSecurityGroupRequest securityGroupRequest = new CreateSecurityGroupRequest("GettingStartedGroup", "Getting Started Security Group");
ec2.createSecurityGroup(securityGroupRequest);
} catch (AmazonServiceException ase) {
// Likely this means that the group is already created, so ignore.
System.out.println(ase.getMessage());
}
String ipAddr = "0.0.0.0/0";
// Get the IP of the current host, so that we can limit the Security
// Group by default to the ip range associated with your subnet.
try {
InetAddress addr = InetAddress.getLocalHost();
// Get IP Address
ipAddr = addr.getHostAddress()+"/10";
} catch (UnknownHostException e) {
}
// Create a range that you would like to populate.
ArrayList ipRanges = new ArrayList();
ipRanges.add(ipAddr);
// Open up port 22 for TCP traffic to the associated IP
// from above (e.g. ssh traffic).
ArrayList ipPermissions = new ArrayList ();
IpPermission ipPermission = new IpPermission();
ipPermission.setIpProtocol("tcp");
ipPermission.setFromPort(new Integer(22));
ipPermission.setToPort(new Integer(22));
ipPermission.setIpRanges(ipRanges);
ipPermissions.add(ipPermission);
try {
// Authorize the ports to the used.
AuthorizeSecurityGroupIngressRequest ingressRequest =
new AuthorizeSecurityGroupIngressRequest("GettingStartedGroup",ipPermissions);
ec2.authorizeSecurityGroupIngress(ingressRequest);
} catch (AmazonServiceException ase) {
// Ignore because this likely means the zone has
// already been authorized.
System.out.println(ase.getMessage());
}
```
Tenga en cuenta que solo necesita ejecutar esta aplicación una vez para crear un nuevo grupo de seguridad.
También puede crear el grupo de seguridad mediante AWS Toolkit for Eclipse. Consulte [Administración de grupos de seguridad desde AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) para obtener más información.
## Paso 3: Envío de la solicitud de spot
Para enviar una solicitud de spot, primero es necesario determinar el tipo de instancia, la imagen de máquina de Amazon (AMI) y el precio de puja máximo que desea usar. También debe incluir el grupo de seguridad que hemos configurado anteriormente, de modo que pueda iniciar sesión en la instancia si lo desea.
Hay varios tipos de instancia para elegir; vaya a Tipos de instancias Amazon EC2 para obtener una lista completa. En este tutorial, utilizaremos t1.micro, el tipo de instancia más económica disponible. A continuación, determinaremos el tipo de AMI que desea utilizar. Utilizaremos ami-a9d09ed1, la AMI de Amazon Linux más actualizada disponible cuando escribimos este tutorial. La AMI más reciente puede cambiar con el tiempo, pero siempre puede determinar la última versión de la AMI siguiendo estos pasos:
1. Abra la [consola de Amazon EC2](https://console.aws.amazon.com/ec2/home).
1. Elija el botón **Launch Instance (Lanzar instancia)**.
1. La primera ventana muestra las AMI disponibles. El ID de AMI aparece al lado del título de cada AMI. También puede utilizar la API `DescribeImages`, pero el uso de este comando queda fuera del alcance de este tutorial.
Existen muchas formas de pujar por instancias de spot; para obtener una descripción general de los diferentes enfoques, vea el vídeo [Bidding for Spot Instances](https://www.youtube.com/watch?v=WD9N73F3Fao&feature=player_embedded). Sin embargo, para comenzar, describiremos tres estrategias comunes: pujar para garantizar que el costo sea menor que el precio bajo demanda, pujar en función del valor de la computación resultante y pujar con el fin de adquirir capacidad de computación con la mayor rapidez posible.
+ *Reducir el costo por debajo del precio bajo demanda* Tiene una tarea de procesamiento por lotes que tardará en ejecutarse una cantidad determinada de horas o días. Sin embargo, es flexible con respecto a cuándo comienza y finaliza. Desea ver si puede completarla por menos del valor del costo de las instancias bajo demanda. Puede examinar el historial de precios de subasta para tipos de instancia mediante la Consola de administración de AWS o la API de Amazon EC2. Para obtener más información, consulte [Historial de precios de instancias de spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html). Una vez que haya analizado el historial de precios para su tipo de instancia deseado en una zona de disponibilidad especificada, tendrá dos enfoques alternativos para su puja:
+ Podría pujar en el extremo superior del rango de precios de spot (que aún son inferiores al precio bajo demanda), contando con que lo más probable es que su solicitud de spot puntual se atienda y se ejecute durante un tiempo de computación consecutivo suficiente para completar la tarea.
+ O bien, puede especificar la cantidad que está dispuesto a pagar por las instancias de spot como un porcentaje del precio de la instancia bajo demanda, así como combinar muchas instancias lanzadas a lo largo del tiempo a través de una solicitud persistente. Si se supera el precio especificado, la instancia de spot terminará. (Explicaremos cómo automatizar esta tarea más adelante en este tutorial).
+ *No pagar un importe superior al valor del resultado* Tiene una tarea de procesamiento de datos que ejecutar. Conoce las ventajas de los resultados de la tarea lo suficientemente bien como para saber lo valiosos que son en términos de costos de computación. Una vez que haya analizado el historial de precios de spot para el tipo de instancia, podrá elegir un precio de puja en el que el costo del tiempo de computación no sea superior al valor de los resultados de la tarea. Puede crear una puja persistente y permitir su ejecución intermitente a medida que el precio de spot fluctúa en torno a su puja o por debajo de esta.
+ *Adquirir capacidad de computación rápidamente* Tiene una necesidad a corto plazo no anticipada de capacidad adicional que no está disponible a través de las instancias bajo demanda. Una vez que haya analizado el historial de precios de spot para el tipo de instancia, podrá pujar por encima del precio histórico más alto para tener mayores probabilidades de que su solicitud se atienda con rapidez y continúe computándose hasta completarse.
Una vez que haya elegido el precio de puja, estará listo para solicitar una instancia de spot. Para los fines de este tutorial, pujaremos por el precio bajo demanda (0,03 USD) para maximizar las posibilidades de que se atienda la puja. Puede determinar los tipos de instancias disponibles y los precios bajo demanda para instancias yendo a la página de precios de Amazon EC2. Cuando una instancia de spot está en ejecución, paga el precio de spot vigente durante el período de tiempo en que se ejecutan las instancias. Amazon EC2 define los precios de las instancias de spot y estos se ajustan gradualmente en función de las tendencias a largo plazo de la oferta y la demanda de capacidad de este tipo de instancia. También puede especificar el importe que está dispuesto a pagar por una instancia de spot como porcentaje del precio de la instancia bajo demanda. Para solicitar una instancia de spot, solo tiene que crear su solicitud con los parámetros que eligió anteriormente. Comencemos creando un objeto `RequestSpotInstanceRequest`. El objeto de la solicitud requiere el número de instancias que desea para comenzar y el precio de puja. Además, necesita establecer `LaunchSpecification` para la solicitud, que incluye el tipo de instancia, el ID de la AMI y el grupo de seguridad que desea utilizar. Una vez rellenada la solicitud, llama al método `requestSpotInstances` en el objeto `AmazonEC2Client`. En el siguiente ejemplo se muestra cómo solicitar una instancia de 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);
```
Al ejecutarse este código se lanzará una nueva solicitud de instancia de spot. Hay otras opciones que puede usar para configurar las solicitudes de spot. Para obtener más información, consulte [Tutorial: Administración avanzada de solicitudes de spot de Amazon EC2](tutorial-spot-adv-java.md) o la clase [RequestSpotInstances](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesRequest.html) en la Referencia de la API de AWS SDK para Java.
**nota**
Se le cobrará por las instancias de spot que se de verdad se lancen, de modo que asegúrese de cancelar cualquier solicitud y terminar las instancias que lance para reducir las tarifas asociadas.
## Paso 4: Determinación del estado de la solicitud de spot
A continuación, queremos crear código para esperar hasta que la solicitud de spot alcance el estado "activo" antes de continuar con el último paso. Para determinar el estado de nuestra solicitud de spot, usamos el método [describeSpotInstanceRequests](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/AmazonEC2Client.html#describeSpotInstanceRequests) para obtener el estado del ID de solicitud de spot que deseamos monitorizar.
El ID de solicitud creado en el paso 2 se inserta en la respuesta a nuestra solicitud `requestSpotInstances`. El siguiente ejemplo muestra cómo obtener los ID de solicitud de la respuesta `requestSpotInstances` y utilizarlos para rellenar una `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());
}
```
Para monitorizar su ID de solicitud, llame al método `describeSpotInstanceRequests` para determinar el estado de la solicitud. A continuación, recorra en bucle la solicitud hasta que deje de tener el estado "abierto". Tenga en cuenta que buscamos un estado distinto de "abierto" en lugar de, por ejemplo, un estado "activo", porque la solicitud podría pasar directamente al estado "cerrado" si surgiera algún problema con los argumentos de la solicitud. El siguiente ejemplo de código proporciona los detalles de cómo realizar esta tarea.
```
// 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);
```
Después de ejecutar este código, su solicitud de instancia de spot se habrá completado o habrá producido un error que se mostrará en la pantalla. En cualquier caso, podemos continuar con el siguiente paso para limpiar todas las solicitudes activas y terminar todas las instancias en ejecución.
## Paso 5: Limpieza de las instancias y solicitudes de spot
Por último, tenemos que limpiar nuestras solicitudes e instancias. Esto es importante tanto para cancelar cualquier solicitud pendiente *como* para terminar cualquier instancia. Las instancias no terminarán con solo cancelarse las solicitudes, lo que significa que se le seguirá cobrando por ellas. Si termina las instancias, es posible que se cancelen las solicitudes de spot, pero hay algunos escenarios (por ejemplo, si usa pujas persistentes), donde terminar las instancias no es suficiente para evitar que la solicitud vuelva a atenderse. Por lo tanto, se recomienda tanto cancelar cualquier puja activa como terminar cualquier instancia en ejecución.
En el siguiente código se muestra cómo cancelar las solicitudes.
```
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());
}
```
Para terminar todas las instancias pendientes, necesitará el ID de la instancia asociada a la solicitud que las inició. El siguiente ejemplo se basa en el código original de monitorización de instancias en el que se ha añadido una `ArrayList` en la que almacenamos los ID de instancia asociados a la respuesta `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);
```
Usando los ID de instancia almacenados en `ArrayList`, termine todas las instancias en ejecución con el siguiente fragmento de código.
```
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());
}
```
## Operación conjunta
Para realizar todas estas operaciones a la vez, ofrecemos un enfoque más orientado a objetos, que combina los pasos mostrados: inicializar el cliente de EC2, enviar la solicitud de spot, determinar el momento en el que las solicitudes de spot ya no tienen el estado abierto y limpiar todas las solicitudes de spot pendientes y las instancias asociadas. Creamos una clase llamada `Requests` que realiza estas acciones.
También creamos una clase `GettingStartedApp`, que tiene un método principal donde realizamos las llamadas a funciones de alto nivel. En concreto, inicializamos el objeto `Requests` descrito anteriormente. Enviamos la solicitud de instancia de spot. A continuación, esperamos a que la solicitud de spot alcance el estado "activo". Por último, limpiamos las solicitudes y las instancias.
El código fuente completo de este ejemplo se puede consultar o descargar en [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-GettingStarted).
¡Enhorabuena\$1 Ha completado el tutorial de introducción al desarrollo de software de instancias de spot con AWS SDK para Java.
## Siguientes pasos
Continúe con el [Tutorial: Administración avanzada de solicitudes de spot de Amazon EC2](tutorial-spot-adv-java.md).
# Tutorial: Administración avanzada de solicitudes de spot de Amazon EC2
Las instancias de spot de Amazon EC2 le permiten pujar por capacidad de Amazon EC2 sin usar y ejecutar esas instancias mientras su puja supere el *precio de spot* actual. Amazon EC2 cambia el precio de spot periódicamente en función de la oferta y la demanda. Para más información acerca de las instancias de spot, consulte [Instancias de spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
## Requisitos previos
Para utilizar este tutorial, debe tener AWS SDK para Java instalado, así como los requisitos previos de instalación básicos. Para obtener más información, consulte [Configuración de AWS SDK para Java](setup-install.md).
## Configuración de las credenciales
Para empezar a usar este ejemplo de código, debe configurar las credenciales de AWS. Consulte [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md) para ver instrucciones sobre cómo hacerlo.
**nota**
Le recomendamos que utilice las credenciales de un usuario de IAM para proporcionar estos valores. Para obtener más información, consulte [Inscripción en AWS y creación de un usuario de IAM](signup-create-iam-user.md).
Ahora que ha configurado sus opciones, puede empezar a utilizar el código del ejemplo.
## Configuración de un grupo de seguridad
Un grupo de seguridad funciona como un firewall que controla el tráfico permitido de entrada y salida de un grupo de instancias. De forma predeterminada, una instancia se inicia sin ningún grupo de seguridad, lo que significa que se denegará todo el tráfico IP entrante, en cualquier puerto TCP. Por lo tanto, antes de enviar una solicitud de spot, vamos a configurar un grupo de seguridad que permita el tráfico de red necesario. A efectos de este tutorial, vamos a crear un nuevo grupo de seguridad llamado "GettingStarted" que permita el tráfico Secure Shell (SSH) desde la dirección IP en la que se ejecuta su aplicación. Para configurar un nuevo grupo de seguridad, debe incluir o ejecutar el siguiente ejemplo de código, que configura el grupo de seguridad mediante programación.
Después, creamos un objeto cliente `AmazonEC2` y un objeto `CreateSecurityGroupRequest` con el nombre, "GettingStarted" y una descripción para el grupo de seguridad. A continuación, llamamos a la API `ec2.createSecurityGroup` para crear el grupo.
Para habilitar el acceso al grupo, creamos un objeto `ipPermission` con el intervalo de direcciones IP establecido en la representación CIDR de la subred del equipo local; el sufijo "/10" en la dirección IP indica la subred de la dirección IP especificada. También configuramos el objeto `ipPermission` con el protocolo TCP y el puerto 22 (SSH). El último paso consiste en llamar a `ec2 .authorizeSecurityGroupIngress` con el nombre de nuestro grupo de seguridad y el objeto `ipPermission`.
(El siguiente código es el mismo que el que usamos en el primer 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());
}
```
Puede ver este ejemplo de código completo en el ejemplo de código `advanced.CreateSecurityGroupApp.java`. Tenga en cuenta que solo necesita ejecutar esta aplicación una vez para crear un nuevo grupo de seguridad.
**nota**
También puede crear el grupo de seguridad mediante AWS Toolkit for Eclipse. Consulte [Administración de grupos de seguridad desde AWS Cost Explorer](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/tke-sg.html) en la Guía del usuario de AWS Toolkit for Eclipse para obtener más información.
## Opciones detalladas de creación de solicitudes de instancias de spot
Como hemos explicado en el Tutorial: Instancias de spot de Amazon EC2, debe crear la solicitud con un tipo de instancia, una Imagen de máquina de Amazon (AMI) y un precio de puja máximo.
Comencemos creando un objeto `RequestSpotInstanceRequest`. El objeto de la solicitud requiere el número de instancias que desee y el precio de puja. Además, necesitamos establecer `LaunchSpecification` para la solicitud, que incluye el tipo de instancia, el ID de la AMI y el grupo de seguridad que desea utilizar. Una vez rellenada la solicitud, llamamos al método `requestSpotInstances` en el objeto `AmazonEC2Client`. A continuación se incluye un ejemplo de cómo solicitar una instancia de spot.
(El siguiente código es el mismo que el que usamos en el primer 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);
```
## Solicitudes persistentes y solicitudes puntuales
Cuando se crea una solicitud de spot, puede especificar varios parámetros opcionales. El primero es si la solicitud es puntual o persistente. De forma predeterminada, es una solicitud puntual. Una solicitud puntual se puede tramitar solo una vez, y una vez que se terminan las instancias solicitadas, la solicitud se cierra. Una solicitud persistente se puede tramitar siempre que no haya ninguna instancia de spot ejecutándose para la misma solicitud. Para especificar el tipo de solicitud, simplemente tiene que establecer el tipo en la solicitud de spot. Esto se puede hacer con el siguiente código.
```
// 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);
```
## Limitación de la duración de una solicitud
De forma opcional, puede especificar el tiempo que su solicitud seguirá estando en vigor. Puede especificar una hora de inicio y finalización para este periodo. De forma predeterminada, una solicitud de spot se puede tramitar desde el momento en que se crea hasta que se tramita o se cancela. Sin embargo, puede restringir el periodo de validez en caso de que sea necesario. En el siguiente código se muestra un ejemplo de cómo especificar este periodo.
```
// 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);
```
## Agrupación de solicitudes de instancias de spot de Amazon EC2
Tiene la opción de agrupar sus solicitudes de instancias de spot de diferentes maneras. Veamos las ventajas de utilizar grupos de lanzamiento, grupos de zonas de disponibilidad y grupos de ubicación.
Si desea garantizar que las instancias de spot se lancen y terminen a la vez, puede usar un grupo de lanzamiento. Un grupo de lanzamiento es una etiqueta que agrupa un conjunto de pujas. Todas las instancias en un grupo de inicialización se inician y se terminan juntas. Tenga en cuenta que si las instancias de un grupo de lanzamiento ya se han tramitado, no hay ninguna garantía de que se tramiten también las nuevas instancias lanzadas con el mismo grupo de lanzamiento. Un ejemplo de cómo configurar un grupo de lanzamiento se muestra en el siguiente ejemplo de código.
```
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 5 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(5));
// Set the launch group.
requestRequest.setLaunchGroup("ADVANCED-DEMO-LAUNCH-GROUP");
// Set up the specifications of the launch. This includes
// the instance type (e.g. t1.micro) and the latest Amazon Linux
// AMI id available. Note, you should always use the latest
// Amazon Linux AMI id or another of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
Si desea asegurarse de que todas las instancias de una solicitud se lancen en la misma zona de disponibilidad y no tener que preocuparse de cuál de ellas se va a lanzar, puede utilizar grupos de zonas de disponibilidad. Un grupo de zonas de disponibilidad es una etiqueta que agrupa un conjunto de instancias de forma conjunta en la misma zona de disponibilidad. Todas las instancias que comparten un grupo de zonas de disponibilidad y que se tramitan al mismo tiempo se iniciarán en la misma zona de disponibilidad. A continuación se incluye un ejemplo de cómo configurar un grupo de zonas de disponibilidad.
```
// 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);
```
Puede especificar la zona de disponibilidad que desee para sus instancias de spot. El siguiente ejemplo de código muestra cómo definir una zona de disponibilidad.
```
// 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);
```
Por último, puede especificar un *grupo de ubicación* si utiliza instancias de spot de informática de alto rendimiento (HPC), como instancias de informática en clúster o instancias de GPU de clúster. Los grupos de ubicación ofrecen baja latencia y conectividad de alto ancho de banda entre las instancias. A continuación se incluye un ejemplo de cómo configurar un grupo de ubicación.
```
// 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);
```
Todos los parámetros que se muestran en esta sección son opcionales. También es importante tener en cuenta que la mayoría de estos parámetros, con la excepción de si su puja es puntual o persistente, pueden reducir la probabilidad de que se atienda su puja. Por lo tanto, es importante que utilice estas opciones solo si las necesita. Todos los ejemplos de código anteriores se combinan en un único ejemplo de código mayor, que se puede encontrar en la clase `com.amazonaws.codesamples.advanced.InlineGettingStartedCodeSampleApp.java`.
## Cómo conservar una partición raíz después de una interrupción o terminación
Una de las formas más sencillas de administrar la interrupción de sus instancias de spot es garantizar que sus datos se someten comprobación en un volumen de Amazon Elastic Block Store (Amazon Amazon EBS) a un ritmo regular. Mediante la creación de puntos de comprobación de forma periódica, si hay una interrupción, solo perderá los datos creados desde el último punto de comprobación (suponiendo que no se realicen otras acciones no idempotentes entre medias). Para simplificar ese proceso, puede configurar la solicitud de spot para garantizar que la partición raíz no se elimine debido a una interrupción o terminación. Hemos introducido nuevo código en el siguiente ejemplo que muestra cómo permitir este escenario.
En el código añadido, creamos un objeto `BlockDeviceMapping` y establecemos su Amazon Elastic Block Store (Amazon EBS) en un objeto de Amazon EBS que hemos configurado como para que `not` se elimine si la instancia de spot termina. A continuación, añadimos este `BlockDeviceMapping` al ArrayList de asignaciones que incluimos en la especificación de lanzamiento.
```
// Retrieves the credentials from an AWSCredentials.properties file.
AWSCredentials credentials = null;
try {
credentials = new PropertiesCredentials(
GettingStartedApp.class.getResourceAsStream("AwsCredentials.properties"));
}
catch (IOException e1) {
System.out.println(
"Credentials were not properly entered into AwsCredentials.properties.");
System.out.println(e1.getMessage());
System.exit(-1);
}
// Create the AmazonEC2 client so we can call various APIs.
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
// Initializes a Spot Instance Request
RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
// Request 1 x t1.micro instance with a bid price of $0.03.
requestRequest.setSpotPrice("0.03");
requestRequest.setInstanceCount(Integer.valueOf(1));
// Set up the specifications of the launch. This includes the instance
// type (e.g. t1.micro) and the latest Amazon Linux AMI id available.
// Note, you should always use the latest Amazon Linux AMI id or another
// of your choosing.
LaunchSpecification launchSpecification = new LaunchSpecification();
launchSpecification.setImageId("ami-a9d09ed1");
launchSpecification.setInstanceType(InstanceType.T1Micro);
// Add the security group to the request.
ArrayList securityGroups = new ArrayList();
securityGroups.add("GettingStartedGroup");
launchSpecification.setSecurityGroups(securityGroups);
// Create the block device mapping to describe the root partition.
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping();
blockDeviceMapping.setDeviceName("/dev/sda1");
// Set the delete on termination flag to false.
EbsBlockDevice ebs = new EbsBlockDevice();
ebs.setDeleteOnTermination(Boolean.FALSE);
blockDeviceMapping.setEbs(ebs);
// Add the block device mapping to the block list.
ArrayList blockList = new ArrayList();
blockList.add(blockDeviceMapping);
// Set the block device mapping configuration in the launch specifications.
launchSpecification.setBlockDeviceMappings(blockList);
// Add the launch specification.
requestRequest.setLaunchSpecification(launchSpecification);
// Call the RequestSpotInstance API.
RequestSpotInstancesResult requestResult =
ec2.requestSpotInstances(requestRequest);
```
En el caso de que desee volver a asociar este volumen a la instancia durante el inicio, también puede utilizar los ajustes de mapeo de dispositivos de bloques. Si la instancia está asociada a un partición distinta de la partición raíz, también puede especificar los volúmenes de Amazon Amazon EBS que desea asociar a la instancia de spot una vez que esta se reanude. Para ello, solo tiene que especificar un ID de snapshot en su `EbsBlockDevice` y un nombre de dispositivo alternativo en sus objetos `BlockDeviceMapping`. Mediante el uso de mapeos de dispositivos de bloques, puede ser más sencillo arrancar su instancia.
El uso de la partición raíz para aplicar un punto de comprobación a su datos críticos es una forma excelente de administrar la posibilidad de que se interrumpan sus instancias. Para conocer otros métodos de administración de posibles interrupciones, vea el vídeo [Managing Interruption](https://www.youtube.com/watch?feature=player_embedded&v=wcPNnUo60pc).
## Cómo etiquetar sus solicitudes e instancias de spot
Añadir etiquetas a los recursos de Amazon EC2 puede simplificar la administración de la infraestructura de la nube. Las etiquetas, un tipo de metadatos, se pueden utilizar para crear nombres sencillos, mejorar la capacidad de búsqueda y mejorar la coordinación entre varios usuarios. También puede utilizar las etiquetas para automatizar scripts y partes de sus procesos. Para obtener más información sobre cómo etiquetar recursos de Amazon EC2, consulte [Uso de etiquetas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.
### Etiquetado de solicitudes
Para añadir etiquetas a sus solicitudes de spot, tiene que etiquetarlas *después* de que se hayan solicitado. El valor devuelto de `requestSpotInstances()` proporciona un objeto [RequestSpotInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RequestSpotInstancesResult.html) que puede utilizar para obtener los ID de las solicitudes de spot que desea etiquetar:
```
// 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());
}
```
Cuando tenga los ID, puede etiquetar las solicitudes añadiendo sus ID a una [CreateTagsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateTagsRequest.html) y llamando al método `createTags()` del cliente de Amazon EC2:
```
// 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());
}
```
### Etiquetado de instancias
De forma similar a las solicitudes de spot, solo puede etiquetar una instancia una vez que se haya creado, lo que ocurrirá cuando se haya satisfecho la solicitud de spot (cuando ya no tenga el estado *abierto*).
Puede comprobar el estado de sus solicitudes llamando al método `describeSpotInstanceRequests()` del cliente de Amazon EC2 con un objeto [DescribeSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsRequest.html). El objeto [DescribeSpotInstanceRequestsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSpotInstanceRequestsResult.html) devuelto contiene una lista de objetos [SpotInstanceRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/SpotInstanceRequest.html) que puede usar para consultar el estado de sus solicitudes de spot y obtener sus ID de instancia cuando ya no tengan el estado *abierto*.
Cuando la solicitud de spot deje de estar abierta, puede recuperar su ID de instancia del objeto `SpotInstanceRequest` llamando a su método `getInstanceId()`.
```
boolean anyOpen; // tracks whether any requests are still open
// a list of instances to tag.
ArrayList instanceIds = new ArrayList();
do {
DescribeSpotInstanceRequestsRequest describeRequest =
new DescribeSpotInstanceRequestsRequest();
describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);
anyOpen=false; // assume no requests are still open
try {
// Get the requests to monitor
DescribeSpotInstanceRequestsResult describeResult =
ec2.describeSpotInstanceRequests(describeRequest);
List describeResponses =
describeResult.getSpotInstanceRequests();
// are any requests open?
for (SpotInstanceRequest describeResponse : describeResponses) {
if (describeResponse.getState().equals("open")) {
anyOpen = true;
break;
}
// get the corresponding instance ID of the spot request
instanceIds.add(describeResponse.getInstanceId());
}
}
catch (AmazonServiceException e) {
// Don't break the loop due to an exception (it may be a temporary issue)
anyOpen = true;
}
try {
Thread.sleep(60*1000); // sleep 60s.
}
catch (Exception e) {
// Do nothing if the thread woke up early.
}
} while (anyOpen);
```
Ahora puede etiquetar las instancias que se devuelven:
```
// 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());
}
```
## Cancelación de solicitudes de spot y terminación de instancias
### Cancelación de una solicitud de spot
Para cancelar una solicitud de instancia de spot, llame a `cancelSpotInstanceRequests` en el cliente de Amazon EC2 con un objeto [CancelSpotInstanceRequestsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CancelSpotInstanceRequestsRequest.html).
```
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());
}
```
### Terminación de instancias de spot
Puede terminar las instancias de spot que se estén ejecutando pasando sus ID al método `terminateInstances()` del cliente de Amazon EC2.
```
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());
}
```
## Operación conjunta
Para realizar todas estas operaciones a la vez, ofrecemos un enfoque más orientado a objetos, que combina los pasos mostrados en este tutorial en una clase fácil de usar. Creamos una instancia de una clase llamada `Requests` que realiza estas acciones. También creamos una clase `GettingStartedApp`, que tiene un método principal donde realizamos las llamadas a funciones de alto nivel.
El código fuente completo de este ejemplo se puede consultar o descargar en [GitHub](https://github.com/aws/aws-sdk-java/tree/master/src/samples/AmazonEC2SpotInstances-Advanced).
¡Enhorabuena\$1 Ha completado el tutorial de características avanzadas de solicitudes para el desarrollo de instancias de spot con AWS SDK para Java.
# Administración de instancias de Amazon EC2
## Crear una instancia
Cree una nueva instancia de Amazon EC2 llamando al método `runInstances` de AmazonEC2Client, proporcionando un objeto [RunInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RunInstancesRequest.html) que contenga la [Imagen de máquina de Amazon (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) que se va a usar y un [tipo de instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateInstance.java)
## Iniciar una instancia
Para iniciar una instancia Amazon EC2, llame al método `startInstances` de AmazonEC2Client, proporcionando un objeto [StartInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StartInstancesRequest.html) que contenga el ID de la instancia que se va a iniciar.
**Importaciones**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StartInstancesRequest;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StartInstancesRequest request = new StartInstancesRequest()
.withInstanceIds(instance_id);
ec2.startInstances(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java)
## Detener una instancia
Para detener una instancia Amazon EC2, llame al método `stopInstances` de AmazonEC2Client, proporcionando un objeto [StopInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/StopInstancesRequest.html) que contenga el ID de la instancia que se va a detener.
**Importaciones**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.StopInstancesRequest;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
StopInstancesRequest request = new StopInstancesRequest()
.withInstanceIds(instance_id);
ec2.stopInstances(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/StartStopInstance.java)
## Reiniciar una instancia
Para reiniciar una instancia Amazon EC2, llame al método `rebootInstances` de AmazonEC2Client, proporcionando un objeto [RebootInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/RebootInstancesRequest.html) que contenga el ID de la instancia que se va a reiniciar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
RebootInstancesRequest request = new RebootInstancesRequest()
.withInstanceIds(instance_id);
RebootInstancesResult response = ec2.rebootInstances(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/RebootInstance.java)
## Describir instancias
Para enumerar sus instancias, cree un objeto [DescribeInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html) y llame al método `describeInstances` de AmazonEC2Client. Se devolverá un objeto [DescribeInstancesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeInstancesResult.html) que puede utilizar para mostrar las instancias Amazon EC2 de su cuenta y región.
Las instancias se agrupan por *reserva*. Cada reserva se corresponde con la llamada a `startInstances` que lanzó la instancia. Para mostrar sus instancias, primero debe llamar al método `getReservations' method, and then call `getInstances` de la clase `DescribeInstancesResult` en cada objeto [Reservation](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Reservation.html) devuelto.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Los resultados se paginan; puede obtener más resultados pasando el valor devuelto del método `getNextToken` del objeto resultante al método `setNextToken` del objeto de la solicitud original, usando el mismo objeto de la solicitud en la siguiente llamada a `describeInstances`.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeInstances.java)
## Monitorizar una instancia
Puede monitorizar distintos aspectos de las instancias Amazon EC2, como el uso de la CPU y la red, la memoria disponible y el espacio en disco restante. Para obtener más información sobre la supervisión de instancias, consulte [Supervisión Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html) en la Guía del usuario de Amazon EC2 para instancias Linux.
Para iniciar la monitorización de una instancia, debe crear un objeto [MonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/MonitorInstancesRequest.html) con el ID de la instancia que se va a monitorizar y pasarlo al método `monitorInstances` de AmazonEC2Client.
**Importaciones**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.MonitorInstancesRequest;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
MonitorInstancesRequest request = new MonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.monitorInstances(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java)
## Detener la monitorización de instancias
Para detener la monitorización de una instancia, cree un objeto [UnmonitorInstancesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/UnmonitorInstancesRequest.html) con el ID de la instancia cuya monitorización se va a detener y pase el objeto al método de AmazonEC2Client.
**Importaciones**
```
import com.amazonaws.services.ec2.AmazonEC2;
import com.amazonaws.services.ec2.AmazonEC2ClientBuilder;
import com.amazonaws.services.ec2.model.UnmonitorInstancesRequest;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
UnmonitorInstancesRequest request = new UnmonitorInstancesRequest()
.withInstanceIds(instance_id);
ec2.unmonitorInstances(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/MonitorInstance.java)
## Más información
+ [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html) en la referencia de la API de Amazon EC2
+ [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html) en la referencia de la API de Amazon EC2
+ [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html) en la referencia de la API de Amazon EC2
+ [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html) en la referencia de la API de Amazon EC2
+ [RebootInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RebootInstances.html) en la referencia de la API de Amazon EC2
+ [MonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_MonitorInstances.html) en la referencia de la API de Amazon EC2
+ [UnmonitorInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html) en la referencia de la API de Amazon EC2
# Uso de direcciones IP elásticas en Amazon EC2
## Retirada de EC2-Classic
**aviso**
Vamos a retirar EC2-Classic el 15 de agosto de 2022. Le recomendamos que migre de EC2-Classic a una VPC. Para obtener más información, consulte la entrada del blog [EC2-Classic-Classic Networking is Retiring – Here's How to Prepare](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/).
## Asignación de una dirección IP elástica
Para utilizar una dirección IP elástica, primero asigne una a su cuenta y, a continuación, asóciela a su instancia o a una interfaz de red.
Para asignar una dirección IP elástica, llame al método `allocateAddress` del cliente AmazonEC2Client con un objeto [AllocateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressRequest.html) que contenga el tipo de red (EC2 clásico o VPC).
El [AllocateAddressResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AllocateAddressResult.html) devuelto contiene un ID de asignación que puede utilizar para asociar la dirección a una instancia, pasando el ID de asignación y el ID de instancia en un objeto [AssociateAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AssociateAddressRequest.html) al método `associateAddress` de AmazonEC2Client.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/AllocateAddress.java)
## Descripción de direcciones IP elásticas
Para listar las direcciones IP elásticas asignadas a su cuenta, llame al método `describeAddresses` de AmazonEC2Client. Este método devuelve un objeto [DescribeAddressesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAddressesResult.html) que puede utilizar para obtener una lista de objetos [Address](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Address.html) que representan las direcciones IP elásticas de su cuenta.
**Importaciones**
```
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;
```
**Código de**
```
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());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAddresses.java)
## Liberación de una dirección IP elástica
Para liberar una dirección IP elástica, llame al método `releaseAddress` de AmazonEC2Client pasando un objeto [ReleaseAddressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/ReleaseAddressRequest.html) que contenga el ID de asignación de la dirección IP elástica que quiere liberar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
ReleaseAddressRequest request = new ReleaseAddressRequest()
.withAllocationId(alloc_id);
ReleaseAddressResult response = ec2.releaseAddress(request);
```
Tras liberar una dirección IP elástica, esta se libera del grupo de direcciones IP de AWS y puede que no esté disponible para usarla más adelante. Asegúrese de actualizar sus registros DNS y los servidores o dispositivos que se comunican con la dirección. Si intenta liberar una dirección IP elástica que ya ha liberado, obtendrá un error *AuthFailure* si la dirección ya se ha asignado a otra cuenta de Cuenta de AWS.
Si utiliza *EC2-Classic* o una *VPC predeterminada*, al liberar una dirección IP elástica esta se desvincula automáticamente de cualquier instancia a la que esté asociada. Para desvincular una dirección IP elástica sin liberarla, utilice el método `disassociateAddress` de AmazonEC2Client.
Si utiliza una VPC distinta de la predeterminada, *debe* usar `disassociateAddress` para desvincular la dirección IP elástica antes de intentar liberarla. De lo contrario, Amazon EC2 devuelve un error (*InvalidIPAddress.InUse*).
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/ReleaseAddress.java)
## Más información
+ [Direcciones IP elásticas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) en la Guía del usuario de Amazon EC2 para instancias de Linux
+ [AllocateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html) en la referencia de la API Amazon EC2
+ [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html) en la referencia de la API Amazon EC2
+ [ReleaseAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseAddress.html) en la referencia de la API Amazon EC2
# Usar regiones y zonas de disponibilidad
## Describir regiones
Para mostrar las regiones disponibles para su cuenta, llame al método `describeRegions` del AmazonEC2Client. Este método devuelve un objeto [DescribeRegionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeRegionsResult.html). Llame al método `getRegions` del objeto devuelto para obtener una lista de objetos [Region](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/Region.html) que representan cada región.
**Importaciones**
```
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;
```
**Código de**
```
DescribeRegionsResult regions_response = ec2.describeRegions();
for(Region region : regions_response.getRegions()) {
System.out.printf(
"Found region %s " +
"with endpoint %s",
region.getRegionName(),
region.getEndpoint());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java)
## Describir zonas de disponibilidad
Para mostrar las zonas de disponibilidad disponibles para su cuenta, llame al método `describeAvailabilityZones` del AmazonEc2Client. Este método devuelve un objeto [DescribeAvailabilityZonesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAvailabilityZonesResult.html). Llame al método `getAvailabilityZones` del objeto devuelto para obtener una lista de objetos [AvailabilityZone](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AvailabilityZone.html) que representan cada zona de disponibilidad.
**Importaciones**
```
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;
```
**Código de**
```
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());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeRegionsAndZones.java)
## Describir cuentas
Para describir su cuenta, llame al método `describeAccountAttributes` del AmazonEC2Client. Este método devuelve un objeto [DescribeAccountAttributesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeAccountAttributesResult.html). Invoque el método `getAccountAttributes` de este objeto para obtener una lista de objetos [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html). Puede recorrer en iteración la lista para recuperar un objeto [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html).
Puede obtener los valores de los atributos de su cuenta invocando el método `getAttributeValues` del objeto [AccountAttribute](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttribute.html). Este método devuelve una lista de objetos [AccountAttributeValue](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AccountAttributeValue.html). Puede recorrer en iteración esta segunda lista para mostrar el valor de los atributos (consulte el siguiente ejemplo de código).
**Importaciones**
```
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;
```
**Código de**
```
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();
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeAccount.java) en GitHub.
## Más información
+ [Regiones y zonas de disponibilidad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) en la Guía del usuario de Amazon EC2 para instancias de Linux
+ [DescribeRegions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRegions.html) en la Referencia de la API de Amazon EC2
+ [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html) en la Referencia de la API de Amazon EC2
# Uso de pares de claves de Amazon EC2
## Creación de un par de claves
Para crear un par de claves, llame al método `createKeyPair` del AmazonEC2Client con una [CreateKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateKeyPairRequest.html) que contenga el nombre de la clave.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
CreateKeyPairRequest request = new CreateKeyPairRequest()
.withKeyName(key_name);
CreateKeyPairResult response = ec2.createKeyPair(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateKeyPair.java)
## Descripción de pares de claves
Para mostrar sus pares de claves o para obtener información sobre ellos, llame al método `describeKeyPairs` de AmazonEC2Client. Este método devuelve [DescribeKeyPairsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeKeyPairsResult.html), que se puede utilizar para obtener acceso a la lista de pares de claves mediante la llamada a su método `getKeyPairs`, que devuelve una lista de objetos [KeyPairInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/KeyPairInfo.html).
**Importaciones**
```
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;
```
**Código de**
```
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());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeKeyPairs.java)
## Eliminación de un par de claves
Para eliminar un par de claves, llame al método `deleteKeyPair` de AmazonEC2Client, pasando un objeto [DeleteKeyPairRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteKeyPairRequest.html) que contenga el nombre del par de claves que desea eliminar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteKeyPairRequest request = new DeleteKeyPairRequest()
.withKeyName(key_name);
DeleteKeyPairResult response = ec2.deleteKeyPair(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteKeyPair.java)
## Más información
+ [Pares de claves Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la Guía del usuario de Amazon EC2 para instancias de Linux
+ [CreateKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html) en la Referencia de la API de Amazon EC2
+ [DescribeKeyPairs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html) en la referencia de la API de Amazon EC2
+ [DeleteKeyPair](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteKeyPair.html) en la Referencia de la API de Amazon EC2
# Uso de grupos de seguridad en Amazon EC2
## Creación de un grupo de seguridad
Para crear un grupo de seguridad, llame al método `createSecurityGroup` de AmazonEC2Client con una [CreateSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/CreateSecurityGroupRequest.html) que contenga el nombre de la clave.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java)
## Configuración de un grupo de seguridad
Un grupo de seguridad puede controlar el tráfico de entrada y salida a sus instancias Amazon EC2.
Para añadir reglas de entrada al grupo de seguridad, utilice el método `authorizeSecurityGroupIngress` de AmazonEC2Client, proporcionando el nombre del grupo de seguridad y las reglas de acceso ([IpPermission](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/IpPermission.html)) que desea asignar al grupo dentro de un objeto [AuthorizeSecurityGroupIngressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupIngressRequest.html). El siguiente ejemplo muestra cómo añadir permisos de IP a un grupo de seguridad.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Para agregar una regla de salida al grupo de seguridad, proporcione datos similares en un objeto [AuthorizeSecurityGroupEgressRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/AuthorizeSecurityGroupEgressRequest.html) al método `authorizeSecurityGroupEgress` de AmazonEC2Client.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/CreateSecurityGroup.java)
## Descripción de grupos de seguridad
Para describir los grupos de seguridad o para obtener información sobre ellos, llame al método `describeSecurityGroups` de AmazonEC2Client. Este método devuelve [DescribeSecurityGroupsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DescribeSecurityGroupsResult.html), que puede usar para obtener acceso a la lista de grupos de seguridad llamando a su método `getSecurityGroups`, que devuelve una lista de objetos [SecurityGroup](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/SecurityGroup.html).
**Importaciones**
```
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;
```
**Código de**
```
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];
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DescribeSecurityGroups.java)
## Eliminación de un grupo de seguridad
Para eliminar un grupo de seguridad, llame al método `deleteSecurityGroup` de AmazonEC2Client, pasando un [DeleteSecurityGroupRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/ec2/model/DeleteSecurityGroupRequest.html) que contenga el ID del grupo de seguridad que desea eliminar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
DeleteSecurityGroupRequest request = new DeleteSecurityGroupRequest()
.withGroupId(group_id);
DeleteSecurityGroupResult response = ec2.deleteSecurityGroup(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/ec2/src/main/java/aws/example/ec2/DeleteSecurityGroup.java)
## Más información
+ [Grupos de seguridad de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) en la Guía del usuario de Amazon EC2 para instancias de Linux
+ [Autorización del tráfico entrante para sus instancias de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) en la Guía del usuario de Amazon EC2 para instancias de Linux
+ [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html) en la Referencia de la API de Amazon EC2
+ [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html) en la Referencia de la API de Amazon EC2
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html) en la Referencia de la API de Amazon EC2
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html) en la Referencia de la API de Amazon EC2
# Ejemplos de (IAM) con AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [IAM](https://aws.amazon.com/iam/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
AWS Identity and Access Management (IAM) permite controlar de forma segura el acceso a los servicios y recursos de AWS de los usuarios. Con IAM puede crear y administrar usuarios y grupos de AWS, así como utilizar permisos para conceder o denegar el acceso de estos a los recursos de AWS. Para obtener instrucciones completas de IAM, consulte la [Guía del usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Administración de las claves de acceso de IAM](examples-iam-access-keys.md)
+ [Administración de usuarios de IAM](examples-iam-users.md)
+ [Uso de alias de cuenta de IAM](examples-iam-account-aliases.md)
+ [Uso de políticas de IAM](examples-iam-policies.md)
+ [Uso de certificados de servidor de IAM](examples-iam-server-certificates.md)
# Administración de las claves de acceso de IAM
## Creación de una clave de acceso
Para crear una clave de acceso de IAM, llame al método `createAccessKey` de AmazonIdentityManagementClient con un objeto [CreateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccessKeyRequest.html).
`CreateAccessKeyRequest` tiene dos constructores: uno que toma un nombre de usuario y otro sin parámetros. Si utiliza la versión que no toma parámetros, debe definir el nombre de usuario mediante el método setter `withUserName` antes de pasarlo al método `createAccessKey`.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccessKeyRequest request = new CreateAccessKeyRequest()
.withUserName(user);
CreateAccessKeyResult response = iam.createAccessKey(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccessKey.java) en GitHub.
## Mostrar claves de acceso
Para enumerar las claves de acceso de un determinado usuario, cree un objeto [ListAccessKeysRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysRequest.html) que contenga el nombre de usuario cuyas claves desea enumerar y páselo al método `listAccessKeys` de AmazonIdentityManagementClient.
**nota**
Si no proporciona un nombre de usuario a `listAccessKeys`, intentará enumerar las claves de acceso asociadas a la Cuenta de AWS que firmó la solicitud.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Los resultados de `listAccessKeys` están paginados (con un máximo de 100 registros por llamada). Puede llamar a `getIsTruncated` en el objeto [ListAccessKeysResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAccessKeysResult.html) devuelto para saber si la consulta ha devuelto menos resultados de los que están disponibles. En tal caso, llame a `setMarker` en el objeto `ListAccessKeysRequest` y vuelva a pasarlo a la siguiente invocación de `listAccessKeys`.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccessKeys.java) en GitHub.
## Recuperar el momento en que se usó por última vez una clave de acceso
Para obtener el momento en el que se usó por última vez una clave de acceso, llame al método `getAccessKeyLastUsed` de AmazonIdentityManagementClient con el ID de la clave de acceso (que se puede pasar mediante un objeto [GetAccessKeyLastUsedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedRequest.html)) o directamente a la sobrecarga que toma el ID de clave de acceso.
A continuación, puede utilizar el objeto [GetAccessKeyLastUsedResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetAccessKeyLastUsedResult.html) devuelto para recuperar el momento en que se usó por última vez la clave.
**Importaciones**
```
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;
```
**Código de**
```
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());
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AccessKeyLastUsed.java) en GitHub.
## Activación o desactivación de claves de acceso
Puede activar o desactivar una clave de acceso creando un objeto [UpdateAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateAccessKeyRequest.html), proporcionando el ID de clave de acceso, el nombre de usuario (de forma opcional) y el [estado](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/StatusType.html) deseado y, a continuación, pasando el objeto al método `updateAccessKey` de AmazonIdentityManagementClient.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateAccessKeyRequest request = new UpdateAccessKeyRequest()
.withAccessKeyId(access_id)
.withUserName(username)
.withStatus(status);
UpdateAccessKeyResult response = iam.updateAccessKey(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateAccessKey.java) en GitHub.
## Eliminación de una clave de acceso
Para eliminar de forma permanente una clave de acceso, llame al método `deleteKey` de AmazonIdentityManagementClient, proporcionando un objeto [DeleteAccessKeyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccessKeyRequest.html) que contenga el ID de clave de acceso y el nombre de usuario.
**nota**
Una vez eliminada una clave, ya no se puede recuperar ni utilizar. Para desactivar temporalmente una clave de forma que pueda activarse de nuevo más adelante, utilice el método [updateAccessKey](#iam-access-keys-update) en su lugar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccessKeyRequest request = new DeleteAccessKeyRequest()
.withAccessKeyId(access_key)
.withUserName(username);
DeleteAccessKeyResult response = iam.deleteAccessKey(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccessKey.java) en GitHub.
## Más información
+ [CreateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html) en la Referencia de la API de IAM
+ [ListAccessKeys](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccessKeys.html) en la referencia de la API de IAM
+ [GetAccessKeyLastUsed](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetAccessKeyLastUsed.html) en la referencia de la API de IAM
+ [UpdateAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAccessKey.html) en la Referencia de la API de IAM
+ [DeleteAccessKey](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html) en la Referencia de la API de IAM
# Administración de usuarios de IAM
## Crear un usuario
Cree un nuevo usuario de IAM proporcionando el nombre del usuario al método `createUser` de AmazonIdentityManagementClient, ya sea directamente o a través de un objeto [CreateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateUserRequest.html) que contenga el nombre de usuario.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateUserRequest request = new CreateUserRequest()
.withUserName(username);
CreateUserResult response = iam.createUser(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateUser.java) en GitHub.
## Mostrar usuarios
Para mostrar los usuarios de IAM de su cuenta, cree un nuevo objeto [ListUsersRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListUsersRequest.html) y páselo al método `listUsers` de AmazonIdentityManagementClient. Puede recuperar la lista de usuarios llamando a `getUsers` en el objeto [ListUsersResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListUsersResult.html) devuelto.
La lista de usuarios devuelta por `listUsers` está paginada. Puede comprobar que no haya más resultados que recuperar llamando al método `getIsTruncated` del objeto de respuesta. Si devuelve `true`, llame al método `setMarker()` del objeto de solicitud pasando el valor devuelto del método `getMarker()` del objeto de respuesta.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListUsers.java) en GitHub.
## Actualizar un usuario
Para actualizar un usuario, llame al método `updateUser` de AmazonIdentityManagementClient, que toma un objeto [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html) que puede utilizar para cambiar el *nombre* o la *ruta* del usuario.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateUserRequest request = new UpdateUserRequest()
.withUserName(cur_name)
.withNewUserName(new_name);
UpdateUserResult response = iam.updateUser(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateUser.java) en GitHub.
## Eliminar un usuario
Para eliminar un usuario, llame a la solicitud `deleteUser` de AmazonIdentityManagementClient con un objeto [UpdateUserRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateUserRequest.html) definido con el nombre de usuario que desea eliminar.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteUser.java) en GitHub.
## Más información
+ [Usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) en la Guía del usuario de IAM
+ [Gestión de usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) en la Guía del usuario de IAM
+ [CreateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateUser.html) en la Referencia de la API de IAM
+ [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html) en la Referencia de la API de IAM
+ [UpdateUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateUser.html) en la referencia de la API de IAM
+ [DeleteUser](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUser.html) en la referencia de la API de IAM
# Uso de alias de cuenta de IAM
Si quiere que la dirección URL de la página de inicio de sesión contenga el nombre de su empresa u otro identificador intuitivo en lugar de su ID de Cuenta de AWS, puede crear un alias para su Cuenta de AWS.
**nota**
AWS admite exactamente un alias de cuenta por cuenta.
## Creación de un alias de cuenta
Para crear un alias de cuenta, llame al método `createAccountAlias` de AmazonIdentityManagementClient con un objeto [CreateAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreateAccountAliasRequest.html) que contenga el nombre del alias.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreateAccountAliasRequest request = new CreateAccountAliasRequest()
.withAccountAlias(alias);
CreateAccountAliasResult response = iam.createAccountAlias(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreateAccountAlias.java) en GitHub.
## Mostrar alias de cuenta
Para mostrar sus alias de cuenta, si hay alguno, llame al método `listAccountAliases` de AmazonIdentityManagementClient.
**nota**
El [ListAccountAliasesResult](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/identitymanagement/model/ListAccountAliasesResult.html) devuelto admite los mismos métodos `getIsTruncated` y `getMarker` que otros métodos *list* de AWS SDK para Java, pero una Cuenta de AWS solo puede tener *un* alias de cuenta.
**Importaciones**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListAccountAliases.java) en GitHub.
## Eliminación de un alias de cuenta
Para mostrar sus alias de cuenta, si hay alguno, llame al método `deleteAccountAlias` de AmazonIdentityManagementClient. Al eliminar un alias de cuenta, debe proporcionar su nombre mediante un objeto [DeleteAccountAliasRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteAccountAliasRequest.html).
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteAccountAliasRequest request = new DeleteAccountAliasRequest()
.withAccountAlias(alias);
DeleteAccountAliasResult response = iam.deleteAccountAlias(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteAccountAlias.java) en GitHub.
## Más información
+ [Su ID de cuenta AWS y su alias](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html) en la Guía del usuario de IAM
+ [CreateAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccountAlias.html) en la referencia de la API de IAM
+ [ListAccountAliases](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAccountAliases.html) en la referencia de la API de IAM
+ [DeleteAccountAlias](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccountAlias.html) en la referencia de la API de IAM
# Uso de políticas de IAM
## Creación de una política
Para crear una nueva política, proporcione el nombre de la política y un documento de política en formato JSON en un objeto [CreatePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/CreatePolicyRequest.html) al método `createPolicy` de AmazonIdentityManagementClient.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
CreatePolicyRequest request = new CreatePolicyRequest()
.withPolicyName(policy_name)
.withPolicyDocument(POLICY_DOCUMENT);
CreatePolicyResult response = iam.createPolicy(request);
```
Los documentos de política de IAM; son cadenas JSON con una [sintaxis bien documentada](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html). Este es un ejemplo que proporciona acceso para realizar determinadas solicitudes 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\"" +
" }" +
" ]" +
"}";
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/CreatePolicy.java) en GitHub.
## Obtención de una política
Para recuperar una política existente, llame al método `getPolicy` de AmazonIdentityManagementClient, proporcionando el ARN de la política en un objeto [GetPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetPolicyRequest.html).
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetPolicyRequest request = new GetPolicyRequest()
.withPolicyArn(policy_arn);
GetPolicyResult response = iam.getPolicy(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetPolicy.java) en GitHub.
## Asociar una política de rol
Puede adjuntar una política a un IAM http://docs.aws.amazon.com/IAM/latest/UserGuide/id\$1roles.html[rol] llamando al `attachRolePolicy` método de AmazonIdentityManagementClient y proporcionándole el nombre del rol y el ARN de la política en una [AttachRolePolicyRequest.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/AttachRolePolicyRequest.html)
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
AttachRolePolicyRequest attach_request =
new AttachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(POLICY_ARN);
iam.attachRolePolicy(attach_request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) en GitHub.
## Mostrar las políticas de rol asociadas
Enumerar las políticas asociadas a un rol llamando al método `listAttachedRolePolicies` de AmazonIdentityManagementClient. Este método toma un objeto [ListAttachedRolePoliciesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesRequest.html) que contiene el nombre del rol para el que se desea mostrar las políticas.
Llame a `getAttachedPolicies` en el objeto [ListAttachedRolePoliciesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListAttachedRolePoliciesResult.html) devuelto para obtener la lista de políticas asociadas. Los resultados pueden aparecer truncados; si el método `ListAttachedRolePoliciesResult` del objeto `getIsTruncated` devuelve `true`, llame al método `ListAttachedRolePoliciesRequest` del objeto `setMarker` y úselo para llamar a `listAttachedRolePolicies` de nuevo para obtener el siguiente lote de resultados.
**Importaciones**
```
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;
```
**Código de**
```
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());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/AttachRolePolicy.java) en GitHub.
## Desvincular una política de rol
Para desvincular una política de un rol, llame al método `detachRolePolicy` de AmazonIdentityManagementClient proporcionando el nombre de rol y el ARN de política en un objeto [DetachRolePolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DetachRolePolicyRequest.html).
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DetachRolePolicyRequest request = new DetachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(policy_arn);
DetachRolePolicyResult response = iam.detachRolePolicy(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DetachRolePolicy.java) en GitHub.
## Más información
+ [Descripción general de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) en la Guía del usuario de IAM.
+ [Referencia de políticas de AWS IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) en la Guía del usuario de IAM.
+ [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html) en la referencia de la API de IAM
+ [GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html) en la referencia de la API de IAM
+ [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html) en la referencia de la API de IAM
+ [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html) en la referencia de la API de IAM
+ [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html) en la referencia de la API de IAM
# Uso de certificados de servidor de IAM
Para habilitar las conexiones HTTPS en su sitio web o aplicación en AWS, necesita un *certificado de servidor* SSL/TLS. Puede utilizar un certificado de servidor proporcionado por AWS Certificate Manager o uno que haya obtenido de un proveedor externo.
Es recomendable utilizar ACM para aprovisionar, administrar e implementar los certificados de servidor. Con ACM puede solicitar un certificado, implementarlo en los recursos de AWS y dejar que ACM se ocupe de la renovación de los certificados. Los certificados proporcionados por ACM son gratuitos. Para obtener más información acerca de ACM, consulte la [Guía del usuario de ACM](https://docs.aws.amazon.com/acm/latest/userguide/).
## Obtener un certificado de servidor
Puede recuperar un certificado de servidor llamando al método `getServerCertificate` de AmazonIdentityManagementClient, pasando un objeto [GetServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/GetServerCertificateRequest.html) con el nombre del certificado.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
GetServerCertificateRequest request = new GetServerCertificateRequest()
.withServerCertificateName(cert_name);
GetServerCertificateResult response = iam.getServerCertificate(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/GetServerCertificate.java) en GitHub.
## Mostrar certificados de servidor
Para mostrar sus certificados de servidor, llame al método `listServerCertificates` de AmazonIdentityManagementClient con un objeto [ListServerCertificatesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesRequest.html). Este método devuelve un objeto [ListServerCertificatesResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ListServerCertificatesResult.html).
Llame al método `getServerCertificateMetadataList` del objeto `ListServerCertificateResult` devuelto para obtener una lista de objetos [ServerCertificateMetadata](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/ServerCertificateMetadata.html) que puede usar para obtener información de cada certificado.
Los resultados pueden aparecer truncados; si el método `ListServerCertificateResult` del objeto `getIsTruncated` devuelve `true`, llame al método `ListServerCertificatesRequest` del objeto `setMarker` y úselo para llamar a `listServerCertificates` de nuevo para obtener el siguiente lote de resultados.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/ListServerCertificates.java) en GitHub.
## Actualizar un certificado de servidor
Puede actualizar el nombre o la ruta de un certificado de servidor llamando al método `updateServerCertificate` de AmazonIdentityManagementClient. Este método toma un objeto [UpdateServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/UpdateServerCertificateRequest.html) establecido con el nombre actual del certificado de servidor o el nuevo nombre o la nueva ruta que se va a usar.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
UpdateServerCertificateRequest request =
new UpdateServerCertificateRequest()
.withServerCertificateName(cur_name)
.withNewServerCertificateName(new_name);
UpdateServerCertificateResult response =
iam.updateServerCertificate(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/UpdateServerCertificate.java) en GitHub.
## Eliminar un certificado de servidor
Para eliminar un certificado de servidor, llame al método `deleteServerCertificate` de AmazonIdentityManagementClient, con un objeto [DeleteServerCertificateRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/identitymanagement/model/DeleteServerCertificateRequest.html) que contenga el nombre del certificado.
**Importaciones**
```
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;
```
**Código de**
```
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
DeleteServerCertificateRequest request =
new DeleteServerCertificateRequest()
.withServerCertificateName(cert_name);
DeleteServerCertificateResult response =
iam.deleteServerCertificate(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/iam/src/main/java/aws/example/iam/DeleteServerCertificate.java) en GitHub.
## Más información
+ [Uso de certificados de servidor](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) en la Guía del usuario de IAM
+ [GetServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServerCertificate.html) en la referencia de la API de IAM
+ [ListServerCertificates](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListServerCertificates.html) en la referencia de la API de IAM
+ [UpdateServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateServerCertificate.html) en la referencia de la API de IAM
+ [DeleteServerCertificate](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServerCertificate.html) en la referencia de la API de IAM
+ [Guía del usuario de ACM](https://docs.aws.amazon.com/acm/latest/userguide/)
# Lambda Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación en Lambda mediante AWS SDK para Java.
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Operaciones de servicio](examples-lambda.md)
# Invocar, enumerar y eliminar funciones de Lambda
En esta sección se proporcionan ejemplos de programación con el cliente de servicio de Lambda mediante el AWS SDK para Java. Para aprender a crear una función Lambda, consulte Cómo crear funciones AWS Lambda.
**Topics**
+ [Invocar una función](#invoke-function)
+ [Lista de funciones](#list-function)
+ [Eliminar una función](#delete-function)
## Invocar una función
Puede invocar una función Lambda creando un objeto [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html) e invocando su método `invoke`. Cree un objeto [InvokeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html) para especificar información adicional, como el nombre de la función y la carga útil que pasar a la función Lambda. Los nombres de funciones aparecen como *arn:aws:lambda:us-east-1:555556330391:function:HelloFunction*. Puede recuperar el valor viendo la función en la Consola de administración de AWS.
Para pasar datos de carga útil a una función, invoque el método `withPayload` del objeto [InvokerEquest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeRequest.html) y especifique una cadena en formato JSON, como se muestra en el siguiente ejemplo de código.
**Importaciones**
```
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;
```
**Código de**
En el ejemplo de código siguiente se muestra cómo invocar una función 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());
```
Consulte el ejemplo completo en [Github](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/LambdaInvokeFunction.java).
## Lista de funciones
Construya un objeto [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html) e invoque su método `listFunctions`. Este método devuelve un objeto [ListFunctionsResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/ListFunctionsResult.html). Puede invocar el método `getFunctions` de este objeto para devolver una lista de objetos [FunctionConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/FunctionConfiguration.html). Puede recorrer la lista en iteración para recuperar información sobre las funciones. Por ejemplo, el siguiente ejemplo de código Java muestra cómo obtener el nombre de cada función.
**Importaciones**
```
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;
```
**Código de**
El siguiente ejemplo de código Java muestra cómo recuperar una lista de nombres de funciones de Lambda.
```
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);
}
```
Consulte el ejemplo completo en [Github](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/ListFunctions.java).
## Eliminar una función
Construya un objeto [AWSLambda](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambda.html) e invoque su método `deleteFunction`. Cree un objeto [DeleteFunctionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/DeleteFunctionRequest.html) y páselo al método `deleteFunction`. Este objeto contiene información como el nombre de la función que se va a eliminar. Los nombres de funciones aparecen como *arn:aws:lambda:us-east-1:555556330391:function:HelloFunction*. Puede recuperar el valor viendo la función en la Consola de administración de AWS.
**Importaciones**
```
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;
```
**Código de**
El siguiente código Java muestra cómo eliminar una función Lambda.
```
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);
}
```
Consulte el ejemplo completo en [Github](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/lambda/src/main/java/com/example/lambda/DeleteFunction.java).
# Amazon Pinpoint Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [Amazon Pinpoint](https://aws.amazon.com/pinpoint/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Creación y eliminación de aplicaciones en Amazon Pinpoint](examples-pinpoint-create-app.md)
+ [Creación de puntos de conexón en Amazon Pinpoint](examples-pinpoint-create-endpoint.md)
+ [Creación de segmentos en Amazon Pinpoint](examples-pinpoint-create-segment.md)
+ [Creación de campañas en Amazon Pinpoint](examples-pinpoint-create-campaign.md)
+ [Actualización de canales en Amazon Pinpoint](examples-pinpoint-update-channel.md)
# Creación y eliminación de aplicaciones en Amazon Pinpoint
Una aplicación es un proyecto de Amazon Pinpoint en el que se define el público de una aplicación y se intenta atraer a dicho público con mensajes personalizados. Los ejemplos de esta página demuestran cómo crear una aplicación o cómo eliminar una existente.
## Crear una aplicación
Para crear una aplicación en Amazon Pinpoint, proporcione un nombre de aplicación al objeto [CreateAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateAppRequest.html) y, a continuación, pase dicho objeto al método `createApp` de AmazonPinpointClient.
**Importaciones**
```
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;
```
**Código de**
```
CreateApplicationRequest appRequest = new CreateApplicationRequest()
.withName(appName);
CreateAppRequest request = new CreateAppRequest();
request.withCreateApplicationRequest(appRequest);
CreateAppResult result = pinpoint.createApp(request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) en GitHub.
## Eliminar una aplicación
Para eliminar una aplicación, llame a la solicitud `deleteApp` de AmazonPinpointClient con un objeto [DeleteAppRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/DeleteAppRequest.html) en el que se indica el nombre de la aplicación que se va a eliminar.
**Importaciones**
```
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
```
**Código de**
```
DeleteAppRequest deleteRequest = new DeleteAppRequest()
.withApplicationId(appID);
pinpoint.deleteApp(deleteRequest);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/DeleteApp.java) en GitHub.
## Más información
+ [Apps](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apps.html) en la Referencia de la API de Amazon Pinpoint
+ [App](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-app.html) en la Referencia de la API de Amazon Pinpoint
# Creación de puntos de conexón en Amazon Pinpoint
Un punto de enlace identifica de forma exclusiva el dispositivo de un usuario al que puede enviar notificaciones de inserción con Amazon Pinpoint. Si la aplicación está habilitada con la compatibilidad con Amazon Pinpoint, registra automáticamente un punto de enlace en Amazon Pinpoint cuando la abre un nuevo usuario. En el siguiente ejemplo se muestra cómo añadir un nuevo punto de enlace mediante programación.
## Crear un punto de conexión
Para crear un punto de enlace en Amazon Pinpoint, proporcione los datos correspondientes a este en un objeto [EndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/EndpointRequest.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
```
A continuación, cree un objeto [UpdateEndpointRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateEndpointRequest.html) con ese objeto EndpointRequest. Por último, pase el objeto UpdateEndpointRequest al método `updateEndpoint` de AmazonPinpointClient.
**Código de**
```
UpdateEndpointRequest updateEndpointRequest = new UpdateEndpointRequest()
.withApplicationId(appId)
.withEndpointId(endpointId)
.withEndpointRequest(endpointRequest);
UpdateEndpointResult updateEndpointResponse = client.updateEndpoint(updateEndpointRequest);
System.out.println("Update Endpoint Response: " + updateEndpointResponse.getMessageBody());
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateEndpoint.java) en GitHub.
## Más información
+ [Añadir punto de conexión](https://docs.aws.amazon.com/pinpoint/latest/developerguide/endpoints.html) en la Guía para desarrolladores de Amazon Pinpoint
+ [Endpoint](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-endpoint.html) en la referencia de la APP de Amazon Pinpoint
# Creación de segmentos en Amazon Pinpoint
Un segmento de usuarios representa un subconjunto de los usuarios basado en ciertas características compartidas, por ejemplo, cuándo abrió el usuario la aplicación por última vez o qué dispositivo utiliza. El siguiente ejemplo muestra cómo definir un segmento de usuarios.
## Crear un segmento
Para crear un segmento en Amazon Pinpoint, defina las dimensiones del segmento en un objeto [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
```
A continuación, establezca el objeto [SegmentDimensions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/SegmentDimensions.html) en una solicitud [WriteSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteSegmentRequest.html) que, a su vez, se utiliza para crear un objeto [CreateSegmentRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/CreateSegmentRequest.html). Después, pase el objeto CreateSegmentRequest al método `createSegment` de AmazonPinpointClient.
**Código de**
```
WriteSegmentRequest writeSegmentRequest = new WriteSegmentRequest()
.withName("MySegment").withDimensions(dimensions);
CreateSegmentRequest createSegmentRequest = new CreateSegmentRequest()
.withApplicationId(appId).withWriteSegmentRequest(writeSegmentRequest);
CreateSegmentResult createSegmentResult = client.createSegment(createSegmentRequest);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) en GitHub.
## Más información
+ [Segmentos de Amazon Pinpoint](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments.html) en la Guía del usuario de Amazon Pinpoint
+ [Crear segmentos](https://docs.aws.amazon.com/pinpoint/latest/developerguide/segments.html) en la Guía para desarrolladores de Amazon Pinpoint.
+ [Segmentos](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segments.html) en la referencia de la API de Amazon Pinpoint
+ [Segmento](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-segment.html) en la Referencia de la API de Amazon Pinpoint
# Creación de campañas en Amazon Pinpoint
Use las campañas para ayudar a aumentar la conexión entre la aplicación y los usuarios. Puede crear una campaña que se dirija a un segmento de usuarios concretos, con mensajes personalizados o promociones especiales. Este ejemplo demuestra cómo crear una campaña estándar que envía una notificación de inserción personalizada a un segmento especificado.
## Crear una campaña
Antes de crear una campaña, debe definir un valor para [Schedule](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Schedule.html) y [Message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/Message.html) y establecer ambos valores en un objeto [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
```
A continuación, cree una campaña en Amazon Pinpoint. Para ello, proporcione el elemento [WriteCampaignRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/WriteCampaignRequest.html) con la configuración de la campaña a un objeto [CreateCampaignRequest](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/pinpoint/model/CreateCampaignRequest.html). Por último, pase el objeto CreateCampaignRequest al método `createCampaign` de AmazonPinpointClient.
**Código de**
```
CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest()
.withApplicationId(appId).withWriteCampaignRequest(request);
CreateCampaignResult result = client.createCampaign(createCampaignRequest);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateApp.java) en GitHub.
## Más información
+ [Campañas de Amazon Pinpoint](https://docs.aws.amazon.com/pinpoint/latest/userguide/campaigns.html) en la Guía del usuario de Amazon Pinpoint
+ [Creación de campañas](https://docs.aws.amazon.com/pinpoint/latest/developerguide/campaigns.html) en la Guía para desarrolladores de Amazon Pinpoint.
+ [Campañas](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaigns.html) en la Referencia de la API de Amazon Pinpoint
+ [Campaña](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign.html) en la Referencia de la API de Amazon Pinpoint
+ [Actividades de campaña](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-activities.html) en la Referencia de la API de Amazon Pinpoint
+ [Versiones de campaña](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-versions.html) en la Referencia de la API de Amazon Pinpoint
+ [Versión de campaña](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-campaign-version.html) en la Referencia de la API de Amazon Pinpoint
# Actualización de canales en Amazon Pinpoint
Un canal define los tipos de plataformas a los que puede entregar mensajes. Este ejemplo muestra cómo utilizar los canales de APNS para enviar un mensaje.
## Actualizar un canal
Para habilitar un canal en Amazon Pinpoint, proporcione un ID de aplicación y un objeto de solicitud del tipo de canal que desea actualizar. En este ejemplo se actualiza el canal de APNS, que requiere el objeto [APNSChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/APNSChannelRequest.html). Defina estos valores en [UpdateApnsChannelRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/pinpoint/model/UpdateApnsChannelRequest.html) y pase el objeto al método `updateApnsChannel` de AmazonPinpointClient.
**Importaciones**
```
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;
```
**Código de**
```
APNSChannelRequest request = new APNSChannelRequest()
.withEnabled(enabled);
UpdateApnsChannelRequest updateRequest = new UpdateApnsChannelRequest()
.withAPNSChannelRequest(request)
.withApplicationId(appId);
UpdateApnsChannelResult result = client.updateApnsChannel(updateRequest);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/pinpoint/src/main/java/com/example/pinpoint/UpdateChannel.java) en GitHub.
## Más información
+ [Canales de Amazon Pinpoint](https://docs.aws.amazon.com/pinpoint/latest/userguide/channels.html) en la Guía del usuario de Amazon Pinpoint
+ [ADM Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-adm-channel.html) en la referencia de la API de Amazon Pinpoint
+ [APNs Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-channel.html) en la referencia de la API de Amazon Pinpoint
+ [APNs Sandbox Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-sandbox-channel.html) en la referencia de la API de Amazon Pinpoint
+ [APNs VoIP Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-channel.html) en la referencia de la API de Amazon Pinpoint
+ [APNs VoIP Sandbox Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-apns-voip-sandbox-channel.html) en la referencia de la API de Amazon Pinpoint
+ [Baidu Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-baidu-channel.html) en la referencia de la API de Amazon Pinpoint
+ [Email Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-email-channel.html) en la referencia de la API de Amazon Pinpoint
+ [GCM Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-gcm-channel.html) en la referencia de la API de Amazon Pinpoint
+ [SMS Channel](https://docs.aws.amazon.com/pinpoint/latest/apireference/rest-api-sms-channel.html) en la referencia de la API de Amazon Pinpoint
# Amazon S3 Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [Amazon S3](https://aws.amazon.com/s3/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Creación, enumeración y eliminación de buckets de Amazon S3](examples-s3-buckets.md)
+ [Realizar operaciones en objetos de Amazon S3](examples-s3-objects.md)
+ [Administración de permisos de acceso de Amazon S3 para buckets y objetos](examples-s3-access-permissions.md)
+ [Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md)
+ [Uso de TransferManager para operaciones de Amazon S3](examples-s3-transfermanager.md)
+ [Configuración de un bucket de Amazon S3 como un sitio web](examples-s3-website-configuration.md)
+ [Usar cifrado del cliente de Amazon S3](examples-crypto.md)
# Creación, enumeración y eliminación de buckets de Amazon S3
Todos los objetos (archivos) de Amazon S3 deben residir en un *bucket*, que representa una colección (contenedor) de objetos. Cada bucket se designa por medio de una *clave* (nombre), que debe ser única. Para obtener información detallada acerca de los buckets y su configuración, consulte [Uso de buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) en la Guía del usuario de Amazon Simple Storage Service.
**nota**
Práctica recomendada
Le recomendamos que habilite la regla del ciclo de vida [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html) en los buckets de Amazon S3.
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina la carga de datos incompleta.
Para obtener más información, consulte [Configuración de ciclo de vida para un bucket con control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) en la Guía del usuario de Amazon S3.
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
## Crear un bucket
Utilizar el método `createBucket` del cliente AmazonS3. Se devuelve el nuevo [bucket](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html). El método `createBucket` producirá una excepción si el bucket ya existe.
**nota**
Para comprobar si un bucket ya existe antes de intentar crear uno con el mismo nombre, llame al método `doesBucketExist`. Este método devolverá `true` si el bucket existe y `false` en caso contrario.
**Importaciones**
```
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;
```
**Código de**
```
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;
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CreateBucket.java) en GitHub.
## Lista de buckets
Utilizar el método `listBucket` del cliente AmazonS3. Si se ejecuta correctamente, se devuelve una lista de [buckets](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Bucket.html).
**Importaciones**
```
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;
```
**Código de**
```
List buckets = s3.listBuckets();
System.out.println("Your {S3} buckets are:");
for (Bucket b : buckets) {
System.out.println("* " + b.getName());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListBuckets.java) en GitHub.
## Eliminar un bucket
Antes de eliminar un bucket de Amazon S3, debe asegurarse de que el bucket está vacío o se producirá un error. Si tiene un [bucket con control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), también debe eliminar todos los objetos con control de versiones asociados al bucket.
**nota**
El [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) incluye cada uno de estos pasos en orden, lo que constituye una solución completa para eliminar un bucket de Amazon S3 y su contenido.
**Topics**
+ [Eliminar objetos de un bucket sin control de versiones antes de eliminarlo](#remove-objects-from-an-unversioned-bucket-before-deleting-it)
+ [Eliminar objetos de un bucket con control de versiones antes de eliminarlo](#remove-objects-from-a-versioned-bucket-before-deleting-it)
+ [Eliminar un bucket vacío](#delete-an-empty-bucket)
### Eliminar objetos de un bucket sin control de versiones antes de eliminarlo
Utilice el método `listObjects` del cliente AmazonS3 para recuperar la lista de objetos y `deleteObject` para eliminar cada uno de ellos.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) en GitHub.
### Eliminar objetos de un bucket con control de versiones antes de eliminarlo
Si utiliza un [bucket con control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html), también tendrá que eliminar todas las versiones almacenadas de los objetos del bucket para poder eliminarlo.
Siguiendo un patrón similar al utilizado para eliminar objetos dentro de un bucket, elimine los objetos con control de versiones utilizando el método `listVersions` del cliente AmazonS3 para mostrar todos los objetos con control de versiones y después `deleteVersion` para eliminar cada uno de ellos.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) en GitHub.
### Eliminar un bucket vacío
Después de eliminar los objetos de un bucket (incluidos los objetos con control de versiones), puede eliminar el propio bucket mediante el método `deleteBucket` del cliente AmazonS3.
**Importaciones**
```
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;
```
**Código de**
```
System.out.println(" OK, bucket ready to delete!");
s3.deleteBucket(bucket_name);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucket.java) en GitHub.
# Realizar operaciones en objetos de Amazon S3
Un objeto de Amazon S3 representa un *archivo* o conjunto de datos. Cada objeto debe residir en un [bucket](examples-s3-buckets.md).
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
**Topics**
+ [Carga de un objeto](#upload-object)
+ [Lista de objetos](#list-objects)
+ [Descarga de un objeto](#download-object)
+ [Copiar, mover o cambiar de nombre objetos](#copy-object)
+ [Eliminar un objeto](#delete-object)
+ [Eliminación de varios objetos a la vez](#delete-objects)
## Carga de un objeto
Utilice el método `putObject` del cliente AmazonS3, proporcionando un nombre de bucket, un nombre de clave y el archivo que se va a cargar. *El bucket debe existir o se producirá un error*.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/PutObject.java) en GitHub.
## Lista de objetos
Para obtener una lista de objetos dentro de un bucket, utilice el método `listObjects` del cliente AmazonS3, proporcionando el nombre de un bucket.
El método `listObjects` devuelve un objeto [ObjectListing](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/ObjectListing.html) que proporciona información acerca de los objetos del bucket. Para mostrar los nombres de objeto (claves), utilice el método `getObjectSummaries` para obtener una lista de objetos [S3ObjectSummary](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectSummary.html), cada uno de los cuales representa un solo objeto del bucket. A continuación, llame a su método `getKey` para recuperar el nombre del objeto.
**Importaciones**
```
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;
```
**Código de**
```
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());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/ListObjects.java) en GitHub.
## Descarga de un objeto
Utilice el método `getObject` del cliente AmazonS3, pasando el nombre del bucket y el objeto que se van a descargar. Si se ejecuta correctamente, el método devuelve un [S3Object](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3Object.html). *El bucket y la clave de objeto especificados deben existir o se producirá un error*.
Puede obtener el contenido del objeto llamando a `getObjectContent` en el `S3Object`. Esto devuelve un [S3ObjectInputStream](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/S3ObjectInputStream.html) que se comporta como un objeto `InputStream` Java estándar.
El siguiente ejemplo descarga un objeto de S3 y guarda su contenido en un archivo (con el mismo nombre que la clave del objeto).
**Importaciones**
```
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;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetObject.java) en GitHub.
## Copiar, mover o cambiar de nombre objetos
Puede copiar un objeto de un bucket en otro mediante el método `copyObject` del cliente AmazonS3. Este método toma el nombre del bucket desde el que se va a realizar la copia, el objeto destino de la copia y el nombre del bucket de destino.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Código de**
```
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!");
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/CopyObject.java) en GitHub.
**nota**
Puede utilizar `copyObject` con [deleteObject](#delete-object) para **mover** o **cambiar de nombre** un objeto. Para ello, primero copie el objeto en un nuevo nombre (puede utilizar el mismo bucket como origen y destino) y, a continuación, elimine el objeto de su antigua ubicación.
## Eliminar un objeto
Utilice el método `deleteObject` del cliente AmazonS3, pasando el nombre del bucket y el objeto que se van a eliminar. *El bucket y la clave de objeto especificados deben existir o se producirá un error*.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObject.java) en GitHub.
## Eliminación de varios objetos a la vez
Con el método `deleteObjects` del cliente AmazonS3, puede eliminar varios objetos del mismo bucket pasando sus nombres al método `` link:sdk-for-java/v1/reference/com/amazonaws/services/s3/model/DeleteObjectsRequest.html.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteObjects.java) en GitHub.
# Administración de permisos de acceso de Amazon S3 para buckets y objetos
Puede utilizar listas de control de acceso (ACL) para los buckets y objetos de Amazon S3 para obtener un control detallado de los recursos de Amazon S3.
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
## Obtener la lista de control de acceso de un bucket
Para obtener la ACL actual de un bucket, llame al método `getBucketAcl` de AmazonS3, pasando el *nombre de bucket* que se desea consultar. Este método devuelve un objeto [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html). Para obtener cada concesión de acceso en la lista, llame a su método `getGrantsAsList`, que devuelve una lista Java estándar de objetos [Grant](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) en GitHub.
## Establecer la lista de control de acceso de un bucket
Para añadir o modificar permisos de la ACL de un bucket, llame al método `setBucketAcl` de AmazonS3. Este método toma un objeto [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html) que contiene una lista de los destinatarios del acceso y los niveles de acceso que se van a establecer.
**Importaciones**
```
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;
```
**Código de**
```
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**
Puede proporcionar directamente el identificador único del destinatario del acceso mediante la clase [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) o puede usar la clase [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html) para definir el destinatario del acceso por correo electrónico, como hemos hecho aquí.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) en GitHub.
## Obtener la lista de control de acceso de un objeto
Para obtener la ACL actual de un objeto, llame al método `getObjectAcl` de AmazonS3, pasando el *nombre de bucket* y el *nombre de objeto* que se desea consultar. Al igual que `getBucketAcl`, este método devuelve un objeto [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html), que puede utilizar para examinar cada uno de los objetos [Grant](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grant.html).
**Importaciones**
```
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;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetAcl.java) en GitHub.
## Establecer la lista de control de acceso de un objeto
Para añadir o modificar permisos para la ACL de un objeto, llame al método `setObjectAcl` de AmazonS3. Este método toma un objeto [AccessControlList](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/AccessControlList.html) que contiene una lista de los destinatarios del acceso y los niveles de acceso que se van a establecer.
**Importaciones**
```
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;
```
**Código de**
```
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**
Puede proporcionar directamente el identificador único del destinatario del acceso mediante la clase [Grantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/Grantee.html) o puede usar la clase [EmailAddressGrantee](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/EmailAddressGrantee.html) para definir el destinatario del acceso por correo electrónico, como hemos hecho aquí.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetAcl.java) en GitHub.
## Más información
+ [GET Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html) en la referencia de la API de Amazon S3
+ [PUT Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) en la referencia de la API de Amazon S3
+ [GET Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html) en la referencia de la API de Amazon S3
+ [PUT Object acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html) en la referencia de la API de Amazon S3
# Administración del acceso a los buckets de Amazon S3 mediante políticas de buckets
Puede definir, obtener o eliminar una *política de bucket* para administrar el acceso a los buckets de Amazon S3.
## Definir una política de bucket
Puede definir la política de bucket para un determinado bucket de S3:
+ Llamando al `setBucketPolicy` de AmazonS3 client y proporcionándole un [SetBucketPolicyRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/SetBucketPolicyRequest.html)
+ Estableciendo la política directamente mediante la sobrecarga `setBucketPolicy`, que toma un nombre de bucket y el texto de la política (en formato JSON)
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.policy.Policy;
import com.amazonaws.auth.policy.Principal;
```
**Código de**
```
s3.setBucketPolicy(bucket_name, policy_text);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
### Usar la clase Class para generar o validar una política
Cuando proporciona una política de bucket a `setBucketPolicy`, puede hacer lo siguiente:
+ Especificar la política directamente como una cadena de texto con formato JSON
+ Crear la política con la clase [Policy](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/policy/Policy.html)
Si utiliza la clase `Policy`, no tendrá que preocuparse de formatear correctamente la cadena de texto. Para obtener el texto de la política JSON de la clase `Policy`, utilice su método `toJson`.
**Importaciones**
```
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;
```
**Código de**
```
new Statement(Statement.Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new Resource(
"{region-arn}s3:::" + bucket_name + "/*")));
return bucket_policy.toJson();
```
La clase `Policy` proporciona también un método `fromJson` que intenta crear una política mediante una cadena JSON que se haya pasado. El método valida la cadena para garantizar que el texto se pueda transformar en una estructura de política válida y dará un error `IllegalArgumentException` si el texto de la política no es válido.
```
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());
}
```
Puede utilizar esta técnica para validar previamente una política leída de un archivo o por otros medios.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetBucketPolicy.java) en GitHub.
## Obtener una política de bucket
Para recuperar la política de un bucket de Amazon S3, llame al método `getBucketPolicy` del AmazonS3 client pasando el nombre del bucket del que se va a obtener la política.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Código de**
```
try {
BucketPolicy bucket_policy = s3.getBucketPolicy(bucket_name);
policy_text = bucket_policy.getPolicyText();
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Si el bucket especificado no existe, si no tiene acceso a él o si no tiene una política de bucket, se produce la excepción `AmazonServiceException`.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetBucketPolicy.java) en GitHub.
## Eliminar una política de bucket
Para eliminar una política de bucket, llame al `deleteBucketPolicy` de AmazonS3 client proporcionando el nombre del bucket.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
```
**Código de**
```
try {
s3.deleteBucketPolicy(bucket_name);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
```
Este método se ejecuta correctamente aunque el bucket aún no tenga una política. Si especifica el nombre de un bucket que no existe o si no tiene acceso al bucket, se produce la excepción `AmazonServiceException`.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteBucketPolicy.java) en GitHub.
## Más información
+ [Información general del lenguaje de la política de acceso](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html) en la Guía del usuario de Amazon Simple Storage Service
+ [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html) en la Guía del usuario de Amazon Simple Storage Service
# Uso de TransferManager para operaciones de Amazon S3
Puede utilizar la clase AWS SDK para Java TransferManager para transferir archivos de forma fiable desde el entorno local a Amazon S3 y para copiar objetos de una ubicación de S3 a otra. `TransferManager` puede obtener el progreso de la transferencia y detener o reanudar las cargas y descargas.
**nota**
Práctica recomendada
Le recomendamos que habilite la regla del ciclo de vida [AbortIncompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html) en los buckets de Amazon S3.
Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completen en un número especificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula la carga y, a continuación, elimina la carga de datos incompleta.
Para obtener más información, consulte [Configuración de ciclo de vida para un bucket con control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-bucket-with-versioning.html) en la Guía del usuario de Amazon S3.
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
## Carga de archivos y directorios
TransferManager puede cargar archivos, listas de archivos y directorios en cualquier bucket de Amazon S3 [que haya creado previamente](examples-s3-buckets.md#create-bucket).
**Topics**
+ [Carga de un solo archivo](#transfermanager-upload-file)
+ [Carga de una lista de archivos](#transfermanager-upload-file-list)
+ [Carga de un directorio](#transfermanager-upload-directory)
### Carga de un solo archivo
Llame al método `upload` de TransferManager, proporcionando un nombre de bucket de Amazon S3, un nombre de clave (objeto) y un objeto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) Java estándar que represente el archivo que se va a cargar.
**Importaciones**
```
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;
```
**Código de**
```
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();
```
El método `upload` regresa *inmediatamente*, proporcionando el objeto `Upload` que se va a usar para comprobar el estado de la transferencia o esperar a que se complete.
Consulte [Esperar a que se complete una transferencia](#transfermanager-wait-for-completion) para obtener información sobre cómo usar `waitForCompletion` para completar correctamente una transferencia antes de llamar al método `shutdownNow` de TransferManager. Mientras espera a que se complete la transferencia, puede buscar o atender las actualizaciones sobre su estado y su progreso. Consulte [Obtener el estado y el progreso de una transferencia](#transfermanager-get-status-and-progress) para obtener más información.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) en GitHub.
### Carga de una lista de archivos
Para cargar varios archivos en una sola operación, llame al método `uploadFileList` de TransferManager, proporcionando lo siguiente:
+ Un nombre de bucket de Amazon S3
+ Un *prefijo de clave* para adjuntarlo a los nombres de los objetos creados (la ruta en el bucket en el que se colocan los objetos)
+ Un objeto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) que represente el directorio relativo desde el que crean las rutas de archivo
+ Un objeto [List](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/List.html) que contenga el conjunto de objetos [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) que se van a cargar
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte [Esperar a que se complete una transferencia](#transfermanager-wait-for-completion) para obtener información sobre cómo usar `waitForCompletion` para completar correctamente una transferencia antes de llamar al método `shutdownNow` de TransferManager. Mientras espera a que se complete la transferencia, puede buscar o atender las actualizaciones sobre su estado y su progreso. Consulte [Obtener el estado y el progreso de una transferencia](#transfermanager-get-status-and-progress) para obtener más información.
El objeto [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html) devuelto por `uploadFileList` se puede usar para consultar el estado o el progreso de la transferencia. Consulte [Sondear el progreso actual de una transferencia](#transfermanager-get-progress-polling) y [Obtener el progreso de una transferencia con ProgressListener](#transfermanager-progress-listener) para obtener más información.
También puede usar el método `MultipleFileUpload` de `getSubTransfers` para obtener los distintos objetos `Upload` para cada archivo que se va a transferir. Para obtener más información, consulte [Obtener el progreso de las transferencias secundarias](#transfermanager-get-subtransfer-progress).
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) en GitHub.
### Carga de un directorio
Puede utilizar el método `uploadDirectory` de TransferManager para cargar un directorio de archivos completo, con la opción de copiar archivos en subdirectorios recursivamente. Proporciona el nombre de un bucket de Amazon S3, un prefijo de clave de S3, un objeto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) que representa el directorio local donde se va a realizar la copia y un valor `boolean` que indica si desea copiar los subdirectorios recursivamente (*true* o *false*).
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte [Esperar a que se complete una transferencia](#transfermanager-wait-for-completion) para obtener información sobre cómo usar `waitForCompletion` para completar correctamente una transferencia antes de llamar al método `shutdownNow` de TransferManager. Mientras espera a que se complete la transferencia, puede buscar o atender las actualizaciones sobre su estado y su progreso. Consulte [Obtener el estado y el progreso de una transferencia](#transfermanager-get-status-and-progress) para obtener más información.
El objeto [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html) devuelto por `uploadFileList` se puede usar para consultar el estado o el progreso de la transferencia. Consulte [Sondear el progreso actual de una transferencia](#transfermanager-get-progress-polling) y [Obtener el progreso de una transferencia con ProgressListener](#transfermanager-progress-listener) para obtener más información.
También puede usar el método `MultipleFileUpload` de `getSubTransfers` para obtener los distintos objetos `Upload` para cada archivo que se va a transferir. Para obtener más información, consulte [Obtener el progreso de las transferencias secundarias](#transfermanager-get-subtransfer-progress).
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrUpload.java) en GitHub.
## Descarga de archivos o directorios
Utilice la clase TransferManager para descargar un solo archivo (objeto Amazon S3) o un directorio (el nombre de un bucket de Amazon S3 seguido de un prefijo de objeto) de Amazon S3.
**Topics**
+ [Descarga de un solo archivo](#transfermanager-download-file)
+ [Descarga de un directorio](#tranfermanager-download-directory)
### Descarga de un solo archivo
Utilice el método `download` de TransferManager, proporcionando el nombre del bucket de Amazon S3 que contiene el objeto que desea descargar, la clave (nombre de objeto) y un objeto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) que represente el archivo que va a crear en su sistema local.
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte [Esperar a que se complete una transferencia](#transfermanager-wait-for-completion) para obtener información sobre cómo usar `waitForCompletion` para completar correctamente una transferencia antes de llamar al método `shutdownNow` de TransferManager. Mientras espera a que se complete la transferencia, puede buscar o atender las actualizaciones sobre su estado y su progreso. Consulte [Obtener el estado y el progreso de una transferencia](#transfermanager-get-status-and-progress) para obtener más información.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) en GitHub.
### Descarga de un directorio
Para descargar un conjunto de archivos que comparten un prefijo de clave común (similar a un directorio en un sistema de archivos) desde Amazon S3, utilice el método `downloadDirectory` de TransferManager. El método toma el nombre del bucket de Amazon S3 que contiene los objetos que desea descargar, el prefijo de objeto compartido por todos los objetos y un objeto [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) que representa el directorio en el que se van a descargar los archivos en su sistema local. Si el directorio designado aún no existe, se creará.
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte [Esperar a que se complete una transferencia](#transfermanager-wait-for-completion) para obtener información sobre cómo usar `waitForCompletion` para completar correctamente una transferencia antes de llamar al método `shutdownNow` de TransferManager. Mientras espera a que se complete la transferencia, puede buscar o atender las actualizaciones sobre su estado y su progreso. Consulte [Obtener el estado y el progreso de una transferencia](#transfermanager-get-status-and-progress) para obtener más información.
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrDownload.java) en GitHub.
## Copia de objetos
Para copiar un objeto en un bucket de S3 en otro, utilice el método `copy` de TransferManager.
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrCopy.java) en GitHub.
## Esperar a que se complete una transferencia
Si la aplicación (o subproceso) se puede bloquear hasta que se complete la transferencia, puede utilizar el método `waitForCompletion` de la interfaz [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html) para aplicar un bloqueo hasta que se complete la transferencia o se produzca una excepción.
```
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);
}
```
Puede obtener el progreso de las transferencias si sondea eventos *antes* de llamar a `waitForCompletion`, implementar un mecanismo de sondeo en un subproceso distinto o recibir actualizaciones sobre el progreso de forma asíncrona utilizando un [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html).
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) en GitHub.
## Obtener el estado y el progreso de una transferencia
Cada una de las clases devueltas por los métodos `upload*`, `download*` y `copy` de TransferManager devuelve una instancia de una de las siguientes clases, en función de si se trata de una operación en un solo archivo o en varios.
****
| Clase | Devuelta por |
| --- | --- |
| [Copiar](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Copy.html) | `copy` |
| [Descarga de](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` |
| [Cargar](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` |
Todas estas clases implementan la interfaz [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html). `Transfer` proporciona métodos útiles para obtener el progreso de una transferencia, detener o reanudar la transferencia y obtener el estado actual o final de la transferencia.
**Topics**
+ [Sondear el progreso actual de una transferencia](#transfermanager-get-progress-polling)
+ [Obtener el progreso de una transferencia con ProgressListener](#transfermanager-progress-listener)
+ [Obtener el progreso de las transferencias secundarias](#transfermanager-get-subtransfer-progress)
### Sondear el progreso actual de una transferencia
Este bucle muestra el progreso de una transferencia, examina su progreso actual mientras se ejecuta y, cuando se completa, muestra su estado final.
**Importaciones**
```
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;
```
**Código de**
```
// 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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) en GitHub.
### Obtener el progreso de una transferencia con ProgressListener
Puede asociar [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html) a cualquier transferencia mediante el método `addProgressListener` de la interfaz [Transfer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Transfer.html).
Un [ProgressListener](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressListener.html) requiere solo un método `progressChanged`, que toma un objeto [ProgressEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/event/ProgressEvent.html). Puede utilizar el objeto para obtener el total de bytes de la operación llamando a su método `getBytes` y el número de bytes que se han transferido hasta el momento llamando a `getBytesTransferred`.
**Importaciones**
```
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;
```
**Código de**
```
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();
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) en GitHub.
### Obtener el progreso de las transferencias secundarias
La clase [MultipleFileUpload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/MultipleFileUpload.html) puede devolver información sobre sus transferencias secundarias llamando a su método `getSubTransfers`. Devuelve una [colección](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html) no modificable de objetos [Upload](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/Upload.html) que proporcionan el estado y el progreso de cada transferencia secundaria.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/XferMgrProgress.java) en GitHub.
## Más información
+ [Claves de objeto](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html) en la Guía del usuario de Amazon Simple Storage Service
# Configuración de un bucket de Amazon S3 como un sitio web
Puede configurar un bucket de Amazon S3 para que se comporte como un sitio web. Para ello, debe establecer la configuración de su sitio web.
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
## Establecimiento de la configuración de sitio web de un bucket
Para establecer la configuración de sitio web de un bucket de Amazon S3, llame al método `setWebsiteConfiguration` de AmazonS3 con el nombre del bucket para el que se va a establecer la configuración y un objeto [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html) que contenga la configuración de sitio web del bucket.
Es *obligatorio* establecer un documento de índice; todos los demás parámetros son opcionales.
**Importaciones**
```
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;
```
**Código de**
```
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**
El establecimiento de la configuración de sitio web no modifica los permisos de acceso del bucket. Para que los archivos estén visibles en la web, también deberá definir una *política de bucket* que permita el acceso de lectura pública a los archivos del bucket. Para obtener más información, consulte [Administración del acceso a buckets de Amazon S3 mediante políticas de buckets](examples-s3-bucket-policies.md).
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/SetWebsiteConfiguration.java) en GitHub.
## Obtener la configuración de sitio web de un bucket
Para obtener la configuración de sitio web de un bucket de Amazon S3, llame al método `getWebsiteConfiguration` de AmazonS3 con el nombre del bucket para el que desea recuperar la configuración.
La configuración se devolverá como un objeto [BucketWebsiteConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/BucketWebsiteConfiguration.html). Si no hay ninguna configuración de sitio web para el bucket, se devolverá `null`.
**Importaciones**
```
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;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/GetWebsiteConfiguration.java) en GitHub.
## Eliminar la configuración de sitio web de un bucket
Para eliminar la configuración de sitio web de un bucket de Amazon S3, llame al método `deleteWebsiteConfiguration` de AmazonS3 con el nombre del bucket del que se va a eliminar la configuración.
**Importaciones**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/DeleteWebsiteConfiguration.java) en GitHub.
## Más información
+ [Sitio web PUT Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) en la referencia de la API de Amazon S3
+ El [sitio web GET Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETwebsite.html) en la referencia de la API de Amazon S3
+ [Sitio web DELETE Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html) en la referencia de la API de Amazon S3
# Usar cifrado del cliente de Amazon S3
El cifrado de los datos con el cliente Amazon S3 para este fin es una forma de proporcionar una capa de protección adicional para la información confidencial que almacena en Amazon S3. Los ejemplos de esta sección demuestran cómo crear y configurar el cliente de cifrado de Amazon S3 para la aplicación.
Si es la primera vez que utiliza la criptografía, consulte [Conceptos básicos de criptografía](https://docs.aws.amazon.com/kms/latest/developerguide/crypto-intro.html) en la Guía para desarrolladores de AWS KMS para obtener información general básica sobre los términos y los algoritmos de criptografía. Para obtener información sobre la compatibilidad con la criptografía en todos los SDK de AWS, consulte [Soporte de SDK de AWS para cifrado del cliente para Amazon S3](https://docs.aws.amazon.com/general/latest/gr/aws_sdk_cryptography.html) en la Referencia general de Amazon Web Services.
**nota**
En estos ejemplos de código se presupone que conoce la información que se describe en [Uso del AWS SDK para Java](basics.md) y que ha configurado credenciales de AWS predeterminadas mediante la información de [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md).
Si utiliza la versión 1.11.836 o una anterior del AWS SDK para Java, consulte [Migración de clientes de cifrado de Amazon S3](s3-encryption-migration.md) para obtener información sobre la migración de sus aplicaciones a versiones posteriores. Si no puede migrar, consulte [este ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/s3/src/main/java/aws/example/s3/S3Encrypt.java) en GitHub.
De lo contrario, si utiliza la versión 1.11.837 o posterior de AWS SDK para Java, explore los temas de ejemplo que se enumeran a continuación para usar el cifrado del cliente de Amazon S3.
**Topics**
+ [Cifrado del cliente de Amazon S3 con claves maestras de cliente](examples-crypto-masterkey.md)
+ [Cifrado del cliente Amazon S3 con claves administradas por AWS KMS](examples-crypto-kms.md)
# Cifrado del cliente de Amazon S3 con claves maestras de cliente
Los siguientes ejemplos utilizan la clase [AmazonS3EncryptionClientV2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) para crear un cliente Amazon S3 que tenga habilitado el cifrado del cliente. Una vez habilitado, los objetos que se cargan en Amazon S3 con este cliente se cifrarán. Cualquier objeto que se obtenga de Amazon S3 con este cliente se descifrará automáticamente.
**nota**
En los siguientes ejemplos se muestra cómo utilizar el cifrado del cliente de Amazon S3 con claves maestras administradas por el cliente. Para obtener información sobre cómo usar el cifrado con las claves administradas de AWS KMS, consulte [Cifrado del cliente de Amazon S3 con claves administradas por AWS KMS](examples-crypto-kms.md).
Puede elegir entre dos modos de cifrado al activar el cifrado Amazon S3 del cliente: autenticación estricta o autenticación. En las secciones siguientes se muestran cómo habilitar cada uno de estos tipos. Para saber qué algoritmos utiliza cada modo, consulte la definición de [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html).
## Importaciones requeridas
Importe las clases siguientes para estos ejemplos.
**Importaciones**
```
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;
```
## Cifrado de autenticado estricto
El cifrado de autenticado estricto es el modo predeterminado si no se especifica `CryptoMode`.
Para habilitar de manera explícita este modo, especifique el valor `StrictAuthenticatedEncryption` en el método `withCryptoConfiguration`.
**nota**
Para utilizar el cifrado autenticado del lado del cliente, debe incluir el archivo [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/) más reciente en el classpath de la aplicación.
**Código de**
```
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");
```
## Modo de cifrado autenticado
Al utilizar el modo `AuthenticatedEncryption`, se aplica un algoritmo de encapsulamiento de clave mejorado durante el cifrado. Cuando se descifra en este modo, el algoritmo puede verificar la integridad del objeto descifrado e iniciar una excepción si la comprobación falla. Para más detalles sobre cómo funciona el cifrado autenticado, consulte la entrada del blog [Cifrado autenticado del cliente Amazon S3](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption).
**nota**
Para utilizar el cifrado autenticado del lado del cliente, debe incluir el archivo [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/) más reciente en el classpath de la aplicación.
Para habilitar este modo, especifique el valor `AuthenticatedEncryption` en el método `withCryptoConfiguration`.
**Código de**
```
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");
```
# Cifrado del cliente Amazon S3 con claves administradas por AWS KMS
Los siguientes ejemplos utilizan la clase [AmazonS3EncryptionClientV2Builder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/AmazonS3EncryptionClientV2Builder.html) para crear un cliente Amazon S3 que tenga habilitado el cifrado del cliente. Una vez configurado, los objetos que se cargan en Amazon S3 con este cliente se cifrarán. Cualquier objeto que se obtenga de Amazon S3 con este cliente, se descifrará automáticamente.
**nota**
En los siguientes ejemplos se muestra cómo utilizar el cifrado del cliente Amazon S3 con claves administradas por AWS KMS. Para obtener información sobre cómo utilizar el cifrado con sus propias claves, consulte [Cifrado del cliente Amazon S3 con claves maestras de cliente](examples-crypto-masterkey.md).
Puede elegir entre dos modos de cifrado al activar el cifrado Amazon S3 del cliente: autenticación estricta o autenticación. En las secciones siguientes se muestran cómo habilitar cada uno de estos tipos. Para saber qué algoritmos utiliza cada modo, consulte la definición de [CryptoMode](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/model/CryptoMode.html).
## Importaciones requeridas
Importe las clases siguientes para estos ejemplos.
**Importaciones**
```
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;
```
## Cifrado de autenticado estricto
El cifrado de autenticado estricto es el modo predeterminado si no se especifica `CryptoMode`.
Para habilitar de manera explícita este modo, especifique el valor `StrictAuthenticatedEncryption` en el método `withCryptoConfiguration`.
**nota**
Para utilizar el cifrado autenticado del lado del cliente, debe incluir el archivo [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/) más reciente en el classpath de la aplicación.
**Código de**
```
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));
```
Llame al método `putObject` en el cliente de cifrado de Amazon S3 para cargar objetos.
**Código de**
```
s3Encryption.putObject(bucket_name, ENCRYPTED_KEY3, "This is the 3rd content to encrypt with a key created in the {console}");
```
Para recuperar el objeto, puede utilizar el mismo cliente. Este ejemplo llama al método `getObjectAsString` para recuperar la cadena que se almacenó.
**Código de**
```
System.out.println(s3Encryption.getObjectAsString(bucket_name, ENCRYPTED_KEY3));
```
## Modo de cifrado autenticado
Al utilizar el modo `AuthenticatedEncryption`, se aplica un algoritmo de encapsulamiento de clave mejorado durante el cifrado. Cuando se descifra en este modo, el algoritmo puede verificar la integridad del objeto descifrado e iniciar una excepción si la comprobación falla. Para más detalles sobre cómo funciona el cifrado autenticado, consulte la entrada del blog [Cifrado autenticado del cliente Amazon S3](https://aws.amazon.com/blogs/developer/amazon-s3-client-side-authenticated-encryption).
**nota**
Para utilizar el cifrado autenticado del lado del cliente, debe incluir el archivo [Bouncy Castle jar](https://www.bouncycastle.org/download/bouncy-castle-java/) más reciente en el classpath de la aplicación.
Para habilitar este modo, especifique el valor `AuthenticatedEncryption` en el método `withCryptoConfiguration`.
**Código de**
```
AmazonS3EncryptionV2 s3Encryption = AmazonS3EncryptionClientV2Builder.standard()
.withRegion(Regions.US_WEST_2)
.withCryptoConfiguration(new CryptoConfigurationV2().withCryptoMode((CryptoMode.AuthenticatedEncryption)))
.withEncryptionMaterialsProvider(new KMSEncryptionMaterialsProvider(keyId))
.build();
```
## Configuración del cliente AWS KMS
El cliente de cifrado Amazon S3 crea un cliente AWS KMS de forma predeterminada, a menos que se especifique uno de forma explícita.
Para establecer la región de este cliente AWS KMS creado automáticamente, defina el `awsKmsRegion`.
**Código de**
```
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();
```
Si lo prefiere, puede utilizar su propio cliente AWS KMS para inicializar el cliente de cifrado.
**Código de**
```
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 Ejemplos de usando la AWS SDK para Java
En esta sección se proporcionan ejemplos de programación de [Amazon SQS](https://aws.amazon.com/sqs/) mediante [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
**nota**
Los ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Uso de colas de mensajes de Amazon SQS](examples-sqs-message-queues.md)
+ [Envío, recepción y eliminación de mensajes de Amazon SQS](examples-sqs-messages.md)
+ [Habilitar sondeos largos para las colas de mensajes de Amazon SQS](examples-sqs-long-polling.md)
+ [Configuración del tiempo de espera de visibilidad en Amazon SQS](examples-sqs-visibility-timeout.md)
+ [Uso de colas de mensajes fallidos en Amazon SQS](examples-sqs-dead-letter-queues.md)
# Uso de colas de mensajes de Amazon SQS
Una *cola de mensajes* es el contenedor lógico utilizado para enviar mensajes de forma fiable en Amazon SQS. Existen dos tipos de colas: *estándar* y *primero en entrar, primero en salir* (FIFO). Para obtener más información sobre las colas y las diferencias entre estos tipos, consulte la [Guía para desarrolladores de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/).
En este tema se describe cómo crear, mostrar, eliminar y obtener la dirección URL de un cola de Amazon SQS mediante AWS SDK para Java.
## Creación de una cola
Use el método `createQueue` del cliente AmazonSQS, proporcionando un objeto [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html) que describa los parámetros de la cola.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Puede utilizar el formato simplificado `createQueue`, que solo necesita el nombre de una cola, para crear una cola estándar.
```
sqs.createQueue("MyQueue" + new Date().getTime());
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) en GitHub.
## Mostrar colas
Para enumerar las colas de Amazon SQS de su cuenta, llame al método `listQueues` del cliente AmazonSQS.
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesResult;
```
**Código de**
```
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);
}
```
El uso de la sobrecarga `listQueues` sin parámetros devuelve *todas las colas*. Puede filtrar los resultados devueltos pasando un objeto `ListQueuesRequest`.
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.ListQueuesRequest;
```
**Código de**
```
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);
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) en GitHub.
## Obtener la URL de una cola
Llame al método `getQueueUrl` del cliente AmazonSQS.
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Código de**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
String queue_url = sqs.getQueueUrl(QUEUE_NAME).getQueueUrl();
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) en GitHub.
## Eliminar una cola
Proporcione la [URL](#sqs-get-queue-url) de la cola al método del cliente AmazonSQS.
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Código de**
```
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.deleteQueue(queue_url);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/UsingQueues.java) en GitHub.
## Más información
+ [Cómo funcionan las colas de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) en la Guía para desarrolladores de Amazon SQS
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) en la Referencia de la API de Amazon SQS
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html) en la referencia de la API de Amazon SQS
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html) en la Referencia de la API de Amazon SQS
+ [DeleteQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueues.html) en la referencia de la API de Amazon SQS
# Envío, recepción y eliminación de mensajes de Amazon SQS
En este tema se describe cómo enviar, recibir y eliminar mensajes de Amazon SQS. Los mensajes se envían siempre a través de una [cola de SQS](examples-sqs-message-queues.md).
## Enviar un mensaje
Añada un único mensaje a una cola de Amazon SQS llamando al método `sendMessage` del cliente AmazonSQS. Proporcione un objeto [SendMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageRequest.html) que contenga la [URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la cola, el cuerpo del mensaje y el valor de retraso opcional (en segundos).
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.SendMessageRequest;
```
**Código de**
```
SendMessageRequest send_msg_request = new SendMessageRequest()
.withQueueUrl(queueUrl)
.withMessageBody("hello world")
.withDelaySeconds(5);
sqs.sendMessage(send_msg_request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) en GitHub.
### Enviar varios mensajes a la vez
Puede enviar más de un mensaje en una única solicitud. Para enviar varios mensajes, utilice el método `sendMessageBatch` del cliente AmazonSQS, que toma un objeto [SendMessageBatchRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequest.html) con la URL de la cola y una lista de mensajes (un objeto [SendMessageBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SendMessageBatchRequestEntry.html) para cada uno) que se van a enviar. También puede definir un valor de retraso opcional para cada mensaje.
**Importaciones**
```
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
import com.amazonaws.services.sqs.model.SendMessageBatchRequestEntry;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) en GitHub.
## Recibir mensajes
Recupere todos los mensajes que se encuentran actualmente en la cola llamando al método `receiveMessage` del cliente AmazonSQS, pasando la URL de la cola. Los mensajes se devuelven como una lista de objetos [Message](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/Message.html).
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
import com.amazonaws.services.sqs.model.SendMessageBatchRequest;
```
**Código de**
```
List messages = sqs.receiveMessage(queueUrl).getMessages();
```
## Eliminar mensajes después de su recepción
Tras recibir un mensaje y procesar su contenido, elimine el mensaje de la cola enviando el identificador de recepción y la URL de la cola del mensaje al método `deleteMessage` de AmazonSQS.
**Código de**
```
for (Message m : messages) {
sqs.deleteMessage(queueUrl, m.getReceiptHandle());
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/SendReceiveMessages.java) en GitHub.
## Más información
+ [Cómo funcionan las colas de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-how-it-works.html) en la Guía para desarrolladores de Amazon SQS
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html) en la referencia de la API de Amazon SQS
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html) en la referencia de la API de Amazon SQS
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) en la Referencia de la API de Amazon SQS
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html) en la Referencia de la API de Amazon SQS
# Habilitar sondeos largos para las colas de mensajes de Amazon SQS
Amazon SQS utiliza el *sondeo corto* de forma predeterminada; consulta únicamente un subconjunto de los servidores (en función de una distribución aleatoria ponderada) para determinar si hay algún mensaje disponible para su inclusión en la respuesta.
El sondeo largo ayuda a reducir el costo de uso de Amazon SQS al reducir el número de respuestas vacías (cuando no hay ningún mensaje disponible para devolver como respuesta a una solicitud ReceiveMessage enviada a una cola de Amazon SQS) y eliminar falsas respuestas vacías.
**nota**
Puede definir una frecuencia de sondeo largo de *1-20 segundos*.
## Habilitar el sondeo largo al crear una cola
Para habilitar el sondeo largo al crear una cola de Amazon SQS, establezca el atributo `ReceiveMessageWaitTimeSeconds` en el objeto [CreateQueueRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/CreateQueueRequest.html) antes de llamar al método `createQueue` de la clase AmazonSQS.
**Importaciones**
```
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;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) en GitHub.
## Habilitar el sondeo largo en una cola existente
Además de habilitar el sondeo largo al crear una cola, también puede habilitarlo en una cola existente estableciendo `ReceiveMessageWaitTimeSeconds` en [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html) antes de llamar al método `setQueueAttributes` de la clase AmazonSQS.
**Importaciones**
```
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Código de**
```
SetQueueAttributesRequest set_attrs_request = new SetQueueAttributesRequest()
.withQueueUrl(queue_url)
.addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
sqs.setQueueAttributes(set_attrs_request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) en GitHub.
## Habilitar el sondeo largo al recibir un mensaje
Puede habilitar el sondeo largo al recibir un mensaje estableciendo el tiempo de espera en segundos en el objeto [ReceiveMessageRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ReceiveMessageRequest.html) que proporciona al método `receiveMessage` de la clase AmazonSQS.
**nota**
Debe asegurarse de que el tiempo de espera de la solicitud del cliente de AWS sea mayor que el tiempo del sondeo largo (20 segundos) para que no se agote el tiempo de espera de sus solicitudes `receiveMessage` mientras espera al siguiente evento de sondeo.
**Importaciones**
```
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
```
**Código de**
```
ReceiveMessageRequest receive_request = new ReceiveMessageRequest()
.withQueueUrl(queue_url)
.withWaitTimeSeconds(20);
sqs.receiveMessage(receive_request);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/LongPolling.java) en GitHub.
## Más información
+ [Amazon SQSPolíticas de claves](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html) en la Guía para desarrolladores de Amazon SQS
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) en la Referencia de la API de Amazon SQS
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) en la Referencia de la API de Amazon SQS
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html) en la Referencia de la API de Amazon SQS
# Configuración del tiempo de espera de visibilidad en Amazon SQS
Cuando se recibe un mensaje en Amazon SQS, este permanece en la cola hasta que se elimina a fin de garantizar su recepción. Un mensaje que se ha recibido, pero no se ha eliminado, estará disponible en las solicitudes posteriores después de un determinado *tiempo de espera de visibilidad* para ayudar a evitar que el mensaje se reciba más de una vez antes de que pueda procesarse y eliminarse.
**nota**
Cuando se utilizan [colas estándar](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html), el tiempo de espera de visibilidad no es una garantía de que un mensaje no se reciba dos veces. Si utiliza una cola estándar, asegúrese de que el código pueda tratar aquellas situaciones en las que el mismo mensaje se entrega más de una vez.
## Configuración del tiempo de espera de visibilidad de los mensajes para un solo mensaje
Cuando haya recibido un mensaje, puede modificar su tiempo de espera de visibilidad pasando su identificador de recepción en el objeto [ChangeMessageVisibilityRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityRequest.html) que pasa al método `changeMessageVisibility` de AmazonSQS class.
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) en GitHub.
## Configuración del tiempo de espera de visibilidad de los mensajes para varios mensajes a la vez
Para configurar el tiempo de espera de visibilidad para varios mensajes, cree una lista de objetos [ChangeMessageVisibilityBatchRequestEntry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/ChangeMessageVisibilityBatchRequestEntry.html), cada uno con un ID de cadena y un identificador de recepción únicos. A continuación, pase la lista al método Amazon SQS de la clase del cliente de `changeMessageVisibilityBatch`.
**Importaciones**
```
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;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/VisibilityTimeout.java) en GitHub.
## Más información
+ [Tiempo de espera de visibilidad](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html) en la Guía para desarrolladores de Amazon SQS
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html) en la Referencia de la API de Amazon SQS
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html) en la Referencia de la API de Amazon SQS
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) en la Referencia de la API de Amazon SQS
+ [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibility.html) en la Referencia de la API de Amazon SQS
+ [ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html) en la Referencia de la API de Amazon SQS
# Uso de colas de mensajes fallidos en Amazon SQS
Amazon SQS añade compatibilidad para las *colas de mensajes fallidos*. Una cola de mensajes fallidos es una cola a la que otras pueden enviar mensajes que no se pueden procesar correctamente. Puede apartar y aislar estos mensajes en la cola de mensajes fallidos para determinar por qué no se procesaron correctamente.
## Creación de una cola de mensajes fallidos
Una cola de mensajes fallidos se crea de la misma forma que una cola normal, pero con las siguientes restricciones:
+ Una cola de mensajes fallidos debe ser el mismo tipo de cola (FIFO o estándar) que la cola de origen.
+ Una cola de mensajes fallidos se debe crear con la misma cuenta y región de Cuenta de AWS que la cola de origen.
Aquí creamos dos colas de Amazon SQS idénticas, una de los cuales actuará como la cola de mensajes fallidos:
**Importaciones**
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.AmazonSQSException;
```
**Código de**
```
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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) en GitHub.
## Designación de una cola de mensajes fallidos para una cola de origen
Para designar una cola de mensajes fallidos, primero debe crear una *política de redireccionamiento* y, a continuación, configurar la política en los atributos de la cola. Una política de redireccionamiento se especifica en JSON e indica el ARN de la cola de mensajes fallidos y el número máximo de veces que se puede recibir y no procesar el mensaje antes de que se envíe a la cola de mensajes fallidos.
Para establecer la política de redireccionamiento de la cola de origen, llame al método de la clase de `setQueueAttributes` de AmazonSQS con un objeto [SetQueueAttributesRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/sqs/model/SetQueueAttributesRequest.html) para el que haya establecido el atributo `RedrivePolicy` con su política de redireccionamiento JSON.
**Importaciones**
```
import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;
import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;
```
**Código de**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/java/example_code/sqs/src/main/java/aws/example/sqs/DeadLetterQueues.java) en GitHub.
## Más información
+ [Uso de colas de cartas muertas de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) en la Guía para desarrolladores de Amazon SQS
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html) en la Referencia de la API de Amazon SQS
# Amazon SWF Ejemplos de usando la AWS SDK para Java
[Amazon SWF](https://aws.amazon.com/swf/) es un servicio de administración de flujos de trabajo que ayuda a los desarrolladores a crear y escalar flujos de trabajo distribuidos que pueden tener pasos paralelos o secuenciales compuestos de actividades, flujos de trabajo secundarios o incluso tareas [Lambda](https://aws.amazon.com/lambda/).
Existen dos maneras de trabajar con Amazon SWF mediante AWS SDK para Java: utilizando el objeto *client* de SWF o mediante AWS Flow Framework para Java. AWS Flow Framework es más difícil de configurar inicialmente, ya que hace un uso intensivo de las anotaciones y se basa en otras bibliotecas como AspectJ y Spring Framework. Sin embargo, en el caso de proyectos grandes y complejos, con AWS Flow Framework se ahorrará tiempo de programación. Para obtener más información, consulte la [Guía para desarrolladores del AWS Flow Framework para Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
En esta sección se proporciona ejemplos de programación en Amazon SWF que utilizan directamente el cliente de AWS SDK para Java.
**Topics**
+ [Conceptos básicos de SWF](swf-basics.md)
+ [Creación de una aplicación de Amazon SWF sencilla](swf-hello.md)
+ [LambdaTareas de](swf-lambda-task.md)
+ [Cerrar correctamente los procesos de trabajo de actividad y flujo de trabajo](swf-graceful-shutdown.md)
+ [Registro de dominios](prog-services-swf-register-domain.md)
+ [Visualización de los dominios](prog-services-swf-list-domains.md)
# Conceptos básicos de SWF
Estos son los patrones generales para trabajar con Amazon SWF mediante AWS SDK para Java. Se han diseñado principalmente como referencia. Para obtener un tutorial de introducción más completo, consulte Creación de una aplicación de Amazon SWF sencilla.
## Dependencias
Las aplicaciones básicas de Amazon SWF requerirán las siguientes dependencias, que se incluyen con AWS SDK para Java:
+ aws-java-sdk-1.12.\$1.jar
+ commons-logging-1.2.\$1.jar
+ httpclient-4.3.\$1.jar
+ httpcore-4.3.\$1.jar
+ jackson-annotations-2.12.\$1.jar
+ jackson-core-2.12.\$1.jar
+ jackson-databind-2.12.\$1.jar
+ joda-time-2.8.\$1.jar
**nota**
Los números de versión de estos paquetes serán diferentes en función de la versión del SDK que tenga, pero las versiones que se proporcionan con el SDK se han probado para garantizar su compatibilidad y son las que debe utilizar.
Las aplicaciones de AWS Flow Framework para Java requieren configuración adicional *y* dependencias adicionales. Consulte la [Guía para desarrolladores de AWS Flow Framework para Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/) para obtener más información acerca de cómo utilizar la plataforma.
## Importaciones
En general, puede utilizar las siguientes importaciones para el desarrollo de código:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
Sin embargo, es aconsejable que importe solamente las clases que necesite. Lo más probable es que acabe especificando clases concretas en el área de trabajo `com.amazonaws.services.simpleworkflow.model`:
```
import com.amazonaws.services.simpleworkflow.model.PollForActivityTaskRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskCompletedRequest;
import com.amazonaws.services.simpleworkflow.model.RespondActivityTaskFailedRequest;
import com.amazonaws.services.simpleworkflow.model.TaskList;
```
Si utiliza AWS Flow Framework para Java, importará clases del área de trabajo de `com.amazonaws.services.simpleworkflow.flow`. Por ejemplo:
```
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.flow.ActivityWorker;
```
**nota**
El AWS Flow Framework para Java tiene requisitos adicionales además de los del AWS SDK para Java básico. Para obtener más información, consulte la [Guía para desarrolladores del AWS Flow Framework para Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
## Uso de la clase del cliente SWF
La interfaz básica con Amazon SWF se realiza a través de las clases [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html) o [AmazonSimpleWorkflowAsyncClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowAsyncClient.html). La diferencia principal entre estas clases es que la clase `\*AsyncClient` devuelve objetos [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) para la programación simultánea (asíncrona).
```
AmazonSimpleWorkflowClient swf = AmazonSimpleWorkflowClientBuilder.defaultClient();
```
# Creación de una aplicación de Amazon SWF sencilla
Este tema es una introducción a la programación de aplicaciones de [Amazon SWF](https://aws.amazon.com/swf/) con el AWS SDK para Java, en la que se describen algunos conceptos importantes.
## Acerca del ejemplo
El proyecto de ejemplo creará un flujo de trabajo con una única actividad que acepta datos del flujo de trabajo pasados a través de la nube de AWS (siguiendo la tradición de HelloWorld, será el nombre de una persona a la que se saluda) y, a continuación, mostrará un saludo como respuesta.
Aunque puedan parecer muy sencillas, las aplicaciones de Amazon SWF se componen de varias partes que funcionan conjuntamente:
+ Un **dominio**, utilizado como un contenedor lógico para los datos de ejecución del flujo de trabajo.
+ Uno o varios **flujos de trabajo** que representan los componentes de código que definen el orden lógico de ejecución de las actividades del flujo de trabajo y los flujos de trabajo secundarios.
+ Un **proceso de trabajo de flujo de trabajo**, también conocido como *decisor*, que busca tareas de decisión y actividades de programación o flujos de trabajo secundarios como respuesta.
+ Una o varias **actividades**, cada una de las cuales representa una unidad de trabajo del flujo de trabajo.
+ Un **proceso de trabajo de actividad** que busca tareas de actividad y ejecuta métodos de actividad como respuesta.
+ Una o varias **listas de tareas**, que son colas mantenidas por Amazon SWF utilizadas para emitir solicitudes a los procesos de trabajo del flujo de trabajo o actividad. Las tareas de una lista de tareas dirigidas a los procesos de trabajo de flujo de trabajo se denominan *tareas de decisión*. Las dirigidas a los procesos de trabajo de actividad se denominan *tareas de actividad*.
+ Un **iniciador del flujo de trabajo** que inicia la ejecución del flujo de trabajo.
Entre bambalinas, Amazon SWF organiza la operación de estos componentes, coordinando su flujo desde la nube de AWS, pasando datos entre ellos, administrando los tiempos de espera y las notificaciones de latido, y registrando el historial de ejecución del flujo de trabajo.
## Requisitos previos
### Entorno de desarrollo
El entorno de desarrollo que se utiliza en este tutorial se compone de:
+ La [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/).
+ [Apache Maven](http://maven.apache.org/) (3.3.1).
+ JDK 1.7 o posterior. Este tutorial se ha desarrollado y probado con JDK 1.8.0.
+ Un buen editor de texto de Java (el que prefiera).
**nota**
Si utiliza un sistema de compilación distinto de Maven, puede crear igualmente un proyecto realizando los pasos correspondientes de su entorno y usar los conceptos que se proporcionan aquí durante el proceso. En la sección AWS SDK para JavaIntroducción[ se proporciona más información sobre cómo configurar y usar ](getting-started.md) con distintos sistemas de compilación.
Del mismo modo, pero con más esfuerzo, los pasos que se muestran aquí se pueden implementar con cualquiera de los SDK de AWS admitidos para Amazon SWF.
Todas las dependencias externas necesarias se incluyen con AWS SDK para Java, por lo que no necesita descargar nada más.
### Acceso a AWS
Para completar correctamente este tutorial, debe tener acceso al portal de acceso a AWS como se [describe en la sección de configuración básica](signup-create-iam-user.md#signup-create-iam-user-overview) de esta guía.
Las instrucciones describen cómo acceder a las credenciales temporales que se copian y pegan en el archivo de `credentials` compartido local. Las credenciales temporales que pegue deben estar asociadas a un rol de IAM en AWS IAM Identity Center que tenga permisos para acceder a Amazon SWF. Tras pegar las credenciales temporales, el archivo de `credentials` debería tener un aspecto similar al siguiente.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
Estas credenciales temporales están asociadas al perfil `default`.
## Creación de un proyecto de SWF
1. Inicie un nuevo proyecto con Maven:
```
mvn archetype:generate -DartifactId=helloswf \
-DgroupId=aws.example.helloswf -DinteractiveMode=false
```
Se creará un nuevo proyecto con una estructura de proyecto de Maven estándar:
```
helloswf
├── pom.xml
└── src
├── main
│ └── java
│ └── aws
│ └── example
│ └── helloswf
│ └── App.java
└── test
└── ...
```
Puede omitir o eliminar el directorio `test` y todo su contenido; no lo usaremos en este tutorial. También puede eliminar `App.java`, ya que lo reemplazaremos por nuevas clases.
1. Edite el archivo `pom.xml` del proyecto y añada el módulo **aws-java-sdk-simpleworkflow** añadiendo una dependencia para él en el bloque ``.
```
com.amazonawsaws-java-sdk-simpleworkflow1.11.1000
```
1. *Asegúrese de que Maven compila su proyecto de manera que sea compatible con JDK*. Añada lo siguiente a su proyecto (delante o detrás del bloque ``) en `pom.xml`:
```
maven-compiler-plugin3.6.11.81.8
```
## Codificación del proyecto
El proyecto de ejemplo consta de cuatro aplicaciones distintas, que examinaremos de una en una:
+ **HelloTypes.java**: contiene el dominio del proyecto y los datos de tipos de actividad y flujo de trabajo, compartidos con los demás componentes. También se encarga de registrar estos tipos con SWF.
+ **ActivityWorker.java**: contiene el proceso de trabajo de actividad, que busca tareas de actividad y ejecuta actividades como respuesta.
+ **WorkflowWorker.java**: contiene el proceso de trabajo de flujo de trabajo (decisor), que busca tareas de decisión y programa nuevas actividades.
+ **WorkflowStarter.java**: contiene el iniciador del flujo de trabajo, que inicia la ejecución de un nuevo flujo de trabajo, que hará que SWF empiece a generar tareas de decisión y flujo de trabajo para los procesos de trabajo.
### Pasos comunes para todos los archivos de código fuente
Todos los archivos que crea para alojar sus clases Java tendrán algunas cosas en común. Para ahorrar tiempo, estos pasos *estarán implícitos cada vez que añada un nuevo archivo al proyecto*:
1. Cree el archivo en el directorio `src/main/java/aws/example/helloswf/` del proyecto.
1. Añada una declaración `package` al principio de cada archivo para declarar su espacio de nombres. El proyecto de ejemplo usa:
```
package aws.example.helloswf;
```
1. Añada declaraciones `import` para la clase [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html) y para varias clases del espacio de nombres `com.amazonaws.services.simpleworkflow.model`. Para simplificar las cosas, vamos a utilizar:
```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
```
### Registro de un dominio y de tipos de flujo de trabajo y actividad
Comenzaremos creando una nueva clase ejecutable, `HelloTypes.java`. Este archivo contendrá datos compartidos que necesitarán conocer las distintas partes de su flujo de trabajo, como el nombre y la versión de sus tipos de actividad y flujo de trabajo, el nombre de dominio y el nombre de la lista de tareas.
1. Abra su editor de texto y cree el archivo `HelloTypes.java`, añadiendo una declaración del paquete y funciones import de acuerdo con los [pasos comunes](#swf-hello-common).
1. Declare la clase `HelloTypes` y proporcione los valores que se van a usar para los tipos de actividad y flujo de trabajo registrados:
```
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";
```
Estos valores se utilizarán en todo el código.
1. Detrás de las declaraciones de cadena, cree una instancia de la clase [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html). Esta es la interfaz básica a los métodos de Amazon SWF proporcionados por AWS SDK para Java.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
En el fragmento anterior se presupone que las credenciales temporales están asociadas al perfil `default`. Si usa un perfil diferente, modifique el código anterior de la siguiente manera y sustituya *profile\$1name por el nombre* del perfil real.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder
.standard()
.withCredentials(new ProfileCredentialsProvider("profile_name"))
.withRegion(Regions.DEFAULT_REGION)
.build();
```
1. Añada una nueva función para registrar un dominio de SWF. Un *dominio* es un contenedor lógico para una serie de tipos de actividad y flujo de trabajo de SWF relacionados. Los componentes de SWF solo pueden comunicarse entre sí si se encuentran en el mismo 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!");
}
```
Cuando registra un dominio, proporciona un *nombre* (cualquier conjunto de 1-256 caracteres excepto `:`, `/`, `|`, caracteres de control o la cadena literal 'arn') y un *periodo de retención*, que es el número de días que Amazon SWF conservará los datos del historial de ejecución del flujo de trabajo una vez completada la ejecución del flujo de trabajo. El periodo máximo de retención de ejecución del flujo de trabajo es de 90 días. Consulte [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html) para obtener más información.
Si ya existe un dominio con ese nombre, se produce una excepción [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html). Como no nos interesa si se ha creado o no se ha creado el dominio, podemos omitir esta excepción.
**nota**
Este código muestra un patrón común cuando se trabaja con métodos de AWS SDK para Java: los datos del método los proporciona una clase del espacio de nombres `simpleworkflow.model`, de la que se crea una instancia y se rellena mediante la ejecución en cadena de métodos `0with*`.
1. Añada una función para registrar un nuevo tipo de actividad. Una *actividad* representa una unidad de trabajo de su flujo de trabajo.
```
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 de actividad se identifica mediante un *nombre* y una *versión*, que se utilizan para identificar de forma inequívoca la actividad de otras actividades que se han registrado en el dominio. Las actividades también contienen una serie de parámetros opcionales, como la lista de tareas predeterminadas para recibir las tareas y los datos de SWF, y una serie de tiempos de espera diferentes que puede utilizar para aplicar restricciones sobre cuánto tiempo pueden tardar las distintas partes de la ejecución de la actividad. Consulte [RegisterActivityTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterActivityTypeRequest.html) para obtener más información.
**nota**
Todos los valores de tiempo de espera se especifican en *segundos*. Consulte [Tipos de tiempo de espera de Amazon SWF](https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-timeout-types.html) para obtener una descripción completa de cómo los tiempos de espera afectan a las ejecuciones del flujo de trabajo.
Si el tipo de actividad que intenta registrar ya existe, se produce una excepción [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html). Añada una función para registrar un nuevo tipo de flujo de trabajo. Un *flujo de trabajo*, denominado también *decisor*, representa la lógica de la ejecución del flujo de trabajo.
\$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
Al igual que los tipos de actividad, los tipos de flujos de trabajo se identifican mediante un *nombre* y una *versión*, y también tienen tiempos de espera configurables. Consulte [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html) para obtener más información.
\$1
Si el tipo de flujo de trabajo que intenta registrar ya existe, se produce una excepción [TypeAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/TypeAlreadyExistsException.html). Por último, cree la clase ejecutable proporcionando un método `main`, que registrará el dominio, el tipo de actividad y el tipo de flujo de trabajo:
\$1
```
registerDomain();
registerWorkflowType();
registerActivityType();
```
Puede [compilar](#swf-hello-build) y [ejecutar](#swf-hello-run-register) la aplicación ahora para ejecutar el script de registro o continuar programando los procesos de trabajo de actividad y flujo de trabajo. Una vez que el dominio, el flujo de trabajo y la actividad se hayan registrado, no necesitará ejecutar esto de nuevo: estos tipos persisten hasta que los deja de utilizar.
### Implementación del proceso de trabajo de actividad
Una *actividad* es la unidad básica de trabajo de su flujo de trabajo. Un flujo de trabajo proporciona la lógica, programando las actividades que se van a ejecutar (u otras acciones que se deben llevar a cabo) en respuesta a las tareas de decisión. Un flujo de trabajo típico normalmente se compone de una serie de actividades que se pueden ejecutar de forma síncrona, asíncrona o de ambas formas.
El *proceso de trabajo de actividad* es la parte del código que busca las tareas de actividad generadas por Amazon SWF en respuesta a las decisiones del flujo de trabajo. Cuando recibe una tarea de actividad, ejecuta la actividad correspondiente y devuelve una respuesta de éxito/error al flujo de trabajo.
Vamos a implementar un proceso de trabajo de actividad sencillo que se encarga de una sola actividad.
1. Abra su editor de texto y cree el archivo `ActivityWorker.java`, añadiendo una declaración del paquete y funciones import de acuerdo con los [pasos comunes](#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. Añada la clase `ActivityWorker` al archivo y proporcione un miembro de datos para almacenar el cliente de SWF que usaremos para interactuar con Amazon SWF:
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Añada el método que usaremos como actividad:
```
private static String sayHello(String input) throws Throwable {
return "Hello, " + input + "!";
}
```
La actividad simplemente toma una cadena, la combina en un saludo y devuelve el resultado. Aunque no es muy probable que esta actividad produzca una excepción, es aconsejable que diseñe actividades que puedan producir un error si algo va mal.
1. Añada un método `main` que utilizaremos como el método de sondeo de tareas de actividad. Empezaremos añadiendo código para buscar tareas de actividad en la lista de tareas:
```
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();
```
La actividad recibe tareas de Amazon SWF llamando al método `pollForActivityTask` del cliente de SWF, especificando el dominio y la lista de tareas que se van a utilizar en el objeto [PollForActivityTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForActivityTaskRequest.html) pasado al método.
Una vez que se recibe una tarea, recuperamos un identificador único llamando al método `getTaskToken` de la tarea.
1. A continuación, escribimos código para procesar las tareas que llegan. Añada lo siguiente al método `main`, justo detrás del código que busca la tarea y recupera su token de tarea.
```
if (task_token != null) {
String result = null;
Throwable error = null;
try {
System.out.println("Executing the activity task with input '" +
task.getInput() + "'.");
result = sayHello(task.getInput());
} catch (Throwable th) {
error = th;
}
if (error == null) {
System.out.println("The activity task succeeded with result '"
+ result + "'.");
swf.respondActivityTaskCompleted(
new RespondActivityTaskCompletedRequest()
.withTaskToken(task_token)
.withResult(result));
} else {
System.out.println("The activity task failed with the error '"
+ error.getClass().getSimpleName() + "'.");
swf.respondActivityTaskFailed(
new RespondActivityTaskFailedRequest()
.withTaskToken(task_token)
.withReason(error.getClass().getSimpleName())
.withDetails(error.getMessage()));
}
}
```
Si el token de tarea no es `null`, podemos empezar a ejecutar el método de actividad (`sayHello`), facilitándole los datos de entrada que se enviaron con la tarea.
Si la tarea *se ejecuta correctamente* (no se genera ningún error), el proceso de trabajo responde a SWF llamando al método `respondActivityTaskCompleted` del cliente de SWF con un objeto [RespondActivityTaskCompletedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskCompletedRequest.html) que contiene el token de la tarea y los datos de los resultados de la actividad.
Sin embargo, si la tarea *ha producido un error*, respondemos llamando al método `respondActivityTaskFailed` con un objeto [RespondActivityTaskFailedRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RespondActivityTaskFailedRequest.html), proporcionándole el token de la tarea e información sobre el error.
**nota**
Esta actividad no se cerrará correctamente si se cancela. Aunque está fuera del alcance de este tutorial, una implementación alternativa de este proceso de trabajo de actividad se proporciona en el tema complementario [Cerrar correctamente los procesos de trabajo de actividad y flujo de trabajo](swf-graceful-shutdown.md).
### Implementación del proceso de trabajo del flujo de trabajo
La lógica del flujo de trabajo reside en una parte del código denominada **proceso de trabajo de flujo de trabajo**. El proceso de trabajo de flujo de trabajo busca tareas de decisión enviadas por Amazon SWF en el dominio y en la lista de tareas predeterminada en los que se ha registrado este tipo de flujo de trabajo.
Cuando el proceso de trabajo de flujo de trabajo recibe una tarea, toma algún tipo de decisión (normalmente si se va a programar o no una nueva actividad) y realiza la actividad correspondiente (como programar la actividad).
1. Abra su editor de texto y cree el archivo `WorkflowWorker.java`, añadiendo una declaración del paquete y funciones import de acuerdo con los [pasos comunes](#swf-hello-common).
1. Añada algunas funciones import adicionales al archivo:
```
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. Declare la clase `WorkflowWorker` y cree una instancia de la clase [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html) utilizada para obtener acceso a los métodos de SWF.
```
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
```
1. Añada el método `main`. Este método se ejecuta en bucle continuamente en busca de tareas de decisión usando el método `pollForDecisionTask` del cliente de SWF. El objeto [PollForDecisionTaskRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/PollForDecisionTaskRequest.html) proporciona los detalles.
```
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 vez que se recibe una tarea, llamamos a su método `getTaskToken`, que devuelve una cadena que se puede utilizar para identificar la tarea. Si el token devuelto no es `null`, lo seguimos procesando en el método `executeDecisionTask`, pasándole el token de la tarea y la lista de objetos [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html) enviados con la tarea.
1. Añada el método `executeDecisionTask`, tomando el token de tarea (`String`) y la lista `HistoryEvent`.
```
List decisions = new ArrayList();
String workflow_input = null;
int scheduled_activities = 0;
int open_activities = 0;
boolean activity_completed = false;
String result = null;
```
También configuramos algunos miembros de datos para realizar un seguimiento de cosas como:
+ Una lista de objetos [Decision](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) usados para registrar los resultados de procesar la tarea
+ Una cadena para almacenar la entrada del flujo de trabajo proporcionada por el evento "WorkflowExecutionStarted"
+ Un recuento de las actividades programadas y abiertas (en ejecución) para evitar programar la misma actividad cuando ya se ha programado o se está ejecutando en este momento
+ Un valor booleano para indicar que la actividad se ha completado
+ Una cadena para almacenar los resultados de la actividad, que se devolverán como el resultado del flujo de trabajo
1. A continuación, añada código a `executeDecisionTask` para procesar los objetos `HistoryEvent` que se han enviado a la tarea, en función del tipo de evento notificado por el método `getEventType`.
```
System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
System.out.println(" " + event);
switch(event.getEventType()) {
case "WorkflowExecutionStarted":
workflow_input =
event.getWorkflowExecutionStartedEventAttributes()
.getInput();
break;
case "ActivityTaskScheduled":
scheduled_activities++;
break;
case "ScheduleActivityTaskFailed":
scheduled_activities--;
break;
case "ActivityTaskStarted":
scheduled_activities--;
open_activities++;
break;
case "ActivityTaskCompleted":
open_activities--;
activity_completed = true;
result = event.getActivityTaskCompletedEventAttributes()
.getResult();
break;
case "ActivityTaskFailed":
open_activities--;
break;
case "ActivityTaskTimedOut":
open_activities--;
break;
}
}
System.out.println("]");
```
A efectos de nuestro flujo de trabajo, lo que más nos interesa es:
+ El evento "WorkflowExecutionStarted", que indica que ha comenzado la ejecución del flujo de trabajo (lo que normalmente significa que debe ejecutar la primera actividad del flujo de trabajo) y que ofrece la entrada inicial proporcionada en el flujo de trabajo. En este caso, es la parte del nombre del saludo, por lo que se guarda como una cadena para usarla al programar la actividad que se debe ejecutar.
+ El evento "ActivityTaskCompleted", que se envía una vez que se haya completado la actividad programada. Los datos del evento también incluyen el valor devuelto de la actividad completada. Como solo tenemos una actividad, usaremos el valor como el resultado de todo el flujo de trabajo.
Los demás tipos de eventos se pueden utilizar si el flujo de trabajo así lo requiere. Consulte la descripción de la clase [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html) para obtener información acerca de cada tipo de evento.
\$1 NOTA: las cadenas de `switch` se introdujeron en Java 7. Si utiliza una versión anterior de Java, puede utilizar la clase [EventType](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/model/EventType.html) para convertir el valor `String` devuelto por `history_event.getType()` en un valor enum y luego en un valor `String` si es necesario:
```
EventType et = EventType.fromValue(event.getEventType());
```
1. Detrás de la instrucción `switch`, añada más código para responder con una *decisión* adecuada en función de la tarea que se ha recibido.
```
if (activity_completed) {
decisions.add(
new Decision()
.withDecisionType(DecisionType.CompleteWorkflowExecution)
.withCompleteWorkflowExecutionDecisionAttributes(
new CompleteWorkflowExecutionDecisionAttributes()
.withResult(result)));
} else {
if (open_activities == 0 && scheduled_activities == 0) {
ScheduleActivityTaskDecisionAttributes attrs =
new ScheduleActivityTaskDecisionAttributes()
.withActivityType(new ActivityType()
.withName(HelloTypes.ACTIVITY)
.withVersion(HelloTypes.ACTIVITY_VERSION))
.withActivityId(UUID.randomUUID().toString())
.withInput(workflow_input);
decisions.add(
new Decision()
.withDecisionType(DecisionType.ScheduleActivityTask)
.withScheduleActivityTaskDecisionAttributes(attrs));
} else {
// an instance of HelloActivity is already scheduled or running. Do nothing, another
// task will be scheduled once the activity completes, fails or times out
}
}
System.out.println("Exiting the decision task with the decisions " + decisions);
```
+ Si la actividad aún no se ha programado, respondemos con una decisión `ScheduleActivityTask`, que proporciona información en una estructura [ScheduleActivityTaskDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ScheduleActivityTaskDecisionAttributes.html) sobre la actividad que Amazon SWF debería programar a continuación, incluyendo también los datos que Amazon SWF debe enviar a la actividad.
+ Si la actividad se ha completado, consideramos que se ha completado todo el flujo de trabajo y respondemos con una decisión `CompletedWorkflowExecution`, rellenando una estructura [CompleteWorkflowExecutionDecisionAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/CompleteWorkflowExecutionDecisionAttributes.html) para proporcionar información sobre el flujo de trabajo completado. En este caso, devolvemos el resultado de la actividad.
En cualquier caso, la información de la decisión se añade a la lista `Decision` que se declaró encima del método.
1. Complete la tarea de decisión devolviendo la lista de objetos `Decision` recopilados al procesar la tarea. Añada este código al final del método `executeDecisionTask` que hemos escrito:
```
swf.respondDecisionTaskCompleted(
new RespondDecisionTaskCompletedRequest()
.withTaskToken(taskToken)
.withDecisions(decisions));
```
El método `respondDecisionTaskCompleted` del cliente de SWF toma el token de la tarea que identifica la tarea, así como la lista de objetos `Decision`.
### Implementación del iniciador del flujo de trabajo
Por último, escribiremos código para iniciar la ejecución del flujo de trabajo.
1. Abra su editor de texto y cree el archivo `WorkflowStarter.java`, añadiendo una declaración del paquete y funciones import de acuerdo con los [pasos comunes](#swf-hello-common).
1. Añada la clase `WorkflowStarter`:
```
package aws.example.helloswf;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
public class WorkflowStarter {
private static final AmazonSimpleWorkflow swf =
AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
public static final String WORKFLOW_EXECUTION = "HelloWorldWorkflowExecution";
public static void main(String[] args) {
String workflow_input = "{SWF}";
if (args.length > 0) {
workflow_input = args[0];
}
System.out.println("Starting the workflow execution '" + WORKFLOW_EXECUTION +
"' with input '" + workflow_input + "'.");
WorkflowType wf_type = new WorkflowType()
.withName(HelloTypes.WORKFLOW)
.withVersion(HelloTypes.WORKFLOW_VERSION);
Run run = swf.startWorkflowExecution(new StartWorkflowExecutionRequest()
.withDomain(HelloTypes.DOMAIN)
.withWorkflowType(wf_type)
.withWorkflowId(WORKFLOW_EXECUTION)
.withInput(workflow_input)
.withExecutionStartToCloseTimeout("90"));
System.out.println("Workflow execution started with the run id '" +
run.getRunId() + "'.");
}
}
```
La clase `WorkflowStarter` consta de un único método, `main`que toma un argumento opcional pasado en la línea de comandos como datos de entrada para el flujo de trabajo.
El método del cliente de SWF, `startWorkflowExecution`, toma un objeto [StartWorkflowExecutionRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/StartWorkflowExecutionRequest.html) como entrada. Aquí, además de especificar el dominio y tipo de flujo de trabajo que se va a ejecutar, proporcionamos:
+ Un nombre de ejecución de flujo de trabajo en lenguaje natural
+ Los datos de entrada del flujo de trabajo (proporcionados en la línea de comandos en nuestro ejemplo)
+ Un valor de tiempo de espera que representa cuánto tiempo, en segundos, debe tardar en ejecutarse todo el flujo de trabajo
El objeto [Run](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Run.html) que devuelve `startWorkflowExecution` proporciona un *ID de ejecución*, que es un valor que se puede utilizar para identificar esta ejecución del flujo de trabajo en concreto en el historial de ejecuciones del flujo de trabajo de Amazon SWF.
\$1 NOTA: el ID de ejecución lo genera Amazon SWF y *no* es el mismo que el nombre de ejecución del flujo de trabajo que se pasa al iniciar la ejecución del flujo de trabajo.
## Compilación del ejemplo
Para crear el proyecto de ejemplo con Maven, vaya al directorio `helloswf` y escriba:
```
mvn package
```
El `helloswf-1.0.jar` resultante se generará en el directorio `target`.
## Ejecución del ejemplo
El ejemplo consta de cuatro clases ejecutable distintas, que se ejecutan de forma independiente entre sí.
**nota**
Si utiliza un sistema Linux, macOS o Unix, puede ejecutarlas todas ellas, una detrás de otra, en una sola ventana del terminal. Si ejecuta Windows, debe abrir dos instancias de línea de comandos adicionales e ir al directorio `helloswf` de cada una de ellas.
### Definición del classpath Java
Aunque Maven se encarga de las dependencias por usted, para ejecutar el ejemplo, tendrá que proporcionar la biblioteca del SDK de AWS y sus dependencias en el classpath Java. Puede establecer la variable de entorno `CLASSPATH` en la ubicación de las bibliotecas del SDK de AWS y el directorio `third-party/lib` del SDK, que incluye las dependencias necesarias:
```
export CLASSPATH='target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/*'
java example.swf.hello.HelloTypes
```
O puede usar la opción `-cp` del comando **` java `** para establecer el classpath mientras se ejecuta cada una de las aplicaciones.
```
java -cp target/helloswf-1.0.jar:/path/to/sdk/lib/*:/path/to/sdk/third-party/lib/* \
example.swf.hello.HelloTypes
```
Usted decide el método que desea utilizar. Si no ha tenido problemas al compilar el código, pero al intentar ejecutar los ejemplos ha recibido una serie de errores "NoClassDefFound", es probable que el classpath esté establecido de forma incorrecta.
### Registro del dominio y de los tipos de flujo de trabajo y actividad
Antes de ejecutar sus procesos de trabajo y el iniciador del flujo de trabajo, tendrá que registrar el dominio y sus tipos de flujo de trabajo y actividad. El código para esto se ha implementado en la sección [Registro de un dominio y de tipos de flujo de trabajo y actividad](#swf-hello-hellotypes).
Después de la compilación, si ha [establecido el CLASSPATH](#swf-hello-set-classpath), puede ejecutar el código de registro ejecutando el comando:
```
echo 'Supply the name of one of the example classes as an argument.'
```
### Inicio de los procesos de trabajo de actividad y flujo de trabajo
Ahora que los tipos se han registrado, puede iniciar los procesos de trabajo de actividad y flujo de trabajo. Estos se seguirán ejecutando y buscarán tareas hasta que se cancelen, por lo que deberá ejecutarlos en ventanas de terminal diferentes o, si utiliza Linux, macOS o Unix, puede usar el operador `&` para hacer que cada uno de ellos genere un proceso distinto cuando se ejecuten.
```
echo 'If there are arguments to the class, put them in quotes after the class name.'
exit 1
```
Si ejecuta estos comandos en ventanas distintas, omita el operador `&` al final de cada línea.
### Inicio de la ejecución del flujo de trabajo
Ahora que los procesos de trabajo de actividad y flujo de trabajo están realizando operaciones de sondeo, puede iniciar la ejecución del flujo de trabajo. Este proceso se ejecutará hasta que el flujo de trabajo devuelva un estado completado. Debe ejecutarlo en una nueva ventana de terminal (a menos que ejecute sus procesos de trabajo como nuevos procesos generados mediante el operador `&`).
```
fi
```
**nota**
Si desea proporcionar sus propios datos de entrada, que se pasarán primero al flujo de trabajo y después a la actividad, añádalos a la línea de comandos. Por ejemplo:
```
echo "## Running $className..."
```
Una vez que comience la ejecución del flujo de trabajo, debería empezar a ver los resultados enviados por ambos procesos de trabajo y por la propia ejecución del flujo de trabajo. Cuando el flujo de trabajo termine de completarse, el resultado se mostrará en la pantalla.
## Código fuente completo de este ejemplo
Puede buscar el [código fuente completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/java/example_code/swf) de este ejemplo en Github en el repositorio *aws-java-developer-guide*.
## Para obtener más información
+ Los procesos de trabajo presentados aquí pueden ocasionar la pérdida de tareas si se cierran mientras se ejecuta un sondeo del flujo de trabajo. Para saber cómo cerrar correctamente los procesos de trabajo, consulte [Cerrar correctamente los procesos de trabajo de actividad y flujo de trabajo](swf-graceful-shutdown.md).
+ Para obtener más información sobre Amazon SWF, visite la página principal de [Amazon SWF](https://aws.amazon.com/swf/) o consulte la [Guía para desarrolladores de Amazon SWF](https://docs.aws.amazon.com/amazonswf/latest/developerguide/).
+ Puede utilizar AWS Flow Framework para Java para crear flujos de trabajo más complejos en un estilo Java elegante mediante anotaciones. Para obtener más información, consulte la [Guía para desarrolladores de AWS Flow Framework para Java](https://docs.aws.amazon.com/amazonswf/latest/awsflowguide/).
# LambdaTareas de
Como alternativa a las actividades de Amazon SWF, o en combinación con ellas, puede utilizar funciones [Lambda](https://aws.amazon.com/lambda/) que representen unidades de trabajo en sus flujos de trabajo y programarlas de manera similar en actividades.
Este tema se centra en cómo implementar tareas Amazon SWF Lambda mediante AWS SDK para Java. Para obtener más información acerca de las tareas de Lambda, consulte [Tareas AWS Lambda](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html) en la Guía para desarrolladores de Amazon SWF.
## Configuración de un rol de IAM de varios servicios para ejecutar su función Lambda
Para que Amazon SWF pueda ejecutar su función Lambda, debe configurar un rol de IAM para conceder a Amazon SWF permiso para ejecutar funciones Lambda en su nombre. Para obtener información completa al respecto, consulte [AWS LambdaTareas de ](https://docs.aws.amazon.com/amazonswf/latest/developerguide/lambda-task.html).
Necesitará el Nombre de recurso de Amazon (ARN) de este rol de IAM cuando registre un flujo de trabajo que utilice tareas de Lambda.
## Crear una función de Lambda
Puede crear funciones Lambda en diferentes lenguajes, incluido Java. Para obtener información completa sobre cómo crear, implementar y utilizar funciones Lambda, consulte la [AWS LambdaGuía para desarrolladores de ](https://docs.aws.amazon.com/lambda/latest/dg/).
**nota**
Independientemente del lenguaje que use para crear la función Lambda, puede programarla y ejecutarla mediante *cualquier* flujo de trabajo de Amazon SWF, sea cual sea el lenguaje en el que esté escrito el código del flujo de trabajo. Amazon SWF se encarga de los detalles de la ejecución de la función y de pasar los datos.
A continuación se incluye una función Lambda sencilla que se puede utilizar en lugar de la actividad que se indica en [Creación de una aplicación de Amazon SWF sencilla](swf-hello.md).
+ Esta versión está escrita en JavaScript y se puede introducir directamente con la [Consola de administración de AWS](https://console.aws.amazon.com/console/home):
```
exports.handler = function(event, context) {
context.succeed("Hello, " + event.who + "!");
};
```
+ Esta es la misma función escrita en Java, que también podría implementar y ejecutar en 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**
Para obtener más información acerca de la implementación de funciones Java en Lambda, consulte [Creación de un cómo crear un paquete de implementación (Java)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java-how-to-create-deployment-package.html) en la Guía para desarrolladores de AWS Lambda. Puede consultar también la sección sobre cómo [programar modelos de programación para crear funciones Lambda en Java](https://docs.aws.amazon.com/lambda/latest/dg/java-programming-model.html).
Las funciones Lambda toman un *evento* u objeto de *entrada* como el primer parámetro y un objeto de *contexto* como el segundo, que proporciona información sobre la solicitud para ejecutar la función Lambda. Esta función en concreto espera que la entrada esté en formato JSON, con un campo `who` establecido en el nombre usado para crear el saludo.
## Registrar un flujo de trabajo para su uso con Lambda
Para que un flujo de trabajo programe una función Lambda, debe proporcionar el nombre del rol de IAM que proporciona Amazon SWF con permiso para invocar funciones Lambda. Puede definir esto durante el registro del flujo de trabajo mediante los métodos `withDefaultLambdaRole` o `setDefaultLambdaRole` de [RegisterWorkflowTypeRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterWorkflowTypeRequest.html).
```
System.out.println("** Registering the workflow type '" + WORKFLOW + "-" + WORKFLOW_VERSION
+ "'.");
try {
swf.registerWorkflowType(new RegisterWorkflowTypeRequest()
.withDomain(DOMAIN)
.withName(WORKFLOW)
.withDefaultLambdaRole(lambda_role_arn)
.withVersion(WORKFLOW_VERSION)
.withDefaultChildPolicy(ChildPolicy.TERMINATE)
.withDefaultTaskList(new TaskList().withName(TASKLIST))
.withDefaultTaskStartToCloseTimeout("30"));
}
catch (TypeAlreadyExistsException e) {
```
## Programación de una tarea de Lambda
Programar un tarea de Lambda es similar a programar una actividad. Usted proporciona una [Decisión](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/Decision.html) con un [DecisionType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DecisionType.html) `ScheduleLambdaFunction` y 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(
```
En `ScheduleLambdaFuntionDecisionAttributes` debe proporcionar un *nombre*, que es el ARN de la función Lambda que se va a llamar, y un *id*, que es el nombre que Amazon SWF usará para identificar la función Lambda en los registros del historial.
También puede proporcionar una *entrada* opcional para la función Lambda y establecer su valor de *tiempo de espera de inicio a cierre*, que es el número de segundos que la función Lambda se puede ejecutar antes de generar un evento `LambdaFunctionTimedOut`.
**nota**
Este código utiliza [AWSLambdaClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/AWSLambdaClient.html) para recuperar el ARN de la función Lambda, dado el nombre de la función. Puede utilizar esta técnica para evitar codificar de forma rígida el ARN completo (que incluye el ID de Cuenta de AWS) en el código.
## Controlar eventos de funciones de Lambda en su decisor
Las tareas de Lambda generarán una serie de eventos a partir de los cuales puede emprender acciones cuando se sondeen las tareas de decisión en el proceso de trabajo de flujo de trabajo, correspondientes al ciclo de vida de su tarea de Lambda, con valores de [EventType](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/EventType.html) como `LambdaFunctionScheduled`, `LambdaFunctionStarted` y `LambdaFunctionCompleted`. Si la función Lambda produce un error o tarda más tiempo en ejecutarse que el valor de tiempo de espera establecido, recibirá un tipo de evento `LambdaFunctionFailed` o `LambdaFunctionTimedOut`, respectivamente.
```
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;
```
## Recibir la salida de su función Lambda
Cuando recibe 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` en el [HistoryEvent](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/HistoryEvent.html) para obtener un objeto [LambdaFunctionCompletedEventAttributes](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/LambdaFunctionCompletedEventAttributes.html), y luego llamar a su método `getResult` para recuperar la salida de la función Lambda:
```
LambdaFunctionCompleted:
running_functions--;
```
## Código fuente completo de este ejemplo
Puede buscar el *código fuente completo :github:* de este ejemplo en Github en el repositorio *aws-java-developer-guide*.
# Cerrar correctamente los procesos de trabajo de actividad y flujo de trabajo
En el tema [Creación de una aplicación de Amazon SWF sencilla](swf-hello.md) se proporciona una implementación completa de una aplicación de flujo de trabajo sencilla que consta de una solicitud de registro, un proceso de trabajo de actividad y flujo de trabajo y un iniciador de flujo de trabajo.
Las clases de los procesos de trabajo se han diseñado para que se ejecuten continuamente en busca de tareas enviadas por Amazon SWF para ejecutar actividades o devolver decisiones. Una vez que se realiza una solicitud de sondeo, Amazon SWF registra el sondeador e intentará asignarle una tarea.
Si el proceso de trabajo de flujo de trabajo se termina durante un sondeo de larga duración, Amazon SWF puede seguir intentando enviar una tarea al proceso de trabajo terminado, lo que desembocará en una tarea perdida (hasta que se agote el tiempo de espera de la tarea).
Una forma de abordar esta situación es esperar a que todas las solicitudes de sondeo de larga duración finalicen antes de que termine el proceso de trabajo.
En este tema, reescribiremos el proceso de trabajo de actividad de `helloswf`, utilizando enlaces de cierre de Java para cerrar correctamente el proceso de trabajo de actividad.
Este es el código 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()));
}
}
}
}
}
```
En esta versión, el código de sondeo que estaba en la función `main` en la versión original se ha movido a su propio método, `pollAndExecute`.
La función `main` ahora utiliza [CountDownLatch](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CountDownLatch.html) junto con un [enlace de cierre](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Runtime.html) para hacer que el subproceso espere hasta 60 segundos después de que se solicite su terminación y antes de permitir que se cierre el subproceso.
# Registro de dominios
Cada flujo de trabajo y actividad de [Amazon SWF](https://aws.amazon.com/swf/) requiere un *dominio* en el que ejecutarse.
1. Cree un nuevo objeto [RegisterDomainRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/RegisterDomainRequest.html), proporcionando al menos el nombre de dominio y el periodo de retención de ejecución del flujo de trabajo (estos parámetros son obligatorios).
1. Llame al método [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 el objeto *RegisterDomainRequest*.
1. Capture la excepción [DomainAlreadyExistsException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainAlreadyExistsException.html) si el dominio que solicita ya existe (en cuyo caso, no se suele requerir ninguna acción).
El siguiente código muestra este procedimiento:
```
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!");
}
}
```
# Visualización de los dominios
Puede mostrar los dominios de [Amazon SWF](https://aws.amazon.com/swf/) asociados a su cuenta y región de AWS por tipo de registro.
1. Cree un objeto [ListDomainsRequest](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/ListDomainsRequest.html) y especifique el estado de registro de los dominios en los que está interesado (obligatorio).
1. Llame a [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 el objeto *ListDomainRequest*. Los resultados se proporcionan en un objeto [DomainInfos](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html).
1. Llame a [getDomainInfos devuelto](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfos.html#getDomainInfos--) en el objeto devuelto para obtener una lista de objetos [DomainInfo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html).
1. Llame a [getName](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/simpleworkflow/model/DomainInfo.html#getName--) en cada objeto *DomainInfo* para obtener su nombre.
El siguiente código muestra este procedimiento:
```
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());
}
}
```
# Ejemplos de código incluidos con el SDK
AWS SDK para Java incluye ejemplos de código que muestran muchas de las características del SDK en programas compilables y ejecutables. Puede estudiar o modificar estos ejemplos para implementar sus propias soluciones de AWS utilizando el AWS SDK para Java.
## Cómo obtener los ejemplos
Los ejemplos de código de AWS SDK para Java se proporcionan en el directorio *samples* del SDK. Si ha descargado e instalado el SDK usando la información de [Configuración del AWS SDK para Java](setup-install.md), ya tiene los ejemplos en su sistema.
También puede consultar los últimos ejemplos en el repositorio de GitHub de AWS SDK para Java en el directorio [src/samples](https://github.com/aws/aws-sdk-java/tree/master/src/samples).
## Compilación y ejecución de los ejemplos mediante la línea de comandos
Los ejemplos incluyen scripts de compilación [Ant](http://ant.apache.org/) para que pueda compilarlos y ejecutarlos fácilmente desde la línea de comandos. Cada ejemplo contiene también un archivo README en formato HTML que incluye información específica de cada ejemplo.
**nota**
Si examina el código de ejemplo en GitHub, haga clic en el botón **Raw** de la pantalla de código fuente cuando consulte el archivo README.html del ejemplo. En modo "raw", el HTML se mostrará de acuerdo con los requisitos del navegador.
### Requisitos previos
Antes de ejecutar alguno de los ejemplos de AWS SDK para Java, necesitará configurar las credenciales de AWS en el entorno o con la AWS CLI, tal y como se especifica en [Configuración de credenciales y regiones de AWS para desarrollo](setup-credentials.md). Los ejemplos utilizan la cadena predeterminada de proveedores de credenciales siempre que sea posible. Por lo tanto, configurando las credenciales de esta forma, puede evitar el procedimiento arriesgado de insertar las credenciales de AWS en los archivos del directorio de código fuente (en el que puede activarlas sin querer y compartirlas públicamente).
### Ejecución de los ejemplos
1. Vaya al directorio que contiene el código del ejemplo. Por ejemplo, si está en el directorio raíz de la descarga del SDK de AWS y desea ejecutar el ejemplo `AwsConsoleApp`, escriba:
```
cd samples/AwsConsoleApp
```
1. Compile y ejecute el ejemplo con Ant. El destino de la compilación predeterminado realiza ambas opciones, por lo que solo puede introducir:
```
ant
```
El ejemplo muestra información en la salida estándar:
```
===========================================
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.
```
## Compilación y ejecución de los ejemplos mediante el IDE de Eclipse
Si utiliza AWS Toolkit for Eclipse, también puede iniciar un nuevo proyecto en Eclipse basado en AWS SDK para Java o añadir el SDK a un proyecto de Java existente.
### Requisitos previos
Una vez instalado AWS Toolkit for Eclipse, le recomendamos que configure el conjunto de herramientas con sus credenciales de seguridad. Puede hacer esto en cualquier momento eligiendo **Preferencias** en el menú **Ventana** de Eclipse y eligiendo la sección **Toolkit de AWS**.
### Ejecución de los ejemplos
1. Abra Eclipse.
1. Crear un nuevo proyecto Java de AWS En Eclipse, en el menú **File (Archivo)**, elija **New (Nuevo)** y haga clic en **Project (Proyecto)**. Se abre el asistente **New Project (Nuevo proyecto)**.
1. Expanda la categoría **AWS** y, a continuación, elija **Proyecto Java de AWS**.
1. Elija **Siguiente**. Se muestra la página de configuración del proyecto.
1. Introduzca el nombre en el cuadro **Project Name (Nombre del proyecto)**. El grupo de ejemplos de AWS SDK para Java muestra los disponibles en el SDK, descritos anteriormente.
1. Seleccione los ejemplos que desea incluir en su proyecto seleccionando cada casilla de verificación.
1. Introduzca las credenciales de AWS Si ya ha configurado AWS Toolkit for Eclipse con sus credenciales, estas se rellenan automáticamente.
1. Seleccione **Finalizar**. El proyecto se crea y se añade a **Project Explorer (Explorador de proyectos)**.
1. Elija el archivo `.java` del ejemplo que desea ejecutar. Por ejemplo, en el caso del ejemplo de Amazon S3, elija `S3Sample.java`.
1. Elija **Run (Ejecutar)** en el menú **Run (Ejecutar)**.
1. Haga clic con el botón derecho en el proyecto en **Project Explorer (Explorador de proyectos)**, seleccione **Build Path (Ruta de compilación)** y, a continuación, seleccione **Add Libraries (Añadir bibliotecas)**.
1. Elija **SDK de Java AWS**, seleccione **Siguiente** y, a continuación, siga las instrucciones que aparecen en pantalla.