Docker में Manticore Search के साथ शुरुआत करना

इस पोस्ट में, हम चर्चा करेंगे कि आप Manticore Search को Docker के साथ कैसे जल्दी से शुरू कर सकते हैं।

स्थापना और संचालन

आधिकारिक Docker इमेज https://hub.docker.com/r/manticoresearch/manticore/ पर होस्ट की गई हैं।
Manticore Search को शुरू करने के लिए आपको बस यह चलाना होगा:

$ docker run --name manticore -p 9306:9306 -d manticoresearch/manticore

Docker का नुस्खा github पर होस्ट किया गया है, उन लोगों के लिए जो मौजूदा इमेजेस को बढ़ाना चाहते हैं।

Manticore Search कंटेनर में स्थायी संग्रहण नहीं है और यदि कंटेनर को बंद कर दिया जाता है, तो सभी परिवर्तन खो जाते हैं। निरंतरता रखने का एक साधारण तरीका है कि हम स्थानीय मशीनों पर कई फ़ोल्डरों को माउंट करें।

जिन फ़ोल्डरों की हमें निरंतरता चाहिए, वे हैं:

  • /etc/sphinxsearch - sphinx.conf का स्थान
  • /var/lib/manticore/data - इंडेक्स फ़ाइलों के लिए उपयोग किया जाता है
  • /var/lib/manticore/log - लॉग फ़ाइलों के लिए उपयोग किया जाता है

हम अपने होम डायरेक्टरी में manticore/ फ़ोल्डर मानते हैं, जहाँ हम etc/, data/ और logs/ फ़ोल्डर बनाएंगे, साथ ही ~/manticore/etc/ में एक मान्य sphinx.conf जोड़ेंगे। हम नुस्खा रिपॉजिटरी में शामिल sphinx.conf का उपयोग कर सकते हैं।
हम रन कमांड में माउंट जोड़ते हैं:

$ docker run --name manticore -v ~/manticore/etc/:/etc/sphinxsearch/ -v ~/manticore/data/:/var/lib/manticore/data -v ~/manticore/logs/:/var/lib/manticore/log -p 9306:9306 -d manticoresearch/manticore

कंटेनर को बस यह करके बंद किया जा सकता है:

$ docker stop manticore

Docker इमेज में indexer और indextoo उपयोगिताएं भी आती हैं, जिन्हें Docker के exec कमांड के साथ चलाया जा सकता है:

$ docker exec -it manticore indexer --all --rotate

क्वेरी चलाना

कनेक्ट करने और कुछ परीक्षण करने का सरल तरीका SphinxQL प्रोटोकॉल का उपयोग करना है। इसके लिए, आपको एक mysql कमांड लाइन क्लाइंट की आवश्यकता है।

जबकि यह MySQL प्रोटोकॉल को लागू करता है, SphinxQL MySQL के वाक्य रचना के साथ 100% संगत नहीं है। कुछ विशेष एक्सटेंशन हैं, जैसे MATCH क्लॉज़ [Manticore में सबसे शक्तिशाली चीज़] या WITHIN GROUP BY और MySQL में उपलब्ध कई फ़ंक्शन लागू नहीं किए गए हैं (या वे केवल MySQL कनेक्टर के साथ संगतता की अनुमति देने के लिए डमी हैं जैसे) या इंडेक्स के बीच JOIN जो अभी तक समर्थित नहीं हैं।

पहले, चलिए Manticore Search से कनेक्ट करते हैं और उपलब्ध इंडेक्सेस पर एक नज़र डालते हैं:

$ mysql -P9306 -h0
mysql> SHOW TABLES;
+-------+-------------+
| Index | Type        |
+-------+-------------+
| dist1 | distributed |
| testrt| rt          |
+-------+-------------+
2 rows in set (0.00 sec)

अब चलिए अपने RT इंडेक्स पर नज़र डालते हैं:

mysql> DESCRIBE testrt;
+---------+--------+
| Field | Type     |
+---------+--------+
| id      | bigint |
| title   | field  |
| content | field  |
| gid     | uint   |
+---------+--------+
4 rows in set (0.00 sec)

चूंकि RT इंडेक्स खाली शुरू होते हैं, चलिए पहले इसमें कुछ डेटा जोड़ते हैं।

mysql> INSERT INTO testrt VALUES(1,'HP बिजनेस लैपटॉप की सूची','Elitebook Probook',10);
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO testrt VALUES(2,'Dell बिजनेस लैपटॉप की सूची','Latitude Precision Vostro',10);
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO testrt VALUES(3,'Dell गेमिंग लैपटॉप की सूची','Inspirion Alienware',20);
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO testrt VALUES(4,'Lenovo लैपटॉप की सूची','Yoga IdeaPad',30);
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO testrt VALUES(5,'ASUS अल्ट्राबुक और लैपटॉप की सूची','Zenbook Vivobook',30);
Query OK, 1 row affected (0.01 sec)

अब हमारे पास कुछ डेटा है, हम कुछ क्वेरी कर सकते हैं।

पूर्ण-पाठ खोजें विशेष क्लॉज MATCH के साथ की जाती हैं, जो मुख्य कार्यवाहक होती है।

mysql> SELECT * FROM testrt WHERE MATCH('लैपटॉप की सूची');
+------+------+
| id   | gid  |
+------+------+
| 1    | 10   |
| 2    | 10   |
| 3    | 20   |
| 5    | 30   |
+------+------+
4 rows in set (0.00 sec)

जैसा कि आप परिणाम सेट में देखते हैं, हम केवल डॉक आइडी और विशेषताओं को वापस प्राप्त कर सकते हैं। पूर्ण-पाठ फ़ील्ड के मान लौटाए नहीं जाते हैं क्योंकि टेक्स्ट केवल अनुक्रमित होता है, संग्रहित नहीं होता है, और इसे पुनर्निर्माण करना असंभव है।

अब चलिए कुछ फ़िल्टरिंग और अधिक आदेश जोड़ते हैं:

mysql> SELECT *,WEIGHT() FROM testrt WHERE MATCH('लैपटॉप की सूची') AND gid>10 ORDER BY WEIGHT() DESC,gid DESC;
+------+------+----------+
| id   | gid  | weight() |
+------+------+----------+
| 5    | 30   | 2334     |
| 3    | 20   | 2334     |
+------+------+----------+
2 rows in set (0.00 sec)

WEIGHT() फ़ंक्शन गणना किए गए मिलान स्कोर को लौटाता है। यदि कोई क्रम निर्दिष्ट नहीं किया गया है, तो परिणाम WEIGHT() द्वारा प्रदान किए गए स्कोर के द्वारा अवरोही क्रम में_sorted किया जाता है। इस उदाहरण में, हम पहले वजन के अनुसार और फिर एक पूर्णांक विशेषता द्वारा क्रम देते हैं।

ऊपर की खोज एक सरल मिलान करती है, जहाँ सभी शब्द उपस्थित होने की आवश्यकता होती है। लेकिन हम और अधिक कर सकते हैं (और यह सिर्फ एक सरल उदाहरण है):

mysql> SELECT *,WEIGHT() FROM testrt WHERE MATCH('"बिजनेस लैपटॉप की सूची"/3');
+------+------+----------+
| id   | gid  | weight() |
+------+------+----------+
| 1    | 10   | 2397     |
| 2    | 10   | 2397     |
| 3    | 20   | 2375     |
| 5    | 30   | 2375     |
+------+------+----------+
4 rows in set (0.00 sec)

mysql> SHOW META;
+---------------+----------+
| Variable_name | Value    |
+---------------+----------+
| total         | 4        |
| total_found   | 4        |
| time          | 0.000    |
| keyword[0]    | सूची     |
| docs[0]       | 5        |
| hits[0]       | 5        |
| keyword[1]    | की       |
| docs[1]       | 4        |
| hits[1]       | 4        |
| keyword[2]    | बिजनेस   |
| docs[2]       | 2        |
| hits[2]       | 2        |
| keyword[3]    | लैपटॉप  |
| docs[3]       | 5        |
| hits[3]       | 5        |
+---------------+----------+
15 rows in set (0.00 सेकंड)

यहाँ हम 4 शब्दों के लिए खोज करते हैं, लेकिन यदि केवल 3 शब्द (4 में से) पाए जाते हैं, तो भी हमें मेल मिल सकता है। खोज उन दस्तावेजों को पहले उच्च रैंक करेगी जो सभी शब्दों को शामिल करते हैं। हमने एक SHOW META कमांड भी जोड़ी है। SHOW META पिछले कार्यान्वित क्वेरी के बारे में जानकारी लौटाता है, जैसे पाए गए रिकॉर्ड की संख्या (total_found में), निष्पादन समय (time में) और खोज के कीवर्ड के बारे में आंकड़े।

सादा अनुक्रमणिका का उपयोग करना

RT के विपरीत, एक सादा अनुक्रमणिका के लिए भी एक स्रोत कॉन्फ़िगर करना आवश्यक है। हमारे उदाहरण में हम एक MySQL स्रोत का उपयोग कर रहे हैं।

अपने sphinx.conf में जोड़ें:

source src1
{
type = mysql

sql_host = 172.17.0.1
sql_user = test
sql_pass =
sql_db = test
sql_port = 3306 # वैकल्पिक, डिफ़ॉल्ट 3306 है

sql_query_pre = SET NAMES utf8

sql_query = \
SELECT id, group_id, UNIX_TIMESTAMP(date_added) AS date_added, title, content \
FROM documents

sql_attr_uint = group_id
sql_attr_timestamp = date_added

}
index test1
{

source = src1
path = /var/lib/manticore/data/test1
min_word_len = 1

}

इस उदाहरण में हम मानते हैं कि MySQL स्थानीय होस्ट पर चल रहा है, लेकिन चूंकि Manticore Search एक Docker कंटेनर के अंदर चलता है, हमें ‘172.17.0.1’ का उपयोग करना होगा, जो Docker होस्ट का स्थिर IP पता है। अधिक जानकारी के लिए, कृपया Docker दस्तावेज़ देखें। आपको MySQL क्रेडेंशियल्स को भी तदनुसार समायोजित करना होगा।

उसके बाद हम sql_query की तलाश करते हैं, जो डेटा को प्राप्त करने वाला क्वेरी है

sql_query = \
SELECT id, group_id, UNIX_TIMESTAMP(date_added) AS date_added, title, content \
FROM documents

और हम इस SQL स्निपेट का उपयोग करके MySQL में अपनी परीक्षण तालिका बनाएंगे:

DROP TABLE IF EXISTS test.documents;
CREATE TABLE test.documents
(
id INTEGER PRIMARY KEY NOT NULL AUTO_INCREMENT,
group_id INTEGER NOT NULL,
date_added DATETIME NOT NULL,
title VARCHAR(255) NOT NULL,
content TEXT NOT NULL
);

INSERT INTO test.documents ( id, group_id, date_added, title, content ) VALUES
( 1, 1, NOW(), 'test one', 'this is my test document number one. also checking search within phrases.' ),
( 2, 1, NOW(), 'test two', 'this is my test document number two' ),
( 3, 2, NOW(), 'another doc', 'this is another group' ),
( 4, 2, NOW(), 'doc number four', 'this is to test groups' );

यदि आप एक अन्य तालिका का उपयोग करना चाहते हैं, तो ध्यान रखें कि परिणाम सेट में पहली कॉलम एक अंडर साइन यूनिक पूर्णांक होना चाहिए - अधिकांश मामलों में यह आपकी तालिका का प्राथमिक कुंजी ID है।

यदि निर्दिष्ट नहीं किया गया है, तो शेष कॉलम पूर्ण पाठ फ़ील्ड के रूप में अनुक्रमित होते हैं। कॉलम जो गुणों के रूप में उपयोग किए जाने चाहिए उन्हें घोषित किया जाना चाहिए। हमारे उदाहरण में group_id और date_added गुण हैं:

sql_attr_uint = group_id
sql_attr_timestamp = date_added

जब हमारे पास यह सेटअप हो जाए, तो हम अनुक्रमण प्रक्रिया चला सकते हैं:

$ docker exec -it manticore indexer test1 --rotate
using config file '/etc/sphinxsearch/sphinx.conf'...
indexing index 'test1'...
collected 4 docs, 0.0 MB
sorted 0.0 Mhits, 100.0% done
total 4 docs, 193 bytes
total 0.015 sec, 12335 bytes/sec, 255.65 docs/sec
total 4 reads, 0.000 sec, 8.1 kb/call avg, 0.0 msec/call avg
total 12 writes, 0.000 sec, 0.1 kb/call avg, 0.0 msec/call avg

अनुक्रमणिका बनाई गई है और उपयोग के लिए तैयार है:

mysql> SHOW TABLES;
+-------+-------------+
| Index | Type        |
+-------+-------------+
| dist1 | distributed |
| rt    | rt          |
| test1 | local       |
+-------+-------------+
3 rows in set (0.00 सेकंड)

mysql> SELECT * FROM test1;
+------+----------+------------+
| id   | group_id | date_added |
+------+----------+------------+
| 1    | 1        | 1507904567 |
| 2    | 1        | 1507904567 |
| 3    | 2        | 1507904567 |
| 4    | 2        | 1507904567 |
+------+----------+------------+
4 rows in set (0.00 सेकंड)

एक त्वरित खोज़ परीक्षण जो 2 शर्तों से मेल खाना चाहिए, लेकिन दूसरी एक से मेल नहीं खाता:

mysql> SELECT * FROM test1 WHERE MATCH('test document -one');
+------+----------+------------+-------+
| id   | group_id | date_added | tag   |
+------+----------+------------+-------+
| 2    | 1        | 1519040667 | 2,4,6 |   
+------+----------+------------+-------+
1 row in set (0.00 सेकंड)

मैंटीकोर सर्च इंस्टॉल करें

मैंटीकोर सर्च इंस्टॉल करें