ਆਟੋਮੇਸ਼ਨ ਸਕ੍ਰਿਪਟ: Bash, PowerShell, ਅਤੇ Python ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨਾ

ਲਾਭ:

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

ਆਟੋਮੇਸ਼ਨ ਸਕ੍ਰਿਪਟ: AI ਨਾਲ Bash, PowerShell ਅਤੇ Python ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕਰਨਾ

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

ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕਿਵੇਂ AI ਨਾਲ ਸੁਰੱਖਿਅਤ, ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਯੋਗ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨਾ ਹੈ; ਜੀਵਨ-ਰੱਖਿਅਕ ਸਿਧਾਂਤ ਜਿਵੇਂ ਕਿ idempotency (ਇੱਕੋ ਲਿਪੀ ਨੂੰ ਦੋ ਵਾਰ ਚਲਾਉਣ ਨਾਲ ਨੁਕਸਾਨ ਨਹੀਂ ਹੁੰਦਾ) ਅਤੇ ਡਰਾਈ-ਰਨ; ਅਤੇ ਤੁਸੀਂ ਉਹਨਾਂ ਜਾਂਚਾਂ ਨੂੰ ਸਿੱਖੋਗੇ ਜੋ ਇੱਕ ਸਕ੍ਰਿਪਟ ਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਪਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਲੰਘਣਾ ਚਾਹੀਦਾ ਹੈ।

ਏਆਈ ਨਾਲ ਸਕ੍ਰਿਪਟਿੰਗ ਇੰਨੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕਿਉਂ ਹੈ?

ਇੱਥੋਂ ਤੱਕ ਕਿ ਇੱਕ ਤਜਰਬੇਕਾਰ ਪ੍ਰਸ਼ਾਸਕ ਨੂੰ ਵੀ ਇੱਕ Bash ਲੂਪ ਦਾ ਸਹੀ ਸੰਟੈਕਸ, PowerShell cmdlet (ਕਮਾਂਡ), ਜਾਂ ਇੱਕ ਪਾਈਥਨ ਕੋਸ਼ਿਸ਼/ਦਿਲ ਦੁਆਰਾ ਬਲਾਕ ਨੂੰ ਛੱਡ ਕੇ ਦੇ ਮਾਪਦੰਡਾਂ ਬਾਰੇ ਨਹੀਂ ਪਤਾ ਹੋ ਸਕਦਾ ਹੈ। AI ਇਸ ਪਾੜੇ ਨੂੰ ਤੁਰੰਤ ਭਰ ਦਿੰਦਾ ਹੈ: ਤੁਸੀਂ ਸਾਦੇ ਤੁਰਕੀ ਵਿੱਚ ਇਰਾਦੇ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹੋ, ਅਤੇ ਇਹ ਇੱਕ ਕਾਰਜਕਾਰੀ ਰੂਪਰੇਖਾ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ AI ਨੂੰ ਮੌਜੂਦਾ ਸਕ੍ਰਿਪਟ ਦੇ ਸਕਦੇ ਹੋ ਅਤੇ "ਇਸ ਨੂੰ ਸਮਝਾਓ", "ਐਰਰ ਹੈਂਡਲਿੰਗ ਸ਼ਾਮਲ ਕਰੋ", "ਇਸ ਨੂੰ ਹੋਰ ਪੜ੍ਹਨਯੋਗ ਬਣਾਓ" ਕਹਿ ਸਕਦੇ ਹੋ। ਇਹ ਸਿੱਖਣ ਦੀ ਵਕਰ ਨੂੰ ਛੋਟਾ ਕਰਦਾ ਹੈ ਅਤੇ ਜੂਨੀਅਰ ਟੀਮ ਦੇ ਮੈਂਬਰਾਂ ਨੂੰ ਗਤੀ ਵਿੱਚ ਲਿਆਉਂਦਾ ਹੈ।

ਪਰ ਸ਼ਕਤੀ ਨਾਲ ਜ਼ਿੰਮੇਵਾਰੀ ਆਉਂਦੀ ਹੈ. ਬਹੁਤੀ ਵਾਰ, ਇੱਕ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਸਕ੍ਰਿਪਟ "ਖੁਸ਼ਹਾਲ ਮਾਰਗ" ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਲਿਖਦੀ ਹੈ (ਜੇ ਸਭ ਠੀਕ ਹੈ); ਪਰ ਇਹ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨੂੰ ਖੁੰਝ ਸਕਦਾ ਹੈ (ਫਾਇਲ ਗੁੰਮ, ਡਿਸਕ ਪੂਰੀ, ਨੈੱਟਵਰਕ ਡਾਊਨ) ਜਾਂ ਖਤਰਨਾਕ ਧਾਰਨਾਵਾਂ ਬਣਾ ਸਕਦੀ ਹੈ। ਇਸ ਲਈ ਤਿੰਨ ਪੜਾਵਾਂ ਵਿੱਚ AI ਨਾਲ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣ ਬਾਰੇ ਸੋਚੋ: ਤਿਆਰ ਕਰੋ, ਸਖ਼ਤ ਕਰੋ, ਪੁਸ਼ਟੀ ਕਰੋ।

ਕਦਮ ਦਰ ਕਦਮ: ਸੁਰੱਖਿਅਤ ਸਕ੍ਰਿਪਟ ਪੀੜ੍ਹੀ

1. ਇਰਾਦਾ ਅਤੇ ਰੁਕਾਵਟ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖੋ। ਕਿਹੜਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ, ਕਿਹੜਾ ਸ਼ੈੱਲ ਸੰਸਕਰਣ, ਕਿਹੜਾ ਫਾਈਲ ਮਾਰਗ, ਕਿਹੜੇ ਅਧਿਕਾਰ? ਜਿਵੇਂ "ਉਬੰਟੂ 22.04, ਬੈਸ਼ 5, ਸੂਡੋ ਰੂਟ ਨਹੀਂ, ਸਿਰਫ /opt/app/logs ਦੇ ਅਧੀਨ ਚੱਲਦਾ ਹੈ"। ਅਸਪਸ਼ਟ ਮੰਗ ਖਤਰਨਾਕ ਧਾਰਨਾ ਪੈਦਾ ਕਰਦੀ ਹੈ।
2. ਸੁਰੱਖਿਆ ਰੇਲਿੰਗ ਲਈ ਪੁੱਛੋ। ਸਕ੍ਰਿਪਟ ਨੂੰ "ਅਸਫਲਤਾ 'ਤੇ ਰੋਕੋ" (ਬੈਸ਼ ਵਿੱਚ ਸੈੱਟ -euo ਪਾਈਪਫੇਲ), ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈਆਂ ਦੀ ਪੁਸ਼ਟੀ ਲਈ ਪ੍ਰੋਂਪਟ, ਓਪਰੇਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਬੈਕਅੱਪ, ਅਤੇ ਡ੍ਰਾਈ-ਰਨ ਮੋਡ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਗਾਰਡਰੇਲ ਕੈਪਚਰ ਐਜ ਦੱਸਦੇ ਹਨ ਕਿ AI ਬਾਈਪਾਸ ਕਰਦਾ ਹੈ।
3. ਅਯੋਗ ਲਿਖੋ. ਸਕਰਿਪਟ ਨੂੰ ਦੂਜੀ ਵਾਰ ਚਲਾਉਣ ਵੇਲੇ ਕੋਈ ਗਲਤੀ ਜਾਂ ਨੁਕਸਾਨ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। "ਜੇਕਰ ਉਪਭੋਗਤਾ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ ਤਾਂ ਛੱਡੋ", "ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ ਜੇਕਰ ਇਹ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਨਾ ਛੂਹੋ ਜੇ ਇਹ ਮੌਜੂਦ ਹੈ" ਦਾ ਤਰਕ ਸਥਾਪਤ ਕਰੋ। ਇਹ ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਵਾਰ-ਵਾਰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
4. ਪੜ੍ਹੋ ਅਤੇ ਸਮਝੋ. ਤਿਆਰ ਕੀਤੀ ਹਰ ਲਾਈਨ ਨੂੰ ਪੜ੍ਹੋ. AI ਨੂੰ ਵਿਨਾਸ਼ਕਾਰੀ ਕਮਾਂਡਾਂ (rm, Remove-Item, DROP) ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਮਾਰਕ ਕਰਨ ਲਈ ਕਹੋ।
5. ਡਰਾਈ-ਰਨ ਨਾਲ ਟੈਸਟ ਕਰੋ। ਪਹਿਲਾਂ, ਇਸਨੂੰ ਅਸਲ ਕਾਰਵਾਈਆਂ ਦੀ ਬਜਾਏ "ਕੀ ਕਰਨਾ ਹੈ" ਮੋਡ ਵਿੱਚ ਚਲਾਓ। ਜੇਕਰ ਆਉਟਪੁੱਟ ਉਹੀ ਹੈ ਜਿਸਦੀ ਤੁਸੀਂ ਉਮੀਦ ਕਰਦੇ ਹੋ, ਅਸਲ ਮੋਡ - ਅਤੇ ਪਹਿਲਾਂ ਟੈਸਟ ਮਸ਼ੀਨ 'ਤੇ ਸਵਿਚ ਕਰੋ।
6. ਆਪਣੀ ਵਾਪਸੀ ਦੀ ਤਿਆਰੀ ਕਰੋ। ਕੀ ਸਕ੍ਰਿਪਟ ਬੈਕਅੱਪ ਲੈਂਦੀ ਹੈ? ਕੀ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਬੈਕਅੱਪ ਨੂੰ ਕਿਵੇਂ ਰੀਸਟੋਰ ਕਰਨਾ ਹੈ? ਕੀ ਲੌਗਿੰਗ ਹੈ, ਕੀ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਬਾਅਦ ਵਿੱਚ ਕੀ ਕਰ ਰਿਹਾ ਹੈ?

ਸੰਕੇਤ: ਹਰੇਕ ਵਿਨਾਸ਼ਕਾਰੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ DRY_RUN=true ਵੇਰੀਏਬਲ ਅਤੇ ਇੱਕ --apply ਫਲੈਗ ਸ਼ਾਮਲ ਕਰੋ। ਡਿਫਾਲਟ ਵਿਵਹਾਰ ਇਹ ਲਿਖਣਾ ਹੈ ਕਿ ਕੁਝ ਵੀ ਮਿਟਾਏ ਬਿਨਾਂ ਕੀ ਹੋਵੇਗਾ; ਅਸਲ ਮਿਟਾਉਣ ਨੂੰ ਤਾਂ ਹੀ ਕੰਮ ਕਰਨ ਦਿਓ ਜੇਕਰ --apply ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਹ ਇੱਕ ਆਦਤ ਕੈਰੀਅਰ ਦੀਆਂ ਲੰਬੀਆਂ ਤਬਾਹੀਆਂ ਨੂੰ ਰੋਕਦੀ ਹੈ।

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - ਨਿਪੁੰਸਕਤਾ 3 ਘੰਟੇ ਬਚਾਈ ਗਈ। ਇੱਕ ਪ੍ਰਸ਼ਾਸਕ ਨੇ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੀ ਜਿਸ ਨੇ 25 ਸਰਵਰਾਂ 'ਤੇ ਇੱਕੋ ਨਿਗਰਾਨੀ ਏਜੰਟ ਨੂੰ ਸਥਾਪਿਤ ਕੀਤਾ। ਪਹਿਲਾ ਸੰਸਕਰਣ ਅਯੋਗ ਨਹੀਂ ਸੀ: ਇਸਨੇ ਦੂਜੀ ਵਾਰ ਸੰਰਚਨਾ ਨੂੰ ਤੋੜ ਦਿੱਤਾ ਜੇਕਰ ਏਜੰਟ ਪਹਿਲਾਂ ਹੀ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਇੰਜਨੀਅਰ ਕੋਲ ਏਆਈ ਐਡ "ਚੈੱਕ ਕਿ ਕੀ ਇਹ ਇੰਸਟਾਲ ਹੈ, ਇਸ ਨੂੰ ਛੱਡ ਦਿਓ ਜੇ ਇਹ ਹੈ" ਤਰਕ ਸੀ। ਅਗਲੀ ਮੇਨਟੇਨੈਂਸ ਵਿੰਡੋ ਦੇ ਦੌਰਾਨ ਸਕ੍ਰਿਪਟ ਗਲਤੀ ਨਾਲ ਦੋ ਵਾਰ ਚਾਲੂ ਹੋ ਗਈ ਪਰ ਇਸਦਾ ਕੋਈ ਨੁਕਸਾਨ ਨਹੀਂ ਹੋਇਆ। Idempotency ਨੇ ਇੱਕ 25-ਸਰਵਰ ਰਿਕਵਰੀ ਨੂੰ ਬੇਲੋੜੀ ਬਣਾ ਦਿੱਤਾ।

ਕੇਸ 2 - ਡਰਾਈ-ਰਨ ਨੇ ਇੱਕ ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕੀਤਾ। ਇੱਕ ਟੀਮ ਨੂੰ ਇੱਕ Bash ਸਕ੍ਰਿਪਟ ਪ੍ਰਾਪਤ ਹੋਈ ਜਿਸਨੇ ਪੁਰਾਣੇ ਬੈਕਅੱਪ ਨੂੰ ਸਾਫ਼ ਕੀਤਾ। ਜੇਕਰ ਵੇਰੀਏਬਲ ਖਾਲੀ ਸੀ, ਤਾਂ ਮਾਰਗ /ਬੈਕਅੱਪਸ/ ਦੀ ਬਜਾਏ / ਬਣ ਜਾਂਦਾ ਹੈ — ਇੱਕ ਕਲਾਸਿਕ ਖ਼ਤਰਾ। ਇੰਜੀਨੀਅਰ ਨੇ ਪਹਿਲਾਂ ਇਸਨੂੰ DRY_RUN ਮੋਡ ਵਿੱਚ ਚਲਾਇਆ, ਜਦੋਂ ਉਸਨੇ ਆਉਟਪੁੱਟ ਵਿੱਚ rm -rf/ ਵਰਗੀ ਇੱਕ ਲਾਈਨ ਵੇਖੀ, ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ ਚੈੱਕ ਜੋੜਿਆ (: "${BACKUP_DIR:?cannot be empty}")। ਡਰਾਈ ਰਨਿੰਗ ਨੇ ਇੱਕ ਬੱਗ ਫੜਿਆ ਜੋ ਉਤਪਾਦਨ ਵਿੱਚ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰੀ ਡਿਸਕ ਨੂੰ ਪੂੰਝ ਦੇਵੇਗਾ।

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

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ

1) ਸੁਰੱਖਿਅਤ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਜਨਰੇਸ਼ਨ:

ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਸੀਨੀਅਰ ਲੀਨਕਸ ਆਟੋਮੇਸ਼ਨ ਇੰਜੀਨੀਅਰ। ਉਬੰਟੂ 22.04 / ਬੈਸ਼ 5 ਲਈ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੋ। ਉਦੇਸ਼:[ਮਕਸਦ]। ਨਿਯਮ:- "set -euo pipefail" ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ।- ਲੋੜੀਂਦੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ": ${VAR:?}" ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰੋ।- ਡਿਫਾਲਟ DRY_RUN=true ਨਾਲ ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈਆਂ ਕਰੋ; ਅਸਲ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਿਰਫ --apply ਫਲੈਗ ਨਾਲ ਚੱਲਣ ਦਿਓ। - stdout ਲਈ ਹਰੇਕ ਕਦਮ ਨੂੰ ਲੌਗ ਕਰੋ, ਗਲਤੀ 'ਤੇ ਇੱਕ ਅਰਥਪੂਰਨ ਸੰਦੇਸ਼ ਨਾਲ ਰੁਕੋ। - ਇਸ ਨੂੰ ਇਮਪੋਟੈਂਟ ਬਣਾਓ (ਤਾਂ ਕਿ ਇਹ ਦੂਜੀ ਦੌੜ 'ਤੇ ਨੁਕਸਾਨ ਨਾ ਕਰੇ)। ਫਿਰ: ਸੰਭਾਵੀ ਵਿਨਾਸ਼ਕਾਰੀ ਲਾਈਨਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਚਿੰਨ੍ਹਿਤ ਕਰੋ ਅਤੇ 3 ਕੇਸ ਲਿਖੋ ਜਿਨ੍ਹਾਂ ਦੀ ਮੈਨੂੰ ਉਤਪਾਦਨ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

2) ਮੌਜੂਦਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਖਤ ਕਰਨਾ:

ਹੇਠਾਂ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਉਤਪਾਦਨ ਲਈ ਤਿਆਰ ਕਰੋ: (1) ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਅਤੇ ਲੌਗਿੰਗ ਸ਼ਾਮਲ ਕਰੋ, (2) ਇਸ ਨੂੰ ਬੇਮਿਸਾਲ ਬਣਾਓ, (3) ਡਰਾਈ-ਰਨ ਦੇ ਪਿੱਛੇ ਵਿਨਾਸ਼ਕਾਰੀ ਕਮਾਂਡਾਂ ਰੱਖੋ, (4) ਵੇਰੀਏਬਲ ਲਈ ਹਾਰਡ-ਕੋਡ ਕੀਤੇ ਮਾਰਗ ਅਤੇ ਭੇਦ ਕੱਢੋ। ਹਰ ਲਾਈਨ ਦਾ ਸੰਖੇਪ ਵਰਣਨ ਕਰੋ ਜੋ ਤੁਸੀਂ ਬਦਲਿਆ ਹੈ ਅਤੇ ਕਿਉਂ। ਸਕ੍ਰਿਪਟ: [ਸਕ੍ਰਿਪਟ]

3) PowerShell ਸੁਰੱਖਿਅਤ ਆਟੋਮੇਸ਼ਨ:

ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਵਿੰਡੋਜ਼ ਆਟੋਮੇਸ਼ਨ ਮਾਹਰ। ਇੱਕ PowerShell 5.1 ਅਨੁਕੂਲ ਸਕ੍ਰਿਪਟ ਲਿਖੋ। ਉਦੇਸ਼: [ਉਦੇਸ਼]। ਨਿਯਮ:- "$ErrorActionPreference = 'Stop'" ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ।- ਵਿਨਾਸ਼ਕਾਰੀ cmdlets (ਡਿਫਾਲਟ WhatIf) ਲਈ -WhatIf ਸਮਰਥਨ ਸ਼ਾਮਲ ਕਰੋ।- ਹਰ ਐਕਸ਼ਨ ਨੂੰ ਕੋਸ਼ਿਸ਼/ਕੈਚ, ਲੌਗ ਐਰਰ ਨਾਲ ਲਪੇਟੋ।- ਕ੍ਰੈਡੈਂਸ਼ੀਅਲ ਹਾਰਡਕੋਡਿੰਗ; ਪੈਰਾਮੀਟਰ ਜਾਂ ਸੁਰੱਖਿਅਤ ਇੰਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਵਿਨਾਸ਼ਕਾਰੀ ਲਾਈਨਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰੋ ਅਤੇ ਅਨਡੂ ਸਟੈਪਸ ਲਿਖੋ।

4) ਕਰੋਨ/ਸ਼ਡਿਊਲ ਸਮੀਕਰਨ ਡੀਕੋਡਿੰਗ ਅਤੇ ਤਸਦੀਕ:

