SQS maxNumberOfMessages


11

जावा क्लाइंट एप्लिकेशन का उपयोग करते हुए मैं संदेशों के लिए एक एसक्यूएस कतार का उपयोग कर रहा हूं। कतार में परीक्षण के लिए सेटअप के रूप में 12,000 संदेश हैं। मैं aj-java-sdk के साथ openJDK का उपयोग कर रहा हूं नवीनतम (software.amazon.awssdk 2.10.62) pom.xml को और नीचे दिखाया गया है।

मैं जो मुद्दा देख रहा हूं वह यह है कि सेट करने के बावजूद मैक्सनंबरऑफ़मैसेज (10) मुझे केवल 3 ही मिलते हैं। मैं समझता हूं कि यह अधिकतम संदेशों की संख्या की गारंटी नहीं है, हालांकि संदेशों की संख्या में कोई छूट नहीं है। यह हमेशा 3 है।

AWS डॉक्यूमेंटेशन: MaxNumberOfMessages अधिकतम संदेशों की वापसी। अमेज़न SQS इस मूल्य से अधिक संदेश कभी नहीं लौटाता है (हालाँकि, कम संदेश वापस आ सकते हैं)। मान्य मान: 1 से 10. डिफ़ॉल्ट: 1. प्रकार: पूर्णांक आवश्यक: नहीं

शॉर्ट पोलिंग का उपयोग कर संदेश भेजना

जब आप लघु मतदान का उपयोग करके एक कतार से संदेशों का उपभोग करते हैं, तो अमेज़ॅन एसक्यूएस अपने सर्वरों के सबसेट (एक भारित यादृच्छिक वितरण के आधार पर) का नमूना लेता है और केवल उन सर्वरों से संदेश देता है। इस प्रकार, एक विशेष ReceiveMessage अनुरोध आपके सभी संदेशों को वापस नहीं कर सकता है। हालाँकि, यदि आपके पास अपनी कतार में 1,000 से कम संदेश हैं, तो बाद का अनुरोध आपके संदेशों को वापस कर देगा। यदि आप अपनी कतारों से उपभोग करते रहते हैं, तो अमेज़ॅन एसक्यूएस अपने सभी सर्वरों का नमूना लेता है, और आपको अपने सभी संदेश प्राप्त होते हैं।

इसलिए हमने जावा में दो क्लाइंट्स का परीक्षण किया है और दोनों पुराने अर्स sdk और नए को समान परिणामों के साथ उपयोग किया है। हमेशा केवल 3 संदेश वापस।

दिलचस्प बात यह है कि यदि आवेदन को बाहरी रूप से चलाने के बजाय (मेरे शक्तिशाली डेस्कटॉप पर) आप इसे AWS लैंबडा के रूप में चलाते हैं तो आपको 10 संदेश मिलते हैं। यह लैम्ब्डा परीक्षण एक सहकर्मी द्वारा जावास्क्रिप्ट का उपयोग करके किया गया था।

तो सवाल यह है कि हमें केवल 3 संदेश प्रति अनुरोध क्यों मिलते हैं और लंबोदर के भीतर आपको 10 मिल सकते हैं।

यह देखते हुए कि अमेजन लाभ के आधार पर भारित यादृच्छिक वितरण है =))

SQS टेस्ट विधि:

public void SQStart()
{
    AwsBasicCredentials awsCreds = AwsBasicCredentials.create("accessKeyID", "secretKeyID");
    AwsCredentialsProvider creds = StaticCredentialsProvider.create(awsCreds);
    SqsClient sqs = SqsClient.builder().credentialsProvider(creds).region(Region.EU_WEST_1).build();
    GetQueueUrlRequest getQueueRequest = GetQueueUrlRequest.builder()
            .queueName(QUEUE_NAME)
            .build();
    String queueUrl = sqs.getQueueUrl(getQueueRequest).queueUrl();

    for (int x =1; x < 100; x++) {
        ReceiveMessageRequest receiveMessageRequest = ReceiveMessageRequest.builder()
                .queueUrl(queueUrl)
                .maxNumberOfMessages(10)
                .build();


        List<Message> messages = sqs.receiveMessage(receiveMessageRequest).messages();
        if (messages.size() > 3 ) {
            System.out.println("YEY More than 3 Messages: "+ messages.size());
        }
    }
}

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>groupId</groupId>
    <artifactId>SQSTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.10.62</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>

            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>sqs</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.9</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.10</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk-s3</artifactId>
            <version>1.11.720</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.6.1</version>
        </dependency>
    </dependencies>
</project>

बस एक विचार है, लेकिन क्या आपने AWS पर ही कतार के विन्यास की जाँच की है? शायद यह एक maxNumberOfMessages संपत्ति के साथ सेटअप किया गया था जो आपको java क्लाइंट में सेट की गई प्राथमिकता से अधिक मिल सकती है? चूंकि यह जावास्क्रिप्ट लैम्ब्डा में काम करता है, यह अजीब होगा, लेकिन फिर भी एक शॉट के लायक :)
niekname

जवाबों:


9

यह देखते हुए कि अमेजन लाभ के आधार पर भारित यादृच्छिक वितरण है =))

यह स्पष्ट है कि यहां आपका लक्ष्य लागतों को कम करना है, चाहे वह एसक्यूएस के लिए कम अनुरोध भेजकर हो, या उपलब्ध संदेशों की अधिकतम मात्रा को वितरित करने के लिए एसक्यूएस को मजबूर करने से हो।

जैसा कि आपने अपने प्रश्न में कहा है, SQS के पास उपलब्ध संदेशों की अधिकतम मात्रा देने का कोई दायित्व नहीं है। हालाँकि, कुछ ऐसा है जिसके बारे में मैं आपको सूचित करना चाहता हूँ, यह मानते हुए कि आप पहले से ही इसके बारे में नहीं जानते हैं।


लंबा मतदान

अमेज़न की सरल कतार सेवा की डेवलपर गाइड बताती है:

एक कतार से संदेशों का उपभोग करने की प्रक्रिया इस बात पर निर्भर करती है कि आप कम या लंबे मतदान का उपयोग करते हैं। डिफ़ॉल्ट रूप से, अमेज़ॅन एसक्यूएस शॉर्ट पोलिंग का उपयोग करता है , यह निर्धारित करने के लिए कि क्या कोई संदेश प्रतिक्रिया के लिए उपलब्ध है, यह निर्धारित करने के लिए अपने सर्वर के केवल सबसेट (भारित यादृच्छिक वितरण के आधार पर) का उपयोग करता है। आप अपने उपभोक्ताओं को कतार में आते ही संदेश प्राप्त करने की अनुमति देते हुए अपनी लागत को कम करने के लिए लंबे मतदान का उपयोग कर सकते हैं ।

आपने SQS को जो संदेश भेजे हैं वे सभी अलग-अलग सर्वर पर संग्रहीत किए जा सकते हैं। जैसा कि प्रलेखन में कहा गया है, यदि आपकी कतार छोटी मतदान का उपयोग करने के लिए निर्धारित की जाती है, तो केवल सर्वरों के एक सबसेट की पुष्टि की जा सकती है । मेरा अनुमान है कि आप receiveMessageकेवल आह्वान करते समय अशुभ थे3 हर बार लौटाए गए थे।

यदि हम एक ही दस्तावेज़ पृष्ठ पर लंबे मतदान के लाभों को देखते हैं , तो यह बताता है:

लंबा मतदान निम्नलिखित लाभ प्रदान करता है:

  • प्रतिक्रिया भेजने से पहले एक कतार में संदेश उपलब्ध होने तक अमेज़ॅन एसक्यूएस की अनुमति देकर खाली प्रतिक्रियाओं को हटा दें। जब तक कनेक्शन का समय नहीं निकलता, तब तक ReceiveMessage अनुरोध की प्रतिक्रिया में कम से कम एक उपलब्ध संदेश होता है, जो ReceiveMessage कार्रवाई में निर्दिष्ट संदेशों की अधिकतम संख्या तक होता है।

  • अमेज़ॅन SQS सर्वर के सबसेट के बजाय सभी को क्वेरी करके झूठी खाली प्रतिक्रियाओं को हटा दें।

दूसरी गोली यहाँ बहुत महत्वपूर्ण है। भले ही आप खाली प्रतिक्रियाएं नहीं देख रहे हों, लेकिन सर्वर पर संग्रहीत अधिक संदेश मौजूद हो सकते हैं, जिनकी देखभाल नहीं की जा रही है। यदि आप लंबे मतदान को सक्षम करते हैं, तो आपको उम्मीद है कि वापस लौटे संदेशों की मात्रा में वृद्धि देखी जानी चाहिए, यह मानते हुए कि कुल मिलाकर 3 से अधिक सर्वर हैं।

इसलिए, मेरा सुझाव है कि अपनी कतार में लंबे मतदान को सक्षम करें। ऐसा करने के लिए, सेटिंग अप लॉन्ग पोलिंग पेज देखें।


जैसा कि डेविलकोड ने अपनी टिप्पणी में उल्लेख किया है , वह एक मानक कतार के बजाय एक फीफो कतार का उपयोग करके, और उस पर लंबे मतदान को सक्षम करके अपने मुद्दे को हल करने में सक्षम था।


हमने लंबे मतदान के साथ एक ही परीक्षण किया है और एक ही परिणाम मिला है। हमारे पास कतार में 12,000 संदेश और मतदान सेट 20 सेकंड के लिए था। हमें अभी भी केवल तीन संदेश मिले हैं। यदि हमें लंबे और छोटे मतदान के साथ तीन संदेश मिलते हैं, तो लंबे मतदान का उपयोग करने का कोई कारण नहीं है (सिवाय इसके कि कतार संदेशों के इंतजार में खाली है)। दुर्भाग्य से हम लागत और गति को संतुलित करने की कोशिश कर रहे हैं। दुर्भाग्य से हमारे पास केवल सीमित रीड थ्रेड्स हैं जिनका उपयोग हम (हार्डवेयर के कारण) कर सकते हैं, इसलिए प्रति कॉल हम कितने संदेशों को खींच सकते हैं, यह एक सीमित कारक है कि हम कितनी तेजी से इसे प्रोसेस कर सकते हैं।
डेविलकोड

@DevilCode मैं अपने मुद्दे को लंबे समय तक मतदान के साथ सक्षम करने में सक्षम नहीं था। क्या आपकी कतार एक मानक कतार या फीफो कतार है? आप यह देखने के लिए AWS के साथ एक समर्थन टिकट खोलना चाहते हैं कि क्या वे अपने अंत में परिवर्तन कर सकते हैं।
जैकब

यह एक मानक कतार है। क्या आपने अपना कोड स्थानीय स्तर पर चलाया था और क्या हम जावा का उपयोग कर रहे थे?
डेविलकोड

@DevilCode मैंने एक फीफो कतार का उपयोग करके इसका परीक्षण किया। और हां, मैं अपने SQS कतार से संदेश प्राप्त करने के लिए AWS Java SDK v2 का उपयोग कर रहा हूं। मेरा कोड AWS लाम्बा फ़ंक्शन के भीतर नहीं चल रहा है।
याकूब जी

1
OK ने FIFO कतार का परीक्षण किया और हमें 10 संदेश मिले जहां मानक कतार में हमें केवल तीन मिले। अब मैं यह निष्कर्ष निकाल सकता हूं कि प्रलेखन फीफो कतार को संदर्भित करता है न कि मानक कतार को।
डेविलकोड

0

मुझे लगता है कि यह एक ऐसा ही प्रश्न है। जैकब द्वारा बताया गया है, लंबे समय तक मतदान इस मुद्दे का समाधान है।


0

लंबा मतदान:

        ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(queueUrl)
              .withWaitTimeSeconds(10)     // long poll: wait 10 seconds, max is 20 seconds
              .withMaxNumberOfMessages(10);
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.