რა არის Serverless? Serverless გამოთვლა მარტივად ახსნილი
Serverless არის კოდის გაშვების გზა, სადაც სერვერებს თავად არ აყენებთ და არ მართავთ. თქვენს კოდს ღრუბლოვან პროვაიდერს აძლევთ, და ის მხოლოდ მაშინ მუშაობს, როცა რაღაც მას აამოქმედებს — ვებ მოთხოვნა, ატვირთული ფაილი, გადახდის შეტყობინება — შემდეგ ჩერდება. ჩვეულებრივ იხდით იმ დროისთვის, როცა თქვენი კოდი რეალურად მუშაობს, და არა უმოქმედო მანქანისთვის.
რატომ არის serverless მნიშვნელოვანი AI-ით აშენებისას
AI-ით აპის აშენებისას, როცა ჰოსტინგის ვარიანტებს ან კოდს უყურებთ, შეხვდებით „serverless ფუნქციებს“, „edge ფუნქციებს“ ან „cloud ფუნქციებს“. ბევრი ჰოსტინგის პლატფორმა სთავაზობს მათ, და ზოგიერთი AI შემქმნელი ბექენდს ამ გზით ათავსებს. მოდელის გაგება სამ პრაქტიკულ კითხვაში გეხმარებათ:
- ხარჯი. აღმოჩნდება თუ არა, რომ აპი ფულს დაჯდება მაშინაც, როცა არავინ იყენებს?
- სიჩქარე. რატომ არის პირველი მოთხოვნა მშვიდი პერიოდის შემდეგ უფრო ნელი?
- ლიმიტები. რატომ ამოიწურა დრო გრძელმა დავალებამ — დიდი ანგარიშის გენერირებამ, ვიდეოს დამუშავებამ?
ასევე სასარგებლოა იცოდეთ, რას არ ნიშნავს serverless: ის არ არის ბექენდის არქონა. თქვენ კვლავ გაქვთ სერვერის მხარის კოდი; უბრალოდ ვიღაც სხვა უშვებს მანქანებს. საბაზისო ცნებებისთვის იხილეთ რა არის სერვერი.
ყოველდღიური ანალოგია
ტრადიციული სერვერი მანქანის ქონას ჰგავს. ის ყოველთვის იქაა, მზად არის მაშინვე წასასვლელად, მაგრამ იხდით მასზე — დაზღვევას, პარკინგს, მოვლას — მაშინაც კი, თუ არ მართავთ.
Serverless ტაქსის გამოძახებას ჰგავს. იხდით მხოლოდ იმ მგზავრობებისთვის, რომლებსაც აკეთებთ, და თუ ასი ადამიანს ერთდროულად სჭირდება მგზავრობა, ასი ტაქსი მოდის. მაგრამ მანქანის მოსვლას მოკლე ლოდინი სჭირდება (cold start), თითოეულ მგზავრობას მაქსიმალური ხანგრძლივობა აქვს, და მძღოლი წინა მგზავრობას არ იხსენებს (ფუნქციები stateless-ია).
როგორ მუშაობს serverless ფუნქციები
ყველაზე გავრცელებულ ფორმაში, რომელსაც functions as a service ჰქვია:
- წერთ ფუნქციას — პატარა კოდს, რომელიც ერთი ტიპის მოვლენას ამუშავებს, მაგალითად „დაამუშავე POST
/api/bookings-ზე“. - გამოაქვეყნებთ. პროვაიდერი ინახავს მას და აკავშირებს გამშვებთან: URL-თან, განრიგთან, საცავში ახალ ფაილთან, რიგში შეტყობინებასთან.
- მოვლენა მოდის. პროვაიდერი იწყებს თქვენი ფუნქციის ასლს (ან იყენებს უკვე გახურებულს), უშვებს მას და აბრუნებს შედეგს.
- თავად იზრდება. თუ ათასი მოთხოვნა ერთდროულად მოვიდა, პროვაიდერი ბევრ ასლს პარალელურად უშვებს, თქვენი ანგარიშის ლიმიტების ფარგლებში.
- უმოქმედო ხდება. როცა ტრაფიკი ჩერდება, ასლები ითიშება. როცა არაფერი მუშაობს, გამოთვლაში არაფერს იხდით.
პატარა serverless ფუნქცია JavaScript-ში ასე შეიძლება გამოიყურებოდეს:
export default async function handler(request) {
const { name } = await request.json();
return Response.json({ message: `გამარჯობა, ${name}` });
}
სერვერის დასაწყებად, პორტის გასახსნელად ან პროცესის ჩართულად შესანარჩუნებლად კოდი არ არის საჭირო. ამას პლატფორმა ყველაფერს თავად აკეთებს.
„Serverless“ უფრო ზოგადადაც გამოიყენება სხვა მართული სერვისებისთვის, რომლებიც თავად იზრდებიან და გამოყენების მიხედვით ირიცხებიან — მაგალითად serverless მონაცემთა ბაზები, რომლებიც უმოქმედობისას ჩერდებიან.
ძირითადი ტერმინები
| ტერმინი | რას ნიშნავს |
|---|---|
| ფუნქცია (FaaS) | პატარა კოდის ერთეული, რომელსაც პროვაიდერი მოთხოვნით უშვებს. |
| გამშვები / მოვლენა | რა იწყებს ფუნქციას — HTTP მოთხოვნა, ფაილის ატვირთვა, ტაიმერი, რიგის შეტყობინება. |
| Cold start | დაყოვნება, როცა ფუნქციის ახალი ასლი მოთხოვნის დამუშავებამდე უნდა გაეშვას. |
| Warm | უკვე გაშვებული ასლი, რომელსაც შეუძლია მაშინვე უპასუხოს. |
| Stateless | ფუნქცია გაშვებებს შორის მეხსიერებას არ ინახავს. ყველაფერი, რაც უნდა შენარჩუნდეს, მონაცემთა ბაზაში ან საცავში ინახება. |
| Timeout | მაქსიმალური დრო, რომელიც ერთ გაშვებას ეძლევა. მაგალითად, AWS Lambda-ს მაქსიმუმი 15 წუთია; ბევრ პლატფორმას ბევრად ნაკლები აქვს ნაგულისხმევად. |
| Edge ფუნქცია | ფუნქცია, რომელიც მომხმარებლებთან ახლოს, ბევრ ადგილას მუშაობს, ხშირად უფრო მკაცრი ლიმიტებით. |
| Scale to zero | არაფრის გაშვება და გამოთვლაში არაფრის გადახდა, როცა ტრაფიკი არ არის. |
სამუშაო მაგალითი: პატარა დაჯავშნის საიტი
იოგას სტუდიის დაჯავშნის საიტს ყოველ კვირა საღამოს დიდი ნახვები მოდის, როცა ახალი განრიგი ავიდება, და დანარჩენ კვირაში — ძალიან ცოტა.
- ყოველთვის ჩართულ სერვერზე სტუდია 24/7 იხდის მანქანაზე, რომელიც კვირა საღამოს პიკისთვისაა გაზომილი, და დანარჩენ დროს უმეტესად უმოქმედოა.
- Serverless ფუნქციებით
GET /api/classesდაPOST /api/bookingsფუნქციებია. კვირის მოზღვავება ბევრ ასლს ავტომატურად აამოქმედებს; ჩუმ სამშაბათს დილით თითქმის არაფერი მუშაობს და ანგარიში თითქმის ნულია.
კომპრომისებიც ჩნდება. სამშაბათს დილით საიტის პირველმა გამხსნელმა შეიძლება ცოტა მეტი დაელოდოს cold start-ის გამო. მონაცემთა ბაზამ უნდა გაუმკლავდეს ბევრ მოკლევადიან კავშირს ბევრი ფუნქციის ასლისგან, რაც შეიძლება connection pooler-ს მოითხოვდეს. და თუ სტუდია მოგვიანებით მოინდომებს დავალებას „ყველას წლიური დასწრების PDF-ის გენერირება“, ის შეიძლება ფუნქციის დროის ლიმიტს გადააჭარბოს და სხვაგან უნდა გაეშვას.
როდის ერგება serverless — და როდის არა
| კარგი შესაბამისობა | ნაკლებად კარგი შესაბამისობა |
|---|---|
| დაბალი, ნახტომებიანი ან არაპროგნოზირებადი ტრაფიკი | მუდმივი მძიმე ტრაფიკი, სადაც მუდმივად ჩართული იაფი შეიძლება იყოს |
| მოკლე მოთხოვნა/პასუხი: API-ები, ფორმების დამმუშავებლები, webhook-ები | ხანგრძლივი სამუშაოები: დიდი ვიდეოების დამუშავება, დიდი მონაცემების იმპორტი |
| პატარა გუნდები, რომლებსაც სერვერების მართვა არ სურთ | აპები, რომლებიც ცოცხალ კავშირებს ინახავენ ღიად (ზოგი ჩატი ან მრავალმოთამაშიანი ფუნქცია), თუ პლატფორმა არ უჭერს მხარს |
| მოვლენების დამუშავება: „ფაილის ატვირთვისას შექმენი მინიატურა“ | აპები, რომლებსაც მოთხოვნებს შორის ბევრი მეხსიერება სჭირდება |
გავრცელებული მცდარი წარმოდგენები
- „Serverless ნიშნავს backend-ის არქონას.“ ნიშნავს სერვერების მართვის არქონას. კვლავ წერთ და იცავთ ბექენდის კოდს.
- „Serverless ყოველთვის იაფია.“ დაბალ მოცულობაზე იაფია, მაგრამ მოთხოვნაზე ფასმა შეიძლება დიდ, მუდმივ მოცულობაზე დიდ თანხად დაგროვდეს.
- „Serverless უსასრულოდ იზრდება.“ პლატფორმებს კონკურენტულობის ლიმიტები აქვთ, და თქვენი მონაცემთა ბაზა შეიძლება ბოთლის ყელად იქცეს ფუნქციებზე ადრე.
- „ფუნქციაში შენახული ფაილები შემდეგჯერ იქნება.“ ლოკალური საცავი დროებითია. გამოიყენეთ მონაცემთა ბაზა ან ფაილის საცავი.
- „Scale-to-zero იგივეა, რაც serverless.“ ახლოსაა, მაგრამ იდენტური არ არის. ზოგი პლატფორმა თქვენს აპს ჩვეულებრივ სერვერად უშვებს, რომელიც უმოქმედობისას იძინებს და შემდეგ მოთხოვნაზე იღვიძებს — მსგავსი დანაზოგი და მსგავსი დაყოვნება პირველ მოთხოვნაზე, მაგრამ მოთხოვნაზე ფუნქციის სტილის დროის ლიმიტების გარეშე.
რა სთხოვოთ თქვენს AI შემქმნელს
- „ეს ბექენდი გაეშვება serverless ფუნქციებად, თუ ყოველთვის ჩართულ ან მძინარე სერვერად? რას ნიშნავს ეს ხარჯისთვის?“
- „არის თუ არა ზოგი დავალება, რომელიც პლატფორმის დროის ლიმიტს გადააჭარბებს? თუ არის, როგორ დავამუშაოთ ისინი?“
- „ყველაფერი, რაც უნდა შენარჩუნდეს, შეინახე მონაცემთა ბაზაში ან ფაილის საცავში, და არა მეხსიერებაში ან ლოკალურ ფაილებში.“
- „როგორ უნდა ვმართოთ მონაცემთა ბაზის კავშირები, თუ ბევრი ასლი ერთდროულად მუშაობს?“
- „რამდენ ხანს გასტანს პირველი მოთხოვნა, როცა აპი უმოქმედო იყო?“
როგორ უშვებს Mythex აპებს
Mythex თავის ჰოსტინგს serverless ფუნქციებად არ აღწერს. გამოქვეყნებისას თქვენი აპი ჩვეულებრივ ვებაპად ან კონტეინერად მუშაობს, რომელსაც Mythex თქვენთვის მართავს — ჰოსტინგის დაყენება საჭირო არ არის. ეს არის scale-to-zero: გამოქვეყნებული აპები და მათი მონაცემთა ბაზები უმოქმედობისას იძინებენ და შემდეგ ვიზიტზე იღვიძებენ; მძინარე აპი გამოთვლაში არაფერს ხარჯავს, დამატებითი მანქანები კი მხოლოდ მძიმე ტრაფიკისას ირთვება (Pro-ზე სერვისზე მაქსიმუმ 3). მიერთებული Postgres მონაცემთა ბაზაც 5 წუთიანი უმოქმედობის შემდეგ იძინებს და ირიცხება მის გაღვიძებულ დროზე. ასე რომ, იღებთ „იხდი იმაში, რასაც იყენებ“ უპირატესობის დიდ ნაწილს, იმავე ტიპის დაყოვნებით პირველ მოთხოვნაზე მშვიდი პერიოდის შემდეგ. დოკუმენტაციაში იხილეთ ჰოსტინგის ლიმიტები, ხოლო ჩვენს გზამკვლევებში — რა არის ვებ ჰოსტინგი და როგორ შევამციროთ ჰოსტინგის ხარჯები.
კითხვები
რას ნიშნავს serverless მარტივად რომ ვთქვათ?
Serverless ნიშნავს, რომ კოდს ღრუბლოვან პროვაიდერს აძლევთ და ის მხოლოდ მაშინ გაეშვება, როცა საჭიროა — მაგალითად, როცა მოთხოვნა მოდის — სერვერების დაყენებისა და მოვლის გარეშე. ჩვეულებრივ იხდით იმ დროისთვის, როცა თქვენი კოდი რეალურად მუშაობს, და არა მუდმივად ჩართული მანქანისთვის.
მართლა არ არის სერვერები serverless-ში?
სერვერები არის; თქვენ მხოლოდ არ მართავთ მათ. პროვაიდერი თქვენს კოდს საკუთარ მანქანებზე უშვებს, იწყებს მოთხოვნების მოსვლისას, ზრდის დატვირთვის ქვეშ და თიშავს უმოქმედობისას.
რა არის cold start?
Cold start არის დამატებითი დაყოვნება, როცა serverless ფუნქცია უმოქმედობის შემდეგ მუშაობს, რადგან პროვაიდერს ჯერ ახალი ასლი უნდა გაუშვას. ის შეიძლება თითქმის შეუმჩნეველი იყოს, ან წამი და მეტიც, პლატფორმის, ენისა და კოდის ზომის მიხედვით.
Serverless იაფია ჩვეულებრივ სერვერზე?
აპებისთვის მცირე ან არათანაბარი ტრაფიკით, ხშირად დიახ, რადგან უმოქმედობისას თითქმის არაფერს იხდით. მძიმე, მუდმივი ტრაფიკის მქონე აპებისთვის მუდმივად ჩართული სერვერი შეიძლება იაფი გამოვიდეს. ეს დამოკიდებულია თქვენს გამოყენების ნიმუშსა და პროვაიდერის ფასებზე.
რა არის serverless პლატფორმების მაგალითები?
კარგად ცნობილი მაგალითებია AWS Lambda, Google Cloud Run functions, Azure Functions, Cloudflare Workers, და ჰოსტინგის პლატფორმების, როგორიცაა Vercel და Netlify, ფუნქციების შესაძლებლობები.