Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Tutorial di ActiveMQ I seguenti tutorial illustrano come creare e connettersi ai broker ActiveMQ. Per utilizzare il codice di esempio ActiveMQ Java, devi installare [Java Standard Edition Development Kit](https://www.oracle.com/technetwork/java/javase/downloads/index.html) e apportare alcune modifiche di configurazione al codice di esempio **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) + [Integrazione dei broker ActiveMQ con LDAP](security-authentication-authorization.md) + [Connect your Amazon MQ for ActiveMQ broker to Lambda](#activemq-connect-to-lambda) + [Creazione di un utente broker ActiveMQ](amazon-mq-listing-managing-users.md) + [Modifica un utente del broker ActiveMQ](edit-existing-user-console.md) + [Eliminare un utente del broker ActiveMQ](delete-existing-user-console.md) + [Working Java Example](amazon-mq-working-java-example.md) # Creazione e configurazione di una rete di broker Amazon MQ Una *rete di broker* è composta da più [broker a istanza singola](amazon-mq-broker-architecture.md#single-broker-deployment) simultaneamente attivi o [broker attivi/in standby](amazon-mq-broker-architecture.md#active-standby-broker-deployment). In questo tutorial imparerai a creare una rete di broker a due broker con una topologia *source and sink*. Per una panoramica concettuale e informazioni di configurazione dettagliate, vedi quanto segue: + [Rete di broker Amazon MQ](network-of-brokers.md) + [Configura la rete di broker nel modo corretto](best-practices-activemq.md#network-of-brokers-configure-correctly) + `networkConnector` + `networkConnectionStartAsincrono` + [Reti di broker](http://activemq.apache.org/networks-of-brokers.html) nella documentazione di ActiveMQ Puoi utilizzare la console Amazon MQ per creare una rete di broker Amazon MQ. Poiché è possibile avviare la creazione di due broker in parallelo, questo processo richiede circa 15 minuti. **Topics** + [Prerequisiti](#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) ## Prerequisiti Per creare una rete di broker, devi disporre di quanto segue: + Due o più broker attivi simultaneamente (denominati `MyBroker1` e `MyBroker2` in questo tutorial). Per ulteriori informazioni sulla creazione di broker, consulta [Guida introduttiva: creazione e connessione a un broker ActiveMQ](getting-started-activemq.md). + I due broker devono essere nello stesso VPC o in peering. VPCs Per ulteriori informazioni su VPCs, consulta [Cos'è Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html)? nella *Guida per l'utente di Amazon VPC* e [Cos'è il peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)? nella *Amazon VPC Peering* Guide. **Importante** Se non disponi di un VPC predefinito, di una o più sottoreti o di un gruppo di sicurezza, per prima cosa devi crearli. Per ulteriori informazioni, consultare gli argomenti seguenti nella *Guida per l'utente di Amazon VPC*: [Creazione di un VPC predefinito](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-vpc) [Creazione di una sottorete predefinita](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet) [Creazione di un gruppo di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#CreatingSecurityGroups) + Due utenti con credenziali di accesso identiche per entrambi i broker. Per ulteriori informazioni sulla creazione degli utenti, vedere [Creazione di un utente broker ActiveMQ](amazon-mq-listing-managing-users.md). **Nota** Quando si integra l'autenticazione LDAP con una rete di broker, assicurarsi che l'utente esista sia come broker ActiveMQ, sia come utente LDAP. L'esempio seguente utilizza due [broker a istanza singola](amazon-mq-broker-architecture.md#single-broker-deployment). Tuttavia, puoi creare reti di broker utilizzando [broker attivi/in standby](amazon-mq-broker-architecture.md#active-standby-broker-deployment) o una combinazione di modalità di distribuzione di broker. ## Fase 1: abilita il traffico tra i broker Dopo aver creato i broker, devi abilitare il traffico tra di loro. 1. Sulla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/), nella pagina **MyBroker2**, nella sezione **Dettagli**, in **Sicurezza e rete**, scegli il nome del tuo gruppo di sicurezza oppure![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png). Viene visualizzata la pagina **Security Groups (Gruppi di sicurezza)** del pannello di controllo EC2. 1. Scegli il tuo gruppo di sicurezza dall'elenco. 1. Nella parte inferiore della pagina scegli **Inbound (In entrata)**, quindi scegli **Edit (Modifica)**. 1. Nella finestra di dialogo **Modifica regole in entrata**, aggiungi una regola per l' OpenWire endpoint. 1. Selezionare **Add Rule (Aggiungi regola)**. 1. Per **Type (Tipo)** seleziona **Custom TCP (TCP personalizzato)**. 1. Per **Port Range**, digitate la OpenWire porta ()`61617`. 1. Esegui una delle seguenti operazioni: + Se desideri limitare l'accesso a un determinato indirizzo IP per **Origine**, lascia selezionato **Personalizzato**, quindi immetti l'indirizzo IP di `MyBroker1` seguito da `/32`. (Questo converte l'indirizzo IP in un record CIDR valido). Per ulteriori informazioni consulta [Interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html). **Suggerimento** Per recuperare l'indirizzo IP di `MyBroker1`, nella [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/) scegliere il nome del broker e andare alla sezione **Details** (Dettagli). + Se tutti i broker sono privati e appartengono allo stesso VPC, per **Origine** lascia selezionato **Personalizzato** quindi digita l'ID del gruppo di sicurezza che stai modificando. **Nota** Per i broker pubblici, è necessario limitare l'accesso utilizzando gli indirizzi IP. 1. Scegli **Save** (Salva). Il broker può ora accettare connessioni in entrata. ## Fase 2: configura i connettori di rete per il broker Dopo aver abilitato il traffico tra i broker, devi configurare i connettori di rete per uno di essi. 1. Modifica la revisione della configurazione per il broker `MyBroker1`. 1. Nella pagina **MyBroker1**, scegli **Modifica**. 1. Nella pagina **Modifica MyBroker 1**, nella sezione **Configurazione**, scegli **Visualizza**. Vengono visualizzati il tipo di motore del broker e la versione utilizzati dalla configurazione (ad esempio, **Apache ActiveMQ 5.15.0**). 1. Nella scheda **Configuration details** (Dettagli configurazione) vengono visualizzati il numero di revisione della configurazione, la descrizione e la configurazione del broker in formato XML. 1. Scegli **Edit configuration (Modifica configurazione)**. 1. Nella parte inferiore del file di configurazione, rimuovi il commento dalla sezione `` e includi le informazioni riportate di seguito: + Il `name` per il connettore di rete. + [Lo `username` della console Web ActiveMQ](#creating-configuring-network-of-brokers-create-brokers) comune a entrambi i broker. + Abilita le connessioni `duplex`. + Esegui una delle seguenti operazioni: + Se stai collegando il broker a un broker a istanza singola, usa il `static:` prefisso e l' OpenWire endpoint `uri` per. `MyBroker2` Esempio: ``` ``` + Se stai collegando il broker a un broker attivo/in standby, utilizza il `static+failover` trasporto e l' OpenWireendpoint `uri` per entrambi i broker con i seguenti parametri di query. `?randomize=false&maxReconnectAttempts=0` Esempio: ``` ``` **Nota** Non includere le credenziali di accesso per l'utente ActiveMQ. 1. Scegli **Save** (Salva). 1. Nella finestra di dialogo **Save revision (Salva revisione)**, digita `Add network of brokers connector for MyBroker2`. 1. Scegli **Save (Salva)** per salvare la nuova revisione della configurazione. 1. Modifica `MyBroker1` per applicare immediatamente l'ultima revisione della configurazione. 1. **Nella pagina **MyBroker1, scegli Modifica**.** 1. Nella pagina **Modifica MyBroker 1**, nella sezione **Configurazione**, scegli **Pianifica modifiche**. 1. Nella sezione **Schedule broker modifications (Pianifica modifiche broker)**, scegli di applicare le modifiche **Immediately (Immediatamente)**. 1. Scegli **Applica**. `MyBroker1` viene riavviato e la revisione della configurazione viene applicata. La rete di broker viene creata. ## Fasi successive Dopo aver configurato la rete di broker, è possibile testarla tramite la creazione e l'utilizzo di messaggi. **Importante** Assicurati di [abilitare le connessioni in entrata](amazon-mq-working-java-example.md#quick-start-allow-inbound-connections) *dal tuo computer locale* per il broker `MyBroker1` sulla porta 8162 (per ActiveMQ Web Console) e sulla porta 61617 (per l'endpoint). OpenWire Potresti inoltre dover modificare le impostazioni dei gruppi di sicurezza per consentire al produttore e al consumatore di connettersi alla rete di broker. 1. Nella [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/), andare alla sezione **Connections** (Connessioni) e prendere nota dell'endpoint della console Web ActiveMQ per il broker `MyBroker1`. 1. Vai alla console Web ActiveMQ per il broker `MyBroker1`. 1. Per verificare che il bridge di rete sia connesso, scegli **Network (Rete)**. Nella sezione **Network Bridges (Bridge di rete)**, il nome e l'indirizzo di `MyBroker2` sono elencati nelle colonne **Remote Broker (broker remoto)** e **Remote Address (Indirizzo remoto)**. 1. Da una macchina che ha accesso al broker `MyBroker2`, crea un consumatore. Esempio: ``` 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 ``` Il consumatore si connette all' OpenWire endpoint di e inizia a consumare i messaggi dalla `MyBroker2` coda. `MyQueue` 1. Da una macchina che ha accesso al broker `MyBroker1`, crea un produttore e invia alcuni messaggi. Esempio: ``` 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 ``` Il produttore si connette all' OpenWire endpoint di `MyBroker1` e inizia a produrre messaggi persistenti da mettere in coda. `MyQueue` # Connessione di un'applicazione Java alil broker Amazon MQ Dopo aver creato un broker ActiveMQ di Amazon MQ, è possibile collegarvi l'applicazione. Di seguito sono riportati esempi che mostrano come è possibile utilizzare il servizio di messaggistica Java (JMS) per creare una connessione alil broker, creare una coda e inviare un messaggio. Per un esempio Java completo e funzionante, consultare [Esempi funzionanti di utilizzo di Java Message Service (JMS) con ActiveMQ](amazon-mq-working-java-example.md). Puoi connetterti ai broker ActiveMQ utilizzando [vari client ActiveMQ](http://activemq.apache.org/cross-language-clients.html). È consigliato l'uso del [client ActiveMQ](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client). **Topics** + [Prerequisiti](#connect-application-prerequisites-tutorial) + [Per creare un produttore del messaggio e inviare un messaggio](#create-producer-send-message-tutorial) + [Per creare un consumatore del messaggio e ricevere il messaggio](#create-consumer-receive-message-tutorial) ## Prerequisiti ### Abilitazione attributi VPC Per garantire che il broker sia accessibile all'interno del VPC, è necessario abilitare gli attributi VPC `enableDnsHostnames` e `enableDnsSupport`. Per ulteriori informazioni, consultare [Supporto del DNS nel VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) nella *Guida per l'utente di Amazon VPC*. ### Abilitazione connessioni in entrata Quindi, abilita le connessioni in entrata per la tua applicazione. 1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/). 1. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio, **MyBroker**). 1. Nella ***MyBroker***pagina, nella sezione **Connessioni**, annota gli indirizzi e le porte dell'URL della console web del broker e dei protocolli a livello di cavo. 1. Nella sezione **Details** (Dettagli), in **Security and network** (Sicurezza e rete), scegliere il nome del gruppo di sicurezza o ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png). Viene visualizzata la pagina **Security Groups (Gruppi di sicurezza)** del pannello di controllo EC2. 1. Scegli il tuo gruppo di sicurezza dall'elenco. 1. Nella parte inferiore della pagina scegli **Inbound (In entrata)**, quindi scegli **Edit (Modifica)**. 1. Nella finestra di dialogo **Edit inbound rules** (Modifica le regole in entrata), aggiungere una regola per ogni URL o endpoint che si desidera rendere accessibile pubblicamente (nell'esempio seguente viene illustrato come eseguire questa operazione per una console Web del broker). 1. Selezionare **Add Rule (Aggiungi regola)**. 1. Per **Type (Tipo)** seleziona **Custom TCP (TCP personalizzato)**. 1. Per **Port Range** (Intervallo porte), digitare la porta della console Web (`8162`). 1. Per **Source** (Origine), lasciare selezionato **Custom** (Personalizzato), quindi inserire l'indirizzo IP del sistema a cui desideri poter accedere alla console Web (ad esempio, `192.0.2.1`). 1. Scegli **Save** (Salva). Il broker può ora accettare connessioni in entrata. ### Aggiunta dipendenze Java Aggiungere i pacchetti `activemq-client.jar` e `activemq-pool.jar` al percorso di classe Java. L'esempio seguente mostra queste dipendenze in un file `pom.xml` di progetto Maven. ``` org.apache.activemq activemq-client 5.15.16 org.apache.activemq activemq-pool 5.15.16 ``` Per ulteriori informazioni su `activemq-client.jar`, consultare [Configurazione iniziale](http://activemq.apache.org/initial-configuration.html) nella documentazione di Apache ActiveMQ. **Importante** Nel codice di esempio seguente, produttori e consumatori vengono eseguiti in un singolo thread. Per i sistemi di produzione (o per testare il failover delle istanze del broker), assicurarsi che i produttori e i consumatori vengano eseguiti su host o thread separati. ## Per creare un produttore del messaggio e inviare un messaggio Usa le seguenti istruzioni per creare un produttore di messaggi e ricevere un messaggio. 1. Creare un pool di connessioni di stabilimento JMS per il produttore di messaggi utilizzando l'endpoint del broker e quindi chiamare il metodo `createConnection` rispetto allo stabilimento. **Nota** Per un active/standby broker, Amazon MQ fornisce due URLs console Web ActiveMQ, ma è attivo un solo URL alla volta. Allo stesso modo, Amazon MQ fornisce due endpoint per ogni protocollo a livello di connessione, ma è attivo un solo endpoint per ogni coppia alla volta. I suffissi `-1` e `-2` indicano una coppia ridondante. Per ulteriori informazioni, vedere [Opzioni di implementazione per i broker Amazon MQ for ActiveMQ](amazon-mq-broker-architecture.md)). [Per gli endpoint con protocollo a livello di cavo, è necessario consentire all'applicazione di connettersi a entrambi gli endpoint utilizzando il Failover Transport.](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(); ``` **Nota** I produttori di messaggi devono sempre utilizzare la classe `PooledConnectionFactory`. Per ulteriori informazioni, consulta [Usa sempre il pooling delle connessioni](best-practices-activemq.md#always-use-connection-pooling). 1. Creare una sessione, una coda denominata `MyQueue` e un produttore di messaggi. ``` // 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. Creare la stringa del messaggio `"Hello from Amazon MQ!"` e quindi inviare il messaggio. ``` // 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. Eliminare il produttore. ``` producer.close(); producerSession.close(); producerConnection.close(); ``` ## Per creare un consumatore del messaggio e ricevere il messaggio Utilizzate le seguenti istruzioni per creare un produttore di messaggi e ricevere un messaggio. 1. Creare una connessione di stabilimento JMS per il produttore di messaggi utilizzando l'endpoint del broker e quindi chiamare il metodo `createConnection` rispetto allo stabilimento. ``` // 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(); ``` **Nota** I consumatori dei messaggi non dovrebbero *mai* utilizzare la classe `PooledConnectionFactory`. Per ulteriori informazioni, consulta [Usa sempre il pooling delle connessioni](best-practices-activemq.md#always-use-connection-pooling). 1. Creare una sessione, una coda denominata `MyQueue` e un consumatore di messaggi. ``` // 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. Iniziare ad attendere i messaggi quindi riceverlo non appena arriva. ``` // 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()); ``` **Nota** A differenza dei servizi di AWS messaggistica (come Amazon SQS), il consumatore è costantemente connesso al broker. 1. Chiudere il consumatore, la sessione e la connessione. ``` consumer.close(); consumerSession.close(); consumerConnection.close(); ``` # Integrazione dei broker ActiveMQ con LDAP **Importante** Amazon MQ non supporta certificati server emessi da una CA privata. È possibile accedere ai broker ActiveMQ utilizzando i seguenti protocolli con TLS abilitato: + [AMQP](http://activemq.apache.org/amqp.html) + [MQTT](http://activemq.apache.org/mqtt.html) + MQTT over [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 una scelta tra l'autenticazione nativa ActiveMQ e l'autenticazione LDAP e l'autorizzazione per gestire le autorizzazioni utente. Per informazioni relative alle limitazioni correlate a nomi utente e password ActiveMQ, consulta [Utenti](amazon-mq-limits.md#activemq-user-limits). Per autorizzare gli utenti e i gruppi ActiveMQ a utilizzare code e argomenti, è necessario [modificare la configurazione del broker](amazon-mq-creating-applying-configurations.md). Amazon MQ utilizza il [plugin di autenticazione semplice](http://activemq.apache.org/security.html#Security-SimpleAuthenticationPlugin) di ActiveMQ per limitare la lettura e la scrittura alle destinazioni. Per ulteriori informazioni ed esempi, consulta [Configurare sempre una mappa di autorizzazione](using-amazon-mq-securely.md#always-configure-authorization-map) e `authorizationEntry`. **Nota** Attualmente, Amazon MQ non supporta l'autenticazione dei certificati client. **Topics** + [Integrazione di LDAP con ActiveMQ](#integrate-ldap) + [Prerequisiti](#ldap-prerequisites) + [Nozioni di base su LDAP](#ldap-get-started) + [Come funziona l'integrazione LDAP](#ldap-support-details) ## Integrazione di LDAP con ActiveMQ È possibile autenticare gli utenti Amazon MQ tramite le credenziali memorizzate nel server LDAP (Lightweight Directory Access Protocol). È inoltre possibile aggiungere, eliminare e modificare gli utenti Amazon MQ e assegnare autorizzazioni ad argomenti e code attraverso di esso. Le operazioni di gestione come la creazione, l'aggiornamento e l'eliminazione dei broker richiedono ancora credenziali IAM e non sono integrate con LDAP. I clienti che desiderano semplificare e centralizzare l'autenticazione e l'autorizzazione del broker Amazon MQ utilizzando un server LDAP possono utilizzare questa funzione. Mantenere tutte le credenziali utente nel server LDAP consente di risparmiare tempo e fatica fornendo una posizione centrale per l'archiviazione e la gestione di tali credenziali. Amazon MQ fornisce supporto LDAP utilizzando il plugin Apache ActiveMQ JAAS. Qualsiasi server LDAP, ad esempio Microsoft Active Directory od OpenLDAP supportato dal plugin, è supportato anche da Amazon MQ. Per ulteriori informazioni sul plugin, consultare la sezione [Sicurezza](https://activemq.apache.org/security) della documentazione di Active MQ. Oltre agli utenti, è possibile specificare l'accesso agli argomenti e alle code per un gruppo specifico o un utente tramite il server LDAP. A tale scopo, creare voci che rappresentano argomenti e code nel server LDAP e quindi assegnare autorizzazioni a un utente LDAP specifico o a un gruppo. È quindi possibile configurare i broker per recuperare i dati di autorizzazione dal server LDAP. **Importante** Quando si utilizza LDAP, l'autenticazione non fa distinzione tra maiuscole e minuscole, ma l'autorizzazione fa distinzione tra maiuscole e minuscole per il nome utente. ## Prerequisiti Prima di aggiungere il supporto LDAP a un broker Amazon MQ nuovo o esistente, occorre configurare un account di servizio. Questo account di servizio è necessario per avviare una connessione a un server LDAP e deve disporre delle autorizzazioni corrette per effettuare questa connessione. Questo account di servizio configurerà l'autenticazione LDAP per il broker. Eventuali connessioni client successive verranno autenticate tramite la stessa connessione. Un account del servizio è un account nel server LDAP che ha accesso per avviare una connessione. Si tratta di un requisito LDAP standard ed è necessario fornire le credenziali dell'account di servizio una sola volta. Dopo aver configurato la connessione, tutte le future connessioni client vengono autenticate tramite il server LDAP. Le credenziali dell'account di servizio sono memorizzate in modo sicuro in un formato crittografato, accessibile solo ad Amazon MQ. Per l'integrazione con ActiveMQ, sul server LDAP è necessario disporre di una specifica struttura DIT (Directory Information Tree). Per un esempio di file `ldif` che mostra chiaramente questa struttura, consultare *Importazione del seguente file LDIF nel server LDAP* nella sezione [Sicurezza](https://activemq.apache.org/security) della documentazione di ActiveMQ. ## Nozioni di base su LDAP Per iniziare, accedere alla console Amazon MQ e scegliere **LDAP authentication and authorization** (Autenticazione e autorizzazione LDAP) durante la creazione di una nuova istanza del broker Amazon MQ o la modifica di un'istanza esistente. Fornire le informazioni seguenti sull'account di servizio: + **Fully qualified domain name** (Nome di dominio completo) Posizione del server LDAP in cui devono essere emesse le richieste di autenticazione e autorizzazione. **Nota** Il nome di dominio completo del server LDAP fornito non deve includere il protocollo o il numero di porta. Amazon MQ antepone il nome di dominio completo con il protocollo `ldaps`, a cui aggiungerà il numero di porta `636`. Ad esempio, se si specifica il seguente dominio completo `example.com`, Amazon MQ accederà al server LDAP utilizzando l'URL `ldaps://example.com:636`. Affinché l'host del broker sia in grado di comunicare correttamente con il server LDAP, il nome di dominio completo deve essere risolvibile pubblicamente. Per mantenere il server LDAP privato e sicuro, limitare il traffico in ingresso nelle regole in entrata del server per consentire solo il traffico originato dall'interno del VPC del broker. + **Service account username** (Nome utente dell'account del servizio) Il nome distinto dell'utente che verrà utilizzato per eseguire l'associazione iniziale al server LDAP. + **Service account password** (Password dell'account del servizio) La password dell'utente che esegue l'associazione iniziale. L'immagine seguente evidenzia dove fornire questi dettagli. ![\[Dove specificare i dettagli dell'account del servizio LDAP.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-service-account.png) Nella sezione **LDAP login configuration** (Configurazione dell'accesso con LDAP), fornire le informazioni obbligatorie seguenti: + **User Base** (Base utenti) Nome distinto del nodo nella struttura DIT (Directory Information Tree) che verrà cercato per gli utenti. + **User Search Matching** (Corrispondenza ricerca utente) Filtro di ricerca LDAP che verrà utilizzato per trovare gli utenti all'interno di `userBase`. Il nome utente del client viene sostituito nel placeholder `{0}` nel filtro di ricerca. Per ulteriori informazioni, consultare [Autenticazione](#ldap-authentication) e [Autorizzazione](#ldap-authorization). + **Role Base** (Base di ruoli) Nome distinto del nodo nel DIT in cui verranno cercati i ruoli. I ruoli possono essere configurati come voci esplicite del gruppo LDAP nella directory. Una voce di ruolo tipica può essere costituita da un attributo per il nome del ruolo, ad esempio **nome comune (NC)** e un altro attributo, come `member`, con valori che rappresentano i nomi distinti o i nomi utente degli utenti appartenenti al gruppo di ruoli. Ad esempio, data l'unità organizzativa, `group`, è possibile fornire il nome distinto seguente `ou=group,dc=example,dc=com`. + **Role Search Matching** (Corrispondenza ricerca ruolo) Filtro di ricerca LDAP che verrà utilizzato per trovare i ruoli all'interno di `roleBase`. Il nome distinto dell'utente abbinato da `userSearchMatching` sarà sostituito nel placeholder `{0}` nel filtro di ricerca. Il nome utente del cliente verrà sostituito al posto del placeholder `{1}`. Ad esempio, se le voci di ruolo nella directory includono un attributo denominato `member`, contenente i nomi utente per tutti gli utenti in tale ruolo, è possibile fornire il seguente filtro di ricerca: `(member:=uid={1})`. L'immagine seguente evidenzia dove specificare questi dettagli. ![\[Dove specificare i dettagli di accesso LDAP.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-login-configuration.png) Nella sezione **Optional settings** (Impostazioni opzionali), è possibile fornire le informazioni facoltative seguenti: + **User Role Name** (Nome del ruolo dell'utente) Nome dell'attributo LDAP nella voce di directory dell'utente per l'appartenenza al gruppo dell'utente. In alcuni casi, i ruoli utente possono essere identificati dal valore di un attributo nella voce di directory dell'utente. L'opzione `userRoleName` consente di fornire il nome di questo attributo. Ad esempio, consideriamo la seguente voce utente: ``` 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 ``` Per fornire il corretto `userRoleName` per l'esempio precedente, è necessario specificare l'attributo `memberOf`. Se l'autenticazione viene completata correttamente, l'utente viene assegnato al ruolo `role1`. + **Role Name** (Nome del ruolo) Attributo del nome del gruppo in una voce del ruolo il cui valore è il nome di tale ruolo. Ad esempio, è possibile specificare `cn` per il **nome comune** di una voce del gruppo. Se l'autenticazione ha esito positivo, all'utente viene assegnato il valore dell'attributo `cn` per ogni voce di ruolo di cui è membro. + **User Search Subtree** (Sottostruttura di ricerca utente) Definisce l'ambito per la query di ricerca utente LDAP. Se true, l'ambito è impostato per cercare l'intera sottostruttura sotto il nodo definito da `userBase`. + **Role Search Subtree** (Sottostruttura di ricerca ruolo) Definisce l'ambito per la query di ricerca ruolo LDAP. Se true, l'ambito è impostato per cercare l'intera sottostruttura sotto il nodo definito da `roleBase`. L'immagine seguente evidenzia dove specificare queste impostazioni opzionali. ![\[Optional settings for LDAP attributes and search scope in role search matching.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-active-ldap-optional-settings.png) ## Come funziona l'integrazione LDAP Si può pensare all'integrazione in due categorie principali: la struttura per l'autenticazione e la struttura per l'autorizzazione. ### Autenticazione Per l'autenticazione, le credenziali client devono essere valide. Queste credenziali vengono convalidate rispetto agli utenti della base utenti nel server LDAP. La base utenti fornita alil broker ActiveMQ deve puntare al nodo nel DIT in cui gli utenti sono archiviati nel server LDAP. Ad esempio, se utilizzi e disponi dei componenti del dominio e AWS Managed Microsoft AD, all'interno di questi `corp``example`, disponi di unità organizzative `corp` e`Users`, utilizzerai quanto segue come base di utenti: `com` ``` OU=Users,OU=corp,DC=corp,DC=example,DC=com ``` il broker ActiveMQ cercherà gli utenti in questa posizione nel DIT al fine di autenticare le richieste di connessione client alil broker. ![\[Posizione in cui cercare utenti\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-structure.png) Poiché il codice sorgente ActiveMQ codifica hardcode il nome dell'attributo per gli utenti in `uid`, è necessario assicurarsi che ogni utente abbia questo attributo impostato. Per semplicità, è possibile utilizzare il nome utente della connessione. Per ulteriori informazioni, consultare il codice sorgente [activemq](https://github.com/apache/activemq/blob/c3d9b388e4f1fe73e348bf466122fe6862e064a0/activemq-broker/src/main/java/org/apache/activemq/security/SimpleCachedLDAPAuthorizationMap.java#L89) e [Configurazione delle mappature dell'ID in utenti Active Directory e computer per Windows Server 2016 (e versioni successive)](https://www.ibm.com/support/knowledgecenter/en/STXKQY_5.0.3/com.ibm.spectrum.scale.v5r03.doc/bl1adm_confidmapaduc.htm). Per abilitare l'accesso alla console ActiveMQ per utenti specifici, assicurarsi che appartengano al gruppo `amazonmq-console-admins`. ### Autorizzazione Per l'autorizzazione, le basi di ricerca delle autorizzazioni sono specificate nella configurazione del broker. L'autorizzazione viene eseguita in base alla destinazione (o carattere jolly, set di destinazione) tramite l'elemento `cachedLdapAuthorizationMap`, che si trova nel file di configurazione `activemq.xml`. Per ulteriori informazioni, consultare [Modulo di autorizzazione LDAP memorizzato nella cache](https://activemq.apache.org/cached-ldap-authorization-module). **Nota** Per poter utilizzare l'`cachedLDAPAuthorizationMap`elemento nel file di `activemq.xml` configurazione del tuo broker, devi scegliere l'opzione **Autenticazione e autorizzazione LDAP** quando [crei una configurazione tramite Console di gestione AWS](amazon-mq-creating-applying-configurations.md), oppure impostare la [creazione di una configurazione tramite Console di gestione AWS](amazon-mq-creating-applying-configurations.md), o impostare 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)proprietà su `LDAP` quando crei una nuova configurazione utilizzando l'API Amazon MQ. Occorre fornire i seguenti tre attributi come parte dell'elemento `cachedLDAPAuthorizationMap`: + `queueSearchBase` + `topicSearchBase` + `tempSearchBase` **Importante** Per evitare che le informazioni sensibili vengano inserite direttamente nel file di configurazione del broker, Amazon MQ blocca l'utilizzo dei seguenti attributi in `cachedLdapAuthorizationMap`: `connectionURL` `connectionUsername` `connectionPassword` Quando crei un broker, Amazon MQ sostituisce i valori forniti tramite o nella [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)proprietà della tua richiesta API con gli attributi di cui sopra. Console di gestione AWS Di seguito è mostrato un esempio funzionante di `cachedLdapAuthorizationMap`. ``` ``` Questi valori identificano le posizioni all'interno del DIT in cui sono specificate le autorizzazioni per ogni tipo di destinazione. Quindi, per l'esempio precedente con AWS Managed Microsoft AD, utilizzando gli stessi componenti di dominio di`corp`, e `example``com`, dovresti specificare un'unità organizzativa denominata `destination` per contenere tutti i tipi di destinazione. All'interno di quell'unità organizzativa, occorre crearne uno per le destinazioni `queues`, uno per `topics` e uno per `temp`. Ciò significa che la base di ricerca della coda, che fornisce informazioni di autorizzazione per le destinazioni della coda dei tipi, avrebbe la seguente posizione nel DIT: ``` OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com ``` ![\[Posizione della base di ricerca della coda.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-queue-structure.png) Analogamente, le regole di autorizzazione per gli argomenti e le destinazioni temporanee si trovano allo stesso livello nel 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 ``` All'interno dell'unità organizzativa per ogni tipo di destinazione (coda, argomento, temp), è possibile specificare un carattere jolly o un nome di destinazione specifico. Ad esempio, per fornire una regola di autorizzazione per tutte le code che iniziano con il prefisso DEMO.EVENTS.\$1., è possibile creare la seguente unità organizzativa: ``` OU=DEMO.EVENTS.$,OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com ``` **Nota** L'unità organizzativa `DEMO.EVENTS.$` è all'interno dell'unità organizzativa `Queue`. Per altre informazioni sui caratteri jolly in ActiveMQ, fare riferimento ai [Caratteri jolly](https://activemq.apache.org/wildcards) Per fornire regole di autorizzazione per code specifiche, ad esempio DEMO.MYQUEUE, specificare qualcosa di simile al seguente: ``` OU=DEMO.MYQUEUE,OU=Queue,OU=Destination,OU=corp,DC=corp,DC=example,DC=com ``` ![\[Regole di autorizzazione per code specifiche\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-authorization-rules.png) ### Gruppi di sicurezza All'interno di ogni unità organizzativa che rappresenta una destinazione o un carattere jolly, è necessario creare tre gruppi di sicurezza. Come tutte le autorizzazioni in ActiveMQ, si tratta di autorizzazioni. read/write/admin Per ulteriori informazioni sulle operazioni di ciascuna utente, consultare [Sicurezza](https://activemq.apache.org/security) nella documentazione di ActiveMQ. È necessario assegnare un nome a questi gruppi di sicurezza `read`, `write` e `admin`. All'interno di ciascuno di questi gruppi di sicurezza è possibile aggiungere utenti o gruppi, che avranno quindi l'autorizzazione per eseguire le azioni associate. Questi gruppi di sicurezza sono necessari per ogni set di destinazione jolly o singola destinazione. ![\[Gruppi di sicurezza\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-security-groups.png) **Nota** Quando si crea il gruppo di amministrazione, si verificherà un conflitto con il nome del gruppo. Questo conflitto si verifica perché le regole legacy a Windows 2000 non consentono ai gruppi di condividere lo stesso nome, anche se i gruppi si trovano in posizioni diverse del DIT. Il valore nella casella di testo **Pre-Windows 2000** non ha alcun impatto sulla configurazione, ma deve essere univoco a livello globale. Per evitare questo conflitto, è possibile aggiungere un suffisso `uuid` a ciascun gruppo `admin`. ![\[Questa è la mia immagine.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/active-mq-ldap-admin-qualifier.png) L'aggiunta di un utente al gruppo di sicurezza `admin` per una determinata destinazione consentirà all'utente di creare ed eliminare tale argomento. Aggiungendoli al gruppo di sicurezza `read` consentirà loro di leggere dalla destinazione mentre aggiungerli al gruppo di sicurezza `write` consentirà loro di scrivere nella destinazione. Oltre ad aggiungere singoli utenti alle autorizzazioni dei gruppi di sicurezza, è anche possibile aggiungere interi gruppi. Tuttavia, poiché ActiveMQ di nuovo specifica a livello di codice i nomi degli attributi per i gruppi, è necessario assicurarsi che il gruppo che si desidera aggiungere abbia la classe dell'oggetto `groupOfNames`, come mostrato nel codice sorgente [activemq](https://github.com/apache/activemq/blob/c3d9b388e4f1fe73e348bf466122fe6862e064a0/activemq-broker/src/main/java/org/apache/activemq/security/SimpleCachedLDAPAuthorizationMap.java#L86). Per fare ciò, seguire lo stesso processo di `uid` per gli utenti. Consultare [Configurazione delle mappature dell'ID in utenti Active Directory e computer per Windows Server 2016 (e versioni successive)](https://www.ibm.com/support/knowledgecenter/en/STXKQY_5.0.3/com.ibm.spectrum.scale.v5r03.doc/bl1adm_confidmapaduc.htm). ## Fase 3: (Opzionale) Connect a una AWS Lambda funzione AWS Lambda può connettersi e utilizzare i messaggi del tuo broker Amazon MQ. Quando si connette un broker a Lambda, si crea una [mappatura delle origini degli eventi](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) che legge i messaggi da una coda e richiama la funzione [in modo sincrono](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). La mappatura dell'origine degli eventi creata legge i messaggi dal broker in batch e li converte in un payload Lambda sotto forma di oggetto JSON. **Connessione del broker a una funzione Lambda** 1. Aggiungere le seguenti autorizzazioni del ruolo IAM al [ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) della funzione 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) + [registri: CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html) + [registri: CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html) + [registri: PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html) + [gestore dei segreti: GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) **Nota** Senza le necessarie autorizzazioni IAM, la tua funzione non sarà in grado di leggere correttamente i record dalle risorse di Amazon MQ. 1. (Opzionale) Se hai creato un broker senza accessibilità pubblica, devi effettuare una delle seguenti operazioni per consentire a Lambda di connettersi al broker: + Configurare un gateway NAT per sottorete pubblica. Per ulteriori informazioni, consultare [Accesso a Internet e ai servizi per funzioni connesse a un VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet) nella *AWS Lambda Guida per gli sviluppatori*. + Creare una connessione tra Amazon Virtual Private Cloud (Amazon VPC) e Lambda mediante un endpoint VPC. Il tuo Amazon VPC deve inoltre connettersi agli endpoint AWS Security Token Service (AWS STS) e Secrets Manager. Per ulteriori informazioni, consulta [Configuring interface VPC endpoints for Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) nella *AWS Lambda Guida per gli sviluppatori*. 1. [Configurare il broker come origine dell'evento](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping) per una funzione Lambda che utilizza la Console di gestione AWS. Puoi anche usare il comando. [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 1. Scrivere un codice per la funzione Lambda per elaborare i messaggi utilizzati dal broker. Il payload Lambda recuperato dalla mappatura dell'origine dell'evento dipende dal tipo di motore del broker. Di seguito è riportato un esempio di payload Lambda per una coda Amazon MQ per ActiveMQ. **Nota** Nell'esempio, `testQueue` corrisponde al nome della coda. ``` { "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 } ] } } ``` Per maggiori informazioni sulla connessione di Amazon MQ a Lambda, le opzioni supportate da Lambda per un'origine dell'evento Amazon MQ e gli errori di mappatura delle origini degli eventi, vedere [Uso di Lambda con Amazon MQ](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html) nella *AWS Lambda Guida per gli sviluppatori*. # Creazione di un utente broker ActiveMQ Un *utente* ActiveMQ è una persona o un'applicazione che può accedere alle code e agli argomenti di un broker ActiveMQ. È possibile configurare gli utenti in modo che dispongano di autorizzazioni specifiche. Ad esempio, è possibile consentire ad alcuni utenti di accedere alla [console Web ActiveMQ](http://activemq.apache.org/web-console.html). Un *gruppo* è un'etichetta semantica. È possibile assegnare un gruppo a un utente e configurare le autorizzazioni per i gruppi in modo che possano inviare, ricevere e amministrare code e argomenti specifici. **Nota** Non è possibile configurare i gruppi indipendentemente dagli utenti. Un'etichetta di gruppo viene creata quando si aggiunge almeno un utente ed eliminata quando si rimuovono tutti gli utenti da essa. **Nota** Il `activemq-webconsole` gruppo in ActiveMQ su Amazon MQ dispone delle autorizzazioni di amministratore per tutte le code e gli argomenti. Tutti gli utenti di questo gruppo avranno accesso come amministratore. Nei seguenti esempi viene mostrato come creare, modificare ed eliminare gli utenti del broker Amazon MQ utilizzando la Console di gestione AWS. ## Creare un nuovo utente del broker ActiveMQ 1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/). 1. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio **MyBroker**), quindi scegli **Visualizza** dettagli. Nella ***MyBroker***pagina, nella sezione **Utenti**, sono elencati tutti gli utenti di questo broker. ![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png) 1. Selezionare **Create user (Crea utente)**. 1. Nella finestra di dialogo **Create user (Crea utente)**, digitare **Username (Nome utente)** e **Password**. 1. (Facoltativo) Digitare i nomi dei gruppi cui appartiene l'utente, separati da virgole (ad esempio: `Devs, Admins`). 1. (Facoltativo) Per abilitare l'accesso dell'utente a [ActiveMQ Web Console (Console Web ActiveMQ)](http://activemq.apache.org/web-console.html), scegliere **ActiveMQ Web Console (Console Web ActiveMQ)**. 1. Selezionare **Create user (Crea utente)**. **Importante** Apportare modifiche a un utente *non* applica le modifiche all'utente in modo istantaneo. Per applicare le modifiche, attendere la finestra di manutenzione successiva o [riavviare il broker](amazon-mq-rebooting-broker.md). # Modifica un utente del broker ActiveMQ Per modificare un utente esistente, procedi come segue: 1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/). 1. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio **MyBroker**), quindi scegli **Visualizza dettagli**. Nella ***MyBroker***pagina, nella sezione **Utenti**, sono elencati tutti gli utenti di questo broker. ![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png) 1. Seleziona le credenziali di accesso e poi **Modifica**. Viene visualizzata la finestra di dialogo **Edit user (Modifica utente)**. 1. (Facoltativo) Digitare una nuova **Password**. 1. (Facoltativo) Aggiungere o rimuovere i nomi dei gruppi cui appartiene l'utente, separati da virgole (ad esempio: `Managers, Admins`). 1. (Facoltativo) Per abilitare l'accesso dell'utente a [ActiveMQ Web Console (Console Web ActiveMQ)](http://activemq.apache.org/web-console.html), scegliere **ActiveMQ Web Console (Console Web ActiveMQ)**. 1. Per salvare le modifiche apportate all'utente, selezionare **Done (Fatto)**. **Importante** Apportare modifiche a un utente *non* applica le modifiche all'utente in modo istantaneo. Per applicare le modifiche, attendere la finestra di manutenzione successiva o [riavviare il broker](amazon-mq-rebooting-broker.md). # Eliminare un utente del broker ActiveMQ Quando non è più necessario un utente, è possibile eliminarlo. 1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/). 1. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio, **MyBroker**), quindi scegli **Visualizza dettagli**. Nella ***MyBroker***pagina, nella sezione **Utenti**, sono elencati tutti gli utenti di questo broker. ![\[Table showing two users with their console access and group information.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-list-users.png) 1. **Seleziona le tue credenziali di accesso (ad esempio ***MyUser***), quindi scegli Elimina.** 1. **Per confermare l'eliminazione dell'utente, nella sezione Elimina? *MyUser*** nella finestra di dialogo, scegli **Elimina**. **Importante** Apportare modifiche a un utente *non* applica le modifiche all'utente in modo istantaneo. Per applicare le modifiche, attendere la finestra di manutenzione successiva o [riavviare il broker](amazon-mq-rebooting-broker.md). # Esempi funzionanti di utilizzo di Java Message Service (JMS) con ActiveMQ Nei seguenti esempi viene illustrato come utilizzare ActiveMQ a livello di codice: + Il codice Java di OpenWire esempio si connette a un broker, crea una coda e invia e riceve un messaggio. Per un'analisi e una spiegazione dettagliata, consulta [Connessione di un'applicazione Java alil broker Amazon MQ](amazon-mq-connecting-application.md). + L'esempio di codice funzionante Java MQTT si connette a un broker, crea un argomento e invia e riceve un messaggio. + L'esempio di codice funzionante Java STOMP\$1WSS si connette a un broker, crea una coda e invia e riceve un messaggio. ## Prerequisiti ### Abilitazione attributi VPC Per garantire che il broker sia accessibile all'interno del VPC, è necessario abilitare gli attributi VPC `enableDnsHostnames` e `enableDnsSupport`. Per ulteriori informazioni, consultare [Supporto del DNS nel VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) nella *Guida per l'utente di Amazon VPC*. ### Abilitazione delle connessioni in entrata Per utilizzare Amazon MQ a livello di programmazione, devi utilizzare connessioni in entrata. 1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/). 1. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio,). **MyBroker** 1. Nella ***MyBroker***pagina, nella sezione **Connessioni**, annota gli indirizzi e le porte dell'URL della console web del broker e dei protocolli a livello di cavo. 1. Nella sezione **Details** (Dettagli), in **Security and network** (Sicurezza e rete), scegliere il nome del gruppo di sicurezza o ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png). Viene visualizzata la pagina **Security Groups (Gruppi di sicurezza)** del pannello di controllo EC2. 1. Scegli il tuo gruppo di sicurezza dall'elenco. 1. Nella parte inferiore della pagina scegli **Inbound (In entrata)**, quindi scegli **Edit (Modifica)**. 1. Nella finestra di dialogo **Edit inbound rules** (Modifica le regole in entrata), aggiungere una regola per ogni URL o endpoint che si desidera rendere accessibile pubblicamente (nell'esempio seguente viene illustrato come eseguire questa operazione per una console Web del broker). 1. Selezionare **Add Rule (Aggiungi regola)**. 1. Per **Type (Tipo)** seleziona **Custom TCP (TCP personalizzato)**. 1. Per **Port Range** (Intervallo porte), digitare la porta della console Web (`8162`). 1. Per **Source** (Origine), lasciare selezionato **Custom** (Personalizzato), quindi inserire l'indirizzo IP del sistema a cui desideri poter accedere alla console Web (ad esempio, `192.0.2.1`). 1. Scegli **Save** (Salva). Il broker può ora accettare connessioni in entrata. ### Aggiunta di dipendenze Java ------ #### [ OpenWire ] Aggiungere i pacchetti `activemq-client.jar` e `activemq-pool.jar` al percorso di classe Java. L'esempio seguente mostra queste dipendenze in un file `pom.xml` di progetto Maven. ``` org.apache.activemq activemq-client 5.15.16 org.apache.activemq activemq-pool 5.15.16 ``` Per ulteriori informazioni su `activemq-client.jar`, consultare [Configurazione iniziale](http://activemq.apache.org/initial-configuration.html) nella documentazione di Apache ActiveMQ. ------ #### [ MQTT ] Aggiungi il pacchetto `org.eclipse.paho.client.mqttv3.jar` al percorso di classe Java. L'esempio seguente mostra questa dipendenza in un file `pom.xml` di progetto Maven. ``` org.eclipse.paho org.eclipse.paho.client.mqttv3 1.2.0 ``` Per ulteriori informazioni su `org.eclipse.paho.client.mqttv3.jar`, consulta [Eclipse Paho Java Client](https://www.eclipse.org/paho/clients/java/). ------ #### [ STOMP\$1WSS ] Aggiungi i pacchetti seguenti al percorso di classe Java: + `spring-messaging.jar` + `spring-websocket.jar` + `javax.websocket-api.jar` + `jetty-all.jar` + `slf4j-simple.jar` + `jackson-databind.jar` L'esempio seguente mostra queste dipendenze in un file `pom.xml` di progetto Maven. ``` org.springframework spring-messaging 5.0.5.RELEASE org.springframework spring-websocket 5.0.5.RELEASE javax.websocket javax.websocket-api 1.1 org.eclipse.jetty.aggregate jetty-all pom 9.3.3.v20150827 org.slf4j slf4j-simple 1.6.6 com.fasterxml.jackson.core jackson-databind 2.5.0 ``` Per ulteriori informazioni, consulta [STOMP Support](https://docs.spring.io/spring-integration/docs/5.0.5.RELEASE/reference/html/stomp.html) nella documentazione di Spring Framework. ------ ## Amazon MQExample .java **Importante** Nel codice di esempio seguente, produttori e consumatori vengono eseguiti in un singolo thread. Per i sistemi di produzione (o per testare il failover delle istanze del broker), assicurarsi che i produttori e i consumatori vengano eseguiti su host o thread separati. ------ #### [ 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); } } } ``` ------