अमेजन एसक्यूएस में एक मृत पत्र कतार से मूल कतार में संदेशों को स्थानांतरित करने के लिए सबसे अच्छा अभ्यास क्या है?
क्या यह होगा
या एक सरल तरीका है?
इसके अलावा, क्या AWS के पास अंततः DLQ से संदेश स्थानांतरित करने के लिए कंसोल में एक उपकरण होगा?
जवाबों:
यहाँ एक त्वरित हैक है। यह निश्चित रूप से सबसे अच्छा या अनुशंसित विकल्प नहीं है।
वहाँ कुछ स्क्रिप्ट हैं जो आपके लिए ऐसा करती हैं:
# install
npm install replay-aws-dlq;
# use
npx replay-aws-dlq [source_queue_url] [dest_queue_url]
# compile: https://github.com/mercury2269/sqsmover#compiling-from-source
# use
sqsmover -s [source_queue_url] -d [dest_queue_url]
npx replay-aws-dlq DL_URI MAIN_URI
संदेश को स्थानांतरित करने की आवश्यकता नहीं है क्योंकि यह बहुत सी अन्य चुनौतियों जैसे डुप्लिकेट संदेश, पुनर्प्राप्ति परिदृश्य, खोया हुआ संदेश, डी-डुप्लीकेशन चेक और आदि के साथ आएगा।
यहाँ समाधान है जिसे हमने लागू किया है -
आमतौर पर, हम क्षणिक त्रुटियों के लिए DLQ का उपयोग करते हैं, स्थायी त्रुटियों के लिए नहीं। तो नीचे दृष्टिकोण लिया -
DLQ से एक नियमित कतार की तरह संदेश पढ़ें
लाभफिर उसी कोड को फॉलो करें जो रेगुलर कतार फॉलो कर रहा है।
नौकरी निरस्त करने के मामले में अधिक विश्वसनीय या प्रक्रिया करते समय प्रक्रिया समाप्त हो गई (उदाहरण के लिए हत्या या प्रक्रिया समाप्त हो गई)
लाभसंदेश की दृश्यता बढ़ाएं ताकि कोई भी थ्रेड प्रक्रिया न करें।
फायदासंदेश तभी डिलीट करें जब या तो कोई स्थायी त्रुटि हो या सफल हो।
फायदायहाँ:
import boto3
import sys
import Queue
import threading
work_queue = Queue.Queue()
sqs = boto3.resource('sqs')
from_q_name = sys.argv[1]
to_q_name = sys.argv[2]
print("From: " + from_q_name + " To: " + to_q_name)
from_q = sqs.get_queue_by_name(QueueName=from_q_name)
to_q = sqs.get_queue_by_name(QueueName=to_q_name)
def process_queue():
while True:
messages = work_queue.get()
bodies = list()
for i in range(0, len(messages)):
bodies.append({'Id': str(i+1), 'MessageBody': messages[i].body})
to_q.send_messages(Entries=bodies)
for message in messages:
print("Coppied " + str(message.body))
message.delete()
for i in range(10):
t = threading.Thread(target=process_queue)
t.daemon = True
t.start()
while True:
messages = list()
for message in from_q.receive_messages(
MaxNumberOfMessages=10,
VisibilityTimeout=123,
WaitTimeSeconds=20):
messages.append(message)
work_queue.put(messages)
work_queue.join()
कोड की एक पंक्ति लिखे बिना इसे प्राप्त करने का एक और तरीका है। अपने वास्तविक कतार नाम पर विचार करें SQS_Queue और इसके लिए DLQ SQS_DLQ है। अब इन चरणों का पालन करें:
aws sqs receive-message --queue-url <url of DLQ> --max-number-of-messages 10। चूंकि अधिकतम संदेश आप 10 पर कैप पढ़ सकते हैं, इसलिए मैं सुझाव देता हूं कि कमांड को इस तरह से for i in {1..1000}; do <CMD>; done
मैंने ऐसा करने के लिए एक छोटी सी स्क्रिप्ट लिखी है, boto3 lib का उपयोग करके:
conf = {
"sqs-access-key": "",
"sqs-secret-key": "",
"reader-sqs-queue": "",
"writer-sqs-queue": "",
"message-group-id": ""
}
import boto3
client = boto3.client(
'sqs',
aws_access_key_id = conf.get('sqs-access-key'),
aws_secret_access_key = conf.get('sqs-secret-key')
)
while True:
messages = client.receive_message(QueueUrl=conf['reader-sqs-queue'], MaxNumberOfMessages=10, WaitTimeSeconds=10)
if 'Messages' in messages:
for m in messages['Messages']:
print(m['Body'])
ret = client.send_message( QueueUrl=conf['writer-sqs-queue'], MessageBody=m['Body'], MessageGroupId=conf['message-group-id'])
print(ret)
client.delete_message(QueueUrl=conf['reader-sqs-queue'], ReceiptHandle=m['ReceiptHandle'])
else:
print('Queue is currently empty or messages are invisible')
break
आप इस लिंक में इस स्क्रिप्ट को प्राप्त कर सकते हैं
यह स्क्रिप्ट मूल रूप से किसी भी मनमाने कतारों के बीच संदेशों को स्थानांतरित कर सकती है। और यह पेंडो कतारों का समर्थन करता है और साथ ही आप message_group_idक्षेत्र की आपूर्ति कर सकते हैं ।
हम src कतार से tgt कतार तक संदेश को फिर से भेजने के लिए निम्नलिखित स्क्रिप्ट का उपयोग करते हैं:
फ़ाइल का नाम: redrive.py
उपयोग: python redrive.py -s {source queue name} -t {target queue name}
'''
This script is used to redrive message in (src) queue to (tgt) queue
The solution is to set the Target Queue as the Source Queue's Dead Letter Queue.
Also set Source Queue's redrive policy, Maximum Receives to 1.
Also set Source Queue's VisibilityTimeout to 5 seconds (a small period)
Then read data from the Source Queue.
Source Queue's Redrive Policy will copy the message to the Target Queue.
'''
import argparse
import json
import boto3
sqs = boto3.client('sqs')
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--src', required=True,
help='Name of source SQS')
parser.add_argument('-t', '--tgt', required=True,
help='Name of targeted SQS')
args = parser.parse_args()
return args
def verify_queue(queue_name):
queue_url = sqs.get_queue_url(QueueName=queue_name)
return True if queue_url.get('QueueUrl') else False
def get_queue_attribute(queue_url):
queue_attributes = sqs.get_queue_attributes(
QueueUrl=queue_url,
AttributeNames=['All'])['Attributes']
print(queue_attributes)
return queue_attributes
def main():
args = parse_args()
for q in [args.src, args.tgt]:
if not verify_queue(q):
print(f"Cannot find {q} in AWS SQS")
src_queue_url = sqs.get_queue_url(QueueName=args.src)['QueueUrl']
target_queue_url = sqs.get_queue_url(QueueName=args.tgt)['QueueUrl']
target_queue_attributes = get_queue_attribute(target_queue_url)
# Set the Source Queue's Redrive policy
redrive_policy = {
'deadLetterTargetArn': target_queue_attributes['QueueArn'],
'maxReceiveCount': '1'
}
sqs.set_queue_attributes(
QueueUrl=src_queue_url,
Attributes={
'VisibilityTimeout': '5',
'RedrivePolicy': json.dumps(redrive_policy)
}
)
get_queue_attribute(src_queue_url)
# read all messages
num_received = 0
while True:
try:
resp = sqs.receive_message(
QueueUrl=src_queue_url,
MaxNumberOfMessages=10,
AttributeNames=['All'],
WaitTimeSeconds=5)
num_message = len(resp.get('Messages', []))
if not num_message:
break
num_received += num_message
except Exception:
break
print(f"Redrive {num_received} messages")
# Reset the Source Queue's Redrive policy
sqs.set_queue_attributes(
QueueUrl=src_queue_url,
Attributes={
'VisibilityTimeout': '30',
'RedrivePolicy': ''
}
)
get_queue_attribute(src_queue_url)
if __name__ == "__main__":
main()
मूल उपभोक्ता विभिन्न प्रयासों के बाद संदेश का उपभोग करने में विफल रहने पर ही DLQ खेल में आता है। हम संदेश को नष्ट नहीं करना चाहते क्योंकि हम मानते हैं कि हम अभी भी इसके साथ कुछ कर सकते हैं (शायद फिर से प्रक्रिया करने या इसे लॉग इन करने या कुछ आँकड़े एकत्र करने का प्रयास करें) और हम बार-बार इस संदेश का सामना नहीं करना चाहते हैं और करने की क्षमता को रोकना चाहते हैं इसके पीछे अन्य संदेशों को संसाधित करें।
DLQ एक और कतार के अलावा कुछ भी नहीं है। जिसका अर्थ है कि हमें DLQ के लिए एक उपभोक्ता लिखने की आवश्यकता होगी जो आदर्श रूप से कम बार (मूल कतार की तुलना में) चलेगा जो DLQ से खपत करेगा और मूल कतार में वापस संदेश का उत्पादन करेगा और इसे DLQ से हटा देगा - यदि इच्छित व्यवहार और हम सोचते हैं मूल उपभोक्ता अब इसे फिर से संसाधित करने के लिए तैयार होगा। यह ठीक होना चाहिए अगर यह सिलसिला कुछ समय के लिए जारी रहता है, क्योंकि हमें अब मैन्युअल रूप से निरीक्षण करने और आवश्यक बदलाव करने और संदेश खोए बिना मूल उपभोक्ता के दूसरे संस्करण को तैनात करने का अवसर मिलता है (बेशक संदेश प्रतिधारण अवधि के भीतर - जो 4 दिनों का है चूक)।
अच्छा होगा यदि AWS इस क्षमता को बॉक्स से बाहर प्रदान करता है, लेकिन मैं इसे अभी तक नहीं देखता हूं - वे इसे अंतिम उपयोगकर्ता के लिए छोड़ रहे हैं ताकि वे इसे उचित महसूस कर सकें।