ਸਾਦੇ ਤੁਰਕੀ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਕ੍ਰੋਨ ਕਥਨ ਦੀ ਵਿਆਖਿਆ ਕਰੋ ਅਤੇ ਅਗਲੇ 3 ਰਨਟਾਈਮ ਲਿਖੋ: [ਪ੍ਰਗਟਾਵੇ] ਨਾਲ ਹੀ, ਜੇਕਰ ਮੇਰਾ ਟੀਚਾ "[ਮਕਸਦ]" ਹੈ, ਤਾਂ ਕੀ ਇਹ ਕਥਨ ਸਹੀ ਹੈ ਜਾਂ ਕੀ ਕੋਈ ਹੱਲ ਹੈ ਜੋ ਤੁਸੀਂ ਸੁਝਾਉਂਦੇ ਹੋ? ਸਮਾਂ ਮਿਆਦ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਵੀ ਨੋਟ ਕਰੋ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ:

ਮੈਨੂੰ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੋ ਜੋ ਲੌਗ ਨੂੰ ਸਾਫ਼ ਕਰੇ।

ਇਹ ਪ੍ਰੋਂਪਟ ਖ਼ਤਰਨਾਕ ਹੈ: ਇਹ ਸਪਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਕਿਹੜਾ OS, ਕਿਹੜੀ ਡਾਇਰੈਕਟਰੀ, ਕਿਹੜੀ ਉਮਰ ਸੀਮਾ, ਕਿਹੜੀ ਸੁਰੱਖਿਆ ਗਾਰਡਰੇਲ। AI ਇੱਕ-ਲਾਈਨਰ, ਵਿਨਾਸ਼ਕਾਰੀ ਅਤੇ ਅਪ੍ਰਮਾਣਿਤ rm ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ।

ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਾਉਟ:

ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਸੀਨੀਅਰ ਲੀਨਕਸ ਆਟੋਮੇਸ਼ਨ ਇੰਜੀਨੀਅਰ। Ubuntu 22.04 / Bash ਲਈ ਲੌਗ ਕਲੀਨਿੰਗ ਸਕ੍ਰਿਪਟ ਲਿਖੋ। /opt/app/logs ਅਧੀਨ ਸਿਰਫ਼ .log ਫ਼ਾਈਲਾਂ ਨੂੰ ਮਿਟਾਓ ਜੋ 30 ਦਿਨਾਂ ਤੋਂ ਪੁਰਾਣੀਆਂ ਹਨ। ਨਿਯਮ: ਸੈੱਟ -euo ਪਾਈਪਫੇਲ; BACKUP_DIR ਅਤੇ LOG_DIR ਵੇਰੀਏਬਲ ਪ੍ਰਮਾਣਿਤ ਕਰੋ (ਖਾਲੀ ਹੋਣ 'ਤੇ ਰੋਕੋ); ਮਿਟਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਲੌਗ ਫਾਈਲ ਸੂਚੀ; DRY_RUN=true ਨੂੰ ਡਿਫਾਲਟ ਹੋਣ ਦਿਓ, ਅਸਲ ਵਿੱਚ ਸਿਰਫ --apply ਨਾਲ ਮਿਟਾਉਣਾ; ਇਸ ਨੂੰ ਅਯੋਗ ਹੋਣ ਦਿਓ। ਵਿਨਾਸ਼ਕਾਰੀ ਲਾਈਨਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰੋ ਅਤੇ 3 ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਲਿਖੋ ਜਿਨ੍ਹਾਂ ਦੀ ਮੈਨੂੰ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਵਿਸ਼ੇਸ਼ਤਾ

ਕਮਜ਼ੋਰ/ਤੇਜ਼ ਸਕ੍ਰਿਪਟ

ਸਖ਼ਤ ਸਕ੍ਰਿਪਟ

ਅਸ਼ੁੱਧੀ ਨੂੰ ਸੰਭਾਲਣਾ

ਨਹੀਂ, ਚੁੱਪ ਅਸਫਲਤਾ

ਸੈੱਟ -euo ਪਾਈਪ ਫੇਲ, ਕੋਸ਼ਿਸ਼ ਕਰੋ/ਕੈਚ ਕਰੋ

ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈ

ਸਿੱਧਾ ਕੰਮ ਕਰਦਾ ਹੈ

ਡ੍ਰਾਈ-ਰਨ + ਓਪਨ ਚੈੱਕ ਫਲੈਗ

ਰੀਸਟਾਰਟ ਕਰੋ

ਨੁਕਸਾਨ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ

ਅਕਲਮੰਦ, ਸੁਰੱਖਿਅਤ

ਗੁਪਤ ਪ੍ਰਬੰਧਨ

ਹਾਰਡ ਕੋਡਿਡ

ਵੇਰੀਏਬਲ/ਲੁਕਿਆ ਹੋਇਆ ਇੰਪੁੱਟ

ਅਣਡੂ

ਕੋਈ ਨਹੀਂ

ਬੈਕਅੱਪ + ਰੀਸਟੋਰ ਪੜਾਅ

ਆਮ ਗਲਤੀਆਂ

• ਡ੍ਰਾਈ-ਰਨ ਤੋਂ ਬਿਨਾਂ ਵਿਨਾਸ਼ਕਾਰੀ ਲਿਪੀ ਨੂੰ ਚਲਾਉਣਾ। ਸਕ੍ਰਿਪਟ ਨੂੰ ਨਹੀਂ ਦੇਖ ਰਿਹਾ ਜਿਸ ਵਿੱਚ rm, Remove-Item, DROP ਪਹਿਲਾਂ ਡਰਾਈ ਮੋਡ ਲਾਗਤ ਡਿਸਕ ਵਿੱਚ ਹੈ।
• ਨਲ ਵੇਰੀਏਬਲ ਜਾਂਚ ਨੂੰ ਛੱਡੋ। ਇੱਕ ਖਾਲੀ ਮਾਰਗ ਵੇਰੀਏਬਲ /ਬੈਕਅੱਪ/ ਦੀ ਬਜਾਏ / ਬਣਾਉਂਦਾ ਹੈ; : "${VAR:?}" ਨਾਲ ਪੁਸ਼ਟੀ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ।
• ਵਿਹਾਰਕਤਾ ਨੂੰ ਭੁੱਲਣਾ. ਦੋ ਵਾਰ ਚੱਲਣ 'ਤੇ ਸਕ੍ਰਿਪਟ ਟੁੱਟ ਜਾਂਦੀ ਹੈ, ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਭਰੋਸੇਯੋਗ ਨਹੀਂ ਬਣਾਉਂਦਾ।
• ਹਾਰਡ-ਕੋਡਿੰਗ ਰਾਜ਼. ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਪਾਸਵਰਡ ਅਤੇ ਕੁੰਜੀ ਲਿਖਣਾ ਇੱਕ ਲੀਕ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਉਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਾਂਝਾ ਕਰਦੇ ਹੋ।
• ਉਤਪਾਦਨ ਵਿੱਚ ਟੈਸਟਿੰਗ. ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਪਹਿਲੀ ਵਾਰ ਕਰਨ ਦਾ ਮਤਲਬ ਹੈ ਸਟੇਜ 'ਤੇ ਰਿਹਰਸਲ ਕਰਨਾ; ਪਹਿਲਾਂ ਮਸ਼ੀਨ ਦੀ ਜਾਂਚ ਕਰੋ।

ਧਿਆਨ ਦਿਓ: AI ਦੁਆਰਾ ਦਿੱਤੀ ਗਈ ਇੱਕ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਿਰਫ਼ ਇਸ ਲਈ ਸਵੀਕਾਰ ਨਾ ਕਰੋ ਕਿਉਂਕਿ "ਇਸਨੇ ਕੰਮ ਕੀਤਾ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਸਹੀ ਹੈ"। ਕਿਉਂਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਵਿਨਾਸ਼ਕਾਰੀ ਨਹੀਂ ਹੈ। ਇੱਕ ਸਕ੍ਰਿਪਟ ਖੁਸ਼ਹਾਲ ਮਾਰਗ 'ਤੇ ਚੱਲ ਸਕਦੀ ਹੈ ਅਤੇ ਕਿਨਾਰੇ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ; ਅਸਲ ਪ੍ਰੀਖਿਆ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਹਨ.

ਸਾਰੰਸ਼ ਵਿੱਚ

ਆਟੋਮੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਦੁਹਰਾਓ ਨੂੰ ਖਤਮ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਮਨੁੱਖੀ ਗਲਤੀ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ; AI ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਬਣਾਉਣ, ਵਿਆਖਿਆ ਕਰਨ ਅਤੇ ਸਖ਼ਤ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਤੇਜ਼ ਹੈ। ਪਰ ਸਕ੍ਰਿਪਟ ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਸ਼ਕਤੀ ਹੈ: ਜੇ ਇਹ ਗਲਤ ਹੈ, ਤਾਂ ਇਹ ਮਿਟਾਉਂਦੀ ਹੈ, ਰੋਕਦੀ ਹੈ, ਰੁਕਾਵਟ ਪਾਉਂਦੀ ਹੈ। ਇਸ ਲਈ "ਉਤਪਾਦਨ, ਸਖ਼ਤ, ਪ੍ਰਮਾਣਿਤ" ਚੱਕਰ ਸਥਾਪਤ ਕਰੋ। ਹਰ ਵਿਨਾਸ਼ਕਾਰੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣਾ, ਇਮਦਾਦਤਾ, ਡਰਾਈ-ਰਨ, ਅਤੇ ਫਾਲਬੈਕ ਸ਼ਾਮਲ ਕਰੋ। ਵੇਰੀਏਬਲ ਦੇ ਭੇਦ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰੋ, ਟੈਸਟ ਮਸ਼ੀਨ 'ਤੇ ਪਹਿਲੀ ਵਾਰ ਕਰੋ. ਏਆਈ ਸਕ੍ਰਿਪਟ ਲਿਖਦੀ ਹੈ; ਇਸ ਨੂੰ ਪੜ੍ਹਨਾ, ਇਸ ਦੀ ਜਾਂਚ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਚਲਾਉਣ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਲੈਣਾ ਤੁਹਾਡਾ ਕੰਮ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

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

ਚੈੱਕਲਿਸਟ

• [ ] ਕੀ ਮੈਂ ਪ੍ਰੋਂਪਟ ਵਿੱਚ OS, ਸ਼ੈੱਲ ਸੰਸਕਰਣ, ਮਾਰਗ ਅਤੇ ਅਧਿਕਾਰ ਵਰਗੀਆਂ ਪਾਬੰਦੀਆਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਹਨ?
• ਕੀ ਸਕ੍ਰਿਪਟ ਸੈੱਟ -euo pipefail / $ErrorActionPreference='Stop' ਨਾਲ ਨੁਕਸ-ਸਹਿਣਸ਼ੀਲ ਹੈ?
• [ ] ਕੀ ਡਰਾਈ-ਰਨ ਦੇ ਪਿੱਛੇ ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈਆਂ ਹਨ/-ਕੀ ਜੇ ਅਤੇ ਇੱਕ ਸਪੱਸ਼ਟ ਜਾਂਚ ਫਲੈਗ ਦੀ ਲੋੜ ਹੈ?
• [ ] ਕੀ ਸਕ੍ਰਿਪਟ ਅਯੋਗ ਹੈ (ਦੂਜੀ ਦੌੜ 'ਤੇ ਸੁਰੱਖਿਅਤ)?
• [ ] ਕੀ ਮੈਂ ਉਹਨਾਂ ਨੂੰ ਹਾਰਡ ਕੋਡਿੰਗ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲ/ਗੁਪਤ ਇਨਪੁਟ ਦੇ ਭੇਦਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕੀਤਾ ਹੈ?
• [ ] ਕੀ ਮੈਂ ਟੈਸਟ ਮਸ਼ੀਨ 'ਤੇ ਪਹਿਲੀ ਵਾਰ ਕੀਤਾ ਹੈ ਅਤੇ ਵਾਪਸੀ ਦੀ ਯੋਜਨਾ ਤਿਆਰ ਕੀਤੀ ਹੈ?