RabbitMQ: Primeiros passos

Como usar o Stackhero para RabbitMQ

👋 Bem-vindo à documentação da Stackhero!

A Stackhero oferece uma solução RabbitMQ cloud pronta para uso que proporciona uma série de benefícios, incluindo:

Acesso completo à interface web do RabbitMQ para gerir utilizadores, vhosts e permissões.

Filas ilimitadas sem limitações de tempo de retenção.

Suporte para os protocolos AMQP, MQTT, STOMP e WebSocket.

Muitos plugins incluídos, como Delayed Message Exchange, Message Deduplication e Consistent-hash Exchange.

Atualizações fáceis com apenas um clique.

Desempenho ótimo e segurança robusta alimentados por uma VM privada e dedicada.

Poupe tempo e simplifique a sua vida: leva apenas 5 minutos para experimentar a solução de hospedagem cloud RabbitMQ da Stackhero!

Usar Python para se conectar ao RabbitMQ

Este exemplo mostra como usar a biblioteca Aio Pika para conectar Python ao RabbitMQ. Em muitos casos, especificar o URL AMQPS é tudo o que é necessário:

connection = await aio_pika.connect_robust(
  "amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>",
)

Abaixo está um exemplo completo em Python que estabelece uma conexão segura com o RabbitMQ. Pode seguir estes passos para verificar a sua conexão e configurar uma fila básica:

import asyncio
import logging
import aio_pika

async def main() -> None:
    # Descomente a linha seguinte para ativar logs de depuração
    # logging.basicConfig(level=logging.DEBUG)

    connection = await aio_pika.connect_robust(
        "amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>"
    )

    async with connection:
        print("A conexão funcionou!")
        channel = await connection.channel()
        await channel.set_qos(prefetch_count=10)
        queue = await channel.declare_queue("test_queue", auto_delete=True)

if __name__ == "__main__":
    asyncio.run(main())

Lidar com o erro `unable to get local issuer certificate`

Se vir o erro

aiormq.exceptions.AMQPConnectionError: [Errno 5] [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1006)

ao conectar ao RabbitMQ a partir do Python, geralmente indica que o seu sistema está sem o certificado Let's Encrypt. Para resolver isto, instale os certificados CA comuns:

No Ubuntu/Debian, execute:
```
sudo apt install ca-certificates
```
No Alpine Linux, execute:
```
apk add ca-certificates
```

Se não puder usar estes comandos, pode instalar o certificado CA manualmente:

Faça o download do certificado CA Let's Encrypt de https://letsencrypt.org/certs/isrgrootx1.pem.

Depois, conecte-se ao RabbitMQ no seu código Python passando o ficheiro de certificado CA:

import ssl

ssl_context = ssl.create_default_context()
ssl_context.load_verify_locations(cafile='isrgrootx1.pem')

connection = await aio_pika.connect_robust(
  "amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>",
  ssl_context=ssl_context
)

Abaixo está um exemplo completo em Python que usa o certificado CA Let's Encrypt para estabelecer uma conexão segura:

import asyncio
import logging
import ssl
import aio_pika

async def main() -> None:
    # Descomente a linha seguinte para ativar logs de depuração
    # logging.basicConfig(level=logging.DEBUG)

    ssl_context = ssl.create_default_context()
    # Carregue manualmente o certificado CA Let's Encrypt
    # Faça o download usando: wget https://letsencrypt.org/certs/isrgrootx1.pem
    ssl_context.load_verify_locations(cafile='isrgrootx1.pem')

    connection = await aio_pika.connect_robust(
        "amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>",
        ssl_context=ssl_context
    )

    async with connection:
        print("A conexão funcionou!")
        channel = await connection.channel()
        await channel.set_qos(prefetch_count=10)
        queue = await channel.declare_queue("test_queue", auto_delete=True)


if __name__ == "__main__":
    asyncio.run(main())

Usar GoLang para se conectar ao RabbitMQ

Abaixo está um exemplo simples que mostra como se conectar ao RabbitMQ a partir de uma aplicação GoLang usando a biblioteca oficial Go RabbitMQ Client Library. Siga estes passos para configurar o seu projeto:

Crie um novo diretório e inicialize o módulo:

go mod init rabbitmq-example

Adicione a biblioteca RabbitMQ:

go get github.com/rabbitmq/amqp091-go

Crie um novo ficheiro chamado main.go e adicione o seguinte conteúdo:

package main

import (
  "fmt"
  amqp "github.com/rabbitmq/amqp091-go"
)

func main() {
  connection, err := amqp.Dial("amqps://<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>")
  if err != nil {
    panic(err)
  }
  defer connection.Close()

  fmt.Println("Conectado com sucesso à instância RabbitMQ")
}

Execute o seu código:

go run main.go

Deverá ver "Conectado com sucesso à instância RabbitMQ", o que indica que o seu código se conectou com segurança usando autenticação e encriptação TLS.

Para mais exemplos, pode explorar exemplos Go no repositório oficial RabbitMQ: https://github.com/rabbitmq/rabbitmq-tutorials/tree/main/go.

Usar PHP para se conectar ao RabbitMQ

Abaixo está um exemplo que demonstra como se conectar ao RabbitMQ a partir do PHP usando a biblioteca php-amqplib. Como as instâncias Stackhero usam encriptação TLS (SSL), a conexão deve ser estabelecida com AMQPSSLConnection:

use PhpAmqpLib\Connection\AMQPSSLConnection;

$connection = new AMQPSSLConnection(
  '<XXXXXX>.stackhero-network.com',
  <AMQP_PORT_TLS>,
  'admin',
  '<PASSWORD>',
  '/',
  array()
);

