22 ਨਵੰ 2025·8 ਮਿੰਟ
ਡੌਗ ਕਟਿੰਗ ਦੀ Lucene ਅਤੇ Hadoop: ਖੋਜ ਤੋਂ ਬੱਡੇ ਡੇਟਾ ਤੱਕ
कैਸੇ Doug Cutting ਦੀਆਂ Lucene ਅਤੇ Hadoop ਨੇ ਖੋਜ ਅਤੇ ਵੰਡਿਆ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਆਮ ਖੁੱਲ੍ਹੇ-ਸੋਰਸ ਬਿਲਡਿੰਗ ਬਲਾਕ ਬਣਾਇਆ, ਜੋ ਆਧੁਨਿਕ ਡੇਟਾ ਟੀਮਾਂ ਲਈ ਵਿਕਸਿਤ ਹੋਏ।
कैਸੇ Doug Cutting ਦੀਆਂ Lucene ਅਤੇ Hadoop ਨੇ ਖੋਜ ਅਤੇ ਵੰਡਿਆ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਆਮ ਖੁੱਲ੍ਹੇ-ਸੋਰਸ ਬਿਲਡਿੰਗ ਬਲਾਕ ਬਣਾਇਆ, ਜੋ ਆਧੁਨਿਕ ਡੇਟਾ ਟੀਮਾਂ ਲਈ ਵਿਕਸਿਤ ਹੋਏ।
Lucene ਅਤੇ Hadoop ਇੱਕ ਅਚੰਭੇ ਰੂپ ਵਿੱਚ ਪ੍ਰਯੋਗਕਰਤਾ ਕਹਾਣੀ ਦੱਸਦੇ ਹਨ: ਇੱਕ ਵਾਰੀ ਤੁਸੀਂ ਜਾਣਕਾਰੀ ਨੂੰ ਤੇਜ਼ ਖੋਜ ਲਈ ਇੰਡੈਕਸ ਕਰ ਸਕਦੇ ਹੋ, ਅਗਲਾ ਚੈਲੈਂਜ ਹੁੰਦਾ ਹੈ ਉਸ ਤੋਂ ਵੱਧ ਡੇਟਾ ਪ੍ਰੋਸੈਸ ਕਰਨਾ ਜੋ ਇਕ ਮਸ਼ੀਨ ਸਮਭਾਲ ਸਕੇ। ਇਕੱਠੇ, ਇਨ੍ਹਾਂ ਨੇ “ਖੋਜ” ਅਤੇ “ਵੰਡਿਆ ਕੰਪਿਊਟਿੰਗ” ਨੂੰ ਨਿਚ-ਪ੍ਰਾਈਸ ਜਾਂ ਮਹਿੰਗੇ ਵਿਸ਼ੇਸ਼ ਸਮਰਥਨਾਂ ਤੋਂ ਐਸੇ ਬਿਲਡਿੰਗ ਬਲਾਕ ਬਣਾਇਆ ਜੋ ਆਮ ਹਾਰਡਵੇਅਰ ਨਾਲ ਟੀਮਾਂ ਅਪਣਾਉ ਸਕਦੀਆਂ ਸਨ।
ਇਹ ਲੇਖ ਇੱਕ ਕੰਮ ਕਰ ਰਹੀ ਇਤਿਹਾਸਕ ਰਿਪੋਰਟ ਹੈ, ਗਹਿਰਾਈ ਵਿੱਚ scoring ਫਾਰਮੂਲਜ਼ ਜਾਂ ਵੰਡਿਆ ਪ੍ਰਣਾਲੀ ਸਿਧਾਂਤ ਵਿੱਚ ਨਹੀਂ। ਮਕਸਦ ਇਹ ਜੋੜਨਾ ਹੈ ਕਿ ਲੋਕਾਂ ਕੋਲ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਸਨ, ਉਹ ਸਾਦੇ ਖ਼ਿਆਲ ਜਿਹੜੇ ਤਰੱਕੀ ਖੋਲ੍ਹੇ, ਅਤੇ ਕਿਉਂ ਉਹ ਖ਼ਿਆਲ ਅਜੇ ਵੀ ਆਧੁਨਿਕ ਟੂਲਾਂ ਵਿੱਚ ਨਜ਼ਰ ਆਉਂਦੇ ਹਨ।
Apache Lucene ਨੇ ਵਿਕਾਸਕਾਰਾਂ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਉੱਚ-ਗੁਣਵੱਤਾ ਵਾਲੀ ਖੋਜ ਜੋੜਨਾ ਸੌਖਾ ਕੀਤਾ: ਟੈਕਸਟ ਦਾ ਇੰਡੈਕਸ ਬਣਾਉਣਾ, ਤੇਜ਼ੀ ਨਾਲ ਕ્વੈਰੀ ਕਰਨਾ, ਅਤੇ ਸਬ ਕੁਝ ਨਵੇਂ ਸਿਰੇ ਤੋਂ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਬਿਨਾਂ ਦੁਹਰਾਉਣ ਦੇ।
Apache Hadoop ਨੇ ਇੱਕ ਵੱਖਰੀ ਪীੜਾ ਹੱਲ ਕੀਤੀ: ਸੰਗਠਨਾਂ ਵੱਲੋਂ ਲਾਗਜ਼, ਕਲਿਕਸਟਰੀਮ ਅਤੇ ਐਸੇ ਡੇਟਾਸੇਟ ਇਕੱਠੇ ਕੀਤੇ ਜਾ ਰਹੇ ਸਨ ਜੋ ਇੱਕ ਸਰਵਰ 'ਤੇ ਆਸਾਨੀ ਨਾਲ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦੇ ਸਨ। Hadoop ਇੱਕ ਤਰੀਕਾ ਦਿੱਤਾ ਕਿ ਉਹ ਡੇਟਾ ਬਹੁਤ ਸਾਰੀਆਂ ਮਸ਼ੀਨਾਂ 'ਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਵੇ (HDFS) ਅਤੇ ਇਸ 'ਤੇ ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ ਜੌਬਸ (MapReduce) ਚਲਾਏ ਜਾ ਸਕਣ—ਬਿਨਾਂ ਹੱਥੋਂ-ਹੱਥ ਇੱਕ ਵੰਡਿਆ ਸਿਸਟਮ ਬਣਾਉਣ ਦੀ ਲੋੜ ਦੇ।
ਇਨ੍ਹਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਤੋਂ ਪਹਿਲਾਂ ਕਈ ਟੀਮਾਂ ਕੋਲ ਇਕ ਮੁਸ਼ਕਲ ਚੋਣ ਸੀ: ਮਹੰਗੇ ਪ੍ਰੋਪ੍ਰਾਇਟਰੀ ਸਿਸਟਮ ਖਰੀਦੋ ਜਾਂ ਹੌਲੀ-ਹੌਲੀ, ਨਿਰਲਜ ਅਤੇ ਗਲਤੀਆਂ ਭਰੇ ਮੈਨੂਅਲ ਕੰਮਾਂ ਨੂੰ ਕਬੂਲ ਕਰੋ। Lucene ਅਤੇ Hadoop ਨੇ ਬਾਧਾ ਥੱਲੇ ਕੀਤੀ।
ਤੁਸੀਂ ਵੇਖੋਗੇ Lucene ਅਤੇ Hadoop ਤੋਂ ਪਹਿਲਾਂ ਕੀ ਸਮੱਸਿਆਵਾਂ ਸੀ, ਕਿਉਂ Doug Cutting ਦਾ ਕੰਮ ਨਿਰਮਾਤਿਆਂ ਨੂੰ ਖਿੱਚਿਆ, ਅਤੇ ਕਿਵੇਂ ਇਹ ਖ਼ਿਆਲ ਜੋੜੇ ਗਏ—ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਇੰਡੈਕਸ ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਕਲੱਸਟਰਾਂ ਦਾ ਕੋਆਰਡੀਨੇਸ਼ਨ ਕਰਨ ਤੱਕ।
ਅਖੀਰ ਵਿੱਚ, ਤੁਸੀਂ ਝਾੜਕ ਦੇ ਤੌਰ 'ਤੇ ਸਮਝ ਪਾਓਗੇ: ਭਾਵੇਂ ਤੁਹਾਡਾ ਸਟੈਕ Elasticsearch, Spark, ਕਲਾਊਡ ਆਬਜੈਕਟ ਸਟੋਰੇਜ, ਜਾਂ ਮੈਨੇਜਡ ਸਰਵਿਸਜ਼ ਵਰਤੇ, ਬਹੁਤ ਸਾਰੇ ਮੂਲ ਧਾਰਣਾਂ ਉਹਨਾਂ ਵਿਚੋਂ ਆਉਂਦੀਆਂ ਹਨ ਜਿਹੜੀਆਂ Lucene ਅਤੇ Hadoop ਨੇ ਆਮ ਕੀਤਾ।
Doug Cutting ਉਹਨਾਂ ਦੁਰਲਭ ਇੰਜੀਨੀਅਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਕੰਮ ਦੋ ਵੱਖ-ਵੱਖ “ਡਿਫ਼ਾਫ਼ੋਲਟ” ਟੂਲਾਂ ਨੂੰ ਰੂਪ ਦਿੱਤਾ: ਆਧੁਨਿਕ ਡਾਟਾ ਟੀਮਾਂ ਲਈ Apache Lucene ਖੋਜ ਲਈ, ਅਤੇ Apache Hadoop ਵੰਡਿਆ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ। ਦੋਹਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਨੇ ਕਿਸੇ ਇੱਕ ਵਿਅਕਤੀ ਤੋਂ ਕਾਫੀ ਵੱਧ ਪ੍ਰਸਾਰ ਕੀਤਾ, ਪਰ Cutting ਦੇ ਸ਼ੁਰੂਆਤੀ ਟੈਕਨੀਕੀ ਫੈਸਲਿਆਂ ਅਤੇ ਖੁੱਲ੍ਹੀ ਸਹਿਯੋਗੀ ਵ੍ਯਵਹਾਰ ਨੇ ਦਿੱਸ਼ਾ ਨਿਰਧਾਰਤ ਕੀਤੀ।
Cutting ਦਾ ਲਗਾਤਾਰ ਥੀਮ ਪਹੁੰਚਯੋਗਤਾ ਸੀ। Lucene ਨੇ ਉੱਚ-ਗੁਣਵੱਤਾ ਵਾਲੀ ਖੋਜ ਨੂੰ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਵਾਇਆ ਜਿਸਨੂੰ ਤੁਸੀਂ ਆਪਣੀ ਐਪ ਵਿੱਚ ਏਂਬੇਡ ਕਰ ਸਕਦੇ ਸੀ, ਨ ਕਿ ਇਕ ਵਿਸ਼ੇਸ਼ਿਤ ਪ੍ਰਣਾਲੀ ਜੋ ਸਿਰਫ ਵੱਡੀਆਂ ਕੰਪਨੀਆਂ ਹੀ ਬਣਵਾ ਸਕਦੀਆਂ। ਬਾਅਦ ਵਿੱਚ, Hadoop ਦਾ ਮਕਸਦ ਸੀ ਕਿ ਆਮ ਮਸ਼ੀਨਾਂ ਦੇ ਕਲੱਸਟਰਾਂ 'ਤੇ ਵੱਡੇ ਪੈਮਾਨੇ ਦੀ ਸਟੋਰੇਜ ਅਤੇ ਕੰਪਿਊਟੇਸ਼ਨ ਸੰਭਵ ਬਣੇ, ਨਾ ਕਿ ਸਿਰਫ ਮਹਿੰਗੇ ਪ੍ਰੋਪ੍ਰਾਇਟਰੀ ਹਾਰਡਵੇਅਰ।
ਇਹ ਪ੍ਰੇਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਇਹ “ਵੱਡੇ ਡੇਟਾ ਸਿਰਫ ਵੱਡੇ ਲਈ” ਨਹੀਂ ਸੀ, ਬਲਕਿ ਛੋਟੀਆਂ ਟੀਮਾਂ ਨੂੰ ਸੀਮਿਤ ਬਜਟ ਨਾਲ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਮਰਥਨ ਉਪਲਬਧ ਕਰਵਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਸੀ।
ਦੋਹਾਂ Lucene ਅਤੇ Hadoop Apache Software Foundation ਹੇਠ ਵਧੇ, ਜਿੱਥੇ ਫੈਸਲੇ ਖੁੱਲ੍ਹੇ ਤੌਰ 'ਤੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਅਧਿਕਾਰ ਯੋਗਦਾਨ ਰਾਹੀਂ ਮਿਲਦਾ ਹੈ। ਇਹ ਮਾਡਲ ਸੁਧਾਰਾਂ ਦਾ ਸਥਿਰ ਪ੍ਰਵਾਹ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਸੀ: ਬੱਗ ਫਿਕਸ, ਪ੍ਰਦਰਸ਼ਨ ਕੰਮ, ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਅਤੇ ਕੰਪਨੀਆਂ ਤੇ ਯੂਨੀਵਰਸਿਟੀਆਂ ਤੋਂ ਹਕੀਕਤੀ ਫੀਡਬੈਕ।
Cutting ਦੀ ਨਿੱਜੀ ਯੋਗਦਾਨ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਸਭ ਤੋਂ ਮਜ਼ਬੂਤ ਸੀ: ਪਹਿਲੀ ਆਰਕੀਟੈਕਚਰ, ਸ਼ੁਰੂਆਤੀ ਇੰਪਲੇਮੈਂਟੇਸ਼ਨ, ਅਤੇ ਹੋਰ ਯੋਗਦਾਨਕਾਰਾਂ ਨੂੰ ਆਕਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਰੇਡਿਬਿਲਿਟੀ। ਜਿਵੇਂ ਜੇਹੜੀ ਗ੍ਰਾਹਕੀ ਵਧੀ, ਕਮਿਊਨਿਟੀ (ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਕੰਪਨੀਆਂ) ਨੇ ਮੁੱਖ ਜੁਟਦੇ ਜੋੜੇ: ਨਵੇਂ ਫੀਚਰ, ਇੰਟਿਗ੍ਰੇਸ਼ਨ, ਸਕੇਲਿੰਗ ਕੰਮ, ਅਤੇ ਓਪਰੇਸ਼ਨਲ ਟੂਲਿੰਗ।
ਇੱਕ ਉਪਯੋਗੀ ਢੰਗ ਸੋਚਣ ਦਾ: Cutting ਨੇ “ਪਹਿਲੀ ਵਰਕਿੰਗ ਵਰਜਨ” ਅਤੇ ਉਸਦੇ ਇर्द-ਗਿਰਦ ਸੱਭਿਆਚਾਰ ਨੂੰ ਬਣਾਇਆ; ਓਪਨ-ਸੋਰਸ ਕਮਿਊਨਿਟੀ ਨੇ ਉਹਨਾਂ ਵਿਚਾਰਾਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਵਾਲੀ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ।
Lucene ਤੋਂ ਪਹਿਲਾਂ, ਪ੍ਰੋਡਕਟ ਵਿੱਚ “ਖੋਜ” ਜੋੜਨਾ ਅਕਸਰ ਇਕ ਛੋਟਾ ਰਿਸਰਚ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਵਰਗਾ ਸੀ। ਕਈ ਟੀਮਾਂ ਜਾਂ ਤਾਂ ਮਹਿੰਗਾ ਪ੍ਰੋਪ੍ਰਾਇਟਰੀ ਸਾਫਟਵੇਅਰ ਖਰੀਦਦੀਆਂ ਜਾਂ ਘਰੇਲੂ ਹੱਲ ਸਿਲਾਈਆਂ ਕਰਦੀਆਂ ਜੋ ਟਿਊਨ ਕਰਨ ਵਿੱਚ ਔਖੀਆਂ, ਸਕੇਲ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਅਤੇ ਗਲਤੀਆਂ ਭਰਪੂਰ ਹੁੰਦੀਆਂ।
ਖੋਜ ਸਿਰਫ ਕਿਸੇ ਸ਼ਬਦ ਦੀ ਥਾਂ ਲਭਣ ਹੀ ਨਹੀਂ ਹੈ। ਇਹ ਗਤੀ, ਰੈਂਕਿੰਗ ਅਤੇ ਗੰਦੇ-ਹਕੀਕਤੀ ਟੈਕਸਟ ਨਾਲ ਨਜਿੱਠਣ ਬਾਰੇ ਹੈ। ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਯੂਜ਼ਰ “running shoes” ਟਾਈਪ ਕਰਨ ਤੇ ਮਿਲੀ-ਸੈਕਿੰਡਾਂ ਵਿੱਚ ਉਪਯੁਕਤ ਨਤੀਜੇ ਮਿਲਣ, ਤਾਂ ਤੁਹਾਨੂੰ ਵਿਸ਼ੇਸ਼ ਡੇਟਾ ਸਟ੍ਰੱਕਚਰ ਅਤੇ ਅਲਗੋਰਿਦਮ ਦੀ ਲੋੜ ਹੁੰਦੀ—ਨਾਲ ਹੀ ਇੰਡੈਕਸਿੰਗ, ਅਪਡੇਟਸ, ਅਤੇ ਕਵੇਰੀਜ਼ ਨੂੰ ਭਰੋਸੇਯੋਗ ਰੱਖਣ ਲਈ ਧਿਆਨਪੂਰਵਕ ਇੰਜੀਨੀਅਰਿੰਗ।
ਇੱਕ ਇੰਡੈਕਸ ਕਿਤਾਬ ਦੇ ਪਿੱਠ ਦੇ ਇੰਡੈਕਸ ਵਾਂਗ ਹੈ, ਪਰ ਤੁਹਾਡੇ ਸਾਰੇ ਦਸਤਾਵੇਜ਼ਾਂ ਲਈ: ਹਰ ਵਾਰੀ ਹਰ ਇਕ ਪੰਨਾ ਸਕੈਨ ਕਰਨ ਦੀ ਬਜਾਏ ਤੁਸੀਂ ਕਿਸੇ ਸ਼ਬਦ ਲਈ ਲੁੱਕ-ਅੱਪ ਕਰਦੇ ਹੋ ਅਤੇ ਸਿੱਧੇ ਓਥੇ ਪਹੁੰਚਦੇ ਹੋ ਜਿੱਥੇ ਉਹ ਨਜ਼ਰ ਆਉਂਦਾ ਹੈ। ਇੰਡੈਕਸ ਬਿਨਾਂ, ਖੋਜ ਹੌਲੀ ਹੋ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਹਰ ਵਾਰੀ ਫਿਰ-ਫਿਰ ਸਭ ਕੁਝ ਪੜ੍ਹ ਰਹੇ ਹੁੰਦੇ ਹੋ।
ਪ੍ਰਸੰਗਤਾ (relevance) ਇਹ ਫੈਸਲਾ ਕਰਦੀ ਹੈ ਕਿ ਕੀ ਪਹਿਲਾਂ ਦਿਖਾਇਆ ਜਾਵੇ। ਜੇ 10,000 ਦਸਤਾਵੇਜ਼ “shoes” ਨਾਲ ਮਿਲਦੇ ਹਨ, ਤਾਂ relevance ਦੱਸਦਾ ਹੈ: ਪਹਿਲੇ ਪੇਜ 'ਤੇ ਕਿਹੜੇ 10 ਦਿਖਾਏ ਜਾਣ? ਇਹ ਅਕਸਰ ਸੂਚਕਾਂ ਤੇ ਨਿਰਭਰ ਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਟਰਮ ਦੀ ਤ੍ਰਿਕਤਾ, ਇਹ ਕਿੱਥੇ ਆਇਆ (ਸਿਰਲੇਖ ਵੱਲੋਂ ਬਾਡੀ ਵੱਲ), ਅਤੇ ਕਿੰਨਾ ਦੁਰਲਭ ਹੈ।
ਜਿਵੇਂ-ਜਿਵੇਂ ਵੈੱਪਸਾਈਟਾਂ ਅਤੇ ਆਨਲਾਈਨ ਕੈਟਾਲੌਗ ਵਧੇ, “ਠੀਕ-ਠਾਕ” ਖੋਜ ਕਾਫੀ ਨਹੀਂ ਰਹੀ। ਯੂਜ਼ਰ ਤੇਜ਼ ਨਤੀਜੇ, ਟਾਇਪੋ ਟੋਲਰੇੰਸ ਅਤੇ ਸਮਝਦਾਰ ਰੈਂਕਿੰਗ ਦੀ ਉਮੀਦ ਕਰਨ ਲੱਗੇ। ਕੰਪਨੀਆਂ ਜਿਹੜੀਆਂ ਇਹ ਨਹੀਂ ਦਿੰਦੀਆਂ, ਉਹ ਐੰਗੇਜਮੈਂਟ ਅਤੇ ਵਿਕਰੀ ਗੁੰਵਾ ਬੈਠਦੀਆਂ।
ਇੱਕ ਪੁਨਰ-ਉਪਯੋਗ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਟੀਮਾਂ ਨੂੰ ਇੰਡੈਕਸਿੰਗ ਅਤੇ ਰੈਂਕਿੰਗ ਨੂੰ ਨਵੇਂ ਸਿਰੇ ਤੋਂ ਦੁਹਰਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਰਹੀ। ਇਸ ਨਾਲ ਖੋਜ ਬਣਾਉਣ ਦੀ ਲਾਗਤ ਘੱਟ ਹੋਈ, ਵਧੀਆ ਅਮਲ ਸਾਂਝੇ ਹੋ ਸਕੇ, ਅਤੇ ਡਿਵੈਲਪੜਾਂ ਨੂੰ ਆਪਣੇ ਉਤਪਾਦ ਦੀਆਂ ਖ਼ਾਸ ਲੋੜਾਂ 'ਤੇ ਧਿਆਨ ਕਰਨ ਦੀ ਆਜ਼ਾਦੀ ਮਿਲੀ।
Lucene ਨੇ “ਖੋਜ” ਨੂੰ ਐਸਾ ਫੀਚਰ ਬਣਾਇਆ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਉਤਪਾਦ ਵਿੱਚ ਜੋੜ ਸਕਦੇ ਸੀ, ਨਾ ਕਿ ਇੱਕ ਰੀਸਰਚ ਪ੍ਰੋਜੈਕਟ ਜੋ ਤੁਹਾਨੂੰ ਨਵੇਂ ਸਿਰੇ ਤੋਂ ਲੈ ਕੇ ਜਾਣਾ ਪਏ। ਮੁੱਢ 'ਤੇ, ਇਹ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਗੰਦੇ ਟੈਕਸਟ ਨੂੰ ਐਸੇ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਉਸਨੂੰ ਤੇਜ਼ ਅਤੇ ਸਥਿਰ ਤਰੀਕੇ ਨਾਲ ਖੋਜ ਸਕੋ।
Lucene ਚਾਰ ਪ੍ਰਯੋਗਿਕ ਕੰਮਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਿਤ ਕਰਦਾ ਹੈ:
Lucene ਪਹਿਲਾਂ (ਅਤੇ ਹੁਣ ਵੀ) ਦੈਨੀਕ ਖੋਜ ਲੋੜਾਂ ਲਈ ਵਧੀਆ ਸੀ:
Lucene ਦੀ ਖ਼ਾਸੀਅਤ ਕੋਈ ਜਾਦੂ ਨਹੀਂ ਸੀ—ਇਹ ਵਰਤਣ ਯੋਗਤਾ ਸੀ:
Lucene ਨੇ ਸਿਰਫ ਇੱਕ ਕੰਪਨੀ ਦੀ ਸਮੱਸਿਆ ਨਹੀਂ ਹੱਲ ਕੀਤੀ; ਇਹ ਇੱਕ ਭਰੋਸੇਯੋਗ ਬੇਸ ਲੇਅਰ ਬਣ ਗਿਆ ਜਿਸ 'ਤੇ ਕਈ ਖੋਜ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਸਰਵਿਸਜ਼ ਨੇ ਨਿਰਮਾਣ ਕੀਤਾ। ਬਹੁਤ ਸਾਰੇ ਬਾਅਦ ਦੇ ਖੋਜ ਟੂਲਾਂ ਨੇ Lucene ਦੇ ਇੰਡੈਕਸਿੰਗ ਅਤੇ relevance ਢੰਗ ਨੂੰ ਧਾਰ ਕੀਤਾ—ਜਾਂ ਸਿੱਧਾ Lucene ਨੂੰ ਅੰਦਰੂਨੀ ਇੰਜਣ ਵਜੋਂ ਵਰਤਿਆ।
ਲੌਗਸ, ਕਲਿਕਸਟਰੀਮ, ਈਮੇਲ ਆਰਕਾਈਵ, ਸੈਂਸਰ ਰੀਡਿੰਗ ਅਤੇ ਵੈੱਬ ਪੇਜਾਂ ਸਾਰੀਆਂ ਇਸ ਸਾਦੇ ਗੁਣ ਨੂੰ ਸਾਂਝਾ ਕਰਦੀਆਂ ਹਨ: ਉਹ ਉਸ ਰਫਤਾਰ ਨਾਲ ਵਧਦੀਆਂ ਹਨ ਜੋ ਤੁਸੀਂ ਪਿਛਲੇ ਸਾਲ ਖਰੀਦੇ ਸਰਵਰਾਂ ਦੀ ਦੇਣਸ਼ਕਤੀ ਤੋਂ ਤੇਜ਼ ਹੈ। ਇਕ ਵਾਰੀ ਟੀਮਾਂ “ਸਭ ਕੁਝ ਰੱਖਣ” ਲੱਗੀਆਂ, ਡੇਟਾਸੇਟ ਇੱਕ ਸਰਵਰ 'ਤੇ ਫਿੱਟ ਹੋਣਾ ਰੋਕ ਦਿਤਾ—ਨਾ ਸਿਰਫ ਸਟੋਰੇਜ ਵਿੱਚ, ਬਲਕਿ ਉਹ ਸਮਾਂ ਵਿੱਚ ਵੀ ਜੋ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਲੱਗਦਾ।
ਪਹਿਲੀ ਪ੍ਰਤੀਕਿਰਿਆ ਸਕੇਲ-ਅੱਪ ਸੀ: ਵੱਧ CPU, ਵੱਧ RAM, ਵੱਡੇ ਡਿਸਕ। ਇਹ ਚੱਲਦਾ ਹੈ…ਜਦ ਤਕ ਉਹ ਨਹੀਂ ਕਰਦਾ।
ਹਾਈ-ਐਂਡ ਸਰਵਰ ਤੇਜ਼ੀ ਨਾਲ ਮਹਿੰਗੇ ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਕੀਮਤ ਉੱਚੀ ਹੋਣ 'ਤੇ ਲੀਕੇ ਨਹੀਂ ਹੁੰਦੀ। ਤੁਸੀਂ ਆਪਣੇ ਪੂਰੇ ਪਾਇਪਲਾਈਨ 'ਤੇ ਇਕ ਹੀ ਬਾਕਸ ਤਹ ਨਿਰਭਰ ਹੋ ਜਾਂਦੇ ਹੋ। ਜੇ ਇਹ ਫੇਲ ਹੋ ਜਾਵੇ, ਸਭ ਕੁਝ ਫੇਲ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਭਾਵੇਂ ਫੇਲ ਨ ਹੋਵੇ, ਫਿਜ਼ਿਕਲ ਸੀਮਾਵਾਂ ਹਨ: ਡਿਸਕ ਇੱਕ ਨਿਰਧਾਰਿਤ ਰਫਤਾਰ 'ਤੇ ਘੁੰਮ ਸਕਦੇ ਹਨ, ਮੈਮੋਰੀ ਦੀ ਛੱਤ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਕੁਝ ਵਰਕਲੋਡ ਇਸ ਤਰ੍ਹਾਂ ਹੁੰਦੇ ਹਨ ਜੋ ਡੇਟਾ ਜਿਵੇਂ-ਜਿਵੇਂ ਡਬਲ ਹੁੰਦਾ ਹੈ, ਸਮੇਂ 'ਚ ਮੁਕੰਮਲ ਨਹੀਂ ਹੁੰਦੇ।
ਸਕੇਲ-ਆਊਟ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਨੂੰ ਉਲਟ ਦਿੰਦਾ ਹੈ। ਇਕ ਤਾਕਤਵਰ ਕੰਪਿਊਟਰ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਕਈ ਆਮ ਕੰਪਿਊਟਰ ਵਰਤਦੇ ਹੋ ਅਤੇ ਕੰਮ ਵੰਡ ਦਿੰਦੇ ਹੋ।
ਇੱਕ ਮਦਦਗਾਰ ਮਾਨਸਿਕ ਮਾਡਲ ਹੈ: ਇਕ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਪਰਿਵਾਹ ਦਿਨ—ਇੱਕ ਵਿਅਕਤੀ ਭਾਰੀਆਂ ਡੱਬਿਆਂ ਨੂੰ ਥਾਮ ਸਕਦਾ ਹੈ, ਪਰ ਦਸ ਲੋਕ ਛੋਟੀਆਂ ਡੱਬੀਆਂ ਲੈ ਕੇ ਜਲਦੀ ਮੁਕੰਮਲ ਕਰ ਲੈਂਦੇ ਹਨ—ਅਤੇ ਜੇ ਇਕ ਥੱਕ ਜਾਂਦਾ ਹੈ ਤਾਂ ਬਾਕੀ ਫਿਰ ਵੀ ਅੱਗੇ ਬਢੰਦੇ ਹਨ। ਵੰਡਿਆ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਇਸੇ ਵਿਚਾਰ ਨੂੰ ਸਟੋਰੇਜ ਅਤੇ ਗਣਨਾ 'ਤੇ ਲਾਗੂ ਕਰਦਾ ਹੈ।
ਕਈ ਸਸਤੇ ਮਸ਼ੀਨਾਂ ਵਰਤਣ ਨਾਲ ਨਵਾਂ ਅਨੁਮਾਨ ਆਉਂਦਾ ਹੈ: ਕੁਝ ਨਾ ਕੁਝ ਹਮੇਸ਼ਾ ਟੁੱਟ ਰਿਹਾ ਹੁੰਦਾ ਹੈ। ਡਿਸਕ ਖਰਾਬ ਹੁੰਦੇ ਹਨ, ਨੈੱਟਵਰਕ ਹਿੱਕਪ ਕਰਦੇ ਹਨ, ਨੋਡਸ ਰੀਬੂਟ ਹੁੰਦੇ ਹਨ।
ਇਸ ਲਈ ਲਕੜੀ ਇਹ ਬਣ ਗਈ ਕਿ ਸਿਸਟਮ ਫੇਲਿਅਰ ਦੀ ਉਮੀਦ ਕਰੇ ਅਤੇ ਚੱਲਦਾ ਰਹੇ—ਡੇਟਾ ਦੀਆਂ ਕਾਪੀਆਂ ਰੱਖ ਕੇ, ਇਹ ਟਰੈਕ ਕਰਕੇ ਕਿ ਨੌਕਰੀਆਂ ਦੇ ਕਿਹੜੇ ਹਿੱਸੇ ਮੁੱਕ ਗਏ ਹਨ, ਅਤੇ ਆਪੋ-ਆਪਣੇ ਤੌਰ 'ਤੇ ਉਸ ਹਿੱਸੇ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਕੇ ਜੋ ਰੁਕ ਗਏ ਸਨ। ਇਹ ਦਬਾਅ—ਇੱਕ ਮਸ਼ੀਨ ਤੋਂ ਵੱਧ ਡੇਟਾ, ਅਤੇ ਵੱਡੇ ਪੈਮाने 'ਤੇ ਅਕਸਰ ਫੇਲਿਅਰ—Hadoop ਦੀ ਵੰਡਿਆ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਰਵੱਈਏ ਲਈ ਸੈੱਟ ਕਰਦਾ ਹੈ।
Hadoop ਨੂੰ ਸਭ ਤੋਂ ਅਸਾਨ ਤਰੀਕੇ ਨਾਲ ਦੋ ਸਧਾਰਨ ਵਾਅਦਿਆਂ ਵਜੋਂ ਸਮਝਿਆ ਜਾ ਸਕਦਾ ਹੈ: ਕਈ ਆਮ ਮਸ਼ੀਨਾਂ 'ਤੇ ਬਹੁਤ ਵੱਡਾ ਡੇਟਾ ਸਟੋਰ ਕਰੋ ਅਤੇ ਉਹ ਡੇਟਾ ਸਮਕਾਲੀ ਤੌਰ 'ਤੇ ਪ੍ਰੋਸੈਸ ਕਰੋ। ਇਹ ਦੋ ਕੋਰ ਹਿੱਸਿਆਂ ਵਜੋਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ: HDFS ਸਟੋਰੇਜ ਲਈ ਅਤੇ MapReduce ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ।
HDFS (Hadoop Distributed File System) ਉਹਨਾਂ ਫਾਇਲਾਂ ਨੂੰ ਜੋ ਇੱਕ ਕੰਪਿਊਟਰ ਲਈ ਬਹੁਤ ਵੱਡੀਆਂ ਹਨ, ਨਿਰਧਾਰਿਤ-ਆਕਾਰ ਦੇ ਬਲੌਕ ਵਿੱਚ ਵੰਡਦਾ ਹੈ (ਸੋਚੋ “ਚੰਕਸ”)। ਉਹ ਬਲੌਕਜ਼ ਫਿਰ ਕਲੱਸਟਰ ਦੀਆਂ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ 'ਤੇ ਫੈਲੇ ਹੋਏ ਹੁੰਦੇ ਹਨ।
ਮਸ਼ੀਨ ਫੇਲ ਹੋ ਜਾਣ 'ਤੇ ਡੇਟਾ ਸੁਰੱਖਿਅਤ ਰਹੇ, ਇਹ ਲਈ HDFS ਹਰ ਬਲੌਕ ਦੀਆਂ ਕਾਪੀਆਂ ਵੀ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ 'ਤੇ ਰੱਖਦਾ ਹੈ। ਜੇ ਇਕ ਕੰਪਿਊਟਰ ਡਾਊਨ ਹੋ ਜਾਏ, ਸਿਸਟਮ ਫਿਰ ਵੀ ਫਾਇਲ ਨੂੰ ਹੋਰ ਕਾਪੀ ਤੋਂ ਪੜ੍ਹ ਸਕਦਾ ਹੈ—ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਬੈਕਅੱਪਾਂ ਦੀ تلاش ਕਰਨ ਦੇ।
ਪਰੈਕਟਿਕਲ ਨਤੀਜਾ: HDFS ਵਿੱਚ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਇੱਕ ਆਮ ਫੋਲਡਰ ਵਾਂਗ ਵਰਤਦੀ ਹੈ, ਪਰ ਪਿਛੋਕੜ ਵਿੱਚ ਇਹ ਕਈ ਡਿਸਕਾਂ ਤੋਂ ਜੁੜੀ ਹੋਈ ਹੁੰਦੀ ਹੈ।
MapReduce ਇੱਕ ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਮਾਡਲ ਹੈ। ਇਸਦੇ ਦੋ ਨਾਮਿਤ ਚਰਣ ਹਨ:
ਇੱਕ ਲਾਜ਼ਮੀ ਉਦਾਹਰਣ ਬਹੁਤ ਸਾਰੀਆਂ ਲੋਗ ਫਾਈਲਾਂ 'ਚ ਸ਼ਬਦ ਗਿਣਤੀ ਕਰਨ ਦੀ ਹੈ: ਮੈਪਰ ਆਪਣੇ ਚੰਕਸ ਵਿੱਚ ਸ਼ਬਦ ਗਿਣਦੇ ਹਨ; ਰੀਡਿਊਸਰ ਹਰ ਸ਼ਬਦ ਲਈ ਕੁੱਲ ਜੋੜਦੇ ਹਨ।
HDFS + MapReduce ਨੂੰ ਇਕੱਠਾ ਕਰਕੇ ਵੱਡੇ ਬੈਚ ਜੌਬਸ—ਲਾਗ ਵਿਸ਼ਲੇਸ਼ਣ, ਇੰਡੈਕਸਿੰਗ ਪਾਈਪਲਾਈਨ, ਕਲਿਕਸਟ੍ਰੀਮ ਐਗਰੀਗੇਸ਼ਨ, ਡੇਟਾ ਸਫਾਈ—ਉਹਨਾਂ ਡੇਟਾਸੇਟਸ 'ਤੇ ਚਲਾਉਣਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਣ ਗਿਆ ਜੋ ਇਕ ਸਰਵਰ ਲਈ ਬਹੁਤ ਵੱਡੇ ਸਨ। ਇੱਕ ਵੱਡੇ ਮਸ਼ੀਨ ਨੂੰ ਖਰੀਦਣ ਦੀ ਥਾਂ, ਟੀਮਾਂ ਹੋਰ ਆਮ ਬਾਕਸ ਮਿਲਾ ਕੇ ਸਕੇਲ ਕਰ ਸਕਦੀਆਂ ਸਨ ਅਤੇ Hadoop ਸਟੋਰੇਜ, ਰੀਟ੍ਰਾਈਜ਼, ਅਤੇ ਸਮਕਾਲੀ ਐਕਸਿਕਿ600ਨ ਕੋਆਰਡੀਨੇਟ ਕਰਦਾ।
Lucene ਅਤੇ Hadoop ਵੱਖ-ਵੱਖ ਅਧਿਆਇ ਵਰਗੇ ਦਿੱਸ ਸਕਦੇ ਹਨ—ਇੱਕ ਖੋਜ ਬਾਰੇ, ਦੂਜਾ “ਬਿਗ ਡੇਟਾ” ਬਾਰੇ। ਪਰ ਉਹ ਇੱਕ ਹੀ ਮਨੋਭਾਵ ਸਾਂਝਾ ਕਰਦੇ ਹਨ: ਕਾਰਗਰ ਟੂਲ ਬਣਾਓ ਜੋ ਅਸਲ ਟੀਮਾਂ ਚਲਾ ਸਕਣ, ਵਧਾ ਸਕਣ ਅਤੇ ਭਰੋਸਾ ਕਰ ਸਕਣ, ਨ ਕਿ ਸਿਰਫ ਇਕ ਚਤੁਰ ਨਮੂਨਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ ਅਤੇ ਅੱਗੇ ਵਧੋ।
Lucene ਨੇ ਇੱਕ-ਦੋ ਮੁਸ਼ਕਲ ਕੰਮ ਬਹੁਤ ਖੁਬ ਕੀਤੇ—ਇੰਡੈਕਸਿੰਗ, ਕਵੇਰੀ ਅਤੇ ਰੈਂਕਿੰਗ—ਇਹਨਾਂ ਨੂੰ ਇਕ ਲਾਇਬ੍ਰੇਰੀ ਵਜੋਂ ਪੈਕ ਕੀਤਾ ਜੋ ਕੋਈ ਵੀ ਐਪ ਵਿੱਚ ਏਂਬੇਡ ਕਰ ਸਕਦਾ। ਇਸ ਚੋਣ ਨੇ ਇਹ ਸਿਖਾਇਆ: ਗ੍ਰਹਿਣਯੋਗਤਾ ਉਪਯੋਗੀਤਾ ਨਾਲ ਆਉਂਦੀ ਹੈ। ਜੇ ਇੱਕ ਟੂਲ ਵਰਤਣਾ ਆਸਾਨ, ਡੀਬੱਗਬਲ ਅਤੇ ਚੰਗੀ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਵਾਲਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਆਪਣੀ ਮੂਲ ਵਰਤੋਂ ਤੋਂ ਬਾਹਰ ਵੀ ਫੈਲ ਜਾਂਦਾ ਹੈ।
Hadoop ਨੇ ਉਹੀ ਦ੍ਰਿਸ਼ਟੀ Distributed ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ 'ਤੇ ਲਗਾਈ। ਇਹ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਕਿ ਨਿਸ਼ਚਿਤ ਹਾਰਡਵੇਅਰ ਜਾਂ ਨੀਚ ਪ੍ਰਣਾਲੀਆਂ ਦੀ ਲੋੜ ਨਹੀਂ, ਪਰ ਆਮ ਮਸ਼ੀਨਾਂ 'ਤੇ ਚੱਲਣ ਦੀ ਯੋਗਤਾ ਹੋਵੇ ਅਤੇ ਉਨ੍ਹਾਂ ਦੁਆਰਾ ਉਹ ਦਿਨ-ਪ੍ਰਤੀਦਿਨ ਦਾ ਦਰਦ ਹੱਲ ਹੋ ਜਾਵੇ—ਡੇਟਾ ਜੋ ਇਕ ਹੀ ਸਰਵਰ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦਾ।
ਜੇ ਤੁਹਾਡਾ ਡੇਟਾ ਵੱਡਾ ਹੈ, ਤਾਂ ਉਹਨੂੰ ਨੈੱਟਵਰਕ 'ਤੇ ਇੱਕ ਤਾਕਤਵਰ ਮਸ਼ੀਨ ਨੂੰ ਕਾਪੀ ਕਰਨਾ ਉਸੇ ਤਰ੍ਹਾਂ ਹੈ ਜਿਵੇਂ ਲਾਇਬ੍ਰੇਰੀ ਦੀਆਂ ਸਾਰੀਆਂ ਕਿਤਾਬਾਂ ਨੂੰ ਇੱਕ ਡੈਸਕ ਤੇ ਲਿਆਉਣਾ। Hadoop ਦਾ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਕੰਮ ਉਸੇ ਜਗ੍ਹਾ ਭੇਜੋ ਜਿੱਥੇ ਡੇਟਾ ਪਹਿਲਾਂ ਹੀ ਹੁੰਦਾ ਹੈ: ਛੋਟੇ-ਟੁਕੜੇ ਕੋਡ ਨੂੰ ਕਈ ਮਸ਼ੀਨਾਂ 'ਤੇ ਭੇਜੋ, ਹਰ ਇਕ ਆਪਣਾ ਸਥਾਨਕ ਕੰਮ ਕਰੋ, ਫਿਰ ਨਤੀਜੇ ਜੋੜੋ।
ਇਹ ਵਿਚਾਰ ਖੋਜ ਇੰਡੈਕਸਿੰਗ ਨਾਲ ਮਿਲਦਾ ਹੈ: ਤੁਸੀਂ ਡੇਟਾ ਨੂੰ ਉਸ ਥਾਂ ਸੱਜਾ ਦਿੰਦੇ ਹੋ (ਇੰਡੈਕਸ) ਤਾਂ ਜੋ ਕਵੇਰੀਆਂ ਹਰ ਵਾਰੀ ਸਭ ਕੁਝ ਸਕੈਨ ਨਾ ਕਰਨ।
ਦੋਹਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਓਪਨ ਸਹਿਯੋਗ ਤੋਂ ਲਾਭ ਮਿਲਿਆ: ਯੂਜ਼ਰ ਬੱਗ ਰਿਪੋਰਟ ਕਰ ਸਕਦੇ ਸਨ, ਫਿਕਸਜ਼ ਸਬਮਿਟ ਕਰ ਸਕਦੇ ਸਨ, ਅਤੇ ਓਪਰੇਸ਼ਨਲ ਗਿਆਨ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਸਨ। ਅਡਾਪਸ਼ਨ ਦੇ ਮੁੱਖ ਚਾਲਕ ਸੀ ਸਧਾਰਨ ਪਰ ਨਿਸ਼ਚਿਤ ਚੀਜ਼ਾਂ—ਸਪਸ਼ਟ ਦਸਤਾਵੇਜ਼ੀਕਰਨ, ਵਾਤਾਵਰਨਾਂ 'ਚ ਪੋ੍ਰਟੇਬਿਲਟੀ, ਅਤੇ Apache ਸਕੀਮ ਜੋ ਕੰਪਨੀਆਂ ਨੂੰ ਇਹ ਯਕੀਨ ਦਿਵਾਉਂਦੀ ਸੀ ਕਿ ਉਹ ਰੁਕ-ਵੈਂਡਰ ਲਾਕ-ਇਨ ਦੀ ਚਿੰਤਾ ਨਾ ਕਰਨ।
Hadoop ਇਸ ਲਈ ਫੈਲਿਆ ਨਹੀਂ ਕਿ ਟੀਮਾਂ ਸਵੇਰ-ਸਵੇਰ "ਬਿਗ ਡੇਟਾ" ਚਾਹੁੰਦੀਆਂ ਸਨ। ਇਹ ਫੈਲਿਆ ਕਿਉਂਕਿ ਕੁਝ ਆਮ ਕੰਮ ਉਸ ਵੇਲੇ ਇਕ ਸਰਵਰ ਅਤੇ ਰਵਾਇਤੀ ਡੇਟਾਬੇਸ 'ਤੇ ਮਹਿੰਗੇ ਅਤੇ ਅਣ-ਭਰੋਸੇਯੋਗ ਹੋ ਰਹੇ ਸਨ।
ਲੌਗ ਪ੍ਰੋਸੈਸਿੰਗ ਇੱਕ ਪਹਿਲੀ ਵੱਡੀ ਜਿੱਤ ਸੀ। ਵੈੱਬ ਸਰਵਰ, ਐਪਸ, ਅਤੇ ਨੈੱਟਵਰਕ ਡਿਵਾਈਸ ਬਹੁਤ ਮਾਤਰਾ ਵਿੱਚ ਐਪੈਂਡ-ਓਨਲੀ ਰਿਕਾਰਡ ਜਨਰੇਟ ਕਰਦੇ ਹਨ। ਟੀਮਾਂ ਨੂੰ ਰੋਜ਼ਾਨਾ (ਜਾਂ ਘੰਟੇਦਾਰ) ਰੂਪ-ਸਾਰੈਂਪਜ: ਐਰਰਜ਼ ਬਾਇ ਐਂਡਪੋਇੰਟ, ਲੇਟੈਂਸੀ ਪ੍ਰਤੀਸ਼ਤ, ਖੇਤਰ-ਅਨੁਸਾਰ ਟ੍ਰੈਫਿਕ, ਟਾਪ ਰੀਫਰਰ ਆਦਿ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। Hadoop ਨੇ ਉਨ੍ਹਾਂ ਨੂੰ ਕੱਚੇ ਲੌਗ HDFS ਵਿੱਚ ਡਾਲ ਕੇ ਨਿਰਧਾਰਿਤ ਸਮੇਂ ਤੇ ਸੰਖੇਪ ਪੁਸਤਕ ਬਣਾਉਣ ਦੀ ਆਸਾਨੀ ਦਿੱਤੀ।
ਕਲਿਕਸਟ੍ਰੀਮ ਵਿਸ਼ਲੇਸ਼ਣ ਨੇ ਕੁਝ ਹੀ ਦੇਰ ਵਿੱਚ ਅਨੁਕੂਲਤਾ ਪਾਈ। ਪ੍ਰੋਡਕਟ ਟੀਮਾਂ ਜਾਣਨਾ ਚਾਹੁੰਦੀਆਂ ਸਨ ਕਿ ਉਪਭੋਗਤਾ ਕਿਸ ਤਰ੍ਹਾਂ ਯਾਤਰਾ ਕਰਦੇ ਹਨ—ਕਿਸ ਤੇ ਕਲਿੀ ਕੀਤਾ ਗਿਆ ਪਹਿਲਾਂ, ਕਿੱਥੇ ਉਹ ਰੁਕਦੇ ਹਨ, ਕੋਹੋਰਟ ਕਿਵੇਂ ਵਰਤ ਰਹੇ ਹਨ। ਇਹ ਡੇਟਾ ਗੰਦ ਅਤੇ ਉੱਚ-ਵਾਲਿਊਮ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਅਕਸਰ ਵੱਡੇ ਏਗਰੀਗੇਟ ਤੋਂ ਆਉਂਦਾ ਹੈ ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਲੁੱਕਅਪਸ ਤੋਂ।
ETL (extract, transform, load) ਇੱਕ ਮੂਲ ਵਰਤੋਂ ਕੇਸ ਬਣ ਗਿਆ। ਸੰਗਠਨਾਂ ਕੋਲ ਡੇਟਾ ਵੱਖ-ਵੱਖ ਡੇਟਾਬੇਸ, ਫਾਇਲਾਂ, ਅਤੇ ਵੇਨਡਰ ਐਕਸਪੋਰਟਸ ਵਿੱਚ ਫੈਲਾ ਹੋਇਆ ਹੁੰਦਾ ਸੀ। Hadoop ਨੇ ਕੱਚਾ ਡੇਟਾ ਲੈਂਡ ਕਰਨ, ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ ਰੂਪਾਂਤਰ ਕਰਨ, ਅਤੇ ਫਿਰ curated ਨਤੀਜੇ ਡੇਟਾ ਵੈਅਰਹਾਊਸ ਜਾਂ ਡਾਊਨਸਟਰੀਮ ਸਿਸਟਮਾਂ ਵਿੱਚ ਲੋਡ ਕਰਨ ਲਈ ਕੇਂਦਰੀ ਥਾਂ ਦਿੱਤੀ।
ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਵਰਕਫਲੋ ਬੈਚ ਸਨ: ਤੁਸੀਂ ਇੱਕ ਖਿੜਕੀ ਦੇ ਦੌਰਾਨ (ਕਹੋ ਇੱਕ ਘੰਟਾ ਜਾਂ ਦਿਨ) ਡੇਟਾ ਇਕਠਾ ਕਰਦੇ ਹੋ, ਫਿਰ ਇਸ ਨੂੰ ਇੱਕ ਨੌਕਰੀ ਵਜੋਂ ਪ੍ਰੋਸੈਸ ਕਰਦੇ ਹੋ ਜੋ ਮਿੰਟਾਂ ਜਾਂ ਘੰਟਿਆਂ ਲੱਗ ਸਕਦੀ ਹੈ। ਬੈਚ ਸਾਰੀਆਂ ਰੁਪਾਂਤਰ ਤੇਜ਼ੀ ਨਾਲ ਨਹੀਂ ਮੰਗਦਾ—ਇਹ ਉਤਮ ਹੈ ਜਦ ਸਵਾਲ ਰੁਝਾਨਾਂ ਅਤੇ ਕੁੱਲਤਾਂ ਬਾਰੇ ਹੋਵੇ, ਨਾ ਕਿ ਤੁਰੰਤ ਪ੍ਰਤੀ-ਯੂਜ਼ਰ ਜਵਾਬ ਲਈ।
ਵਾਸਤਵ ਵਿੱਚ, ਇਸਦਾ ਮਤਲਬ ਸੀ ਕਿ Hadoop ਰਾਤ-भर ਰਿਪੋਰਟਿੰਗ, ਪੀਰੀਓਡਿਕ ਡੈਸ਼ਬੋਰਡ ਅਤੇ ਵੱਡੇ ਬੈਕਫਿਲਸ ("ਨਵੇਂ ਲਾਜਿਕ ਨਾਲ ਪਿਛਲੇ ਸਾਲ ਦੀ ਮੁੜ-ਗਣਨਾ") ਦਾ ਢਾਂਚਾ ਸੀ। ਇਹ ਇੰਟਰਐਕਟਿਵ, ਉਪ-ਸੈਕਿੰਡ ਖੋਜ ਲਈ ਨਹੀਂ ਬਣਿਆ ਸੀ।
ਇੱਕ ਵੱਡੀ ਚੀਜ਼ ਸੀ ਸਸਤੀ ਪ੍ਰੋਸੈਸਿੰਗ: ਇੱਕ ਮਹਿੰਗੇ ਇਕ-ਬਕਸ ਨੂੰ ਸਕੇਲ-ਅੱਪ ਕਰਨ ਦੀ ਥਾਂ, ਕਾਮੋਡੀਟੀ ਹਾਰਡਵੇਅਰ ਨਾਲ ਸਕੇਲ-ਆਊਟ।
ਹੋਰ ਇੱਕ ਸੀ ਰਿਡੰਡੈੰਸੀ ਰਾਹੀਂ ਭਰੋਸੇਯੋਗਤਾ। HDFS ਡੇਟਾ ਬਲੌਕਾਂ ਦੀਆਂ ਕਈ ਕਾਪੀਆਂ ਰੱਖਦਾ ਹੈ, ਇਸ ਲਈ ਨੋਡ ਫੇਲ ਹੋਣ 'ਤੇ ਡੇਟਾ ਗੁਆਉਣ ਜਾਂ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀ ਹੁੰਦੀ।
Hadoop ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਟੈਕ ଇੰਟਰਐਕਟਿਵ ਕਵੇਰੀਆਂ ਲਈ ਢਿੱਲਾ ਹੋ ਸਕਦੀ ਸੀ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਡੇਟਾਬੇਸਾਂ ਦੇ ਮੁਕਾਬਲੇ ਜੋ ਤੇਜ਼ ਰੀਡ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਸਨ।
ਇਸ ਨੇ ਓਪਰੇਸ਼ਨਲ ਜਟਿਲਤਾ ਵੀ ਲਾਈ: ਕਲੱਸਟਰਾਂ ਦਾ ਪ੍ਰਬੰਧਨ, ਜੌਬ ਸਥਾਪਨਾ, ਡੇਟਾ ਫਾਰਮੈਟ, ਅਤੇ ਬਹੁਤ-ਸਾਰੀਆਂ ਮਸ਼ੀਨਾਂ 'ਤੇ ਫੇਲਿਅਰਾਂ ਨੂੰ ਟ੍ਰਬਲਸ਼ੂਟ ਕਰਨਾ। ਅੰਦਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਜਦ ਟੀਮ ਕੋਲ ਇੱਕ ਸਪਸ਼ਟ ਬੈਚ ਵਰਕਲੋਡ ਅਤੇ ਪਾਈਪਲਾਈਨ ਨੂੰ ਸਥਿਰ ਕਰਨ ਦੀ ਅਨੁਸ਼ਾਸਨ ਹੋਵੇ, ਤਾਂ ਗ੍ਰਹਿਣਯੋਗਤਾ ਜ਼ਿਆਦਾ ਹੋਣੀ ਸੀ—ਬਜਾਏ ਇਹ ਕਿ Hadoop ਨੂੰ ਹਰ ਕੰਮ ਲਈ ਮਜ਼ਬੂਰ ਕੀਤਾ ਜਾਵੇ।
Lucene ਅਤੇ Hadoop ਵੱਖ-ਵੱਖ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਦੇ ਹਨ, ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਇੱਕੱਠੇ ਬਹੁਤ ਹੀ ਸੁਟਦੇ ਬਣਾਉਂਦਾ ਹੈ।
Lucene ਤੇਜ਼ ਰੀਟਰੀਵਲ ਬਾਰੇ ਹੈ: ਇਹ ਇੱਕ ਇੰਡੈਕਸ ਬਣਾਉਂਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਟੈਕਸਟ ਅਤੇ ਸੰਰਚਿਤ ਫੀਲਡਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਖੋਜ ਸਕੋ (ਸੋਚੋ “ਇਸ ਕਵੇਰੀ ਲਈ 200 ਸਭ ਤੋਂ ਪ੍ਰਸੰਗਿਕ ਘਟਨਾਵਾਂ ਹੁਣੇ ਦਿਖਾਓ”)।
Hadoop ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਬਾਰੇ ਹੈ: ਇਹ ਉਨ੍ਹਾਂ ਨੂੰ ਵਿਸ਼ਵਾਸਯੋਗ ਤਰੀਕੇ ਨਾਲ HDFS ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਸਮਕਾਲੀ ਤੌਰ 'ਤੇ ਪ੍ਰੋਸੈਸ ਕਰਦਾ ਹੈ (ਇਤਿਹਾਸਕ ਤੌਰ 'ਤੇ MapReduce) ਤਾਂ ਜੋ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਤਬਦੀਲ, ਏਗਰੀਗੇਟ ਅਤੇ ਰਿਚ-ਕਰ ਸਕੋ ਜੋ ਇਕ ਸਰਵਰ ਲਈ ਬਹੁਤ ਵੱਡੇ ਹੋ।
ਸਧਾਰਨ ਤੌਰ 'ਤੇ: Hadoop ਡੇਟਾ ਤਿਆਰ ਅਤੇ ਕ੍ਰੰਚ ਕਰਦਾ ਹੈ; Lucene ਨਤੀਜਿਆਂ ਨੂੰ ਖੋਜਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।
ਕਲਪਨਾ ਕਰੋ ਤੁਹਾਡੇ ਕੋਲ ਮਹੀਨੇ ਭਰ ਦੇ ਕੱਚੇ ਐਪਲੀਕੇਸ਼ਨ ਲੌਗ ਹਨ।
ਹੁਣ ਤੁਹਾਨੂੰ ਦੋਹਾਂ ਦਾ ਵਧੀਆ ਮਿਲਾਪ ਮਿਲਦਾ ਹੈ: ਵੱਡੇ ਕੱਚੇ ਡੇਟਾ 'ਤੇ ਭਾਰੀ-ਡਿਾਨ ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ, ਨਾਲ ਹੀ ਇੰਟਰਐਕਟिव ਖੋਜ ਜਾਂਚ ਲਈ Lucene।
ਐਨਾਲਿਟਿਕਸ ਅਕਸਰ “ਕُل ਕੀ ਹੋਇਆ?” ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਖੋਜ ਮਦਦ ਕਰਦੀ ਹੈ “ਮੈਨੂੰ ਵਿਸ਼ੇਸ਼ ਸਬੂਤ ਦਿਖਾਓ”। Hadoop ਨੇ ਵੱਡੇ ਇਨਪੁੱਟ ਤੋਂ ਨਿਕਲੇ ਡੇਰੀਵਡ ਡੇਟਾਸੇਟ ਨੂੰ ਗਣਨਾ ਕਰਨਯੋਗ ਬਣਾਇਆ; Lucene ਨੇ ਉਹਨਾਂ ਡੇਟਾਸੇਟਸ ਨੂੰ ਖੋਜਯੋਗ ਬਣਾਇਆ—ਫਾਇਲਾਂ ਦੇ ਢੇਰ ਨੂੰ ਕੁਝ ਇਸੇ ਤਰ੍ਹਾਂ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਕਿ ਲੋਕ ਅਸਲ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਨੇਵੀਗੇਟ ਕਰ ਸਕਣ।
ਇਹ ਜੋੜ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ। ਜੇ ਤੁਸੀਂ ਡੇਟਾ ਨੂੰ ਇਕ ਸਰਵਰ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਫਿੱਟ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੈਨੇਜਡ ਖੋਜ ਅਤੇ ਮੈਨੇਜਡ ਐਨਾਲਿਟਿਕਸ ਤੁਹਾਡੇ ਲੋੜਾਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਪੂਰਾ ਕਰ ਰਹੇ ਹਨ, ਤਾਂ Hadoop + Lucene ਨੂੰ ਇਕ-ਦੂਜੇ ਨਾਲ ਵਾਇਰਿੰਗ ਕਰਨਾ ਓਪਰੇਸ਼ਨਲ ਔਬਰਹੈੱਡ ਵਧਾ ਸਕਦਾ ਹੈ। ਜੋੜ ਇਸ ਵੇਲੇ ਵਰਤੋ ਜਦ ਤੁਹਾਨੂੰ ਦੋਹਾਂ ਦੀ ਸੱਚਮੁਚ ਲੋੜ ਹੋਵੇ: ਵੱਡੇ ਪੈਮਾਨੇ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਤੇਜ਼, ਲਚਕੀਲੀ ਖੋਜ।
Hadoop ਸਿਰਫ਼ ਵੱਡੀਆਂ ਫਾਇਲਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਦਾ ਨਵਾਂ ਤਰੀਕਾ ਨਹੀਂ ਦਿੱਤਾ; ਇਸਨੇ ਕਈ ਸੰਗਠਨਾਂ ਨੂੰ ਇੱਕ ਸਾਂਝੇ ਡੇਟਾ ਪਲੇਟਫਾਰਮ ਦੀ ਸੋਚ ਵੱਲ ਮੋੜ ਦਿੱਤਾ। ਹਰ ਵਾਰੀ ਹਰ ਵਿਸ਼ਲੇਸ਼ਣ ਪ੍ਰਾਜੈਕਟ ਲਈ ਵੱਖਰਾ ਸਿਸਟਮ ਬਣਾਉਣ ਦੀ ਥਾਂ, ਟੀਮਾਂ ਇੱਕ ਵਾਰ ਕੱਚਾ ਡੇਟਾ ਲੈਂਡ ਕਰ ਸਕਦੀਆਂ ਸਨ, ਉਹਨੂੰ ਸਸਤੇ ਤਰੀਕੇ ਨਾਲ ਰੱਖ ਸਕਦੀਆਂ ਸਨ, ਅਤੇ ਵੱਖ-ਵੱਖ ਗਰੁੱਪ ਵੱਖ-ਵੱਖ ਸਵਾਲਾਂ ਲਈ ਦੁਬਾਰਾ ਵਰਤ ਸਕਦੇ ਸਨ।
ਜਿਵੇਂ HDFS-ਸਟਾਈਲ ਸਟੋਰੇਜ ਅਤੇ ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ ਜਾਣ ਪਛਾਣ ਹੋਏ, ਇੱਕ ਪੈਟਰਨ ਉਭਰਿਆ: ਡੇਟਾ ਕੇਂਦਰੀ ਬਣਾਇਆ ਜਾਵੇ, ਫਿਰ ਉਸ 'ਤੇ ਪੇਰ ਲਾਏ ਜਾਣ। ਉਸ ਬਦਲਾਅ ਨੇ ਸਪਸ਼ਟ ਵੱਖਰਾ ਕੀਤਾ:
ਇਹ ਇੱਕ ਤਕਨੀਕੀ ਬਦਲਾਅ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਧਾਰਣਾਤਮਕ ਬਦਲਾਅ ਸੀ। ਇਸਨੇ ਉਮੀਦਾਂ ਸੈਟ ਕੀਤੀਆਂ ਕਿ ਡੇਟਾ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਦੁਬਾਰਾ ਵਰਤਣਯੋਗ, ਗਵਰਨਡ ਅਤੇ ਟੀਮਾਂ ਲਈ ਪਹੁੰਚਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਕਮਿਊਨਿਟੀ ਗਤੀਸ਼ੀਲ ਹੋ ਗਈ: ਲੋਕਾਂ ਨੇ ਡੇਟਾ ਨੂੰ ਆਸਾਨ ਤਰੀਕੇ ਨਾਲ ਕਵੇਰੀ ਕਰਨ, ਇਸਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਲਿਆਉਣ, ਅਤੇ ਰਿਕਰਿੰਗ ਵਰਕਫਲੋ ਚਲਾਉਣ ਦੀ ਚਾਹ ਰੱਖੀ। ਉੱਚ-ਪੱਧਰੀ ਤੌਰ 'ਤੇ, ਇਸ ਨਾਲ ਉਤਪੱਤੀ ਹੋਈ:
ਜਦ ਹੋਰ-ਹੋਰ ਟੂਲ ਉਸੇ ਪਲੇਟਫਾਰਮ ਵਿਚ ਜੋੜੇ ਗਏ, ਮਿਆਰਾਂ glue ਬਣ ਗਈਆਂ। ਆਮ ਫਾਇਲ ਫਾਰਮੈਟ ਅਤੇ ਸਾਂਝੇ ਸਟੋਰੇਜ ਪੈਟਰਨ ਡੇਟਾ ਨੂੰ ਵੱਖ-ਵੱਖ ਇੰਜਨਾਂ ਅਤੇ ਟੀਮਾਂ ਵਿਚ ਅਦਲਾ-ਬਦਲੀ ਕਰਨ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦੇ ਸਨ। ਹਰ ਪਾਈਪਲਾਈਨ ਨੂੰ ਹਰ ਇਕ ਟੂਲ ਲਈ ਦੁਬਾਰਾ ਲਿਖਣ ਦੀ ਬਜਾਏ, ਸੰਗਠਨਾਂ ਕੁਝ “ਡਿਫਾਲਟ” ਫਾਰਮੈਟ ਅਤੇ ਡਾਇਰੈਕਟਰੀ ਰਿਵਾਜਾਂ 'ਤੇ ਸਹਿਮਤ ਹੋ ਗਈਆਂ—ਅਤੇ ਪਲੇਟਫਾਰਮ ਆਪਣੇ ਹਿੱਸਿਆਂ ਨਾਲੋਂ ਵੱਧ ਬਣ ਗਿਆ।
Hadoop ਦੇ ਚਰਮ-ਸਾਲ ਉਹ ਸਨ ਜਦ ਵੱਡੇ, ਬੈਚ-ਓਰੀਏਂਟਡ ਜੌਬਸ ਪ੍ਰਚਲਿਤ ਸਨ: ਡੇਟਾ HDFS ਵਿੱਚ ਕਾਪੀ ਕਰੋ, ਰਾਤ ਨੂੰ MapReduce ਚਲਾਓ, ਫਿਰ ਨਤੀਜੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। ਉਹ ਮਾਡਲ ਖਤਮ ਨਹੀਂ ਹੋਇਆ, ਪਰ ਜਦ ਉਮੀਦਾਂ “ਹੁਣ ਜਵਾਬ” ਅਤੇ “ਲਗਾਤਾਰ ਅੱਪਡੇਟ” ਵੱਲ ਮੁੜੀਆਂ ਤਾਂ ਇਹ ਡੀਫਾਲਟ ਨਹੀਂ ਰਹਿਣਾ ਲੱਗਾ।
ਟੀਮਾਂ ਨੇ ਖਾਲੀ ਬੈਚ ਤੋਂ ਸਟ੍ਰੀਮਿੰਗ ਅਤੇ ਨਿਯਰ-ਰੀਅਲ-ਟਾਈਮ ਪਾਈਪਲਾਈਨਾਂ ਵੱਲ ਮੋੜਿਆ। ਰੋਜ਼ਾਨਾ MapReduce ਚਲਾਉਣ ਦੀ ਥਾਂ, ਸਿਸਟਮ ਘਟਨਾਵਾਂ ਆਉਂਦੀਆਂ ਹੀ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲੱਗੇ ਅਤੇ ਡੈਸ਼ਬੋਰਡ ਜਾਂ ਅਲਰਟ ਤੁਰੰਤ ਅੱਪਡੇਟ ਹੋਣ ਲੱਗੇ।
ਇਸੇ ਸਮੇਂ, ਨਵੇਂ ਕੰਪਿਊਟ ਇੰਜਨਾਂ ਨੇ ਇੰਟਰਐਕਟਿਵ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਅਸਾਨ ਬਣਾਇਆ। ਇਨ-ਮੇਮੋਰੀ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਅਪਟਿਮਾਈਜ਼ਡ ਕੁਐਰੀ ਐਗਜ਼ੀਕਿਨ ਵਾਲੇ ਫਰੇਮਵਰਕ ਆਮ ਤੌਰ 'ਤੇ ਕਈ ਰਣਨੀਤੀਆਂ ਵਿੱਚ ਪਰੰਪਰਾਗਤ MapReduce ਨੂੰ ਹਰਾ ਦਿੰਦੇ ਸਨ—ਖਾਸ ਕਰਕੇ ਇਤਰੈਟਿਵ ਕੰਮ, ਐਕਸਪਲੋਰੇਟਰੀ ਐਨਾਲਿਟਿਕਸ, ਅਤੇ SQL-ਸਟਾਈਲ ਕੁਐਰੀਆਂ ਲਈ।
ਸਟੋਰੇਜ ਵੀ ਬਦਲਿਆ। ਬਹੁਤ ਸਾਰੀਆਂ ਸੰਸਥਾਵਾਂ ਨੇ “HDFS ਕੇਂਦਰ ਤੋਂ ਬਦਲ ਕੇ” ਕਲਾਊਡ ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਨੂੰ ਇੱਕ ਸਸਤਾ, ਸਧਾਰਨ ਸਾਂਝਾ ਡੇਟਾ ਲੇਅਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਤਣਾ ਸ਼ੁਰੂ ਕੀਤਾ। ਕੰਪਿਊਟ ਹੋਰ ਵੱਧ ਡਿਸਪੋਜ਼ਬਲ ਹੋ ਗਿਆ: ਜਦ ਲੋੜ ਹੋਵੇ ਉਸਨੂੰ ਚਲਾ ਕੇ, ਕੰਮ ਮੁਕੰਮਲ ਹੋਣ 'ਤੇ ਬੰਦ ਕਰ ਦਿੰਦੇ।
ਕੁਝ Hadoop-ਨਾਮੀ ਘਟਕ ਘਟ ਗਏ, ਪਰ ਵਿਚਾਰ ਸਾਰਿਆਂ ਜਗ੍ਹਾਂ ਫੈਲ ਗਏ: ਵੰਡਿਆ ਸਟੋਰੇਜ, ਕੰਪਿਊਟ ਨੂੰ ਡੇਟਾ ਕੋਲ ਲਿਜਾਣਾ, ਕਾਮੋਡੀਟੀ ਹਾਰਡਵੇਅਰ 'ਤੇ ਫੋਲਟ ਟੋਲਰੈਂਸ, ਅਤੇ ਸਾਂਝਾ “ਡੇਟਾ ਲੇਕ” ਮਨੋਭਾਵ। ਯਾਦ ਰੱਖੋ ਕਿ ਜੰਤਰ-ਟੂਲ ਭਿੰਨ ਹੋ ਸਕਦੇ ਹਨ, ਪਰ ਆਰਕੀਟੈਕਚਰ ਪੈਟਰਨ ਆਮ ਹੋ ਗਏ।
Lucene ਨੂੰ ਉਹਨਾਂ ਚਰਮ-ਅਰੰਭੀ ਸਾਈਕਲਾਂ ਵਾਲੀ ਗਿਰਾਵਟ ਨਹੀਂ ਮਿਲੀ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਕੋਰ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਆਧੁਨਿਕ ਖੋਜ ਸਟੈਕਾਂ ਵਿੱਚ ਏਂਬੇਡ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। Elasticsearch, Solr, ਅਤੇ ਹੋਰ ਖੋਜ ਹੱਲ ਅਜੇ ਵੀ Lucene 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ—ਇੰਡੈਕਸਿੰਗ, ਸਕੋਰਿੰਗ, ਅਤੇ ਕੁਐਰੀ ਪਾਰਸਿੰਗ ਜਿਹੜੇ ਖੋਜ, ਨਿਗਰਾਨੀ ਅਤੇ ਉਤਪਾਦ ਖੋਜ ਲਈ ਕੇਂਦਰੀ ਹਨ।
Hadoop ਇੱਕ ਬੰਨ੍ਹੇ ਹੋਏ ਪਲੇਟਫਾਰਮ ਵਜੋਂ ਘੱਟ ਆਮ ਹੋ ਗਿਆ ਹੈ, ਪਰ ਇਸ ਦੀਆਂ ਬੁਨਿਆਦੀਆਂ ਨੇ ਆਧੁਨਿਕ ਡੇਟਾ ਇੰਜੀਨੀਅਰਿੰਗ ਨੂੰ ਰੂਪ ਦਿੱਤਾ। Lucene, ਇਸਦਰਮਿਆਨ, ਖੋਜ-ਭਾਰੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਸ਼ਕਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ, ਭਾਵੇਂ ਉਹ ਨਵੇਂ ਸਰਵਿਸਜ਼ ਅਤੇ APIs ਵਿੱਚ ਲਪੇਟਿਆ ਗਿਆ ਹੋਵੇ।
ਤੁਹਾਨੂੰ “ਬਿਗ ਡੇਟਾ” ਸਿਸਟਮ ਨਹੀਂ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਤਾ ਕਿ Lucene ਅਤੇ Hadoop ਦੇ ਵਿਚਾਰਾਂ ਤੋਂ ਫਾਇਦਾ ਹੋ ਸਕੇ। ਲਿਆਣਯੋਗ ਹਿੱਸਾ ਇਹ ਜਾਣਨਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਹੜੀ ਸਮੱਸਿਆ ਹੱਲ ਕਰ ਰਹੇ ਹੋ: ਚੀਜ਼ਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਲੱਭਣਾ (ਖੋਜ) ਜਾਂ ਜ਼ਿਆਦਾ ਡੇਟਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰਨਾ (ਬੈਚ/ਵੰਡਿਆ ਕੰਪਿਊਟ)।
ਜੇ ਯੂਜ਼ਰ (ਜਾਂ ਅੰਦਰੂਨੀ ਟੂਲ) ਨੂੰ ਕਵੇਰੀ ਟਾਈਪ ਕਰਨੀ ਹੈ ਅਤੇ ਸਬੰਧਿਤ ਨਤੀਆਂ ਤੁਰੰਤ ਮਿਲਣੀ ਚਾਹੀਦੀ ਹੋਵੇ—ਕੀਵਰਡਸ, ਫਰੇਜ਼, ਫਿਲਟਰ, ਅਤੇ ਰੈਂਕਿੰਗ ਨਾਲ—ਤੁਸੀਂ search indexing ਖੇਤਰ ਵਿੱਚ ਹੋ। ਇੱਥੇ Lucene-ਸਟਾਈਲ ਇੰਡੈਕਸਿੰਗ ਚਮਕਦਾ ਹੈ।
ਜੇ ਤੁਹਾਡਾ ਮਕਸਦ ਵੱਡੇ ਪੈਮਾਨੇ ਦਾ ਡੇਟਾ ਕਰੰਚ ਕਰਨਾ ਹੈ ਤਾਂ ਕਿ ਤੁਸੀਂ ਏਗਰੀਗੇਟਸ, ਫੀਚਰ, ਐਕਸਪੋਰਟ, ਰਿਪੋਰਟ ਉਤਪੰਨ ਕਰੋ—ਅਕਸਰ ਸ਼ੈਡਿਊਲ 'ਤੇ—ਤਾਂ ਤੁਸੀਂ batch processing ਖੇਤਰ ਵਿੱਚ ਹੋ। ਇਹ ਉਹ ਸਮੱਸਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ Hadoop ਸਨਹਿਲ ਕੀਤਾ।
ਇੱਕ ਛੋਟੀ ਸਹਾਇਕ ਨੁਸਖਾ:
ਟੂਲ ਚੁਣਨ (ਜਾਂ ਖਰੀਦਣ) ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੀਆਂ ਲੋੜਾਂ ਨੂੰ ਟੈਸਟ ਕਰੋ:\n
ਜੇ ਤੁਸੀਂ ਵਿਕਲਪਾਂ ਦੀ ਜਾਂਚ ਕਰ ਰਹੇ ਹੋ, ਆਪਣੇ ਲੋੜਾਂ ਨੂੰ ਆਮ ਪੈਟਰਨਾਂ ਅਤੇ ਟਰੇਡ-ਆਫ ਨਾਲ ਮਿਲਾਉਣਾ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ; /blog ਦੇ ਲੇਖਾਂ ਨੂੰ ਦੇਖਣਾ ਇੱਕ ਸੂਚੀਬੱਢ ਸਰਵੇਟਿੰਗ ਕਰ ਸਕਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਮੈਨੇਜਡ ਵਰਨਾਮਾਂ ਅਤੇ ਸੈਲਫ-ਹੋਸਟਿਡ ਵਿਚਕਾਰ ਵਿਚਾਰ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ /pricing ਨੂੰ ਦੇਖਣਾ ਅਕਸਰ ਓਪਰੇਸ਼ਨਲ ਜਿੰਮੇਵਾਰੀਆਂ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ ਜੋ ਕੱਚੇ ਫੀਚਰ-ਲਿਸਟ ਤੋਂ ਵਧ ਕੇ ਹੁੰਦੀਆਂ ਹਨ।
Lucene/Hadoop ਯੁੱਗ ਤੋਂ ਇੱਕ ਕਾਰਗਰ ਸਬਕ ਇਹ ਹੈ ਕਿ ਟੀਮਾਂ ਜਿਨ੍ਹਾਂ ਇਹ “ਇੰਫਰਾਸਟ੍ਰਕਚਰ ਆਈਡੀਅਸ” ਨੂੰ ਕਾਮਯਾਬ ਪ੍ਰੋਡਕਟ ਵਿੱਚ ਬਦਲ ਸਕਦੀਆਂ ਹਨ, ਉਹ ਜਿੱਤਦੀਆਂ ਹਨ। ਜੇ ਤੁਸੀਂ ਇੱਕ ਅੰਦਰੂਨੀ ਲੌਗ ਏਕਸਪਲੋਰਰ, ਦਸਤਾਵੇਜ਼ ਖੋਜ ਐਪ, ਜਾਂ ਛੋਟਾ ਐਨਾਲਿਟਿਕਸ ਡੈਸ਼ਬੋਰਡ ਪ੍ਰੋਟੋਟਾਈਪ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ Koder.ai ਵਰਗਾ ਇਕ vibe-coding ਪਲੇਟਫਾਰਮ ਤੁਹਾਨੂੰ ਉਚਿਤ ਅੰਤ-ਟੂ-ਅੰਤ ਐਪ ਤੇਜ਼ੀ ਨਾਲ ਲੈ ਕੇ ਜਾਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ: frontend 'ਤੇ React, Go backend ਨਾਲ PostgreSQL, ਅਤੇ ਇਕ ਇੰਟਰਫੇਸ ਜਿੱਥੇ ਤੁਸੀਂ ਚੈਟ ਰਾਹੀਂ ਇਟਰੈਟ ਕਰ ਸਕਦੇ ਹੋ।
ਇਹ ਖ਼ਾਸ ਕਰਕੇ ਉਸ ਵੇਲੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦ ਤੁਸੀਂ ਅਜੇ ਵੀ ਲੋੜਾਂ ਨੂੰ ਵੈਰੀਫਾਈ ਕਰ ਰਹੇ ਹੋ (ਫੀਲਡਜ਼, ਫਿਲਟਰ, ਰੀਟੇਨਸ਼ਨ, ਅਤੇ UX)। Planning mode, snapshots, ਅਤੇ rollback ਵਰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਯੋਗਨੂੰ ਘੱਟ ਖਤਰੇ ਵਾਲਾ ਬਣਾ ਦਿੰਦੀਆਂ ਹਨ—ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਭਾਰੀ ਓਪਰੇਸ਼ਨਲ ਚੋਣਾਂ ਜਿਵੇਂ ਕਿ ਕਲੱਸਟਰ ਚਲਾਉਣਾ ਜਾਂ ਖੋਜ ਸਟੈਕ ਟਿਊਨ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੋ।
Lucene ਅਤੇ Hadoop ਇਸ ਲਈ ਪ੍ਰਮੁੱਖ ਨਹੀਂ ਬਣੇ ਕਿ ਉਹ ਜਾਦੂਈ ਸਨ, ਪਰ ਕਿਉਂਕਿ ਉਨ੍ਹਾਂ ਨੇ ਦੁਹਰਾਏ ਜਾ ਸਕਣ ਵਾਲੇ ਪ੍ਰਮੁੱਖ ਘਟਕ—ਇੰਡੈਕਸਿੰਗ ਅਤੇ ਵੰਡਿਆ ਪ੍ਰੋਸੈਸਿੰਗ—ਨੂੰ ਐਸੇ ਬਿਲਡਿੰਗ ਬਲਾਕਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਜੋ ਟੀਮਾਂ ਅਪਣਾ ਸਕਦੀਆਂ, ਵਧਾ ਸਕਦੀਆਂ, ਅਤੇ ਆਮਣ-ਸਾਮਣੇ ਸਾਂਝਾ ਕਰ ਸਕਦੀਆਂ।
Lucene ਇੱਕ ਖੋਜ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਇੱਕ ਇੰਡੈਕਸ ਬਣਾਉਂਦੀ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਮਿਲਦੀਆਂ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਹਰ ਵਾਰ ਸਾਰਾ ਸਮੱਗਰੀ ਨਹੀਂ ਪੜ੍ਹ ਕੇ ਤੇਜ਼ੀ ਨਾਲ ਹਾਸਲ ਕਰ ਸਕੋ। ਇਹ ਉਤਪਾਦਾਂ ਵਿੱਚ ਲੋੜੀਂਦੇ ਪ੍ਰਯੋਗਿਕ ਹਿੱਸੇ ਵੀ ਦਿੰਦੀ ਹੈ: analyzers (ਪাঠ ਨੂੰ ਕਿਵੇਂ ਟੋਕਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ), query parsing, ਅਤੇ relevance scoring.
Hadoop ਉਸ ਬਿੰਦੂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ ਜਿੱਥੇ “ਵੱਡਾ ਸਰਵਰ ਖਰੀਦ ਲਓ” ਕੰਮ ਕਰਨਾ ਬੰਦ ਕਰ ਦੇਂਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਕਈ ਮਸ਼ੀਨਾਂ 'ਤੇ ਵੱਡੇ ਡੇਟਾਸੇਟ ਸਟੋਰ ਕਰਨ ਅਤੇ ਉਨ੍ਹਾਂ 'ਤੇ ਸਮਾਂਤਰੀ ਬੈਚ ਪ੍ਰੋਸੈਸਿੰਗ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਮਸ਼ੀਨੀ ਫੇਲਿਅਰਾਂ ਲਈ ਰੀਟ੍ਰਾਈਜ਼ ਅਤੇ ਰਿਡੰਡੈੰਸੀ ਦੀ ਬਣੀ-ਬਨਾਈ ਦੇਖਭਾਲ ਸ਼ਾਮਿਲ ਹੁੰਦੀ ਹੈ।
ਇੱਕ ਇੰਡੈਕਸ ਇੱਕ ਡੇਟਾ ਸਟਰੱਕਚਰ ਹੈ ਜੋ terms (ਜਾਂ ਹੋਰ ਟੋਕਨ) ਨੂੰ ਉਹਨਾਂ ਦਸਤਾਵੇਜ਼ਾਂ/ਫੀਲਡਾਂ ਨਾਲ ਜੋੜਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਨਜ਼ਰ ਆਉਂਦੇ ਹਨ—ਪਿੱਠੇ ਵਾਲੇ-ਕਿਤਾਬ ਦੇ ਇੰਡੈਕਸ ਵਾਂਗ।
ਵਿਆਹਕ ਤੌਰ 'ਤੇ: ਇੰਡੈਕਸਿੰਗ ਉਹ ਕੰਮ ਹੈ ਜੋ ਤੁਸੀਂ ਇੱਕ ਵਾਰੀ ਅੱਗੇ ਕਰਦੇ ਹੋ ਤਾਂ ਜੋ ਯੂਜ਼ਰ ਦੀਆਂ ਕਵੇਰੀਆਂ ਮਿੰਟਾਂ ਨਹੀਂ, ਮਿਲੀਸੈਕਿੰਡਾਂ ਵਿੱਚ ਨਤੀਜੇ ਦੇ ਸਕਣ।
Relevance ਇਹ ਹੈ ਕਿ ਖੋਜ ਇੰਜਣ ਇਹ ਫੈਸਲਾ ਕਿਵੇਂ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਮਿਲਦੇ ਨਤੀਜੇ ਪਹਿਲਾਂ ਦਿਖਾਏ ਜਾਣ।
ਅਮੂਮਨ ਸੰਕੇਤਾਂ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹਨ:
ਜੇ ਤੁਸੀਂ ਉਤਪਾਦ ਖੋਜ ਬਣਾ ਰਹੇ ਹੋ, ਤਾਂ relevance ਟਿਊਨਿੰਗ (ਫੀਲਡ ਬੂਸਟ, analyzers, synonyms) ਲਈ ਸਮਾਂ ਰੱਖੋ—ਇਸ ਨੂੰ ਬਾਦ ਵਿੱਚ ਠੀਕ ਕਰਨ ਦੀ ਵਜਾਇ ਸ਼ੁਰੂ ਵਿੱਚ ਨਜ਼ਰਅੰਦਾਜ਼ ਨਾ ਕਰੋ।
HDFS (Hadoop Distributed File System) ਵੱਡੀਆਂ ਫਾਇਲਾਂ ਨੂੰ ਨਿਰਧਾਰਿਤ-ਆਕਾਰ ਦੇ ਬਲੌਕਾਂ ਵਿੱਚ ਵੰਡ ਕਰਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ 'ਤੇ ਫੈਲਾਉਂਦਾ ਹੈ। ਇਹ ਵੀ ਹਰ ਬਲੌਕ ਦੀਆਂ ਕਾਪੀਆਂ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ 'ਤੇ ਰੱਖਦਾ ਹੈ ਤਾਂ ਕਿ ਜੇ ਇਕ ਨੋਡ ਡਾਊਨ ਹੋ ਜਾਏ ਤਾਂ ਡੇਟਾ ਹੋਰ ਕਾਪੀ ਤੋਂ ਪਹੁੰਚਯੋਗ ਰਹੇ।
ਆਪਰੇਸ਼ਨ ਵਜੋਂ, ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਫਾਇਲ ਸਿਸਟਮ ਵਾਂਗ ਵਰਤਦੇ ਹੋ, ਜਦ ਕਿ Hadoop ਪਿਛੋਕੜ 'ਚ ਪਲੇਸਮੈਂਟ ਅਤੇ ਰਿਡੰਡੈਂਸੀ ਨੂੰ ਦੇਖਦਾ ਹੈ।
MapReduce ਇੱਕ ਬੈਚ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਮਾਡਲ ਹੈ ਜਿਸਦੇ ਦੋ ਚਰਨ ਹਨ:
ਇਹ ਉਨ੍ਹਾਂ ਨੌਕਰੀਆਂ ਲਈ ਵਰਤੋ ਜਿੱਥੇ ਤੁਸੀਂ ਕੁੱਲ ਡੇਟਾ ਨੂੰ ਸਕੈਨ ਕਰਦੇ ਹੋ, ਸੰਖੇਪ ਬਣਾਉਂਦੇ ਹੋ ਅਤੇ ਨਤੀਜੇ ਲਿਖਦੇ ਹੋ—ਜਿਵੇਂ ਲੌਗ ਰੋਲਅਪ ਜਾਂ ਵੱਡੇ ਬੈਕਫਿਲਸ।
“ਡੇਟਾ ਵੱਲ ਕੰਪਿਊਟੇਸ਼ਨ ਲਿਜਾਣਾ” ਦਾ ਮਤਲਬ ਹੈ ਉਹਨਾਂ ਮਸ਼ੀਨਾਂ ਨੂੰ ਛੋਟੀ ਕੋਡ ਟੁਕੜੀਆਂ ਭੇਜਣਾ ਜਿਹੜਿਆਂ ਕੋਲ ਡੇਟਾ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ, ਬਜਾਏ ਇਸਦੇ ਕਿ ਵੱਡੇ ਡੇਟਾਸੇਟ ਨੂੰ ਨੈਟਵਰਕ 'ਤੇ ਇੱਕ ਥਾਂ ਤੇ ਕਾਪੀ ਕੀਤਾ ਜਾਏ।
ਇਸ ਨਾਲ ਨੈਟਵਰਕ ਜਾਮ ਘਟਦਾ ਹੈ ਅਤੇ ਜਿਵੇਂ ਡੇਟਾ ਵਧਦਾ ਹੈ, ਮਾਪਨੇਯੋਗਤਾ ਵਧਦੀ ਹੈ—ਖਾਸ ਕਰਕੇ ਵੱਡੇ ਬੈਚ ਵਰਕਲੋਡ ਲਈ।
ਆਮ ਪੈਟਰਨ ਇਹ ਹੈ:
ਇਸ ਵਿਭਾਜਨ ਨਾਲ ਭਾਰੀ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਇੰਟਰਐਕਟਿਵ ਖੋਜ ਇੱਕ-ਦੂਜੇ ਨਾਲ ਟਕਰਾਉਂਦੇ ਨਹੀਂ।
ਅਰੰਭੀ ਜਿੱਤਾਂ ਉਹ ਉੱਚ-ਵਾਲਿਊਮ, ਅੱਡ-ਹੈਵੀ ਡੇਟਾ ਸਨ ਜਿੱਥੇ ਮੁੱਲ ਅਕਸਰ ਸਮੂਹਿਕ ਹੈ:
ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਬੈਚ ਵਰਕਫਲੋ ਹਨ ਜਿੱਥੇ ਮਿਲੀਨ-ਸਟੈਂਡੀ ਰਿਪੋਰਟਿੰਗ/ਅਗਰਿਗੇਟਸ ਲਈ ਮਿੰਟਾਂ/ਘੰਟਿਆਂ ਦੀ ਦੇਰੀ ਸਵੀਕਾਰਯੋਗ ਹੁੰਦੀ ਹੈ।
ਸ਼ੁਰੂ ਕਰੋ ਨਾਲ ਲੋੜਾਂ ਨੂੰ ਸਮਝੋ, ਫਿਰ ਉਹ ਸਭ ਤੋਂ ਸਧਾਰਣ ਟੂਲ ਚੁਨੋ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਪੂਰਾ ਕਰੇ:
Latency, ਡੇਟਾ ਆਕਾਰ/ਵਾਧਾ, ਅੱਪਡੇਟ ਪੈਟਰਨ ਅਤੇ ਓਪਰੇਸ਼ਨਲ ਲੋਡ ਨੂੰ ਪ੍ਰੈਸ਼ਰ-ਟੈਸਟ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਸਬੰਧਤ ਤੁਲਨਾਵਾਂ ਦੀ ਖੋਜ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ /blog ਦੇਖੋ; ਜੇ ਤੁਸੀਂ ਮੈਨੇਜਡ ਬਨਾਮ ਸੈਲਫ-ਹੋਸਟਿਡ ਦੇ ਵਿਚਕਾਰ ਤੌਲਣਾ ਕਰ ਰਹੇ ਹੋ ਤਾਂ /pricing ਆਪਰੇਸ਼ਨਲ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮੱਦਦ ਕਰ ਸਕਦਾ ਹੈ।