Node.js Puppeteer ਨਾਲ ਸਰਵਰ 'ਤੇ "Chrome ਲੱਭ ਨਹੀਂ ਸਕਿਆ" ਅਤੇ ਕੈਸ਼ ਪਾਥ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਠੀਕ ਕਰਨਾ

Node.js ਅਤੇ Laravel ਸਰਵਰ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਠਪੁਤਲੀ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪਾਰ ਕਰਨਾ

ਇੱਕ ਸਥਾਨਕ ਵਿਕਾਸ ਸੈਟਅਪ ਤੋਂ ਇੱਕ ਲਾਈਵ ਸਰਵਰ ਤੇ ਜਾਣ ਵੇਲੇ, ਅਚਾਨਕ ਸੰਰਚਨਾ ਸਮੱਸਿਆਵਾਂ ਅਕਸਰ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। ਇੱਕ ਅਜਿਹਾ ਮੁੱਦਾ ਜੋ ਖਾਸ ਤੌਰ 'ਤੇ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਏ Node.js ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਠਪੁਤਲੀ ਗਲਤੀ ਸੁੱਟਦਾ ਹੈ: "ਕ੍ਰੋਮ ਨਹੀਂ ਲੱਭ ਸਕਿਆ।" ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਅਪਾਚੇ ਸਰਵਰ ਖਾਤੇ ਜਿਵੇਂ ਕਿ "www-data" ਅਧੀਨ ਇੱਕ Laravel-ਚਾਲਿਤ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦਾ ਹੈ। 🖥️

ਇੱਕ ਸਥਾਨਕ ਮਸ਼ੀਨ 'ਤੇ, ਲਾਰਵੇਲ ਸਕ੍ਰਿਪਟਾਂ ਮੌਜੂਦਾ ਉਪਭੋਗਤਾ ਦੇ ਖਾਤੇ ਦੇ ਅਧੀਨ ਚਲਾਉਂਦੀਆਂ ਹਨ, ਭਾਵ ਸਾਰੀਆਂ ਸੰਬੰਧਿਤ ਨੋਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਉਸ ਉਪਭੋਗਤਾ ਦੀ ਸੰਰਚਨਾ ਦੀ ਪਾਲਣਾ ਕਰਦੀਆਂ ਹਨ। ਪਰ ਇੱਕ ਸਰਵਰ 'ਤੇ, ਅਨੁਮਤੀਆਂ ਅਤੇ ਮਾਰਗ ਬਦਲ ਜਾਂਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਕ੍ਰੋਮ ਬਾਈਨਰੀ ਪਪੀਟੀਅਰ ਨੂੰ ਲੱਭਣ ਵਿੱਚ ਜਟਿਲਤਾਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਆਮ ਚੁਣੌਤੀ ਹੈ, ਕਿਉਂਕਿ ਹਰੇਕ ਵਾਤਾਵਰਣ ਦੀਆਂ ਆਪਣੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਲੋੜਾਂ ਹੁੰਦੀਆਂ ਹਨ।

ਇਸ ਗਲਤੀ ਦੇ ਪਿੱਛੇ ਮੁੱਖ ਮੁੱਦਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਅਕਸਰ ਇੱਕ ਗਲਤ ਸੰਰਚਨਾ ਜਾਂ ਪਹੁੰਚਯੋਗ ਨਹੀਂ ਹੁੰਦਾ ਹੈ ਕੈਸ਼ ਮਾਰਗ Chrome ਇੰਸਟਾਲੇਸ਼ਨ ਲਈ। ਜਦੋਂ ਕਿ ਕਠਪੁਤਲੀ ਲਈ ਕ੍ਰੋਮ ਨੂੰ ਹੱਥੀਂ ਸਥਾਪਿਤ ਕਰਨਾ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਇਹ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਹਮੇਸ਼ਾ ਕਾਫ਼ੀ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਨੇ ਪਾਇਆ ਹੈ ਕਿ ਸਿਸਟਮ-ਪੱਧਰ ਦੀਆਂ ਇਜਾਜ਼ਤਾਂ ਲਈ ਸਹੀ ਸੰਰਚਨਾ ਸਰਵਰ 'ਤੇ ਪਪੀਟੀਅਰ ਨੂੰ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਚਲਾਉਣ ਲਈ ਕੁੰਜੀ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਤਰੀਕੇ ਨੂੰ ਤੋੜਾਂਗੇ, ਇਹ ਪਤਾ ਲਗਾਵਾਂਗੇ ਕਿ ਕੈਸ਼ ਪਾਥ ਕੌਂਫਿਗਰੇਸ਼ਨ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਅਤੇ ਵਿਹਾਰਕ ਹੱਲ ਸਾਂਝੇ ਕਰਾਂਗੇ। 🛠️ ਕੁਝ ਸਿੱਧੀਆਂ ਵਿਵਸਥਾਵਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਆਪਣੇ ਸਰਵਰ ਵਾਤਾਵਰਣ 'ਤੇ ਭਰੋਸੇਯੋਗਤਾ ਨਾਲ ਆਪਣੀਆਂ ਕਠਪੁਤਲੀ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋਵੋਗੇ।

ਸਰਵਰ ਉੱਤੇ Node.js ਵਿੱਚ ਕਠਪੁਤਲੀ ਕੈਸ਼ ਪਾਥ ਮੁੱਦਿਆਂ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਹੱਲ ਕਰਨਾ

ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਸਰਵਰ 'ਤੇ ਸਥਾਪਿਤ ਕਰੋਮ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਖੋਜਣ ਵਿੱਚ ਪਪੀਟੀਅਰ ਦੀ ਮਦਦ ਕਰਨ ਦੇ ਮਹੱਤਵਪੂਰਨ ਉਦੇਸ਼ ਨੂੰ ਪੂਰਾ ਕਰਦੀਆਂ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ Node.js ਸਕ੍ਰਿਪਟ ਇੱਕ ਵੱਖਰੇ ਉਪਭੋਗਤਾ ਖਾਤੇ (ਜਿਵੇਂ ਕਿ Apache ਦੇ ਅਧੀਨ "www-data") ਦੁਆਰਾ ਚਲਾਈ ਜਾਂਦੀ ਹੈ। ਇਸ ਤਰੁੱਟੀ ਦੇ ਪ੍ਰਗਟ ਹੋਣ ਦਾ ਇੱਕ ਮੁੱਖ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਕਠਪੁਤਲੀ ਇੱਕ ਡਿਫੌਲਟ ਕੈਸ਼ ਮਾਰਗ ਵਿੱਚ Chrome ਨੂੰ ਲੱਭਦਾ ਹੈ ਜੋ ਅਕਸਰ ਉਪਭੋਗਤਾ-ਵਿਸ਼ੇਸ਼ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਨੋਡ ਸਕ੍ਰਿਪਟ ਨੂੰ ਅਪਾਚੇ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸ ਕੋਲ ਮੌਜੂਦਾ ਉਪਭੋਗਤਾ ਦੇ ਹੋਮ ਫੋਲਡਰ ਵਿੱਚ ਕੈਸ਼ ਡਾਇਰੈਕਟਰੀ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਹੁੰਦੀ ਹੈ। ਇਹ ਸੈੱਟਅੱਪ ਇੱਕ ਵਿਕਲਪਿਕ ਮਾਰਗ ਨੂੰ ਸੈੱਟ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ /var/www/.cache/puppeteer, ਜ਼ਰੂਰੀ ਹੈ ਤਾਂ ਕਿ ਚੱਲ ਰਹੇ ਉਪਭੋਗਤਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ Chrome ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾ ਸਕੇ। ਇਸ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਢੁਕਵੇਂ ਅਨੁਮਤੀਆਂ ਨਾਲ ਬਣਾ ਕੇ ਅਤੇ ਪਪੀਟੀਅਰ ਦੇ ਕੈਸ਼ ਨੂੰ ਇਸ ਨਾਲ ਲਿੰਕ ਕਰਕੇ, ਅਸੀਂ ਅਪਾਚੇ ਦੇ ਅਧੀਨ ਚੱਲ ਰਹੀ ਪਪੀਟੀਅਰ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਕ੍ਰੋਮ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਖੋਜਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ।