/**
 * @param \PhpAmqpLib\Connection\AbstractConnection $connection
 */
function shutdown($connection)
{
  $connection->close();
}

register_shutdown_function('shutdown', $connection);

Fazer download manual do certificado CA

A conexão TLS pode exigir um certificado de Autoridade de Certificação (CA). Embora muitos servidores já tenham isto instalado, pode ser necessário fazer o download manualmente. Siga estes passos:

Faça o download do certificado de https://letsencrypt.org/certs/isrgrootx1.pem e guarde-o no seu servidor.
Use o seguinte código PHP para se conectar usando o certificado baixado:

$sslOptions = array(
  'cafile' => realpath(__DIR__ . '/isrgrootx1.pem'),
);

$connection = new AMQPSSLConnection(
  '<XXXXXX>.stackhero-network.com',
  <AMQP_PORT_TLS>,
  'admin',
  '<PASSWORD>',
  '/',
  $sslOptions
);

Usar PHP/Symfony para se conectar ao RabbitMQ

O Symfony pode usar o RabbitMQ como um broker de mensagens definindo a variável de ambiente MESSENGER_TRANSPORT_DSN. Para configurar isto, edite o ficheiro .env e defina a variável da seguinte forma:

MESSENGER_TRANSPORT_DSN=amqps://<USER>:<PASSWORD>@<HOST>:<PORT>/%2f/messages?cacert=%2Fetc%2Fssl%2Fcerts%2Fca-certificates.crt

Substitua <USER>, <PASSWORD>, <HOST> e <PORT> pelos seus detalhes do RabbitMQ.

Além disso, certifique-se de que o ficheiro config/packages/messenger.yaml usa a variável MESSENGER_TRANSPORT_DSN. A configuração deve ser assim:

framework:
    messenger:
        transports:
            async: '%env(MESSENGER_TRANSPORT_DSN)%'

Usar Spring Boot para se conectar ao RabbitMQ

Abaixo está um exemplo de como pode configurar o Spring Boot para se conectar com segurança a uma instância RabbitMQ Stackhero. Atualize as propriedades da sua aplicação com estas definições:

spring.rabbitmq.host=<XXXXXX>.stackhero-network.com
spring.rabbitmq.port=<AMQP_PORT_TLS>
spring.rabbitmq.username=admin
spring.rabbitmq.password=<PASSWORD>
spring.rabbitmq.ssl.enabled=true
spring.rabbitmq.ssl.algorithm=TLSv1.2

Usar .NET e MassTransit para se conectar ao RabbitMQ

Aqui está um exemplo mostrando como se conectar ao Stackhero RabbitMQ usando .NET e MassTransit. Este exemplo configura o host com as definições necessárias para encriptação TLS:

using MassTransit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;

public class Program
{
  public static void Main(string[] args)
  {
    var host = Host.CreateDefaultBuilder(args)
      .ConfigureServices((context, services) =>
      {
        services.AddMassTransit(x =>
        {
          x.UsingRabbitMq((context, cfg) =>
          {
            cfg.Host(new Uri("amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>"), h =>
            {
              h.UseSsl(s =>
              {
                s.Protocol = System.Security.Authentication.SslProtocols.Tls12;
              });
            });
          });
        });

        services.AddMassTransitHostedService(true);
      })
      .Build();

    host.Run();
  }
}

Mensagens atrasadas

Com o plugin "Mensagens atrasadas", pode atrasar ou agendar mensagens definindo um atraso em milissegundos. O plugin pode ser ativado diretamente no painel de controlo do Stackhero. Após ativar o plugin, crie uma exchange atrasada, seja através do painel de administração do RabbitMQ ou diretamente no seu código.

Para mais detalhes, consulte o repositório oficial: https://github.com/rabbitmq/rabbitmq-delayed-message-exchange.

Se desativar o plugin, quaisquer mensagens atrasadas que ainda não tenham sido entregues serão perdidas.

Criar uma exchange atrasada através do painel de administração do RabbitMQ

Após ativar o plugin no painel de controlo do Stackhero, navegue até ao seu painel de administração do RabbitMQ e crie uma exchange do tipo "x-delayed-message". Depois adicione um argumento com a chave x-delayed-type e o valor "direct". Esta configuração é ilustrada na captura de ecrã abaixo.

Criação de Exchange

Se encontrar o erro "Invalid argument, 'x-delayed-type' must be an existing exchange type", certifique-se de que definiu corretamente o argumento x-delayed-type.

Lidar com o erro `CLIENT ALERT: Fatal - Handshake Failure` com Elixir

Ao usar Elixir para se conectar ao RabbitMQ, pode encontrar o erro

CLIENT ALERT: Fatal - Handshake Failure

Este problema está relacionado a um bug com o suporte a TLS 1.3 na biblioteca AMQP para Elixir. Uma solução prática é forçar o uso de TLS 1.2. Pode conseguir isso incluindo a seguinte opção ao abrir a conexão:

AMQP.Connection.open("amqps://admin:<PASSWORD>@<XXXXXX>.stackhero-network.com:<AMQP_PORT_TLS>", :undefined, ssl_options: [ versions: [ :"tlsv1.2" ] ])

Lidar com o erro `Error: Socket closed abruptly during opening handshake` com Node.js

O erro Error: Socket closed abruptly during opening handshake pode ocorrer ao usar uma versão da biblioteca amqplib do Node.js anterior à 0.10.7 ao conectar ao RabbitMQ 4.1.0 ou posterior. Este problema está relacionado a uma alteração na configuração frame_max introduzida no RabbitMQ 4.1.0.

Para resolver o erro, atualize a sua biblioteca amqplib para a versão 0.10.7 ou posterior.