What types of services exist and how do they operate at a low level?

There are several main types of services in the context of microservices architecture and distributed systems:

• Monolithic applications: A single, indivisible codebase containing all application functionality.
• Microservices: A set of small, independent services, each implementing specific business logic. They interact via APIs.
• Serverless: A computing model where the cloud provider dynamically manages resource allocation and scaling. Developers focus only on function code.

At a low level, operation looks like this:

Monolithic:

Runs as a single process. All components are loaded into memory simultaneously. Interaction between components occurs through function or method calls within the same address space. Fault tolerance is achieved through whole monolith redundancy. Scaling is difficult, requiring scaling of the entire application instance. Resource usage is often redundant.

Microservices:

Each microservice is a separate process or set of processes. It runs in its isolated environment (container, virtual machine). Interaction occurs over the network, usually via HTTP/gRPC based on synchronous or asynchronous protocols (e.g., RabbitMQ, Kafka for asynchrony). Each service can have its own technology stack and database. Scaling occurs independently for each service. High fault tolerance is provided (failure of one service does not affect others), and resource utilization is better. Management is more complex (requires Service Discovery, API Gateway, distributed logging, and monitoring).

Example of network interaction between microservices:

// Request to Service A
GET /users/123 HTTP/1.1
Host: service-a.example.com

// Response from Service A
HTTP/1.1 200 OK
Content-Type: application/json

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

Serverless:

Function code is deployed in a cloud environment. The cloud provider runs the function code in response to specific events (HTTP requests, queue messages, database changes). Infrastructure (servers, OS) is managed by the provider. Functions are usually short-lived and stateless (no state preservation between calls). Scaling is automatic, based on the number of events. Payment is based on resource consumption (number of executions, runtime). At a low level, the provider uses containers or virtual machines for isolation and execution, but this level is abstracted from the user.

Example of a Serverless function (AWS Lambda):

# Simple Lambda function
import json

def lambda_handler(event, context):
    # Process incoming event
    # Execute logic
    response_body = {
        "message": "Hello from Lambda!",
        "input": event
    }

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

Comparison table:

Characteristic	Monolithic	Microservices	Serverless
Architecture	Single codebase	Independent services	Functions managed by events
Deployment	Single process	Independent for each service	Managed by provider
Scaling	Horizontal (cloning)	Independent for each service	Automatic, event-based
Fault tolerance	Low	High (isolated)	High (built-in)
Resource utilization	Partially redundant	More efficient	Pay for consumption
Management complexity	Low	High	Low (for infrastructure)
Communication	Intra-process	Over network (API, messages)	Through provider events