** AI- ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಶನ್‌ನೊಂದಿಗೆ ZeroOps DevOps ರೂಪಾಂತರ**

ಪರಿಚಯ

DevOps ಕ್ರಾಂತಿಯು ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ, ನಿಯೋಜಿಸುವ ಮತ್ತು ನಿರ್ವಹಿಸುವ ವಿಧಾನವನ್ನು ಮಾರ್ಪಡಿಸಿದೆ. ಆದಾಗ್ಯೂ, ಸಾಂಪ್ರದಾಯಿಕ DevOps ವಿಧಾನವು ಇನ್ನೂ ಗಮನಾರ್ಹವಾದ ಕೈಯಾರೆ ಪ್ರಯತ್ನ, ಪರಿಣತಿ ಮತ್ತು ಸಮಯದ ಅಗತ್ಯವಿರುತ್ತದೆ. AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳ ಹೊರಹೊಮ್ಮುವಿಕೆಯು DevOps ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡಿದೆ, ಇದು ZeroOps ಪರಿಕಲ್ಪನೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ, DevOps ಅಭ್ಯಾಸಗಳನ್ನು ZeroOps ಆಗಿ ಪರಿವರ್ತಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವ ಮೂಲಕ, ನಾವು Kiro ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು LangChain ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು AI-ಚಾಲಿತ DevOps ಆಟೊಮೇಷನ್‌ನ ಅನುಷ್ಠಾನವನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ZeroOps ಎಂದರೇನು?

ZeroOps ಅಭಿವೃದ್ಧಿ ಮತ್ತು ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ಹಸ್ತಕ್ಷೇಪದ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕುವ ಗುರಿಯನ್ನು ಹೊಂದಿರುವ DevOps ನಲ್ಲಿ ಉದಯೋನ್ಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. AI ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ZeroOps ಸ್ವಯಂಚಾಲಿತ ನಿಯೋಜನೆ, ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಮೇಲ್ವಿಚಾರಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಮಾನವ ದೋಷದ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ZeroOps ನ ಅಂತಿಮ ಗುರಿಯು ಸ್ವಯಂ-ಚಿಕಿತ್ಸೆ, ಸ್ವಯಂ-ಆಪ್ಟಿಮೈಸಿಂಗ್ ಮತ್ತು ಸ್ವಯಂ-ಸ್ಕೇಲಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವುದು, ಅದು ಕನಿಷ್ಠ ಮಾನವ ಹಸ್ತಕ್ಷೇಪದ ಅಗತ್ಯವಿರುತ್ತದೆ.

AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳು: ZeroOps ಗೆ ಕೀ

AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳು ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಮತ್ತು ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಯಂತ್ರ ಕಲಿಕೆ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುವ ಸಾಫ್ಟ್‌ವೇರ್ ಪ್ರೋಗ್ರಾಂಗಳಾಗಿವೆ. DevOps ಸಂದರ್ಭದಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು, ವೈಪರೀತ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಸರಿಪಡಿಸುವ ಕ್ರಮವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. Kiro ಏಜೆಂಟ್‌ಗಳು AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳಾಗಿದ್ದು, ಇದನ್ನು DevOps ಆಟೊಮೇಷನ್‌ಗಾಗಿ ಬಳಸಬಹುದು.

ಕಿರೋ ಏಜೆಂಟ್

Kiro ಏಜೆಂಟ್‌ಗಳು AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳಾಗಿದ್ದು, ಇದನ್ನು DevOps ಆಟೊಮೇಷನ್‌ಗಾಗಿ ಬಳಸಬಹುದು. ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಿಯೋಜನೆ, ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅವುಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಕಿರೊ ಏಜೆಂಟ್‌ಗಳು ಮಾದರಿಗಳು ಮತ್ತು ವೈಪರೀತ್ಯಗಳನ್ನು ಕಲಿಯಲು ಐತಿಹಾಸಿಕ ದತ್ತಾಂಶದ ಮೇಲೆ ತರಬೇತಿ ನೀಡಬಹುದು, ತಿಳುವಳಿಕೆಯುಳ್ಳ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮತ್ತು ಸರಿಪಡಿಸುವ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಅವರಿಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಲ್ಯಾಂಗ್‌ಚೈನ್: ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಟೂಲ್

LangChain ಎಂಬುದು ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಸಾಧನವಾಗಿದ್ದು ಅದು Kiro ನಂತಹ AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು DevOps ಪ್ರಕ್ರಿಯೆಗಳ ಯಾಂತ್ರೀಕೃತಗೊಂಡವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ನಿಯೋಜನೆ, ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯಂತಹ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದಾದ AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಇದು ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತದೆ. ಲ್ಯಾಂಗ್‌ಚೈನ್ ಪೈಥಾನ್, ರಸ್ಟ್ ಮತ್ತು ಗೋ ಸೇರಿದಂತೆ ಹಲವಾರು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.

ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ AI-ಚಾಲಿತ DevOps ಆಟೊಮೇಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

Kiro ಮತ್ತು LangChain ಬಳಸಿಕೊಂಡು AI-ಚಾಲಿತ DevOps ಆಟೊಮೇಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಾವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಬೇಕು:

1. ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ: ಪಿಪ್ ಅಥವಾ ನಿಮ್ಮ ಆದ್ಯತೆಯ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ.
2. ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ: DevOps ಆಟೊಮೇಷನ್‌ಗಾಗಿ ಬಳಸಬಹುದಾದ Kiro ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ. ಇದು ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು ಮತ್ತು ವೈಪರೀತ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವಂತಹ ಏಜೆಂಟ್‌ನ ನಡವಳಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
3. ಕಿರೊ ಏಜೆಂಟ್‌ಗೆ ತರಬೇತಿ ನೀಡಿ: ಮಾದರಿಗಳು ಮತ್ತು ವೈಪರೀತ್ಯಗಳನ್ನು ಕಲಿಯಲು ಐತಿಹಾಸಿಕ ಡೇಟಾದಲ್ಲಿ ಕಿರೊ ಏಜೆಂಟ್‌ಗೆ ತರಬೇತಿ ನೀಡಿ. ಇದು ತಿಳುವಳಿಕೆಯುಳ್ಳ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮತ್ತು ಸರಿಪಡಿಸುವ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಏಜೆಂಟ್ ಅನ್ನು ಶಕ್ತಗೊಳಿಸುತ್ತದೆ.
4. LangChain ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: DevOps ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು LangChain ನೊಂದಿಗೆ Kiro ಏಜೆಂಟ್ ಅನ್ನು ಸಂಯೋಜಿಸಿ. ಇದು ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ವರ್ಕ್‌ಫ್ಲೋ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಏಜೆಂಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಉದಾಹರಣೆ ಕೋಡ್: ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುವುದು

ಪೈಥಾನ್‌ನಲ್ಲಿ ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುವ ಉದಾಹರಣೆ ಕೋಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ: ``ಹೆಬ್ಬಾವು ಆಮದು ಕಿರೋ ಲ್ಯಾಂಗ್‌ಚೈನ್ ಆಮದು LLMS ನಿಂದ

ಏಜೆಂಟ್ = ಕಿರೋ. ಏಜೆಂಟ್( ಹೆಸರು="ನನ್ನ_ಏಜೆಂಟ್", ನಡವಳಿಕೆ={ "monitor_performance": { "ಫಂಕ್ಷನ್": "ಮಾನಿಟರ್_ಪರ್ಫಾರ್ಮೆನ್ಸ್", "args": ["app_name", "threshold"], }, "ಡಿಟೆಕ್ಟ್_ಅಸಂಗತತೆ": { "ಫಂಕ್ಷನ್": "ಡಿಟೆಕ್ಟ್_ಅಸಂಗತ", "args": ["app_name", "threshold"], }, }, )

ಐತಿಹಾಸಿಕ ಡೇಟಾದಲ್ಲಿ ಏಜೆಂಟರಿಗೆ ತರಬೇತಿ ನೀಡಿ

agent.train( ಡೇಟಾ=[ {"app_name": "my_app", "performance": 90}, {"app_name": "my_app", "performance": 80}, {"app_name": "my_app", "performance": 70}, ], ಮಿತಿ=85, )

ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ

llms = LLMS( ಏಜೆಂಟ್ = ಏಜೆಂಟ್, ಕೆಲಸದ ಹರಿವು={ "monitor_performance": { "ಫಂಕ್ಷನ್": "ಮಾನಿಟರ್_ಪರ್ಫಾರ್ಮೆನ್ಸ್", "args": ["my_app", 85], }, "ಡಿಟೆಕ್ಟ್_ಅಸಂಗತತೆ": { "ಫಂಕ್ಷನ್": "ಡಿಟೆಕ್ಟ್_ಅಸಂಗತ", "args": ["my_app", 85], }, }, )

ಕೆಲಸದ ಹರಿವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ

llms.execute()

ಈ ಕೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಮತ್ತು ವೈಪರೀತ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಕಿರೊ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ನಂತರ ಏಜೆಂಟರಿಗೆ ಐತಿಹಾಸಿಕ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತಿ ನೀಡುತ್ತದೆ ಮತ್ತು DevOps ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು LangChain ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ.

**ಟಾಪ್ 5-10 ಹೆಚ್ಚು ಬಳಸಿದ ಆಜ್ಞೆಗಳು/ತುಣುಕುಗಳು**


Kiro ಮತ್ತು LangChain ಗಾಗಿ ಹೆಚ್ಚು ಬಳಸಿದ 5-10 ಕಮಾಂಡ್‌ಗಳು/ತುಣುಕುಗಳು ಇಲ್ಲಿವೆ:

1. **ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುವುದು**: `kiro.Agent(name="my_agent", ನಡವಳಿಕೆ={"monitor_performance": {"function": "monitor_performance", "args": ["app_name", "threshold"]}})`
2. **ಕಿರೋ ಏಜೆಂಟ್‌ಗೆ ತರಬೇತಿ**: `agent.train(data=[{"app_name": "my_app", "performance": 90}], threshold=85)`
3. **LangChain ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು**: `llms = LLMS(ಏಜೆಂಟ್=ಏಜೆಂಟ್, ವರ್ಕ್‌ಫ್ಲೋ={"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", threshold=85)`
8. **ಅಸಂಗತತೆಗಳನ್ನು ಪತ್ತೆ ಹಚ್ಚುವುದು**: `agent.detect_anomaly(app_name="my_app", threshold=85)`
9. **ಏಜೆಂಟರ ಸ್ಥಿತಿಯನ್ನು ಪಡೆಯುವುದು**: `agent.status()`
10. ** ಏಜೆಂಟ್ ಲಾಗ್‌ಗಳನ್ನು ಪಡೆಯುವುದು**: `agent.logs()`

**ದೃಶ್ಯೀಕರಣ**


Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು DevOps ಪೈಪ್‌ಲೈನ್‌ನ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:
```json
{
  "ಪ್ರಕಾರ": "ಬಾರ್",
  "ಡೇಟಾ": {
    "ಲೇಬಲ್‌ಗಳು": ["ಮಾನಿಟರ್ ಕಾರ್ಯಕ್ಷಮತೆ", "ಅಸಂಗತತೆಯನ್ನು ಪತ್ತೆ ಮಾಡಿ", "ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ"],
    "ಡೇಟಾಸೆಟ್‌ಗಳು": [
      {
        "ಲೇಬಲ್": "ಏಜೆಂಟ್",
        "ಡೇಟಾ": [90, 80, 70],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "ಬಾರ್ಡರ್ ಅಗಲ": 1
      }
    ]
  },
  "ಆಯ್ಕೆಗಳು": {
    "ಶೀರ್ಷಿಕೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ,
      "ಪಠ್ಯ": "DevOps ಪೈಪ್‌ಲೈನ್"
    },
    "ಮಾಪಕಗಳು": {
      "yAxes": [
        {
          "ಉಣ್ಣಿ": {
            "beginAtZero": ನಿಜ
          }
        }
      ]
    }
  }
}

ಈ ದೃಶ್ಯೀಕರಣವು DevOps ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಮೂರು ಹಂತಗಳೊಂದಿಗೆ ತೋರಿಸುತ್ತದೆ: ಮಾನಿಟರ್ ಕಾರ್ಯಕ್ಷಮತೆ, ಅಸಂಗತತೆಯನ್ನು ಪತ್ತೆ ಮಾಡಿ ಮತ್ತು ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ಏಜೆಂಟ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಬಾರ್ ಚಾರ್ಟ್‌ನಂತೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

** ತೀರ್ಮಾನ **

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು Kiro ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು LangChain ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು AI-ಚಾಲಿತ DevOps ಆಟೊಮೇಷನ್‌ನ ಅನುಷ್ಠಾನವನ್ನು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಮತ್ತು ವೈಪರೀತ್ಯಗಳನ್ನು ಪತ್ತೆ ಮಾಡುವ Kiro ಏಜೆಂಟ್ ಅನ್ನು ನಾವು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು DevOps ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು LangChain ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದ್ದೇವೆ. ನಾವು Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು DevOps ಪೈಪ್‌ಲೈನ್‌ನ ದೃಶ್ಯೀಕರಣವನ್ನು ಸಹ ಒದಗಿಸಿದ್ದೇವೆ. ZeroOps ನ ಅಂತಿಮ ಗುರಿಯು ಸ್ವಯಂ-ಚಿಕಿತ್ಸೆ, ಸ್ವಯಂ-ಆಪ್ಟಿಮೈಸಿಂಗ್ ಮತ್ತು ಸ್ವಯಂ-ಸ್ಕೇಲಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವುದು, ಅದು ಕನಿಷ್ಠ ಮಾನವ ಹಸ್ತಕ್ಷೇಪದ ಅಗತ್ಯವಿರುತ್ತದೆ. AI ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ನಾವು ಈ ಗುರಿಯನ್ನು ಸಾಧಿಸಬಹುದು ಮತ್ತು DevOps ಅಭ್ಯಾಸಗಳನ್ನು ZeroOps ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು.