

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.

# Didacticiels ActiveMQ
Didacticiels ActiveMQ

Les didacticiels suivants vous montrent comment créer et connecter vos agents ActiveMQ. Pour utiliser l'exemple de code Java ActiveMQ, vous devez installer le [kit de développement Java édition Standard](https://www.oracle.com/technetwork/java/javase/downloads/index.html) et apporter des modifications de code.

**Topics**
+ [Creating and Configuring a Network of Brokers](amazon-mq-creating-configuring-network-of-brokers.md)
+ [Connecting a Java application to your broker](amazon-mq-connecting-application.md)
+ [

# Intégration des agents ActiveMQ avec LDAP
](security-authentication-authorization.md)
+ [Connect your Amazon MQ for ActiveMQ broker to Lambda](#activemq-connect-to-lambda)
+ [

# Création d'un utilisateur de courtier ActiveMQ
](amazon-mq-listing-managing-users.md)
+ [

# Modifier un utilisateur de courtier ActiveMQ
](edit-existing-user-console.md)
+ [

# Supprimer un utilisateur de courtier ActiveMQ
](delete-existing-user-console.md)
+ [Working Java Example](amazon-mq-working-java-example.md)

# Création et configuration d'un réseau d'agents Amazon MQ
Création et configuration d'un réseau d'agents

Un *réseau d'agents* est composé de plusieurs [agents à instance unique](amazon-mq-broker-architecture.md#single-broker-deployment) actifs simultanément ou plusieurs [agents actifs/en veille](amazon-mq-broker-architecture.md#active-standby-broker-deployment). Dans ce didacticiel, vous allez apprendre à créer un réseau d'agents à deux agents avec une topologie *source et puits*. 

Pour une présentation conceptuelle et des informations de configuration détaillées, consultez les sections suivantes :
+ [Réseau de courtiers Amazon MQ](network-of-brokers.md)
+ [Correctement configurer votre réseau d'agents](best-practices-activemq.md#network-of-brokers-configure-correctly)
+ `networkConnector`
+ `networkConnectionStartAsynchrone`
+ [Réseaux d'agents](http://activemq.apache.org/networks-of-brokers.html) dans la documentation ActiveMQ

Vous pouvez utiliser la console Amazon MQ pour créer un réseau d'agents Amazon MQ. Puisque vous pouvez démarrer la création des deux agents en parallèle, ce processus dure environ 15 minutes. 

**Topics**
+ [

## Conditions préalables
](#creating-configuring-network-of-brokers-create-brokers)
+ [Configure the Brokers in a Network](#creating-configuring-network-of-brokers-allow-traffic)
+ [Configure Network Connectors for Your Broker](#creating-configuring-network-of-brokers-configure-network-connectors)
+ [Next Steps: Test the Network of Brokers](#creating-configuring-network-of-brokers-test)

## Conditions préalables
Conditions préalables

Pour créer un réseau d'agents, vous devez disposer des éléments suivants :
+ Deux ou plusieurs agents actifs simultanément (nommés `MyBroker1` et `MyBroker2` dans ce didacticiel). Pour plus d'informations sur la création d'agents, consultez le didacticiel [Mise en route : création et connexion à un courtier ActiveMQ](getting-started-activemq.md).
+ Les deux courtiers doivent appartenir au même VPC ou être pairs. VPCs Pour plus d'informations VPCs, consultez [Qu'est-ce qu'Amazon VPC ?](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) dans le *guide de l'utilisateur Amazon VPC* et [qu'est-ce que le peering VPC ?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) dans le guide de *peering Amazon VPC*.
**Important**  
Si vous n'avez pas de VPC par défaut, de sous-réseau(x) ou de groupe de sécurité, vous devez les créer en premier. Pour plus d'informations, consultez ce qui suit dans le *Guide de l'utilisateur Amazon VPC* :  
[Création d'un VPC par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-vpc)
[Création d'un sous-réseau par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet)
[Création d'un groupe de sécurité](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#CreatingSecurityGroups)
+ Deux utilisateurs avec des informations d'identification de connexion identiques pour les deux agents. Pour plus d'informations sur la création d'utilisateurs, consultez [Création d'un utilisateur de courtier ActiveMQ](amazon-mq-listing-managing-users.md). 
**Note**  
Lors de l'intégration de l'authentification LDAP à un réseau d'agents, assurez-vous que l'utilisateur existe à la fois en tant qu'agents ActiveMQ et en tant qu'utilisateur LDAP.

L'exemple suivant utilise deux [agents à instance unique](amazon-mq-broker-architecture.md#single-broker-deployment). Cependant, vous pouvez créer des réseaux d'agents à l'aide d'[agents actifs/en veille](amazon-mq-broker-architecture.md#active-standby-broker-deployment) ou d'une combinaison des modes de déploiement d'agents.

## Étape 1 : Autoriser le trafic entre les agents


Une fois que vous avez créé vos agents, vous devez autoriser le trafic entre eux.

1. Sur la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/), sur la page **MyBroker2**, dans la section **Détails**, sous **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 **Modifier les règles entrantes**, ajoutez une règle pour le OpenWire point de terminaison.

   1. Choisissez **Add Rule** (Ajouter une règle).

   1. Pour **Type**, sélectionnez **Custom TCP (TCP personnalisé)**.

   1. Pour **Port Range**, tapez le OpenWire port (`61617`).

   1. Effectuez l’une des actions suivantes :
      + Si vous souhaitez limiter l'accès à une adresse IP en particulier, pour **Source**, laissez **Personnalisé** sélectionné, puis saisissez l'adresse IP de `MyBroker1`, suivie de `/32`. (Cela convertit l'adresse IP en un enregistrement CIDR valide). Pour plus d'informations, consultez [Interfaces réseau Elastic](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html).
**Astuce**  
Pour extraire l'adresse IP de `MyBroker1`, sur la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/), choisissez le nom de l'agent et accédez à la section **Details (Détails)**.
      + Si tous vos agents sont privés et appartiennent au même VPC, pour **Source**, laissez **Personnalisé** sélectionné, puis saisissez l'ID du groupe de sécurité que vous modifiez.
**Note**  
Pour les agents publics, vous devez limiter l'accès à l'aide d'adresses IP.

   1. Choisissez **Enregistrer**.

      Votre agent peut désormais accepter les connexions entrantes.

## Étape 2 : Configurer le réseau de connecteurs pour votre agent


Une fois le trafic autorisé entre vos agents, vous devez configurer les connecteurs de réseau pour l'un d'entre eux.

1. Modifiez la révision de configuration pour l'agent `MyBroker1`.

   1. Sur la page **MyBroker1**, choisissez **Modifier**.

   1. Sur la page **Modifier MyBroker 1**, dans la section **Configuration**, choisissez **Afficher**.

      Le type de moteur de l'agent et la version que la configuration utilise (par exemple, **Apache ActiveMQ 5.15.0**) sont affichés.

   1. Dans l'onglet **Configuration details**, le numéro de révision de configuration, la description et la configuration d'agent au format XML sont affichés.

   1. Choisissez **Modifier la configuration**.

   1. En bas du fichier de configuration, supprimez la section `<networkConnectors>` et incluez les informations suivantes :
      + Le `name` du connecteur de réseau.
      + [Le `username`](#creating-configuring-network-of-brokers-create-brokers) de la console web ActiveMQ qui est commune aux deux agents.
      + Activer les connexions `duplex`.
      + Effectuez l’une des actions suivantes :
        + Si vous connectez le broker à un broker à instance unique, utilisez le `static:` préfixe et le OpenWire point de terminaison `uri` pour. `MyBroker2` Par exemple :

          ```
          <networkConnectors>
            <networkConnector name="connector_1_to_2" userName="myCommonUser" duplex="true"
              uri="static:(ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61617)"/>
          </networkConnectors>
          ```
        + Si vous connectez le courtier à un courtier actif/de secours, utilisez le `static+failover` transport et le point de OpenWire terminaison `uri` pour les deux courtiers avec les paramètres de requête suivants. `?randomize=false&maxReconnectAttempts=0` Par exemple :

          ```
          <networkConnectors>
            <networkConnector name="connector_1_to_2" userName="myCommonUser" duplex="true"
              uri="static:(failover:(ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61617,
              ssl://b-9876l5k4-32ji-109h-8gfe-7d65c4b132a1-2.mq.us-west-2.amazonaws.com:61617)?randomize=false&amp;maxReconnectAttempts=0)"/>
          </networkConnectors>
          ```
**Note**  
N'incluez pas les informations d'identification de connexion pour l'utilisateur ActiveMQ.

   1. Choisissez **Enregistrer**.

   1. Dans la boîte de dialogue **Save revision (Enregistrer la révision)**, tapez `Add network of brokers connector for MyBroker2`.

   1. Choisissez **Enregistrer** pour enregistrer la nouvelle révision de la configuration.

1. Modifier l'agent `MyBroker1` pour définir la dernière révision de configuration comme s'appliquant immédiatement.

   1. Sur la page **MyBroker1**, choisissez **Modifier**.

   1. Sur la page **Modifier MyBroker 1**, dans la section **Configuration**, sélectionnez **Planifier les modifications**.

   1. Dans la section **Schedule broker modifications (Planifier les modifications de l'agent)**, choisissez d'appliquer les modifications **immédiatement**.

   1. Cliquez sur **Appliquer**.

      L'agent `MyBroker1` est redémarré et votre révision de configuration est appliquée.

   Le réseau d'agents est créé.

## Étapes suivantes


Une fois votre réseau d'agents configuré, vous pouvez le tester en produisant et en consommant des messages.

**Important**  
Assurez-vous d'[activer les connexions entrantes](amazon-mq-working-java-example.md#quick-start-allow-inbound-connections) *depuis votre machine locale* pour le broker `MyBroker1` sur le port 8162 (pour la console Web ActiveMQ) et le port 61617 (pour le point de terminaison). OpenWire  
Il se peut également que vous ayez besoin de régler les paramètres de votre(vos) groupe(s) de sécurité afin d'autoriser le producteur et le consommateur à se connecter au réseau d'agents.

1. Sur la [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/), accédez à la section **Connections (Connexions)** et notez le point de terminaison de la console web ActiveMQ pour l'agent `MyBroker1`.

1. Accédez à la console web ActiveMQ pour l'agent `MyBroker1`.

1. Pour vérifier que le pont réseau est connecté, choisissez **Réseau**.

   Dans la section **Network Bridges** (Ponts de réseau), le nom et l'adresse du `MyBroker2` sont listés dans les colonnes **Remote Broker** (Agent à distance) et **Remote Address** (Adresse à distance).

1. À partir de n'importe quelle machine ayant accès à l'agent `MyBroker2`, créez un consommateur. Par exemple :

   ```
   activemq consumer --brokerUrl "ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61617" \
   	--user commonUser \
   	--password myPassword456 \
   	--destination queue://MyQueue
   ```

   Le consommateur se connecte au OpenWire point de terminaison de `MyBroker2` et commence à consommer les messages de la file d'attente`MyQueue`.

1. À partir de n'importe quelle machine ayant accès à l'agent `MyBroker1`, créez un producteur et envoyez quelques messages. Par exemple :

   ```
   activemq producer --brokerUrl "ssl://b-9876l5k4-32ji-109h-8gfe-7d65c4b132a1-1.mq.us-east-2.amazonaws.com:61617" \
   	--user commonUser \
   	--password myPassword456 \
   	--destination queue://MyQueue \
   	--persistent true \
   	--messageSize 1000 \
   	--messageCount 10000
   ```

   Le producteur se connecte au OpenWire point de terminaison de `MyBroker1` et commence à produire des messages persistants à mettre en file d'attente`MyQueue`.

# Connexion d'une application Java à votre agent Amazon MQ
Connexion d'une application Java à votre agent

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.

```
<dependencies>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.15.16</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-pool</artifactId>
        <version>5.15.16</version>
    </dependency>
</dependencies>
```

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();
   ```

# Intégration des agents ActiveMQ avec LDAP
Intégration des agents ActiveMQ avec LDAP

**Important**  
Amazon MQ ne prend pas en charge les certificats de serveur émis par une autorité de certification privée.

Vous pouvez accéder à vos agents ActiveMQ en utilisant les protocoles suivants avec TLS activé :
+ [AMQP](http://activemq.apache.org/amqp.html)
+ [MQTT](http://activemq.apache.org/mqtt.html)
+ MQTT terminé [WebSocket](http://activemq.apache.org/websockets.html)
+ [OpenWire](http://activemq.apache.org/openwire.html)
+ [STOMP](http://activemq.apache.org/stomp.html)
+ STOMP over WebSocket

Amazon MQ offre un choix entre l'authentification ActiveMQ native et l'authentification LDAP et l'autorisation pour gérer les autorisations utilisateur. Pour plus d'informations sur les restrictions liées aux noms d'utilisateur et aux mots de passe ActiveMQ, consultez [Utilisateurs](amazon-mq-limits.md#activemq-user-limits).

Pour autoriser des utilisateurs et des groupes ActiveMQ à utiliser des files d'attente et des rubriques, vous devez [modifier la configuration de votre agent](amazon-mq-creating-applying-configurations.md). Amazon MQ utilise le [plugin Simple Authentication](http://activemq.apache.org/security.html#Security-SimpleAuthenticationPlugin) d'ActiveMQ pour limiter la lecture et l'écriture aux destinations. Pour plus d'informations et d'exemples, consultez [Toujours configurer un plan d'autorisation](using-amazon-mq-securely.md#always-configure-authorization-map) et `authorizationEntry`.

**Note**  
Actuellement, Amazon MQ ne prend pas en charge l'authentification par certificat client.

**Topics**
+ [

## Intégrer LDAP avec ActiveMQ
](#integrate-ldap)
+ [

## Conditions préalables
](#ldap-prerequisites)
+ [

## Mise en route avec LDAP
](#ldap-get-started)
+ [

## Fonctionnement de l'intégration avec LDAP
](#ldap-support-details)

## Intégrer LDAP avec ActiveMQ


Vous pouvez authentifier les utilisateurs Amazon MQ à l'aide des informations d'identification stockées dans votre Active Directory ou un autre serveur LDAP. Vous pouvez également ajouter, supprimer et modifier des utilisateurs Amazon MQ et attribuer des autorisations aux rubriques et aux files d'attente. Les opérations de gestion telles que la création, la mise à jour et la suppression des agents nécessitent toujours des informations d'identification IAM et ne sont pas intégrées à LDAP.

Les clients qui souhaitent simplifier et centraliser leur authentification et leur autorisation d'agent Amazon MQ à l'aide d'un serveur LDAP peuvent utiliser cette fonctionnalité. La conservation de toutes les informations d'identification utilisateur sur le serveur LDAP permet d'économiser du temps et des efforts en fournissant un emplacement central pour stocker et gérer ces informations d'identification.

Amazon MQ fournit la prise en charge LDAP à l'aide du plugin Apache ActiveMQ JAAS. Tout serveur LDAP, tel que Microsoft Active Directory ou OpenLDAP pris en charge par le plugin, est également pris en charge par Amazon MQ. Pour de plus amples informations sur le plugin, veuillez consulter la section [Sécurité](https://activemq.apache.org/security) de la documentation ActiveMQ.

Outre les utilisateurs, vous pouvez spécifier l'accès aux rubriques et aux files d'attente pour un groupe spécifique ou un utilisateur via votre serveur LDAP. Pour ce faire, créez des entrées représentant des rubriques et des files d'attente dans votre serveur LDAP, puis attribuez des autorisations à un utilisateur LDAP spécifique ou à un groupe. Vous pouvez ensuite configurer l'agent pour récupérer les données d'autorisation à partir du serveur LDAP.

**Important**  
 Lorsque vous utilisez LDAP, l'authentification ne distingue pas les majuscules des minuscules, mais l'autorisation fait la distinction entre majuscules et minuscules pour votre nom d'utilisateur. 

## Conditions préalables


Avant d'ajouter la prise en charge LDAP à un agent Amazon MQ nouveau ou existant, vous devez configurer un compte de service. Ce compte de service est requis pour initier une connexion à un serveur LDAP et doit disposer des autorisations appropriées pour établir cette connexion. Ce compte de service configurera l'authentification LDAP pour votre agent. Toutes les connexions client successives seront authentifiées via la même connexion. 

Un compte de service est un compte de votre serveur LDAP qui a accès afin d'initier une connexion. Il s'agit d'une exigence LDAP standard et vous ne devez fournir les informations d'identification du compte de service qu'une seule fois. Une fois la connexion configurée, toutes les futures connexions client sont authentifiées via votre serveur LDAP. Les informations d'identification de votre compte de service sont stockées de manière sécurisée sous une forme chiffrée, accessible uniquement à Amazon MQ.

Pour intégrer ActiveMQ, une arborescence d'informations d'annuaire (DIT) spécifique est requise sur le serveur LDAP. Pour un exemple de fichier `ldif` qui montre clairement cette structure, consultez *Import the following LDIF file into the LDAP server (Importer le fichier LDIF suivant dans le serveur LDAP)* dans la section [Security (Sécurité)](https://activemq.apache.org/security) de la documentation ActiveMQ.

## Mise en route avec LDAP


Pour commencer, accédez à la console Amazon MQ et choisissez **LDAP authentication and authorization (Authentification et autorisation LDAP)** lorsque vous créez une instance d'agent existante ou nouvelle Amazon MQ.

Fournissez les informations suivantes sur le compte de service :
+ **Fully qualified domain name (Nom de domaine entièrement qualifié)** : Emplacement du serveur LDAP auquel les demandes d'authentification et d'autorisation doivent être émises.
**Note**  
Le nom de domaine complet du serveur LDAP que vous fournissez ne doit pas inclure le numéro de protocole ou de port. Amazon MQ va ajouter le nom de domaine complet au protocole `ldaps`, et ajoutera le numéro de port `636`.  
Par exemple, si vous fournissez le domaine complet suivant `example.com`, Amazon MQ accède à votre serveur LDAP à l'aide de l'URL suivante : `ldaps://example.com:636`.  
Pour que l'hôte de l'agent puisse communiquer avec le serveur LDAP, le nom de domaine complet doit pouvoir être résolu publiquement. Pour garder le serveur LDAP privé et sécurisé, limitez le trafic entrant dans les règles entrantes du serveur afin d'autoriser uniquement le trafic provenant du VPC de l'agent.
+ **Service account username (Nom d'utilisateur du compte de service)** Nom unique de l'utilisateur qui sera utilisé pour effectuer la liaison initiale au serveur LDAP.
+ **Service account password (Mot de passe du compte de service)** Mot de passe de l'utilisateur effectuant la liaison initiale.

L'image suivante met en évidence où fournir ces détails.

![\[Où spécifier les détails du compte de service LDAP.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-service-account.png)


Dans la section **LDAP login configuration (Configuration de la connexion LDAP)**, fournissez les informations requises suivantes :
+ **User Base (Base d'utilisateurs)** Nom unique du nœud de l'arborescence des informations de répertoire (DIT) qui sera recherché pour les utilisateurs.
+ **User Search Matching (Recherche d'utilisateur)** Filtre de recherche LDAP qui sera utilisé pour rechercher des utilisateurs dans `userBase`. Le nom d'utilisateur du client est remplacé par l'espace réservé `{0}` dans le filtre de recherche. Pour plus d’informations, consultez [Authentification](#ldap-authentication) et [Autorisation](#ldap-authorization).
+ **Role Base (Base de rôles)** Nom unique du nœud du DIT qui sera recherché pour des rôles. Les rôles peuvent être configurés en tant qu'entrées de groupe LDAP explicites dans votre répertoire. Une entrée de rôle typique peut consister en un attribut pour le nom du rôle, tel que **Nom commun**, et un autre attribut, tel que `member`, avec des valeurs représentant les noms distinctifs ou les noms d'utilisateur des utilisateurs appartenant au groupe de rôles. Par exemple, compte tenu de l'unité administrative, `group`, vous pouvez fournir le nom distinctif suivant : `ou=group,dc=example,dc=com`.
+ **Role Search Matching (Recherche de rôle)** Filtre de recherche LDAP qui sera utilisé pour rechercher des rôles dans `roleBase`. Le nom unique de l'utilisateur correspondant à `userSearchMatching` est remplacé dans l'espace réservé `{0}` du filtre de recherche. Le nom d'utilisateur du client sera remplacé par l'espace réservé `{1}`. Par exemple, si les entrées de rôle dans votre répertoire incluent un attribut nommé `member`, contenant les noms d'utilisateur de tous les utilisateurs de ce rôle, vous pouvez fournir le filtre de recherche suivant : `(member:=uid={1})`.

 L'image suivante met en surbrillance l'endroit où spécifier ces détails.

![\[Où spécifier les détails de connexion LDAP.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-login-configuration.png)


Dans **Optional settings (Paramètres facultatifs)**, vous pouvez fournir les informations facultatives suivantes :
+ **User Role Name (Nom du rôle utilisateur)** Le nom de l'attribut LDAP dans l'entrée de répertoire de l'utilisateur aux fins de l'adhésion au groupe de l'utilisateur. Dans certains cas, les rôles utilisateur peuvent être identifiés par la valeur d'un attribut dans l'entrée de répertoire de l'utilisateur. L'option `userRoleName` vous permet de fournir le nom de cet attribut. Par exemple, considérons l'entrée utilisateur suivante :

  ```
  dn: uid=jdoe,ou=user,dc=example,dc=com
  objectClass: user
  uid: jdoe
  sn: jane
  cn: Jane Doe
  mail: j.doe@somecompany.com
  memberOf: role1
  userPassword: password
  ```

  Pour fournir le bon `userRoleName` pour l'exemple ci-dessus, spécifiez l'attribut `memberOf`. Si l'authentification réussit, le rôle `role1` est affecté à l'utilisateur.
+ **Role Name (Nom du rôle)** L'attribut du nom de groupe dans une entrée de rôle dont la valeur constitue le nom de ce rôle. Par exemple, vous pouvez spécifier `cn` pour le **nom commun** d'une entrée de groupe. Si l'authentification réussit, l'utilisateur reçoit la valeur de l'attribut `cn` pour chaque entrée de rôle dont il est membre.
+ **User Search Subtree (Sous-arborescence de recherche d'utilisateur)** Définit l'étendue de la requête de recherche utilisateur LDAP. Si true, la portée est définie pour rechercher la sous-arborescence entière sous le nœud défini par `userBase`.
+ **Role Search Subtree (Sous-arborescence de recherche de rôle)** Définit l'étendue de la requête de recherche utilisateur LDAP. Si true, la portée est définie pour rechercher la sous-arborescence entière sous le nœud défini par `roleBase`.

L'image suivante met en surbrillance l'endroit où spécifier ces paramètres facultatifs.

![\[Optional settings for LDAP attributes and search scope in role search matching.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-active-ldap-optional-settings.png)


## Fonctionnement de l'intégration avec LDAP


Vous pouvez penser à l'intégration dans deux catégories principales : la structure pour l'authentification et la structure pour l'autorisation.

### Authentification


Pour l'authentification, les informations d'identification du client doivent être valides. Ces informations d'identification sont validées par rapport aux utilisateurs de la base d'utilisateurs du serveur LDAP.

La base d'utilisateurs fournie à l'agent ActiveMQ doit pointer vers le nœud dans le DIT où les utilisateurs sont stockés sur le serveur LDAP. Par exemple, si vous utilisez AWS Managed Microsoft AD, et que vous avez les composants du domaine `corp``example`, et que vous avez au sein de ceux-ci`com`, vous avez des unités organisationnelles `corp` et `Users` que vous utiliseriez les éléments suivants comme base d'utilisateurs :

```
OU=Users,OU=corp,DC=corp,DC=example,DC=com
```

L'agent ActiveMQ recherche à cet emplacement dans le DIT les utilisateurs afin d'authentifier les demandes de connexion client auprès de l'agent.

![\[Emplacement pour rechercher des utilisateurs\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-structure.png)


Parce que le code source ActiveMQ code en dur le nom de l'attribut pour les utilisateurs sur `uid`, vous devez vous assurer que cet attribut est défini à chaque utilisateur. Pour plus de simplicité, vous pouvez utiliser le nom d'utilisateur de connexion de l'utilisateur. Pour plus d'informations, consultez le code source [activemq](https://github.com/apache/activemq/blob/c3d9b388e4f1fe73e348bf466122fe6862e064a0/activemq-broker/src/main/java/org/apache/activemq/security/SimpleCachedLDAPAuthorizationMap.java#L89) et [Configuration des mappages d'ID dans les utilisateurs et ordinateurs Active Directory pour les versions Windows Server 2016 (et ultérieures)](https://www.ibm.com/support/knowledgecenter/en/STXKQY_5.0.3/com.ibm.spectrum.scale.v5r03.doc/bl1adm_confidmapaduc.htm).

Pour activer l'accès à la console ActiveMQ pour des utilisateurs spécifiques, assurez-vous qu'ils appartiennent au `amazonmq-console-admins`.

### Autorisation


Pour l'autorisation, les bases de recherche d'autorisations sont spécifiées dans la configuration de l'agent. L'autorisation est effectuée sur une base par destination (ou caractère générique, ensemble de destination) via l'élément `cachedLdapAuthorizationMap`, qui se trouve dans le fichier de configuration `activemq.xml` de l'agent. Pour de plus amples informations, consultez [Module d'autorisation LDAP mis en cache](https://activemq.apache.org/cached-ldap-authorization-module).

**Note**  
Pour pouvoir utiliser l'`cachedLDAPAuthorizationMap`élément dans le fichier de `activemq.xml` configuration de votre courtier, vous devez choisir l'option **Authentification et autorisation LDAP** lors de la [création d'une configuration via le AWS Management Console](amazon-mq-creating-applying-configurations.md), ou définir la [création d'une configuration via le AWS Management Console, ou définir la [https://docs.aws.amazon.com//amazon-mq/latest/api-reference/configurations.html#configurations-model-authenticationstrategy](https://docs.aws.amazon.com//amazon-mq/latest/api-reference/configurations.html#configurations-model-authenticationstrategy)](amazon-mq-creating-applying-configurations.md)propriété sur `LDAP` lors de la création d'une nouvelle configuration à l'aide de l'API Amazon MQ.

Vous devez fournir les trois attributs suivants dans l'élément `cachedLDAPAuthorizationMap` :
+ `queueSearchBase`
+ `topicSearchBase`
+ `tempSearchBase`

**Important**  
Pour éviter que des informations sensibles ne soient directement placées dans le fichier de configuration de l'agent, Amazon MQ bloque l'utilisation des attributs suivants dans `cachedLdapAuthorizationMap` :  
`connectionURL`
`connectionUsername`
`connectionPassword`
Lorsque vous créez un courtier, Amazon MQ remplace les valeurs que vous fournissez par le biais ou dans la AWS Management Console[https://docs.aws.amazon.com//amazon-mq/latest/api-reference/brokers.html#brokers-prop-createbrokerinput-ldapservermetadata](https://docs.aws.amazon.com//amazon-mq/latest/api-reference/brokers.html#brokers-prop-createbrokerinput-ldapservermetadata)propriété de votre demande d'API par les attributs ci-dessus.

L'exemple suivant illustre un exemple d'utilisation de `cachedLdapAuthorizationMap`.

```
<authorizationPlugin>
    <map>
        <cachedLDAPAuthorizationMap
            queueSearchBase="ou=Queue,ou=Destination,ou=corp,dc=corp,dc=example,dc=com"
            topicSearchBase="ou=Topic,ou=Destination,ou=corp,dc=corp,dc=example,dc=com"
            tempSearchBase="ou=Temp,ou=Destination,ou=corp,dc=corp,dc=example,dc=com"
            refreshInterval="300000"
            legacyGroupMapping="false"
        />
    </map>
</authorizationPlugin>
```

Ces valeurs identifient les emplacements dans le DIT où les autorisations pour chaque type de destination sont spécifiées. Ainsi, dans l'exemple ci-dessus AWS Managed Microsoft AD, en utilisant les mêmes composants de domaine que `corp``example`, et`com`, vous devez spécifier une unité organisationnelle nommée `destination` pour contenir tous vos types de destination. Dans cette unité d'organisation, vous en créeriez un pour `queues`, un pour `topics` et un pour destinations `temp`.

Cela signifie que votre base de recherche de file d'attente, qui fournit des informations d'autorisation pour les destinations de type file d'attente, aurait l'emplacement suivant dans votre DIT :

```
OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com
```

![\[Emplacement de base de recherche de file d'attente.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-queue-structure.png)


De même, les règles d'autorisation pour les rubriques et les destinations temporaires seraient situées au même niveau dans le DIT : 

```
OU=Topic,OU=Destination,OU=corp,DC=corp,DC=example,DC=com
OU=Temp,OU=Destination,OU=corp,DC=corp,DC=example,DC=com
```

Dans l'unité d'organisation pour chaque type de destination (file d'attente, rubrique, temp), un caractère générique ou un nom de destination spécifique peut être fourni. Par exemple, pour fournir une règle d'autorisation pour toutes les files d'attente commençant par le préfixe DEMO.EVENTS.\$1., vous pouvez créer l'unité d'organisation suivante :

```
OU=DEMO.EVENTS.$,OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com
```

**Note**  
L'unité d'organisation `DEMO.EVENTS.$` est dans l'unité d'organisation `Queue`.

Pour plus d'informations sur les caractères génériques dans ActiveMQ, consultez[Caractères génériques](https://activemq.apache.org/wildcards)

Pour fournir des règles d'autorisation pour des files d'attente spécifiques, telles que DEMO.MYQUEUE, spécifiez quelque chose comme suit :

```
OU=DEMO.MYQUEUE,OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com
```

![\[Règles d'autorisation pour des files d'attente spécifiques\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-authorization-rules.png)


### Groupes de sécurité


Dans chaque unité d'organisation qui représente une destination ou un caractère générique, vous devez créer trois groupes de sécurité. Comme toutes les autorisations dans ActiveMQ, il s'agit d'autorisations. read/write/admin Pour plus d'informations sur ce que chacune de ces autorisations permet à un utilisateur, consultez [Sécurité](https://activemq.apache.org/security) dans la documentation ActiveMQ.

Vous devez nommer ces groupes de sécurité `read`, `write` et `admin`. Dans chacun de ces groupes de sécurité, vous pouvez ajouter des utilisateurs ou des groupes, qui auront ensuite l'autorisation d'effectuer les actions associées. Vous aurez besoin de ces groupes de sécurité pour chaque jeu de destinations génériques ou chaque destination individuelle. 

![\[Groupes de sécurité\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-security-groups.png)


**Note**  
Lorsque vous créez le groupe admin, un conflit survient avec le nom du groupe. Ce conflit se produit parce que les règles antérieures à Windows 2000 héritées ne permettent pas aux groupes de partager le même nom, même si les groupes se trouvent à des emplacements différents du DIT. La valeur de la zone de texte **Pre-Windows 2000 (Pré-Windows 2000)** n'a aucun impact sur la configuration, mais elle doit être globalement unique. Pour éviter ce conflit, vous pouvez ajouter un suffixe `uuid` à chaque groupe `admin`.  

![\[Ceci est mon image.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/active-mq-ldap-admin-qualifier.png)


L'ajout d'un utilisateur au groupe de sécurité `admin` pour une destination particulière permettra à l'utilisateur de créer et de supprimer cette rubrique. Les ajouter au groupe de sécurité `read` leur permettra de lire à partir de la destination, et les ajouter au groupe `write` leur permettra d'écrire dans la destination.

Outre l'ajout d'utilisateurs individuels aux autorisations de groupe de sécurité, vous pouvez également ajouter des groupes entiers. Cependant, comme ActiveMQ code à nouveau en dur les noms d'attributs pour les groupes, vous devez vous assurer que le groupe que vous souhaitez ajouter possède la classe d'objet `groupOfNames`, comme illustré dans le code source [ActiveMQ](https://github.com/apache/activemq/blob/c3d9b388e4f1fe73e348bf466122fe6862e064a0/activemq-broker/src/main/java/org/apache/activemq/security/SimpleCachedLDAPAuthorizationMap.java#L86).

Pour ce faire, suivez le même processus qu'avec l'`uid` pour les utilisateurs. Consultez [Configuration des mappages d'ID dans les utilisateurs et ordinateurs Active Directory pour les versions Windows Server 2016 (et ultérieures)](https://www.ibm.com/support/knowledgecenter/en/STXKQY_5.0.3/com.ibm.spectrum.scale.v5r03.doc/bl1adm_confidmapaduc.htm).

## Étape 3 : (Facultatif) Se connecter à une AWS Lambda fonction


 AWS Lambda peut se connecter à votre courtier Amazon MQ et en consommer les messages. Lorsque vous connectez un agent à Lambda, vous créez un [mappage de la source d'événement](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) qui lit les messages d'une file d'attente et appelle la fonction [de manière synchrone](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). Le mappage de la source d'événements que vous créez lit les messages de votre agent par lots et les convertit en une charge utile Lambda sous la forme d'un objet JSON. 

**Pour connecter votre agent à une fonction Lambda**

1. Ajoutez les autorisations de rôle IAM suivantes au [rôle d'exécution](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de votre fonction Lambda.
   + [mq : DescribeBroker](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
   + [EC2 : CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html)
   + [EC2 : DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html)
   + [EC2 : DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html)
   + [EC2 : DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
   + [EC2 : DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
   + [EC2 : DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
   + [journaux : CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
   + [journaux : CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
   + [journaux : PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
   + [responsable des secrets : GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**Note**  
Sans les autorisations IAM nécessaires, votre fonction ne sera pas en mesure de lire correctement les enregistrements des ressources Amazon MQ.

1.  (Facultatif) Si vous avez créé un agent sans accès public, vous devez effectuer l'une des opérations suivantes pour permettre à Lambda de se connecter à votre agent : 
   +  Configurez une passerelle NAT par sous-réseau public. Pour plus d'informations, consultez [Accès à Internet et aux services pour les fonctions connectées à un VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet) dans le *Guide du développeur AWS Lambda *. 
   + Créez une connexion entre votre Amazon Virtual Private Cloud (Amazon VPC) et Lambda à l'aide d'un point de terminaison VPC. Votre Amazon VPC doit également se connecter à AWS Security Token Service (AWS STS) et aux points de terminaison Secrets Manager. Pour plus d’informations, consultez [Configuration de points de terminaison de VPC d’interface pour Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) dans le *Guide du développeur AWS Lambda *. 

1.  [Configurez votre agent en tant que source d'événement](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping) pour une fonction Lambda à l'aide de la AWS Management Console. Vous pouvez également utiliser la [https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) AWS Command Line Interface commande. 

1.  Écrivez du code pour votre fonction Lambda pour traiter les messages consommés par votre agent. La charge utile Lambda récupérée par votre mappage de source d'événement dépend du type de moteur de l'agent. Voici un exemple de charge utile Lambda pour une file d'attente Amazon MQ for ActiveMQ. 
**Note**  
 Dans cet exemple, `testQueue` est le nom de la file d'attente. 

   ```
   {
     "eventSource": "aws:amq",
     "eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
     "messages": {
       [
         {
           "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1---mq---us-west-2.amazonaws.com.rproxy.govskope.ca-37557-1234520418293-4:1:1:1:1",
           "messageType": "jms/text-message",
           "data": "QUJDOkFBQUE=",
           "connectionId": "myJMSCoID",
           "redelivered": false,
           "destination": {
             "physicalname": "testQueue" 
           }, 
           "timestamp": 1598827811958,
           "brokerInTime": 1598827811958,
           "brokerOutTime": 1598827811959
         },
         {
           "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1---mq---us-west-2.amazonaws.com.rproxy.govskope.ca-37557-1234520418293-4:1:1:1:1",
           "messageType":"jms/bytes-message",
           "data": "3DTOOW7crj51prgVLQaGQ82S48k=",
           "connectionId": "myJMSCoID1",
           "persistent": false,
           "destination": {
             "physicalname": "testQueue" 
           }, 
           "timestamp": 1598827811958,
           "brokerInTime": 1598827811958,
           "brokerOutTime": 1598827811959
         }
       ]
     }
   }
   ```

Pour plus d'informations sur la connexion d'Amazon MQ à Lambda, les options prises en charge par Lambda pour une source d'événement Amazon MQ et les erreurs de mappage de source d'événement, consultez [Utilisation de Lambda avec Amazon MQ](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html) dans le *Guide du développeur AWS Lambda *.

# Création d'un utilisateur de courtier ActiveMQ
Création d'un utilisateur de courtier ActiveMQ

Un *utilisateur* ActiveMQ est une personne ou une application qui peut accéder aux files d'attente et aux rubriques d'un agent ActiveMQ. Vous pouvez configurer les utilisateurs pour qu'ils disposent d'autorisations spécifiques. Par exemple, vous pouvez autoriser certains utilisateurs à accéder à la [console web ActiveMQ](http://activemq.apache.org/web-console.html).

Un *groupe* est une étiquette sémantique. Vous pouvez affecter un groupe à un utilisateur et configurer des autorisations pour les groupes pour envoyer vers, recevoir depuis et administrer des files d'attente et des rubriques spécifiques.

**Note**  
Vous ne pouvez pas configurer des groupes indépendamment des utilisateurs. Une étiquette de groupe est créée lorsque vous ajoutez au moins un utilisateur et supprimée lorsque vous en supprimez tous les utilisateurs.

**Note**  
 Le `activemq-webconsole` groupe dans ActiveMQ sur Amazon MQ possède des autorisations d'administrateur sur toutes les files d'attente et sur tous les sujets. Tous les utilisateurs de ce groupe auront un accès administrateur. 

Les exemples suivants montrent comment créer, modifier et supprimer des utilisateurs d'agent Amazon MQ à l'aide de AWS Management Console.

## Création d'un nouvel utilisateur de courtier ActiveMQ


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**), puis choisissez **Afficher les détails**.

   Sur la ***MyBroker***page, dans la section **Utilisateurs**, tous les utilisateurs de ce courtier sont répertoriés.  
![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png)

1. Choisissez **Create user (Créer un utilisateur)**.

1. Dans la boîte de dialogue **Create user (Créer un utilisateur)**, saisissez un **Username (Nom d'utilisateur)** et un **Password (Mot de passe)**.

1. (Facultatif) Saisissez les noms des groupes auxquels l'utilisateur appartient, séparés par des virgules (par exemple : `Devs, Admins`).

1. (Facultatif) Pour permettre à l'utilisateur d'accéder à la [console web ActiveMQ](http://activemq.apache.org/web-console.html), choisissez **ActiveMQ Web Console**.

1. Choisissez **Create user (Créer un utilisateur)**.
**Important**  
Apporter des modifications à une configuration n'applique *pas* immédiatement les modifications à l'agent. Pour appliquer vos modifications, vous devez attendre la fenêtre de maintenance suivante ou [redémarrer l’agent](amazon-mq-rebooting-broker.md).

# Modifier un utilisateur de courtier ActiveMQ


 Pour modifier un utilisateur existant, procédez comme suit : 

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**), puis choisissez **Afficher les détails**.

   Sur la ***MyBroker***page, dans la section **Utilisateurs**, tous les utilisateurs de ce courtier sont répertoriés.  
![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png)

1. Sélectionnez vos informations d'identification de connexion et choisissez **Modifier**.

   La boîte de dialogue **Edit user (Modifier l'utilisateur)** s'affiche.

1. (Facultatif) Saisissez un nouveau **Password (Mot de passe)**.

1. (Facultatif) Ajoutez ou supprimez les noms des groupes auxquels l'utilisateur appartient, séparés par des virgules (par exemple : `Managers, Admins`).

1. (Facultatif) Pour permettre à l'utilisateur d'accéder à la [console web ActiveMQ](http://activemq.apache.org/web-console.html), choisissez **ActiveMQ Web Console**.

1. Pour enregistrer les modifications apportées à l'utilisateur, choisissez **Done (Terminé)**.
**Important**  
Apporter des modifications à une configuration n'applique *pas* immédiatement les modifications à l'agent. Pour appliquer vos modifications, vous devez attendre la fenêtre de maintenance suivante ou [redémarrer l’agent](amazon-mq-rebooting-broker.md).

# Supprimer un utilisateur de courtier ActiveMQ


 Lorsque vous n'avez plus besoin d'un utilisateur, vous pouvez le supprimer. 

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**), puis choisissez **Afficher les détails**.

   Sur la ***MyBroker***page, dans la section **Utilisateurs**, tous les utilisateurs de ce courtier sont répertoriés.  
![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/fr_fr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png)

1. Sélectionnez vos informations de connexion (par exemple, ***MyUser***), puis choisissez **Supprimer**.

1. Pour confirmer la suppression de l'utilisateur, dans le champ **Supprimer *MyUser* ?** dans une boîte de dialogue, choisissez **Supprimer**.
**Important**  
Apporter des modifications à une configuration n'applique *pas* immédiatement les modifications à l'agent. Pour appliquer vos modifications, vous devez attendre la fenêtre de maintenance suivante ou [redémarrer l’agent](amazon-mq-rebooting-broker.md).

# Exemples pratiques d'utilisation de Java Message Service (JMS) avec ActiveMQ
Exemples Java pratiques

Les exemples suivants montrent comment utiliser ActiveMQ par programmation :
+ L' OpenWire exemple de code Java permet de se connecter à un courtier, de créer une file d'attente, d'envoyer et de recevoir un message. Pour obtenir une analyse et une explication détaillées, consultez [Connexion d'une application Java à votre agent Amazon MQ](amazon-mq-connecting-application.md).
+ L'exemple de code Java MQTT se connecte à un agent, crée une rubrique, et publie et reçoit un message.
+ L'exemple de code Java STOMP\$1WSS se connecte à un agent, crée une file d'attente, et envoie et reçoit un message.

## 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*.

### Activer les connexions entrantes


 Pour utiliser Amazon MQ par programmation, vous devez utiliser des connexions entrantes. 

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.

### Ajouter des dépendances Java


------
#### [ OpenWire ]

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.

```
<dependencies>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.15.16</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-pool</artifactId>
        <version>5.15.16</version>
    </dependency>
</dependencies>
```

Pour plus d'informations sur `activemq-client.jar`, consultez [Configuration initiale](http://activemq.apache.org/initial-configuration.html) dans la documentation ActiveMQ Apache.

------
#### [ MQTT ]

Ajoutez le package `org.eclipse.paho.client.mqttv3.jar` au chemin de classe Java. L'exemple suivant illustre cette dépendance dans un fichier `pom.xml` de projet Maven.

```
<dependencies>
                    <dependency>
                        <groupId>org.eclipse.paho</groupId>
                        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
                        <version>1.2.0</version>
                    </dependency>                               
                    </dependencies>
```

Pour plus d'informations sur `org.eclipse.paho.client.mqttv3.jar`, consultez [Eclipse Paho Java Client](https://www.eclipse.org/paho/clients/java/).

------
#### [ STOMP\$1WSS ]

Ajoutez les packages suivants au chemin de classe Java :
+ `spring-messaging.jar`
+ `spring-websocket.jar`
+ `javax.websocket-api.jar`
+ `jetty-all.jar`
+ `slf4j-simple.jar`
+ `jackson-databind.jar`

L'exemple suivant illustre ces dépendances dans un fichier `pom.xml` de projet Maven.

```
<dependencies>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-messaging</artifactId>
                        <version>5.0.5.RELEASE</version>
                    </dependency>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-websocket</artifactId>
                        <version>5.0.5.RELEASE</version>
                    </dependency>
                    <dependency>
                        <groupId>javax.websocket</groupId>
                        <artifactId>javax.websocket-api</artifactId>
                        <version>1.1</version>
                    </dependency>
                    <dependency>
                        <groupId>org.eclipse.jetty.aggregate</groupId>
                        <artifactId>jetty-all</artifactId>
                        <type>pom</type>
                        <version>9.3.3.v20150827</version>
                    </dependency>
                    <dependency>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-simple</artifactId>
                        <version>1.6.6</version>
                    </dependency>
                    <dependency>
                        <groupId>com.fasterxml.jackson.core</groupId>
                        <artifactId>jackson-databind</artifactId>
                        <version>2.5.0</version>
                    </dependency>
                    </dependencies>
```

Pour plus d'informations, consultez [STOMP Support](https://docs.spring.io/spring-integration/docs/5.0.5.RELEASE/reference/html/stomp.html) dans la documentation du framework Spring.

------

## MQExampleAmazon.java


**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.

------
#### [ OpenWire ]

```
/*
 * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */
                    
                    import org.apache.activemq.ActiveMQConnectionFactory;
                    import org.apache.activemq.jms.pool.PooledConnectionFactory;
                    
                    import javax.jms.*;
                    
                    public class AmazonMQExample {
                    
                    // Specify the connection parameters.
                    private final static String WIRE_LEVEL_ENDPOINT 
                            = "ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61617";
                    private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
                    private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
                    
                    public static void main(String[] args) throws JMSException {
                        final ActiveMQConnectionFactory connectionFactory =
                                createActiveMQConnectionFactory();
                        final PooledConnectionFactory pooledConnectionFactory =
                                createPooledConnectionFactory(connectionFactory);
                    
                        sendMessage(pooledConnectionFactory);
                        receiveMessage(connectionFactory);
                    
                        pooledConnectionFactory.stop();
                    }
                    
                    private static void
                    sendMessage(PooledConnectionFactory pooledConnectionFactory) throws JMSException {
                        // Establish a connection for the producer.
                        final Connection producerConnection = pooledConnectionFactory
                                .createConnection();
                        producerConnection.start();
                    
                        // 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);
                    
                        // Create a message.
                        final String text = "Hello from Amazon MQ!";
                        final TextMessage producerMessage = producerSession
                                .createTextMessage(text);
                    
                        // Send the message.
                        producer.send(producerMessage);
                        System.out.println("Message sent.");
                    
                        // Clean up the producer.
                        producer.close();
                        producerSession.close();
                        producerConnection.close();
                    }
                    
                    private static void
                    receiveMessage(ActiveMQConnectionFactory connectionFactory) throws JMSException {
                        // Establish a connection for the consumer.
                        // Note: Consumers should not use PooledConnectionFactory.
                        final Connection consumerConnection = connectionFactory.createConnection();
                        consumerConnection.start();
                    
                        // 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);
                    
                        // 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());
                    
                        // Clean up the consumer.
                        consumer.close();
                        consumerSession.close();
                        consumerConnection.close();
                    }
                    
                    private static PooledConnectionFactory
                    createPooledConnectionFactory(ActiveMQConnectionFactory connectionFactory) {
                        // Create a pooled connection factory.
                        final PooledConnectionFactory pooledConnectionFactory =
                                new PooledConnectionFactory();
                        pooledConnectionFactory.setConnectionFactory(connectionFactory);
                        pooledConnectionFactory.setMaxConnections(10);
                        return pooledConnectionFactory;
                    }
                    
                    private static ActiveMQConnectionFactory createActiveMQConnectionFactory() {
                        // Create a connection factory.
                        final ActiveMQConnectionFactory connectionFactory =
                                new ActiveMQConnectionFactory(WIRE_LEVEL_ENDPOINT);
                    
                        // Pass the sign-in credentials.
                        connectionFactory.setUserName(ACTIVE_MQ_USERNAME);
                        connectionFactory.setPassword(ACTIVE_MQ_PASSWORD);
                        return connectionFactory;
                    }
                    }
```

------
#### [ MQTT ]

```
/*
 * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */
                    
                    import org.eclipse.paho.client.mqttv3.*;
                    
                    public class AmazonMQExampleMqtt implements MqttCallback {
                    
                    // Specify the connection parameters.
                    private final static String WIRE_LEVEL_ENDPOINT =
                            "ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:8883";
                    private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
                    private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
                    
                    public static void main(String[] args) throws Exception {
                        new AmazonMQExampleMqtt().run();
                    }
                    
                    private void run() throws MqttException, InterruptedException {
                    
                        // Specify the topic name and the message text.
                        final String topic = "myTopic";
                        final String text = "Hello from Amazon MQ!";
                    
                        // Create the MQTT client and specify the connection options.
                        final String clientId = "abc123";
                        final MqttClient client = new MqttClient(WIRE_LEVEL_ENDPOINT, clientId);
                        final MqttConnectOptions connOpts = new MqttConnectOptions();
                    
                        // Pass the sign-in credentials.
                        connOpts.setUserName(ACTIVE_MQ_USERNAME);
                        connOpts.setPassword(ACTIVE_MQ_PASSWORD.toCharArray());
                    
                        // Create a session and subscribe to a topic filter.
                        client.connect(connOpts);
                        client.setCallback(this);
                        client.subscribe("+");
                    
                        // Create a message.
                        final MqttMessage message = new MqttMessage(text.getBytes());
                    
                        // Publish the message to a topic.
                        client.publish(topic, message);
                        System.out.println("Published message.");
                    
                        // Wait for the message to be received.
                        Thread.sleep(3000L);
                    
                        // Clean up the connection.
                        client.disconnect();
                    }
                    
                    @Override
                    public void connectionLost(Throwable cause) {
                        System.out.println("Lost connection.");
                    }
                    
                    @Override
                    public void messageArrived(String topic, MqttMessage message) throws MqttException {
                        System.out.println("Received message from topic " + topic + ": " + message);
                    }
                    
                    @Override
                    public void deliveryComplete(IMqttDeliveryToken token) {
                        System.out.println("Delivered message.");
                    }
                    }
```

------
#### [ STOMP\$1WSS ]

```
/*
 * Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */
                    
                    import org.springframework.messaging.converter.StringMessageConverter;
                    import org.springframework.messaging.simp.stomp.*;
                    import org.springframework.web.socket.WebSocketHttpHeaders;
                    import org.springframework.web.socket.client.WebSocketClient;
                    import org.springframework.web.socket.client.standard.StandardWebSocketClient;
                    import org.springframework.web.socket.messaging.WebSocketStompClient;
                    
                    import java.lang.reflect.Type;
                    
                    public class AmazonMQExampleStompWss {
                    
                    // Specify the connection parameters.
                    private final static String DESTINATION = "/queue";
                    private final static String WIRE_LEVEL_ENDPOINT =
                            "wss://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61619";
                    private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
                    private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
                    
                    public static void main(String[] args) throws Exception {
                        final AmazonMQExampleStompWss example = new AmazonMQExampleStompWss();
                    
                        final StompSession stompSession = example.connect();
                        System.out.println("Subscribed to a destination using session.");
                        example.subscribeToDestination(stompSession);
                    
                        System.out.println("Sent message to session.");
                        example.sendMessage(stompSession);
                        Thread.sleep(60000);
                    }
                    
                    private StompSession connect() throws Exception {
                        // Create a client.
                        final WebSocketClient client = new StandardWebSocketClient();
                        final WebSocketStompClient stompClient = new WebSocketStompClient(client);
                        stompClient.setMessageConverter(new StringMessageConverter());
                    
                        final WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
                    
                        // Create headers with authentication parameters.
                        final StompHeaders head = new StompHeaders();
                        head.add(StompHeaders.LOGIN, ACTIVE_MQ_USERNAME);
                        head.add(StompHeaders.PASSCODE, ACTIVE_MQ_PASSWORD);
                    
                        final StompSessionHandler sessionHandler = new MySessionHandler();
                    
                        // Create a connection.
                        return stompClient.connect(WIRE_LEVEL_ENDPOINT, headers, head,
                                sessionHandler).get();
                    }
                    
                    private void subscribeToDestination(final StompSession stompSession) {
                        stompSession.subscribe(DESTINATION, new MyFrameHandler());
                    }
                    
                    private void sendMessage(final StompSession stompSession) {
                        stompSession.send(DESTINATION, "Hello from Amazon MQ!".getBytes());
                    }
                    
                    private static class MySessionHandler extends StompSessionHandlerAdapter {
                        public void afterConnected(final StompSession stompSession,
                                                final StompHeaders stompHeaders) {
                            System.out.println("Connected to broker.");
                        }
                    }
                    
                    private static class MyFrameHandler implements StompFrameHandler {
                        public Type getPayloadType(final StompHeaders headers) {
                            return String.class;
                        }
                    
                        public void handleFrame(final StompHeaders stompHeaders,
                                                final Object message) {
                            System.out.print("Received message from topic: " + message);
                        }
                    }
                    }
```

------