ਸਕ੍ਰਿਪਟਾਂ ਦੁਆਰਾ ਚੁੱਕੇ ਗਏ ਪਹਿਲੇ ਕਦਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਕੈਸ਼ ਡਾਇਰੈਕਟਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਜੂਦ ਹੈ fs.mkdirSync ਆਵਰਤੀ ਵਿਕਲਪ ਦੇ ਨਾਲ. ਇਹ ਇਸ ਗੱਲ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਕੋਈ ਵੀ ਲੋੜੀਂਦੀ ਪੇਰੈਂਟ ਡਾਇਰੈਕਟਰੀਆਂ ਇੱਕੋ ਵਾਰ ਵਿੱਚ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ, ਸਕ੍ਰਿਪਟ ਫਿਰ ਸੈੱਟ ਕਰਦੀ ਹੈ ਕਠਪੁਤਲੀ ਕੈਚ ਉਸ ਮਾਰਗ ਲਈ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਜਿੱਥੇ Chrome ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਹ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨਾਜ਼ੁਕ ਹੈ ਕਿਉਂਕਿ ਇਹ Puppeteer ਦੇ ਡਿਫੌਲਟ ਕੈਸ਼ ਮਾਰਗ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇਹ ਹਮੇਸ਼ਾਂ ਉਪਭੋਗਤਾ-ਵਿਸ਼ੇਸ਼ ਦੀ ਬਜਾਏ ਮਨੋਨੀਤ ਸਰਵਰ-ਅਨੁਕੂਲ ਮਾਰਗ ਵਿੱਚ ਵੇਖਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟੇਜਿੰਗ ਸਰਵਰ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ Puppeteer ਇੱਕ ਤੋਂ ਵੱਧ ਖਾਤਿਆਂ ਵਿੱਚ ਲਗਾਤਾਰ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਸਾਂਝੇ ਕੀਤੇ ਸਥਾਨ 'ਤੇ ਸੈੱਟ ਕਰਨ ਨਾਲ ਗੁੰਮ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਨਾਲ ਸੰਬੰਧਿਤ ਤਰੁੱਟੀਆਂ ਨੂੰ ਰੋਕਿਆ ਜਾਵੇਗਾ।

ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਕਠਪੁਤਲੀ ਲਾਂਚ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਾਂ executablePath ਕ੍ਰੋਮ ਬਾਈਨਰੀ ਨੂੰ ਸਿੱਧਾ ਮਾਰਗ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਪੈਰਾਮੀਟਰ। ਇਹ ਕਠਪੁਤਲੀ ਦੀ ਮਲਟੀਪਲ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਖੋਜ ਕਰਨ ਦੀ ਲੋੜ ਨੂੰ ਬਾਈਪਾਸ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਕੁਝ ਅਨੁਮਤੀਆਂ ਦੇ ਅਧੀਨ ਅਸਫਲ ਹੋ ਸਕਦਾ ਹੈ। ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਇੱਕ ਹੋਰ ਮਦਦਗਾਰ ਕਮਾਂਡ ਹੈ args: ['---ਨੋ-ਸੈਂਡਬਾਕਸ'], ਇੱਕ ਆਰਗੂਮੈਂਟ ਅਕਸਰ ਸਰਵਰ ਵਾਤਾਵਰਣ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੁੰਦਾ ਹੈ। ਸੈਂਡਬੌਕਸ ਮੋਡ, ਜੋ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਮਰੱਥ ਹੈ, ਕਈ ਵਾਰ ਗੈਰ-ਰੂਟ ਉਪਭੋਗਤਾਵਾਂ ਵਿੱਚ ਦਖਲ ਦੇ ਸਕਦਾ ਹੈ ਜਾਂ ਕੁਝ ਸਰਵਰ ਸੰਰਚਨਾਵਾਂ ਵਿੱਚ ਅਨੁਮਤੀਆਂ ਨੂੰ ਸੀਮਤ ਕਰ ਸਕਦਾ ਹੈ। ਇਸ ਦਲੀਲ ਨੂੰ ਜੋੜ ਕੇ, ਅਸੀਂ ਕਠਪੁਤਲੀ ਨੂੰ ਸੈਂਡਬੌਕਸ ਤੋਂ ਬਿਨਾਂ ਕ੍ਰੋਮ ਨੂੰ ਲਾਂਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ, ਜੋ ਕਿ ਲੀਨਕਸ ਸਰਵਰ ਵਾਤਾਵਰਨ ਵਿੱਚ ਕਈ ਅਨੁਮਤੀ-ਸੰਬੰਧੀ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ। 🖥️

