Rancangan Skalabilitas dan Ketahanan

In this lesson, we'll dive into designing Erlang/OTP applications that are not just functional, but also scalable, resilient, and highly available.

• Scalability: The ability to handle increasing workload by adding resources.
• Resilience: The capacity to recover from failures and maintain functionality.
• High Availability: Ensuring the system is operational for a high percentage of the time.

These are crucial for any modern distributed system.

Erlang and OTP provide powerful primitives that naturally support these design goals:

• Lightweight Processes: Millions can run concurrently, allowing fine-grained isolation.
• Message Passing: Processes communicate asynchronously, preventing shared state issues.
• Fault Tolerance: Supervisors automatically restart failed processes, making systems self-healing.

Understanding these strengths is key to building robust architectures.

Horizontal scaling means adding more machines (nodes) to distribute the workload. Erlang processes are perfect for this.

• Design worker processes to be stateless: they receive input, perform a task, and return output, without holding long-term data.
• This allows any available worker on any node to handle a request, making it easy to add more workers as demand grows.

When your data grows large, keeping it all in one place becomes a bottleneck. Data partitioning involves splitting your data across multiple nodes.

• Each node manages a subset of the data.
• This reduces contention and allows parallel access, significantly improving read and write performance.
• Strategies include hashing data keys or partitioning by ranges.

The Erlang philosophy of 'Let It Crash' is fundamental to resilience. Instead of trying to prevent every possible error, you design systems that expect failures and recover gracefully.

• When a process crashes, its supervisor detects it and restarts it.
• This allows you to focus on the 'happy path' in your code, knowing that OTP will handle the unexpected.

Erlang processes are strongly isolated, meaning one process's failure typically doesn't affect others. You can leverage this to create fault domains.

• Group related processes under a common supervisor.
• If one process in the group fails, the supervisor can restart just that process or the entire group, containing the impact.
• This prevents failures from cascading throughout the entire system.

To achieve high availability, systems need redundancy. If one component fails, another must be ready to take over.

• Active-Passive: One primary component handles requests, with a backup standing by.
• Active-Active: Multiple components simultaneously handle requests, providing both redundancy and load distribution.

Erlang allows you to build sophisticated failover mechanisms using process linking and monitoring.

Erlang supports location transparency, meaning you can call a process without knowing if it's on the local machine or a remote node.

• Processes can be registered with a name (e.g., {local, my_server} or {global, my_global_server}).
• You send messages to the name, and Erlang's distribution mechanism handles routing.

This simplifies distributed programming and makes it easier to move services or implement failover.

Efficiently distributing tasks across available workers is crucial for scalability. In Erlang, you can implement simple load balancing strategies:

• A dedicated dispatcher process receives tasks.
• The dispatcher then forwards tasks to a pool of worker processes, potentially using a round-robin or least-loaded strategy.
• Workers can be local or distributed across different nodes.

Let's see a simple example of a dispatcher distributing tasks to dynamically spawned workers. This illustrates a core pattern for scalability and resilience.

The run/0 function starts the dispatcher and submits a few tasks. Each task gets its own worker.

You've now explored fundamental design patterns and best practices for building scalable, resilient, and highly available systems with Erlang/OTP.

• Leverage Erlang's processes and message passing for concurrent, isolated components.
• Embrace 'Let It Crash' and design fault domains with supervisors.
• Think horizontally, partition data, and use location transparency for flexible distribution.

These principles empower you to build robust applications ready for the demands of distributed environments.