ਸਕ੍ਰਿਪਟ ਅਤੇ ਆਟੋਮੇਸ਼ਨ ਜਨਰੇਸ਼ਨ: ਬੈਸ਼, ਪਾਈਥਨ ਅਤੇ ਪਾਵਰਸ਼ੇਲ

ਲਾਭ:

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

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

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

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

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

1. ਕੰਮ ਅਤੇ ਵਾਤਾਵਰਣ ਦਾ ਵਰਣਨ ਕਰੋ। ਇਹ ਕੀ ਕਰੇਗਾ, ਕਿਹੜਾ OS/ਸ਼ੈਲ, ਕਿਹੜੀਆਂ ਰੁਕਾਵਟਾਂ ਹਨ?
2. ਸੁਰੱਖਿਆ ਰੇਲਿੰਗ ਲਈ ਪੁੱਛੋ। bash ਵਿੱਚ, ਸੈੱਟ -euo ਪਾਈਪਫੇਲ (ਗਲਤੀ 'ਤੇ ਰੁਕੋ, ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ 'ਤੇ ਰੋਕੋ), ਖਤਰਨਾਕ ਕਾਰਵਾਈਆਂ ਲਈ ਪੁਸ਼ਟੀਕਰਨ ਪ੍ਰੋਂਪਟ, ਮਿਟਾਉਣ ਦੀ ਬਜਾਏ ਪਹਿਲਾਂ ਮੂਵ ਕਰੋ।
3. ਡਰਾਈ-ਰਨ ਮੋਡ ਲਈ ਬੇਨਤੀ ਕਰੋ। ਸਕ੍ਰਿਪਟ ਨੂੰ ਲਿਖਣ ਦਿਓ ਕਿ --dry-run ਨਾਲ ਕੀ ਕਰਨਾ ਹੈ, ਪਰ ਅਜਿਹਾ ਨਾ ਕਰੋ।
4. ਪੜ੍ਹੋ ਅਤੇ ਸਮਝੋ. ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਹਰ ਕਤਾਰ ਕੀ ਕਰਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਮਿਟਾਓ/ਮੂਵ/ਨੈੱਟਵਰਕ ਓਪਰੇਸ਼ਨ।
5. ਇੱਕ ਅਲੱਗ-ਥਲੱਗ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇਸਨੂੰ ਅਜ਼ਮਾਓ। ਟੈਸਟ ਫੋਲਡਰ ਵਿੱਚ, ਇਸ ਨੂੰ ਨਮੂਨਾ ਡੇਟਾ ਨਾਲ ਚਲਾਓ।
6. ਲੌਗਿੰਗ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ। ਸਕ੍ਰਿਪਟ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਦਿਓ ਕਿ ਇਹ ਕੀ ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸਨੂੰ ਬਾਅਦ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕੇ।

ਸੁਰੱਖਿਅਤ ਸਕ੍ਰਿਪਟਿੰਗ ਦੀਆਂ ਜ਼ਰੂਰੀ ਗੱਲਾਂ

ਇੱਕ ਉਤਪਾਦਨ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇਹ ਗਾਰਡਰੇਲ ਸ਼ਾਮਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ:

• ਗਲਤੀ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਰੋਕਿਆ ਜਾ ਰਿਹਾ ਹੈ। ਬੈਸ਼: ਸੈੱਟ -ਯੂਓ ਪਾਈਪਫੇਲ। PowerShell: $ErrorActionPreference = 'ਸਟਾਪ'। ਜੇ ਇੱਕ ਕਦਮ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅਗਲੇ ਨੂੰ ਕੰਮ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ।
• ਨਿਪੁੰਸਕਤਾ (ਦੁਹਰਾਉਣਯੋਗਤਾ)। ਜੇ ਸਕ੍ਰਿਪਟ ਦੋ ਵਾਰ ਚਲਦੀ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਦੁੱਗਣਾ ਨੁਕਸਾਨ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ; "ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਛੱਡ ਦਿਓ" ਤਰਕ।
• ਪ੍ਰਵਾਨਗੀ ਅਤੇ ਡਰਾਈ-ਰਨ. ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈਆਂ ਲਈ "ਕੀ ਤੁਹਾਨੂੰ ਯਕੀਨ ਹੈ?" ਜਾਂ --dry-run ਫਲੈਗ।
• ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਕਤਾ। ਕੀ ਮਾਪਦੰਡ ਉਮੀਦ ਅਨੁਸਾਰ ਹਨ? ਇੱਕ ਖਾਲੀ ਵੇਰੀਏਬਲ rm -rf "$DIR"/ ਨੂੰ rm -rf / ਆਫ਼ਤ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ।
• ਲਾਗਿੰਗ. ਕੀ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਕਦੋਂ ਕੀਤਾ ਗਿਆ ਸੀ ਇਸ ਦਾ ਰਿਕਾਰਡ।

