使用rabbitmq接受云计算监控告警信息案例

已于 2022-06-28 11:07:16 修改
阅读量512 收藏 2
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq springboot
于 2021-09-06 10:43:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45243783/article/details/120127531
版权

在日常的工作当中，服务器上面跑了非常多的东西，使用开源的监控组件去监控服务器上面的信息，发现服务器上面一些负载情况超标了就发送对应的告警信息，下面的案例是模仿服务器可能在一个时间段内发生多次告警信息，使用alertmanager将这一系列的告警信息路由给java后端接口来进行处理，使用rabbitmq缓冲告警消息，从而提高程序的性能

  1. 在pom.xml中导入依赖：
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.7.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.编写配置文件

server:
  port: 7003
spring:
  application:
    name: rabbitmq
  rabbitmq:
    host: 192.168.31.100
    port: 5672
    username: guest
    password: guest
    template:
      retry:  # 失败重试
        enabled: true  # 开启失败重试
        initial-interval: 10000ms   # 第一次重试的间隔时长
        max-interval: 300000ms    # 最长重试间隔，超过这个间隔将不再重试
        multiplier: 2   # 下次重试间隔的倍数，此处是2即下次重试间隔是上次的2倍
      exchange: topic.exchange   # 缺省的交换机名称，此处配置后，发送消息如果不指定交换机就会使用这个
    publisher-confirms: true   # 生产者确认机制，确保消息会正确发送，如果发送失败会有错误回执，从而触发重试
    publisher-returns: true # 可以确保消息在未被队列接收时返回

# 如果consumer只是接收消息而不发送，就不用配置template相关内容

3.编写Rabbitmq配置类

@Configuration
public class RabbitMQConfiguration {

    public static final String EXCHANGE_NAME_DIRECT="direct.exchange";//topics类型交换机
    public static final String DIRECT_EXCHANGE_WITH_QUEUE="direct_exchange_with_queue";

    /**
     * 配置RabbitMq 消息服务
     */
    @Bean("connectionFactory")//默认和方法名一致
    public ConnectionFactory rabbitConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();

        String rabbitmqHost = "192.168.31.100";
        String rabbitmqPort = "5672";
        String rabbitmqUsername = "guest";
        String rabbitmqPassword = "guest";
        String rabbitmqVirtualHost = "/mye";

        connectionFactory.setHost(rabbitmqHost);
        connectionFactory.setPort(Integer.parseInt(rabbitmqPort));
        connectionFactory.setUsername(rabbitmqUsername);
        connectionFactory.setPassword(rabbitmqPassword);
        connectionFactory.setVirtualHost(rabbitmqVirtualHost);
        connectionFactory.setPublisherConfirms(true); // 设置后才能显示调用
        return connectionFactory;
    }

    /**
     * 消息生产者
     */
    @Bean(name = "rabbitTemplate")
    //必须是prototype类型
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public RabbitTemplate rabbitTemplate() {
        return new RabbitTemplate(rabbitConnectionFactory());
    }

    /**
     * 参数详解
     *  1、directExchange() 路由模式，也是默认的
     *  2、topicExchange() 通配符模式
     *  3、fanoutExchange() 发布订阅模式
     *  4、headersExchange() 头交换机(路由模式键只有是字符串,而头交换机可以是整型和哈希值)
     *  5、durable(true) 持久化，mq重启后交换机还在
     * @return 交换机
     */
    //声明交换机
    @Bean(EXCHANGE_NAME_DIRECT)
    public Exchange exchange() {
        return ExchangeBuilder.directExchange(EXCHANGE_NAME_DIRECT).durable(true).build();
    }

    /**
     * 参数详解
     *  public Queue(String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
     *  1、name: 队列的名称
     *  2、durable: 是否持久化，如果持久化，mq重启后队列还在
     *  3、exclusive: 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建，默认false
     *  4、autoDelete：是否自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）默认false
     *  5、arguments：参数，可以设置一个队列的扩展参数，比如：可设置存活时间
     *
     * @return
     * @throws UnknownHostException
     */
    //声明队列
    @Bean("queue")
    public Queue queue() throws UnknownHostException {
        获取本机(或者服务器ip地址)
        InetAddress inetAddress = InetAddress.getLocalHost();
        return new Queue(inetAddress.getHostName(),true, false, true);
    }

    //队列绑定交换机
    @Bean
    public Binding binding(@Qualifier("queue") Queue queue,@Qualifier(EXCHANGE_NAME_DIRECT) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DIRECT_EXCHANGE_WITH_QUEUE).noargs();
    }

    @Bean("customContainerFactory")
    public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer,
                                                                 @Autowired ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConcurrentConsumers(1);  //设置线程数
        factory.setMaxConcurrentConsumers(1); //最大线程数
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);//开启手动确认消息
        configurer.configure(factory, connectionFactory);
        return factory;
    }
}