ਅੰਤ ਵਿੱਚ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਹੱਲ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਸੀਂ ਯੂਨਿਟ ਟੈਸਟ ਪ੍ਰਦਾਨ ਕੀਤੇ ਹਨ। ਇਹ ਟੈਸਟ ਜਿਵੇਂ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ fs.rmdirSync ਕੈਸ਼ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਰੀਸੈਟ ਕਰਨ ਲਈ, ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਸਾਫ਼ ਸਲੇਟ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ, ਜੋ ਸਕ੍ਰਿਪਟ ਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟੈਸਟ ਇਹ ਤਸਦੀਕ ਕਰਕੇ ਸਫਲ ਬ੍ਰਾਊਜ਼ਰ ਲਾਂਚ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ Puppeteer ਨਿਰਧਾਰਤ ਮਾਰਗ ਵਿੱਚ Chrome ਨੂੰ ਲੱਭ ਸਕਦਾ ਹੈ। ਇਹ ਸਵੈਚਲਿਤ ਤੈਨਾਤੀਆਂ ਵਾਲੇ ਸਰਵਰਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਬ੍ਰਾਊਜ਼ਰ ਕੌਂਫਿਗਰੇਸ਼ਨ ਮੈਨੂਅਲ ਐਡਜਸਟਮੈਂਟਾਂ ਦੇ ਬਿਨਾਂ ਉਤਪਾਦਨ ਵਿੱਚ ਕੰਮ ਕਰੇਗੀ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਸੈੱਟਅੱਪ ਵਿੱਚ, ਇਹ ਟੈਸਟ ਹਰ ਵਾਰ ਕੋਡ ਤੈਨਾਤ ਕੀਤੇ ਜਾਣ 'ਤੇ ਚੱਲ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵਿਸ਼ਵਾਸ ਹੁੰਦਾ ਹੈ ਕਿ ਪਪੀਟੀਅਰ ਦੀ ਸੰਰਚਨਾ ਬਰਕਰਾਰ ਹੈ, ਲਾਈਵ ਵਾਤਾਵਰਨ ਵਿੱਚ ਅਣਚਾਹੇ ਹੈਰਾਨੀ ਨੂੰ ਰੋਕਦੀ ਹੈ। 🛠️

const puppeteer = require('puppeteer');
const fs = require('fs');
const path = '/var/www/.cache/puppeteer';

// Ensure the cache directory exists with appropriate permissions
function ensureCacheDirectory() {
    if (!fs.existsSync(path)) {
        fs.mkdirSync(path, { recursive: true });
        console.log('Cache directory created.');
    }
}

// Launch Puppeteer with a custom cache path
async function launchBrowser() {
    ensureCacheDirectory();
    const browser = await puppeteer.launch({
        headless: true,
        executablePath: '/usr/bin/google-chrome-stable',
        userDataDir: path,
    });
    return browser;
}

// Main function to handle the process
(async () => {
    try {
        const browser = await launchBrowser();
        const page = await browser.newPage();
        await page.goto('https://example.com');
        console.log('Page loaded successfully');
        await browser.close();
    } catch (error) {
        console.error('Error launching browser:', error);
    }
})();

const puppeteer = require('puppeteer');
require('dotenv').config();

// Load cache path from environment variables
const CACHE_PATH = process.env.PUPPETEER_CACHE_PATH || '/var/www/.cache/puppeteer';
process.env.PUPPETEER_CACHE = CACHE_PATH;

// Ensure directory exists
const fs = require('fs');
if (!fs.existsSync(CACHE_PATH)) {
    fs.mkdirSync(CACHE_PATH, { recursive: true });
}

// Launch Puppeteer with environment-based cache path
async function launchBrowser() {
    const browser = await puppeteer.launch({
        headless: true,
        args: ['--no-sandbox'],
        executablePath: '/usr/bin/google-chrome-stable',
    });
    return browser;
}

(async () => {
    try {
        const browser = await launchBrowser();
        console.log('Browser launched successfully');
        await browser.close();
    } catch (error) {
        console.error('Launch error:', error);
    }
})();

const { exec } = require('child_process');
const puppeteer = require('puppeteer');
const fs = require('fs');
const path = '/var/www/.cache/puppeteer';

describe('Puppeteer Configuration Tests', () => {
    it('should create cache directory if missing', (done) => {
        if (fs.existsSync(path)) fs.rmdirSync(path, { recursive: true });
        exec('node setupScript.js', (error) => {
            if (error) return done(error);
            expect(fs.existsSync(path)).toBe(true);
            done();
        });
    });

    it('should launch Puppeteer successfully', async () => {
        const browser = await puppeteer.launch({
            headless: true,
            executablePath: '/usr/bin/google-chrome-stable',
            userDataDir: path,
        });
        expect(browser).toBeDefined();
        await browser.close();
    });
});

ਬਹੁ-ਉਪਭੋਗਤਾ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਠਪੁਤਲੀ ਅਤੇ ਕਰੋਮ ਪਾਥ ਤਰੁਟੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਵਰਤਣ ਵੇਲੇ ਚੁਣੌਤੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਕਠਪੁਤਲੀ ਇੱਕ ਸਰਵਰ ਵਾਤਾਵਰਣ ਵਿੱਚ ਸਹੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਰਿਹਾ ਹੈ ਕੈਸ਼ ਮਾਰਗ Chrome ਲਈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਸਕ੍ਰਿਪਟ ਇੱਕ ਵੱਖਰੇ ਉਪਭੋਗਤਾ ਖਾਤੇ ਦੇ ਅਧੀਨ ਚੱਲਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ Apache ਦਾ "www-data." ਇਹ ਸੈੱਟਅੱਪ ਅਕਸਰ ਸੰਰਚਨਾ ਨੂੰ ਗੁੰਝਲਦਾਰ ਬਣਾਉਂਦਾ ਹੈ ਕਿਉਂਕਿ ਡਿਫੌਲਟ ਪਪੀਟੀਅਰ ਕੈਸ਼ ਮਾਰਗ "www-data" ਖਾਤੇ ਲਈ ਪਹੁੰਚਯੋਗ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ਜਦੋਂ ਕਠਪੁਤਲੀ ਕ੍ਰੋਮ ਬਾਈਨਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਸਦਾ ਨਤੀਜਾ ਅਕਸਰ "ਕ੍ਰੋਮ ਨੂੰ ਲੱਭਿਆ ਨਹੀਂ ਜਾ ਸਕਿਆ" ਵਿੱਚ ਗਲਤੀ ਹੁੰਦਾ ਹੈ, ਭਾਵੇਂ ਕਿ ਕ੍ਰੋਮ ਪਹਿਲਾਂ ਸਥਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਕੈਸ਼ ਮਾਰਗ ਨੂੰ ਮੈਨੂਅਲੀ ਕੌਂਫਿਗਰ ਕਰਨਾ ਜਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੈਟ ਕਰਨਾ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਪਪੀਟੀਅਰ ਦਿਖਦਾ ਹੈ ਜੋ ਉਪਭੋਗਤਾਵਾਂ ਵਿੱਚ ਸਾਂਝੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ /var/www/.cache/puppeteer.

ਵਿਚਾਰ ਕਰਨ ਲਈ ਇਕ ਹੋਰ ਪਹਿਲੂ ਸਰਵਰ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਠਪੁਤਲੀ ਲਈ ਖਾਸ ਲਾਂਚ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਨਾਲ Chrome ਸੈਂਡਬਾਕਸ ਨੂੰ ਅਯੋਗ ਕਰਨਾ args: ['--no-sandbox'] ਲੀਨਕਸ ਸਰਵਰਾਂ 'ਤੇ ਅਨੁਮਤੀ ਦੇ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜੋ ਹਮੇਸ਼ਾ ਗੈਰ-ਰੂਟ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਸੈਂਡਬਾਕਸਿੰਗ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਸੰਭਾਲਦੇ ਹਨ। ਇਹ ਵਿਕਲਪ, ਇੱਕ ਕਸਟਮ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਮਾਰਗ ਨਿਰਧਾਰਤ ਕਰਨ ਦੇ ਨਾਲ, ਸਰਵਰ ਵਾਤਾਵਰਣਾਂ ਦੇ ਨਾਲ ਪਪੀਟੀਅਰ ਦੀ ਅਨੁਕੂਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਥਾਨਕ ਸੈਟਅਪ 'ਤੇ, ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ Puppeteer ਮੌਜੂਦਾ ਉਪਭੋਗਤਾ ਦੀਆਂ ਅਨੁਮਤੀਆਂ ਨਾਲ ਚੱਲਦਾ ਹੈ, ਪਰ ਉਤਪਾਦਨ ਵਿੱਚ, ਵਧੇਰੇ ਪ੍ਰਤਿਬੰਧਿਤ "www-data" ਉਪਭੋਗਤਾ ਕੋਲ ਕੁਝ ਸਰੋਤਾਂ ਤੱਕ ਪਹੁੰਚ ਦੀ ਘਾਟ ਹੈ ਜਦੋਂ ਤੱਕ ਉਹ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਕੌਂਫਿਗਰ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਅੰਤ ਵਿੱਚ, ਸ਼ੇਅਰਡ ਜਾਂ ਪ੍ਰੋਡਕਸ਼ਨ ਵਾਤਾਵਰਨ ਵਿੱਚ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਸਮੇਂ, ਇਹਨਾਂ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨਾ ਇੱਕ ਚੰਗਾ ਅਭਿਆਸ ਹੈ। ਸਵੈਚਲਿਤ ਕਦਮ ਜਿਵੇਂ ਕਿ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੈਸ਼ ਪਾਥ ਨੂੰ ਸੈਟ ਅਪ ਕਰਨਾ ਅਤੇ ਕ੍ਰੋਮ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ npx puppeteer browsers install ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਤੈਨਾਤੀ ਹੱਥੀਂ ਦਖਲ ਤੋਂ ਬਿਨਾਂ ਕਠਪੁਤਲੀ ਨੂੰ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਟੈਸਟਾਂ ਨੂੰ ਜੋੜਨਾ ਕਿ Chrome ਸਹੀ ਢੰਗ ਨਾਲ ਲਾਂਚ ਹੋਇਆ ਹੈ, ਗਲਤ ਸੰਰਚਨਾਵਾਂ ਦੇ ਕਾਰਨ ਹੋਣ ਵਾਲੇ ਡਾਊਨਟਾਈਮ ਨੂੰ ਰੋਕ ਸਕਦਾ ਹੈ। ਇਹ ਵਿਵਸਥਾਵਾਂ ਇੱਕ ਸਥਿਰ ਵਾਤਾਵਰਣ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹਨ ਜਿੱਥੇ ਪਪੀਟੀਅਰ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਕਿ ਸਕ੍ਰਿਪਟ ਚਲਾ ਰਹੇ ਉਪਭੋਗਤਾ ਖਾਤੇ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ। 🛠️