สถาปัตยกรรมแบบไร้เซิร์ฟเวอร์

Welcome to Serverless Architectures! This lesson introduces a powerful cloud-native design pattern.

Serverless doesn't mean there are no servers. It means you, as the developer, don't have to manage them. The cloud provider handles all the underlying infrastructure.

With serverless, your main focus shifts from server provisioning and maintenance to writing just your application code.

The cloud provider automatically provisions, scales, and manages the servers needed to run your code. You only pay for the resources consumed during execution.

The most common form of serverless computing is Functions as a Service (FaaS).

• You write small, single-purpose functions.
• These functions are deployed to a FaaS platform.
• They execute only when triggered by an event.

Serverless architectures offer several compelling advantages:

• Reduced Operational Overhead: No server patching or updates.
• Automatic Scaling: Handles traffic spikes effortlessly.
• Cost Efficiency: Pay only for actual compute time, often measured in milliseconds.
• Faster Development: Focus on business logic, not infrastructure.

Many cloud providers offer robust serverless platforms:

• AWS Lambda: Amazon's FaaS offering, widely used.
• Google Cloud Functions: Google's serverless compute service.
• Azure Functions: Microsoft's event-driven serverless platform.

They all provide similar core functionalities, allowing you to run code without managing servers.

Serverless functions are event-driven. This means they are invoked in response to specific events.

Common triggers include:

• HTTP requests (e.g., a web API call)
• Database changes (e.g., a new record inserted)
• File uploads (e.g., to an S3 bucket)
• Scheduled events (e.g., a cron job)

Here's a basic Python function, similar to what you might deploy on AWS Lambda. It's designed to respond to an event.

Serverless architectures are great for many scenarios:

• Web APIs & Backends: Building RESTful APIs quickly.
• Data Processing: Responding to new data uploads or database events.
• Chatbots & IoT: Handling real-time interactions.
• Scheduled Tasks: Running cron jobs without managing servers.

While powerful, serverless has some challenges:

• Cold Starts: Initial delay when a function hasn't been used recently.
• Vendor Lock-in: Architectures can become tied to a specific cloud provider.
• Debugging Complexity: Distributed nature can make debugging harder.
• Resource Limits: Functions have limits on memory, CPU, and execution time.

Let's check your understanding of serverless architectures.

Great job! You've learned about serverless architectures.

• It abstracts away server management.
• FaaS (Functions as a Service) is a core component.
• Offers benefits like auto-scaling, cost-efficiency, and reduced ops.
• Common platforms include AWS Lambda and Google Cloud Functions.
• Functions are event-driven, triggered by various events.
• Considerations include cold starts and vendor lock-in.

On to the next cloud-native pattern!