Migrera befintliga Java Message Service-program (JMS) 2.0 från Apache ActiveMQ till Azure Service Bus

  • Artikel

I den här artikeln beskrivs hur du ändrar ett befintligt Java Message Service (JMS) 2.0-program som interagerar med en JMS Broker för att interagera med Azure Service Bus i stället. I synnerhet omfattar artikeln migrering från Apache ActiveMQ eller Amazon MQ.

Azure Service Bus stöder Java 2-plattforms-, Enterprise Edition- och Spring-arbetsbelastningar som använder JMS 2.0-API:et via Advanced Message Queueing Protocol (AMQP).

Innan du börjar

Skillnader mellan Azure Service Bus och Apache ActiveMQ

Azure Service Bus och Apache ActiveMQ är båda meddelandeköer som fungerar som JMS-leverantörer för klientprogram för att skicka meddelanden till och ta emot meddelanden från. De aktiverar både punkt-till-punkt-semantik med köer och publicera-prenumerera-semantik med ämnen och prenumerationer.

Trots detta finns det vissa skillnader mellan de två, som följande tabell visar:

Kategori ActiveMQ Azure Service Bus
Programnivåindelning Klustrad monolit Två nivåer
(gateway + serverdel)
Protokollstöd
  • AMQP
  • STOMP
  • OpenWire
AMQP
Etableringsläge
  • Infrastruktur som en tjänst (IaaS), lokalt
  • Amazon MQ (hanterad plattform som en tjänst)
Hanterad plattform som en tjänst (PaaS)
Meddelandestorlek Kundkonfigurerbar 100 MB (Premium-nivå)
Hög tillgänglighet Kundhanterad Plattformshanterad
Haveriberedskap Kundhanterad Plattformshanterad

Aktuella funktioner som stöds och inte stöds

I följande tabell visas de JMS-funktioner (Java Message Service) som Azure Service Bus stöder för närvarande. Den visar även funktioner som inte stöds.

Funktion API Status
Köer
  • JMSContext.createQueue( String queueName)
Stöds
Ämnen
  • JMSContext.createTopic( String topicName)
Stöds
Tillfälliga köer
  • JMSContext.createTemporaryQueue()
Stöds
Tillfälliga ämnen
  • JMSContext.createTemporaryTopic()
Stöds
Meddelandeproducent/
JMSProducer
  • JMSContext.createProducer()
Stöds
Köwebbläsare
  • JMSContext.createBrowser(kökö)
  • JMSContext.createBrowser(Kökö, SträngmeddelandeVälj)
Stöds
Meddelandekonsument/
JMSConsumer
  • JMSContext.createConsumer( Målmål)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte		 Stöds
Delade varaktiga prenumerationer
  • JMSContext.createSharedDurableConsumer(Ämnesämne, Strängnamn)
  • JMSContext.createSharedDurableConsumer(Ämnesämne, Strängnamn, SträngmeddelandeVälj)
Stöds
Ej delade varaktiga prenumerationer
  • JMSContext.createDurableConsumer(Ämnesämne, Strängnamn)
  • createDurableConsumer(Ämnesämne, Strängnamn, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte och bör anges till false		 Stöds
Delade icke-varaktiga prenumerationer
  • JMSContext.createSharedConsumer(Ämnesämne, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector)
Stöds
Ej delade icke-varaktiga prenumerationer
  • JMSContext.createConsumer(målmål)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj)
  • JMSContext.createConsumer( Målmål, SträngmeddelandeVälj, boolesk noLocal)

noLocal stöds för närvarande inte och bör anges till false		 Stöds
Meddelandeväljare beror på vilken konsument som skapats Stöds
Leveransfördröjning (schemalagda meddelanden)
  • JMSProducer.setDeliveryDelay( long deliveryDelay)
Stöds
Meddelande har skapats
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Serializable object)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( Strängtext)
Stöds
Transaktioner mellan entiteter
  • Anslut ion.createSession(true, Session.SESSION_TRANSACTED)
 Stöds
Distribuerade transaktioner Stöds inte

Överväganden

Den tvådelade typen av Azure Service Bus ger olika funktioner för affärskontinuitet (hög tillgänglighet och haveriberedskap). Det finns dock vissa överväganden när du använder JMS-funktioner.

Tjänstuppgraderingar

Vid service bus-uppgraderingar och omstarter tas tillfälliga köer eller ämnen bort. Om ditt program är känsligt för dataförlust i tillfälliga köer eller ämnen ska du inte använda tillfälliga köer eller ämnen. Använd varaktiga köer, ämnen och prenumerationer i stället.

Datamigrering

Som en del av att migrera och ändra dina klientprogram för att interagera med Azure Service Bus migreras inte de data som lagras i ActiveMQ till Service Bus. Du kan behöva ett anpassat program för att tömma ActiveMQ-köer, ämnen och prenumerationer och sedan spela upp meddelandena till köer, ämnen och prenumerationer i Service Bus.

Autentisering och auktorisering

Rollbaserad åtkomstkontroll i Azure (Azure RBAC), som backas upp av Microsoft Entra-ID, är den föredragna autentiseringsmekanismen för Service Bus. Om du vill aktivera rollbaserad åtkomstkontroll följer du stegen i utvecklarguiden för Azure Service Bus JMS 2.0.

Före migrering

Versionskontroll

Du använder följande komponenter och versioner när du skriver JMS-programmen:

Komponent Version:
Java Message Service (JMS) API 1.1 eller senare
AMQP-protokoll 1.0

Kontrollera att AMQP-portar är öppna

Service Bus stöder kommunikation via AMQP-protokollet. För detta ändamål aktiverar du kommunikation via portarna 5671 (AMQP) och 443 (TCP). Beroende på var klientprogrammen finns kan du behöva ett supportärende för att tillåta kommunikation via dessa portar.

Viktigt!

Service Bus stöder endast AMQP 1.0-protokoll.

Konfigurera företagskonfigurationer

Service Bus möjliggör olika funktioner för företagssäkerhet och hög tillgänglighet. Mer information finns i:

Övervakning, aviseringar och spårning

För varje Service Bus-namnområde publicerar du mått på Azure Monitor. Du kan använda dessa mått för aviseringar och dynamisk skalning av resurser som allokerats till namnområdet.

Mer information om de olika måtten och hur du konfigurerar aviseringar för dem finns i Service Bus-mått i Azure Monitor. Du kan också ta reda på mer om spårning på klientsidan för dataåtgärder och drift-/diagnostikloggning för hanteringsåtgärder.

Mått – Ny relik

Du kan korrelera vilka mått från ActiveMQ-karta till vilka mått i Azure Service Bus. Se följande från webbplatsen New Relic:

Kommentar

För närvarande har New Relic inte direkt, sömlös integrering med ActiveMQ, men de har mått tillgängliga för Amazon MQ. Eftersom Amazon MQ härleds från ActiveMQ mappar följande tabell måtten New Relic från Amazon MQ till Azure Service Bus.

Måttgruppering Amazon MQ/ActiveMQ-mått Azure Service Bus-mått
Broker CpuUtilization CPUXNS
Broker MemoryUsage WSXNS
Broker CurrentConnectionsCount activeConnections
Broker EstablishedConnectionsCount activeConnections + connectionsClosed
Broker InactiveDurableTopicSubscribersCount Använda prenumerationsmått
Broker TotalMessageCount Använda kö/ämne/prenumerationsnivå activeMessages
Kö/ämne EnqueueCount incomingMessages
Kö/ämne DequeueCount outgoingMessages
Kö QueueSize sizeBytes

Migrering

Om du vill migrera ditt befintliga JMS 2.0-program för att interagera med Service Bus följer du stegen i de kommande avsnitten.

Exportera topologin från ActiveMQ och skapa entiteterna i Service Bus (valfritt)

För att säkerställa att klientprogram smidigt kan ansluta till Service Bus migrerar du topologin (inklusive köer, ämnen och prenumerationer) från Apache ActiveMQ till Service Bus.

Kommentar

För JMS-program skapar du köer, ämnen och prenumerationer som en körningsåtgärd. De flesta JMS-leverantörer (meddelandeköer) ger dig möjlighet att skapa dessa vid körning. Därför anses det här exportsteget vara valfritt. För att säkerställa att ditt program har behörighet att skapa topologin vid körning använder du anslutningssträng med SAS-behörigheterManage.

Gör så här:

  1. Använd ActiveMQ-kommandoradsverktygen för att exportera topologin.
  2. Återskapa samma topologi med hjälp av en Azure Resource Manager-mall.
  3. Kör Azure Resource Manager-mallen.

Importera maven-beroendet för Service Bus JMS-implementering

För att säkerställa sömlös anslutning med Service Bus lägger du till azure-servicebus-jms paketet som ett beroende till Maven-filen pom.xml på följande sätt:

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

Konfigurationsändringar för programserver

Den här delen är anpassad till programservern som är värd för dina klientprogram som ansluter till ActiveMQ.

Spring-program

application.properties Uppdatera filen

Om du använder ett Spring Boot-program för att ansluta till ActiveMQ vill du ta bort de ActiveMQ-specifika egenskaperna från application.properties filen.

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

Lägg sedan till de Service Bus-specifika egenskaperna i application.properties filen.

azure.servicebus.connection-string=Endpoint=myEndpoint;SharedAccessKeyName=mySharedAccessKeyName;SharedAccessKey=mySharedAccessKey
Ersätt ActiveMQConnectionFactory med ServiceBusJmsConnectionFactory

Nästa steg är att ersätta instansen av ActiveMQConnectionFactory med ServiceBusJmsConnectionFactory.

Kommentar

De faktiska kodändringarna är specifika för programmet och hur beroenden hanteras, men följande exempel innehåller vägledning om vad som ska ändras.

Tidigare kanske du instansierar ett objekt i ActiveMQConnectionFactory, enligt följande:


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

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

Nu ändrar du detta för att instansiera ett objekt i ServiceBusJmsConnectionFactory, enligt följande:


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

Efter migreringen

Nu när du har ändrat programmet så att det börjar skicka och ta emot meddelanden från Service Bus bör du kontrollera att det fungerar som förväntat. När det är klart kan du fortsätta att förfina och modernisera programstacken ytterligare.

Nästa steg

Använd Spring Boot Starter för Azure Service Bus JMS för sömlös integrering med Service Bus.

Mer information om Service Bus-meddelanden och JMS finns i: