

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Intégration AWS Health à d'autres systèmes à l'aide de l' AWS Health API
<a name="health-api"></a>

AWS Health est un service RESTful Web qui utilise le protocole HTTPS comme moyen de transport et le format JSON comme format de sérialisation des messages. Votre code applicatif peut effectuer des requêtes directement à l'API AWS Health . Lorsque vous utilisez directement l'API REST, vous devez écrire le code nécessaire pour signer et authentifier vos demandes. Pour plus d'informations sur les AWS Health opérations et les paramètres, consultez la [référence de l'AWS Health API](https://docs.aws.amazon.com/health/latest/APIReference/).

**Note**  
Vous devez disposer d'un plan AWS Business Support\$1, AWS Enterprise Support ou AWS Unified Operations [AWS Support](https://aws.amazon.com/premiumsupport/)pour utiliser l' AWS Health API. Si vous êtes dans un pays Région AWS qui ne propose aucun de ces AWS Support plans, ou si vous n'êtes pas passé à l'un de ces plans, vous pouvez utiliser l' AWS Health API avec un plan Business, Enterprise On-Ramp ou Enterprise Support. Si vous appelez l' AWS Health API depuis un pays Compte AWS qui n'est pas inscrit à l'un de ces forfaits, vous recevez un `SubscriptionRequiredException` message d'erreur.

Vous pouvez utiliser le AWS SDKs pour encapsuler les appels d' AWS Health API REST, ce qui peut simplifier le développement de vos applications. Vous spécifiez vos AWS informations d'identification, et ces bibliothèques se chargent de l'authentification et de la signature des demandes pour vous.

AWS Health fournit également un AWS Health tableau de bord AWS Management Console que vous pouvez utiliser pour afficher et rechercher des événements et des entités concernées. Consultez [Commencer à utiliser votre AWS Health tableau de bord](getting-started-health-dashboard.md).

**Topics**
+ [Signature des demandes AWS Health d'API](#signing)
+ [Choix des points de terminaison pour les demandes AWS Health d'API](#endpoints)
+ [Démos : récupération des données d' AWS Health événements des sept derniers jours par programmation](using-global-endpoints-demo.md)
+ [Tutoriel : Utilisation de l' AWS Health API avec des exemples Java](code-sample-java.md)

## Signature des demandes AWS Health d'API
<a name="signing"></a>

Lorsque vous utilisez le AWS SDKs ou le AWS Command Line Interface (AWS CLI) pour faire des demandes AWS, ces outils signent automatiquement les demandes à votre place avec la clé d'accès que vous spécifiez lors de la configuration des outils. Par exemple, si vous utilisez le AWS SDK pour Java pour la démonstration précédente des terminaux à haute disponibilité, vous n'avez pas besoin de signer vous-même les demandes.

**Exemples de code Java**  
Pour plus d'exemples sur l'utilisation de l' AWS Health API avec le AWS SDK pour Java, consultez cet [exemple de code](code-sample-java.md).



Lorsque vous faites des demandes, nous vous recommandons vivement de ne pas utiliser les informations d'identification de votre compte AWS root pour accéder régulièrement à AWS Health. Vous pouvez utiliser les informations d'identification d'un utilisateur IAM. Pour plus d'informations, voir [Verrouiller les clés d'accès utilisateur root de votre AWS compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials) dans le *guide de l'utilisateur IAM*.

Si vous n'utilisez pas le AWS SDKs ou le AWS CLI, vous devez signer vous-même vos demandes. Nous vous recommandons d'utiliser AWS la version 4 de Signature. Pour plus d'informations, consultez [la section Signature des demandes d' AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) dans le *Références générales AWS*.

## Choix des points de terminaison pour les demandes AWS Health d'API
<a name="endpoints"></a>

L' AWS Health API suit une architecture d'application multirégionale Architecture d'application et possède deux points de terminaison régionaux dans une configuration active-passive. Pour prendre en charge le basculement du DNS actif-passif, AWS Health fournit un point de terminaison global unique. Vous pouvez effectuer une recherche DNS sur le point de terminaison global pour déterminer le point de terminaison actif et la AWS région de signature correspondante. Cela vous permet de savoir quel point de terminaison utiliser dans votre code, afin que vous puissiez obtenir les informations les plus récentes AWS Health.

Lorsque vous envoyez une demande au point de terminaison mondial, vous devez spécifier vos informations d' AWS accès au point de terminaison régional que vous ciblez et configurer la signature pour votre région. Dans le cas contraire, votre authentification risque d'échouer. Pour de plus amples informations, veuillez consulter [Signature des demandes AWS Health d'API](#signing).

Pour les demandes IPv6 uniquement, nous recommandons d'effectuer une recherche DNS sur le point de terminaison global afin de déterminer le point de terminaison actif, Région AWS puis d'appeler le point de terminaison à double pile IPv6 pris en charge pour cette région.

Le tableau suivant représente la configuration par défaut.


****  

| Description | Région de signature | Endpoint |  Protocole | 
| --- | --- | --- | --- | 
| Actif |  us-east-1  |  health.us-east-1.amazonaws.com (IPv4-uniquement) health.us-east-1.api.aws (et pris en charge) IPv4 IPv6   | HTTPS | 
| Passif |  us-east-2  |  health.us-east-2.amazonaws.com (IPv4-uniquement) health.us-east-2.api.aws (et pris en charge) IPv4 IPv6   | HTTPS | 
| Globale |  us-east-1  Il s'agit de la région de signature du point de terminaison actif actuel.   |  global.health.amazonaws.com  | HTTPS | 

Pour déterminer si un point de terminaison est le point de *terminaison actif*, effectuez une recherche DNS sur le *CNAME du point de terminaison global*, puis extrayez la AWS région du nom résolu.

**Example : recherche DNS sur le point de terminaison global**  
 La commande renvoie ensuite le point de terminaison de la région us-east-1 . Cette sortie vous indique pour quel point de terminaison vous devez utiliser AWS Health.  

```
dig global.health.amazonaws.com | grep CNAME
global.health.amazonaws.com. 10 IN CNAME health.us-east-1.amazonaws.com
```

**Astuce**  
Les points de terminaison actifs et passifs renvoient AWS Health des données. Cependant, les AWS Health données les plus récentes ne sont disponibles qu'à partir du point de terminaison actif. Les données du point de terminaison passif seront finalement cohérentes avec le point de terminaison actif. Nous vous recommandons de redémarrer tous les flux de travail lorsque le point de terminaison actif change.

# Démos : récupération des données d' AWS Health événements des sept derniers jours par programmation
<a name="using-global-endpoints-demo"></a>

Dans les exemples de code suivants, AWS Health utilise une recherche DNS sur le point de terminaison global pour déterminer le point de terminaison régional actif et la région de signature. AWS Health utilise ces informations pour récupérer un rapport des sept derniers jours de données relatives aux événements. Le code redémarre le flux de travail si le point de terminaison actif change. 

**Topics**
+ [Démo : récupération des données d' AWS Health événements des sept derniers jours à l'aide de Java](#using-the-java-sample-code)
+ [Démo : récupération des données d' AWS Health événements des sept derniers jours à l'aide de Python](#using-the-python-code)

## Démo : récupération des données d' AWS Health événements des sept derniers jours à l'aide de Java
<a name="using-the-java-sample-code"></a>

**Prérequis**  
Vous devez installer [Gradle.](https://docs.gradle.org/current/userguide/installation.html)

**Pour utiliser l'exemple Java**

1. Téléchargez la [démo des terminaux de AWS Health haute disponibilité](https://github.com/aws/aws-health-tools/tree/master/high-availability-endpoint) sur GitHub.

1. Accédez au `high-availability-endpoint/java` répertoire du projet de démonstration.

1. Dans une fenêtre de ligne de commande, entrez la commande suivante.

   ```
   gradle build
   ```

1. Entrez les commandes suivantes pour spécifier vos AWS informations d'identification.

   ```
   export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
   export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
   export AWS_SESSION_TOKEN="your-aws-token"
   ```

1. Entrez la commande suivante pour exécuter la démo.

   ```
   gradle run
   ```  
**Example : sortie AWS Health d'événement**  

   L'exemple de code renvoie l' AWS Health événement récent des sept derniers jours sur votre AWS compte. Dans l'exemple suivant, la sortie inclut un AWS Health événement pour le AWS Config service.

   ```
   > Task :run
   [main] INFO aws.health.high.availability.endpoint.demo.HighAvailabilityV2Workflow - EventDetails(Event=Event(Arn=arn:aws:health:global::event/CONFIG/AWS_CONFIG_OPERATIONAL_NOTIFICATION/AWS_CONFIG_OPERATIONAL_NOTIFICATION_88a43e8a-e419-4ca7-9baa-56bcde4dba3, 
   Service=CONFIG, EventTypeCode=AWS_CONFIG_OPERATIONAL_NOTIFICATION, EventTypeCategory=accountNotification, Region=global, StartTime=2020-09-11T02:55:49.899Z, LastUpdatedTime=2020-09-11T03:46:31.764Z, 
   StatusCode=open, EventScopeCode=ACCOUNT_SPECIFIC), EventDescription=EventDescription(LatestDescription=As part of our ongoing efforts to optimize costs associated with recording changes related to certain ephemeral workloads,
   AWS Config is scheduled to release an update to relationships modeled within ConfigurationItems (CI) for 7 EC2 resource types on August 1, 2021. 
   Examples of ephemeral workloads include changes to Amazon Elastic Compute Cloud (Amazon EC2) Spot Instances, Amazon Elastic MapReduce jobs, and Amazon EC2 Autoscaling. 
   This update will optimize CI models for EC2 Instance, SecurityGroup, Network Interface, Subnet, VPC, VPN Gateway, and Customer Gateway resource types to record direct relationships and deprecate indirect relationships.
    
   A direct relationship is defined as a one-way relationship (A->B) between a resource (A) and another resource (B), and is typically derived from the Describe API response of resource (A). 
   An indirect relationship, on the other hand, is a relationship that AWS Config infers (B->A), in order to create a bidirectional relationship. 
   For example, EC2 instance -> Security Group is a direct relationship, since security groups are returned as part of the describe API response for an EC2 instance. 
   But Security Group -> EC2 instance is an indirect relationship, since EC2 instances are not returned when describing an EC2 Security group.
    
   Until now, AWS Config has recorded both direct and indirect relationships. With the launch of Advanced queries in March 2019, indirect relationships can easily be answered by running Structured Query Language (SQL) queries such as:
    
   SELECT
    resourceId,
    resourceType
   WHERE
    resourceType ='AWS::EC2::Instance'
   AND
    relationships.resourceId = 'sg-234213'
    
   By deprecating indirect relationships, we can optimize the information contained within a
   Configuration Item while reducing AWS Config costs related to relationship changes. 
   This is especially useful in case of ephemeral workloads where there is a high volume of configuration changes for EC2 resource types.
    
   Which resource relationships are being removed?
    
   Resource Type: Related Resource Type
   1 AWS::EC2::CustomerGateway: AWS::VPN::Connection
   2 AWS::EC2::Instance: AWS::EC2::EIP, AWS::EC2::RouteTable
   3 AWS::EC2::NetworkInterface: AWS::EC2::EIP, AWS::EC2::RouteTable
   4 AWS::EC2::SecurityGroup: AWS::EC2::Instance, AWS::EC2::NetworkInterface
   5 AWS::EC2::Subnet: AWS::EC2::Instance, AWS::EC2::NetworkACL, AWS::EC2::NetworkInterface, AWS::EC2::RouteTable
   6 AWS::EC2::VPC: AWS::EC2::Instance, AWS::EC2::InternetGateway, AWS::EC2::NetworkACL, AWS::EC2::NetworkInterface, AWS::EC2::RouteTable, AWS::EC2::Subnet, AWS::EC2::VPNGateway, AWS::EC2::SecurityGroup
   7 AWS::EC2::VPNGateway: AWS::EC2::RouteTable, AWS::EC2::VPNConnection
    
   Alternate mechanism to retrieve this relationship information:
   The SelectResourceConfig API accepts a SQL SELECT command, performs the corresponding search, and returns resource configurations matching the properties. You can use this API to retrieve the same relationship information. 
   For example, to retrieve the list of all EC2 Instances related to a particular VPC vpc-1234abc, you can use the following query:
    
   SELECT
    resourceId,
    resourceType
   WHERE
    resourceType ='AWS::EC2::Instance'
   AND
    relationships.resourceId = 'vpc-1234abc'
    
   If you have any questions regarding this deprecation plan, please contact AWS Support [1]. Additional sample queries to retrieve the relationship information for the resources listed above is provided in [2].
    
   [1] https://aws.amazon.com/support
   [2] https://docs.aws.amazon.com/config/latest/developerguide/examplerelationshipqueries.html),
   EventMetadata={})
   ```

### Ressources Java
<a name="resources-for-the-java-code"></a>
+ Pour plus d'informations, consultez l'[interface HealthClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/health/HealthClient.html) dans la *référence de l'AWS SDK pour Java API* et le [code source](https://repo1.maven.org/maven2/software/amazon/awssdk/health/2.14.2/).
+ Pour plus d'informations sur la bibliothèque utilisée dans cette démonstration pour les recherches DNS, consultez le fichier [dnsjava](https://github.com/dnsjava/dnsjava) dans. GitHub

## Démo : récupération des données d' AWS Health événements des sept derniers jours à l'aide de Python
<a name="using-the-python-code"></a>

**Prérequis**  
Vous devez installer [Python 3](https://www.python.org/downloads/).

**Pour utiliser l'exemple Python**

1. Téléchargez la [démo des terminaux de AWS Health haute disponibilité](https://github.com/aws/aws-health-tools/tree/master/high-availability-endpoint) sur GitHub.

1. Accédez au `high-availability-endpoint/python` répertoire du projet de démonstration.

1. Dans une fenêtre de ligne de commande, entrez les commandes suivantes.

   ```
   pip3 install virtualenv 
   virtualenv -p python3 v-aws-health-env
   ```
**Note**  
Pour Python 3.3 et versions ultérieures, vous pouvez utiliser le `venv` module intégré pour créer l'environnement virtuel au lieu de l'installer`virtualenv`. Pour plus d'informations, consultez [venv - Création d'environnements virtuels](https://docs.python.org/3/library/venv.html) sur le site Web de Python.  

   ```
   python3 -m venv v-aws-health-env
   ```

1. Entrez la commande suivante pour activer l'environnement virtuel.

   ```
   source v-aws-health-env/bin/activate
   ```

1. Entrez la commande suivante pour installer les dépendances.

   ```
   pip install -r requirements.txt
   ```

1. Entrez les commandes suivantes pour spécifier vos AWS informations d'identification.

   ```
   export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
   export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
   export AWS_SESSION_TOKEN="your-aws-token"
   ```

1. Entrez la commande suivante pour exécuter la démo.

   ```
   python3 main.py
   ```  
**Example : sortie AWS Health d'événement**  

   L'exemple de code renvoie l' AWS Health événement récent des sept derniers jours sur votre AWS compte. La sortie suivante renvoie un AWS Health événement pour une notification AWS de sécurité.

   ```
   INFO:botocore.credentials:Found credentials in environment variables.
   INFO:root:Details: {'arn': 'arn:aws:health:global::event/SECURITY/AWS_SECURITY_NOTIFICATION/AWS_SECURITY_NOTIFICATION_0e35e47e-2247-47c4-a9a5-876544042721', 
   'service': 'SECURITY', 'eventTypeCode': 'AWS_SECURITY_NOTIFICATION', 'eventTypeCategory': 'accountNotification', 'region': 'global', 'startTime': datetime.datetime(2020, 8, 19, 23, 30, 42, 476000, 
   tzinfo=tzlocal()), 'lastUpdatedTime': datetime.datetime(2020, 8, 20, 20, 44, 9, 547000, tzinfo=tzlocal()), 'statusCode': 'open', 'eventScopeCode': 'PUBLIC'}, description: 
   {'latestDescription': 'This is the second notice regarding TLS requirements on FIPS endpoints.\n\nWe
   are in the process of updating all AWS Federal Information Processing Standard (FIPS) endpoints across all AWS regions 
   to Transport Layer Security (TLS) version 1.2 by March 31, 2021 . In order to avoid an interruption in service, we encourage you to act now, by ensuring that you connect to AWS FIPS endpoints at a TLS version of 1.2. 
   If your client applications fail to support TLS 1.2 it will result in connection failures when TLS versions below 1.2 are no longer supported.\n\nBetween now and March 31, 2021 AWS will remove TLS 1.0 and TLS 1.1 support from each FIPS endpoint where no connections below TLS 1.2 are detected over a 30-day period. 
   After March 31, 2021 we may deploy this change to all AWS FIPS endpoints, even if there continue
   to be customer connections detected at TLS versions below 1.2. \n\nWe will provide additional updates and reminders on the AWS Security Blog, with a ‘TLS’ tag [1]. If you need further guidance or assistance, please contact AWS Support [2] or your Technical Account Manager (TAM). 
   Additional information is below.\n\nHow can I identify clients that are connecting with TLS
   1.0/1.1?\nFor customers using S3 [3], Cloudfront [4] or Application Load Balancer [5] you can use
   your access logs to view the TLS connection information for these services, and identify client
   connections that are not at TLS 1.2. If you are using the AWS Developer Tools on your clients, 
   you can find information on how to properly configure your client’s TLS versions by visiting Tools to Build on AWS [7] or our associated AWS Security Blog has a link for each unique code language [7].\n\nWhat is Transport Layer Security (TLS)?\nTransport Layer Security (TLS Protocols) are cryptographic protocols designed to provide secure communication across a computer network 
   [6].\n\nWhat are AWS FIPS endpoints? \nAll AWS services offer Transport Layer Security (TLS) 1.2 encrypted endpoints that can be used for all API calls. Some AWS services also offer FIPS 140-2 endpoints [9] for customers that require use of FIPS validated cryptographic libraries. \n\n[1] https://aws.amazon.com/blogs/security/tag/tls/\n[2] https://aws.amazon.com/support\n[3] 
   https://docs.aws.amazon.com/AmazonS3/latest/dev/LogFormat.html\n[4] https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html\n[5] https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html\n[6] https://aws.amazon.com/tools\n[7] https://aws.amazon.com/blogs/security/tls-1-2-to-become-the-minimum-for-all-aws-fips-endpoints\n[8] 
   https://en.wikipedia.org/wiki/Transport_Layer_Security\n[9] https://aws.amazon.com/compliance/fips'}
   ```

1. Lorsque vous avez terminé, entrez la commande suivante pour désactiver la machine virtuelle.

   ```
   deactivate
   ```

### Ressources Python
<a name="resources-for-python-code-example"></a>
+ Pour plus d'informations à ce sujet`Health. Client`, consultez le manuel de référence de l'API du [AWS SDK pour Python (Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/health.html#Health.Client)).
+ Pour plus d'informations sur la bibliothèque utilisée dans cette démo pour les recherches DNS, consultez le kit d'outils [dnspython](https://dnspython.readthedocs.io/en/stable/) et son [code source](https://github.com/rthalley/dnspython/). GitHub

# Tutoriel : Utilisation de l' AWS Health API avec des exemples Java
<a name="code-sample-java"></a>

Les exemples de code Java suivants montrent comment initialiser un AWS Health client et récupérer des informations sur les événements et les entités.

## Étape 1 : Initialiser des informations d'identification
<a name="step-1"></a>

Des informations d'identification valides sont requises pour communiquer avec l' AWS Health API. Vous pouvez utiliser la paire de clés de n'importe quel utilisateur IAM associé au AWS compte.

Créez et initialisez une [AWSCredentials](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/AWSCredentials.html)instance :

```
AWSCredentials credentials = null;
try {
       credentials = new ProfileCredentialsProvider("default").getCredentials();
} catch (Exception e) {
throw new AmazonClientException(
   "Cannot load the credentials from the credential profiles file. "
   + "Please make sure that your credentials file is at the correct "
   + "location (/home/username/.aws/credentials), and is in valid format.", e);
}
```

## Étape 2 : Initialisation d'un client AWS Health API
<a name="step-2"></a>

Utilisez l'objet d'informations d'identification initialisé à l'étape précédente pour créer un client AWS Health  :

```
import com.amazonaws.services.health.AWSHealthClient;

AWSHealth awsHealthClient = new AWSHealthClient(credentials);
```

## Étape 3 : utiliser les opérations de AWS Health l'API pour obtenir des informations sur les événements
<a name="step-3"></a>

**DescribeEvents**

```
import com.amazonaws.services.health.model.DescribeEventsRequest;
import com.amazonaws.services.health.model.DescribeEventsResult;
import com.amazonaws.services.health.model.Event;
import com.amazonaws.services.health.model.EventFilter;

DescribeEventsRequest request = new DescribeEventsRequest();

EventFilter filter = new EventFilter();
// Filter on any field from the supported AWS Health EventFilter model. 
// Here is an example for Region us-east-1 events from the EC2 service.
filter.setServices(singletonList("EC2"));
filter.setRegions(singletonList("us-east-1"));
request.setFilter(filter);

DescribeEventsResult response = awsHealthClient.describeEvents(request);
List<Event> resultEvents = response.getEvents();

Event currentEvent = null;
for (Event event : resultEvents) {
    // Display result event data; here is a subset.
    System.out.println(event.getArn());
    System.out.println(event.getService());
    System.out.println(event.getRegion());
    System.out.println(event.getAvailabilityZone());
    System.out.println(event.getStartTime());
    System.out.println(event.getEndTime());
 }
```

**DescribeEventAggregates**

```
import com.amazonaws.services.health.model.DescribeEventAggregatesRequest;
import com.amazonaws.services.health.model.DescribeEventAggregatesResult;
import com.amazonaws.services.health.model.EventAggregate;
import com.amazonaws.services.health.model.EventFilter;

DescribeEventAggregatesRequest request = new DescribeEventAggregatesRequest();
// set the aggregation field
request.setAggregateField("eventTypeCategory");

// filter more on result if needed
EventFilter filter = new EventFilter();
filter.setRegions(singleton("us-east-1"));
request.setFilter(filter);

DescribeEventAggregatesResult response = awsHealthClient.describeEventAggregates(request);

// print event count for each eventTypeCategory
for (EventAggregate aggregate: response.getEventAggregates()) {
    System.out.println("Event Category:" + aggregate.getAggregateValue());
    System.out.println("Event Count:" + aggregate.getCount());
 }
```

**DescribeEventDetails**

```
import com.amazonaws.services.health.model.DescribeEventDetailsRequest;
import com.amazonaws.services.health.model.DescribeEventDetailsResult;
import com.amazonaws.services.health.model.Event;
import com.amazonaws.services.health.model.EventDetails;


DescribeEventDetailsRequest describeEventDetailsRequest = new DescribeEventDetailsRequest();
// set event ARN and local value

describeEventDetailsRequest.setEventArns(singletonList("arn:aws:health:us-east-1::event/service/eventTypeCode/eventId"));
describeEventDetailsRequest.setLocale("en-US");
filter.setEventArns
DescribeEventDetailsResult describeEventDetailsResult = awsHealthClient.describeEventDetails(request);
EventDetails eventDetail = describeEventDetailsResult.getSuccessfulSet().get(0);

// check event-related fields
Event event = eventDetail.getEvent();
System.out.println(event.getService());
System.out.println(event.getRegion());
System.out.println(event.getAvailabilityZone());
System.out.println(event.getStartTime());
System.out.println(event.getEndTime());

// print out event description
System.out.println(eventDetail.getEventDescription().getLatestDescription());
```

**DescribeAffectedEntities**

```
import com.amazonaws.services.health.model.AffectedEntity;
import com.amazonaws.services.health.model.DateTimeRange;
import com.amazonaws.services.health.model.DescribeAffectedEntitiesRequest;
import com.amdescribeEventDetailsRequestazonaws.services.health.model.DescribeAffectedEntitiesResult;

DescribeAffectedEntitiesRequest request = new DescribeAffectedEntitiesRequest();
EntityFilter filter = new EntityFilter();

filter.setEventArns(singletonList("arn:aws:health:us-east-1::event/service/eventTypeCode/eventId"));

DescribeAffectedEntitiesResult response = awsHealthClient.describeAffectedEntities(request);

for (AffectedEntity affectedEntity: response.getEntities()) {
    System.out.println(affectedEntity.getEntityValue());
    System.out.println(affectedEntity.getAwsAccountId());
    System.out.println(affectedEntity.getEntityArn());
 }
```

**DescribeEntityAggregates**

```
import com.amazonaws.services.health.model.DescribeEntityAggregatesRequest;
import com.amazonaws.services.health.model.DescribeEntityAggregatesResult;
import com.amazonaws.services.health.model.EntityAggregate;

DescribeEntityAggregatesRequest request = new DescribeEntityAggregatesRequest();

request.setEventArns(singletonList("arn:aws:health:us-east-1::event/service/eventTypeCode/eventId"));

DescribeEntityAggregatesResult response = awsHealthClient.describeEntityAggregates(request);

for (EntityAggregate entityAggregate : response.getEntityAggregates()) {
    System.out.println(entityAggregate.getEventArn());
    System.out.println(entityAggregate.getCount());
 }
```