tencent cloud

go get "github.com/rabbitmq/amqp091-go"

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

// Required parameters
const (
    host     = "amqp-xx.rabbitmq.x.tencenttdmq.com" // Service access address
    username = "roleName" // Role name in the console
    password = "eyJrZX..." // Role key
    vhost    = "amqp-xx|Vhost" // Full name of the vhost to be used
)
// Create a connection
conn, err := amqp.Dial("amqp://" + username + ":" + password + "@" + host + ":5672/" + vhost)
failOnError(err, "Failed to connect to RabbitMQ")
defer func(conn *amqp.Connection) {
    err := conn.Close()
    if err != nil {
    }
}(conn)

// Establish a channel
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer func(ch *amqp.Channel) {
    err := ch.Close()
    if err != nil {
    }
}(ch)

// Declare the exchange (the name and type must be the same as those of the existing exchange)
    err = ch.ExchangeDeclare(
        "logs-exchange",   // Exchange name
        "fanout", // Exchange type
        true,     // durable
        false,    // auto-deleted
        false,    // internal
        false,    // no-wait
        nil,      // arguments
    )
    failOnError(err, "Failed to declare a exchange")

// Message content
body := "this is new message."
// Publish messages to the exchange   
err = ch.Publish(
    "logs-exchange",         // exchange
    "", // Routing key (set whether the routing key is required based on the used exchange type). If exchange is not selected, this parameter will be the message queue name
    false,      // mandatory
    false,      // immediate
    amqp.Publishing{
        ContentType: "text/plain",
        Body:        []byte(body),
    })
failOnError(err, "Failed to publish a message")

// Publish messages to the specified message queue
err = ch.Publish(
    "",         // exchange
    queue.Name, // routing key
    false,      // mandatory
    false,      // immediate
    amqp.Publishing{
        ContentType: "text/plain",
        Body:        []byte(body),
    })
failOnError(err, "Failed to publish a message")

// Create a consumer and consume messages in the specified message queue
msgs, err := ch.Consume(
    "message-queue", // message-queue
    "",           // consumer
    false,        // Set to manual acknowledgment as needed
    false,        // exclusive
    false,        // no-local
    false,        // no-wait
    nil,          // args
)
failOnError(err, "Failed to register a consumer")

// Get messages in the message queue
forever := make(chan bool)
go func() {
    for d := range msgs {
        log.Printf("Received a message: %s", d.Body)
        t := time.Duration(1)
        time.Sleep(t * time.Second)
        // Manually return the acknowledgment
        d.Ack(false)
    }
}()
log.Printf(" [Consumer] Waiting for messages.")
<-forever

// You need to specify the exchange and routing key in the message queue
err = ch.QueueBind(
    q.Name, // queue name
    "routing_key",     // routing key
    "topic_demo", // exchange
    false,
    nil,
)
failOnError(err, "Failed to bind a queue")