ਏਆਈ-ਪਾਵਰਡ ਏਜੰਟਾਂ ਅਤੇ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਨਾਲ ZeroOps DevOps ਪਰਿਵਰਤਨ

ਜਾਣ-ਪਛਾਣ

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

ਜ਼ੀਰੋਓਪਸ ਕੀ ਹੈ?

ZeroOps DevOps ਵਿੱਚ ਇੱਕ ਉਭਰਦੀ ਧਾਰਨਾ ਹੈ ਜਿਸਦਾ ਉਦੇਸ਼ ਵਿਕਾਸ ਅਤੇ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦਸਤੀ ਦਖਲ ਦੀ ਲੋੜ ਨੂੰ ਖਤਮ ਕਰਨਾ ਹੈ। AI ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦਾ ਲਾਭ ਲੈ ਕੇ, ZeroOps ਆਟੋਮੇਟਿਡ ਡਿਪਲਾਇਮੈਂਟ, ਸਕੇਲਿੰਗ, ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਨਿਗਰਾਨੀ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ, ਮਨੁੱਖੀ ਗਲਤੀ ਦੇ ਜੋਖਮ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਕੁਸ਼ਲਤਾ ਵਧਾਉਂਦਾ ਹੈ। ZeroOps ਦਾ ਅੰਤਮ ਟੀਚਾ ਇੱਕ ਸਵੈ-ਇਲਾਜ, ਸਵੈ-ਅਨੁਕੂਲ, ਅਤੇ ਸਵੈ-ਸਕੇਲਿੰਗ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣਾ ਹੈ ਜਿਸ ਲਈ ਘੱਟੋ-ਘੱਟ ਮਨੁੱਖੀ ਦਖਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

AI-ਪਾਵਰਡ ਏਜੰਟ: ZeroOps ਦੀ ਕੁੰਜੀ

AI-ਸੰਚਾਲਿਤ ਏਜੰਟ ਸਾਫਟਵੇਅਰ ਪ੍ਰੋਗਰਾਮ ਹੁੰਦੇ ਹਨ ਜੋ ਕੰਮ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਅਤੇ ਫੈਸਲੇ ਲੈਣ ਲਈ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। DevOps ਦੇ ਸੰਦਰਭ ਵਿੱਚ, AI-ਸੰਚਾਲਿਤ ਏਜੰਟਾਂ ਦੀ ਵਰਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ, ਵਿਗਾੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਸੁਧਾਰਾਤਮਕ ਕਾਰਵਾਈ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਕਿਰੋ ਏਜੰਟ ਇੱਕ ਕਿਸਮ ਦੇ AI-ਸੰਚਾਲਿਤ ਏਜੰਟ ਹਨ ਜੋ DevOps ਆਟੋਮੇਸ਼ਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਕਿਰੋ ਏਜੰਟ

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

ਲੈਂਗਚੇਨ: ਆਰਕੈਸਟਰੇਸ਼ਨ ਟੂਲ

LangChain ਇੱਕ ਆਰਕੈਸਟਰੇਸ਼ਨ ਟੂਲ ਹੈ ਜੋ ਕਿਰੋ ਵਰਗੇ AI-ਸੰਚਾਲਿਤ ਏਜੰਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ DevOps ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਏਆਈ-ਸੰਚਾਲਿਤ ਏਜੰਟਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਤੈਨਾਤ ਕਰਨ ਲਈ ਇੱਕ ਢਾਂਚਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਕਿ ਤੈਨਾਤੀ, ਸਕੇਲਿੰਗ ਅਤੇ ਨਿਗਰਾਨੀ ਵਰਗੇ ਕੰਮਾਂ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰ ਸਕਦਾ ਹੈ। LangChain ਪਾਇਥਨ, ਰਸਟ, ਅਤੇ ਗੋ ਸਮੇਤ ਕਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

ਕਿਰੋ ਅਤੇ ਲੈਂਗਚੇਨ ਨਾਲ AI-ਪਾਵਰਡ DevOps ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

Kiro ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI-ਸੰਚਾਲਿਤ DevOps ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਕਿਰੋ ਅਤੇ ਲੈਂਗਚੈਨ ਸਥਾਪਿਤ ਕਰੋ: ਪਾਈਪ ਜਾਂ ਆਪਣੇ ਪਸੰਦੀਦਾ ਪੈਕੇਜ ਮੈਨੇਜਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਰੋ ਅਤੇ ਲੈਂਗਚੈਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ।
2. ਇੱਕ Kiro ਏਜੰਟ ਬਣਾਓ: ਇੱਕ Kiro ਏਜੰਟ ਬਣਾਓ ਜੋ DevOps ਆਟੋਮੇਸ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਏਜੰਟ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ, ਜਿਵੇਂ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ ਅਤੇ ਵਿਗਾੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ।
3. ਕਿਰੋ ਏਜੰਟ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ: ਪੈਟਰਨਾਂ ਅਤੇ ਵਿਗਾੜਾਂ ਨੂੰ ਸਿੱਖਣ ਲਈ ਇਤਿਹਾਸਕ ਡੇਟਾ 'ਤੇ ਕਿਰੋ ਏਜੰਟ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ। ਇਹ ਏਜੰਟ ਨੂੰ ਸੂਚਿਤ ਫੈਸਲੇ ਲੈਣ ਅਤੇ ਸੁਧਾਰਾਤਮਕ ਕਾਰਵਾਈ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।
4. LangChain ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰੋ: DevOps ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਕਿਰੋ ਏਜੰਟ ਨੂੰ LangChain ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰੋ। ਇਸ ਵਿੱਚ ਆਰਕੈਸਟਰੇਸ਼ਨ ਵਰਕਫਲੋ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਕਾਰਜਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਏਜੰਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ।

ਉਦਾਹਰਨ ਕੋਡ: ਕਿਰੋ ਏਜੰਟ ਬਣਾਉਣਾ

ਇੱਥੇ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਨ ਕੋਡ ਬਲਾਕ ਹੈ ਜੋ ਕਿਰੋ ਏਜੰਟ ਬਣਾਉਂਦਾ ਹੈ: ``ਅਜਗਰ ਕਿਰੋ ਆਯਾਤ ਕਰੋ ਲੈਂਗਚੈਨ ਆਯਾਤ ਐਲਐਲਐਮਐਸ ਤੋਂ

ਏਜੰਟ = kiro.Agent( name="my_agent", ਵਿਹਾਰ ={ "monitor_performance": { "ਫੰਕਸ਼ਨ": "ਨਿਗਰਾਨੀ_ਪ੍ਰਦਰਸ਼ਨ", "args": ["app_name", "threshold"], }, "detect_anomaly": { "ਫੰਕਸ਼ਨ": "ਡਿਟੈਕਟ_ਅਨੁਮਾਲੀ", "args": ["app_name", "threshold"], }, }, )

ਇਤਿਹਾਸਕ ਡੇਟਾ 'ਤੇ ਏਜੰਟ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ

agent.train( ਡਾਟਾ=[ {"app_name": "my_app", "ਪ੍ਰਦਰਸ਼ਨ": 90}, {"app_name": "my_app", "ਪ੍ਰਦਰਸ਼ਨ": 80}, {"app_name": "my_app", "ਪ੍ਰਦਰਸ਼ਨ": 70}, ], ਥ੍ਰੈਸ਼ਹੋਲਡ = 85, )

ਲੈਂਗਚੈਨ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰੋ

llms = LLMS( ਏਜੰਟ = ਏਜੰਟ, ਵਰਕਫਲੋ={ "monitor_performance": { "ਫੰਕਸ਼ਨ": "ਨਿਗਰਾਨੀ_ਪ੍ਰਦਰਸ਼ਨ", "args": ["my_app", 85], }, "detect_anomaly": { "ਫੰਕਸ਼ਨ": "ਡਿਟੈਕਟ_ਅਨੁਮਾਲੀ", "args": ["my_app", 85], }, }, )

ਵਰਕਫਲੋ ਚਲਾਓ

llms.execute() `` ਇਹ ਕੋਡ ਇੱਕ ਕਿਰੋ ਏਜੰਟ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸੰਗਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ। ਇਹ ਫਿਰ ਏਜੰਟ ਨੂੰ ਇਤਿਹਾਸਕ ਡੇਟਾ 'ਤੇ ਸਿਖਲਾਈ ਦਿੰਦਾ ਹੈ ਅਤੇ DevOps ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਇਸਨੂੰ LangChain ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ।

ਟੌਪ 5-10 ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ/ਸਨਿਪੇਟਸ

ਇੱਥੇ Kiro ਅਤੇ LangChain ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ 5-10 ਕਮਾਂਡਾਂ/ਸਨਿਪੇਟਸ ਹਨ:

1. ਕਿਰੋ ਏਜੰਟ ਬਣਾਉਣਾ: kiro.Agent(name="my_agent", behavior={"monitor_performance": {"function": "monitor_performance", "args": ["app_name", "threshold"]}})
2. ਕਿਰੋ ਏਜੰਟ ਦੀ ਸਿਖਲਾਈ: agent.train(data=[{"app_name": "my_app", "ਪ੍ਰਦਰਸ਼ਨ": 90}], ਥ੍ਰੈਸ਼ਹੋਲਡ=85)
3. LangChain ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ: llms = LLMS(agent=agent, workflow={"monitor_performance": {"function": "monitor_performance", "args": ["my_app", 85]}})
4. ਵਰਕਫਲੋ ਨੂੰ ਚਲਾਉਣਾ: llms.execute()
5. ਆਰਕੇਸਟ੍ਰੇਸ਼ਨ ਵਰਕਫਲੋ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ: ਵਰਕਫਲੋ = {"ਮਾਨੀਟਰ_ਪਰਫਾਰਮੈਂਸ": {"ਫੰਕਸ਼ਨ": "ਮਾਨੀਟਰ_ਪਰਫਾਰਮੈਂਸ", "ਆਰਗਜ਼": ["ਮੇਰਾ_ਐਪ", 85]}}
6. ਕਾਰਜਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਏਜੰਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ: agent.configure({"function": "execute_task", "args": ["task_name"]})
7. ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ: agent.monitor_performance(app_name="my_app", ਥ੍ਰੈਸ਼ਹੋਲਡ=85)
8. ਅਸੰਗਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ: agent.detect_anomaly(app_name="my_app", threshold=85)
9. ਏਜੰਟ ਦੀ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨਾ: agent.status()
10. ਏਜੰਟ ਦੇ ਲੌਗਸ ਪ੍ਰਾਪਤ ਕਰਨਾ: agent.logs()

ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ

ਇੱਥੇ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ DevOps ਪਾਈਪਲਾਈਨ ਦਾ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਹੈ: ਜੇਸਨ { "type": "ਪੱਟੀ", "ਡਾਟਾ": { "ਲੇਬਲ": ["ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰੋ", "ਅਨੁਮਾਲੀ ਦਾ ਪਤਾ ਲਗਾਓ", "ਕਾਰਜ ਚਲਾਓ"], "datasets": [ { "label": "ਏਜੰਟ", "ਡਾਟਾ": [90, 80, 70], "ਬੈਕਗ੍ਰਾਉਂਡ ਰੰਗ": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "ਬਾਰਡਰ ਚੌੜਾਈ": 1 } ] }, "ਵਿਕਲਪ": { "ਸਿਰਲੇਖ": { "ਡਿਸਪਲੇ": ਸਹੀ, "text": "DevOps ਪਾਈਪਲਾਈਨ" }, "ਪੈਮਾਨਾ": { "yAxes": [ { "ਟਿਕਸ": { "beginAtZero": ਸਹੀ } } ] } } } ਇਹ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤਿੰਨ ਪੜਾਵਾਂ ਦੇ ਨਾਲ DevOps ਪਾਈਪਲਾਈਨ ਦਿਖਾਉਂਦਾ ਹੈ: ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰੋ, ਵਿਗਾੜ ਦਾ ਪਤਾ ਲਗਾਓ, ਅਤੇ ਕਾਰਜ ਚਲਾਓ। ਏਜੰਟ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਇੱਕ ਬਾਰ ਚਾਰਟ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦੀ ਹੈ।

ਸਿੱਟਾ

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ Kiro ਏਜੰਟਾਂ ਅਤੇ LangChain ਵਰਗੇ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI-ਸੰਚਾਲਿਤ DevOps ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਪੜਚੋਲ ਕੀਤੀ। ਅਸੀਂ ਇੱਕ Kiro ਏਜੰਟ ਬਣਾਇਆ ਹੈ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ ਅਤੇ ਵਿਗਾੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ, ਅਤੇ DevOps ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਇਸਨੂੰ LangChain ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ। ਅਸੀਂ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ DevOps ਪਾਈਪਲਾਈਨ ਦਾ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਵੀ ਪ੍ਰਦਾਨ ਕੀਤਾ ਹੈ। ZeroOps ਦਾ ਅੰਤਮ ਟੀਚਾ ਇੱਕ ਸਵੈ-ਇਲਾਜ, ਸਵੈ-ਅਨੁਕੂਲ, ਅਤੇ ਸਵੈ-ਸਕੇਲਿੰਗ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣਾ ਹੈ ਜਿਸ ਲਈ ਘੱਟੋ-ਘੱਟ ਮਨੁੱਖੀ ਦਖਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। AI ਅਤੇ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਦਾ ਲਾਭ ਲੈ ਕੇ, ਅਸੀਂ ਇਸ ਟੀਚੇ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ DevOps ਅਭਿਆਸਾਂ ਨੂੰ ZeroOps ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹਾਂ।