ਵੈੱਬ ਐਪ ਵਿੱਚ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਕਿਵੇਂ ਚਲਾਈਏ: ਕਿਊ, ਸ਼ਡਿਊਲਰ ਅਤੇ cron

ਵੈੱਬ ਐਪ ਵਿੱਚ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਚਲਾਉਣ ਲਈ ਪਹਿਲਾਂ ਕੰਮ ਨੂੰ ਦੋ ਕਿਸਮਾਂ ਵਿੱਚ ਵੰਡੋ। ਟ੍ਰਿਗਰ ਹੋਣ ਵਾਲੀਆਂ ਜੌਬਾਂ (ਸਵਾਗਤ ਈਮੇਲ ਭੇਜਣਾ, ਅੱਪਲੋਡ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ) ਨੂੰ ਜੌਬ ਕਿਊ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਅਕਸਰ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਇੱਕ ਟੇਬਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਰੀਟਰਾਈ ਵਾਲਾ ਵਰਕਰ ਉਸਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਸ਼ਡਿਊਲ ਕੀਤੀਆਂ ਜੌਬਾਂ (ਰਾਤ ਦੀ ਰਿਪੋਰਟ, ਹਰ 15 ਮਿੰਟ ਯਾਦ-ਦਿਹਾਨੀਆਂ) ਨੂੰ ਕੋਈ ਅਜਿਹੀ ਚੀਜ਼ ਚਾਹੀਦੀ ਹੈ ਜੋ ਤੈਅ ਸਮੇਂ 'ਤੇ ਚੱਲੇ: ਹੋਸਟ ਦੀ cron ਸਹੂਲਤ, ਜਾਂ ਇੱਕ ਬਾਹਰੀ ਸ਼ਡਿਊਲਰ ਜੋ ਤੁਹਾਡੀ ਐਪ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਐਂਡਪੌਇੰਟ ਨੂੰ ਬੁਲਾਉਂਦਾ ਹੈ। ਹਮੇਸ਼ਾ ਜੌਬਾਂ ਨੂੰ ਦੋ ਵਾਰ ਚੱਲਣ ਲਈ ਸੁਰੱਖਿਅਤ ਬਣਾਓ, ਅਸਫਲਤਾਵਾਂ ਰਿਕਾਰਡ ਕਰੋ, ਅਤੇ ਕਦੇ ਵੀ ਉਸ ਸਰਵਰ ਦੇ ਅੰਦਰ ਟਾਈਮਰ 'ਤੇ ਨਿਰਭਰ ਨਾ ਹੋਵੋ ਜੋ ਸੌਂ ਸਕਦਾ ਹੈ ਜਾਂ ਮੁੜ ਚਾਲੂ ਹੋ ਸਕਦਾ ਹੈ।

ਇਹ ਗਾਈਡ ਵਿਕਲਪ ਸਮਝਾਉਂਦੀ ਹੈ, ਦੱਸਦੀ ਹੈ ਕਿ ਹਰ ਇੱਕ ਕਦੋਂ ਫਿੱਟ ਬੈਠਦਾ ਹੈ, ਅਤੇ ਇਹਨਾਂ ਨੂੰ AI ਐਪ ਬਿਲਡਰ ਨਾਲ ਕਿਵੇਂ ਸੈੱਟ ਕਰਨਾ ਹੈ, ਜ਼ੀਰੋ ਤੱਕ ਸਕੇਲ ਹੋਣ ਵਾਲੇ ਹੋਸਟਾਂ 'ਤੇ ਵੀ।

ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਵਿੱਚ ਕੀ ਆਉਂਦਾ ਹੈ

ਇਹ ਕੁਝ ਵੀ ਜੋ ਹੌਲਾ, ਅਵਿਸ਼ਵਾਸਯੋਗ ਜਾਂ ਉਪਭੋਗਤਾ ਦੇ ਤੁਰੰਤ ਜਵਾਬ ਲਈ ਜ਼ਰੂਰੀ ਨਾ ਹੋਵੇ:

