ਕੋਡ ਦੇ ਤੌਰ 'ਤੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦਾ ਪ੍ਰਬੰਧਨ: ਟੈਰਾਫਾਰਮ ਅਤੇ ਆਈਏਸੀ ਨਾਲ ਨਕਲੀ ਬੁੱਧੀ

ਲਾਭ:

• IaC ਸੰਕਲਪ ਅਤੇ Terraform ਦੇ ਕਾਰਜ ਚੱਕਰ (init, plan, apply, state, module) ਨੂੰ ਸਮਝਣ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਸੁਰੱਖਿਅਤ HCL ਡਰਾਫਟ ਤਿਆਰ ਕਰਦੀ ਹੈ।
• ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਯੋਜਨਾ ਨਾਲ ਹਰੇਕ ਤਬਦੀਲੀ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਅਚਾਨਕ ਤਬਾਹ/ਬਦਲਣ ਵਾਲੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਫੜਨ ਦੀ ਸਮਰੱਥਾ
• ਕੋਡ ਤੋਂ ਭੇਦ ਰੱਖਣ, ਰਾਜ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਅਤੇ IAM ਅਨੁਮਤੀਆਂ ਨੂੰ ਘੱਟ ਕਰਨ ਦੇ ਸਿਧਾਂਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

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

ਸਭ ਤੋਂ ਆਮ IaC ਟੂਲ ਟੈਰਾਫਾਰਮ ਹੈ। Terraform ਉਹਨਾਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਲੈਂਦਾ ਹੈ ਜੋ ਤੁਸੀਂ HCL (HashiCorp ਸੰਰਚਨਾ ਭਾਸ਼ਾ — Terraform ਦੀ ਸੰਰਚਨਾ ਭਾਸ਼ਾ) ਨਾਮਕ ਇੱਕ ਪੜ੍ਹਨਯੋਗ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖਦੇ ਹੋ, ਉਹਨਾਂ ਨੂੰ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ (AWS, Azure, GCP) API ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ਅਤੇ ਸਰੋਤ ਬਣਾਉਂਦਾ ਹੈ। AI HCL ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣਦਾ ਹੈ ਅਤੇ ਜਲਦੀ ਹੀ ਗੁੰਝਲਦਾਰ ਬਲਾਕ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਪਰ IaC ਵਿੱਚ, ਇੱਕ ਗਲਤੀ ਦੀ ਕੀਮਤ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ: ਇੱਕ ਗਲਤ ਪਰਿਭਾਸ਼ਾ ਪੂਰੇ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ। ਇਸ ਲਈ ਟੈਰਾਫਾਰਮ ਵਿੱਚ ਸੁਨਹਿਰੀ ਨਿਯਮ ਇਹ ਹੈ ਕਿ ਹਰ ਤਬਦੀਲੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ 'ਯੋਜਨਾ' ਨਾਲ ਦੇਖਿਆ ਜਾਵੇ।

ਟੈਰਾਫਾਰਮ ਦਾ ਰਨਟਾਈਮ

ਟੈਰਾਫਾਰਮ ਤਿੰਨ ਬੁਨਿਆਦੀ ਕਮਾਂਡਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ - ਇਹ ਜਾਣਨਾ ਕਿ ਏਆਈ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇਹ ਇੱਕ ਪੂਰਵ ਸ਼ਰਤ ਹੈ:

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

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

ਟਿਪ: ਟੈਰਾਫਾਰਮ ਆਉਟਪੁੱਟ ਵਿੱਚ ਸਭ ਤੋਂ ਖਤਰਨਾਕ ਸੰਕੇਤ ਪਲਾਨ ਆਉਟਪੁੱਟ ਵਿੱਚ ਲਾਈਨਾਂ ਨੂੰ ਨਸ਼ਟ ਜਾਂ -/+ (ਬਦਲਣਾ) ਹੈ। ਇਹਨਾਂ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਰੋਤ ਮਿਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਯੋਜਨਾ ਵਿੱਚ ਅਚਾਨਕ ਤਬਾਹੀ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਕਦੇ ਵੀ ਲਾਗੂ ਨਹੀਂ ਕਰੋ, ਪਹਿਲਾਂ ਸਮਝੋ ਕਿ ਇਹ ਕਿਉਂ ਦਿਖਾਈ ਦਿੱਤਾ।

ਕਦਮ ਦਰ ਕਦਮ: AI ਨਾਲ IaC ਲਿਖਣਾ

1. ਲੋੜੀਂਦੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ। "ਇੱਕ VPC, ਦੋ ਸਬਨੈੱਟ, ਇੱਕ ਸੁਰੱਖਿਆ ਸਮੂਹ ਅਤੇ eu-central-1 ਉੱਤੇ ਇੱਕ t3.micro EC2" ਵਰਗੇ ਠੋਸ ਬਣੋ।
2. ਪ੍ਰਦਾਤਾ ਅਤੇ ਸੰਸਕਰਣ ਨਿਰਧਾਰਤ ਕਰੋ। ਕਿਹੜਾ ਬੱਦਲ, ਕਿਹੜਾ ਟੈਰਾਫਾਰਮ ਅਤੇ ਪ੍ਰਦਾਤਾ ਸੰਸਕਰਣ? ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸੰਸਕਰਣ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ AI ਪੁਰਾਣਾ/ਅਸੰਗਤ ਸੰਟੈਕਸ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ।
3. HCL ਡਰਾਫਟ ਤਿਆਰ ਕਰਵਾਓ। ਵੇਰੀਏਬਲ ਅਤੇ ਆਉਟਪੁੱਟ ਲਈ ਵੀ ਬੇਨਤੀ ਕਰੋ।
4. ਰਾਜ਼ ਬਾਹਰ ਕੱਢੋ. ਪਾਸਵਰਡ ਅਤੇ ਕੁੰਜੀਆਂ ਵਰਗੇ ਮੁੱਲ ਵੇਰੀਏਬਲ ਅਤੇ ਗੁਪਤ ਵਾਲਟ ਵਿੱਚ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ, ਕੋਡ ਵਿੱਚ ਨਹੀਂ।
5. `init` + `ਯੋਜਨਾ` ਚਲਾਓ। ਲਾਈਨ ਦੁਆਰਾ ਯੋਜਨਾ ਆਉਟਪੁੱਟ ਲਾਈਨ ਪੜ੍ਹੋ; ਅਚਾਨਕ ਮਿਟਾਏ ਜਾਣ ਦੀ ਜਾਂਚ ਕਰੋ।
6. ਛੋਟੀ ਸ਼ੁਰੂਆਤ ਕਰੋ, ਹੌਲੀ-ਹੌਲੀ ਲਾਗੂ ਕਰੋ। ਇਸਨੂੰ ਪਹਿਲਾਂ ਇੱਕ ਅਲੱਗ ਟੈਸਟ ਖਾਤੇ/ਵਾਤਾਵਰਣ ਵਿੱਚ ਲਾਗੂ ਕਰੋ।

ਸੁਰੱਖਿਆ: IaC-ਵਿਸ਼ੇਸ਼ ਜੋਖਮ

IaC ਓਨਾ ਹੀ ਖਤਰਨਾਕ ਹੈ ਜਿੰਨਾ ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ। ਤਿੰਨ ਮਹੱਤਵਪੂਰਨ ਨੁਕਤੇ:

1. ਸਟੇਟ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਰਾਜ਼ ਹੈ। ਟੈਰਾਫਾਰਮ ਸਟੇਟ ਕਈ ਵਾਰ ਸੰਵੇਦਨਸ਼ੀਲ ਮੁੱਲਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਪਾਸਵਰਡ, ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ। ਰਾਜ ਨੂੰ ਕਦੇ ਵੀ ਜਨਤਕ ਭੰਡਾਰ ਵਿੱਚ ਨਾ ਰੱਖੋ; ਇੱਕ ਐਨਕ੍ਰਿਪਟਡ, ਪ੍ਰਤਿਬੰਧਿਤ-ਪਹੁੰਚ ਰਿਮੋਟ ਬੈਕਐਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ।
2. ਐਚਸੀਐਲ ਵਿੱਚ ਰਾਜ਼ ਨੂੰ ਏਮਬੇਡ ਨਾ ਕਰੋ। Password="prod123" ਵਰਗੀਆਂ ਲਾਈਨਾਂ ਪੱਕੇ ਤੌਰ 'ਤੇ ਗਿੱਟ ਇਤਿਹਾਸ ਵਿੱਚ ਲਿਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਸਦੀ ਬਜਾਏ, ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ (TF_VAR_...) ਜਾਂ ਗੁਪਤ ਵਾਲਟ ਤੋਂ ਰਨਟਾਈਮ 'ਤੇ ਮੁੱਲ ਦਿਓ।
3. ਬਹੁਤ ਵਿਆਪਕ IAM ਅਨੁਮਤੀ। AI ਕਈ ਵਾਰ ਐਕਸ਼ਨ ਵਰਗੇ ਬਲਾਕ ਪੈਦਾ ਕਰਦਾ ਹੈ: "*" (ਸਭ ਕੁਝ ਕਰਨ ਦਿਓ) "ਇਸ ਨੂੰ ਕੰਮ ਕਰਨ" ਲਈ। ਇਹ ਇੱਕ ਕਮਜ਼ੋਰੀ ਹੈ; ਘੱਟੋ-ਘੱਟ ਲੋੜੀਂਦੀ ਅਨੁਮਤੀ ਨੂੰ ਸੰਕੁਚਿਤ ਕਰੋ।

ਧਿਆਨ ਦਿਓ: ਇੱਕ ਵਾਰ ਜਦੋਂ ਕੋਈ ਗੁਪਤ Git ਇਤਿਹਾਸ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਅਤੀਤ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਸਮਝੌਤਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਤੁਸੀਂ ਫਾਈਲ ਨੂੰ ਮਿਟਾ ਦਿੰਦੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਗਲਤੀ ਨਾਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਰੰਤ ਰੱਦ ਕਰੋ ਅਤੇ ਗੁਪਤ ਨੂੰ ਘੁੰਮਾਓ; ਸਿਰਫ਼ ਮਿਟਾਉਣਾ ਹੀ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ।

ਜੋਖਮ ਭਰੀ ਯੋਜਨਾ ਦੇ ਸੰਕੇਤ ਸਾਰਣੀ

ਯੋਜਨਾ ਪ੍ਰਿੰਟਆਊਟ

ਭਾਵ

ਕੀ ਕਰਨਾ ਹੈ

+ ਬਣਾਓ

ਨਵਾਂ ਸਰੋਤ ਜੋੜਿਆ ਜਾਵੇਗਾ

ਆਮ ਤੌਰ 'ਤੇ ਸੁਰੱਖਿਅਤ, ਹਾਲਾਂਕਿ ਸਮੀਖਿਆ ਕਰੋ

~ ਥਾਂ-ਥਾਂ ਅੱਪਡੇਟ ਕਰੋ

ਸਰੋਤ ਸਾਈਟ 'ਤੇ ਬਦਲ ਜਾਵੇਗਾ

ਪ੍ਰਭਾਵ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ (ਕੀ ਕੋਈ ਆਊਟੇਜ ਹੋਵੇਗਾ?)

-/+ ਬਦਲੋ

ਮਿਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਇਆ ਜਾਵੇਗਾ

ਸਾਵਧਾਨ: ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ

- ਨਸ਼ਟ ਕਰੋ

ਸਰੋਤ ਤਬਾਹ ਹੋ ਜਾਵੇਗਾ

STOP: ਜੇਕਰ ਤੁਸੀਂ ਇਸਦੀ ਉਮੀਦ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਕਦੇ ਵੀ ਅਰਜ਼ੀ ਨਾ ਦਿਓ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - 3 ਘੰਟਿਆਂ ਵਿੱਚ 2 ਦਿਨ ਦਾ ਕੰਮ। ਇੱਕ ਟੀਮ ਇੱਕ ਨਵਾਂ ਟੈਸਟ ਵਾਤਾਵਰਨ (VPC, ਸਬਨੈੱਟ, RDS ਡੇਟਾਬੇਸ, ECS ਕਲੱਸਟਰ) ਸਥਾਪਤ ਕਰਨ ਲਈ ਟੈਰਾਫਾਰਮ ਲਿਖਣ ਜਾ ਰਹੀ ਸੀ ਪਰ ਉਹ ਹੁਣੇ ਹੀ HCL ਵਿੱਚ ਚਲੇ ਗਏ ਸਨ। ਉਹਨਾਂ ਨੇ AI ਨੂੰ ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਸੰਸਕਰਣਾਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਅਤੇ ਇੱਕ ਮਾਡਯੂਲਰ ਬਲੂਪ੍ਰਿੰਟ ਤਿਆਰ ਕੀਤਾ। ਉਹਨਾਂ ਨੇ ਯੋਜਨਾ ਦੇ ਨਾਲ ਹਰੇਕ ਮੋਡੀਊਲ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਅਤੇ ਇਸਨੂੰ 3 ਘੰਟਿਆਂ ਵਿੱਚ ਤਿਆਰ ਕੀਤਾ ਅਤੇ ਚਲਾਇਆ; ਇਹ ਉਹਨਾਂ ਨੂੰ ਮੈਨੂਅਲ ਅਜ਼ਮਾਇਸ਼ ਅਤੇ ਗਲਤੀ ਦੇ ਦੋ ਦਿਨ ਲਵੇਗਾ.

ਕੇਸ 2 - ਯੋਜਨਾ ਨੂੰ ਮਿਟਾਇਆ ਗਿਆ। ਇੱਕ ਇੰਜੀਨੀਅਰ ਨੇ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਅਪਡੇਟ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਯੋਜਨਾ ਚਲਾਈ। ਆਉਟਪੁੱਟ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ -/+ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਲਈ ਰੀਪਲੇਸ - AI ਨੇ ਇੱਕ ਗੈਰ-ਬਦਲਣਯੋਗ ਖੇਤਰ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਡੇਟਾਬੇਸ ਨੂੰ ਮਿਟਾਉਣਾ ਅਤੇ ਮੁੜ ਬਣਾਉਣਾ। ਇੰਜੀਨੀਅਰ ਨੇ ਅਪਲਾਈ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੱਤਾ ਅਤੇ ਬਦਲਾਅ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਬਦਲ ਦਿੱਤਾ। ਯੋਜਨਾਬੰਦੀ ਦੀ ਆਦਤ ਨੇ ਕਿਸੇ ਤਬਾਹੀ ਨੂੰ ਰੋਕਿਆ।

ਕੇਸ 3 - ਗੁਪਤ ਲੀਕ ਨੂੰ ਦਫ਼ਨਾਇਆ ਗਿਆ। ਇੱਕ ਜੂਨੀਅਰ, YZ ਜਾਰੀ ਕੀਤਾ db_password = "S3cret!" ਉਸਨੇ ਲਾਈਨ ਨੂੰ ਜਿਵੇਂ ਹੈ, ਵਚਨਬੱਧ ਕੀਤਾ ਅਤੇ ਇਸਨੂੰ ਧੱਕ ਦਿੱਤਾ। ਕੋਡ ਸਮੀਖਿਆ ਵਿੱਚ ਫਸਿਆ; ਪਾਸਵਰਡ ਨੂੰ ਤੁਰੰਤ ਰੱਦ ਕਰ ਦਿੱਤਾ ਗਿਆ ਅਤੇ ਬਦਲਿਆ ਗਿਆ, ਮੁੱਲ ਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਭੇਜਿਆ ਗਿਆ ਅਤੇ ਗੁਪਤ ਵਾਲਟ ਤੋਂ ਖੁਆਇਆ ਗਿਆ। ਸਬਕ: ਐਚਸੀਐਲ ਵਿੱਚ ਕਦੇ ਵੀ ਸਾਦੇ ਭੇਦ ਨਹੀਂ ਹੁੰਦੇ।

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

1) ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨਾ:

ਟੈਰਾਫਾਰਮ (ਵਰਜਨ ~> 1.7) ਦੇ ਨਾਲ [Cloud: AWS] 'ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਲਿਖੋ: [ਸਰੋਤ ਸੂਚੀ]। ਖੇਤਰ [X]. ਨਿਯਮ:- ਸਾਰੇ ਸੰਵੇਦਨਸ਼ੀਲ ਮੁੱਲਾਂ ਨੂੰ ਵੇਰੀਏਬਲ ਬਣਾਓ, ਉਹਨਾਂ ਨੂੰ HCL ਵਿੱਚ ਏਮਬੇਡ ਨਾ ਕਰੋ।- ਪ੍ਰਦਾਤਾ ਸੰਸਕਰਣ (ਲੋੜੀਂਦਾ_ਪ੍ਰੋਵਾਈਡਰ) ਫਿਕਸ ਕਰੋ।- IAM ਅਨੁਮਤੀਆਂ ਨੂੰ ਘੱਟ ਕਰੋ, "*" ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ।- ਆਉਟਪੁੱਟ ਵਜੋਂ [X, Y] ਵਾਪਸ ਕਰੋ। ਕੋਡ ਮਾਡਿਊਲਰ ਅਤੇ ਸਪੱਸ਼ਟੀਕਰਨ ਦੇ ਨਾਲ ਦਿਓ।

2) ਯੋਜਨਾ ਆਉਟਪੁੱਟ ਦੀ ਵਿਆਖਿਆ:

ਹੇਠਾਂ 'ਟੇਰਾਫਾਰਮ ਪਲਾਨ' ਆਉਟਪੁੱਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ। ਮੈਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ: (1) ਕਿਹੜੇ ਸਰੋਤ ਜੋੜੇ/ਬਦਲਿਆ/ਹਟਾਏ ਗਏ, (2) ਡੇਟਾ ਦੇ ਨੁਕਸਾਨ ਜਾਂ ਰੁਕਾਵਟ ਦੇ ਜੋਖਮ 'ਤੇ ਕਤਾਰਾਂ, (3) 3 ਸਵਾਲ ਮੈਨੂੰ ਅਰਜ਼ੀ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਪੁੱਛਣੇ ਚਾਹੀਦੇ ਹਨ। ਯੋਜਨਾ: [ਆਊਟਪੁੱਟ]

3) ਸੁਰੱਖਿਆ ਲਈ ਮੌਜੂਦਾ HCL ਦੀ ਜਾਂਚ ਕਰੋ:

ਸੁਰੱਖਿਆ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਟੈਰਾਫਾਰਮ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ: ਏਮਬੇਡਡ ਗੁਪਤ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਆਪਕ IAM ਅਨੁਮਤੀ, ਓਪਨ ਨੈੱਟਵਰਕ ਨਿਯਮ (0.0.0.0/0), ਅਣਏਨਕ੍ਰਿਪਟਡ ਸਟੋਰੇਜ? ਹਰੇਕ ਖੋਜ ਨੂੰ ਮਹੱਤਵ ਅਤੇ ਸੁਧਾਰ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਲਿਖੋ। ਕੋਡ: [HCL]

4) ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੋਡ ਨੂੰ ਮੋਡੀਊਲ ਵਿੱਚ ਬਦਲੋ:

ਹੇਠਾਂ ਦਿੱਤੇ ਦੁਹਰਾਉਣ ਵਾਲੇ ਟੈਰਾਫਾਰਮ ਕੋਡ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਮੋਡੀਊਲ ਵਿੱਚ ਬਦਲੋ: ਕਿਹੜੇ ਮੁੱਲ ਵੇਰੀਏਬਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਮੋਡੀਊਲ ਇੰਟਰਫੇਸ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ? ਉਦਾਹਰਨ ਵਰਤੋਂ ਵੀ ਦਿਖਾਓ। ਕੋਡ: [HCL]

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

ਕਮਜ਼ੋਰ: "Terraform ਨਾਲ ਇੱਕ ਡਾਟਾਬੇਸ ਬਣਾਓ।"

ਨਤੀਜਾ: ਅਸਪਸ਼ਟ ਹੈ ਕਿ ਕਿਹੜਾ ਬੱਦਲ, ਕਿਹੜਾ ਇੰਜਣ, ਕਿਹੜਾ ਸੰਸਕਰਣ, ਐਨਕ੍ਰਿਪਟਡ ਜਾਂ ਨਹੀਂ; ਪੁਰਾਤਨ ਸੰਟੈਕਸ ਦੇ ਨਾਲ, AI ਇੱਕ ਜਨਤਕ ਤੌਰ 'ਤੇ ਉਪਲਬਧ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਕੋਡ ਵਿੱਚ ਪਾਸਵਰਡ ਨੂੰ ਏਮਬੈਡ ਕਰਦਾ ਹੈ।

ਮਜ਼ਬੂਤ: "Terraform ~> 1.7 ਦੇ ਨਾਲ AWS 'ਤੇ ਇੱਕ RDS PostgreSQL 15 ਉਦਾਹਰਨ ਬਣਾਓ। ਪਾਸਵਰਡ ਵੇਰੀਏਬਲ ਬਣਾਓ, ਇਸਨੂੰ ਕੋਡ ਵਿੱਚ ਏਮਬੈਡ ਨਾ ਕਰੋ। ਸਟੋਰੇਜ਼ ਏਨਕ੍ਰਿਪਟਡ ਹੈ, ਸਿਰਫ਼ ਨਿੱਜੀ ਸਬਨੈੱਟ ਤੋਂ ਪਹੁੰਚਯੋਗ ਹੈ, ਜਨਤਕ ਨਹੀਂ। ਪ੍ਰਦਾਤਾ ਸੰਸਕਰਣ ਫਿਕਸ ਕਰੋ। ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ 'ਤੇ ਅੰਤਮ ਬਿੰਦੂ ਵਾਪਸ ਕਰੋ।"

ਅੰਤਰ: ਦੂਜਾ ਪ੍ਰੋਂਪਟ ਇੰਜਣ, ਸੰਸਕਰਣ, ਏਨਕ੍ਰਿਪਸ਼ਨ, ਨੈੱਟਵਰਕ ਰੁਕਾਵਟ ਅਤੇ ਗੁਪਤ ਨਿਯਮ ਦਿੰਦਾ ਹੈ — ਆਉਟਪੁੱਟ ਸੁਰੱਖਿਅਤ ਅਤੇ ਪ੍ਰੋਡ ਦੇ ਨੇੜੇ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• ਇੱਕ 'ਯੋਜਨਾ' ਬਣਾਏ ਬਿਨਾਂ 'ਲਾਗੂ' ਕਰਨ ਲਈ। IaC ਵਿੱਚ ਸਭ ਤੋਂ ਮਹਿੰਗੀ ਗਲਤੀ; ਹਮੇਸ਼ਾ ਪਹਿਲਾਂ ਯੋਜਨਾ ਬਣਾਓ।
• HCL ਵਿੱਚ ਏਮਬੈਡਿੰਗ ਸੀਕਰੇਟ। Git ਇਤਿਹਾਸ ਵਿੱਚ ਸਥਾਈ ਲੀਕੇਜ ਬਣਾਉਂਦਾ ਹੈ।
• ਸਟੇਟ ਅਸੁਰੱਖਿਅਤ ਸਟੋਰ ਕਰਨਾ। ਇੱਕ ਅਨਕ੍ਰਿਪਟਡ, ਅਨਲੌਕਡ, ਜਨਤਕ ਰਾਜ ਇੱਕ ਤਬਾਹੀ ਹੈ।
• ਸੰਸਕਰਣ ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰ ਰਿਹਾ। ਇੱਕ ਸੰਸਕਰਣ ਨਿਰਧਾਰਤ ਕੀਤੇ ਬਿਨਾਂ ਪ੍ਰਦਾਤਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਭਵਿੱਖ ਵਿੱਚ ਅਚਾਨਕ ਅਸਫਲਤਾਵਾਂ ਵੱਲ ਲੈ ਜਾਵੇਗਾ।
• *`ਕਾਰਵਾਈ: ਵਿਆਪਕ ਇਜਾਜ਼ਤ ਜਿਵੇਂ ਕਿ ""`।** ਘੱਟੋ-ਘੱਟ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਦੇ ਸਿਧਾਂਤ ਦੀ ਉਲੰਘਣਾ ਕਰਦੀ ਹੈ।
• ਅਚਾਨਕ 'ਨਸ਼ਟ' ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ। ਬਿਨਾਂ ਸਵਾਲ ਕੀਤੇ ਪਲਾਨ ਵਿੱਚ ਡਿਲੀਟ ਲਾਈਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ।

ਸੰਖੇਪ ਵਿੱਚ

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

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

ਉੱਪਰ ਦਿੱਤੇ "ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਤਿਆਰ ਕਰੋ" ਟੈਮਪਲੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਨੂੰ ਇੱਕ ਛੋਟਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਸਟੋਰੇਜ ਬਾਲਟੀ ਅਤੇ ਇੱਕ ਪਹੁੰਚ ਨੀਤੀ) ਤਿਆਰ ਕਰਨ ਲਈ ਕਹੋ। ਫਿਰ: (1) ਕੋਡ ਵਿੱਚ ਗੁਪਤ ਜਾਂ * ਅਨੁਮਤੀਆਂ ਲਈ "ਵੇਟਿੰਗ" ਟੈਮਪਲੇਟ ਦੀ ਜਾਂਚ ਕਰੋ; (2) ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਟੈਸਟ ਖਾਤੇ ਵਿੱਚ init + plan ਚਲਾਓ ਅਤੇ "ਯੋਜਨਾ ਵਿਆਖਿਆ" ਟੈਮਪਲੇਟ ਨਾਲ ਯੋਜਨਾ ਆਉਟਪੁੱਟ ਪੜ੍ਹੋ; (3) ਕਿਸੇ ਵੀ ਅਚਾਨਕ ਮਿਟਾਏ ਜਾਣ/ਤਬਦੀਲੀਆਂ ਨੂੰ ਨੋਟ ਕਰੋ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਆਪਣੇ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਕਲਾਉਡ, ਟੈਰਾਫਾਰਮ/ਪ੍ਰਦਾਤਾ ਸੰਸਕਰਣ, ਅਤੇ ਏਨਕ੍ਰਿਪਸ਼ਨ/ਨੈੱਟਵਰਕ ਪਾਬੰਦੀਆਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਹਨ।
• [ ] ਕੋਡ ਵਿੱਚ ਕੋਈ ਸਾਦਾ ਲਿਖਤ ਗੁਪਤ ਨਹੀਂ ਹੈ; ਸ਼ੁੱਧਤਾ ਮੁੱਲ ਵੇਰੀਏਬਲ।
• [ ] ਮੈਂ IAM/ਇਜਾਜ਼ਤਾਂ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਅਨੁਮਤੀਆਂ ਤੱਕ ਘਟਾ ਦਿੱਤਾ, * ਮੈਂ ਇਸਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ।
• [] ਮੈਂ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਯੋਜਨਾ ਚਲਾਈ ਅਤੇ ਆਉਟਪੁੱਟ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਿਆ।
• [ ] ਮੈਂ ਤਸਦੀਕ ਕੀਤਾ ਹੈ ਕਿ ਯੋਜਨਾ ਵਿੱਚ ਕੋਈ ਅਚਾਨਕ ਤਬਾਹੀ/ਬਦਲੀ ਨਹੀਂ ਹੈ।
• [ ] ਮੈਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਰਾਜ ਨੂੰ ਇੱਕ ਐਨਕ੍ਰਿਪਟਡ, ਲਾਕ ਅਤੇ ਪ੍ਰਤਿਬੰਧਿਤ ਬੈਕਐਂਡ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ।