RabbitMQ3.10.7高级特性

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实现客户端访问入口的高可用机制。

服务架构设计

 服务节点分配

官方文档手册：

集群配置文档：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所需要的依赖包

2、下载安装包

3、安装服务命令

4、修改集群用户与连接心跳检测

5、安装管理插件

6、服务指令

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即可。

​​​​​​​2.3 组成集群步骤

1、停止MQ服务

PS:我们首先停止3个节点的服务：(这里不能使用原来的命令：/etc/init.d/rabbitmq-server stop)

2、组成集群操作

PS:接下来我们就可以使用集群命令，配置71、72、73为集群模式，3个节点（71、72、73）执行启动命令，后续启动集群使用此命令即可。

3、slave加入集群操作（重新加入集群也是如此，以最开始的主节点为加入节点）

4、修改集群名称

PS:修改集群名称（默认为第一个node名称）：

5、查看集群状态

PS:最后在集群的任意一个节点执行命令：查看集群状态

 

6、管控台界面

PS: 访问任意一个管控台节点：http://192.168.11.71:15672 如图所示

 

​​​​​​​2.4 配置镜像队列

PS:设置镜像队列策略（在任意一个节点上执行）

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，下面步骤统一

3、Haproxy配置

PS:haproxy 配置文件haproxy.cfg详解

4、启动haproxy

5、访问haproxy

PS:访问如下地址可以对rmq节点进行监控：http://192.168.11.74:8100/rabbitmq-stats

 

6、关闭haproxy

​​​​​​​​​​​​​​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

3、Keepalived配置

PS:修改keepalived.conf配置文件

PS: 79节点（Master）配置如下

PS: 80节点（backup）配置如下

4、执行脚本编写

PS:添加文件位置为/etc/keepalived/haproxy_check.sh（74、75两个节点文件内容一致即可）

5、执行脚本赋权

PS:haproxy_check.sh脚本授权,赋予可执行权限.

6、启动keepalived

PS:当我们启动俩个haproxy节点以后，我们可以启动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集群启动： 

rabbitMQ集群关闭：

设置keepalived开机启动后，则会直接运行chk_haproxy.sh脚本，从而启动haproxy服务，所以对于负载均衡和高可用层我们无需任何配置。

PS:由《2.2章节 MQ服务架构图》所示。我们的虚拟VIP节点为192.168.1.20，所以我们进行MQ服务生产消费消息测试。

2、测试代码

PS: MQ Sender代码

PS: MQ Receiver代码

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插件中获取该脚本即可。执行命令如下所示：

 

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在启动时会进行如下换算：

RabbitMQ的File descriptors（文件描述符）的数量受到三个参数的约束：

（1）系统级别，配置文件为：/proc/sys/fs/file-max，如果太小需要修改。

（2）用户级别，配置文件为：/etc/security/limits.conf

 

（3）进程级别，即ulimit -n

 

以上三个参数都确认>=我们需要的连接数后，重启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

Community Plugins — RabbitMQ

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，添加延迟队列