რა სახის სერვისები არსებობს და როგორ მუშაობენ დაბალ დონეზე?

მიკროსერვისებისა და გავრცელებული სისტემების კონტექსტში არსებობს რამდენიმე ძირითადი ტიპის სერვისი:

• მონოლითური პროგრამები: ერთიანი, განყოფილებადი კოდის ბაზა, რომელიც შეიცავს პროგრამის ყველა ფუნქციონალს.
• მიკროსერვისები: პატარა, დამოუკიდებელი სერვისების ნაკრები, თითოეული მათგანი ახორციელებს გარკვეულ ბიზნეს ლოგიკას. ურთიერთქმედება ხდება API-ის საშუალებით.
• Serverless (სერვერლესს): ღრუბლოვანი პროვაიდერი დინამიურად მართავს რესურსების განაწილებას და მასშტაბირებას. დეველოპერი კონცენტრირებულია მხოლოდ ფუნქციების კოდზე.

მცირე დონეზე მუშაობა ასე გამოიყურება:

მონოლითი:

მუშაობს როგორც ერთიანი პროცესი. ყველა კომპონენტი ერთდროულად იტვირთება მეხსიერებაში. ურთიერთქმედება ხდება ფუნქციების ან მეთოდების გამოძახილებით ერთ მისამართის სივრცეში. გამძლეობა უზრუნველყოფილია მთლიანი მონოლიტის რეზერვირებით. მასშტაბირება რთულია, საჭიროა მთელი აპლიკაციის გაზრდა. რესურსების გამოყენება ხშირად ზედმეტია:

მიკროსერვისები:

ყოველი მიკროსერვისი — ცალკე პროცესი ან პროცესების ნაკრები. მუშაობს თავის იზოლირებულ გარემოში (კონტეინერი, ვირტუალური მანქანა). ურთიერთქმედება ხდება ქსელით, ჩვეულებრივ HTTP/gRPC-ის საშუალებით — სინქრონული და ასინქრონული პროტოკოლებით (მაგ., RabbitMQ, Kafka). თითოეულ სერვისს შეიძლება ჰქონდეს თავისი ტექნოლოგიური სტაკი და მონაცემთა ბაზა. მასშტაბირება ხდება დამოუკიდებლად თითოეულ სერვისზე. უზრუნველყოფს მაღალი გამძლეობას (ერთი სერვისის გაუქმება არ ზეგავლენას ახდენს სხვებზე), რესურსების ეფექტიან გამოყენებას. მართვა რთულია (Service Discovery, API Gateway, ლოგირება და მონიტორინგი საჭიროა).

მიკროსერვისების ქსელური ურთიერთქმედების მაგალითი:

// სერვის A-სთვის მოთხოვნა
GET /users/123 HTTP/1.1
Host: service-a.example.com

// პასუხი სერვის A-დან
HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 123,
  "username": "testuser"
}

Serverless:

ფუნქციის კოდი განთავსებულია ღრუბლოვან გარემოში. ღრუბლოვანი პროვაიდერი ამუშავებს ფუნქციას გარკვეული მოვლენების (HTTP-შეკვეთები, რიგის შეტყობინებები, მონაცემთა ბაზის ცვლილებები) პასუხად. ინფრასტრუქტურას (სერვერები, ოპერაციული სისტემა) მართავს პროვაიდერი. ფუნქციები ჩვეულებრივ მოკლე ხანგრძლივობის და stateless-ია (არ ინახავს მდგომარეობას). მასშტაბირება ავტომატურად ხდება, მოვლენების რაოდენობის მიხედვით. გადახდა ხდება რესურსების გამოყენების მიხედვით (შესრულების რაოდენობა, მუშაობის დრო). ქვედა დონეზე პროვაიდერი იყენებს კონტეინერებს ან ვირტუალურ მანქანებს ფუნქციების იზოლაციისა და შესრულებისთვის, მაგრამ ეს დონე დამალულია მომხმარებლისთვის:

AWS Lambda-ის მაგალითი — Serverless ფუნქცია:

# მარტივი Lambda ფუნქცია
import json

def lambda_handler(event, context):
    # შემოსული მოვლენის დამუშავება
    # ლოგიკის შესრულება
    response_body = {
        "message": "Hello from Lambda!",
        "input": event
    }

    return {
        "statusCode": 200,
        "body": json.dumps(response_body)
    }

შედარებითი სია:

მახასიათებელი	მონოლითი	მიკროსერვისები	Serverless
არქიტექტურა	ერთიანი კოდის ბაზა	დამოუკიდებელი სერვისები	ფუნქციები, რომლებიც მართავს მოვლენები
განთავსება	ერთიანი პროცესი	თითოეული სერვისისთვის დამოუკიდებელი	პროვაიდერის მიერ მართვა
მასშტაბირება	ჰორიზონტალური (კოპირება)	თითოეული სერვისისთვის დამოუკიდებელი	ავტომატური, მოვლენებზე დაფუძნებული
გამძლეობა	დაბალი	მაღალი (გამოყოფილია)	მაღალი (შენიღბულია)
რესურსების გამოყენება	ზოგჯერ ზედმეტია	უფრო ეფექტიანი	გამოყენების მიხედვით გადახდა
მართვის სირთულე	დაბალი	მაღალი	დაბალი (ინფრასტრუქტურისთვის)
კომუნიკაცია	პროცესის შიგნით	ქსელით (API, შეტყობინებები)	მოვლენების საშუალებით