ਸੰਕੇਤ: Bash ਵਿੱਚ ਸਭ ਤੋਂ ਖਤਰਨਾਕ ਗਲਤੀ ਇੱਕ ਖਾਲੀ ਵੇਰੀਏਬਲ ਨਾਲ ਮਿਟਾਉਣਾ ਹੈ। rm -rf "$DIR" ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਹਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੇਕਰ $DIR ਖਾਲੀ ਹੈ। ਸੈੱਟ -u (ਅਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲ 'ਤੇ ਰੋਕੋ) ਅਤੇ ਮਿਟਾਉਣ ਤੋਂ ਪਹਿਲਾਂ [ -n "$DIR" ] ਦੀ ਜਾਂਚ ਕਰਨਾ ਇੱਕ ਜੀਵਨ ਬਚਾਉਣ ਵਾਲਾ ਹੈ। AI ਤੋਂ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਬੇਨਤੀ ਕਰਦੇ ਸਮੇਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਸੁਰੱਖਿਆ ਦੀ ਬੇਨਤੀ ਕਰੋ।

ਸੁਰੱਖਿਆ: ਗੁਪਤ ਅਤੇ ਵਿਨਾਸ਼ਕਾਰੀ ਹੁਕਮ

ਦੋ ਵੱਡੇ ਖ਼ਤਰੇ:

1. ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਰਾਜ਼ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ। ਪਾਸਵਰਡ ਟੋਕਨ ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਪਲੇਨ ਟੈਕਸਟ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਜਾਂ ਵਾਲਟ ਤੋਂ ਪੜ੍ਹਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਲਿਪੀਆਂ ਗਿੱਟ ਵਿੱਚ ਜਾਂਦੀਆਂ ਹਨ; ਦਫ਼ਨਾਇਆ ਗੁਪਤ ਸਥਾਈ ਲੀਕ ਹੈ.
2. ਵਿਨਾਸ਼ਕਾਰੀ ਹੁਕਮ. rm -rf, Remove-Item -Recurse -Force, DROP TABLE, terraform ਤਬਾਹ — ਜਦੋਂ ਤੁਸੀਂ ਇਹਨਾਂ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਰੁਕੋ ਅਤੇ ਦੋ ਵਾਰ ਸੋਚੋ। ਪਹਿਲਾਂ ਪ੍ਰੋਡ ਵਿੱਚ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਵਿਨਾਸ਼ਕਾਰੀ ਕਮਾਂਡ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਾ ਕਰੋ।

ਸਾਵਧਾਨ: ਜਦੋਂ ਤੁਸੀਂ AI ਨੂੰ "ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖਣ ਲਈ ਕਹਿੰਦੇ ਹੋ ਜੋ ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਦੀ ਹੈ", ਧਿਆਨ ਨਾਲ ਖੋਜ ਦੇ ਸਕੋਪ ਨੂੰ ਪੜ੍ਹੋ ... -delete ਜਾਂ rm ਕਮਾਂਡ ਜੋ ਇਹ ਪੈਦਾ ਕਰਦੀ ਹੈ। ਇੱਕ ਵਾਈਲਡਕਾਰਡ (*) ਜਾਂ ਗਲਤ ਮਾਰਗ ਉਸ ਤੋਂ ਵੱਧ ਮਿਟਾ ਦੇਵੇਗਾ ਜਿੰਨਾ ਤੁਸੀਂ ਮਿਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਹਮੇਸ਼ਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਬਜਾਏ "ਲਿਸਟ ਟੂ ਡਿਲੀਟ" ਮੋਡ ਨਾਲ ਪਹਿਲਾਂ ਚਲਾਓ।

ਤਿੰਨ ਭਾਸ਼ਾਵਾਂ ਦੀ ਤੁਲਨਾ

ਮਾਪਦੰਡ

bash

ਪਾਈਥਨ

ਪਾਵਰਸ਼ੇਲ

ਜਿੱਥੇ ਇਹ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ

ਲੀਨਕਸ ਸ਼ੈੱਲ, ਕਮਾਂਡ ਚੇਨ

ਗੁੰਝਲਦਾਰ ਤਰਕ, API, ਡੇਟਾ

ਵਿੰਡੋਜ਼ ਕਲਾਉਡ ਪ੍ਰਬੰਧਨ

ਸਿੱਖਣ ਦੀ ਵਕਰ

ਮੱਧਮ (ਫਸਿਆ)

ਆਸਾਨ

ਮੱਧਮ

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

ਸੈੱਟ -euo ਪਾਈਪਫੇਲ

ਕੋਸ਼ਿਸ਼ ਕਰੋ/ਸਿਵਾਏ

ਕੋਸ਼ਿਸ਼ ਕਰੋ/ਫੜੋ, -ਗਲਤੀ ਐਕਸ਼ਨ

ਪੋਰਟੇਬਿਲਟੀ

ਯੂਨਿਕਸ/ਲੀਨਕਸ/ਮੈਕ

ਹਰ ਥਾਂ

ਕ੍ਰਾਸ-ਪਲੇਟਫਾਰਮ (PS 7+)

ਜਦੋਂ

ਛੋਟਾ, ਸਿਸਟਮ ਕੰਮ ਕਰਦਾ ਹੈ

20 ਲਾਈਨਾਂ ਤੋਂ ਲੰਬਾ ਤਰਕ

ਵਿੰਡੋਜ਼/ਏਡੀ/ਅਜ਼ੁਰ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - 5 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਘੰਟੇ ਦਾ ਕਰਾਫਟ। ਇੱਕ ਇੰਜੀਨੀਅਰ ਹਰ ਹਫ਼ਤੇ 40 ਸਰਵਰਾਂ ਤੋਂ ਲੌਗ ਇਕੱਠੇ ਕਰਨ ਅਤੇ ਪੁਰਾਲੇਖ ਕਰਨ ਵਿੱਚ 2 ਘੰਟੇ ਬਿਤਾ ਰਿਹਾ ਸੀ। ਉਸ ਕੋਲ AI ਕੰਮ ਦਾ ਵਰਣਨ ਸੀ ਅਤੇ -euo pipefail + ਡ੍ਰਾਈ-ਰਨ ਪ੍ਰੋਟੈਕਸ਼ਨ ਅਤੇ ਇੱਕ Bash ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕਰਦਾ ਸੀ। ਪਹਿਲਾਂ ਸਕ੍ਰਿਪਟ ਨੂੰ ਡਰਾਈ-ਰਨ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ, ਫਿਰ ਇਸਨੂੰ ਅਨੁਸੂਚਿਤ ਕਾਰਜ (ਕ੍ਰੋਨ) ਨਾਲ ਜੋੜਿਆ। ਹਫਤਾਵਾਰੀ ਕੰਮ ਨੂੰ 5 ਮਿੰਟ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮਨੁੱਖੀ ਗਲਤੀ ਦੂਰ ਹੋ ਜਾਂਦੀ ਹੈ।

ਕੇਸ 2 - ਨਲ ਵੇਰੀਏਬਲ ਆਫ਼ਤ ਟਾਲਿਆ ਗਿਆ। AI ਦੁਆਰਾ ਨਿਰਮਿਤ ਸਫਾਈ ਸਕ੍ਰਿਪਟ ਵਿੱਚ rm -rf "$TARGET"/* ਸੀ, ਪਰ ਜੇਕਰ TARGET ਨੂੰ ਕਿਤੇ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ, ਤਾਂ ਇਹ ਖਾਲੀ ਰਿਹਾ। ਇਸ ਗੱਲ ਦਾ ਅਹਿਸਾਸ ਉਸ ਨੂੰ ਇੰਜੀਨੀਅਰ ਵਜੋਂ ਪੜ੍ਹਦਿਆਂ ਹੋਇਆ ਸੀ; ਸੈੱਟ -u ਅਤੇ [ -n "$TARGET" ] || ਐਗਜ਼ਿਟ 1 ਕੰਟਰੋਲ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ। ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਵੇਰੀਏਬਲ ਖਾਲੀ ਰਿਹਾ ਅਤੇ ਸਕਰਿਪਟ ਵਿਨਾਸ਼ਕਾਰੀ ਦੀ ਬਜਾਏ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਬੰਦ ਹੋ ਗਈ।

ਕੇਸ 3 — ਏਮਬੈਡਡ ਟੋਕਨ ਕੈਪਚਰ ਕੀਤਾ ਗਿਆ। ਸਹੂਲਤ ਲਈ, AI ਨੇ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ TOKEN = "ghp_realtoken" ਲਾਈਨ ਜੋੜੀ ਹੈ ਜੋ ਇੱਕ API (ਉਦਾਹਰਣ ਵਜੋਂ) ਲਈ ਬੇਨਤੀ ਕਰਦੀ ਹੈ। ਇੰਜੀਨੀਅਰ ਨੇ ਇਸਨੂੰ ਹਟਾ ਦਿੱਤਾ ਅਤੇ ਇਸਨੂੰ os.environ["TOKEN"] ਨਾਲ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਤੋਂ ਰੀਡਿੰਗ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਅਤੇ ਟੋਕਨ ਨੂੰ ਰੱਦ ਅਤੇ ਨਵਿਆਇਆ। ਜੇਕਰ ਸਕ੍ਰਿਪਟ Git 'ਤੇ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਟੋਕਨ ਜਨਤਕ ਹੋਵੇਗੀ।

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

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

ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਲਿਖੋ: [ਟਾਸਕ]। ਲਾਜ਼ਮੀ ਨਿਯਮ:- ਸ਼ੁਰੂ ਵਿੱਚ `ਸੈੱਟ -ਯੂਓ ਪਾਈਪ ਫੇਲ`।- ਜਾਂਚ ਕਰੋ ਕਿ ਵੇਰੀਏਬਲ ਖਾਲੀ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਵੀ ਮਿਟਾਉਣਾ/ਹਟਾਉਣਾ ਹੈ।- `--ਡਰਾਈ-ਰਨ` ਫਲੈਗ: ਲਿਖੋ ਕਿ ਇਸ ਮੋਡ ਵਿੱਚ ਕੀ ਕਰਨਾ ਹੈ ਪਰ ਇਹ ਨਾ ਕਰੋ।- ਗੁਪਤ ਨੂੰ ਏਮਬੈਡ ਨਾ ਕਰੋ; ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਤੋਂ ਪੜ੍ਹੋ। - ਹਰ ਪੜਾਅ 'ਤੇ ਜਾਣਕਾਰੀ ਵਾਲਾ ਲੌਗ ਪ੍ਰਿੰਟ ਕਰੋ। ਸਕ੍ਰਿਪਟ 'ਤੇ ਟਿੱਪਣੀ ਕਰੋ ਅਤੇ ਸਭ ਤੋਂ ਖਤਰਨਾਕ ਲਾਈਨ 'ਤੇ ਨਿਸ਼ਾਨ ਲਗਾਓ।

2) ਸਕ੍ਰਿਪਟ ਵਰਣਨ/ਨਿਯੰਤਰਣ:

ਹੇਠਾਂ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਵਰਣਨ ਕਰੋ ਅਤੇ ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰੋ: ਏਮਬੇਡਡ ਗੁਪਤ, ਵਿਨਾਸ਼ਕਾਰੀ ਕਮਾਂਡ (rm/Remove-Item/DROP), ਅਣ-ਪ੍ਰਮਾਣਿਤ ਇਨਪੁਟ, ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਦੀ ਕਮੀ? ਹਰੇਕ ਖਤਰੇ ਨੂੰ ਮਹੱਤਤਾ ਅਤੇ ਸੁਧਾਰ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਲਿਖੋ। ਸਕ੍ਰਿਪਟ: [CODE]

3) ਭਾਸ਼ਾ ਅਨੁਵਾਦ:

ਉਸ [ਸਰੋਤ ਭਾਸ਼ਾ] ਲਿਪੀ ਦਾ [ਟਾਰਗੇਟ ਭਾਸ਼ਾ] ਵਿੱਚ ਅਨੁਵਾਦ ਕਰੋ। ਵਿਵਹਾਰ ਨੂੰ ਜ਼ੁਬਾਨੀ ਰੱਖੋ, ਨਿਸ਼ਾਨਾ ਭਾਸ਼ਾ ਦੀ ਮੁਹਾਵਰੇ ਵਾਲੀ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਕਿਸੇ ਵੀ ਏਮਬੇਡ ਕੀਤੇ ਭੇਦ ਨੂੰ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਵਿੱਚ ਭੇਜੋ। ਨੋਟ ਪੁਆਇੰਟ ਜੋ ਵੱਖਰਾ ਵਿਵਹਾਰ ਕਰ ਸਕਦੇ ਹਨ। ਸਕ੍ਰਿਪਟ: [CODE]

4) ਯੋਜਨਾਬੱਧ ਕੰਮ (ਕ੍ਰੋਨ/ਨਿਰਧਾਰਤ ਕੰਮ):

ਇਸ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰੋ [ਫ੍ਰੀਕੁਐਂਸੀ: ਉਦਾ. ਇੱਕ ਸਮਾਂ-ਸਾਰਣੀ ਪਰਿਭਾਸ਼ਾ ([cron / systemd timer / Windows Task Scheduler]) ਲਿਖੋ ਜੋ [ਹਰ ਰਾਤ 02:00 ਵਜੇ] ਚੱਲੇਗੀ। ਸ਼ਾਮਲ ਕਰੋ ਕਿ ਮੈਨੂੰ ਅਸਫਲਤਾ (ਲੌਗ/ਐਗਜ਼ਿਟ ਕੋਡ/ਨੋਟੀਫਿਕੇਸ਼ਨ) ਬਾਰੇ ਚੇਤਾਵਨੀ ਕਿਵੇਂ ਦਿੱਤੀ ਜਾਵੇ ਅਤੇ ਓਵਰਲੈਪ ਨੂੰ ਕਿਵੇਂ ਰੋਕਿਆ ਜਾਵੇ।

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

ਕਮਜ਼ੋਰ: "ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੋ ਜੋ ਪੁਰਾਣੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਮਿਟਾਉਂਦੀ ਹੈ।"

ਨਤੀਜਾ: ਇੱਕ ਸਕੋਪ ਰਹਿਤ, ਅਸੁਰੱਖਿਅਤ, ਡਰਾਈ-ਰਨ ਰਹਿਤ rm ਸਕ੍ਰਿਪਟ; ਜੇਕਰ ਇਹ ਗਲਤ ਫੋਲਡਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਅਟੱਲ ਤੌਰ 'ਤੇ ਮਿਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ।

ਮਜ਼ਬੂਤ: ".

ਅੰਤਰ: ਦੂਜਾ ਦਾਅਵਾ ਪੂਰੀ ਸਕੋਪ, ਸੁਰੱਖਿਆ ਗਾਰਡਰੇਲ ਅਤੇ ਡਰਾਈ-ਰਨ ਉਮੀਦ ਦਿੰਦਾ ਹੈ; ਆਉਟਪੁੱਟ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• ਸਕ੍ਰਿਪਟ ਨੂੰ ਪੜ੍ਹੇ ਬਿਨਾਂ ਹੀ ਚਲਾਇਆ ਜਾ ਰਿਹਾ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ ਕਤਾਰਾਂ ਨੂੰ ਮਿਟਾਉਣਾ/ਮੂਵ ਕਰਨਾ ਤਬਾਹੀ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ।
• ਖਾਲੀ ਵੇਰੀਏਬਲ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ। rm -rf "$X"/ ਨਾਲ ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਮਿਟਾਉਣ ਦਾ ਕਲਾਸਿਕ ਆਫ਼ਤ।
• `set -euo pipefail` / `-ErrorAction Stop` ਨੂੰ ਛੱਡੋ। ਇੱਕ ਕਦਮ ਅੱਗ, ਲਿਪੀ ਅੰਨ੍ਹੇਵਾਹ ਜਾਰੀ ਹੈ.
• ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਰਾਜ਼ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ। Git ਨੂੰ ਲਗਾਤਾਰ ਲੀਕ.
• ਡ੍ਰਾਈ-ਰਨ ਤੋਂ ਬਿਨਾਂ ਵਿਨਾਸ਼ਕਾਰੀ ਪ੍ਰਕਿਰਿਆ. ਪਹਿਲਾਂ "ਮੈਨੂੰ ਦਿਖਾਓ ਕਿ ਕੀ ਕਰਨਾ ਹੈ", ਫਿਰ ਕਰੋ।
• ਉਤਪਾਦ ਵਿੱਚ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ। ਇੱਕ ਅਲੱਗ-ਥਲੱਗ ਟੈਸਟ ਵਾਤਾਵਰਨ ਤੋਂ ਬਿਨਾਂ ਚੱਲ ਰਿਹਾ ਹੈ।

ਸਾਰੰਸ਼ ਵਿੱਚ

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

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

ਇੱਕ ਆਵਰਤੀ ਕੰਮ ਚੁਣੋ (ਲੌਗ ਆਰਕਾਈਵਿੰਗ, ਬੈਕਅੱਪ, ਸਫਾਈ)। (1) AI ਨੂੰ "ਸੁਰੱਖਿਅਤ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ" ਟੈਂਪਲੇਟ ਨਾਲ ਇੱਕ ਸੁਰੱਖਿਅਤ ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕਰਨ ਲਈ ਕਹੋ। (2) ਸੁਰੱਖਿਆ ਲਈ "ਸਕ੍ਰਿਪਟ ਵਰਣਨ/ਆਡਿਟ" ਟੈਂਪਲੇਟ ਦੇ ਤੌਰ 'ਤੇ ਉਸੇ ਸਕ੍ਰਿਪਟ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸਭ ਤੋਂ ਖਤਰਨਾਕ ਲਾਈਨ ਲੱਭੋ ਜਿਸ ਨੂੰ AI ਨੇ ਫਲੈਗ ਕੀਤਾ ਹੈ। (3) ਇੱਕ ਟੈਸਟ ਫੋਲਡਰ ਵਿੱਚ ਨਮੂਨਾ ਫਾਈਲਾਂ ਨਾਲ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾ ਕੇ ਇਸਦੇ ਵਿਵਹਾਰ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, ਪਹਿਲਾਂ --dry-run ਨਾਲ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਉਹ ਕੰਮ ਲਿਖਿਆ ਜੋ ਮੈਂ ਨਹੀਂ ਚਾਹੁੰਦਾ, OS/ਸ਼ੈਲ ਅਤੇ ਸੁਰੱਖਿਆ ਗਾਰਡਰੇਲ।
• [ ] ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਸੈਟ -euo pipefail / -ErrorAction Stop ਵਾਂਗ ਸਟਾਪਿੰਗ ਵਿੱਚ ਤਰੁੱਟੀ ਹੈ।
• [] ਮੈਂ ਮਿਟਾਉਣ/ਮੂਵ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਖਾਲੀ ਵੇਰੀਏਬਲ ਅਤੇ ਇਨਪੁਟ ਜਾਂਚ ਸ਼ਾਮਲ ਕੀਤੀ।
• [ ] ਵਿਨਾਸ਼ਕਾਰੀ ਕਾਰਵਾਈਆਂ ਲਈ --dry-run/confirmation mechanism ਹੈ।
• [ ] ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੋਈ ਗੁਪਤ ਏਮਬੇਡ ਨਹੀਂ ਹੈ; ਮੁੱਲ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ/ਕੇਸ ਤੋਂ ਆਉਂਦੇ ਹਨ।
• [ ] ਮੈਂ ਡ੍ਰਾਈ-ਰਨ ਦੇ ਨਾਲ ਇੱਕ ਅਲੱਗ ਟੈਸਟ ਵਾਤਾਵਰਨ ਵਿੱਚ ਪਹਿਲਾ ਟੈਸਟ ਕੀਤਾ।