一般在实际的生产环境中，要考虑非常多的情况，比如一些网络的抖动，服务器可能宕机了等等一系列不可抗拒的因素都有可能影响消息的投递，因此会单独建立一张表来记载消息的一些情况，消息表字段如下：

在这里插入图片描述

对应实体类

 @Data
public class MsgLog implements Serializable {
    private String id;
    private String msg;
    private String exchange;
    private String routingKey;
    private Integer status;
    private Integer tryCount;
    private Long nextTryTime;
    private Long createTime;
    private Long updateTime;
    private String alertId;

消息发送确认

发送的消息怎么样才算失败或成功？如何确认？

  • 当消息无法路由到队列时，确认消息路由失败。消息成功路由时，当需要发送的队列都发送成功后，进行确认消息，对于持久化队列意味着写入磁盘，对于镜像队列意味着所有镜像接收成功

ConfirmCallback

  • 通过实现 ConfirmCallback 接口，消息发送到 Broker 后触发回调，确认消息是否到达 Broker 服务器，也就是只确认是否正确到达 Exchange 中
@Component
public class ConfirmCallbackService implements RabbitTemplate.ConfirmCallback {

    private static final Logger logger = LoggerFactory.getLogger(ConfirmCallbackService.class);

    @Autowired
    private MsgLogBiz msgLogBiz;


    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {

        if (!ack) {
            logger.error("消息发送异常!");
        } else {

            String msgId = correlationData.getId();
            msgLogBiz.updateStatus(msgId, MsgLogStatusEnum.DELIVER_SUCCESS.getKey(),System.currentTimeMillis());
            logger.info("发送者已经收到确认，correlationData={} ,ack={}, cause={}", correlationData.getId(), ack, cause);


        }
    }
}

ReturnCallback

  • 通过实现 ReturnCallback 接口，启动消息失败返回，比如路由不到队列时触发回调
@Component
public class ReturnCallbackService implements RabbitTemplate.ReturnCallback {

    private static final Logger logger = LoggerFactory.getLogger(ConfirmCallbackService.class);

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        logger.error("returnedMessage ===> replyCode={} ,replyText={} ,exchange={} ,routingKey={}", replyCode, replyText, exchange, routingKey);
        System.out.println("消息主体 message : "+message);
        System.out.println("消息主体 message : "+replyCode);
        System.out.println("描述："+replyText);
        System.out.println("消息使用的交换器 exchange : "+exchange);
        System.out.println("消息使用的路由键 routing : "+routingKey);

    }
}

编一个枚举类用于记录消息的投递状态

public enum MsgLogStatusEnum {

    /**
     * 投递中
     **/
    DELIVERING(0, "delivering"),
    /**
     * 投递成功
     **/
    DELIVER_SUCCESS(1, "deliver_success"),
    /**
     * 投递失败
     **/
    DELIVER_FAIL(2, "deliver_fail"),

    /**
     * 消费成功
     **/
    CONSUMED_SUCCESS(3, "consumed_success");


    private final int key;
    private final String value;

    public int getKey() {
        return key;
    }

    public String getValue() {
        return value;
    }

    MsgLogStatusEnum(int key, String value) {
        this.key = key;
        this.value = value;
    }

    /**
     * 判断数值是否属于枚举类的值
     *
     * @param key
     * @return
     */
    public static boolean isInclude(int key) {
        boolean include = false;
        for (MsgLogStatusEnum e : MsgLogStatusEnum.values()) {
            if (e.key == key) {
                include = true;
                break;
            }
        }
        return include;
    }

