Condividi tramite

Eseguire la migrazione di applicazioni Java Message Service (JMS) 2.0 esistenti da Apache ActiveMQ a bus di servizio di Azure

  • Articolo

Questo articolo illustra come modificare un'applicazione JMS (Java Message Service) 2.0 esistente che interagisce con un broker JMS per interagire con bus di servizio di Azure. In particolare, l'articolo illustra la migrazione da Apache ActiveMQ o Amazon MQ.

bus di servizio di Azure supporta i carichi di lavoro Java 2 Platform, edizione Enterprise e Spring che usano l'API JMS 2.0 su Advanced Message Queueing Protocol (AMQP).

Prima di iniziare

Differenze tra bus di servizio di Azure e Apache ActiveMQ

bus di servizio di Azure e Apache ActiveMQ sono entrambi broker di messaggi, che funzionano come provider JMS per le applicazioni client per inviare e ricevere messaggi da. Entrambi abilitano la semantica da punto a punto con le code e la semantica di pubblicazione-sottoscrizione con argomenti e sottoscrizioni.

Anche in questo caso, esistono alcune differenze tra i due, come illustrato nella tabella seguente:

Categoria ActiveMQ Bus di servizio di Azure
Suddivisione in livelli dell'applicazione Monolith cluster Due livelli
(gateway + back-end)
Supporto del protocollo
  • AMQP
  • STOMP
  • OpenWire
AMQP
Modalità di provisioning
  • Infrastruttura distribuita come servizio (IaaS), locale
  • Amazon MQ (piattaforma gestita come servizio)
Piattaforma gestita distribuita come servizio (PaaS)
Dimensione del messaggio Configurabile dal cliente 100 MB (livello Premium)
Disponibilità elevata Gestita dal cliente Piattaforma gestita
Ripristino di emergenza Gestita dal cliente Piattaforma gestita

Funzionalità supportate e non supportate correnti

La tabella seguente elenca le funzionalità di Java Message Service (JMS) attualmente supportate bus di servizio di Azure. Mostra anche le funzionalità non supportate.

Funzionalità API Stato
Code
  • JMSContext.createQueue( String queueName)
Supportato
Argomenti
  • JMSContext.createTopic( String topicName)
Supportato
Code temporanee
  • JMSContext.createTemporaryQueue()
Supportato
Argomenti temporanei
  • JMSContext.createTemporaryTopic()
Supportato
Producer di messaggi/
JMSProducer
  • JMSContext.createProducer()
Supportato
Browser di accodamento
  • JMSContext.createBrowser(Queue queue)
  • JMSContext.createBrowser(Queue queue, String messageSelector)
Supportato
Consumer di messaggi/
JMSConsumer
  • JMSContext.createConsumer( Destinazione di destinazione)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato		 Supportato
Sottoscrizioni durevoli condivise
  • JMSContext.createSharedDurableConsumer(Topic topic, String name)
  • JMSContext.createSharedDurableConsumer(Topic, String name, String messageSelector)
Supportato
Sottoscrizioni permanenti non condivise
  • JMSContext.createDurableConsumer(Topic topic, String name)
  • createDurableConsumer(Topic, String name, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato e deve essere impostato su false		 Supportato
Sottoscrizioni non durevoli condivise
  • JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic, String sharedSubscriptionName, String messageSelector)
Supportato
Sottoscrizioni non durevoli non condivise
  • JMSContext.createConsumer(Destinazione)
  • JMSContext.createConsumer( Destination destination, String messageSelector)
  • JMSContext.createConsumer( Destination destination, String messageSelector, boolean noLocal)

noLocal non è attualmente supportato e deve essere impostato su false		 Supportato
Selettori di messaggi dipende dal consumer creato Supportato
Ritardo recapito (messaggi pianificati)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Supportato
Messaggio creato
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Oggetto Serializable)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( String text)
Supportato
Transazioni tra entità
  • Connessione ion.createSession(true, Session.edizione StandardSSION_TRANSACTED)
 Supportato
Transazioni distribuite Non supportato

Considerazioni

