ELK Stack – பகுதி 2

September 15, 2017 1 Comment

Big Data, elk stack, கணியம்

, , , , ,

Elastic Search

ElasticSearch என்பது பல கோடிக்கணக்கான தரவுகளை சேமித்து வைத்துக்கொண்டு, நாம் கேட்கும் நேரங்களில் கேட்கும் தகவல்களை துரிதமாக வெளிப்படுத்த உதவும் ஒரு சேமிப்புக் கிடங்கு மற்றும் தேடு இயந்திரம் (Storage area & Search engine) ஆகும். தேடலிலும் நமக்கு உதவும் வகையில் இது வடிவமைக்கப்பட்டுள்ளது. GitHub, Google, StackOverflow, Wikipediaபோன்றவை இதனைப் பயன்படுத்தி அதிக அளவு தகவல்களை சேமிப்பத்தோடு மட்டுமல்லாமல், பயனர்கள் தங்கள் விருப்பம்போல் தகவல்களை தேடி எடுப்பதற்கு ஏற்ற வகையில் தேடும் திறனையும், வேகத்தினையும் துரிதமாக்குகின்றன. எடுத்துக் காட்டுக்கு, Google-ல் நாம் எதையாவது கொடுத்து தேடும்போது, நாம் கொடுக்கின்ற வார்த்தைகளில் முழுவதுமாகப் பொருந்தக் கூடிய இணைப்புகளை முதலாவதாகவும், சற்று ஓரளவு தொடர்புடைய வார்த்தைகளைப்  பெற்றுள்ள இணைப்புகளை அடுத்தடுத்தும் வெளிப்படுத்தும். அவ்வாறே நாம் தேடுவதற்காக வார்த்தைகளை அடிக்கும்போதே ‘suggessions’ என்ற பெயரில் நம் தேடலுக்கு ஏற்ற வார்த்தைகளை அதுவே நமக்கு பரிந்துரைக்கும். இவையெல்லாம் Elastic Search-ன் அம்சங்களே.

வாக்கியங்கள்/வார்த்தைகளின் அடிப்படையில் துரிதமாகத் தேடல்களை நிகழ்த்துவதற்கு ஏற்ற வகையில் முதன்முதலில் வடிவமைக்கப்பட்டதே Apache’s Lucene எனும் இயந்திரம் ஆகும். இது Java மொழியைக் கொண்டு எழுதப்பட்ட cross-platform திறன் கொண்ட ஒரு இயந்திரம். இதனை அடித்தளமாக வைத்துத்தான் இன்றைய ‘ElasticSearch’ உருவாக்கப்பட்டுள்ளது. Lucene-ல் காணப்பட்ட ஒருசில சிரமங்களைக் களைவதற்காக, இது வலிமைமிகு REST API-ஐப் பயன்படுத்துகிறது. இதன் மூலம் தரவுகள் அனைத்தும் index முறையில் கையாளப்படுகின்றன. எனவே தரவுகளை தேடுவதும், எடுப்பதும், சேமிப்பதும் சுலபமாகிறது. மேலும் இந்த Rest API-ஆனது  Curl எனும் கட்டளையைப் பயன்படுத்தி நேரடியாக elastic search-வுடன் பேசுகிறது. இவ்வாறு பேசும்போது இது செலுத்தும் தகவல்களும், பெற்றுக்கொள்ளும் தகவல்களும் JSON வடிவத்தில் அமையும்.

ElasticSearch-ஆனது Lucene-ன் செயல்பாடுகளை இன்னும் அதிக அளவில் விரிவாக்கியுள்ளது. அதாவது சமீபத்திய தகவல்களின் அடிப்படையில் உடனுக்குடன் ஆய்வறிக்கை எடுக்கும் அளவிற்கு (Real-time Analysis with real-time data) இது மிகவும் துரிதமானது. எடுத்துக்காட்டுக்கு டுவிட்டரில் எத்தனை பேர் ‘#கதிராமங்கலம்’ என்று பதிவிட்டுள்ளனர் என்பதனை அறிக்கையாக எடுத்துப்பார்த்தால், அதில் ஒரு சில நிமிடத்திற்கு முன்னர் பதிவிட்டவர் கூட இடம் பெற்றிருப்பார். அந்த அளவுக்கு இதன் வேகம் மிகவும் துரிதமானது. ElasticSearch-ல் வடிவான வடிவற்ற தகவல்கள் அனைத்தும் ஒரு ஒழுங்குமுறைப்படுத்தப்பட்ட நிலையில், index-ன் அடிப்படையில் சேமிக்கப்படுகின்றன. எனவே பயனர்கள் கேட்கும் தகவல்களை இது நொடியில் எடுத்து வெளிப்படுத்தும். அதே போல இதனுள் செலுத்தப்படும் தகவல்களும் உடனுக்குடன் உள் சென்றுவிடும்.

ஒருசில அடிப்படைப் பதங்கள்

அடுத்தபடியாக ElasticSearch-ல் பயன்படுத்தும் ஒருசில அடிப்படையான சொற்களைப் பற்றி அறிந்து கொள்வோம்.

Node

இதுதான் நமது கணினியில் elasticsearch-ஐ இயக்கிக்கொண்டிருக்கின்ற இடம் ஆகும். Cluster முறையில் பல்வேறு கணினிகள் இணைக்கப்பட்டு அவை அனைத்தும் தங்களுக்கென்று உள்ள node-ல் elasticsearch-ஐ  இயக்கிக்கொண்டிருக்கும். ஒரு node-ல் ஏதோ கோளாறு ஏற்பட்டு, அது தன் செயல்பாட்டை நிறுத்திவிட்டால்கூட, மற்றொரு கணினியில் இயங்கிக்கொண்டிருக்கும் node-ஆனது செயல்பட்டு நமது வேலைக்குத் தடைகள் ஏதும் நிகழாமல் பார்த்துக்கொள்ளும்.  இவ்வகையாக பல்வேறு கணினிகளில் இயங்கிக்கொண்டிருக்கும் nodes-ஐ, அது செய்யும் வேலையைப் பொறுத்து கீழ்க்கண்ட 3 விதங்களில் பிரிக்கலாம். ஒவ்வொரு கணினியில் உள்ள node-ன் configurations-ம் ஒவ்வொரு வகையில் அமையும்.

Master Node:- இது cluster முறையில் இணைக்கப்பட்டுள்ள பல்வேறு கணினிகளில் உள்ள அனைத்து nodes-ஐயும் மேலாண்மை செய்கின்ற வேலையை மட்டும் செய்யும். தரவுகளை சேமித்தல், வேண்டிய தரவுகளைத் தேடி எடுத்துக் கொடுத்தல் போன்ற எந்த ஒரு வேலையையும் செய்யாது. அதாவது தான் பெற்றுக்கொள்கின்ற ஒரு வேலையை மற்ற data nodes-க்கு அனுப்பி செய்யச் சொல்லும். அவ்வளவுதான். ஒரு node-ஐ இவ்வகையில் செயல்பட வைக்க விரும்பினால் elasticsearch.yml எனும் கோப்பில் சென்று node.master = true , node.data=false என்று  கொடுக்க வேண்டும்.

Data Node:- இது தரவுகளை சேமித்தல், வேண்டிய தரவுகளைத் தேடி எடுத்துக் கொடுத்தல் போன்ற அடிப்படை வேலைகளைச் செய்கிறது. ஒரு node-ஐ இவ்வகையில் செயல்பட வைக்க விரும்பினால் அதே கோப்பில் சென்று node.master = true , node.data=false என்று கொடுக்க வேண்டும்.

Routing node or load balancer node:- Master Node-தான் தன்னிடம் உள்ள வேலைகளை data node-க்கு அனுப்பும் என்று ஏற்கனவே பார்த்தோம். ஆனால் இப்படிப் பிரித்துக் கொடுப்பதும் ஒரு வேலைதானே. வேலைப்பளு அதிகமான நேரங்களில் இந்த வேலையைச் செய்வதற்குக் கூட Master-ஆனது Routing Node என்பதனைப் பயன்படுத்துகிறது. இந்த routing node-தான் வேலைப்பளுவை மொத்தமாகப் பெற்றுக்கொண்டு அதனைப் பிரித்து, data node-க்கு அனுப்பும் வேலையைச் செய்கிறது. ஒரு node-ஐ இவ்வகையில் செயல்பட வைக்க node.master = false , node.data=false என்று கொடுக்க வேண்டும்.

Shards

ஒவ்வொரு Node-லும் ஒன்று அல்லது அதற்கு மேற்பட்ட ‘shard’ வசிக்கின்றன. இத்தகைய shards-தான் தரவுகளைத் தாங்கியிருக்கும் பற்பல பிரிவுகள் ஆகும். ஒவ்வொரு shard-ம் பற்பல segments-களில் தரவுகளை சேமித்துக்கொண்டே வரும். நாம் கொடுக்கும் தகவல்கள் அப்படியே சென்று இதில் சேமிக்கப்படாது. வாக்கியங்கள் வார்த்தைகளாகப் பிரிக்கப்பட்டு, அந்த வார்த்தைகளில் ஒரே மாதிரியானவை நீக்கப்பட்டு தனித்தனி வார்த்தைகளாக சேமிக்கப்படும். இதே முறையில்தான் எண்கள், குறியீடுகள், வடிவங்கள் போன்றவற்றையும் கையாளும். அதாவது “I Love Chennai” என்பது சேமிக்கப்பட்ட பின்னர், மீண்டும் “I Love London” என்றொரு வார்த்தை வருகிறதெனில், I Love என்பது தவிர்க்கப்பட்டு London என்பது மட்டுமே சேமிக்கப்படும். இவ்வகையான சேமிப்பு முறைக்கு ‘Inverted Index’ என்று பெயர். இதுதான் ஒரு வார்த்தை எந்தெந்த வார்த்தைகளுடன் தொடர்புடையது(term relevance), அது எத்தனை முறை இடம் பெற்றுள்ளது(term frequencies), எந்தெந்த இடங்களில் இடம்பெற்றுள்ளது(word proximity) என்பது போன்ற விவரங்களைப் பாதுகாத்து ஒரு கையேடு போன்று செயல்படும். இவ்வகையான ‘Inverted Index’ நிலையானது. சேமிக்கப்பட்டுள்ள தரவுகளில் எவ்வித மாற்றமும் செய்ய இயலாது. ஏனெனில் ஒரு இடத்தில் மாற்றினால், அது தொடர்புடைய பல்வேறு இடங்களில் சேமிக்கப்பட்டுள்ள வார்த்தைகளும் சேர்ந்து பாதிப்படையும்.

ஒரு node-ல் பல்வேறு shards உள்ளன என்று நாம் பார்த்தோம். இந்த node-ல் ஏதோ கோளாறு ஏற்பட்டு, அது தன் செயல்பட்டை நிறுத்திவிட்டால், இதன் அடிப்படையில் நிகழ்த்து கொண்டிருக்கும் அனைத்து விதமான செயல்பாடுகளும் நின்று விடும் அபாயம் உள்ளது. இதனைத் தவிர்ப்பதற்காக உள்ளதே Replica shards ஆகும். அதாவது Cluster முறையில் இணைக்கப்பட்ட பல்வேறு கணினிகளில் ஒன்றில் முதன்மையான Primary Shards உருவாக்கப்படும். பின்னர் அதன் வடிவமைப்பிலேயே மற்றொரு இயந்திரத்தில் ஒரு பிரதி எடுத்துவைக்கப்படும். இதுவே Replica Shards எனப்படும்.  எனவே முதன்மை இயந்திரத்தில் ஏதேனும் கோளாறு ஏற்பட்டால், மற்றொரு இயந்திரத்தில் உள்ள replica shards இயங்க ஆரம்பிக்கும். அவ்வாறே ஒவ்வொரு இயந்திரத்தினுடைய பிரதிகளும் அடுத்தடுத்த இயந்திரங்களில் பாதுகாக்கப்படும். ஏதேனும் ஒன்று தன் செயல்பாட்டை நிறுத்தினால் கூட மற்றொன்று இயங்கி நமக்கு கைகொடுக்கும். இதுவே ‘Failover Mechanism’ என்று அழைக்கப்படும்.

Index

எந்த shard-ல் எந்தெந்த  விவரங்கள் பொதிக்கப்பட்டுள்ளன, அவை ஒன்றுடன் ஒன்று எவ்வாறு இணைக்கப்பட்டுள்ளன என்பது போன்ற விவரங்களை அளிப்பதற்கு index ஒரு மாபெரும் தளம் போன்று  செயல்படும். ஒன்றுக்கும் மேற்பட்ட index செயல்பட்டு இத்தகைய தரவுகளைப் பராமரிக்கின்றன. பொதுவாக ஒரேமாதிரியான குணநலன்களைக் கொண்ட தரவுகள் அனைத்தும் ஒரு index-ன் கீழ் அமையும். மேலும் இவை பல்வேறு வகைகளில்(types) பிரிக்கப்பட்டு, ஒவ்வொரு வகையின் கீழும் விவரங்களை அதனதன் பண்புகளின்(characteristics) அடிப்படையில் சேமிக்கும்.

அதாவது ElasticSearch-ல் பல்வேறு வகையான indices (plural of index) காணப்படும். ஒவ்வொரு index-ம் பல்வேறு types-ஐக் கொண்டிருக்கும். ஒவ்வொரு type-ம் documents-ஐ பல்வேறு வகையான Properties-ன் அடிப்படையில் சேமிக்கும். மற்றொரு வகையில் சொல்ல வேண்டுமானால் Elastic Search-ஐ Mysql-வுடன் ஒப்பிட்டு மேற்கண்ட அனைத்தையும் பின்வருமாறு புரிந்து கொள்ளலாம்.

Elastic Search = Mysql
Index = Database
Types = Tables
Properties = Columns
Documents = Rows

Curl கட்டளையின் மாதிரி வடிவம்

நாம் ஏற்கனவே கண்டது போல ElasticSearch-வுடன் பேசி அதனுள் விவரங்களைப் போடுவதற்கும், எடுப்பதற்கும், தேடுவதற்கும் RESTful API என்பது பயன்படுகிறது. இது command line-ல் curl எனும் கட்டளையைப் பயன்படுத்தி index-வுடன் நேரடியாகப் பேசுகிறது. இதன் மாதிரி வடிவம் பின்வருமாறு.

curl -X<verb> ‘<protocol>://<host>:<port>/<path>/<operation_name>?<query_string>’ -d ‘<body>’

verb : என்ன செய்ய வேண்டும் என்பதனைக் குறிக்கும் ஒரு வினைச்சொல்லை இது பெற்றிருக்கும். GET, POST, PUT, DELETE, HEAD ஆகிய மதிப்புகளில் ஏதேனும் ஒரு மதிப்பு இங்கு காணப்படும்.

protocol : இது http அல்லது https ஆகிய மதிப்புகளில் ஒன்றாக இருக்கும்.

host : இது ‘localhost’ என்றோ அல்லது cluster-ல் இயங்கிக்கொண்டிருக்கின்ற node-ன் IP முகவரியாகவோ இருக்கும்.

port : தற்போது elasticsearch இயங்கிக்கொண்டிருக்கின்ற port-ன் உடைய எண் ஆகும். பொதுவாக 9200 என்று இருக்கும்.

path : இது index,type போன்ற மதிப்பினைக் கொண்டிருக்கும்.

operation_name : என்ன வகையான செயல் செய்யப்போகிறோம் என்பது இங்கு காணப்படும். _search , _count போன்ற மதிப்புகளைக் கொண்டிருக்கும்.

query_string : இது கட்டாய மதிப்பு கிடையாது. விருப்பம் இருந்தால் ?pretty எனக் கொடுக்கலாம். இது  தெளிவான வடிவில் தகவல்களை வெளிப்படுத்த உதவும்.

body : data என்பதைக் குறிக்கும் -dஐத் தொடர்ந்து இப்பகுதி காணப்படும். நமது விருப்பத்திற்கு ஏற்றார் போன்ற தகவல்களைப் பெறுவதற்கு இப்பகுதியில் தான் கூடுதல் விவரங்கள் அளிக்கப்படும்.

எடுத்துக்காட்டு 1

பின்வரும் கட்டளை localhost-னுடைய port எண் 9200-ல் எது இயங்கிக்கொண்டிருக்கிறதோ அதனுடைய விவரங்களைப் பெற்று json வடிவில் வெளிப்படுத்தும். பொதுவாக 9200-ல் ElasticSearch இயங்கிக்கொண்டிருப்பதால் அதனுடைய மதிப்பு இங்கு வெளிப்பட்டுள்ளது.

curl -XGET ‘http://localhost:9200/?pretty’

வெளியீடு:

எடுத்துக்காட்டு 2

இது கொடுக்கப்பட்டுள்ள port-ல் இயங்கிக்கொண்டிருக்கும் elasticsearch அமைந்துள்ள cluster பற்றிய விவரங்களை அளிக்கிறது.  Cluster-ன் பெயர், அதன் நிலை, அதிலுள்ள nodes, shards என்று அனைத்து விவரங்களையும் வெளிப்படுத்தும்.

Cluster முறையில் இணைக்கப்பட்ட கணினிகளில் உள்ள nodes, shards ஆகியவை தயார் நிலையில் உள்ளதா இல்லையா என்பதைத் தெரிந்து கொள்வதற்கு health உதவும். இது தன்னுடைய நிலையினை பின்வரும் 3 மதிப்புகளில் வெளிப்படுத்தும்.

• Red என வெளிப்படுத்தினால் “ஒருசில முதன்மை shards தயாராக இல்லை” என்று அர்த்தம்.
• Yellow என வெளிப்படுத்தினால் “முதன்மை shards அனைத்தும் தயாராக உள்ளது, ஒருசில replica shards-தான் தயாராக இல்லை” என்று அர்த்தம். பொதுவாக ஒரே ஒரு கணினியில் இயங்கிக்கொண்டிருக்கும் elasticsearch இந்நிலையினை வெளிப்படுத்தும். ஏனெனில் அதற்கு replica என்ற ஒன்று கிடையாது.
• Green என வெளிப்படுத்தினால் “முதன்மை Replica ஆகிய அனைத்தும் தயாராக உள்ளது” என்று அர்த்தம்.

curl -XGET ‘http://localhost:9200/_cluster/health?pretty=true’

வெளியீடு:

{
  "cluster_name" : "elasticsearch",
  "status" : "yellow",
  "timed_out" : false,
  "number_of_nodes" : 1,
  "number_of_data_nodes" : 1,
  "active_primary_shards" : 6,
  "active_shards" : 6,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 6,
  "delayed_unassigned_shards" : 0,
  "number_of_pending_tasks" : 0,
  "number_of_in_flight_fetch" : 0,
  "task_max_waiting_in_queue_millis" : 0,
  "active_shards_percent_as_number" : 50.0
}

Cluster-ன் நிலையினைத் தெரிந்து கொண்டதுபோல shards, indexஆகிய அனைத்தின் நிலையினையும் health மூலம் தெரிந்து கொள்ளலாம். அதற்கான கட்டளைகள் பின்வருமாறு.

curl -XGET ‘http://localhost:9200/_cluster/health?level=cluster
curl -XGET ‘http://localhost:9200/_cluster/health?level=shards
curl -XGET ‘http://localhost:9200/_cluster/health?level=indices

எடுத்துக்காட்டு 3

இது கொடுக்கப்பட்டுள்ள port-ல் இயங்கிக்கொண்டிருக்கும் அனைத்து index- ஐயும் பட்டியலிடும். ?v என்பது தலைப்புடன் சேர்த்து வெளியிடும். ?v தரவில்லையெனில் தலைப்புகள் வெளிவராது.

curl ‘localhost:9200/_cat/indices?v’

வெளியீடு:
health status index        uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   interviews   EU-BIHTrSgmoScvHsNGXzA   5   1          4            0     25.7kb         25.7kb
yellow open   bookdb_index TeMyXrZeT8iMsQjoVxBqwQ   1   1          4            0     27.5kb         27.5kb

எடுத்துக்காட்டு 4

இப்போது ஒரு புது index-ஐ உருவாக்கி அதனுள் எவ்வாறு தகவல்களை உட்செலுத்துவது என்று பார்க்கலாம்.பின்வரும் கட்டளை elasticsearchஇயங்கிக்கொண்டிருக்கும் இடத்தில் ‘interviews’ எனும் பெயர் கொண்ட index-ஐ உருவாக்கி அதில் ‘candidates’எனும் வகையின்கீழ் கொடுக்கப்பட்டுள்ள விவரங்களை உட்செலுத்துகிறது.

-d ஐத் தொடர்ந்து single quotes-க்குள் {பண்பு:தரவு} (property:data) எனும் முறையில் விவரங்களை அமைக்க வேண்டும் .

curl -XPOST ‘http://localhost:9200/interviews/candidates’ -d ‘
{
“Name” : “Nandhini”,
“DOB” : “1988-10-04”,
“Experience”: 7,
“Organizations_worked” : [“Polaris”, “Virtusa”,”Infosys”],
“Skillset”: “Ruby, Python, Pearl, ETL Testing”,
“Feedback”:”Strong in Testing, Expert in SQL, Beginner in Python”
}’

இதன் வெளியீடு பின்வருமாறு அமைந்தால் தரவுகள் வெற்றிகரமாக உட்சென்றுவிட்டன என்று அர்த்தம்.

{“_index”:”interviews”,”_type”:”candidates”,”_id”:”AV2n8sn4DfKljeJYHE0Y”,”_version”:1,”result”:
“created”,”_shards”:{“total”:2,”successful”:1,”failed”:0},”created”:true}

மேற்கூறிய அதே முறையில் பின்வரும் தரவுகளையும் ஒவ்வொன்றாக உட்செலுத்தி விடவும்.

“Name” : “Ruby Jackson”,
“DOB” : “1983-05-23”,
“Experience”: 10,
“Organizations_worked” : [“Virtusa”, “TVS Lucas”,”Tech Mahindra”],
“Skillset”: “DW Testing, Expert systems, Java”,”Feedback”:”Beginner in Selenium, Knows Java and ETL”

“Name” : “Narayani”,
“DOB” : “1995-11-14”,
“Experience”: 2,
“Organizations_worked” : [“Aspire Systems”],
“Skillset”: “Big Data, ELK Stack”,
“Feedback”:”Expertise in Big Data, Beginner in ELK”

“Name” : “N.T.Madhuri”,
“DOB” : “1990-05-30”,
“Experience”: 4,
“Organizations_worked” : [“Thoughtworks”, “Virtusa”],
“Skillset”: “Unix, Linux”,
“Feedback”:”Strong knowledge in Unix & Linux”

இப்போது நந்தினி, ரூபி ஜாக்சன், நாராயாணி, N.T.மாதுரி ஆகியோரின் பெயர், பிறந்த தேதி, எத்தனை வருட அனுபவமுடையவர்கள், அவர்கள் வேலை செய்த நிறுவனங்களின் விவரம், எந்தெந்த தொழில்நுட்பங்களில் திறன் மிக்கவர்கள் மற்றும் அவர்களை நேர்காணல் செய்தவர்கள் கொடுத்த பின்னொட்டம் ஆகியவை elasticsearch-க்குள் செலுத்தப்பட்டுவிட்டன.

இப்போது இவற்றை வைத்து எந்தெந்த வகையில் நமக்கு வேண்டிய தரவுகளை மட்டும் தேடுவது, எடுப்பது, அதற்குக் கட்டளைகளை எவ்வாறெல்லாம் அமைப்பது போன்றவை பற்றி இனி பார்க்கப்போகிறோம்.

எடுத்துக்காட்டு 5

நாம் உருவாக்கிய index-ல் உள்ள அனைத்து தரவுகளையும் தேடி எடுப்பதற்கான கட்டளை பின்வருமாறு அமையும். மேற்கண்டது போன்றே கட்டளையை அமைத்து கடைசியாக _search எனக் கொடுத்தால், அது கொடுக்கப்பட்ட index/type-ல் உள்ள அனைத்துத் தரவுகளையும் எடுத்து வெளிப்படுத்தும்.

curl -XGET ‘http://localhost:9200/interviews/candidates/_search?pretty’

வெளியீடு:

{
  "took" : 5,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 4,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2nkI0pDfKljeJYHE0U",
        "_score" : 1.0,
        "_source" : {
          "Name" : "Narayani",
          "DOB" : "1995-11-14",
          "Experience" : 2,
          "Organizations_worked" : [
            "Aspire Systems"
          ],
          "Skillset" : "Big Data, ELK Stack",
          "Feedback" : "Expertise in Big Data, Beginner in ELK"
        }
      },
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2neRCiDfKljeJYHE0O",
        "_score" : 1.0,
        "_source" : {
          "Name" : "N.T.Madhuri",
          "DOB" : "1990-05-30",
          "Experience" : 4,
          "Organizations_worked" : [
            "Thoughtworks",
            "Virtusa"
          ],
          "Skillset" : "Unix, Linux",
          "Feedback" : "Strong knowledge in Unix & Linux"
        }
      },
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2nkG8DDfKljeJYHE0T",
        "_score" : 1.0,
        "_source" : {
          "Name" : "Ruby Jackson",
          "DOB" : "1983-05-23",
          "Experience" : 10,
          "Organizations_worked" : [
            "Virtusa",
            "TVS Lucas",
            "Tech Mahindra"
          ],
          "Skillset" : "DW Testing, Expert systems, Java",
          "Feedback" : "Beginner in Selenium, Knows Java and ETL"
        }
      },
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2n8sn4DfKljeJYHE0Y",
        "_score" : 1.0,
        "_source" : {
          "Name" : "Nandhini",
          "DOB" : "1988-10-04",
          "Experience" : 7,
          "Organizations_worked" : [
            "Polaris",
            "Virtusa",
            "Infosys"
          ],
          "Skillset" : "Ruby, Python, Pearl, ETL Testing",
          "Feedback" : "Strong in Testing, Expert in SQL, Beginner in Python"
        }
      }
    ]
  }
}

இங்கு தரவுகளுக்கான ஒவ்வொரு தொகுப்பும் தனித்தனி id-யுடன் விளங்குவதைக் காணவும். இந்த id-தான் பின்னாளில் இத்தரவுகளை அழிக்கவோ மாற்றம் செய்யவோ பயன்படும்.

எடுத்துக்காட்டு 6

ஒரு குறிப்பிட்ட id-ஐக் கொண்ட தரவுகளை ஆழிப்பதற்கான கட்டளை பின்வருமாறு அமையும். இதில்  ‘AV2nkFPQDfKljeJYHE0S’ என்பதுதான் id ஆகும்.

curl -XDELETE ‘http://localhost:9200/interviews/candidates/AV2nkFPQDfKljeJYHE0S’

இதன் வெளியீடு பின்வருமாறு அமைந்தால் தரவுகள் வெற்றிகரமாக நீக்கப்பட்டுவிட்டன என்று அர்த்தம்.

{“found”:true,”_index”:”interviews”,”_type”:”candidates”,”_id”:”AV2nkFPQDfKljeJYHE0S”,”_version”:2,”result”:”deleted”,”_shards”:{“total”:2,”successful”:1,”failed”:0}}

எடுத்துக்காட்டு 7

இப்போது ஒருவர் நாம் மேலே உட்செலுத்திய விவரங்களின் அடிப்படையில் தனக்கு வேண்டிய தேடலைத் தொடங்குகிறார் என்று வைத்துக்கொள்வோம். அவர் Ruby எனும் மொழி தெரிந்தவர்களின் தொகுப்புகளைப் பெறுவதற்காக _searchஐத் தொடர்ந்து q=Ruby எனப் பின்வருமாறு கொடுத்துள்ளார்.

curl -XGET ‘http://localhost:9200/interviews/candidates/_search?q=Ruby&pretty’

ஆனால் இதுவோ Ruby மொழி தெரிந்த நந்தினியின் தரவுகளை வெளியிடுவதோடு நிறுத்தாமல், ரூபி எனும் பெயர் கொண்டவரின் தகவலையும் சேர்த்து வெளியிட்டுள்ளது.

வெளியீடு:

{
  "took" : 37,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 0.26228312,
    "hits" : [
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2nkG8DDfKljeJYHE0T",
        "_score" : 0.26228312,
        "_source" : {
          "Name" : "Ruby Jackson",
          "DOB" : "1983-05-23",
          "Experience" : 10,
          "Organizations_worked" : [
            "Virtusa",
            "TVS Lucas",
            "Tech Mahindra"
          ],
          "Skillset" : "DW Testing, Expert systems, Java",
          "Feedback" : "Beginner in Selenium, Knows Java and ETL"
        }
      },
      {
        "_index" : "interviews",
        "_type" : "candidates",
        "_id" : "AV2n8sn4DfKljeJYHE0Y",
        "_score" : 0.2568969,
        "_source" : {
          "Name" : "Nandhini",
          "DOB" : "1988-10-04",
          "Experience" : 7,
          "Organizations_worked" : [
            "Polaris",
            "Virtusa",
            "Infosys"
          ],
          "Skillset" : "Ruby, Python, Pearl, ETL Testing",
          "Feedback" : "Strong in Testing, Expert in SQL, Beginner in Python"
        }
      }
    ]
  }
}

இதுபோன்ற குழப்பங்களைத் தவிர்க்க நாம் கொடுக்கின்ற வார்த்தையை எந்தப் பண்பின்கீழ் தேட வேண்டும் எனவும் குறிப்பிட்டுக் கூற வேண்டும்.

எடுத்துக்காட்டு 8

Ruby எனும் வார்த்தையை skillset எனும் பண்பின்கீழ் தேடி அதில் பொருந்துபவர்களை மட்டும் வெளியிடுக என்று கூறுவதற்கான கட்டளை பின்வருமாறு அமையும்.

curl -XGET ‘http://localhost:9200/interviews/candidates/_search?q=Skillset:Ruby&pretty’

எடுத்துக்காட்டு 9

மேற்கண்ட அதே கட்டளையை DSL (Domain Specific Language) மொழி கொண்டு பின்வருமாறு எழுதலாம்.

அதாவது ஒன்று அல்லது அதற்கு மேற்பட்ட விதிமுறைகளை இணைத்து நமது தேடுதலைக் குறுக்குவதற்கு இம்மொழி மிகவும் உதவுகிறது. இங்கு நாம் கண்டது ஒரே ஒரு பண்பில் மட்டும் வார்த்தையைத் தேடுகின்ற  அடிப்படை ‘match query’ ஆகும். இனிவரும் கட்டளைகளில் இதன் பல்வேறு அம்சங்களைக் காணலாம்.

எடுத்துக்காட்டு 10

ஒன்றுக்கும் மேற்பட்ட பண்புகளில் வார்த்தையைத் தேடுகின்ற ‘multi_match query’ பின்வருமாறு அமையும். இங்கு Expert எனும் வார்த்தை “Skillset”-ல் காணப்பட்டாலோ அல்லது “Feedback”-ல் காணப்பட்டாலோ அத்தரவுத் தொகுப்பு வெளிப்படும்.

எடுத்துக்காட்டு 11

இங்கு multi_match query-ல் உள்ள fuzziness எனும் பண்பினைப்  பற்றிக் காணலாம். இது நமது தேடு வார்த்தையில் உள்ள எழுத்துப் பிழைகளை நீக்க உதவுகிறது. தவறுதலாக Expertis என்று கொடுத்தாலும் சரியான Expertise எனும் வார்த்தையை எடுத்துக்கொண்டு தேடுகிறது.

எடுத்துக்காட்டு 12

must, should, must_not மூலம் விதிமுறைகளை இணைத்து நமது தேடுதலை இன்னும் சிறப்பாகக்  குறுக்குவதற்கு ‘bool query’ பயன்படுகிறது. இவை முறையே AND, OR, NOT போன்றவற்றிற்கு மாற்றாகப் பயன்படுத்தப்படுகின்றன.

பின்வரும் bool query-ல் உட்புறமும் வெளிப்புறமுமாக இரண்டு bools பயன்படுத்தப்பட்டுள்ளன. உட்புற bool-ல் ஒருவருடைய skillset-ஆனது ‘ETL Testing’ அல்லது ‘DW Testing’-ஆக இருக்க வேண்டும் என்பதற்காக அவை should-க்குள் கொடுக்கப்பட்டுள்ளன. இந்தப் பொருத்தத்தின் மூலம் தேர்ந்தெடுக்கப்படுபவர் virtusa-நிறுவனத்தில் பணிபுரிந்தவராகவும் polaris-ல் பணிபுரியாதவராகவும் இருக்க வேண்டும் என்பதற்காக அவைகள் முறையே must மற்றும் must_not பயன்படுத்தி அமைக்கப்பட்டுள்ளன. இவை அனைத்திலும் பொருந்துகின்ற ஒருவரைத் தேர்வு செய்வதற்காக வெளிப்புற boolஉருவாக்கப்பட்டு அனைத்து விதிமுறைகளையும் இணைக்கிறது.

%d bloggers like this: