All chapters now available: Designing for Scalability with Erlang/OTP
Chapters 13-16 of the book “Designing for Scalability with Erlang/OTP – Implement Robust, Available, Fault-Tolerant Systems” are now available.
Designing for Scalability with Erlang/OTP
Implement Robust, Available, Fault-Tolerant Systems
By Francesco Cesarini, Steve Vinoski
Publisher: O’Reilly Media
With Early Release ebooks, you get books in their earliest form—the author’s raw and unedited content as he or she writes—so you can take advantage of these technologies long before the official release of these titles. You’ll also receive updates when significant changes are made, new chapters as they’re written, and the final ebook bundle.
Design and build complex, scalable commercial-grade systems with the Open Telecom Platform (OTP), the open source system developed by Ericsson and written in Erlang. With this hands-on book, you’ll learn how to apply OTP libraries and techniques to develop concurrent, fault-tolerant systems with no single point of failure.
Written by the authors of O’Reilly’s Erlang Programming, including a member of OTP’s R1 release team, this guide takes you through the basics of OTP and Erlang Design Patterns, and demonstrates how the platform can be used in a wide range of industries. If you have Erlang experience, you’ll learn how to overcome key obstacles in OTP that have thwarted many other developers.
13 Distributed Architectures
Previous chapters have described the implementation of a single, simple node. A node is the smallest executable standalone unit consisting of a running instance of
the Erlang runtime system. In this chapter we’ll show how to expand to wider collections of code. We’ll try to help you achieve availability, scalability, and consistency
across nodes. These qualities go hand in hand with reliability, which ensures that your system behaves correctly even under abnormal circumstances such as failure or
14 Systems that Never Stop
In this chapter, we continue explaining approaches to distributed programming commonly used in Erlang systems. We focus on data replication and retry strategies across nodes and computers, and the compromises and trade-offs needed to build systems that never stop. These approaches affect how you distribute your data and how you retry executing requests if they have failed for reasons out of your control.
15 Scaling Out
In this chapter, we follow on from the distributed programming patterns and recovery and data sharing patterns described in Chapter 13 and Chapter 14, focusing on the scalability trade-offs you took when designing your architecture. We describe the tests needed to understand your system’s limitations and ensure it can handle, without failing, the capacity for which it was designed. This allows you to put safeguards in place, ensuring users do not overflow the system with requests that can’t be handled. The last thing you want to deal with when under heavy load is a node crash, the degradation of throughput, or a service provider or third party API not responding as a result of the wrath of Erlang being unleashed upon it.
16 Monitoring and Preemptive support
If you have read this far, you must really be out to impress everyone with a system that is not only scalable and reliable, but also highly available. With the right tools and approach, the five nines once reserved for Telecom systems are now easily attainable in whatever other vertical for which you might be developing software. But implementing everything described in the previous chapters is not enough. Just as important as resilient software, redundant hardware, networks, power supplies and multiple data centers, your secret sauce to high availability is achieving a high level of visibility into what is going on in your system, reacting on the information you collect. In this chapter, we cover approaches to monitoring and preemptive support, introducing some of the most common support automation approaches.
Available on O’Reilly. Use the code authd to get a 50% discount.