1、 消息如何保障100%的投递成功?
什么是生产端的可靠性投递?
-
保障消息的成功发出
-
保障MQ节点的成功接收
-
发送端收到MQ节点(Broker)确认应答
-
完善的消息进行补偿机制
BAT/TMD互联网大厂的解决方案
消息信息落库,对消息状态进行打标
MQ最重要的两个特定:生产端保证可靠性投递;消费端幂等性消费
3、在海量订单产生的业务高峰期,如何避免消息的重复性消费问题?
解决:消费端实现幂等性,就意味着,我们的消息永远不会消费多次,即使我们多收到了多条一样的消息。
4、Confirm确认消息、Return返回消息
5、消息的Ack与重回队列
6、消息的限流
7、TTL消息
8、死信队列
confirmlistener监听代码
发送者客户端代码:
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
public class Sender4ConfirmListener {
public static void main(String[] args) throws Exception {
//1 创建ConnectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
//2 创建Connection
Connection connection = connectionFactory.newConnection();
//3 创建Channel
Channel channel = connection.createChannel();
//4 声明
String exchangeName = "test_confirmlistener_exchange";
String routingKey1 = "confirm.save";
//5 发送
String msg = "Hello World RabbitMQ 4 Confirm Listener Message ...";
channel.confirmSelect();
channel.addConfirmListener(new ConfirmListener() {
@Override
public void handleNack(long deliveryTag, boolean multiple) throws IOException {
System.err.println("------- error ---------");
}
@Override
public void handleAck(long deliveryTag, boolean multiple) throws IOException {
System.err.println("------- ok ---------");
}
});
channel.basicPublish(exchangeName, routingKey1 , null , msg.getBytes());
}
}
接受者客户端代码:
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class Receiver4ConfirmListener {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
//4 声明
String exchangeName = "test_confirmlistener_exchange";
String exchangeType = "topic";
String queueName = "test_confirmlistener_queue";
//String routingKey = "user.*";
String routingKey = "confirm.#";
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
channel.queueDeclare(queueName, false, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
System.out.println("receive message:" + new String(body) + ", RoutingKey: " + envelope.getRoutingKey());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
channel.basicConsume(queueName, consumer);
//等待回调函数执行完毕之后,关闭资源。
TimeUnit.SECONDS.sleep(50);
channel.close();
connection.close();
}
}
returnlistener监听代码
发送者客户端代码:
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ReturnListener;
import java.io.IOException;
public class Sender4ReturnListener {
public static void main(String[] args) throws Exception {
//1 创建ConnectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
//2 创建Connection
Connection connection = connectionFactory.newConnection();
//3 创建Channel
Channel channel = connection.createChannel();
//4 声明
String exchangeName = "test_returnlistener_exchange";
String routingKey1 = "abcd.save";
String routingKey2 = "return.save";
String routingKey3 = "return.delete.abc";
//5 监听
channel.addReturnListener(new ReturnListener() {
public void handleReturn(int replyCode,
String replyText,
String exchange,
String routingKey,
BasicProperties properties,
byte[] body)
throws IOException {
System.out.println("**************handleReturn**********");
System.out.println("replyCode: " + replyCode);
System.out.println("replyText: " + replyText);
System.out.println("exchange: " + exchange);
System.out.println("routingKey: " + routingKey);
System.out.println("body: " + new String(body));
}
});
//6 发送
String msg = "Hello World RabbitMQ 4 Return Listener Message ...";
boolean mandatory = true;
channel.basicPublish(exchangeName, routingKey1 , mandatory, null , msg.getBytes());
// channel.basicPublish(exchangeName, routingKey2 , null , msg.getBytes());
/// channel.basicPublish(exchangeName, routingKey3 , null , msg.getBytes());
}
}
接收者客户端代码:
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class Receiver4ReturnListener {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
//4 声明
String exchangeName = "test_returnlistener_exchange";
String exchangeType = "topic";
String queueName = "test_returnlistener_queue";
//String routingKey = "user.*";
String routingKey = "return.#";
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
channel.queueDeclare(queueName, false, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
System.out.println("receive message:" + new String(body) + ", RoutingKey: " + envelope.getRoutingKey());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
channel.basicConsume(queueName, true, consumer);
//等待回调函数执行完毕之后,关闭资源。
TimeUnit.SECONDS.sleep(50);
channel.close();
connection.close();
}
}
限流代码演示:
接收者客户端代码:
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class Receiver {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
String queueName = "test001";
// durable 是否持久化消息
channel.queueDeclare(queueName, true, false, false, null);
channel.basicQos(0, 1, false);
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
System.out.println("receive message:" + new String(body) + ", RoutingKey: " + envelope.getRoutingKey());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
// 参数:队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, false, consumer);
//等待回调函数执行完毕之后,关闭资源。
TimeUnit.SECONDS.sleep(5);
channel.close();
connection.close();
}
}
发送者客户端代码:
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.util.HashMap;
import java.util.Map;
public class Sender {
public static void main(String[] args) throws Exception {
//1 创建ConnectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
//2 创建Connection
Connection connection = connectionFactory.newConnection();
//3 创建Channel
Channel channel = connection.createChannel();
//4 声明
String queueName = "test001";
//参数: queue名字,是否持久化,独占的queue(仅供此连接),不使用时是否自动删除, 其他参数
channel.queueDeclare(queueName, true, false, false, null);
Map<String, Object> headers = new HashMap<String, Object>();
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.deliveryMode(2)
.contentEncoding("UTF-8")
.headers(headers).build();
for(int i = 0; i < 5;i++) {
String msg = "Hello World RabbitMQ " + i;
channel.basicPublish("", queueName , props , msg.getBytes());
}
}
}
消费端的重回队列
是为了对没有处理成功的消息,把消息重新会投递给broker。
重回队列,会回到队列的尾部也会造成一条消息一直重复投递,死循环了在实际应用中,都会关闭重回队列,也就是设置为false
重回队列代码演示:
接收者客户端代码:
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class Receiver {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
String queueName = "test001";
//durable 是否持久化消息
channel.queueDeclare(queueName, true, false, false, null);
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
try {
System.out.println("receive message:" + new String(body) + ", RoutingKey: " + envelope.getRoutingKey());
if((Integer)properties.getHeaders().get("flag") == 0) {
//throw new RuntimeException("异常");
// 设置为false表示关闭重回队列
// channel.basicNack(envelope.getDeliveryTag(), false, false);
// 设置为true表示开启重回队列
channel.basicNack(envelope.getDeliveryTag(), false, true);
} else {
channel.basicAck(envelope.getDeliveryTag(), false);
}
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
// 参数:队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, false, consumer);
}
}
生产者客户端代码:
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.util.HashMap;
import java.util.Map;
public class Sender {
public static void main(String[] args) throws Exception {
//1 创建ConnectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
//2 创建Connection
Connection connection = connectionFactory.newConnection();
//3 创建Channel
Channel channel = connection.createChannel();
//4 声明
String queueName = "test001";
//参数: queue名字,是否持久化,独占的queue(仅供此连接),不使用时是否自动删除, 其他参数
channel.queueDeclare(queueName, true, false, false, null);
for(int i = 0; i < 5;i++) {
String msg = "Hello World RabbitMQ " + i;
Map<String, Object> headers = new HashMap<String, Object>();
headers.put("flag", i);
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.deliveryMode(2)
.contentEncoding("UTF-8")
.headers(headers).build();
channel.basicPublish("", queueName , props , msg.getBytes());
}
}
}
死信队列代码演示:
接收者客户端代码:
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class Receiver4DLXtExchange {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
connectionFactory.setAutomaticRecoveryEnabled(true);
connectionFactory.setNetworkRecoveryInterval(3000);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
//4 声明正常的 exchange queue 路由规则
String queueName = "test_dlx_queue";
String exchangeName = "test_dlx_exchange";
String exchangeType = "topic";
String routingKey = "group.*";
// 声明 exchange
channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
// 注意在这里要加一个特殊的属性arguments: x-dead-letter-exchange
Map<String, Object> arguments = new HashMap<String, Object>();
arguments.put("x-dead-letter-exchange", "dlx.exchange");
//arguments.put("x-dead-letter-routing-key", "dlx.*");
//arguments.put("x-message-ttl", 6000);
channel.queueDeclare(queueName, false, false, false, arguments);
channel.queueBind(queueName, exchangeName, routingKey);
//dlx declare:
channel.exchangeDeclare("dlx.exchange", exchangeType, true, false, false, null);
channel.queueDeclare("dlx.queue", false, false, false, null);
channel.queueBind("dlx.queue", "dlx.exchange", "#");
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException {
System.out.println("receive message:" + new String(body) + ", RoutingKey: " + envelope.getRoutingKey());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
// 参数:队列名称、是否自动ACK、Consumer
channel.basicConsume(queueName, true, consumer);
//等待回调函数执行完毕之后,关闭资源。
TimeUnit.SECONDS.sleep(5);
channel.close();
connection.close();
}
}
发送者客户端代码:
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.util.HashMap;
import java.util.Map;
public class Sender4DLXExchange {
public static void main(String[] args) throws Exception {
//1 创建ConnectionFactory
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.110.130");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("root");
connectionFactory.setPassword("1TdhblkFcdhx2a");
//2 创建Connection
Connection connection = connectionFactory.newConnection();
//3 创建Channel
Channel channel = connection.createChannel();
//4 声明
String exchangeName = "test_dlx_exchange";
String routingKey = "group.bfxy";
//5 发送
Map<String, Object> headers = new HashMap<String, Object>();
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.deliveryMode(2)
.contentEncoding("UTF-8")
// TTL
.expiration("6000")
.headers(headers).build();
String msg = "Hello World RabbitMQ 4 DLX Exchange Message ... ";
channel.basicPublish(exchangeName, routingKey , props , msg.getBytes());
}
}
TTL队列、消息
TTL: time to live的缩写,也就是生存时间。
RabbitMQ 支持消息过期时间,在消息发送时可以进行指定
RabbitMQ支持队列过期时间,从消息入队列开始计算,只要超过了队列的超时间时间配置,那么消息会自动的清除
死队列: DLX,Dead-Letter-Exchange
利用DLX,当消息在一个队列中变成死信(dead message)之后,它能被重新publish到另一个Exchange,这个Exchange就是DLX.
消息变成死信的几种情况
1、消息被拒绝 并且requeue = false
2、消息TTL过期
3、队列达到最大长度
DLX也是一个真长的Exchange,实际上是一个属性控制
当队列中有死信时,RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上,进而被路由到另一个队列.
可以监听这个队列中消息做相应的处理,这个特性可以弥补rabbitMQ3.0以前的immediate参数功能。
在正常队列上添加参数:arguments.put("x-dead-letter-exchange","dlx.exchange");
这样消息过期、requeue、队列达到最大长度时,就可以直接路由到死信队列。
rabbitmq支持事务,但是不要使用,性能太差。
RabbitMQ集群搭建
服务架构概述
架构:RabbitMQ Cluster + Queue HA + Haproxy + Keepalived
解释:3台rabbitMQ服务器构建broker集群,允许任意2台服务器故障而服务不受影响,在此基础上,通过Queue HA (queue mirror)实现队列的高可用,在本例中镜像到所有服务器节点(即1个master,2个slave);为保证客户端访问入口地址的唯一性,通过haproxy做4层代理来提供MQ服务,并通过简单的轮询方式来进行负载均衡,设置健康检查来屏蔽故障节点对客户端的影响;使用2台haproxy并且通过keepalived实现客户端访问入口的高可用机制。
服务架构设计
服务节点分配
服务器IP | hostname | 节点说明 | 端口 | 管控台地址 |
192.168.11.71 | bhz71 | rabbitmq master | 5672 | http://192.168.11.71:15672 |
192.168.11.72 | bhz72 | rabbitmq slave | 5672 | http://192.168.11.72:15672 |
192.168.11.73 | bhz73 | rabbitmq slave | 5672 | http://192.168.11.73:15672 |
192.168.11.74 | bhz74 | haproxy+keepalived | 8100 | |
192.168.11.75 | bhz75 | haproxy+keepalived | 8100 |
官方文档手册:
集群配置文档:Clustering Guide — RabbitMQ
镜像队列文档:Classic Queue Mirroring — RabbitMQ
集群操作文档:http://www.rabbitmq.com/man/rabbitmqctl.1.man.html
中文版AMQP用户手册:
Spring AMQP文档:http://www.blogjava.net/qbna350816/category/55056.html?Show=All
事务文档:http://www.blogjava.net/qbna350816/archive/2016/08/13/431567.html
2 集群搭建
2.1 集群节点安装
1、安装依赖包
PS:安装rabbitmq所需要的依赖包
yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz |
2、下载安装包
wget www.rabbitmq.com/releases/erlang/erlang-18.3-1.el7.centos.x86_64.rpm wget http://repo.iotti.biz/CentOS/7/x86_64/socat-1.7.3.2-5.el7.lux.x86_64.rpm wget www.rabbitmq.com/releases/rabbitmq-server/v3.6.5/rabbitmq-server-3.6.5-1.noarch.rpm |
3、安装服务命令
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm rpm -ivh socat-1.7.3.2-1.1.el7.x86_64.rpm rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm //卸载 rpm -qa | grep rabbitmq rpm -e --allmatches rabbitmq-server-3.6.5-1.noarch rpm -qa | grep erlang rpm -e --allmatches erlang-18.3-1.el7.centos.x86_64 rpm -qa | grep socat rpm -e --allmatches socat-1.7.3.2-5.el7.lux.x86_64 rm -rf /usr/lib/rabbitmq/ /etc/rabbitmq/ /var/lib/rabbitmq/ |
4、修改集群用户与连接心跳检测
注意修改vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app文件 修改:loopback_users 中的 <<"guest">>,只保留guest 修改:heartbeat 为10 |
5、安装管理插件
//首先启动服务 /etc/init.d/rabbitmq-server start stop status restart //查看服务有没有启动: lsof -i:5672 rabbitmq-plugins enable rabbitmq_management //可查看管理端口有没有启动: lsof -i:15672 或者 netstat -tnlp|grep 15672 |
6、服务指令
/etc/init.d/rabbitmq-server start stop status restart 验证单个节点是否安装成功:http://192.168.11.71:15672/ Ps:以上操作三个节点(71、72、73)同时进行操作 |
2.2 文件同步步骤
PS:选择71、72、73任意一个节点为Master(这里选择71为Master),也就是说我们需要把71的Cookie文件同步到72、73节点上去,进入/var/lib/rabbitmq目录下,把/var/lib/rabbitmq/.erlang.cookie文件的权限修改为777,原来是400;然后把.erlang.cookie文件copy到各个节点下;最后把所有cookie文件权限还原为400即可。
//进入目录修改权限;远程copy72、73节点 scp /var/lib/rabbitmq/.erlang.cookie 192.168.11.72:/var/lib/rabbitmq/ scp /var/lib/rabbitmq/.erlang.cookie 192.168.11.73:/var/lib/rabbitmq/ |
2.3 组成集群步骤
1、停止MQ服务
PS:我们首先停止3个节点的服务:(这里不能使用原来的命令:/etc/init.d/rabbitmq-server stop)
rabbitmqctl stop |
2、组成集群操作
PS:接下来我们就可以使用集群命令,配置71、72、73为集群模式,3个节点(71、72、73)执行启动命令,后续启动集群使用此命令即可。
rabbitmq-server -detached |
3、slave加入集群操作(重新加入集群也是如此,以最开始的主节点为加入节点)
//注意做这个步骤的时候:需要配置/etc/hosts 必须相互能够寻址到 bhz72:rabbitmqctl stop_app bhz72:rabbitmqctl join_cluster --ram rabbit@bhz71 bhz72:rabbitmqctl start_app bhz73:rabbitmqctl stop_app bhz73:rabbitmqctl join_cluster rabbit@bhz71 bhz73:rabbitmqctl start_app //在另外其他节点上操作要移除的集群节点 rabbitmqctl forget_cluster_node rabbit@bhz71 |
4、修改集群名称
PS:修改集群名称(默认为第一个node名称):
rabbitmqctl set_cluster_name rabbitmq_cluster1 |
5、查看集群状态
PS:最后在集群的任意一个节点执行命令:查看集群状态
rabbitmqctl cluster_status |
6、管控台界面
PS: 访问任意一个管控台节点:http://192.168.11.71:15672 如图所示
2.4 配置镜像队列
PS:设置镜像队列策略(在任意一个节点上执行)
rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all"}' |
PS:将所有队列设置为镜像队列,即队列会被复制到各个节点,各个节点状态一致,RabbitMQ高可用集群就已经搭建好了,我们可以重启服务,查看其队列是否在从节点同步。
2.5 消息一致性问题
在使用rabbitmq中,消息的一致性是非常重要的一个话题。下面我们来研究一下,在数据一致性方面,有哪些需要关注的。发送者发送消息出来,在数据一致性的要求下,我们通常认为必须达到以下条件
broker持久化消息
publisher知道消息已经成功持久化
首先,我们可以采用事务来解决此问题。每个消息都必须经历以上两个步骤,就算一次事务成功。
事务是同步的。因此,如果采用事务,发送性能必然很差。官方给出来的性能是:
异步的方法的效率是事务方法效率的100倍。
我们可以采用异步的方式来解决此问题。publisher发送消息后,不进行等待,而是异步监听是否成功。这种方式又分为两种模式,一种是return,另一种是confirm. 前一种是publisher发送到exchange后,异步收到消息。第二种是publisher发送消息到exchange,queue,consumer收到消息后才会收到异步收到消息。可见,第二种方式更加安全可靠。如下所示:
但是,异步也存在些局限性。如果一旦出现broker挂机或者网络不稳定,broker已经成功接收消息,但是publisher并没有收到confirm或return.这时,对于publisher来说,只能重发消息解决问题。而在这里面,我们会发生重复消息的问题。当然,如果业务类型要求数据一致性非常高,可以采用低效率的事务型解决方案:引用:Introducing Publisher Confirms | RabbitMQ - Blog
2.6 安装Ha-Proxy
1、Haproxy简介
HAProxy是一款提供高可用性、负载均衡以及基于TCP和HTTP应用的代理软件,HAProxy是完全免费的、借助HAProxy可以快速并且可靠的提供基于TCP和HTTP应用的代理解决方案。
HAProxy适用于那些负载较大的web站点,这些站点通常又需要会话保持或七层处理。
HAProxy可以支持数以万计的并发连接,并且HAProxy的运行模式使得它可以很简单安全的整合进架构中,同时可以保护web服务器不被暴露到网络上。
PS:haproxy学习博客:https://www.cnblogs.com/f-ck-need-u/p/8540805.html
2、Haproxy安装
PS:74、75节点同时安装Haproxy,下面步骤统一
//下载依赖包 //下载haproxy wget http://www.haproxy.org/download/1.6/src/haproxy-1.6.5.tar.gz //解压 tar -zxvf haproxy-1.6.5.tar.gz -C /usr/local //进入目录、进行编译、安装 cd /usr/local/haproxy-1.6.5 make TARGET=linux31 PREFIX=/usr/local/haproxy make install PREFIX=/usr/local/haproxy mkdir /etc/haproxy //赋权 groupadd -r -g 149 haproxy useradd -g haproxy -r -s /sbin/nologin -u 149 haproxy //创建haproxy配置文件 touch /etc/haproxy/haproxy.cfg |
3、Haproxy配置
PS:haproxy 配置文件haproxy.cfg详解
vim /etc/haproxy/haproxy.cfg |
#logging options global log 127.0.0.1 local0 info maxconn 5120 chroot /usr/local/haproxy uid 99 gid 99 daemon quiet nbproc 20 pidfile /var/run/haproxy.pid defaults log global #使用4层代理模式,”mode http”为7层代理模式 mode tcp #if you set mode to tcp,then you nust change tcplog into httplog option tcplog option dontlognull retries 3 option redispatch maxconn 2000 contimeout 10s ##客户端空闲超时时间为 60秒 则HA 发起重连机制 clitimeout 10s ##服务器端链接超时时间为 15秒 则HA 发起重连机制 srvtimeout 10s #front-end IP for consumers and producters listen rabbitmq_cluster bind 0.0.0.0:5672 #配置TCP模式 mode tcp #balance url_param userid #balance url_param session_id check_post 64 #balance hdr(User-Agent) #balance hdr(host) #balance hdr(Host) use_domain_only #balance rdp-cookie #balance leastconn #balance source //ip #简单的轮询 balance roundrobin #rabbitmq集群节点配置 #inter 每隔五秒对mq集群做健康检查, 2次正确证明服务器可用,2次失败证明服务器不可用,并且配置主备机制 server bhz71 192.168.11.71:5672 check inter 5000 rise 2 fall 2 server bhz72 192.168.11.72:5672 check inter 5000 rise 2 fall 2 server bhz73 192.168.11.73:5672 check inter 5000 rise 2 fall 2 #配置haproxy web监控,查看统计信息 listen stats bind 192.168.11.74:8100 mode http option httplog stats enable #设置haproxy监控地址为http://localhost:8100/rabbitmq-stats stats uri /rabbitmq-stats stats refresh 5s |
4、启动haproxy
/usr/local/haproxy/sbin/haproxy -f /etc/haproxy/haproxy.cfg //查看haproxy进程状态 |
5、访问haproxy
PS:访问如下地址可以对rmq节点进行监控:http://192.168.11.74:8100/rabbitmq-stats
6、关闭haproxy
killall haproxy ps -ef | grep haproxy netstat -tunpl | grep haproxy ps -ef |grep haproxy |awk '{print $2}'|xargs kill -9 |
2.7 安装KeepAlived
1、Keepalived简介
Keepalived,它是一个高性能的服务器高可用或热备解决方案,Keepalived主要来防止服务器单点故障的发生问题,可以通过其与Nginx、Haproxy等反向代理的负载均衡服务器配合实现web服务端的高可用。Keepalived以VRRP协议为实现基础,用VRRP协议来实现高可用性(HA).VRRP(Virtual Router Redundancy Protocol)协议是用于实现路由器冗余的协议,VRRP协议将两台或多台路由器设备虚拟成一个设备,对外提供虚拟路由器IP(一个或多个)。
2、Keepalived安装
PS:下载地址:Keepalived for Linux
//安装所需软件包 yum install -y openssl openssl-devel //下载 wget http://www.keepalived.org/software/keepalived-1.2.18.tar.gz //解压、编译、安装 tar -zxvf keepalived-1.2.18.tar.gz -C /usr/local/ cd .. cd keepalived-1.2.18/ && ./configure --prefix=/usr/local/keepalived make && make install //将keepalived安装成Linux系统服务,因为没有使用keepalived的默认安装路径(默认路径:/usr/local),安装完成之后,需要做一些修改工作 //首先创建文件夹,将keepalived配置文件进行复制: mkdir /etc/keepalived cp /usr/local/keepalived/etc/keepalived/keepalived.conf /etc/keepalived/ //然后复制keepalived脚本文件: cp /usr/local/keepalived/etc/rc.d/init.d/keepalived /etc/init.d/ cp /usr/local/keepalived/etc/sysconfig/keepalived /etc/sysconfig/ ln -s /usr/local/sbin/keepalived /usr/sbin/ //如果存在则进行删除: rm /sbin/keepalived ln -s /usr/local/keepalived/sbin/keepalived /sbin/ //可以设置开机启动:chkconfig keepalived on,到此我们安装完毕! chkconfig keepalived on |
3、Keepalived配置
PS:修改keepalived.conf配置文件
vim /etc/keepalived/keepalived.conf |
PS: 79节点(Master)配置如下
! Configuration File for keepalived global_defs { router_id bhz74 ##标识节点的字符串,通常为hostname } vrrp_script chk_haproxy { script "/etc/keepalived/haproxy_check.sh" ##执行脚本位置 interval 2 ##检测时间间隔 weight -20 ##如果条件成立则权重减20 } vrrp_instance VI_1 { state MASTER ## 主节点为MASTER,备份节点为BACKUP interface eno16777736 ## 绑定虚拟IP的网络接口(网卡),与本机IP地址所在的网络接口相同(我这里是eth0) virtual_router_id 74 ## 虚拟路由ID号(主备节点一定要相同) mcast_src_ip 192.168.11.74 ## 本机ip地址 priority 100 ##优先级配置(0-254的值) nopreempt advert_int 1 ## 组播信息发送间隔,俩个节点必须配置一致,默认1s authentication { ## 认证匹配 auth_type PASS auth_pass bhz } track_script { chk_haproxy } virtual_ipaddress { 192.168.11.70 ## 虚拟ip,可以指定多个 } } |
PS: 80节点(backup)配置如下
! Configuration File for keepalived global_defs { router_id bhz75 ##标识节点的字符串,通常为hostname } vrrp_script chk_haproxy { script "/etc/keepalived/haproxy_check.sh" ##执行脚本位置 interval 2 ##检测时间间隔 weight -20 ##如果条件成立则权重减20 } vrrp_instance VI_1 { state BACKUP ## 主节点为MASTER,备份节点为BACKUP interface eno16777736 ## 绑定虚拟IP的网络接口(网卡),与本机IP地址所在的网络接口相同(我这里是eno16777736) virtual_router_id 74 ## 虚拟路由ID号(主备节点一定要相同) mcast_src_ip 192.168.11.75 ## 本机ip地址 priority 90 ##优先级配置(0-254的值) nopreempt advert_int 1 ## 组播信息发送间隔,俩个节点必须配置一致,默认1s authentication { ## 认证匹配 auth_type PASS auth_pass bhz } track_script { chk_haproxy } virtual_ipaddress { 192.168.1.70 ## 虚拟ip,可以指定多个 } } |
4、执行脚本编写
PS:添加文件位置为/etc/keepalived/haproxy_check.sh(74、75两个节点文件内容一致即可)
#!/bin/bash COUNT=`ps -C haproxy --no-header |wc -l` if [ $COUNT -eq 0 ];then /usr/local/haproxy/sbin/haproxy -f /etc/haproxy/haproxy.cfg sleep 2 if [ `ps -C haproxy --no-header |wc -l` -eq 0 ];then killall keepalived fi fi |
5、执行脚本赋权
PS:haproxy_check.sh脚本授权,赋予可执行权限.
chmod +x /etc/keepalived/haproxy_check.sh |
6、启动keepalived
PS:当我们启动俩个haproxy节点以后,我们可以启动keepalived服务程序:
//如果74、75的haproxy没有启动则执行启动脚本 /usr/local/haproxy/sbin/haproxy -f /etc/haproxy/haproxy.cfg //查看haproxy进程状态 ps -ef | grep haproxy //启动两台机器的keepalived service keepalived start | stop | status | restart //查看状态 ps -ef | grep haproxy ps -ef | grep keepalived |
7、高可用测试
PS:vip在27节点上
PS:27节点宕机测试:停掉27的keepalived服务即可。
PS:查看28节点状态:我们发现VIP漂移到了28节点上,那么28节点的haproxy可以继续对外提供服务!
2.8 集群配置文件
创建如下配置文件位于:/etc/rabbitmq目录下(这个目录需要自己创建)
环境变量配置文件:rabbitmq-env.conf
配置信息配置文件:rabbitmq.config(可以不创建和配置,修改)
rabbitmq-env.conf配置文件:
---------------------------------------关键参数配置-------------------------------------------
RABBITMQ_NODE_IP_ADDRESS=本机IP地址
RABBITMQ_NODE_PORT=5672
RABBITMQ_LOG_BASE=/var/lib/rabbitmq/log
RABBITMQ_MNESIA_BASE=/var/lib/rabbitmq/mnesia
配置参考参数如下:
RABBITMQ_NODENAME=FZTEC-240088 节点名称
RABBITMQ_NODE_IP_ADDRESS=127.0.0.1 监听IP
RABBITMQ_NODE_PORT=5672 监听端口
RABBITMQ_LOG_BASE=/data/rabbitmq/log 日志目录
RABBITMQ_PLUGINS_DIR=/data/rabbitmq/plugins 插件目录
RABBITMQ_MNESIA_BASE=/data/rabbitmq/mnesia 后端存储目录
更详细的配置参见: http://www.rabbitmq.com/configure.html#configuration-file
配置文件信息修改:
/usr/lib/rabbitmq/lib/rabbitmq_server-3.6.4/ebin/rabbit.app和rabbitmq.config配置文件配置任意一个即可,我们进行配置如下:
vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.4/ebin/rabbit.app
-------------------------------------关键参数配置----------------------------------------
tcp_listerners 设置rabbimq的监听端口,默认为[5672]。
disk_free_limit 磁盘低水位线,若磁盘容量低于指定值则停止接收数据,默认值为{mem_relative, 1.0},即与内存相关联1:1,也可定制为多少byte.
vm_memory_high_watermark,设置内存低水位线,若低于该水位线,则开启流控机制,默认值是0.4,即内存总量的40%。
hipe_compile 将部分rabbimq代码用High Performance Erlang compiler编译,可提升性能,该参数是实验性,若出现erlang vm segfaults,应关掉。
force_fine_statistics, 该参数属于rabbimq_management,若为true则进行精细化的统计,但会影响性能
------------------------------------------------------------------------------------------
更详细的配置参见:http://www.rabbitmq.com/configure.html
2.9 服务测试运行
1、集群启动
rabbitMQ集群启动:
//启动各个MQ节点 rabbitmq-server -detached //查看集群状态 rabbitmqctl cluster_status |
rabbitMQ集群关闭:
//各节点停止MQ集群命令 rabbitmqctl stop_app | start_app | cluster_status | reset //各节点停止MQ服务 /etc/init.d/rabbitmq-server stop | start | restart | status |
设置keepalived开机启动后,则会直接运行chk_haproxy.sh脚本,从而启动haproxy服务,所以对于负载均衡和高可用层我们无需任何配置。
PS:由《2.2章节 MQ服务架构图》所示。我们的虚拟VIP节点为192.168.1.20,所以我们进行MQ服务生产消费消息测试。
2、测试代码
PS: MQ Sender代码
package bhz.rabbitmq.helloword; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import com.rabbitmq.client.Address; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory;
/** * <B>中文类名:</B>rabbitmq负载均衡测试<BR> * <B>概要说明:</B><BR> * @author bhz(Alienware) * @since 2016年7月20日 */ public class Sender {
public static void main(String[] args) throws Exception {
ConnectionFactory connectionFactory = new ConnectionFactory() ;
//RabbitMQ-Server安装在本机,所以直接用127.0.0.1 connectionFactory.setHost("192.168.1.20"); connectionFactory.setPort(5672); Connection connection = connectionFactory.newConnection(); Channel channel = connection.createChannel() ; //定义Queue名称 String queueName = "queue01" ; //为channel定义queue的属性,queueName为Queue名称 channel.queueDeclare(queueName , false, false, false, null) ; for(int i =0; i < 100000; i ++){ //发送消息 String msg = "Hello World RabbitMQ " + i; channel.basicPublish("", queueName , null , msg.getBytes()); System.out.println("发送数据:" + msg); TimeUnit.SECONDS.sleep(1); } channel.close(); connection.close(); } } |
PS: MQ Receiver代码
package bhz.rabbitmq.helloword; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import com.rabbitmq.client.Address; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import com.rabbitmq.client.QueueingConsumer; import com.rabbitmq.client.QueueingConsumer.Delivery; /** * <B>中文类名:</B>rabbitmq 负载均衡测试<BR> * <B>概要说明:</B><BR> * @author bhz(Alienware) * @since 2016年7月20日 */ public class Receiver { public static void main(String[] args) throws Exception { ConnectionFactory connectionFactory = new ConnectionFactory() ; connectionFactory.setHost("192.168.1.20"); connectionFactory.setPort(5672); Connection connection = connectionFactory.newConnection(); Channel channel = connection.createChannel() ; String queueName = "queue01"; channel.queueDeclare(queueName, false, false, false, null) ; //上面的部分,与Sender01是一样的 //配置好获取消息的方式 QueueingConsumer consumer = new QueueingConsumer(channel) ; channel.basicConsume(queueName, true, consumer) ; //循环获取消息 while(true){ //获取消息,如果没有消息,这一步将会一直阻塞 Delivery delivery = consumer.nextDelivery() ; String msg = new String(delivery.getBody()) ; System.out.println("收到消息:" + msg); } } } |
3、测试结果
PS: Sender程序启动发送5条数据:
PS:我们在MQ集群管控台查看队列情况,说明生产者消息发送到MQ集群中。
PS:并且任意MQ节点执行如下命令:由下图可知我们镜像队列配置成功。
//查看镜像队列的状态,同步到了24 25 26三个节点上
rabbitmqctl list_queues name pid slave_pids
PS: Received程序启动成功接收5条数据
PS:查看集群队列消费状态:已经成功消费数据
3 运维手册
3.1 集群节点重置
停止所有服务后,删除 /var/lib/rabbitmq/mnesia 文件夹内容,重新再启动每个节点!(重新进行集群的初始化等工作,重新操作<<3.3章组成集群操作即可>>)
3.2 集群节点操作
3.2.1集群配置管理
1、首先,我们在管控台里可以对集群的vhost、exchange、queue、用户等进行增删改查。
我们在overview的最下面Import / export definitions中 可以下载(当前集群配置)和上传(修改集群)配置,这些配置为json格式。如图所示:
2、json文件如图所示,形如:
3、也就是说我们可以使用json的方式去通过管控台web界面去对集群配置进行修改。
3.2.2 集群用户管理
1、我们点击admin标签,如图所示:
2、下面会列出当前用户列表,可以进行增删改查操作,如下图所示:
3.2.3 交换机、队列
PS:交换机(exchange)
PS:队列(queue)
3.2.4 安装管理脚本
安装rabbitmqadmin管理脚本,唯一的要求就是unix系统中存在Python即可。我, 只需要从之前所安装好的management插件中获取该脚本即可。执行命令如下所示:
cd /etc/rabbitmq wget http://localhost:15672/cli/rabbitmqadmin chmod +x rabbitmqadmin |
3.2.5 使用管理脚本
1、查看虚拟主机(vhost)下的交换机队列(exchange queues)
rabbitmqadmin -V "/" list exchanges
2、清空队列
rabbitmqadmin purge queue name=exchange-1.queue-1
3、创建交换机
rabbitmqadmin -u guest -p guest declare exchange \name=exchange-2 type=fanout
4、获得连接数,关闭连接。
rabbitmqadmin list connections name
rabbitmqadmin close connection name="链接名称"
PS:更多管理员操作命令详见文档:
3.3 集群应用监控
生产注意问题:提高RabbitMQ的File descriptors_GISAstian的博客-CSDN博客
按默认配置安装完RabbitMQ后,发现其File descriptors(即文件描述符)和Socket descriptors都特别低,分别为924和829。客户端(消费者)保持长连接时很容易就将socket占满。
经查该问题是由于系统当前的ulimit -n仅为1024,rabbitmq在启动时会进行如下换算:
file_limit = 1024 - 100; // 924 sockets_limit = trunc((1024 - 100) * 0.9 - 2); //829 |
RabbitMQ的File descriptors(文件描述符)的数量受到三个参数的约束:
(1)系统级别,配置文件为:/proc/sys/fs/file-max,如果太小需要修改。
[root@hadoop1 ~]# cat /proc/sys/fs/file-max 778230 [root@hadoop1 ~]# cat /proc/sys/fs/file-nr 2432 0 778230 |
(2)用户级别,配置文件为:/etc/security/limits.conf
* - nofile 65536 |
(3)进程级别,即ulimit -n
#修改 [root@hadoop1 ~]# ulimit -n 65536 |
以上三个参数都确认>=我们需要的连接数后,重启RabbitMQ,注意需要连Erlang一起重启:
重启后即可看到效果。
4 定制扩展
4.1 延迟队列插件
#step1:upload the ‘rabbitmq_delayed_message_exchange-0.0.1.ez’ file:
https://github.com/rabbitmq/rabbitmq-delayed-message-exchange
https://bintray.com/rabbitmq/community-plugins/rabbitmq_delayed_message_exchange/v3.6.x#files/
#step2:PUT Directory:
/usr/lib/rabbitmq/lib/rabbitmq_server-3.6.4/plugins
#step3:Then run the following command:
Start the rabbitmq cluster for command ## rabbitmq-server -detached
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
访问地址:http://192.168.1.21:15672/#/exchanges,添加延迟队列