La natura a due livelli di bus di servizio di Azure offre diverse funzionalità di continuità aziendale (disponibilità elevata e ripristino di emergenza). Tuttavia, quando si usano le funzionalità JMS, è necessario tenere presenti alcune considerazioni.

Aggiornamenti del servizio

In caso di aggiornamenti e riavvii del bus di servizio, le code o gli argomenti temporanei vengono eliminati. Se l'applicazione è sensibile alla perdita di dati in code o argomenti temporanei, non usare code o argomenti temporanei. Usare invece code, argomenti e sottoscrizioni durevoli.

Migrazione dei dati

Durante la migrazione e la modifica delle applicazioni client per interagire con bus di servizio di Azure, i dati contenuti in ActiveMQ non vengono migrati a bus di servizio. Potrebbe essere necessaria un'applicazione personalizzata per svuotare le code, gli argomenti e le sottoscrizioni di ActiveMQ e quindi riprodurre i messaggi nelle code, negli argomenti e nelle sottoscrizioni di bus di servizio.

Autenticazione e autorizzazione

Il controllo degli accessi in base al ruolo di Azure, supportato da Microsoft Entra ID, è il meccanismo di autenticazione preferito per bus di servizio. Per abilitare il controllo degli accessi in base al ruolo, seguire la procedura descritta nella guida per sviluppatori di JMS 2.0 bus di servizio di Azure.

Pre-migrazione

Controllo della versione

Si usano i componenti e le versioni seguenti durante la scrittura delle applicazioni JMS:

Componente Versione
Java Message Service (JMS) API 1.1 o versione successiva
Protocollo AMQP 1.0

Assicurarsi che le porte AMQP siano aperte

bus di servizio supporta la comunicazione tramite il protocollo AMQP. A questo scopo, abilitare la comunicazione sulle porte 5671 (AMQP) e 443 (TCP). A seconda della posizione in cui sono ospitate le applicazioni client, potrebbe essere necessario un ticket di supporto per consentire la comunicazione su queste porte.

Importante

bus di servizio supporta solo il protocollo AMQP 1.0.

Configurare le configurazioni aziendali

bus di servizio abilita varie funzionalità di sicurezza aziendale e disponibilità elevata. Per altre informazioni, vedere:

Monitoraggio, avvisi e traccia

Per ogni spazio dei nomi bus di servizio si pubblicano metriche in Monitoraggio di Azure. È possibile usare queste metriche per l'invio di avvisi e il ridimensionamento dinamico delle risorse allocate allo spazio dei nomi.

Per altre informazioni sulle diverse metriche e su come configurare gli avvisi, vedere bus di servizio metriche in Monitoraggio di Azure. È anche possibile trovare altre informazioni sulla traccia lato client per le operazioni sui dati e la registrazione operativa/diagnostica per le operazioni di gestione.

Metriche - New Relic

È possibile correlare le metriche da ActiveMQ mappate alle metriche in bus di servizio di Azure. Vedere quanto segue dal sito Web di New Relic:

Nota

Attualmente, New Relic non ha un'integrazione diretta e senza problemi con ActiveMQ, ma ha metriche disponibili per Amazon MQ. Poiché Amazon MQ è derivato da ActiveMQ, la tabella seguente esegue il mapping delle metriche di New Relic da Amazon MQ a bus di servizio di Azure.

Raggruppamento delle metriche Metrica Amazon MQ/ActiveMQ metrica bus di servizio di Azure
Gestore CpuUtilization CPUXNS
Gestore MemoryUsage WSXNS
Gestore CurrentConnectionsCount activeConnections
Gestore EstablishedConnectionsCount activeConnections + connectionsClosed
Gestore InactiveDurableTopicSubscribersCount Usare le metriche delle sottoscrizioni
Gestore TotalMessageCount Usare il livello di coda/argomento/sottoscrizione activeMessages
Coda/Argomento EnqueueCount incomingMessages
Coda/Argomento DequeueCount outgoingMessages
Coda QueueSize sizeBytes

Migrazione

Per eseguire la migrazione dell'applicazione JMS 2.0 esistente per interagire con bus di servizio, seguire la procedura descritta nelle sezioni successive.

Esportare la topologia da ActiveMQ e creare le entità in bus di servizio (facoltativo)

Per garantire che le applicazioni client possano connettersi facilmente con bus di servizio, eseguire la migrazione della topologia (incluse code, argomenti e sottoscrizioni) da Apache ActiveMQ a bus di servizio.

Nota

Per le applicazioni JMS, è possibile creare code, argomenti e sottoscrizioni come operazione di runtime. La maggior parte dei provider JMS (broker di messaggi) consente di crearli in fase di esecuzione. Ecco perché questo passaggio di esportazione è considerato facoltativo. Per assicurarsi che l'applicazione disponga delle autorizzazioni per creare la topologia in fase di esecuzione, usare il stringa di connessione con autorizzazioni di firma di accesso condivisoManage.

Per eseguire questa operazione:

  1. Usare gli strumenti da riga di comando ActiveMQ per esportare la topologia.
  2. Ricreare la stessa topologia usando un modello di Azure Resource Manager.
  3. Eseguire il modello di Azure Resource Manager.

Importare la dipendenza maven per bus di servizio'implementazione di JMS

Per garantire una connettività senza problemi con bus di servizio, aggiungere il azure-servicebus-jms pacchetto come dipendenza al file Mavenpom.xml, come indicato di seguito:

<dependencies>
...
    <dependency>
        <groupId>com.microsoft.azure</groupId>
        <artifactId>azure-servicebus-jms</artifactId>
    </dependency>
...
</dependencies>

Modifiche alla configurazione del server applicazioni

Questa parte è personalizzata per il server applicazioni che ospita le applicazioni client che si connettono ad ActiveMQ.

Applicazioni Spring

Aggiornare il application.properties file

Se si usa un'applicazione Spring Boot per connettersi ad ActiveMQ, rimuovere le proprietà specifiche di ActiveMQ dal application.properties file.

spring.activemq.broker-url=<ACTIVEMQ BROKER URL>
spring.activemq.user=<ACTIVEMQ USERNAME>
spring.activemq.password=<ACTIVEMQ PASSWORD>

Aggiungere quindi le proprietà specifiche del bus di servizio al application.properties file.

azure.servicebus.connection-string=Endpoint=myEndpoint;SharedAccessKeyName=mySharedAccessKeyName;SharedAccessKey=mySharedAccessKey
Sostituire ActiveMQConnectionFactory con ServiceBusJmsConnectionFactory

Il passaggio successivo consiste nel sostituire l'istanza di ActiveMQConnectionFactory con .ServiceBusJmsConnectionFactory

Nota

Le modifiche effettive del codice sono specifiche per l'applicazione e la modalità di gestione delle dipendenze, ma l'esempio seguente fornisce le indicazioni su cosa modificare.

In precedenza, potrebbe essere stata creata un'istanza di un oggetto di ActiveMQConnectionFactory, come indicato di seguito:


String BROKER_URL = "<URL of the hosted ActiveMQ broker>";
ConnectionFactory factory = new ActiveMQConnectionFactory(BROKER_URL);

Connection connection = factory.createConnection();
connection.start();

A questo scopo, si sta modificando questa opzione per creare un'istanza di un oggetto di ServiceBusJmsConnectionFactory, come indicato di seguito:


ServiceBusJmsConnectionFactorySettings settings = new ServiceBusJmsConnectionFactorySettings();
String SERVICE_BUS_CONNECTION_STRING = "<Service Bus Connection string>";

ConnectionFactory factory = new ServiceBusJmsConnectionFactory(SERVICE_BUS_CONNECTION_STRING, settings);

Connection connection = factory.createConnection();
connection.start();

Dopo la migrazione

Ora che l'applicazione è stata modificata per iniziare a inviare e ricevere messaggi da bus di servizio, è necessario verificare che funzioni come previsto. Al termine, è possibile continuare a perfezionare e modernizzare ulteriormente lo stack di applicazioni.

Passaggi successivi

Usare Spring Boot Starter per bus di servizio di Azure JMS per una perfetta integrazione con bus di servizio.

Per altre informazioni sulla messaggistica bus di servizio e su JMS, vedere: