rabbitmq安装以及高可用配置haproxy

rabbitmq安装

* 安装erlang和rabbitmq
yum install erlang
yum install -y rabbitmq-server.noarch

./rabbitmq-plugins enable rabbitmq_management
./rabbitmq-plugins enable rabbitmq_management

*重启
service rabbitmq-server restart
service rabbitmq-server status

* 创建账号（先启动服务 才能创建账号）
rabbitmqctl add_user admin 123456
* 授予管理员权限
rabbitmqctl set_user_tags admin administrator
* 查看用户
rabbitmqctl list_users
* 设置权限
rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"
* 查看权限
rabbitmqctl list_user_permissions admin


-- web管理页面
* 启动web管理才能进行访问web页面
rabbitmq-plugins enable rabbitmq_management
* 打开web页面
http://192.168.0.189:15672/

集群配置

* 其他从节点安装RabbitMQ（和上面安装一致）
* 保证相同的Erlang Cookie(拷贝.erlang.cookie到其他机器覆盖)
scp /var/lib/rabbitmq/.erlang.cookie root@192.168.0.178:/var/lib/rabbitmq
scp /var/lib/rabbitmq/.erlang.cookie rootr@192.168.0.178:/var/lib/rabbitmq

#指定为该文件为rabbitmq用户 并只保留r权限（ 如果不对，启动会报错）
cd  /var/lib/rabbitmq
chown rabbitmq:rabbitmq .erlang.cookie
chmod 400 .erlang.cookie


* 运行各个RabbitMQ节点
rabbitmqctl stop
rabbitmq-server -detached

* 将节点连接成集群（sparkmast为189节点配置的host名称）
rabbitmqctl stop_app
rabbitmqctl join_cluster rabbit@sparkmast
rabbitmqctl start_app
-- 另外一台也加进集群
rabbitmqctl stop_app
rabbitmqctl join_cluster rabbit@sparkmast
rabbitmqctl start_app

* 检查集群状态（有多个说明集群配置正确）
rabbitmqctl cluster_status

* 停止一台，实验一下容错
rabbitmqctl stop
rabbitmqctl cluster_status

haproxy高可用配置

ha（High Availability）,上边已经完成了集群配置，集群内可以相互复制数据，但是客户端是只连其中一台服务器，如果 这台服务器宕掉了，那客户端还是访问不了rabbitmq集群，haproxy的目的是代理这些集群服务，客户端连接代理 代理再转发给rabbitmq。这样其中一个服务挂了 代理服务会检测到并转发给其他可用的节点。
下边的配置 bind *:5077代表监听5077端口，客户端请求这个代理的ip和端口就行，代理会自动转发到rabbitmq


*  先安装
yum install -haproxy
rpm -qi haproxy
rpm -ql haproxy

---- 配置haproxy /etc/haproxy/haproxy.cfg
### haproxy 监控页面地址是：http://192.168.0.189:9188/haproxy_status（admin/123456）
listen admin_stats
    bind *:9188
    mode http
    log 127.0.0.1 local3 err
    stats refresh 60s
    stats uri /haproxy_status
    stats realm welcome login\ Haproxy
    stats auth admin:123456
    stats hide-version
    stats admin if TRUE

########tcp配置#################
listen rabbitmq_cluster
    bind *:5077
    mode tcp
    balance roundrobin
    server rabbitnode1 192.168.0.189:5672 check inter 2000 rise 2 fall 3 weight 1
    server rabbitnode2 192.168.0.179:5672 check inter 2000 rise 2 fall 3 weight 1
    server rabbitnode3 192.168.0.178:5672 check inter 2000 rise 2 fall 3 weight 1

-- 启动
/usr/sbin/haproxy -f /etc/haproxy/haproxy.cfg
-- 重启
/usr/sbin/haproxy -f /etc/haproxy/haproxy.cfg -st `cat /usr/local/haproxy/haproxy.pid`
-- 关闭
killall haproxy

java生产和消费demo

package vip.zhangchuan.demo;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * 测试RabbitMQ
 *
 */
public class RabbitMQTest {
    public static String QUEUE_NAME = "mytestquery";
    public static String HOST = "192.168.0.189";
    public static Integer PORT = 5077;//5077   5672（5077为代理端口）
    public static String USERNAME = "admin";
    public static String PASSWORD = "123456";

    public static void main(String[] args) {
       // product();
        consumer();
    }

    /**
     * 生产消息
     */
    public static void product() {
        //初始化socket链接
        ConnectionFactory factory = new ConnectionFactory();
        //指定链接地址
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        try{
            //建立程序和rabbitmq的socket连接
            Connection connection = factory.newConnection();

            //创建管道
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            //让当前线程睡眠8s，以检验rabbitmq的消息轮询
            Thread.currentThread().sleep(8000);
            String message = "hello,world";
            //发送消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("发送消息==>："+message);
            channel.close();
            connection.close();
        }catch (Exception e) {
            System.out.println("程序出错:"+e);
            e.printStackTrace();
        }
    }


    /**
     * 消费消息
     */
    public static void consumer() {
        try {
            //初始化socket链接
            ConnectionFactory factory = new ConnectionFactory();
            //指定链接地址
            factory.setHost(HOST);
            factory.setPort(PORT);
            factory.setUsername(USERNAME);
            factory.setPassword(PASSWORD);

            //建立程序与rabbitmq的socket连接
            Connection connection = factory.newConnection();
            //创建管道
            Channel channel = connection.createChannel();

           /* //声明队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
            //创建队列消费对象
            QueueingConsumer consumer = new QueueingConsumer(channel);
            //设置参数
            channel.basicConsume(QUEUE_NAME, true, consumer);
            //创建接收对象来接收来自服务端的消息
            Delivery delivery = null;
            //循环接收，相当于开启了一个监听
            while (true) {
                delivery = consumer.nextDelivery();
                String message = new String(delivery.getBody());
                System.out.println(" [x] Received '" + message + "'");
            }
            */

            /*
             * 4.设置客户端最多接收示被ack的消息个数
             */
            channel.basicQos(64);

            Consumer consumer  = new DefaultConsumer(channel) {

                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope,
                                               AMQP.BasicProperties properties, byte[] body) throws IOException{

                    System.out.println("接收消息==>:"+new String(body));
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //消息确认
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            };

            /**
             * 回调
             */
            channel.basicConsume(QUEUE_NAME, consumer);
            /**
             * 关闭资源
             */
            TimeUnit.SECONDS.sleep(5);
            channel.close();
            connection.close();

        } catch (Exception e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }


}