• ਈਮੇਲ, ਸੂਚਨਾਵਾਂ ਅਤੇ ਰਸੀਦਾਂ ਭੇਜਣਾ
• ਤਸਵੀਰਾਂ ਦਾ ਆਕਾਰ ਬਦਲਣਾ, ਵੀਡੀਓ ਟ੍ਰਾਂਸਕੋਡ ਕਰਨਾ, PDF ਬਣਾਉਣਾ
• ਹੌਲੀ ਤੀਜੀ ਧਿਰ APIs ਨੂੰ ਬੁਲਾਉਣਾ, AI ਮਾਡਲ ਸਮੇਤ ਲੰਬੇ ਕੰਮਾਂ ਲਈ
• ਕਿਸੇ ਹੋਰ ਪ੍ਰਣਾਲੀ ਤੋਂ ਡੇਟਾ ਇੰਪੋਰਟ ਜਾਂ ਸਿੰਕ ਕਰਨਾ
• ਰਾਤ ਦੀ ਸਫ਼ਾਈ, ਰਿਪੋਰਟਾਂ ਅਤੇ ਯਾਦ-ਦਿਹਾਨੀਆਂ

ਇਹ ਕੰਮ ਬੇਨਤੀ ਦੇ ਅੰਦਰ ਕਰਨ ਨਾਲ ਪੰਨੇ ਹੌਲੇ ਅਤੇ ਨਾਜ਼ੁਕ ਹੁੰਦੇ ਹਨ: ਜੇ ਈਮੇਲ ਪ੍ਰਦਾਤਾ ਡਾਊਨ ਹੋਵੇ, ਤਾਂ ਉਪਭੋਗਤਾ ਦਾ ਸਾਈਨ ਅੱਪ ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਸਨੂੰ ਪਿਛੋਕੜ ਵਿੱਚ ਲਿਜਾਣ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਤੁਰੰਤ ਜਵਾਬ ਮਿਲਦਾ ਹੈ ਅਤੇ ਜੌਬ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਹੋ ਸਕਦੀ ਹੈ।

ਵਿਕਲਪ

ਕੋਈ ਇੱਕ ਸਹੀ ਜਵਾਬ ਨਹੀਂ। ਇੱਕ ਛੋਟੀ ਐਪ ਨੂੰ ਅਕਸਰ ਬੱਸ ਇੱਕ ਡੇਟਾਬੇਸ ਕਿਊ ਅਤੇ ਇੱਕ ਬਾਹਰੀ ਸ਼ਡਿਊਲਰ ਚਾਹੀਦਾ ਹੈ।

ਜ਼ੀਰੋ ਤੱਕ ਸਕੇਲ ਹੋਣ ਵਾਲੇ ਹੋਸਟ ਕਿਉਂ ਸਥਿਤੀ ਬਦਲਦੇ ਹਨ

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

ਪੈਟਰਨ 1: ਡੇਟਾਬੇਸ ਜੌਬ ਕਿਊ

ਟ੍ਰਿਗਰ ਹੋਣ ਵਾਲੀਆਂ ਜੌਬਾਂ ਲਈ:

1. ਇੱਕ jobs ਟੇਬਲ ਬਣਾਓ: ਕਿਸਮ, ਪੇਲੋਡ (JSON), ਸਥਿਤੀ (pending, running, done, failed), ਕੋਸ਼ਿਸ਼ਾਂ, run_after, last_error, ਸਮੇਂ-ਚਿੰਨ੍ਹ।
2. ਜਦੋਂ ਕੁਝ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਸੇ ਟ੍ਰਾਂਜ਼ੈਕਸ਼ਨ ਵਿੱਚ ਜੌਬ ਰੋਅ ਪਾਓ ਜੋ ਬਦਲਾਅ ਕਰਦਾ ਹੈ, ਤਾਂ ਕਿ ਦੋਵੇਂ ਇਕੱਠੇ ਸਫ਼ਲ ਜਾਂ ਅਸਫ਼ਲ ਹੋਣ।
3. ਇੱਕ ਵਰਕਰ ਤਿਆਰ ਜੌਬਾਂ ਚੁੱਕਦਾ ਹੈ, ਉਹਨਾਂ ਨੂੰ running ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ, ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ done ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ।
4. ਅਸਫਲਤਾ 'ਤੇ, attempts ਵਧਾਓ, run_after ਬਾਅਦ ਵਿੱਚ ਸੈੱਟ ਕਰੋ (ਜਿਵੇਂ 1, 5, ਫਿਰ 30 ਮਿੰਟ) ਅਤੇ ਗਲਤੀ ਸੰਭਾਲੋ। ਵੱਧ ਤੋਂ ਵੱਧ ਕੋਸ਼ਿਸ਼ਾਂ ਤੋਂ ਬਾਅਦ failed ਚਿੰਨ੍ਹਿਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਨੂੰ ਸੂਚਿਤ ਕਰੋ।

ਜੇ ਇੱਕ ਤੋਂ ਵੱਧ ਵਰਕਰ ਇੱਕੋ ਸਮੇਂ ਚੱਲ ਸਕਦੇ ਹਨ, ਤਾਂ ਜੌਬਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਕਲੇਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। Postgres 'ਤੇ, SELECT ... FOR UPDATE SKIP LOCKED ਹਰ ਵਰਕਰ ਨੂੰ ਵੱਖਰੀਆਂ ਕਤਾਰਾਂ ਕਲੇਮ ਕਰਨ ਦਿੰਦਾ ਹੈ ਬਿਨਾਂ ਟਕਰਾਅ ਦੇ।

ਵਰਕਰ ਕੌਣ ਚਲਾਉਂਦਾ ਹੈ? ਹਮੇਸ਼ਾ ਚਾਲੂ ਸਰਵਰ 'ਤੇ, ਇੱਕ ਵੱਖਰੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਲੂਪ। ਜ਼ੀਰੋ ਤੱਕ ਸਕੇਲ ਹੋਣ ਵਾਲੇ ਹੋਸਟ 'ਤੇ, ਪੈਟਰਨ 2 ਵਾਲਾ ਸ਼ਡਿਊਲ ਕੀਤਾ ਐਂਡਪੌਇੰਟ ਹਰ ਕਾਲ 'ਤੇ ਤੈਅ ਜੌਬਾਂ ਦਾ ਇੱਕ ਬੈਚ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦਾ ਹੈ।

ਪੈਟਰਨ 2: ਬਾਹਰੀ ਸ਼ਡਿਊਲਰ ਜੋ ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਬੁਲਾਵੇ

ਸ਼ਡਿਊਲ ਕੀਤੀਆਂ ਜੌਬਾਂ ਲਈ:

1. ਇੱਕ ਐਂਡਪੌਇੰਟ ਜੋੜੋ ਜਿਵੇਂ POST /api/cron/send-reminders।
2. ਇਸਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ: ਇੱਕ ਹੈਡਰ ਵਿੱਚ ਗੁਪਤ ਟੋਕਨ ਮੰਗੋ, ਜੋ ਦੋਵੇਂ ਪਾਸੇ ਸੀਕ੍ਰੇਟ ਵਜੋਂ ਰੱਖਿਆ ਹੋਵੇ, ਅਤੇ ਹੋਰ ਸਭ ਰੱਦ ਕਰੋ।
3. ਇਸਨੂੰ ਇਡੈਂਪੋਟੈਂਟ ਬਣਾਓ: ਇੱਕੋ ਮਿੰਟ ਵਿੱਚ ਦੋ ਵਾਰ ਚੱਲਣ ਨਾਲ ਦੋ ਯਾਦ-ਦਿਹਾਨੀਆਂ ਨਹੀਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ। ਜੋ ਭੇਜਿਆ ਗਿਆ ਉਹ ਰਿਕਾਰਡ ਕਰੋ।
4. ਹਰ ਕਾਲ ਨੂੰ ਛੋਟਾ ਰੱਖੋ: ਇੱਕ ਬੈਚ (ਜਿਵੇਂ 100 ਆਈਟਮ) ਪ੍ਰਕਿਰਿਆ ਕਰੋ ਅਤੇ ਬਾਕੀ ਅਗਲੀ ਕਾਲ 'ਤੇ ਛੱਡੋ।
5. ਕਿਸੇ ਸ਼ਡਿਊਲਰ ਨੂੰ ਇਸ 'ਤੇ ਇਸ਼ਾਰਾ ਕਰੋ।

ਸ਼ਡਿਊਲਰ ਦੀਆਂ ਚੋਣਾਂ:

• GitHub Actions ਸ਼ਡਿਊਲ ਕੀਤੇ ਵਰਕਫਲੋ। GitHub ਦੀਆਂ ਵਰਤੋਂ ਸੀਮਾਵਾਂ ਅੰਦਰ ਮੁਫ਼ਤ। ਸਤੰਬਰ 2026 ਤੱਕ, GitHub ਦੇ ਦਸਤਾਵੇਜ਼ ਕਹਿੰਦੇ ਹਨ ਕਿ ਸਭ ਤੋਂ ਛੋਟਾ ਅੰਤਰਾਲ ਹਰ 5 ਮਿੰਟ ਹੈ, ਵਿਅਸਤ ਸਮੇਂ 'ਤੇ ਚੱਲਣ ਵਿੱਚ ਦੇਰੀ ਹੋ ਸਕਦੀ ਹੈ (ਖ਼ਾਸ ਕਰਕੇ ਹਰ ਘੰਟੇ ਦੀ ਸ਼ੁਰੂਆਤ 'ਤੇ), ਸ਼ਡਿਊਲ ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ UTC ਵਰਤਦੇ ਹਨ, ਅਤੇ ਜਨਤਕ ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਸ਼ਡਿਊਲ ਕੀਤੇ ਵਰਕਫਲੋ 60 ਦਿਨ ਰਿਪੋਜ਼ਟਰੀ ਗਤੀਵਿਧੀ ਨਾ ਹੋਣ 'ਤੇ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ।
• ਹੋਸਟਡ cron ਸੇਵਾਵਾਂ। ਬਹੁਤ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਇੱਕੋ ਕੰਮ ਹੈ ਕਿ ਤੈਅ ਸਮੇਂ 'ਤੇ ਕੋਈ URL ਬੁਲਾਉਣਾ। ਨਿਰਭਰ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਭਰੋਸੇਯੋਗਤਾ, ਘੱਟੋ-ਘੱਟ ਅੰਤਰਾਲ ਅਤੇ ਚੇਤਾਵਨੀਆਂ ਜਾਂਚੋ।
• ਤੁਹਾਡੇ ਕਲਾਊਡ ਪ੍ਰਦਾਤਾ ਦਾ ਸ਼ਡਿਊਲਰ। ਜੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਵੱਡਾ ਕਲਾਊਡ ਪ੍ਰਦਾਤਾ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਉਸ ਕੋਲ ਇੱਕ ਪ੍ਰਬੰਧਿਤ ਸ਼ਡਿਊਲਰ ਹੋਵੇਗਾ ਜੋ HTTPS ਐਂਡਪੌਇੰਟ ਬੁਲਾ ਸਕਦਾ ਹੈ।
• ਹੋਸਟਡ ਜੌਬ ਜਾਂ ਵਰਕਫਲੋ ਸੇਵਾ। ਇਹ ਸ਼ਡਿਊਲਿੰਗ, ਕਿਊ ਅਤੇ ਰੀਟਰਾਈ ਇਕੱਠੇ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਹਰ ਕਦਮ ਲਈ ਤੁਹਾਡੇ ਐਂਡਪੌਇੰਟ ਬੁਲਾਉਂਦੀਆਂ ਹਨ। ਹਰ ਵੇਚਣ ਵਾਲੇ ਦੀ ਸਾਈਟ 'ਤੇ ਕੀਮਤ ਅਤੇ ਸੀਮਾਵਾਂ ਤੁਲਨਾ ਕਰੋ।

ਪੈਟਰਨ 3: ਪ੍ਰਦਾਤਾ ਨੂੰ ਇਹ ਕਰਨ ਦਿਓ

ਕਈ ਵਾਰ ਸਭ ਤੋਂ ਵਧੀਆ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਕੋਈ ਨਹੀਂ ਹੁੰਦੀ:

• ਭੁਗਤਾਨ। Stripe ਅਸਫਲ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਭੁਗਤਾਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਅਤੇ webhooks ਭੇਜਦਾ ਹੈ; ਤੁਸੀਂ ਪੋਲ ਕਰਨ ਦੀ ਬਜਾਏ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿੰਦੇ ਹੋ। ਵੇਖੋ webhook ਕੀ ਹੁੰਦਾ ਹੈ।
• ਈਮੇਲ। ਪ੍ਰਦਾਤਾ ਸੁਨੇਹਾ ਸੌਂਪਣ ਤੋਂ ਬਾਅਦ ਡਿਲੀਵਰੀ ਨੂੰ ਕਿਊ ਅਤੇ ਰੀਟਰਾਈ ਕਰਦੇ ਹਨ।
• ਵੱਡੇ AI ਕੰਮ। OpenAI ਅਤੇ Anthropic ਗੈਰ-ਜ਼ਰੂਰੀ ਬੇਨਤੀਆਂ ਲਈ ਬੈਚ APIs ਦਿੰਦੇ ਹਨ, ਜੋ ਤੁਸੀਂ ਜਮ੍ਹਾਂ ਕਰਦੇ ਹੋ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇਕੱਠੇ ਕਰਦੇ ਹੋ।

ਆਪਣੇ AI ਬਿਲਡਰ ਨੂੰ ਦੇਣ ਵਾਲੇ ਪ੍ਰੰਪਟ

ਕਿਊ ਲਈ:

ਸਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ jobs ਟੇਬਲ ਵਰਤ ਕੇ ਇੱਕ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਕਿਊ ਜੋੜੋ (ਕਿਸਮ, ਪੇਲੋਡ JSON, ਸਥਿਤੀ, ਕੋਸ਼ਿਸ਼ਾਂ, run_after, last_error)। ਜਦੋਂ ਉਪਭੋਗਤਾ ਸਾਈਨ ਅੱਪ ਕਰੇ, ਤਾਂ ਸਿੱਧੇ ਈਮੇਲ ਭੇਜਣ ਦੀ ਬਜਾਏ ਉਸੇ ਟ੍ਰਾਂਜ਼ੈਕਸ਼ਨ ਵਿੱਚ send_welcome_email ਜੌਬ ਪਾਓ। processJobs(limit) ਫੰਕਸ਼ਨ ਜੋੜੋ ਜੋ SELECT ... FOR UPDATE SKIP LOCKED ਨਾਲ ਤਿਆਰ ਜੌਬਾਂ ਕਲੇਮ ਕਰੇ, ਉਹਨਾਂ ਨੂੰ ਚਲਾਵੇ, ਅਤੇ ਅਸਫਲਤਾਵਾਂ ਨੂੰ 1, 5 ਅਤੇ 30 ਮਿੰਟ ਬਾਅਦ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੇ, ਅਤੇ 4 ਕੋਸ਼ਿਸ਼ਾਂ ਤੋਂ ਬਾਅਦ failed ਚਿੰਨ੍ਹਿਤ ਕਰੇ।

ਸ਼ਡਿਊਲ ਕੀਤੇ ਟ੍ਰਿਗਰ ਲਈ:

POST /api/cron/tick ਜੋੜੋ ਜੋ CRON_SECRET ਸੀਕ੍ਰੇਟ ਦੇ bearer ਟੋਕਨ ਨਾਲ ਸੁਰੱਖਿਅਤ ਹੋਵੇ; ਬਿਨਾਂ ਇਸਦੇ ਕੋਈ ਵੀ ਬੇਨਤੀ ਰੱਦ ਕਰੋ। ਹਰ ਕਾਲ processJobs(100) ਚਲਾਵੇ ਅਤੇ ਅਗਲੇ 24 ਘੰਟਿਆਂ ਵਿੱਚ ਤੈਅ ਬੁਕਿੰਗ ਯਾਦ-ਦਿਹਾਨੀਆਂ ਭੇਜੇ ਜੋ ਅਜੇ ਨਹੀਂ ਭੇਜੀਆਂ ਗਈਆਂ, ਅਤੇ ਭੇਜੀਆਂ ਯਾਦ-ਦਿਹਾਨੀਆਂ ਰਿਕਾਰਡ ਕਰੇ ਤਾਂ ਕਿ ਕੁਝ ਵੀ ਦੋ ਵਾਰ ਨਾ ਜਾਵੇ। ਚੱਲੀਆਂ ਜੌਬਾਂ ਦਾ JSON ਸਾਰ ਵਾਪਸ ਕਰੇ। ਫਿਰ ਇੱਕ GitHub Actions ਵਰਕਫਲੋ ਲਿਖੋ ਜੋ ਇਸ ਐਂਡਪੌਇੰਟ ਨੂੰ ਹਰ 15 ਮਿੰਟ ਬਾਅਦ ਬੁਲਾਵੇ, URL ਅਤੇ ਟੋਕਨ ਰਿਪੋਜ਼ਟਰੀ ਸੀਕ੍ਰੇਟ ਤੋਂ ਪੜ੍ਹਦਾ ਹੋਵੇ।

ਆਮ ਗਲਤੀਆਂ

• setInterval 'ਤੇ ਨਿਰਭਰ ਹੋਣਾ। ਇਹ ਚੁੱਪ-ਚਾਪ ਰੁਕ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਸਰਵਰ ਸੌਂਦਾ ਜਾਂ ਮੁੜ ਚਾਲੂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਦੋ ਕਾਪੀਆਂ ਚੱਲਣ 'ਤੇ ਦੁੱਗਣਾ ਹੋ ਜਾਂਦਾ ਹੈ।
• ਬਿਨਾਂ ਸੁਰੱਖਿਆ ਵਾਲਾ cron ਐਂਡਪੌਇੰਟ। ਜੋ ਵੀ ਇਸਨੂੰ ਲੱਭੇ ਉਹ ਤੁਹਾਡੀਆਂ ਜੌਬਾਂ, ਜਾਂ ਤੁਹਾਡਾ ਈਮੇਲ ਬਿੱਲ, ਚਾਲੂ ਕਰ ਸਕਦਾ ਹੈ।
• ਜੌਬਾਂ ਜੋ ਇਡੈਂਪੋਟੈਂਟ ਨਹੀਂ। ਰੀਟਰਾਈ ਅਤੇ ਦੁਹਰਾਏ ਸ਼ਡਿਊਲਰ ਕਾਲ ਹੋਣਗੇ। ਇਸੇ ਲਈ ਡਿਜ਼ਾਈਨ ਕਰੋ।
• ਅਸਫਲਤਾ ਦੀ ਦਿੱਖ ਨਹੀਂ। ਇੱਕ ਹਫ਼ਤਾ ਚੁੱਪ-ਚਾਪ ਫੇਲ ਹੋਣ ਵਾਲੀ ਜੌਬ ਉਸ ਤੋਂ ਬੁਰੀ ਹੈ ਜੋ ਉੱਚੀ ਆਵਾਜ਼ ਵਿੱਚ ਫੇਲ ਹੋਵੇ। ਗਲਤੀਆਂ ਲੌਗ ਕਰੋ ਅਤੇ ਵਾਰ-ਵਾਰ ਅਸਫਲਤਾ 'ਤੇ ਚੇਤਾਵਨੀ ਦਿਓ।
• ਇੱਕ ਬੇਨਤੀ ਵਿੱਚ ਲੰਮੀਆਂ ਦੌੜਾਂ। ਬੇਨਤੀਆਂ ਸਮਾਂ ਖਤਮ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਬੈਚਾਂ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਕਰੋ।
• ਬਹੁਤ ਵਾਰ ਸ਼ਡਿਊਲ ਕਰਨਾ। ਜ਼ੀਰੋ ਤੱਕ ਸਕੇਲ ਹੋਸਟ 'ਤੇ ਹਰ ਕਾਲ ਐਪ ਨੂੰ ਜਗਾਉਂਦੀ ਅਤੇ ਬਿਲ ਕਰਦੀ ਹੈ। ਅੰਤਰਾਲ ਨੂੰ ਅਸਲ ਲੋੜ ਨਾਲ ਮੇਲੋ।
• ਸਮਾਂ ਖੇਤਰ। "ਸਵੇਰੇ 9 ਵਜੇ" ਤੁਹਾਡੇ ਸ਼ਡਿਊਲਰ (ਅਕਸਰ UTC) ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਵੱਖਰਾ ਮਤਲਬ ਰੱਖਦਾ ਹੈ। ਸਮਾਂ UTC ਵਿੱਚ ਸੰਭਾਲੋ ਅਤੇ ਹਰ ਉਪਭੋਗਤਾ ਲਈ ਬਦਲੋ।
• ਵਰਕਫਲੋ ਫਾਈਲ ਵਿੱਚ ਸੀਕ੍ਰੇਟ। ਟੋਕਨ ਸ਼ਡਿਊਲਰ ਦੇ ਸੀਕ੍ਰੇਟ ਸਟੋਰ ਵਿੱਚ ਰੱਖੋ। ਵੇਖੋ ਐਪ ਦੀਆਂ API ਕੁੰਜੀਆਂ ਸੁਰੱਖਿਅਤ ਕਿਵੇਂ ਰੱਖੀਏ।

