ਲਾਭ:
- ਇਹ ਫਰਕ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਕਿ DevOps ਚੇਨ (ਪਾਈਪਲਾਈਨ, ਕੌਂਫਿਗਰੇਸ਼ਨ, ਸਕ੍ਰਿਪਟ, ਲੌਗ) ਵਿੱਚ ਕਿੱਥੇ ਨਕਲੀ ਬੁੱਧੀ ਅਸਲ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰਦੀ ਹੈ ਅਤੇ ਕਿੱਥੇ ਉਤਪਾਦਨ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਨ ਵਾਲੇ ਫੈਸਲੇ ਕੰਮ ਦੇ ਜੋਖਮ ਪੱਧਰ ਦੇ ਅਧਾਰ ਤੇ ਮਨੁੱਖਾਂ ਉੱਤੇ ਛੱਡ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।
- ਇੱਕ ਅਨੁਸ਼ਾਸਨ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਜੋ ਹਰੇਕ AI ਆਉਟਪੁੱਟ ਨੂੰ ਸਰੋਤ ਨਾਲ ਜੋੜਨ, ਇਸਨੂੰ ਸੁੱਕਾ ਚਲਾਉਣ ਅਤੇ ਇਸਨੂੰ ਸਿਸਟਮ ਫਿਲਟਰ ਦੁਆਰਾ ਪਾਸ ਕਰਨ ਦੇ ਕਦਮਾਂ ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਕਰਦੀ ਹੈ।
- ਬੇਨਤੀਆਂ 'ਤੇ ਕਦੇ ਵੀ ਰਾਜ਼ ਨਾ ਚਿਪਕਾਉਣ, ਉਨ੍ਹਾਂ ਨੂੰ ਨਕਾਬ ਨਾ ਲਗਾਉਣ ਅਤੇ ਸਿਰਫ ਅਧਿਕਾਰਤ ਪ੍ਰਣਾਲੀਆਂ 'ਤੇ ਰੱਖਿਆਤਮਕ ਉਦੇਸ਼ਾਂ ਲਈ ਕੰਮ ਕਰਨ ਦੀ ਆਦਤ ਨੂੰ ਹਾਸਲ ਕਰਨ ਦੀ ਯੋਗਤਾ।
ਇੱਕ ਰਾਤ 03:14 'ਤੇ ਤੁਹਾਡੇ ਫ਼ੋਨ ਦੀ ਘੰਟੀ ਵੱਜਦੀ ਹੈ: ਭੁਗਤਾਨ ਸੇਵਾ ਬੰਦ ਹੈ, ਹਰ ਮਿੰਟ ਪੈਸੇ ਅਤੇ ਸਾਖ ਦਾ ਨੁਕਸਾਨ ਹੋ ਰਿਹਾ ਹੈ। ਇੱਕ ਹੋਰ ਦਿਨ, ਇੱਕ ਸਿੰਗਲ ਗਲਤ ਕਮਾਂਡ ਹਜ਼ਾਰਾਂ ਸਰਵਰਾਂ ਨੂੰ ਰੀਬੂਟ ਕਰਦੀ ਹੈ। ਇਹ DevOps ਪੇਸ਼ੇਵਰ ਦੀ ਦੁਨੀਆ ਹੈ — ਸਾਰੀਆਂ ਪਾਈਪਲਾਈਨਾਂ, ਆਟੋਮੇਸ਼ਨ, ਅਤੇ ਆਨ-ਕਾਲ ਲਈ ਜ਼ਿੰਮੇਵਾਰੀ ਜੋ ਕਿ ਸੌਫਟਵੇਅਰ ਕੋਡ ਰਿਪੋਜ਼ਟਰੀ (ਜਿੱਥੇ ਸੌਫਟਵੇਅਰ ਦਾ ਸਰੋਤ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ) ਤੋਂ ਲੰਘਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਗਾਹਕ ਦੇ ਹੱਥਾਂ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। DevOps ਸ਼ਬਦ "ਵਿਕਾਸ" ਅਤੇ "ਓਪਰੇਸ਼ਨਾਂ" ਦਾ ਸੁਮੇਲ ਹੈ: ਇਹ ਇੱਕ ਸਭਿਆਚਾਰ ਅਤੇ ਅਭਿਆਸਾਂ ਦਾ ਸਮੂਹ ਹੈ ਜੋ ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਲਿਆਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਤੇਜ਼, ਭਰੋਸੇਮੰਦ ਪ੍ਰਵਾਹ ਵਿੱਚ ਚਲਾਉਂਦਾ ਹੈ। ਇਸ ਪ੍ਰਵਾਹ ਦਾ ਹਰ ਪੜਾਅ ਇੱਕ ਕਮਾਂਡ, ਇੱਕ ਸੰਰਚਨਾ ਫਾਈਲ, ਇੱਕ ਸਕ੍ਰਿਪਟ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI - ਸੌਫਟਵੇਅਰ ਜੋ ਇਤਿਹਾਸਕ ਡੇਟਾ ਤੋਂ ਪੈਟਰਨ ਕੱਢਦਾ ਹੈ ਅਤੇ ਟੈਕਸਟ, ਕੋਡ ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਬਣਾਉਂਦਾ ਹੈ) ਟੈਕਸਟ ਦੀ ਇਸ ਬਹੁਤਾਤ ਵਿੱਚ ਤੁਹਾਡਾ ਬਹੁਤ ਸਮਾਂ ਬਚਾਉਂਦਾ ਹੈ।
ਪਰ ਇਸ ਮੋਡੀਊਲ ਦੀ ਸ਼ੁਰੂਆਤ ਸਪਸ਼ਟ ਹੈ: AI ਇੱਕ ਸਹਾਇਕ, ਡਰਾਫਟ ਜਨਰੇਟਰ ਅਤੇ ਫੈਸਲੇ ਦਾ ਸਮਰਥਨ ਸੰਦ ਹੈ; ਤੁਸੀਂ ਇਹ ਫੈਸਲਾ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋ ਕਿ ਲਾਈਵ ਵਾਤਾਵਰਨ (ਉਤਪਾਦਨ, ਅਸਲ ਗਾਹਕਾਂ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਸਿਸਟਮ), ਅੱਧੀ ਰਾਤ ਨੂੰ ਕਦੋਂ ਅਤੇ ਕਿਹੜਾ ਬਟਨ ਦਬਾਇਆ ਜਾਵੇ। DevOps ਵਿੱਚ, ਇੱਕ ਬੱਗ ਦੀ ਕੀਮਤ ਮਿੰਟਾਂ ਦੀ ਨਹੀਂ, ਪਰ ਡਾਊਨਟਾਈਮ, ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ, ਅਤੇ ਸੁਰੱਖਿਆ ਉਲੰਘਣਾ ਹੈ। ਇਸ ਲਈ ਇਸ ਪਹਿਲੀ ਇਕਾਈ ਵਿਚ ਅਸੀਂ ਅਨੁਸ਼ਾਸਨ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ, ਸੰਦ 'ਤੇ ਨਹੀਂ।
DevOps ਚੇਨ ਵਿੱਚ AI ਕਿੱਥੇ ਕੰਮ ਆਉਂਦਾ ਹੈ?
ਆਓ DevOps ਨੌਕਰੀਆਂ ਨੂੰ ਦੋ ਵੱਡੇ ਕਲੱਸਟਰਾਂ ਵਿੱਚ ਵੰਡੀਏ। ਪਹਿਲਾ ਕਲੱਸਟਰ: ਦੁਹਰਾਉਣ ਵਾਲੀਆਂ, ਟੈਕਸਟ ਅਤੇ ਸਟ੍ਰਕਚਰਿੰਗ ਨੌਕਰੀਆਂ। ਇੱਕ CI/CD (ਲਗਾਤਾਰ ਏਕੀਕਰਣ / ਨਿਰੰਤਰ ਸਪੁਰਦਗੀ — ਪਾਈਪਲਾਈਨ ਜੋ ਕੋਡ ਨੂੰ ਆਪਣੇ ਆਪ ਟੈਸਟ ਕਰਦੀ ਹੈ ਅਤੇ ਜਾਰੀ ਕਰਦੀ ਹੈ) ਵਰਣਨ, ਇੱਕ ਡੌਕਰਫਾਈਲ (ਵਿਅੰਜਨ ਫਾਈਲ ਜੋ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਕੰਟੇਨਰ ਵਿੱਚ ਪੈਕ ਕਰਦੀ ਹੈ) ਦਾ ਖਰੜਾ ਤਿਆਰ ਕਰਨਾ, ਇੱਕ ਗੁੰਝਲਦਾਰ ਟੈਰਾਫਾਰਮ (ਟੂਲ ਜੋ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਕੋਡ ਵਜੋਂ ਪਰਿਭਾਸ਼ਤ ਕਰਦਾ ਹੈ) ਦੀ ਵਿਆਖਿਆ ਕਰਨਾ, ਇੱਕ ਲੌਗ ਸਟੈਕਡ ਦੁਆਰਾ ਸਿਸਟਮ ਦਾ ਸਾਰ ਦੇਣਾ ਅਤੇ ਰਿਕਾਰਡਿੰਗ ਸਿਸਟਮ ਨੂੰ ਫਲੈਗ ਕਰਨਾ (ਸਟੈਕਡ)। ਇੱਕ bash ਸਕ੍ਰਿਪਟ ਦਾ ਖਰੜਾ ਤਿਆਰ ਕਰਨਾ। ਇਹਨਾਂ ਕੰਮਾਂ ਵਿੱਚ, AI ਮਿੰਟਾਂ ਤੋਂ ਸਕਿੰਟਾਂ ਤੱਕ ਘਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਥੱਕਦਾ ਨਹੀਂ ਹੈ।
ਦੂਜਾ ਸਮੂਹ: ਅਜਿਹੇ ਫੈਸਲੇ ਜਿਨ੍ਹਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਵਿਘਨ, ਪੈਸਾ ਜਾਂ ਸੁਰੱਖਿਆ ਹੁੰਦੀ ਹੈ। ਕੀ ਕੋਈ ਰੀਲੀਜ਼ ਪ੍ਰੋਡ 'ਤੇ ਜਾਵੇਗੀ, ਅੱਧੀ ਰਾਤ ਨੂੰ ਕਿਹੜੀ ਸੇਵਾ ਮੁੜ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਵੇਗੀ, ਗੁਪਤ ਕਿਵੇਂ ਸਟੋਰ ਕਰਨਾ ਹੈ, ਲਾਗਤ ਵਿੱਚ ਕਟੌਤੀ ਕਰਕੇ ਕਿਹੜਾ ਸਰੋਤ ਬੰਦ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਹਨਾਂ ਫੈਸਲਿਆਂ ਲਈ ਸੰਦਰਭ, ਸਿਸਟਮ ਗਿਆਨ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਥੇ, AI ਵਿਕਲਪਾਂ ਅਤੇ ਜੋਖਮਾਂ ਨੂੰ ਦ੍ਰਿਸ਼ਮਾਨ ਬਣਾਉਂਦਾ ਹੈ - ਪਰ ਤੁਸੀਂ "ਲਾਗੂ ਕਰੋ" ਬਟਨ ਨੂੰ ਦਬਾਉਂਦੇ ਹੋ।
ਆਓ ਇੱਕ ਵਾਕ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੀਏ: AI "ਇਹ ਸੰਰਚਨਾ ਕੀ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ" ਸਵਾਲਾਂ 'ਤੇ ਮਜ਼ਬੂਤ ਹੈ; ਫੈਸਲਾ ਤੁਹਾਡਾ ਹੈ ਜਦੋਂ ਇਹ ਸਵਾਲਾਂ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ ਜਿਵੇਂ ਕਿ "ਕੀ ਮੈਨੂੰ ਇਸਨੂੰ ਉਤਪਾਦ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕੌਣ ਇਸਦਾ ਸਮਰਥਨ ਕਰੇਗਾ?"
ਸੁਝਾਅ: ਕਿਸੇ AI ਨੂੰ ਨੌਕਰੀ ਆਊਟਸੋਰਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਪੁੱਛੋ: "ਜੇ ਇਹ ਆਉਟਪੁੱਟ ਗਲਤ ਹੈ ਤਾਂ ਮੈਂ ਕੀ ਗੁਆਵਾਂਗਾ?" ਜੇ ਜਵਾਬ "ਕੁਝ ਮਿੰਟ" ਹੈ, ਤਾਂ ਸੌਂਪਣ ਲਈ ਬੇਝਿਜਕ ਮਹਿਸੂਸ ਕਰੋ। ਜੇ ਜਵਾਬ "ਉਤਪਾਦਨ ਆਊਟੇਜ, ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਜਾਂ ਲੀਕ" ਹੈ, ਤਾਂ AI ਨੂੰ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨ ਦਿਓ ਅਤੇ ਤੁਸੀਂ ਫੈਸਲੇ ਅਤੇ ਲਾਗੂ ਕਰਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹੋ।
ਕਦਮ ਦਰ ਕਦਮ: ਏਆਈ-ਸੰਚਾਲਿਤ DevOps ਕਾਰੋਬਾਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?
- ਸੰਦਰਭ ਇਕੱਠਾ ਕਰੋ। ਕਿਹੜਾ ਕਲਾਊਡ (AWS, Azure, GCP), ਕਿਹੜਾ ਟੂਲ ਵਰਜ਼ਨ, ਕਿਹੜੀਆਂ ਰੁਕਾਵਟਾਂ? ਜੇਕਰ ਤੁਸੀਂ AI ਨੂੰ ਅਧੂਰਾ ਸੰਦਰਭ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਅਧੂਰਾ ਅਤੇ ਖਤਰਨਾਕ ਆਉਟਪੁੱਟ ਮਿਲੇਗਾ।
- ਸਪਸ਼ਟ ਕਾਰਜਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। "ਇੱਕ ਪਾਈਪਲਾਈਨ ਲਿਖੋ" ਨਹੀਂ; ਕਹੋ, "GitHub ਐਕਸ਼ਨਾਂ ਦੇ ਨਾਲ, ਮੁੱਖ ਸ਼ਾਖਾ ਵਿੱਚ ਇੱਕ ਵਰਕਫਲੋ ਲਿਖੋ ਜੋ ਪੁਸ਼ 'ਤੇ ਚੱਲਦਾ ਹੈ, ਟੈਸਟ ਚਲਾਉਂਦਾ ਹੈ, ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਸਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕਰਦਾ ਹੈ।"
- ਡਰਾਫਟ ਤਿਆਰ ਕਰੋ। AI ਨੂੰ ਪਹਿਲਾ ਸੰਸਕਰਣ ਲਿਖਣ ਦਿਓ।
- ਪੁਸ਼ਟੀ ਕਰੋ। ਸੰਟੈਕਸ ਦੀ ਜਾਂਚ ਕਰੋ, ਦੇਖੋ ਕਿ ਕੀ ਗੁਪਤ ਜਾਣਕਾਰੀ ਲੀਕ ਹੋ ਗਈ ਹੈ, ਡਰਾਈ-ਰਨ ਨਾਲ ਟੈਸਟ ਕਰੋ (ਇੱਕ ਮੋਡ ਜੋ ਅਸਲ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਕਰਨਾ ਹੈ)।
- ਇਸਨੂੰ ਸੈਂਡਬਾਕਸ ਵਿੱਚ ਅਜ਼ਮਾਓ। ਉਤਪਾਦ ਵਿੱਚ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕਦੇ ਨਾ ਕਰੋ; ਇੱਕ ਟੈਸਟਿੰਗ/ਸਟੇਜਿੰਗ ਵਾਤਾਵਰਣ ਵਿੱਚ ਚਲਾਓ।
- ਹੌਲੀ-ਹੌਲੀ ਲਾਗੂ ਕਰੋ ਅਤੇ ਨਿਗਰਾਨੀ ਕਰੋ। ਮੈਟ੍ਰਿਕਸ ਅਤੇ ਲੌਗਸ ਦੀ ਨਿਗਰਾਨੀ ਕਰਕੇ ਇਸਨੂੰ ਲਾਈਵ ਪ੍ਰਾਪਤ ਕਰੋ।
ਪੁਸ਼ਟੀਕਰਨ ਅਨੁਸ਼ਾਸਨ: ਤਿੰਨ ਕਦਮ
AI ਚੰਗੀ ਤਰ੍ਹਾਂ ਅਤੇ ਭਰੋਸੇ ਨਾਲ ਬੋਲਦਾ ਹੈ; ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਇਹ ਸੱਚ ਹੈ। AI ਕਦੇ-ਕਦਾਈਂ ਭੁਲੇਖੇ ਪੈਦਾ ਕਰਦਾ ਹੈ - ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਕਮਾਂਡ ਫਲੈਗ, ਇੱਕ ਕਲਾਉਡ ਸੇਵਾ ਨਾਮ, ਜਾਂ ਇੱਕ ਸੰਰਚਨਾ ਕੁੰਜੀ ਨੂੰ ਅਸਲੀ ਬਣਾਉਂਦਾ ਹੈ। DevOps ਵਿੱਚ, ਇੱਕ ਜਾਅਲੀ --force ਫਲੈਗ ਡੇਟਾ ਨੂੰ ਮਿਟਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇੱਕ ਜਾਅਲੀ IAM (ਪਛਾਣ ਅਤੇ ਪਹੁੰਚ ਪ੍ਰਬੰਧਨ) ਅਨੁਮਤੀ ਇੱਕ ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀ ਪੈਦਾ ਕਰਦੀ ਹੈ। ਪ੍ਰਤੀਬਿੰਬ:
- ਇਸਨੂੰ ਸਰੋਤ ਨਾਲ ਕਨੈਕਟ ਕਰੋ। ਕੀ ਏਆਈ ਦੁਆਰਾ ਦਿੱਤੀ ਗਈ ਹਰ ਕਮਾਂਡ ਅਤੇ ਫਲੈਗ ਅਸਲ ਵਿੱਚ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਹੈ? "ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਇਹ ਫਲੈਗ ਕਿਸ ਸੰਸਕਰਣ ਵਿੱਚ ਆਉਂਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਨਾਮ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਹੈ"; ਜੇਕਰ ਯਕੀਨ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ 'ਤੇ ਭਰੋਸਾ ਨਾ ਕਰੋ।
- ਸੁੱਕਾ ਚਲਾਓ. ਦੇਖੋ ਕਿ ਟੈਰਾਫਾਰਮ ਪਲਾਨ, kubectl --dry-run, --check ਵਰਗੇ ਮਾਡਸ ਨਾਲ ਇਸ ਨੂੰ ਲਾਗੂ ਕੀਤੇ ਬਿਨਾਂ ਕੀ ਹੁੰਦਾ ਹੈ।
- ਇਸਨੂੰ ਸਿਸਟਮ ਫਿਲਟਰ ਰਾਹੀਂ ਪਾਸ ਕਰੋ। ਕੀ ਆਉਟਪੁੱਟ ਤੁਹਾਡੇ ਆਰਕੀਟੈਕਚਰ, ਸੁਰੱਖਿਆ ਨੀਤੀ, ਅਤੇ ਉਪਲਬਧ ਸਰੋਤ ਨਾਮਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ? ਤੁਹਾਡਾ ਡੋਮੇਨ ਗਿਆਨ ਅੰਤਮ ਫਿਲਟਰ ਹੈ।
ਧਿਆਨ ਦਿਓ: "ਏਆਈ ਨੇ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖਿਆ" ਇੱਕ ਜਾਇਜ਼ ਨਹੀਂ ਹੈ. ਕਿਸੇ ਉਤਪਾਦ ਵਿੱਚ ਰੁਕਾਵਟ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਜ਼ਿੰਮੇਵਾਰੀ AI ਦੀ ਨਹੀਂ, ਸਗੋਂ ਉਸ ਵਿਅਕਤੀ ਦੀ ਹੈ ਜੋ ਇਸ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੇ ਬਿਨਾਂ ਉਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਇੱਕ ਗੈਰ-ਪ੍ਰਮਾਣਿਤ AI ਕਮਾਂਡ ਉਨਾ ਹੀ ਖਤਰਨਾਕ ਹੈ ਜਿੰਨਾ ਇੱਕ rm -rf ਨੂੰ ਪੜ੍ਹੇ ਬਿਨਾਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।
ਸੁਰੱਖਿਆ ਅਤੇ ਰਾਜ਼: ਕਦੇ ਵੀ ਲੀਕ ਨਾ ਕਰੋ
DevOps ਵਿੱਚ ਸਭ ਤੋਂ ਨਾਜ਼ੁਕ ਗੋਪਨੀਯਤਾ ਨਿਯਮ ਭੇਦ ਬਾਰੇ ਹੈ। ਗੁਪਤ; ਇਹ ਗੁਪਤ ਜਾਣਕਾਰੀ ਹੈ ਜਿਵੇਂ ਕਿ ਪਾਸਵਰਡ, API ਕੁੰਜੀ, ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਸਤਰ, ਪ੍ਰਾਈਵੇਟ ਸਰਟੀਫਿਕੇਟ, ਜੋ ਤੁਹਾਡੇ ਪੂਰੇ ਸਿਸਟਮ ਨੂੰ ਖੋਲ੍ਹ ਸਕਦੀ ਹੈ ਜੇਕਰ ਇਸ ਨਾਲ ਸਮਝੌਤਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ AI ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਕੋਈ ਵੀ ਅਸਲ ਰਾਜ਼ ਪੇਸਟ ਨਾ ਕਰੋ। ਜੇਕਰ ਕੋਡ ਦੇ ਇੱਕ ਬਲਾਕ ਵਿੱਚ ਇੱਕ ਅਸਲ AWS ਪਹੁੰਚ ਕੁੰਜੀ, ਇੱਕ .env ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ, ਜਾਂ ਇੱਕ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਪਾਸਵਰਡ ਹੈ, ਤਾਂ ਇਹਨਾਂ ਨੂੰ AI ਨੂੰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ AKIA ਦੀ ਬਜਾਏ <AWS_ACCESS_KEY> ਵਰਗੇ ਪਲੇਸਹੋਲਡਰਾਂ ਨਾਲ ਮਾਸਕ ਕਰੋ।
ਏਆਈ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਕੋਡ ਦੀ ਵੀ ਜਾਂਚ ਕਰੋ: ਏਆਈ ਕਈ ਵਾਰ ਉਦਾਹਰਨਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੋ ਸਹੂਲਤ ਲਈ ਕੋਡ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਹਾਰਡਕੋਡ ਕਰਦੇ ਹਨ। ਇਹ ਇੱਕ ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀ ਹੈ। ਵਾਸਤਵ ਵਿੱਚ, ਭੇਦ ਇੱਕ ਸੀਕ੍ਰੇਟ ਵਾਲਟ (ਵਾਲਟ, AWS ਸੀਕਰੇਟਸ ਮੈਨੇਜਰ, ਅਜ਼ੂਰ ਕੀ ਵਾਲਟ) ਵਿੱਚ ਰੱਖੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਰਨ ਟਾਈਮ ਵਿੱਚ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੇ ਰੂਪ ਵਿੱਚ ਇੰਜੈਕਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
ਇਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਹੋਰ ਨੈਤਿਕ ਅਤੇ ਕਾਨੂੰਨੀ ਸੀਮਾ: ਰੱਖਿਆਤਮਕ ਵਰਤੋਂ। ਆਪਣੇ ਸਿਸਟਮਾਂ ਨੂੰ ਸਖ਼ਤ ਕਰਨ, ਕਮਜ਼ੋਰੀਆਂ ਲਈ ਸਕੈਨ ਕਰਨ ਅਤੇ ਲਾਗਾਂ ਤੋਂ ਹਮਲਿਆਂ ਦੇ ਨਿਸ਼ਾਨ ਕੱਢਣ ਲਈ AI ਦੀ ਵਰਤੋਂ ਕਰੋ। ਕਿਸੇ ਹੋਰ ਦੇ ਸਿਸਟਮ ਤੱਕ ਅਣਅਧਿਕਾਰਤ ਪਹੁੰਚ, ਅਣਅਧਿਕਾਰਤ ਸਕੈਨਿੰਗ, ਜਾਂ ਅਟੈਕ ਟੂਲ ਬਣਾਉਣਾ ਗੈਰ-ਕਾਨੂੰਨੀ ਹੈ ਅਤੇ ਇਸ ਪਲੇਟਫਾਰਮ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਹੈ। ਹਮੇਸ਼ਾਂ ਉਹਨਾਂ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਕੰਮ ਕਰੋ ਜਿਸ ਲਈ ਤੁਹਾਡੇ ਕੋਲ ਅਧਿਕਾਰ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਇਕਰਾਰਨਾਮੇ ਦੁਆਰਾ ਲਿਖਤੀ ਇਜਾਜ਼ਤ ਪ੍ਰਾਪਤ ਕੀਤੀ ਹੈ।
ਕਿਹੜਾ ਡੇਟਾ ਕਿਸ ਵਾਹਨ ਵਿੱਚ ਜਾਂਦਾ ਹੈ?
ਡਾਟਾ ਕਿਸਮ
ਉਦਾਹਰਨ
ਅਨੁਕੂਲ ਵਾਹਨ
ਡਾਟਾ ਖੋਲ੍ਹੋ
ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼, ਓਪਨ ਸੋਰਸ ਕੋਡ
ਹਰ ਵਾਹਨ
ਅੰਦਰੂਨੀ ਡੇਟਾ (ਗੁਪਤ ਨਹੀਂ)
ਜਨਰਲ ਆਰਕੀਟੈਕਚਰ ਚਿੱਤਰ, ਆਮ ਪਾਈਪਲਾਈਨ
ਸੰਸਥਾ ਵੱਲੋਂ ਮਾਨਤਾ ਪ੍ਰਾਪਤ ਵਾਹਨ
ਗੁਪਤ/ਸੰਵੇਦਨਸ਼ੀਲ
ਗੁਪਤ, ਪ੍ਰੋਡ ਆਈਪੀ/ਟੌਪੋਲੋਜੀ, ਗਾਹਕ ਡੇਟਾ
ਸਿਰਫ਼ ਸੰਸਥਾ ਦੁਆਰਾ ਇਕਰਾਰਨਾਮੇ ਵਾਲੇ ਵਾਹਨ, ਜਿਸਦਾ ਡੇਟਾ ਸਿਖਲਾਈ ਲਈ ਨਹੀਂ ਜਾਂਦਾ; ਮਾਸਕ ਲਗਾ ਕੇ
ਤਿੰਨ ਛੋਟੇ ਕੇਸ
ਕੇਸ 1 - ਸਮਾਂ ਸਹੀ ਜਗ੍ਹਾ 'ਤੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਇੱਕ DevOps ਇੰਜੀਨੀਅਰ ਨੇ ਇੱਕ ਪੁਰਾਣੀ 300-ਲਾਈਨ ਜੇਨਕਿਨਸ ਪਾਈਪਲਾਈਨ ਨੂੰ GitHub ਐਕਸ਼ਨਾਂ ਵਿੱਚ ਲਿਜਾਣ ਵਿੱਚ 6 ਘੰਟੇ ਬਿਤਾਏ। ਉਸਨੇ ਏਆਈ ਦੁਆਰਾ ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਉਣ ਅਤੇ ਡਰਾਫਟ ਤਿਆਰ ਕਰਕੇ ਕੰਮ ਨੂੰ 90 ਮਿੰਟ ਤੱਕ ਘਟਾ ਦਿੱਤਾ। ਉਸਨੇ ਸਟੇਜਿੰਗ ਵਿੱਚ ਏਆਈ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਹਰੇਕ ਕਦਮ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਵਿੱਚ ਬਚਿਆ ਸਮਾਂ ਬਿਤਾਇਆ, ਇੱਕ ਇੱਕ ਕਰਕੇ। AI ਨੇ ਮਕੈਨੀਕਲ ਅਨੁਵਾਦ ਲਿਆ; ਮਾਨਤਾ ਮਨੁੱਖ ਕੋਲ ਹੀ ਰਹੀ।
ਕੇਸ 2 - ਤਸਦੀਕ ਨੇ ਤਬਾਹੀ ਨੂੰ ਟਾਲਿਆ। ਇੱਕ ਟੀਮ ਨੇ ਏਆਈ ਨੂੰ ਟੈਰਾਫਾਰਮ ਕਲੀਨਅੱਪ ਸਕ੍ਰਿਪਟ ਲਈ ਕਿਹਾ। AI ਨੇ ਫਲੂਐਂਟ ਕੋਡ ਦਿੱਤਾ; ਪਰ ਜਦੋਂ ਇੰਜੀਨੀਅਰ ਨੇ ਟੈਰਾਫਾਰਮ ਯੋਜਨਾ ਚਲਾਈ, ਤਾਂ ਉਸਨੇ ਖੋਜ ਕੀਤੀ ਕਿ ਸਕ੍ਰਿਪਟ ਨੇ ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਵੀ ਯੋਜਨਾ ਬਣਾਈ ਸੀ - AI ਨੇ ਸਰੋਤ ਫਿਲਟਰ ਨੂੰ ਗਲਤ ਟਾਈਪ ਕੀਤਾ ਸੀ। ਡ੍ਰਾਈ ਰਨਿੰਗ ਘੰਟਿਆਂ ਦੇ ਡੇਟਾ ਦੇ ਨੁਕਸਾਨ ਨੂੰ ਰੋਕਦੀ ਹੈ।
ਕੇਸ 3 - ਗੁਪਤ ਲੀਕ ਤੋਂ ਵਾਪਸੀ। ਜਦੋਂ ਇਹ ਪੁੱਛਦੇ ਹੋਏ ਕਿ "ਕਿਉਂ ਡਿਪਲਾਇ ਐਰਰ" ਇੱਕ ਇੰਟਰਨ ਨੇ ਅਸਲ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਪਾਸਵਰਡ ਦੇ ਨਾਲ ਇੱਕ ਪਬਲਿਕ ਟੂਲ ਵਿੱਚ ਪੂਰੀ .env ਫਾਈਲ ਪੇਸਟ ਕਰ ਦਿੱਤੀ। ਸੀਨੀਅਰ ਇੰਜੀਨੀਅਰ ਨੇ ਤੁਰੰਤ ਚਾਬੀਆਂ ਨੂੰ ਘੁੰਮਾਇਆ ਅਤੇ ਦੁਬਾਰਾ ਤਿਆਰ ਕੀਤਾ। ਸਹੀ ਤਰੀਕਾ ਸੀ ਪਾਸਵਰਡ ਨੂੰ <DB_PASSWORD> ਨਾਲ ਮਾਸਕ ਕਰਨਾ ਅਤੇ ਸਿਰਫ ਗਲਤੀ ਸੁਨੇਹਾ ਸਾਂਝਾ ਕਰਨਾ।
ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ
1) ਨੌਕਰੀ ਦੀ ਅਨੁਕੂਲਤਾ ਦਾ ਮੁਲਾਂਕਣ:
ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਸੀਨੀਅਰ DevOps/SRE ਸਲਾਹਕਾਰ। ਮੈਂ ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਭੂਮਿਕਾ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ। ਮੈਨੂੰ ਦੱਸੋ (1) ਕੀ ਇਹ ਇੱਕ ਡਰਾਫਟ/ਵਿਸ਼ਲੇਸ਼ਣ ਕਾਰਜ ਹੈ ਜੋ AI ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸੌਂਪਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਉਤਪਾਦ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਵਾਲਾ ਇੱਕ ਨਾਜ਼ੁਕ ਫੈਸਲਾ; (2) ਸਭ ਤੋਂ ਮਾੜਾ ਨਤੀਜਾ ਦੱਸੋ ਜੇ ਇਹ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ; (3) ਤਸਦੀਕ ਦੇ ਕਦਮ ਦੱਸੋ ਜੋ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ। ਕੰਮ: [ਇੱਥੇ]
2) ਸੁਰੱਖਿਅਤ ਸੰਦਰਭ ਦੇਣਾ (ਗੁਪਤ ਮਾਸਕਿੰਗ):
ਹੇਠਾਂ ਦਿੱਤੀ ਗਲਤੀ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ। ਮੈਂ <PLACEHOLDER> ਨਾਲ ਸਾਰੇ ਭੇਦ ਲੁਕਾਏ ਹਨ; ਤੁਸੀਂ ਇਹ ਵੀ ਸੁਝਾਅ ਦਿੰਦੇ ਹੋ ਕਿ ਹੱਲ ਵਿੱਚ ਕਦੇ ਵੀ ਅਸਲ ਰਾਜ਼ ਨਾ ਬਣਾਓ, ਇੱਕ ਪਲੇਸਹੋਲਡਰ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਕੋਡ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਏਮਬੇਡ ਕਰੋ, ਗੁਪਤ ਵਾਲਟ ਤੋਂ ਪੜ੍ਹੋ। ਗਲਤੀ/ਲੌਗ: [ਮਾਸਕ ਕੀਤੀ ਸਮੱਗਰੀ]
3) ਕਮਾਂਡ ਤਸਦੀਕ:
ਮੈਨੂੰ ਇਸ ਕਮਾਂਡ ਦੀ ਵਿਆਖਿਆ ਕਰੋ: ਲਿਖੋ ਕਿ ਹਰੇਕ ਫਲੈਗ ਕੀ ਕਰਦਾ ਹੈ, ਇਹ ਕਿਸ ਟੂਲ ਸੰਸਕਰਣ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸਦਾ ਸਭ ਤੋਂ ਖਤਰਨਾਕ ਮਾੜਾ ਪ੍ਰਭਾਵ। ਅੰਤ ਵਿੱਚ ਇਸਨੂੰ ਪ੍ਰੋਡ ਵਿੱਚ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਕਰਨ ਲਈ 3 ਜਾਂਚਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ। ਹੁਕਮ: [ਇੱਥੇ]
4) ਸਿੱਖਣ/ਸੰਕਲਪ ਪੁੱਛਗਿੱਛ:
ਮੈਂ [ਸੰਕਲਪ: ਉਦਾਹਰਨ ਲਈ [ਨੀਲੇ-ਹਰੇ ਤੈਨਾਤੀ] ਦੀ ਧਾਰਨਾ ਦੀ ਵਿਆਖਿਆ ਕਰੋ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਸ ਨੂੰ ਇੱਕ DevOps ਇੰਜੀਨੀਅਰ ਨੂੰ ਸਮਝਾ ਰਹੇ ਹੋ: ਇਹ ਕੀ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਹੈ, ਕਦੋਂ ਨਹੀਂ ਵਰਤਣਾ ਹੈ, 2 ਖਾਸ ਗਲਤੀਆਂ। ਸੰਖੇਪ ਅਤੇ ਠੋਸ ਬਣੋ।
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਕਮਜ਼ੋਰ: "ਮੈਨੂੰ ਇੱਕ ਡਿਪਲਾਇ ਸਕ੍ਰਿਪਟ ਲਿਖੋ।"
ਸਿੱਟਾ: ਇਹ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਕਿਹੜਾ ਬੱਦਲ, ਕਿਹੜਾ ਸਾਧਨ, ਕਿਹੜਾ ਵਾਤਾਵਰਣ; AI ਇੱਕ ਆਮ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਗੈਰ-ਪ੍ਰੋਡ ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜੋ ਕੋਡ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਏਮਬੈਡ ਕਰਦਾ ਹੈ।
ਮਜਬੂਤ: "ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਦਾ ਇੱਕ ਡਰਾਫਟ ਲਿਖੋ ਜੋ AWS ECS (ਇਲਾਸਟਿਕ ਕੰਟੇਨਰ ਸੇਵਾ) ਨੂੰ ਤੈਨਾਤ ਕਰਦੀ ਹੈ। ਖੇਤਰ eu-central-1 ਹੈ, ਚਿੱਤਰ ECR ਤੋਂ ਆਉਂਦਾ ਹੈ। ਕੋਡ ਵਿੱਚ ਕਦੇ ਵੀ ਭੇਦ ਏਮਬੇਡ ਨਾ ਕਰੋ, ਉਹਨਾਂ ਨੂੰ AWS ਸੀਕਰੇਟਸ ਮੈਨੇਜਰ ਤੋਂ ਪੜ੍ਹੋ। ਜੇਕਰ ਹਰ ਪੜਾਅ 'ਤੇ ਕੋਈ ਤਰੁੱਟੀ ਹੈ, ਤਾਂ ਰੋਕੋ (-Weuveri ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਾਰੇ ਪਾਇਪ 3 ਵਿੱਚ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਸੈੱਟ ਕਰੋ)। ਉਤਪਾਦ।"
ਅੰਤਰ: ਦੂਜਾ ਪ੍ਰੋਂਪਟ ਕਲਾਉਡ, ਟੂਲ, ਵਾਤਾਵਰਣ, ਸੁਰੱਖਿਆ ਨਿਯਮ, ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਉਮੀਦ ਦਿੰਦਾ ਹੈ — ਆਉਟਪੁੱਟ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਅਤੇ ਸੁਰੱਖਿਅਤ ਹੈ।
ਆਮ ਗਲਤੀਆਂ
- ਅਸਲ ਰਾਜ਼ ਨੂੰ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਪੇਸਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ। ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਖਤਰਨਾਕ ਗਲਤੀ. ਹਮੇਸ਼ਾ ਮਾਸਕ.
- ਪ੍ਰਸੰਗ ਰਹਿਤ ਪ੍ਰੋਂਪਟ। ਕਲਾਉਡ, ਸੰਸਕਰਣ, ਵਾਤਾਵਰਣ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕੀਤੇ ਬਿਨਾਂ, ਲੋੜੀਦਾ ਆਉਟਪੁੱਟ ਅਕਸਰ ਗਲਤ ਸੰਸਕਰਣ ਜਾਂ ਗਲਤ ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਸਬੰਧਤ ਹੁੰਦਾ ਹੈ।
- ਸੁੱਕੀ ਦੌੜ ਨੂੰ ਛੱਡਣਾ। ਬਿਨਾਂ ਯੋਜਨਾ ਦੇ ਲਾਗੂ ਕਰਨਾ/-ਡਰਾਈ-ਰਨ DevOps ਵਿੱਚ ਸਭ ਤੋਂ ਮਹਿੰਗਾ ਸ਼ਾਰਟਕੱਟ ਹੈ।
- ਉਤਪਾਦ ਵਿੱਚ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ। ਹਰ ਨਵੀਂ AI ਆਉਟਪੁੱਟ ਨੂੰ ਪਹਿਲਾਂ ਟੈਸਟਿੰਗ/ਸਟੇਜਿੰਗ ਵਿੱਚ ਚਲਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
- "AI ਨੇ ਕਿਹਾ" ਨਾਲ ਜ਼ਿੰਮੇਵਾਰੀ ਸੌਂਪਣਾ। ਜ਼ਿੰਮੇਵਾਰੀ ਹਮੇਸ਼ਾ ਲਾਗੂ ਕਰਨ ਵਾਲੇ ਇੰਜੀਨੀਅਰ ਦੀ ਰਹਿੰਦੀ ਹੈ।
- ਭਰੋਸੇ ਵਾਲੇ ਝੰਡੇ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ। ਬਿਨਾਂ ਪੁੱਛਗਿੱਛ ਦੇ ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਕਮਾਂਡ ਫਲੈਗ ਨੂੰ ਚਲਾਉਣਾ।
ਸੰਖੇਪ ਵਿੱਚ
DevOps ਅਤੇ ਕਲਾਉਡ AI; ਇਹ ਇੱਕ ਸਹਾਇਕ ਹੈ ਜੋ ਟੈਕਸਟ-ਇੰਟੈਂਸਿਵ ਕੰਮਾਂ ਜਿਵੇਂ ਕਿ ਪਾਈਪਲਾਈਨ, ਕੌਂਫਿਗਰੇਸ਼ਨ, ਸਕ੍ਰਿਪਟ ਅਤੇ ਲੌਗ ਵਿੱਚ ਵਧੀਆ ਗਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਪਰ ਉਤਪਾਦ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਨ ਵਾਲੇ ਫੈਸਲਿਆਂ, ਗੁਪਤ ਪ੍ਰਬੰਧਨ ਅਤੇ ਅੰਤਮ ਲਾਗੂ ਕਰਨ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਸਮਰੱਥ ਇੰਜੀਨੀਅਰ ਦੀ ਰਹਿੰਦੀ ਹੈ। ਤਿੰਨ-ਪੜਾਵੀ ਤਸਦੀਕ (ਸਰੋਤ ਨਾਲ ਜੁੜੋ, ਡ੍ਰਾਈ ਕਰੋ, ਸਿਸਟਮ ਫਿਲਟਰ ਤੋਂ ਲੰਘੋ), ਕਦੇ ਵੀ ਭੇਦ ਨਾ ਲੀਕ ਕਰੋ, ਅਤੇ ਸਿਰਫ ਅਧਿਕਾਰਤ ਪ੍ਰਣਾਲੀਆਂ 'ਤੇ ਰੱਖਿਆਤਮਕ ਉਦੇਸ਼ਾਂ ਲਈ ਕੰਮ ਕਰਨਾ ਇਸ ਮੋਡੀਊਲ ਦੇ ਮਾਰਗਦਰਸ਼ਕ ਸਿਧਾਂਤ ਹਨ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਆਪਣੇ ਖੁਦ ਦੇ ਕੰਮ (ਜਾਂ ਇੱਕ ਨਮੂਨਾ ਪ੍ਰੋਜੈਕਟ) ਵਿੱਚੋਂ ਇੱਕ ਤਾਜ਼ਾ DevOps ਕਾਰਜ ਚੁਣੋ। (1) ਉਪਰੋਕਤ "ਨੌਕਰੀ ਅਨੁਕੂਲਤਾ ਮੁਲਾਂਕਣ" ਟੈਂਪਲੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਨੂੰ ਇਸ ਕੰਮ ਦਾ ਵਰਣਨ ਕਰੋ ਅਤੇ ਇਸਦਾ ਵਰਗੀਕਰਨ ਪੜ੍ਹੋ। (2) ਜੇ ਇਸ ਵਿੱਚ ਗੁਪਤ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਮਾਸਕ ਕਰਕੇ ਇੱਕ ਪ੍ਰਸੰਗ ਟੈਕਸਟ ਤਿਆਰ ਕਰੋ। (3) ਤਿੰਨ-ਪੜਾਵੀ ਤਸਦੀਕ ਦੇ ਨਾਲ AI ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਇੱਕ ਵਾਕ ਵਿੱਚ ਨੋਟ ਕਰੋ ਕਿ ਤੁਸੀਂ ਹਰ ਪੜਾਅ 'ਤੇ ਕੀ ਠੀਕ ਕੀਤਾ ਹੈ।
ਚੈੱਕਲਿਸਟ
- [ ] ਮੈਂ ਆਪਣੇ ਕੰਮ ਨੂੰ "ਸਪੁਰਦ ਕਰਨ ਯੋਗ ਕੰਮ" ਜਾਂ "ਨਾਜ਼ੁਕ ਫੈਸਲਾ" ਵਜੋਂ ਸ਼੍ਰੇਣੀਬੱਧ ਕੀਤਾ ਹੈ।
- [ ] ਮੈਂ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਕੋਈ ਅਸਲ ਰਾਜ਼ ਪੇਸਟ ਨਹੀਂ ਕੀਤਾ; ਮੈਂ ਉਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਇੱਕ ਪਲੇਸਹੋਲਡਰ ਨਾਲ ਮਾਸਕ ਕੀਤਾ.
- [ ] ਮੈਂ ਕਲਾਉਡ, ਟੂਲ ਸੰਸਕਰਣ, ਅਤੇ ਵਾਤਾਵਰਣ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਸੰਦਰਭ ਜੋੜਿਆ ਹੈ।
- [ ] ਮੈਂ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ AI ਆਉਟਪੁੱਟ ਨੂੰ ਡਰਾਈ ਰਨ/ਪਲਾਨ ਨਾਲ ਚੈੱਕ ਕੀਤਾ।
- [ ] ਮੈਂ ਟੈਸਟ/ਸਟੇਜਿੰਗ ਵਾਤਾਵਰਨ ਵਿੱਚ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਉਤਪਾਦ ਵਿੱਚ ਨਹੀਂ।
- [ ] ਮੈਂ ਸਿਰਫ ਉਹਨਾਂ ਪ੍ਰਣਾਲੀਆਂ 'ਤੇ ਕੰਮ ਕੀਤਾ ਜਿਸ ਵਿੱਚ ਮੇਰੇ ਕੋਲ ਅਧਿਕਾਰ ਸੀ, ਰੱਖਿਆ ਉਦੇਸ਼ਾਂ ਲਈ।