Migrar aplicativos Java Message Service (JMS) 2.0 existentes do Apache ActiveMQ para o Azure Service Bus

  • Artigo

Este artigo descreve como modificar um aplicativo Java Message Service (JMS) 2.0 existente que interage com um agente JMS para interagir com o Barramento de Serviço do Azure. Em particular, o artigo aborda a migração do Apache ActiveMQ ou do Amazon MQ.

O Barramento de Serviço do Azure dá suporte a cargas de trabalho Java 2 Platform, Enterprise Edition e Spring que usam a API JMS 2.0 sobre o protocolo AMQP (Advanced Message Queueing Protocol).

Antes de começar

Diferenças entre o Azure Service Bus e o Apache ActiveMQ

O Barramento de Serviço do Azure e o Apache ActiveMQ são ambos agentes de mensagens, funcionando como provedores JMS para aplicativos cliente enviarem e receberem mensagens. Ambos habilitam a semântica ponto-a-ponto com filas e a semântica publicar-assinar com tópicos e assinaturas.

Mesmo assim, existem algumas diferenças entre os dois, como mostra a tabela a seguir:

Categoria ActiveMQ Azure Service Bus
Hierarquização de aplicativos Monólito agrupado Dois níveis
(gateway + back-end)
Suporte de protocolo
  • AMQP
  • STOMP
  • OpenWire
AMQP
Modo de provisionamento
  • Infraestrutura como serviço (IaaS), local
  • Amazon MQ (plataforma gerenciada como serviço)
Plataforma gerenciada como serviço (PaaS)
Tamanho da mensagem Configurável pelo cliente 100 MB (nível Premium)
Elevada disponibilidade Gerenciado pelo cliente Plataforma gerida
Recuperação após desastre Gerenciado pelo cliente Plataforma gerida

Recursos atuais suportados e não suportados

A tabela a seguir lista os recursos do Java Message Service (JMS) que o Azure Service Bus suporta atualmente. Ele também mostra recursos que não são suportados.

Caraterística API Estado
Filas
  • JMSContext.createQueue( String queueName)
Suportado
Tópicos
  • JMSContext.createTopic( String topicName)
Suportado
Filas temporárias
  • JMSContext.createTemporaryQueue()
Suportado
Tópicos temporários
  • JMSContext.createTemporaryTopic()
Suportado
Produtor de Mensagens /
JMSProducer
  • JMSContext.createProducer()
Suportado
Navegadores de fila
  • JMSContext.createBrowser(fila de fila)
  • JMSContext.createBrowser(fila de fila, String messageSelector)
Suportado
Mensagem Consumidor/
JMSConsumer
  • JMSContext.createConsumer( Destino de destino)
  • JMSContext.createConsumer( Destino de destino, String messageSelector)
  • JMSContext.createConsumer( Destino de destino, String messageSelector, boolean noLocal)

noLocal não é suportado no momento		 Suportado
Subscrições duradouras partilhadas
  • JMSContext.createSharedDurableConsumer(tópico do tópico, nome da cadeia de caracteres)
  • JMSContext.createSharedDurableConsumer(tópico do tópico, nome da cadeia de caracteres, mensagem da cadeia de caracteresSeletor)
Suportado
Subscrições duradouras não partilhadas
  • JMSContext.createDurableConsumer(tópico do tópico, nome da cadeia de caracteres)
  • createDurableConsumer(tópico do tópico, nome da cadeia de caracteres, String messageSelector, boolean noLocal)

noLocal não é suportado atualmente e deve ser definido como false		 Suportado
Subscrições partilhadas não duráveis
  • JMSContext.createSharedConsumer(tópico do tópico, String sharedSubscriptionName)
  • JMSContext.createSharedConsumer(tópico do tópico, String sharedSubscriptionName, String messageSelector)
Suportado
Subscrições não partilhadas não duradouras
  • JMSContext.createConsumer(Destino de destino)
  • JMSContext.createConsumer( Destino de destino, String messageSelector)
  • JMSContext.createConsumer( Destino de destino, String messageSelector, boolean noLocal)

noLocal não é suportado atualmente e deve ser definido como false		 Suportado
Seletores de mensagens depende do consumidor criado Suportado
Atraso na entrega (mensagens agendadas)
  • JMSProducer.setDeliveryDelay( entrega longaDelay)
Suportado
Mensagem criada
  • JMSContext.createMessage()
  • JMSContext.createBytesMessage()
  • JMSContext.createMapMessage()
  • JMSContext.createObjectMessage( Objeto serializável)
  • JMSContext.createStreamMessage()
  • JMSContext.createTextMessage()
  • JMSContext.createTextMessage( Texto da cadeia de caracteres)
Suportado
Transações entre entidades
  • Connection.createSession(true, Session.SESSION_TRANSACTED)
Suportado
Transações distribuídas Não suportado

Considerações

A natureza de duas camadas do Barramento de Serviço do Azure oferece vários recursos de continuidade de negócios (alta disponibilidade e recuperação de desastres). No entanto, há algumas considerações quando você estiver usando recursos JMS.

Atualizações de serviço

Em caso de atualizações e reinicializações do barramento de serviço, filas temporárias ou tópicos são excluídos. Se seu aplicativo for sensível à perda de dados em filas ou tópicos temporários, não use filas ou tópicos temporários. Em vez disso, use filas, tópicos e assinaturas duráveis.

Migração de dados

Como parte da migração e modificação de seus aplicativos cliente para interagir com o Barramento de Serviço do Azure, os dados mantidos no ActiveMQ não são migrados para o Service Bus. Você pode precisar de um aplicativo personalizado para drenar as filas, tópicos e assinaturas do ActiveMQ e, em seguida, reproduzir as mensagens para as filas, tópicos e assinaturas do Service Bus.

Autenticação e autorização

O controle de acesso baseado em função do Azure (Azure RBAC), apoiado pela ID do Microsoft Entra, é o mecanismo de autenticação preferencial para o Service Bus. Para habilitar o controle de acesso baseado em função, siga as etapas no guia do desenvolvedor do Azure Service Bus JMS 2.0.

Pré-migração

Verificação de versão

Você usa os seguintes componentes e versões enquanto escreve os aplicativos JMS:

Componente Versão
Java Message Service (JMS) API 1.1 ou superior
Protocolo AMQP 1.0

Verifique se as portas AMQP estão abertas

O Service Bus suporta comunicação através do protocolo AMQP. Para isso, habilite a comunicação pelas portas 5671 (AMQP) e 443 (TCP). Dependendo de onde os aplicativos cliente estão hospedados, você pode precisar de um tíquete de suporte para permitir a comunicação por essas portas.

Importante

O Service Bus suporta apenas o protocolo AMQP 1.0.

Configurar configurações empresariais

O Service Bus permite vários recursos de segurança corporativa e alta disponibilidade. Para obter mais informações, consulte:

Monitorização, alertas e rastreio

Para cada namespace do Service Bus, você publica métricas no Azure Monitor. Você pode usar essas métricas para alertas e dimensionamento dinâmico de recursos alocados para o namespace.

Para obter mais informações sobre as diferentes métricas e como configurar alertas nelas, consulte Métricas do Barramento de Serviço no Azure Monitor. Você também pode saber mais sobre o rastreamento do lado do cliente para operações de dados e o log operacional/de diagnóstico para operações de gerenciamento.

Métricas - Nova Relíquia

Você pode correlacionar quais métricas do ActiveMQ mapeiam com quais métricas no Barramento de Serviço do Azure. Veja o seguinte no site da New Relic:

Nota

Atualmente, o New Relic não tem integração direta e perfeita com o ActiveMQ, mas tem métricas disponíveis para o Amazon MQ. Como o Amazon MQ é derivado do ActiveMQ, a tabela a seguir mapeia as métricas do New Relic do Amazon MQ para o Azure Service Bus.

Agrupamento métrico Métrica do Amazon MQ/ActiveMQ Métrica do Barramento de Serviço do Azure
Mediador CpuUtilization CPUXNS
Mediador MemoryUsage WSXNS
Mediador CurrentConnectionsCount activeConnections
Mediador EstablishedConnectionsCount activeConnections + connectionsClosed
Mediador InactiveDurableTopicSubscribersCount Usar métricas de assinatura
Mediador TotalMessageCount Usar nível de fila/tópico/assinatura activeMessages
Fila/Tópico EnqueueCount incomingMessages
Fila/Tópico DequeueCount outgoingMessages
Fila QueueSize sizeBytes

Migração

Para migrar seu aplicativo JMS 2.0 existente para interagir com o Service Bus, siga as etapas nas próximas seções.

Exporte a topologia do ActiveMQ e crie as entidades no Service Bus (opcional)

Para garantir que os aplicativos cliente possam se conectar perfeitamente ao Service Bus, migre a topologia (incluindo filas, tópicos e assinaturas) do Apache ActiveMQ para o Service Bus.

Nota

Para aplicativos JMS, você cria filas, tópicos e assinaturas como uma operação de tempo de execução. A maioria dos provedores JMS (agentes de mensagens) oferece a capacidade de criá-los em tempo de execução. É por isso que esta etapa de exportação é considerada opcional. Para garantir que seu aplicativo tenha as permissões para criar a topologia em tempo de execução, use a cadeia de Manage conexão com permissões SAS.

Para tal:

  1. Use as ferramentas de linha de comando do ActiveMQ para exportar a topologia.
  2. Recrie a mesma topologia usando um modelo do Azure Resource Manager.
  3. Execute o modelo do Azure Resource Manager.

Importar a dependência maven para implementação JMS do Service Bus

Para garantir uma conectividade perfeita com o Service Bus, adicione o azure-servicebus-jms pacote como uma dependência ao arquivo Maven pom.xml , da seguinte maneira:

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

Alterações na configuração do servidor de aplicativos

Esta parte é personalizada para o servidor de aplicativos que está hospedando seus aplicativos cliente que se conectam ao ActiveMQ.

Aplicações de mola

Atualizar o application.properties ficheiro

Se você estiver usando um aplicativo de inicialização Spring para se conectar ao ActiveMQ, desejará remover as propriedades específicas do ActiveMQ do application.properties arquivo.

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

Em seguida, adicione as propriedades específicas do Service Bus ao application.properties arquivo.

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

A próxima etapa é substituir a instância de ActiveMQConnectionFactory pelo ServiceBusJmsConnectionFactory.

Nota

As alterações de código reais são específicas para o aplicativo e como as dependências são gerenciadas, mas o exemplo a seguir fornece a orientação sobre o que deve ser alterado.

Anteriormente, você pode ter instanciado um objeto de , da ActiveMQConnectionFactoryseguinte maneira:


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

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

Agora, você está alterando isso para instanciar um objeto de , da ServiceBusJmsConnectionFactoryseguinte maneira:


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

Pós-migração

Agora que você modificou o aplicativo para começar a enviar e receber mensagens do Service Bus, verifique se ele funciona como esperado. Quando isso for feito, você poderá continuar a refinar e modernizar ainda mais sua pilha de aplicativos.

Próximos passos

Use o Spring Boot Starter for Azure Service Bus JMS para integração perfeita com o Service Bus.

Para saber mais sobre mensagens do Service Bus e JMS, consulte: