apt-get install rabbitmq-server

/etc/init.d/rabbitmq-server status

apt-get update

sudo su

rabbitmqctl status

rabbitmq-plugins

rabbitmq-plugins --help

disable      Disables one or more plugins
enable       Enables one or more plugins
list         Lists plugins and their state
set          Enables one or more plugins, disables the rest

rabbitmq-plugins list

[  ] rabbitmq_amqp1_0                  3.8.2
[  ] rabbitmq_auth_backend_cache       3.8.2
[  ] rabbitmq_auth_backend_http        3.8.2
[  ] rabbitmq_auth_backend_ldap        3.8.2
[  ] rabbitmq_auth_backend_oauth2      3.8.2
[  ] rabbitmq_auth_mechanism_ssl       3.8.2
[  ] rabbitmq_consistent_hash_exchange 3.8.2
[  ] rabbitmq_event_exchange           3.8.2
[  ] rabbitmq_federation               3.8.2
[  ] rabbitmq_federation_management    3.8.2
...

rabbitmq-plugins enable rabbitmq_management

Enabling plugins on node rabbit1
rabbitmq_management
The following plugins have been configured:
  rabbitmq_management
  rabbitmq_management_agent
  rabbitmq_web_dispatch
Applying plugin configuration to rabbit1
The following plugins have been enabled:
  rabbitmq_management
  rabbitmq_management_agent
  rabbitmq_web_dispatch

started 3 plugins.

/etc/init.d/rabbitmq-server restart

apt-get install docker.io

apt-get install docker-compose

version: '3'
 
services:
  rabbit:
    image: rabbitmq:3.8-management
    ports:
      - "5673:5672"
      - "15673:15672"

docker-compose up

docker-compose up -d

docker ps

ctrl + c

docker-compose down

rabbitmq-plugins enable rabbitmq_mqtt

# restart RabbitMQ
/etc/init.d/rabbitmq-server restart

apt install mosquitto-clients

mosquitto_sub -h 127.0.0.1 -p 1883 -t "czujnik_1"

mosquitto_pub -h 127.0.0.1 -p 1883 -t "czujnik_1" -m "Odczyt 1"

rabbitmqctl list_vhosts

rabbitmqctl add_vhost app_1

rabbitmqctl delete_vhost app_1

rabbitmqctl set_permissions -p app_1 guest ".*" ".*" ".*"

rabbitmqctl set_topic_permissions -p app_1 guest amq.topic ".*" ".*"

rabbitmqctl clear_permissions -p app_1 guest

rabbitmqctl clear_topic_permissions -p app_1 guest amq.topic

rabbitmqctl add_user app_1 password

# przypisujemy tag administrator
rabbitmqctl set_user_tags app_1 administrator 

rabbitmqctl list_user_permissions app_1

rabbitmqctl clear_permissions -p app_1 app_1

var amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost', function(err1, connection) {

    if (err1)
    {
        return console.error(err1);
    }

    console.info('Connected');

    connection.close();
});

amqp://username:password@localhost/vhost

var amqp = require('amqplib/callback_api');

amqp.connect('amqp://app_full:app_full@localhost/app_1', function(err1, connection) {

    if (err1)
    {
        return console.error(err1);
    }

    console.info('Connected');

    connection.createChannel(function(err2, channel) {

        if (err2)
        {
            throw err2;
        }

        console.info('Channel created');

        var queue = 'q_1';
        var msg = JSON.stringify({
            'text': 'Hello world'
        });

        channel.sendToQueue(queue, Buffer.from(msg));
        console.log("[x] Sent %s", msg);
    });
});

connection.createChannel(function(err2, channel) {

  if (err2)
  {
    throw err2;
  }

  console.info('Channel created');

  var queue = 'q_1';
  var msg = JSON.stringify({
    'text': 'Hello world'
  });

  channel.sendToQueue(queue, Buffer.from(msg));
  console.log("[x] Sent %s", msg);
});

connection.createChannel(function(err2, channel) {

  if (err2)
  {
    throw err2;
  }

  console.info('Channel created');

  var queue = 'q_1';
  var msg = JSON.stringify({
    'text': 'Hello world'
  });

  // tworzy kolejkę jeśli nie istnieje
  channel.assertQueue(queue, {
    durable: false
  });

  channel.sendToQueue(queue, Buffer.from(msg));
  console.log(" [x] Sent %s", msg);
});

channel.sendToQueue(queue, Buffer.from(msg), {
    expiration: 15000
});

connection.createConfirmChannel(function(err2, channel) {

for (var i = 0; i < 10; i++)
{
  var msg = JSON.stringify({
    'text': 'Message ' + i
  });

  console.log(" [x] Sent %s", msg);

  channel.sendToQueue(queue, Buffer.from(msg), {}, errorCallback(msg));
}

function errorCallback(msg) {

    return function(err) {

        if (err)
        {
            return console.log('Message: ' + msg + ' - NOT confirm');
        }

        console.log(msg + ' - confirm');
    };
}

channel.waitForConfirms(function(err) {

    if (err)
    {
        return console.log('Not confirm all message');
    }

    console.log('All messages confirm');
});

connection.createChannel(function(error1, channel) {

    if (error1)
    {
    	throw error1;
    }

    var exchange = 'fanout_ex_app';
    var msg = JSON.stringify({
    	'text': 'Hello world'
    });

    // tworzy centralę wiadomości
    // channel.assertExchange(exchange, 'fanout', {
    //     durable: false
    // });

    channel.publish(exchange, '', Buffer.from(msg));

    console.log("[x] Sent %s", msg);
});

connection.createChannel(function(error1, channel) {

        if (error1){
            throw error1;
        }

        var exchange = 'fanout_ex_app';
        var queue1 = 'fanout_q1_app';
        var msg = JSON.stringify({
            'id': '145'
        });

        channel.assertExchange(exchange, 'fanout', {
            durable: true
        });

        channel.assertQueue(queue1, {durable: true}, function(err2) {

            if (err2){
                throw err2;
            }

            channel.bindQueue(queue1, exchange);

connection.createChannel(function(error1, channel) {

    if (error1)
    {
    	throw error1;
    }

    var exchange = 'direct_ex';
    var msg = JSON.stringify({
    	'id': '145'
    });

    channel.publish(exchange, 'epub', Buffer.from(msg));

    console.log("[x] Sent %s", msg);
});

connection.createChannel(function(error1, channel) {

    if (error1) {
    	throw error1;
    }

    var exchange = 'direct_ex_app';
    var queue1 = 'direct_epub_app';
    var queue2 = 'direct_mobi_app';
    var queue3 = 'direct_pdf_app';
    var msg = JSON.stringify({
	    'id': '145'
    });

    channel.assertExchange(exchange, 'direct', {
    	durable: true
    });

    channel.assertQueue(queue1, {durable: true}, function(err2) {

        if (err2){
            throw err2;
        }

        channel.bindQueue(queue1, exchange, 'download_epub');

        channel.assertQueue(queue2, {durable: true}, function(err3) {

            if (err3){
                throw err3;
            }

            channel.bindQueue(queue2, exchange, 'download_mobi');

            channel.assertQueue(queue3, {durable: true}, function(err4) {

                if (err4){
                    throw err4;
                }

                channel.bindQueue(queue3, exchange, 'download_pdf');

                channel.publish(exchange, 'download_epub', Buffer.from(msg));

                console.log("[x] Sent %s", msg);
            });
        });
    });
});

connection.createChannel(function(error1, channel) {

        if (error1)
        {
            throw error1;
        }

        var exchange = 'topic_ex_app';
        var queueInfo = 'topic_info_app';
        var queueError = 'topic_error_app';
        var queueAll = 'topic_all_app';
        var msg = JSON.stringify({
            'id': '145'
        });

        channel.assertExchange(exchange, 'topic', {
            durable: true
        });

        channel.assertQueue(queueInfo, {durable: true}, function(err2) {

            if (err2)
            {
                throw err2;
            }

            channel.bindQueue(queueInfo, exchange, 'info.*');

            channel.assertQueue(queueError, {durable: true}, function(err2) {

                if (err2)
                {
                    throw err2;
                }

                channel.bindQueue(queueError, exchange, 'error.*');

                channel.assertQueue(queueAll, {durable: true}, function(err2) {

                    if (err2)
                    {
                        throw err2;
                    }

                    channel.bindQueue(queueAll, exchange, '*.log');

                    console.log("Ready");

                    // channel.publish(exchange, 'info.log', Buffer.from(msg));
                    // console.log("[x] Sent %s", msg);
                });
            });
        });
    });

connection.createChannel(function(error1, channel) {

  // ... pominięto kod
  
  var exchange = 'headers_ex_app';
  var queueError = 'headers_log_error_app';
  var queueInfo = 'headers_log_info_app';
  var queueAll = 'headers_log_all_app';
  var msg = JSON.stringify({
    'id': '145'
  });

  channel.assertExchange(exchange, 'headers', {
    durable: true
  });

  channel.assertQueue(queueError, {durable: true}, function(err2) {

    // ... pominięto kod
    
    channel.bindQueue(queueError, exchange, '', {
      'log_error': '1'
    });

    channel.assertQueue(queueInfo, {durable: true}, function(err2) {

      // ... pominięto kod

      channel.assertQueue(queueAll, {durable: true}, function(err2) {

        // ... pominięto kod

        channel.bindQueue(queueAll, exchange, '', {
          'log_info': '1',
          'log_error': '1'
        });

        channel.publish(exchange, '', Buffer.from(msg), {
          'headers': {
            'log_error': '1'
          }
        });

        console.log("[x] Sent %s", msg);
      });
    });
  });
});

/etc/init.d/rabbitmq-server restart

connection.createChannel(function(err1, channel) {

    if (err1) {
    	throw err1;
    }

    var exchange = 'internal_ex_app';
    var msg = JSON.stringify({
    	'id': '145'
    });

    channel.assertExchange(exchange, 'fanout', {
    	internal: true
    });

    channel.assertQueue('tmp_app', {durable: true}, function(err2) {

        if (err2) {
            throw err2;
        }

        channel.bindQueue('tmp_app', exchange, 'test');

        channel.publish(exchange, 'test', Buffer.from(msg));

        console.log("[x] Sent %s", msg);
    });
});

rabbitmqctl list_queues -p app_1

rabbitmqctl list_queues -p app_1 name durable

rabbitmqadmin -V app_1 declare queue name=test

connection.createChannel(function (err2, channel) {

    if (err2) {
    	throw err2;
    }

    console.info('Channel created');

    var queue = 'q_durable_fale_app';
    var msg = JSON.stringify({
    	'text': 'Czy wiadomość przetrwa restart serwera ??'
    });

    channel.assertQueue(queue, {
    	durable: false
    });

    channel.sendToQueue(queue, Buffer.from(msg));

    console.log("OK");
});

/etc/init.d/rabbitmq-server restart

connection.createChannel(function (err2, channel) {

    if (err2) {
    	throw err2;
    }

    console.info('Channel created');

    var queue = 'q_ttl_app';
    var msg = JSON.stringify({
    	'text': 'TTL 15s.'
    });

    channel.assertQueue(queue, {
    	messageTtl: 15000
    });

    channel.sendToQueue(queue, Buffer.from(msg));

    console.log("OK");
});

connection.createChannel(function (err2, channel) {

    if (err2) {
        throw err2;
    }

    console.info('Channel created');

    var queue = 'q_expiry_app';

    channel.assertQueue(queue, {
    	expires: 15000
    });

    var msg = JSON.stringify({
        'text': 'Hello world'
    });

    channel.sendToQueue(queue, Buffer.from(msg));
    console.log(" [x] Sent %s", msg);
});

connection.createChannel(function(err2, channel) {

    if (err2)
    {
        throw err2;
    }

    channel.consume('q_expiry_app', function(msg) {

        console.log(msg);
    });

    console.info('OK');
});

connection.createChannel(function (err2, channel) {

    if (err2) {
    	throw err2;
    }

    console.info('Channel created');

    channel.assertQueue('q_auto_delete', {
    	autoDelete: true
    });

    console.log("OK");
});

connection.createChannel(function(err2, channel) {

    if (err2)
    {
    	throw err2;
    }

    channel.consume('q_auto_delete', function(msg) {

    	console.log(msg);
    });

    console.info('OK');
});

connection.createChannel(function(err2, channel) {

    if (err2)
    {
    	throw err2;
    }

    console.info('Channel created');

    var queue = 'q_max_length_10_app';

    channel.assertQueue(queue, {
    	maxLength: 10
    });

    for (var i = 0; i < 20; i++)
    {
        var msg = JSON.stringify({
            'text': 'Message ' + i
        });

        console.log(" [x] Sent %s", msg);

        channel.sendToQueue(queue, Buffer.from(msg));
    }
});

connection.createChannel(function(err2, channel) {

    if (err2){
    	throw err2;
    }

    console.info('Channel created');

    var queue = 'q_max_length_10_app';

    channel.assertQueue(queue, {
    	maxLength: 10,
        overflow: 'reject-publish'
    });

    for (var i = 0; i < 20; i++)
    {
        var msg = JSON.stringify({
            'text': 'Message ' + i
        });

        console.log(" [x] Sent %s", msg);

        channel.sendToQueue(queue, Buffer.from(msg));
    }
});

connection.createChannel(function(err2, channel) {

    if (err2)
    {
        throw err2;
    }

    channel.consume('q_single_active_consumer_app', function(msg) {

        setTimeout(function () {
            console.log(msg.content.toString());
            channel.ack(msg);
        }, 1000);
    });

    console.info('OK');
});

connection.createChannel(function(err2, channel) {

    if (err2) {
    	throw err2;
    }

    channel.consume('report_app', function(msg) {

        console.log(msg.content.toString());
    });

    console.info('OK');
});

connection.createChannel(function(err2, channel) {

    if (err2) {
    	throw err2;
    }

    channel.consume('test', function(msg) {

        console.log(msg.content.toString());

        // console.log('Potwierdzam przetworzenie');
        // channel.ack(msg);
    });

    console.info('OK');
});

connection.createChannel(function(err2, channel) {

    if (err2) {
    	throw err2;
    }

    channel.consume('report_app', function(msg) {

        console.log(msg.content.toString());

        console.log('Error - powrót do kolejki');

        setTimeout(function() {

            channel.nack(msg);
        }, 15000);
    });

    console.info('OK');
});

/etc/rabbitmq/rabbitmq.conf

# od wersji 3.8
load_definitions = /etc/rabbitmq/definitions.json

# starsze wersje
# management.load_definitions = /etc/rabbitmq/definitions.json

/etc/init.d/rabbitmq-server restart

/etc/init.d/rabbitmq-server status

/etc/rabbitmq/definitions.json

{
  "users": [
    {
      "name": "app_2",
      "password": "app_2",
      "tags": "administrator"
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "vhosts":[
    {
      "name":"app_2"
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "permissions": [
    {
      "user": "app_2",
      "vhost": "app_2",
      "configure": ".*",
      "write": ".*",
      "read": ".*"
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "exchanges": [
    {
      "vhost": "app_2",
      "name": "reports_ex",
      "type": "direct",
      "durable": true,
      "auto_delete": false,
      "arguments": {}
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "queues":[
    {
      "name":"reports_pdf",
      "vhost":"app_2",
      "durable":true,
      "auto_delete":false,
      "arguments":{}
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "bindings": [
    {
      "arguments":{},
      "destination":"reports_pdf",
      "destination_type":"queue",
      "routing_key":"download_pdf",
      "source":"reports_ex",
      "vhost":"app_2"
    }
  ]
}

/etc/rabbitmq/definitions.json

{
  "users": [
    {
      "name": "app_2",
      "password": "app_2",
      "tags": "administrator"
    }
  ],
  "vhosts":[
    {
      "name":"app_2"
    }
  ],
  "permissions": [
    {
      "user": "app_2",
      "vhost": "app_2",
      "configure": ".*",
      "write": ".*",
      "read": ".*"
    }
  ],
  "parameters": [],
  "policies": [],
  "queues":[
    {
      "name":"reports_pdf",
      "vhost":"app_2",
      "durable":true,
      "auto_delete":false,
      "arguments":{}
    }
  ],
  "exchanges": [
    {
      "vhost": "app_2",
      "name": "reports_ex",
      "type": "direct",
      "durable": true,
      "auto_delete": false,
      "arguments": {}
    }
  ],
  "bindings": [
    {
      "arguments":{},
      "destination":"reports_pdf",
      "destination_type":"queue",
      "routing_key":"download_pdf",
      "source":"reports_ex",
      "vhost":"app_2"
    }
  ]
}

rabbitmqctl import_definitions /etc/rabbitmq/definitions.json

rabbitmqadmin import /etc/rabbitmq/definitions.json

curl --user guest:guest --data "@/etc/rabbitmq/definitions.json" --header "Content-Type: application/json" --request POST http://127.0.0.1:15672/api/definitions

rabbitmqctl export_definitions /etc/rabbitmq/definitions.file.json

rabbitmqadmin export /etc/rabbitmq/definitions_export.json

curl --user guest:guest --header "Content-Type: application/json" --request GET http://127.0.0.1:15672/api/definitions > export_data.json

http://localhost:15672/api/vhosts

http://localhost:15672/api/exchanges

curl -u guest:guest http://localhost:15672/api/vhosts

curl -u guest:guest http://localhost:15672/api/vhosts | json_pp -json_opt pretty,canonical

rabbitmqctl list_queues name durable arguments

rabbitmqctl list_queues name type durable --formatter=pretty_table

rabbitmqadmin list queues

rabbitmqctl list_queues name durable arguments --formatter=pretty_table --silent

docker run -d \
  --name rabbit_cluster_1 \
  --hostname docker1 \
  -e RABBITMQ_ERLANG_COOKIE="cookie" \
  -e RABBITMQ_NODENAME=rabbit1 \
  -p 5673:5672 \
  -p 15673:15672 \
  -p 25673:25672 \
  rabbitmq:3.8-management

docker run -d \
  --name rabbit_cluster_2 \
  --hostname docker2 \
  -e RABBITMQ_ERLANG_COOKIE="cookie" \
  -e RABBITMQ_NODENAME=rabbit2 \
  -p 5674:5672 \
  -p 15674:15672 \
  -p 25674:25672 \
  --link rabbit_cluster_1 \
  rabbitmq:3.8-management

docker run -d \
  --name rabbit_cluster_3 \
  --hostname docker3 \
  -e RABBITMQ_ERLANG_COOKIE="cookie" \
  -e RABBITMQ_NODENAME=rabbit3 \
  -p 5675:5672 \
  -p 15675:15672 \
  -p 25675:25672 \  
  --link rabbit_cluster_1 \
  --link rabbit_cluster_2 \
  rabbitmq:3.8-management

docker exec -it rabbit_cluster_2 /bin/bash

rabbitmqctl stop_app

rabbitmqctl reset

rabbitmqctl join_cluster rabbit1@docker1

rabbitmqctl start_app

version: '3'

services:

  rabbit1:
    image: rabbitmq:3.8-management
    hostname: docker1
    environment:
      - RABBITMQ_ERLANG_COOKIE=test
      - RABBITMQ_NODENAME=rabbit1
    ports:
      - "5673:5672"
      - "15673:15672"
      - "25673:25672"
    volumes:
      - ./rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf

  rabbit2:
    image: rabbitmq:3.8-management
    depends_on:
      - rabbit1
    hostname: docker2
    ports:
      - "5674:5672"
      - "15674:15672"
      - "25674:25672"
    environment:
      - RABBITMQ_ERLANG_COOKIE=test
      - RABBITMQ_NODENAME=rabbit2
    volumes:
      - ./rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf

  rabbit3:
    image: rabbitmq:3.8-management
    depends_on:
      - rabbit1
    hostname: docker3
    ports:
      - "5675:5672"
      - "15675:15672"
      - "25675:25672"
    environment:
      - RABBITMQ_ERLANG_COOKIE=test
      - RABBITMQ_NODENAME=rabbit3
    volumes:
      - ./rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf

loopback_users = none
listeners.tcp.default = 5672

cluster_formation.peer_discovery_backend = rabbit_peer_discovery_classic_config

cluster_formation.classic_config.nodes.1 = rabbit1@docker1
cluster_formation.classic_config.nodes.2 = rabbit2@docker2
cluster_formation.classic_config.nodes.3 = rabbit3@docker3

volumes:
  - ./rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf

global
        log 127.0.0.1   local1
        maxconn 4096
 
defaults
        log     global
        mode    tcp
        option  tcplog
        retries 3
        option redispatch
        maxconn 2000
        timeout connect 5000
        timeout client 50000
        timeout server 50000
 
listen  stats
        bind *:1936
        mode http
        stats enable
        stats hide-version
        stats realm Haproxy\ Statistics
        stats uri /
 
listen rabbitmq
        bind *:5672
        mode            tcp
        balance         roundrobin
        timeout client  3h
        timeout server  3h
        option          clitcpka
        server          rabbitmq1 rabbitmq1:5672  check inter 5s rise 2 fall 3
        server          rabbitmq2 rabbitmq2:5672  check inter 5s rise 2 fall 3
        server          rabbitmq3 rabbitmq3:5672  check inter 5s rise 2 fall 3

listen mgmt
        bind *:15672
        mode            tcp
        balance         roundrobin
        timeout client  3h
        timeout server  3h
        option          clitcpka
        server          rabbitmq1 rabbitmq1:15672  check inter 5s rise 2 fall 3
        server          rabbitmq2 rabbitmq2:15672  check inter 5s rise 2 fall 3
        server          rabbitmq3 rabbitmq3:15672  check inter 5s rise 2 fall 3

let amqp = require('amqp-connection-manager');
let q = 'tasks_app';

function sleep(ms) {
  if(ms <= 0){
    return
  }
    return new Promise(resolve => setTimeout(resolve, ms));
}

let main = async () => {

    var connection = amqp.connect([
        'amqp://localhost:5672',
        'amqp://localhost:5673',
        'amqp://localhost:5674',
    ]);

    var channelWrapper = connection.createChannel({
        json: true,
        setup: function(channel) {
            return channel.assertQueue(q, { durable: true });
        }
    });

    console.log('Starting message stream')
    while (true) {
        await channelWrapper.sendToQueue(q, { value: Math.random() })
        await sleep(100)
    }
}

main()

let amqp = require('amqp-connection-manager');
let q = 'tasks_app';

let main = async () => {

    var connection = amqp.connect([
        'amqp://localhost:5672',
        'amqp://localhost:5673',
        'amqp://localhost:5674',
    ]);

    var channelWrapper = connection.createChannel({
        json: true,
        setup: function(channel) {
            return channel.assertQueue(q, { durable: true });
        }
    });

    channelWrapper.addSetup(function(channel) {
        return Promise.all([
            channel.consume(q, (msg) => {
                console.log(msg.content.toString())
            }, {noAck: true , exclusive: false })
        ])
    });
}

main()

connection.createConfirmChannel(function(err2, channel) {

    if (err2){
    	throw err2;
    }

    console.info('Channel created');

    var queue = 'quorum_q1';

    var msg = JSON.stringify({
    	'text': 'Message 1'
    });

    console.log(" [x] Sent %s", msg);

    channel.sendToQueue(queue, Buffer.from(msg), {}, errorCallback(msg));

    channel.waitForConfirms(function(err3) {

        if (err3) {
        	return console.log('Not confirm all message');
        }

        console.log('All messages confirm');
    });
});

Connected
Channel created
 [x] Sent {"text":"Message 1"}
{"text":"Message 1"} - confirm
All messages confirm

docker stop mle_rabbit2_1

docker ps

node quorum_producer.js

Connected
Channel created
 [x] Sent {"text":"Message 1"}
{"text":"Message 1"} - confirm
All messages confirm

docker stop mle_rabbit3_1

node quorum_producer.js

Connected
Channel created
 [x] Sent {"text":"Message 1"}
Message: {"text":"Message 1"} - NOT confirm
Not confirm all message