ਚੈੱਕਲਿਸਟ

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

Mythex ਵਿੱਚ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬਾਂ

Mythex ਦੇ ਦਸਤਾਵੇਜ਼ ਸ਼ਡਿਊਲ ਕੀਤੀਆਂ ਜਾਂ cron ਜੌਬਾਂ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕਰਦੇ, ਅਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਐਪਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਡੇਟਾਬੇਸ ਬੇਕਾਰ ਹੋਣ 'ਤੇ ਸੌਂ ਜਾਂਦੇ ਹਨ ਅਤੇ ਅਗਲੀ ਬੇਨਤੀ 'ਤੇ ਜਾਗਦੇ ਹਨ (ਵੇਖੋ Hosting limits)। ਇਸ ਲਈ ਐਪ ਦੇ ਅੰਦਰ ਟਾਈਮਰਾਂ 'ਤੇ ਨਿਰਭਰ ਨਾ ਹੋਵੋ। ਜੋ ਤਰੀਕਾ ਕੰਮ ਕਰਦਾ ਹੈ ਉਹ ਉੱਪਰ ਦਿੱਤਾ ਹੈ: ਏਜੰਟ ਨੂੰ ਇੱਕ jobs ਟੇਬਲ ਅਤੇ ਟੋਕਨ-ਸੁਰੱਖਿਅਤ ਐਂਡਪੌਇੰਟ ਬਣਾਉਣ ਲਈ ਕਹੋ, ਫਿਰ ਕਿਸੇ ਬਾਹਰੀ ਸ਼ਡਿਊਲਰ ਨੂੰ ਆਪਣੇ ਪ੍ਰਕਾਸ਼ਿਤ URL 'ਤੇ ਇਸ਼ਾਰਾ ਕਰੋ। ਟੋਕਨ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਸੀਕ੍ਰੇਟ ਵਜੋਂ ਸੰਭਾਲੋ, ਅਤੇ ਯਾਦ ਰੱਖੋ ਕਿ ਹਰ ਜਾਗਣ ਨਾਲ ਐਪ ਅਤੇ ਡੇਟਾਬੇਸ ਦੇ ਜਾਗਣ ਦੇ ਸਮੇਂ ਲਈ ਕ੍ਰੈਡਿਟ ਖਰਚ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਸਮਝਦਾਰ ਅੰਤਰਾਲ ਚੁਣੋ। ਜੇ ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਇਸ ਲਈ API ਬੈਕਐਂਡ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ REST API backend ਰੈਸਿਪੀ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਹੈ, ਅਤੇ REST API ਕਿਵੇਂ ਬਣਾਈਏ ਐਂਡਪੌਇੰਟ ਡਿਜ਼ਾਈਨ ਕਰਨ ਬਾਰੇ ਦੱਸਦਾ ਹੈ। ਜੇ ਤੁਹਾਡੇ ਉਤਪਾਦ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਹਮੇਸ਼ਾ ਚੱਲਦੇ ਵਰਕਰ ਜਾਂ ਬੋਟ ਹਨ, ਤਾਂ ਲੰਬੇ ਸਮੇਂ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਬਣਿਆ ਹੋਸਟ ਬਿਹਤਰ ਹੋ ਸਕਦਾ ਹੈ।

ਸਵਾਲ