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.
# Connexion d'une application Java à votre agent Amazon MQ
Après avoir créé un agent ActiveMQ Amazon MQ, vous pouvez y connecter votre application. Les exemples suivants montrent comment utiliser Java Message Service (JMS) pour créer une connexion à l'agent, créer une file d'attente et envoyer un message. Pour un exemple Java complet et fonctionnel, consultez [Exemples pratiques d'utilisation de Java Message Service (JMS) avec ActiveMQ](amazon-mq-working-java-example.md).
Vous pouvez vous connecter à des agents ActiveMQ à l’aide de [différents clients ActiveMQ](http://activemq.apache.org/cross-language-clients.html). Nous vous recommandons d’utiliser le [client ActiveMQ](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client).
**Topics**
+ [Conditions préalables](#connect-application-prerequisites-tutorial)
+ [Pour créer un producteur de messages et envoyer un message](#create-producer-send-message-tutorial)
+ [Pour créer un consommateur de messages et recevoir le message](#create-consumer-receive-message-tutorial)
## Conditions préalables
### Activer les attributs du VPC
Pour vous assurer que votre agent est accessible dans votre VPC, vous devez activer les attributs `enableDnsHostnames` et `enableDnsSupport` du VPC. Pour plus d'informations, consultez [Prise en charge du DNS dans votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) dans le *Guide de l'utilisateur Amazon VPC*.
### Activation des connexions entrantes
Activez ensuite les connexions entrantes pour votre application.
1. Connectez-vous à la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Dans la liste des courtiers, choisissez le nom de votre courtier (par exemple, **MyBroker**).
1. Sur la ***MyBroker***page, dans la section **Connexions**, notez les adresses et les ports de l'URL de la console Web du courtier et des protocoles au niveau du fil.
1. Dans la section **Details (Détails)**, sous **Security and network (Sécurité et réseau)**, choisissez le nom de votre groupe de sécurité ou ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
La page **Groupes de sécurité** du tableau de bord EC2 est affichée.
1. Dans la liste des groupes de sécurité, choisissez votre groupe de sécurité.
1. Au bas de la page, choisissez **Entrant**, puis **Modifier**.
1. Dans la boîte de dialogue **Edit inbound rules (Modifier les règles entrantes)**, ajoutez une règle pour chaque URL ou point de terminaison pour qu'ils soient accessibles publiquement (l'exemple suivant montre comment procéder pour une console web d'agent).
1. Choisissez **Add Rule** (Ajouter une règle).
1. Pour **Type**, sélectionnez **Custom TCP (TCP personnalisé)**.
1. Pour **Port Range (Plage de ports)**, saisissez le port de la console web (`8162`).
1. Pour **Source**, laissez l'option **Custom (Personnalisée)** sélectionnée, puis tapez l'adresse IP du système qui doit pouvoir accéder à la console web (par exemple, `192.0.2.1`).
1. Choisissez **Enregistrer**.
Votre agent peut désormais accepter les connexions entrantes.
### Ajout de dépendances Java
Ajoutez les packages `activemq-client.jar` et `activemq-pool.jar` au chemin de classe Java. L'exemple suivant illustre ces dépendances dans un fichier `pom.xml` de projet Maven.
```
org.apache.activemq
activemq-client
5.15.16
org.apache.activemq
activemq-pool
5.15.16
```
Pour plus d'informations sur `activemq-client.jar`, consultez [Configuration initiale](http://activemq.apache.org/initial-configuration.html) dans la documentation ActiveMQ Apache.
**Important**
Dans l'exemple de code suivant, les producteurs et les consommateurs s'exécutent dans un seul thread. Pour les systèmes de production (ou pour tester le basculement d'instance d'agent), assurez-vous que vos producteurs et vos consommateurs s'exécutent sur des hôtes ou des threads distincts.
## Pour créer un producteur de messages et envoyer un message
Suivez les instructions ci-dessous pour créer un générateur de message et recevoir un message.
1. Créez une fabrique de connexions groupées JMS pour le producteur de messages à l'aide du point de terminaison de votre agent, puis appelez la méthode `createConnection` par rapport à la fabrique.
**Note**
Pour un active/standby courtier, Amazon MQ fournit deux consoles Web ActiveMQ URLs, mais une seule URL est active à la fois. De même, Amazon MQ fournit deux points de terminaison pour chaque protocole de niveau filaire, mais un seul point de terminaison est actif dans chaque paire à la fois. Les suffixes `-1` et `-2` indiquent une paire redondante. Pour de plus amples informations, veuillez consulter [Options de déploiement pour Amazon MQ pour les courtiers ActiveMQ](amazon-mq-broker-architecture.md)).
[Pour les points de terminaison du protocole filaire, vous devez autoriser votre application à se connecter à l'un ou l'autre point de terminaison à l'aide du transport Failover.](http://activemq.apache.org/failover-transport-reference.html)
```
// Create a connection factory.
final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
// Pass the sign-in credentials.
connectionFactory.setUserName(activeMqUsername);
connectionFactory.setPassword(activeMqPassword);
// Create a pooled connection factory.
final PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
pooledConnectionFactory.setConnectionFactory(connectionFactory);
pooledConnectionFactory.setMaxConnections(10);
// Establish a connection for the producer.
final Connection producerConnection = pooledConnectionFactory.createConnection();
producerConnection.start();
// Close all connections in the pool.
pooledConnectionFactory.clear();
```
**Note**
Les producteurs de messages doivent toujours utiliser la classe `PooledConnectionFactory`. Pour de plus amples informations, veuillez consulter [Toujours utiliser le regroupement de connexions](best-practices-activemq.md#always-use-connection-pooling).
1. Créez une session, une file d'attente nommée `MyQueue` et un producteur de messages.
```
// Create a session.
final Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Create a queue named "MyQueue".
final Destination producerDestination = producerSession.createQueue("MyQueue");
// Create a producer from the session to the queue.
final MessageProducer producer = producerSession.createProducer(producerDestination);
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
```
1. Créez la chaîne de message `"Hello from Amazon MQ!"`, puis envoyez le message.
```
// Create a message.
final String text = "Hello from Amazon MQ!";
TextMessage producerMessage = producerSession.createTextMessage(text);
// Send the message.
producer.send(producerMessage);
System.out.println("Message sent.");
```
1. Nettoyez le producteur.
```
producer.close();
producerSession.close();
producerConnection.close();
```
## Pour créer un consommateur de messages et recevoir le message
Suivez les instructions ci-dessous pour créer un générateur de message et recevoir un message.
1. Créez une fabrique de connexions JMS pour le producteur de messages à l'aide du point de terminaison de votre agent, puis appelez la méthode `createConnection` par rapport à la fabrique.
```
// Create a connection factory.
final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
// Pass the sign-in credentials.
connectionFactory.setUserName(activeMqUsername);
connectionFactory.setPassword(activeMqPassword);
// Establish a connection for the consumer.
final Connection consumerConnection = connectionFactory.createConnection();
consumerConnection.start();
```
**Note**
Les consommateurs de messages ne doivent *jamais* utiliser la classe `PooledConnectionFactory`. Pour de plus amples informations, veuillez consulter [Toujours utiliser le regroupement de connexions](best-practices-activemq.md#always-use-connection-pooling).
1. Créez une session, une file d'attente nommée `MyQueue` et un consommateur de messages.
```
// Create a session.
final Session consumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Create a queue named "MyQueue".
final Destination consumerDestination = consumerSession.createQueue("MyQueue");
// Create a message consumer from the session to the queue.
final MessageConsumer consumer = consumerSession.createConsumer(consumerDestination);
```
1. Commencez à attendre les messages et recevez le message lorsqu'il arrive.
```
// Begin to wait for messages.
final Message consumerMessage = consumer.receive(1000);
// Receive the message when it arrives.
final TextMessage consumerTextMessage = (TextMessage) consumerMessage;
System.out.println("Message received: " + consumerTextMessage.getText());
```
**Note**
Contrairement aux services de AWS messagerie (tels qu'Amazon SQS), le consommateur est constamment connecté au courtier.
1. Fermez le consommateur, la session et la connexion.
```
consumer.close();
consumerSession.close();
consumerConnection.close();
```