ZeroOps DevOps-ի փոխակերպում AI-ի վրա աշխատող գործակալների և նվագախմբի միջոցով

Ներածություն

DevOps-ի հեղափոխությունը փոխեց ծրագրակազմի մշակման, տեղակայման և պահպանման ձևը: Այնուամենայնիվ, ավանդական DevOps մոտեցումը դեռ պահանջում է ձեռքով զգալի ջանքեր, փորձաքննություն և ժամանակ: AI-ով աշխատող գործակալների և նվագախմբային գործիքների ի հայտ գալը հնարավորություն է տվել ավտոմատացնել DevOps գործընթացները՝ հանգեցնելով ZeroOps-ի հայեցակարգին: Այս հոդվածում մենք կուսումնասիրենք AI-ով աշխատող DevOps ավտոմատացման իրականացումը Kiro գործակալների և նվագախմբի գործիքների միջոցով, ինչպիսին LangChain-ն է, կենտրոնանալով DevOps-ի պրակտիկան ZeroOps-ի վերածելու վրա:

Ի՞նչ է ZeroOps-ը:

ZeroOps-ը DevOps-ում առաջացող հայեցակարգ է, որի նպատակն է վերացնել մշակման և տեղակայման գործընթացում ձեռքով միջամտության անհրաժեշտությունը: Օգտագործելով արհեստական ​​ինտելեկտը և մեքենայական ուսուցումը, ZeroOps-ը հնարավորություն է տալիս ավտոմատ կերպով տեղակայել, մասշտաբավորել և վերահսկել հավելվածները՝ նվազեցնելով մարդկային սխալի ռիսկը և բարձրացնելով արդյունավետությունը: ZeroOps-ի վերջնական նպատակն է ստեղծել ինքնաբուժման, ինքնաօպտիմալացման և ինքնասպասարկման համակարգ, որը պահանջում է նվազագույն մարդկային միջամտություն:

AI-ով աշխատող գործակալներ. ZeroOps-ի բանալին

AI-ով աշխատող գործակալները ծրագրային ծրագրեր են, որոնք օգտագործում են մեքենայական ուսուցման ալգորիթմներ՝ առաջադրանքները ավտոմատացնելու և որոշումներ կայացնելու համար: DevOps-ի համատեքստում AI-ով աշխատող գործակալները կարող են օգտագործվել հավելվածի կատարողականը վերահսկելու, անոմալիաները հայտնաբերելու և ուղղիչ գործողություններ ձեռնարկելու համար: Kiro գործակալները AI-ի վրա աշխատող գործակալների մի տեսակ են, որոնք կարող են օգտագործվել DevOps-ի ավտոմատացման համար:

Կիրո գործակալներ

Kiro գործակալները AI-ի վրա աշխատող գործակալների մի տեսակ են, որոնք կարող են օգտագործվել DevOps-ի ավտոմատացման համար: Դրանք նախատեսված են LangChain-ի նման նվագախմբային գործիքների հետ աշխատելու համար՝ ավտոմատացնելով հավելվածների տեղակայումը, մասշտաբը և մոնիտորինգը: Kiro գործակալները կարող են վերապատրաստվել պատմական տվյալների վրա՝ սովորելու օրինաչափություններ և անոմալիաներ՝ հնարավորություն տալով նրանց տեղեկացված որոշումներ կայացնել և ուղղիչ գործողություններ ձեռնարկել:

LangChain: The Orchestration Tool

LangChain-ը նվագախմբային գործիք է, որը հնարավորություն է տալիս ավտոմատացնել DevOps գործընթացները՝ օգտագործելով AI-ով աշխատող գործակալներ, ինչպիսին է Kiro-ն: Այն ապահովում է AI-ի վրա աշխատող գործակալների կառուցման և տեղակայման շրջանակ, որոնք կարող են ավտոմատացնել այնպիսի առաջադրանքներ, ինչպիսիք են տեղակայումը, մասշտաբացումը և մոնիտորինգը: LangChain-ն աջակցում է ծրագրավորման մի շարք լեզուների, ներառյալ Python-ը, Rust-ը և Go-ն:

Իրականացնելով AI-ով աշխատող DevOps ավտոմատացում Kiro-ի և LangChain-ի հետ

AI-ով աշխատող DevOps ավտոմատացումն իրականացնելու համար՝ օգտագործելով Kiro-ն և LangChain-ը, մենք պետք է հետևենք հետևյալ քայլերին.

1. Տեղադրեք Kiro-ն և LangChain-ը. Տեղադրեք Kiro-ն և LangChain-ը` օգտագործելով pip-ը կամ ձեր նախընտրած փաթեթի կառավարիչը:
2. Ստեղծեք Kiro Agent. Ստեղծեք Kiro գործակալ, որը կարող է օգտագործվել DevOps-ի ավտոմատացման համար: Սա ներառում է գործակալի վարքագծի սահմանումը, ինչպես օրինակ՝ կիրառման կատարողականի մոնիտորինգը և անոմալիաների հայտնաբերումը:
3. Վարժեցրեք Kiro գործակալին. Վարժեցրեք Kiro գործակալին պատմական տվյալների վրա՝ սովորելու օրինաչափություններ և անոմալիաներ: Սա գործակալին հնարավորություն է տալիս տեղեկացված որոշումներ կայացնել և ուղղիչ գործողություններ ձեռնարկել:
4. Ինտեգրվել LangChain-ի հետ. Ինտեգրել Kiro գործակալը LangChain-ի հետ՝ DevOps գործընթացները ավտոմատացնելու համար: Սա ներառում է նվագախմբի աշխատանքային հոսքի սահմանումը և առաջադրանքները կատարելու համար գործակալի կազմաձևումը:

**Օրինակ կոդը. Ստեղծելով Kiro Agent **

Ահա Python-ում կոդերի բլոկի օրինակ, որը ստեղծում է Kiro գործակալ. «Պիթոն». ներմուծում kiro langchain import LLMS-ից

agent = kiro.Agent( անուն = "my_agent", վարքագիծ ={ "monitor_performance": { "function": "monitor_performance", "args": ["app_name", "shreshold"], }, «հայտնաբերում_անոմալիա»: { "function": "detect_anomaly", "args": ["app_name", "shreshold"], }, }, )

Վարժեցրեք գործակալին պատմական տվյալների վրա

agent.train( տվյալներ=[ {"app_name": "my_app", "performance": 90}, {"app_name": "my_app", "performance": 80}, {"app_name": "my_app", "performance": 70}, ], շեմ=85, )

Ինտեգրվել LangChain-ի հետ

llms = LLMS ( գործակալ=գործակալ, աշխատանքային հոսք={ "monitor_performance": { "function": "monitor_performance", «args»: [«my_app», 85], }, «հայտնաբերում_անոմալիա»: { "function": "detect_anomaly", «args»: [«my_app», 85], }, }, )

Կատարեք աշխատանքային հոսքը

llms.execute ()

Այս կոդը ստեղծում է Kiro գործակալ, որը վերահսկում է հավելվածի աշխատանքը և հայտնաբերում անոմալիաները: Այնուհետև այն վերապատրաստում է գործակալին պատմական տվյալների վրա և ինտեգրում այն ​​LangChain-ի հետ՝ DevOps գործընթացները ավտոմատացնելու համար:

**Թոփ 5-10 ամենաշատ օգտագործվող հրամաններ/հատվածներ**


Ահա Kiro-ի և LangChain-ի 5-10 ամենաօգտագործվող հրամանները/հատվածները.

1. **Ստեղծելով Kiro Agent**՝ «kiro.Agent(name="my_agent", Behaviour={"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(agent=agent, workflow={"monitor_performance": {"function": "monitor_performance", "args": ["my_app", 85]}})`
4. **Աշխատանքային հոսքի իրականացում**՝ `llms.execute()`
5. **Նվագախմբի աշխատանքային հոսքի սահմանում**. `workflow = {"monitor_performance": {"function": "monitor_performance", "args": ["my_app", 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()»:

**Վիզուալիզացիա**


Ահա DevOps խողովակաշարի արտացոլումը Chart.js-ի միջոցով.
```ջսոն
{
  «տեսակ»՝ «բար»,
  "տվյալներ": {
    «պիտակներ»՝ [«Մոնիտորի կատարողականություն», «Հայտնաբերել անոմալիա», «Կատարել առաջադրանք»],
    «տվյալների հավաքածուներ»:
      {
        «պիտակ»: «Գործակալ»,
        «տվյալներ»: [90, 80, 70],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        «սահմանի լայնություն»՝ 1
      }
    ]
  },
  «Ընտրանքներ»: {
    «վերնագիր»: {
      «ցուցադրում»՝ ճշմարիտ,
      "text": "DevOps Pipeline"
    },
    «կշեռքներ»: {
      «yAxes»:
        {
          "ticks": {
            «beginAtZero»: ճիշտ է
          }
        }
      ]
    }
  }
}

Այս վիզուալիզացիան ցույց է տալիս DevOps խողովակաշարը երեք փուլով՝ Monitor Performance, Detect Anomaly և Execute Task: Գործակալի կատարումը ցուցադրվում է որպես գծապատկեր:

Եզրակացություն

Այս հոդվածում մենք ուսումնասիրեցինք AI-ով աշխատող DevOps ավտոմատացման իրականացումը, օգտագործելով Kiro գործակալները և նվագախմբի գործիքները, ինչպիսիք են LangChain-ը: Մենք ստեղծեցինք Kiro գործակալ, որը վերահսկում է հավելվածի աշխատանքը և հայտնաբերում անոմալիաները, և այն ինտեգրեցինք LangChain-ի հետ՝ DevOps գործընթացները ավտոմատացնելու համար: Մենք նաև տրամադրեցինք DevOps խողովակաշարի պատկերացում՝ օգտագործելով Chart.js: ZeroOps-ի վերջնական նպատակն է ստեղծել ինքնաբուժման, ինքնաօպտիմալացման և ինքնասպասարկման համակարգ, որը պահանջում է նվազագույն մարդկային միջամտություն: Օգտագործելով AI-ն և մեքենայական ուսուցումը, մենք կարող ենք հասնել այս նպատակին և DevOps-ի պրակտիկան վերածել ZeroOps-ի: