• Make sure you have Supabase up and running.
• RabbitMQ should be running too.
• Node.js needs to be installed on your computer.
• You should know a bit about JavaScript and PostgreSQL.

1. Head over to the Supabase website and either sign in or create an account.
2. Start a new project and jot down the project URL and API keys from the settings.

1. Install RabbitMQ on your server or locally by following the official installation guide.
2. Start the RabbitMQ service:
   ```sh
   sudo systemctl start rabbitmq-server
   sudo systemctl enable rabbitmq-server
   ```
3. Check if RabbitMQ is running by going to http://localhost:15672. Use the default login (guest/guest).

1. Open the Supabase dashboard.
2. Go to the SQL Editor and create a new table, like this:
   ```sql
   create table messages (
   id serial primary key,
   content text,
   created_at timestamp default now()
   );
   ```
3. Make sure to turn on Realtime for the messages table by tweaking its settings.

1. Make a new directory for your project and go into it:
   ```sh
   mkdir supabase-rabbitmq
   cd supabase-rabbitmq
   ```
2. Start a new Node.js project:
   ```sh
   npm init -y
   ```
3. Install the necessary packages:
   ```sh
   npm install @supabase/supabase-js amqplib dotenv
   ```

1. Create a .env file in the root of your project and add these variables:
   ```
   SUPABASE_URL=your-supabase-url
   SUPABASE_KEY=your-supabase-key
   RABBITMQ_URL=amqp://localhost
   ```

1. Create a file called supabaseClient.js and set up Supabase:
   ```javascript
   const { createClient } = require('@supabase/supabase-js');
   require('dotenv').config();

   const supabaseUrl = process.env.SUPABASE_URL;
   const supabaseKey = process.env.SUPABASE_KEY;

   const supabase = createClient(supabaseUrl, supabaseKey);

   module.exports = supabase;
   ```

1. Create a file named rabbitmqClient.js to manage the RabbitMQ connection:
   ```javascript
   const amqp = require('amqplib/callback_api');
   require('dotenv').config();

   const rabbitMqUrl = process.env.RABBITMQ_URL;

   amqp.connect(rabbitMqUrl, (error0, connection) => {
   if (error0) {
   throw error0;
   }
   connection.createChannel((error1, channel) => {
   if (error1) {
   throw error1;
   }
   const queue = 'messages_queue';
   channel.assertQueue(queue, { durable: false });
   
   console.log('Waiting for messages in %s', queue);
   
   channel.consume(queue, (msg) => {
   console.log('Received:', msg.content.toString());
   // Perform the action based on the received message
   }, { noAck: true });
   });
   });
   ```

1. Create index.js to listen for changes in the Supabase table and publish to RabbitMQ:
   ```javascript
   const supabase = require('./supabaseClient');
   const amqp = require('amqplib/callback_api');
   const QUEUE = 'messages_queue';

   require('dotenv').config();
   const rabbitMqUrl = process.env.RABBITMQ_URL;

   amqp.connect(rabbitMqUrl, (error0, connection) => {
   if (error0) {
   throw error0;
   }
   connection.createChannel((error1, channel) => {
   if (error1) {
   throw error1;
   }
   
   supabase
   .from('messages')
   .on('INSERT', (payload) => {
   const msg = JSON.stringify(payload.new);
   channel.sendToQueue(QUEUE, Buffer.from(msg));
   console.log('Sent to RabbitMQ:', msg);
   })
   .subscribe();
   });
   });
   ```

To run the project:

node index.js

This setup will listen for new messages in the Supabase messages table and publish them to the RabbitMQ queue. The RabbitMQ consumer will then receive and log these messages.