Help me een Ruby-script implementeren dat integreert met een berichtenwachtrijsysteem
description
Door een berichtenwachtrijsysteem te gebruiken, kan mijn toepassing asynchrone verwerking afhandelen, de fouttolerantie verbeteren en efficiënter schalen. Dit leidt tot betere prestaties en responsiviteit.
prompt
try_prompt
Ik heb hulp nodig bij het schrijven van een Ruby-script dat communiceert met een berichtenwachtrijsysteem, zoals RabbitMQ of Kafka. Geef aan welke berichtenwachtrij ik wil gebruiken: {{berichtwa ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een basisvoorbeeld van een Ruby-script dat communiceert met RabbitMQ, gebruikmakend van de `bunny`-gem. Het script laat zien hoe je berichten in JSON-formaat verzendt en ontvangt, met foutafhandeling en best practices.
1. Installeer eerst de benodigde gem:
```bash
gem install bunny json
```
2. Ruby-script voorbeeld:
```ruby
require 'bunny'
require 'json'
# Configuratie
RABBITMQ_URL = 'amqp://localhost' # Pas dit aan indien nodig
QNAME = 'mijn_queue'
# Verbinding maken met RabbitMQ
begin
connection = Bunny.new(RABBITMQ_URL)
connection.start
channel = connection.create_channel
queue = channel.queue(QNAME, durable: true)
rescue Bunny::Error => e
puts "Fout bij verbinden met RabbitMQ: #{e.message}"
exit 1
end
# Verzenden van berichten
def verzend_bericht(queue, data)
begin
json_data = data.to_json
queue.publish(json_data, persistent: true)
puts "Bericht verzonden: #{json_data}"
rescue StandardError => e
puts "Fout bij het verzenden van bericht: #{e.message}"
end
end
# Ontvangen van berichten
def ontvang_berichten(queue)
begin
puts "Wacht op berichten..."
queue.subscribe(block: true, manual_ack: true) do |delivery_info, properties, payload|
begin
bericht = JSON.parse(payload)
# Verwerk het bericht hier
puts "Ontvangen bericht: #{bericht}"
# Ack het bericht na succesvolle verwerking
channel.ack(delivery_info.delivery_tag)
rescue JSON::ParserError => e
puts "Fout bij parseren van JSON: #{e.message}"
# Doe geen ACK zodat het bericht opnieuw kan worden afgeleverd of verwerk anders
channel.reject(delivery_info.delivery_tag, requeue: false)
end
end
rescue Bunny::Error => e
puts "Fout bij het ontvangen van berichten: #{e.message}"
end
end
# Voorbeeld gebruik
# Berichten verzenden
data = { actie: 'verzend', inhoud: 'Hallo wereld' }
verzend_bericht(queue, data)
# Ontvangen berichten
# ontvang_berichten(queue)
# Sluit verbinding af bij afsluiten
at_exit do
connection.close if connection && connection.open?
end
```
**Samenvatting van best practices:**
- Gebruik `persistent: true` bij het publiceren voor duurzamere berichten.
- Handhaaf foutafhandeling bij verbinding, verzenden en ontvangen.
- Gebruik `manual_ack: true` en bevestig berichten na succesvolle verwerking.
- Verwerk en parseer JSON-berichten veilig, met foutcontrole.
- Sluit de verbinding netjes af bij afsluiten.
Mocht je verdere aanpassingen wensen of hulp bij een specifiek onderdeel, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Hier is een uitgebreid Ruby-voorbeeldscript voor RabbitMQ met JSON-berichten:
## Vereiste gem installeren
```bash
gem install bunny
```
## Ruby Script
```ruby
require 'bunny'
require 'json'
require 'logger'
class RabbitMQHandler
def initialize(connection_params = {})
@connection_params = {
host: 'localhost',
port: 5672,
user: 'guest',
password: 'guest',
vhost: '/'
}.merge(connection_params)
@logger = Logger.new(STDOUT)
@connection = nil
@channel = nil
end
def connect
begin
@connection = Bunny.new(@connection_params)
@connection.start
@channel = @connection.create_channel
# Bevestigingsmodus inschakelen voor betrouwbare levering
@channel.confirm_select
@logger.info("Verbonden met RabbitMQ: #{@connection_params[:host]}")
true
rescue Bunny::TCPConnectionFailed => e
@logger.error("Kan niet verbinden met RabbitMQ: #{e.message}")
false
rescue StandardError => e
@logger.error("Onverwachte fout bij verbinden: #{e.message}")
false
end
end
def setup_queue(queue_name = 'task_queue', durable: true)
begin
queue = @channel.queue(queue_name, durable: durable)
# Prefetch instellen voor eerlijke verdeling
@channel.prefetch(1)
@logger.info("Wachtrij '#{queue_name}' is klaar")
queue
rescue StandardError => e
@logger.error("Fout bij opzetten wachtrij: #{e.message}")
nil
end
end
def publish_message(queue_name, message, persistent: true)
return unless @channel
begin
queue = setup_queue(queue_name)
# JSON-bericht valideren
json_message = validate_and_serialize_json(message)
return unless json_message
properties = { persistent: persistent }
queue.publish(json_message, properties)
# Wacht op bevestiging van broker
@channel.wait_for_confirms
@logger.info("Bericht gepubliceerd naar '#{queue_name}': #{message}")
true
rescue Bunny::ConnectionClosedError => e
@logger.error("Verbinding gesloten tijdens publiceren: #{e.message}")
false
rescue StandardError => e
@logger.error("Fout bij publiceren bericht: #{e.message}")
false
end
end
def consume_messages(queue_name, &block)
return unless @channel
begin
queue = setup_queue(queue_name)
@logger.info("Wacht op berichten van '#{queue_name}'...")
queue.subscribe(manual_ack: true, block: false) do |delivery_info, properties, body|
begin
# JSON-bericht parsen
message = parse_json_message(body)
if message
# Verwerkingscallback aanroepen
block.call(message)
# Bevestig verwerking
@channel.ack(delivery_info.delivery_tag)
@logger.info("Bericht verwerkt: #{delivery_info.delivery_tag}")
else
# Afwijzen bij ongeldig JSON
@channel.nack(delivery_info.delivery_tag)
@logger.error("Ongeldig JSON-bericht afgewezen")
end
rescue StandardError => e
@logger.error("Fout bij verwerken bericht: #{e.message}")
# Bericht opnieuw in wachtrij plaatsen
@channel.nack(delivery_info.delivery_tag, false, true)
end
end
# Houd verbinding open
sleep
rescue StandardError => e
@logger.error("Fout bij consumeren berichten: #{e.message}")
end
end
def close
begin
@channel.close if @channel
@connection.close if @connection
@logger.info("Verbinding met RabbitMQ gesloten")
rescue StandardError => e
@logger.error("Fout bij sluiten verbinding: #{e.message}")
end
end
private
def validate_and_serialize_json(message)
if message.is_a?(String)
# Valideer of het geldige JSON is
JSON.parse(message)
message
else
JSON.generate(message)
end
rescue JSON::ParserError => e
@logger.error("Ongeldig JSON-formaat: #{e.message}")
nil
end
def parse_json_message(body)
JSON.parse(body)
rescue JSON::ParserError => e
@logger.error("Kan JSON-bericht niet parsen: #{e.message}")
nil
end
end
# Gebruiksvoorbeeld
if __FILE__ == $0
handler = RabbitMQHandler.new
# Verbind met RabbitMQ
unless handler.connect
puts "Kan niet verbinden met RabbitMQ. Script stopt."
exit 1
end
# Voorbeeld: Bericht publiceren
message_data = {
id: SecureRandom.uuid,
type: 'user_registration',
timestamp: Time.now.iso8601,
data: {
user_id: 12345,
email: 'gebruiker@voorbeeld.nl',
name: 'Jan Jansen'
}
}
# Publiceren
handler.publish_message('user_events', message_data)
# Consumeren (in aparte thread voor demo)
Thread.new do
handler.consume_messages('user_events') do |message|
puts "Ontvangen bericht: #{message}"
# Simuleer verwerking
sleep(2)
puts "Bericht verwerkt: #{message['id']}"
end
end
# Wacht op interrupt signal
begin
loop { sleep 1 }
rescue Interrupt
puts "\nScript gestopt door gebruiker"
ensure
handler.close
end
end
```
## Belangrijkste kenmerken:
### 1. **Foutafhandeling**
- Verbindingsfouten
- JSON parseerfouten
- Berichtverwerkingsfouten
- Netwerkfouten
### 2. **Beste praktijken**
- **Bevestigingsmodus** voor betrouwbare levering
- **Persistente berichten** om verlies te voorkomen
- **Prefetch** voor eerlijke werklastverdeling
- **Handmatige ACK/NACK** voor controle over verwerking
- **Durable queues** om berichten niet te verliezen bij herstart
### 3. **JSON-bericht structuur**
```ruby
{
"id": "unieke-identifier",
"type": "event_type",
"timestamp": "2024-01-01T12:00:00Z",
"data": {
// applicatie-specifieke data
}
}
```
### 4. **Uitvoering**
```bash
ruby rabbitmq_handler.rb
```
Dit script biedt een robuuste basis voor RabbitMQ-integratie met juiste foutafhandeling en volgt industry best practices voor berichtverwerking.