Designing for Scalability with Erlang/OTP. Implement Robust, Fault-Tolerant Systems - Helion

ebook

Autor: Francesco Cesarini, Steve Vinoski
ISBN: 978-14-493-6156-3
stron: 482, Format: ebook
Data wydania: 2016-05-16
Księgarnia: Helion

Cena książki: 152,15 zł (poprzednio: 176,92 zł)
Oszczędzasz: 14% (-24,77 zł)

Osoby, które kupiły tę książkę, wybierały także »

Tagi: Inne

If you need to build a scalable, fault tolerant system with requirements for high availability, discover why the Erlang/OTP platform stands out for the breadth, depth, and consistency of its features. This hands-on guide demonstrates how to use the Erlang programming language and its OTP framework of reusable libraries, tools, and design principles to develop complex commercial-grade systems that simply cannot fail.

In the first part of the book, you’ll learn how to design and implement process behaviors and supervision trees with Erlang/OTP, and bundle them into standalone nodes. The second part addresses reliability, scalability, and high availability in your overall system design. If you’re familiar with Erlang, this book will help you understand the design choices and trade-offs necessary to keep your system running.

Explore OTP’s building blocks: the Erlang language, tools and libraries collection, and its abstract principles and design rules
Dive into the fundamentals of OTP reusable frameworks: the Erlang process structures OTP uses for behaviors
Understand how OTP behaviors support client-server structures, finite state machine patterns, event handling, and runtime/code integration
Write your own behaviors and special processes
Use OTP’s tools, techniques, and architectures to handle deployment, monitoring, and operations

Osoby które kupowały "Designing for Scalability with Erlang/OTP. Implement Robust, Fault-Tolerant Systems", wybierały także:

Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
Mapa Agile & Scrum. Jak si 57,69 zł, (15,00 zł -74%)
Lean dla bystrzaków. Wydanie II 49,62 zł, (12,90 zł -74%)
Gra bez końca 47,78 zł, (12,90 zł -73%)

Spis treści

Designing for Scalability with Erlang/OTP. Implement Robust, Fault-Tolerant Systems eBook -- spis treści

Preface
- Francesco: Why This Book?
- Steve: Why This Book?
- Who Should Read This Book
- How To Read This Book
- Acknowledgments
- Conventions Used in This Book
- Using Code Examples
- Safari Books Online
- How to Contact Us
1. Introduction
- Defining the Problem
- OTP
  - Erlang
  - Tools and Libraries
  - System Design Principles
  - Erlang Nodes
- Distribution, Infrastructure, and Multicore
- Summing Up
- What Youll Learn in This Book
2. Introducing Erlang
- Recursion and Pattern Matching
- Functional Influence
  - Fun with Anonymous Functions
  - List Comprehensions: Generate and Test
- Processes and Message Passing
- Fail Safe!
- Links and Monitors for Supervision
  - Links
  - Monitors
- Records
- Maps
- Macros
- Upgrading Modules
- ETS: Erlang Term Storage
- Distributed Erlang
  - Naming and Communication
  - Node Connections and Visibility
- Summing Up
- Whats Next?
3. Behaviors
- Process Skeletons
- Design Patterns
  - Callback Modules
- Extracting Generic Behaviors
  - Starting the Server
  - The Client Functions
  - The Server Loop
  - Functions Internal to the Server
- The Generic Server
- Message Passing: Under the Hood
- Summing Up
- Whats Next?
4. Generic Servers
- Generic Servers
- Behavior Directives
- Starting a Server
- Message Passing
  - Synchronous Message Passing
  - Asynchronous Message Passing
  - Other Messages
  - Unhandled Messages
  - Synchronizing Clients
- Termination
- Call Timeouts
  - Deadlocks
- Generic Server Timeouts
  - Hibernating Behaviors
- Going Global
- Linking Behaviors
- Summing Up
- Whats Next?
5. Controlling OTP Behaviors
- The sys Module
  - Tracing and Logging
  - System Messages
  - Your Own Trace Functions
  - Statistics, Status, and State
  - The sys Module Recap
- Spawn Options
  - Memory Management and Garbage Collection
    - Process heap
    - Virtual binary heap
    - Full sweep of the heap
  - Spawn Options to Avoid
  - Timeouts
- Summing Up
- Whats Next?
6. Finite State Machines
- Finite State Machines the Erlang Way
- Coffee FSM
  - The Hardware Stub
  - The Erlang Coffee Machine
    - Starting
    - The events
    - The selection state
    - The payment state
    - The remove state
- Generic FSMs
- A Behavior Example
  - Starting the FSM
  - Sending Events
    - Asynchronous events
    - Defining states
    - Timeouts
    - Asynchronous events to all states
    - Synchronous events
  - Termination
- Summing Up
- Get Your Hands Dirty
  - The Phone Controllers
  - Lets Test It
- Whats Next?
7. Event Handlers
- Events
- Generic Event Managers and Handlers
  - Starting and Stopping Event Managers
  - Adding Event Handlers
  - Deleting an Event Handler
  - Sending Synchronous and Asynchronous Events
  - Retrieving Data
  - Handling Errors and Invalid Return Values
  - Swapping Event Handlers
  - Wrapping It All Up
- The SASL Alarm Handler
- Summing Up
- Whats Next?
8. Supervisors
- Supervision Trees
- OTP Supervisors
  - The Supervisor Behavior
  - Starting the Supervisor
  - The Supervisor Specification
    - The restart specification
    - The child specification
  - Dynamic Children
    - Simple one for one
    - Gluing it all together
  - Non-OTP-Compliant Processes
    - Supervisor bridges
    - Adding non-OTP-compliant processes
  - Scalability and Short-Lived Processes
  - Synchronous Starts for Determinism
  - Testing Your Supervision Strategy
- How Does This Compare?
- Summing Up
- Whats Next?
9. Applications
- How Applications Run
- The Application Structure
- The Callback Module
  - Starting and Stopping Applications
- Application Resource Files
  - The Base Station Controller Application File
- Starting an Application
- Environment Variables
- Application Types and Termination Strategies
- Distributed Applications
- Start Phases
- Included Applications
  - Start Phases in Included Applications
- Combining Supervisors and Applications
- The SASL Application
  - Progress Reports
  - Error Reports
  - Crash Reports
  - Supervisor Reports
- Summing Up
- Whats Next?
10. Special Processes and Your Own Behaviors
- Special Processes
  - The Mutex
  - Starting Special Processes
    - Basic template for starting a special process
    - Asynchronously starting a special process
  - The Mutex States
  - Handling Exits
  - System Messages
  - Trace and Log Events
  - Putting It Together
  - Dynamic Modules and Hibernating
- Your Own Behaviors
  - Rules for Creating Behaviors
  - An Example Handling TCP Streams
- Summing Up
- Whats Next?
11. System Principles and Release Handling
- System Principles
  - Release Directory Structure
  - Release Resource Files
  - Creating a Release
  - Creating the Boot File
    - Script files
    - The make_script parameters
  - Creating a Release Package
  - Start Scripts and Configuring on the Target
  - Arguments and Flags
    - Heart
    - The Erlang loader
  - The init Module
- Rebar3
  - Generating a Rebar3 Release Project
  - Creating a Release with Rebar3
  - Rebar3 Releases with Project Dependencies
- Wrapping Up
- Whats Next?
12. Release Upgrades
- Software Upgrades
  - The First Version of the Coffee FSM
  - Adding a State
- Creating a Release Upgrade
  - The Code to Upgrade
  - Application Upgrade Files
  - High-Level Instructions
  - Release Upgrade Files
  - Low-Level Instructions
  - Installing an Upgrade
  - The Release Handler
  - Upgrading Environment Variables
- Upgrading Special Processes
- Upgrading in Distributed Environments
- Upgrading the Emulator and Core Applications
- Upgrades with Rebar3
- Summing Up
- Whats Next?
13. Distributed Architectures
- Node Types and Families
- Networking
  - Distributed Erlang
    - Riak Core
    - Scalable Distributed Erlang
  - Sockets and SSL
  - Service Orientation and Microservices
  - Peer to Peer
- Interfaces
- Summing Up
- Whats Next?
14. Systems That Never Stop
- Availability
  - Fault Tolerance
  - Resilience
  - Reliability
    - At most once, exactly once, and at least once
  - Sharing Data
    - Share nothing
    - Share something
    - Share everything
  - Tradeoffs Between Consistency and Availability
- Summing Up
- Whats Next?
15. Scaling Out
- Horizontal and Vertical Scaling
- Capacity Planning
  - Capacity Testing
    - Generating load
  - Balancing Your System
  - Finding Bottlenecks
    - Synchronous versus asynchronous calls
  - System Blueprints
- Load Regulation and Backpressure
- Summing Up
- Whats Next?
16. Monitoring and Preemptive Support
- Monitoring
  - Logs
  - Metrics
  - Alarms
- Preemptive Support
- Summing Up
- Whats Next?
Index