    public static String getName(int key) {
        String value = "";
        for (MsgLogStatusEnum e : MsgLogStatusEnum.values()) {
            if (e.key == key) {
                value = e.getValue();
                break;
            }
        }
        return value;
    }


    }

接下来是生产者代码投递消息的代码

@RestController
@RequestMapping("/api/webhook")
public class WebHookController extends ApiController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private ConfirmCallbackService confirmCallbackService;

    @Autowired
    private ReturnCallbackService returnCallbackService;

    @Autowired
    private MsgLogBiz msgLogBiz;

    private static final Logger logger = LoggerFactory.getLogger(WebHookController.class);

    @RequestMapping(value = "/dcim1", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public void getAlarm2(@RequestBody String alarmJson) {
        logger.info("收到原始告警信息: {}", alarmJson);
        List<Alert> alertList;
        try {
            JSONObject jsonObject = JSONUtil.parseObj(alarmJson);
            JSONArray alerts = jsonObject.getJSONArray("alerts");
            alertList = alerts.toList(Alert.class);
            logger.info("alertList: {}", alertList);
        } catch (Exception e) {
            logger.error("收到告警信息Json格式化出现问题: " + alarmJson);
            return;
        }
        if (CollectionUtil.isEmpty(alertList)) {
            return;
        }
        this.sendAlert(alertList);

    }

    private void sendAlert(List<Alert> alertList) {

        String msgId = "alert-" + UUIDUtil.generateUUID();
        MsgLog msgLog = new MsgLog(msgId, JSONUtil.toJsonStr(alertList), "alertDirectExchange", "alert", MsgLogStatusEnum.DELIVERING.getKey(), 0, System.currentTimeMillis() + 2 * 60 * 1000L, System.currentTimeMillis(), 0L);

        msgLogBiz.insert(msgLog);

        /**
         * 当mandatory标志位设置为true时
         * 如果exchange根据自身类型和消息routingKey无法找到一个合适的queue存储消息
         * 那么broker会调用basic.return方法将消息返还给生产者
         * 当mandatory设置为false时，出现上述情况broker会直接将消息丢弃
         */
        rabbitTemplate.setMandatory(true);
        //confirmCallback接口用于实现消息发送到rabbitmq交换机后接受ack回调
        rabbitTemplate.setConfirmCallback(confirmCallbackService);
        //returnCallback接口用于实现消息发送到rabbitmq交换器。但无相应队列与交换机绑定式的回调
        rabbitTemplate.setReturnCallback(returnCallbackService);
        rabbitTemplate.convertAndSend("alertDirectExchange", "alert", JSONUtil.toJsonStr(msgLog), message -> {
             // 消息的持久化，生产者到broker消息不丢失（消息持久化到磁盘）
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            return message;
        }, new CorrelationData(msgId));

    }
}

在消息投递失败时需要有一个补偿机制，这里编写一个定时任务，在生产者消息投递失败时继续投递，直到达到最大投递次数，如果还是失败那就不再投递

@Component
public class ResendMsg {

    private static final Logger logger = LoggerFactory.getLogger(ResendMsg.class);

    @Autowired
    private MsgLogBiz msgLogBiz;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 最大投递次数
    private static final int MAX_TRY_COUNT = 3;

    /**
     * 每30s拉取投递失败的消息, 重新投递
     */
    @Scheduled(cron = "0/30 * * * * ?")
    public void resend() {
        logger.info("开始执行定时任务(重新投递消息)");
        long currentTimeMillis = System.currentTimeMillis();
        List<MsgLog> msgLogs = msgLogBiz.selectTimeoutMsg(currentTimeMillis);
        if (CollectionUtil.isEmpty(msgLogs)) {
            logger.info("开始执行定时任务(重新投递消息),数据为空终止执行.");
            return;
        }
        msgLogs.forEach(msgLog -> {
            String msgId = msgLog.getId();
            if (msgLog.getTryCount() >= MAX_TRY_COUNT) {
                msgLogBiz.updateStatus(msgId, MsgLogStatusEnum.DELIVER_FAIL.getKey(), currentTimeMillis);
                logger.info("超过最大重试次数, 消息投递失败, msgId: {}", msgId);
            } else {
                int count = msgLog.getTryCount() + 1;
                msgLog.setTryCount(count);
                Long nextTryTime = msgLog.getNextTryTime();
                if (nextTryTime == 0) {
                    nextTryTime = currentTimeMillis;
                }
                msgLog.setNextTryTime(nextTryTime + count * 60 * 1000L);
                msgLog.setUpdateTime(currentTimeMillis);
                msgLogBiz.updateTryCount(msgLog);

                CorrelationData correlationData = new CorrelationData(msgId);
                rabbitTemplate.convertAndSend(msgLog.getExchange(), msgLog.getRoutingKey(), JSONUtil.toJsonStr(msgLog), correlationData);// 重新投递

                logger.info("第 " + (msgLog.getTryCount()) + " 次重新投递消息: " + msgId);
            }
        });

        logger.info("定时任务执行结束(重新投递消息)");
    }

}

其中数据库持久层操作接口代码如下:

public interface MsgLogBiz {
      // 插入一条数据
    int insert(MsgLog msgLog);
      // 根据id更新投递消息的状态
    int updateStatus(String msgId,int status,long updateTime);
      // 根据id查询消息详情
    MsgLog selectByMsgId(String msgId);
     // 根据当前时间查询所有正在投递中的
    List<MsgLog> selectTimeoutMsg(long currentTime);
     // 更新消息的重试次数
    int updateTryCount(MsgLog msgLog);

}

对应mapper层代码

@Repository
@Mapper
public interface MsgLogMapper {

    /**
     * 消息表 表名称
     **/
    String MSG_LOG_TABLE_NAME = "msg_log";


    /**
     * 插入一条数据
     **/
    @Insert("INSERT INTO " + MSG_LOG_TABLE_NAME + " (id, msg,exchange,routingKey,status,tryCount,nextTryTime,createTime,updateTime,alertId) VALUES (" +
            "#{id}, #{msg},#{exchange},#{routingKey},#{status}, #{tryCount},#{nextTryTime},#{createTime},#{updateTime},#{alertId})")
    int insert(MsgLog msgLog);


    @Update("update " + MSG_LOG_TABLE_NAME + " set status=#{status}," +
            "updateTime=#{updateTime} where id=#{id}")
    int updateStatus(@Param("id") String id, @Param("status") int status, @Param("updateTime") long updateTime);

    @Select("SELECT * from " + MSG_LOG_TABLE_NAME + " where status  = 0 AND  nextTryTime <= #{currentTime} ")
    List<MsgLog> selectTimeoutMsg(@Param("currentTime")long currentTime);

    @Update("update " + MSG_LOG_TABLE_NAME + " set tryCount=#{tryCount}, nextTryTime=#{nextTryTime}, " +
            "updateTime=#{updateTime} where id=#{id}")
    int updateTryCount(MsgLog msgLog);

    @Select("SELECT * from " + MSG_LOG_TABLE_NAME + " where id  =#{id}")
    MsgLog selectByMsgId(@Param("id") String id);

}

消费者端代码

@Component
public class WebHookMqAlertListener {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @Autowired
    private ConfirmCallbackService confirmCallbackService;

    @Autowired
    private ReturnCallbackService returnCallbackService;

    @Autowired
    private MsgLogBiz msgLogBiz;

    private static final Logger logger = LoggerFactory.getLogger(WebHookMqAlertListener.class);

    @RabbitListener(containerFactory = "customContainerFactory", bindings = @QueueBinding(
            value = @Queue("alertDirectQueue"),
            exchange = @Exchange(value = "alertDirectExchange", type = ExchangeTypes.DIRECT),
            key = "alert"

    ))
    public void process(@Payload String msg, Channel channel, Message message) {
        logger.info("收到告警消息：" + msg);
        MsgLog msgLog = JSONUtil.toBean(msg, MsgLog.class);
        MsgLog msgLogOld = msgLogBiz.selectByMsgId(msgLog.getId());
        if (null == msgLogOld || msgLogOld.getStatus().equals(MsgLogStatusEnum.CONSUMED_SUCCESS.getKey())) {
            logger.info("重复消费, msgId: {}", msgLog.getId());
            msgAck(channel, message, msgLog, false);
            return;
        }
        
        System.out.println(JSONUtil.toList(msgLog.getMsg(), Alert.class));
        System.out.println(msgLog.getId());
        msgAck(channel, message, msgLog, false);
}

	private void msgAck(Channel channel, Message message, MsgLog msgLog, boolean isRepetition) {


        try {
            if (!isRepetition) {
                msgLogBiz.updateStatus(msgLog.getId(), MsgLogStatusEnum.CONSUMED_SUCCESS.getKey(), System.currentTimeMillis());
            }
            //deliveryTag：该消息的index
            //false:是否批处理
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            logger.info("告警消息手动确认：" + message.getMessageProperties().getDeliveryTag());
        } catch (Exception e) {
			//获取消息中是否再次投递，true:再次投递
            if (message.getMessageProperties().getRedelivered()) {

                logger.error("告警消息已重复处理失败,拒绝再次接收...");

                try {
                //deliveryTag：该消息的index
                //消息发送成功并且在broker落地，deliveryTag是唯一标志符，在channek上发布的消息的deliveryTag都会比之前加1
                //requeue：被拒绝后是否重新加入队列
                //channel.basicReject和channel.basicNack的区别是basicNack可以拒绝多条消息，而basicReject一次只能拒绝一条消息
                channel.basicReject(message.getMessageProperties().getDeliveryTag(), false); // 拒绝消息
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            } else {

                logger.error("告警消息即将再次返回队列处理...");

                try {
                //deliveryTag：该消息的index
                //multiple:是否批量true:将一次性拒绝所有小于deliveryTag的消息
                //requeue：被拒绝后是否重新加入队列
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

告警信息内容如下

{
    "alerts": [
        {
            "annotations": {
                "description": "温度指标告警告警,当前值是: 28.3!",
                "summary": "温度指标告警告警"
            },
            "endsAt": "0001-01-01T00:00:00Z",
            "fingerprint": "e467f0ec6d95a4b4",
            "generatorURL": "http://d8a0df8cb5a1:9090/graph?g0.expr=temperature_guage%7BcomponentInstanceId%3D%2233%22%2CcomponentSignalId%3D%221%22%7D+%3C+30&g0.tab=1",
            "labels": {
                "alertname": "温度指标告警闪断震荡测试",
                "componentId": "6",
                "componentInstanceId": "33",
                "componentSignalId": "1",
                "description": "获取温度信息",
                "dynamicId": "1",
                "hostGroupId": "1",
                "instance": "192.168.10.125:8112",
                "job": "test-dcim",
                "nameChs": "温度指标",
                "oid": "1.3.6.1.4.1.123456.1.1.1.1.0",
                "severity": "minor",
                "signalCollectId": "1",
                "snmpAddress": "udp:192.168.10.125/161",
                "threshold": "27",
                "thresholdInfo": "温度指标告警 < 30℃,当前值= 28.3℃"
            },
            "startsAt": "2021-08-17T08:06:38.885Z",
            "status": "firing"
        }
    ]
}
我哪会这个啊
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mq-monitor:rabbitmq监控程序
05-13
RabbitMQ监控平台 功能 提供web界面订阅队列，后台线程定时轮询队列堆积数量，通过邮件的方式告警。 环境依赖 python2 mongo flask 使用说明 配置conf/env.ini [global] ; 全局配置，对所有队列统一指定消息堆积阀值和接警人 msgTotalMax=10000000 mailList=liyanhong@baidu.com ; 忽略某些队列 ignoreQueueList=abc,cde ; 后台线程监控周期，以秒为单位 cycle=120 [mq] ; mq地址、用户名、密码 addr=58.215.141.110:15672 username=test password=test [mongo] ; 监控数据采用mongo存储 host=localhost port=27017 [mail] ; 邮件配置 fromAddr=notonly@1
rabbitMQ报警推送简单方法
ty0903csdn的博客
12-16 1289
application.yml配置 spring: rabbitMQ: host:125.25.23 port:5672 userName:dfwfwd password:635623 maven配置 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&...
docker启动rabbitmq_领导：如何对生产环境的rabbitMQ实时监控并告警？
weixin_39692557的博客
11-29 557
概述Prometheus 服务本地已经启动了，接下来，需要安装并运行 Exporter，它的主要作用是持续输出监控的组件信息并格式化，同时提供 Http 接口供 Prometheus 服务来抓取。Exporter 也是通过 GO 语言编写的，Prometheus GitHub 已经为我们提供了很多实用的 Exporter，直接拿来使用即可。下面介绍下怎么用prometheus去监控rabbitMQ...
【SpringBoot实战系列】RabbitMQ实现消息发送并实现邮箱发送异常监控报警实战
chandfy的博客
07-30 1984
RabbitMQ 邮箱发送 邮件发送
RabbitMQ指南(4)-管理监控
jerome_jun的专栏
11-01 894
1、管理插件 通过浏览器UI、命令行管理工具以及rabbitmqadmin，RabbitMQ的管理插件提供了基于HTTP API的方式来管理和监控服务。主要功能包括： 定义、罗列和删除Exchange、队列、绑定（bingdings）、用户、虚拟主机（virtual hosts）和权限。监控队列长度、channel中和全局的消息速率、每个连接的数据速率、等。发送和接收消息。监控Erla
tp6使用rabbitmq
09-22
【标题】：“TP6使用RabbitMQ” 在PHP框架ThinkPHP6（简称TP6）中集成RabbitMQ是一项常见的任务，用于实现异步处理、消息队列和分布式系统的通信。RabbitMQ是一个开源的消息代理和队列服务器，它遵循AMQP（Advanced...
.Net使用RabbitMQ即时发消息Demo
10-18
标题中的".Net使用RabbitMQ即时发消息Demo"是指在.NET开发环境中，使用RabbitMQ这一消息中间件来实现实时发送消息的功能。RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议的一个开源消息系统，它由...
rabbitMQ代码案例
07-04
【标题】：“rabbitMQ代码案例”提供了初学者进入消息队列世界的实用教程，特别是对于RabbitMQ这个流行的开源消息代理的使用。 【描述】：这个资料包是为那些正在探索如何在实际项目中应用RabbitMQ的人设计的。它...
RabbitMQ 代码案例
08-15
这个“RabbitMQ 代码案例”是专为初学者设计的，旨在通过实际代码来帮助理解RabbitMQ的基本概念和用法。 首先，我们需要了解RabbitMQ的核心概念。在RabbitMQ中，生产者是发送消息的应用，消费者是接收消息的应用。...
一文读懂PHP使用RabbitMQ
12-13
【RabbitMQ 简介】 RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）的开源消息代理和队列服务器，它采用Erlang编程语言开发...正确理解和使用RabbitMQ及其核心概念，对于构建健壮的分布式系统至关重要。
Epiphany：Epiphany是Kubernetes和Docker的完全工业化自动化，以及其他内置服务组件，例如：-Kafka或RabbitMQ用于高速消息传递事件-Prometheus和Alertmanager用于通过Graphana进行可视化监控-Elasticsearch和Kibana用于集中式日志记录-HAProxy用于负载平衡-Postgress for存储-用于身份验证的KeyCloak
02-01
主显节平台 总览 主显节的核心是Kubernetes和Docker的完全自动化以及其他内置服务/组件，例如： Kafka或RabbitMQ用于高速消息传递/事件 Prometheus和Alertmanager用于使用Graphana进行监视以进行可视化 Elasticsearch和Kibana用于集中式日志记录（OpenDistro） HAProxy用于负载平衡 Postgres和Elasticsearch用于数据存储 用于身份验证的KeyCloak 保管箱（MVP），用于保护机密和其他敏感数据 Helm担任Kubernetes的程序包经理 提供以下目标平台：AWS，Azure和本地安装。 主显节只能在一个节点（笔记本电脑，台式机，服务器）上运行，但真正的价值来自于运行3个或更多节点以实现规模和HA。 一切都是数据驱动的，因此只需更改清单数据并运行自动化即可修改环境。 可以根据初始清单中的数据添加Kubernetes主机（主节点，节点）和组件VM。 更多信息。 请注意，当前Epiphany仅支持创建新的主节点和节点并将其添加到Kubernetes集群。 它不支持降级。 要从K
ansible-role-rabbitmq：Ansible角色-安装和配置RabbitMQ
02-06
移至 兔子MQ RabbitMQ剧本，使您可以启动简单的服务器或将它们集群在一起。 当前仅支持EC2上的群集。 如果要将其集成到另一个存储库中，请确保Rabbitmq进入角色文件夹。 配置仅适用于RabbitMQ 3.7和更高版本，因为此角色已经使用了较新的配置格式，请参见这应该不是问题，因为无论如何该角色都会安装最新的RabbitMQ版本已经是3.7.4（2018年4月）。 另请注意，必须在启动新实例时将其运行才能将其挂接到集群中！ 因此，在cluster.yml中安装了ansible和boto。 注意：这是的分支。 要求 Ubuntu / Debian基本映像。 依存关系 此角色不
linux12企业实战 -- 28rabbitmq队列监控报告
明日之星
12-27 793
文章目录一、rabbitmq队列监控报告1、中间件: share_cpos_backroom_rabbitmq_172.18.66.2112、CMDB信息3、告警分析`queue.cash.auto queue message > 100``queue.Dwbi queue message > 100`二、中间件: message_kfcd_rabbitmq_172.18.36.1371、CMDB信息`railway.kfc.ios.oprt.store.msgCenter queque mes
RabbitMQ监控方法以及核心指标
最新发布
李姓门徒
02-19 3424
探讨rabbitmq的监控数据采集方式以及需要关注的核心指标，便于日常生产进行监控和巡检。
使用RabbitMQ进行消息代理
culi3182的博客
08-11 770
RabbitMQ is open-source message brokering software written in Erlang. The MQ in its name refers to a standard known as Advanced Message Queuing Protocol. For our purposes, and most others, it acts as...
RabbitMQ--重试机制
IT利刃出鞘的博客
12-11 9360
本文介绍RabbitMQ的重试机制。
rabbitmq消息发送的可靠性：结合mysql来保证消息投递的可靠性
print的博客
01-02 704
4. 设置一个定时任务：10秒执行一次. 根据（status）状态0并且重试时间（try_time）< sysdate()当前时间查询出List rabbitmqSendLogs消息的数量rabbitmqSendLogs。5.遍历所有消息rabbitmqSendLogs.forEach。定时任务，每隔10秒冲数据库查询，然后再从新投递到mq。数据表rabbitmq_send_log。接收rabbitmq消息的类。
rabbitmq消费消息：结合redis保证消息不被重复消费
print的博客
01-02 1080
如果对判断的稳定性和鲁棒性要求高，使用数据库存储消息实体，同时将 msg_id 作为数据库表的唯一键，插入重复记录一定会抛出异常，避免数据库因为并发问题产生脏数据，保证了消息消费的不可重复性。通用解决方案是在消息实体中添加全局唯一的id，例如 msg_id（消息ID），在代码中保证消息的幂等性，如果不存在已有消息，那么消费之后，将 msg_id 对应的消息实体或者序列化对象写入缓存或者数据库；如果存在已有消息，说明这条消息已被消费过，丢弃消息并且打一条告警日志。
rabbitMQ介绍及配置
qq_45042013的博客
10-31 369
常见MQ产品 ActiveMQ：基于JMS， Apache RabbitMQ：基于AMQP协议，erlang语言开发（c语言开发的），稳定性好 RocketMQ：基于JMS，阿里巴巴产品，目前交由Apache基金会 Kafka：分布式消息系统，高吞吐量 MQ是消息通信的模型，并发具体实现。现在实现MQ的有两种主流方式：AMQP、JMS。 两者间的区别和联系： JMS 定义了统一的接口，来对消...
RabbitMQ：云计算基石，实战与优化指南
RabbitMQ在云计算环境中占据着重要地位，尤其在大规模分布式系统中作为解耦和异步通信的核心组件。 在学习资料中，作者余锋以深入浅出的方式介绍了RabbitMQ的主要特点： 1. **应用领域广泛**：RabbitMQ适用于云计算...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值