English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 12h 21m | 2.22 GB
Akka in Action shows you how to build message-oriented systems with Akka. This comprehensive, hands-on tutorial introduces each concept with a working example. You’ll start with the big picture of how Akka works, and then quickly build and deploy a fully functional REST service out of actors. You’ll explore test-driven development and deploying and scaling fault-tolerant systems. After mastering the basics, you’ll discover how to model immutable messages, implement domain models, and apply techniques like event sourcing and CQRS. You’ll also find a tutorial on building streaming applications using akka-stream and akka-http. Finally, you’ll get practical advice on how to customize and extend your Akka system.
Akka makes it relatively easy to build applications in the cloud or on devices with many cores that efficiently use the full capacity of the computing power available. It’s a toolkit that provides an actor programming model, a runtime, and required support tools for building scalable applications.
Inside:
- Getting concurrency right
- Testing and performance tuning
- Clustered and cloud-based applications
- Covers Akka version 2.4
This book/course assumes that you’re comfortable with Java and Scala. No prior experience with Akka required.
Table of Contents
1 Introducing Akka
2 What is Akka
3 Traditional scaling
4 Traditional scaling and interactive use – polling
5 Scaling with Akka
6 Scaling with Akka and failure – asynchronous decoupling
7 Actors – one programming model to rule up and out
8 Actor operations
9 Akka actors
10 Up and running
11 Fast-forward to the GoTicks.com REST server
12 Structure of the app
13 The actor that handles the sale – TicketSeller
14 Into the cloud
15 Test-driven development with actors
16 One-way messages
17 SendingActor example
18 SideEffectingActor example
19 Fault tolerance
20 Plain old objects and exceptions
21 Let it crash
22 Actor lifecycle
23 Restart event
24 Supervision
25 Predefined strategies
26 Custom strategies
27 Futures
28 In the future nobody blocks
29 Promises are promises
30 Futuristic errors
31 Combining futures
32 Combining futures with actors
33 Your first distributed Akka app
34 Reasons for a distributed programming model
35 Making the GoTicks.com app distributed
36 Remote lookup
37 Remote deployment
38 Multi-JVM testing
39 Summary
40 Configuration, logging, and deployment
41 Using defaults
42 Akka configuration
43 Logging
44 Deploying actor-based applications
45 Structural patterns for actors
46 Pipes and filters in Akka
47 Enterprise integration pattern – scatter-gather
48 Implementing the gather component with the aggregator pattern
49 Enterprise integration pattern – routing slip
50 Routing messages
51 Balance load using Akka routers
52 Akka pool router
53 Akka pool router
54 Akka group router
55 ConsistentHashing router
56 Implementing the router pattern using actors
57 Message channels
58 Publish-subscribe
59 Publish-subscribe
60 Specialized channels
61 Guaranteed delivery
62 Summary
63 Finite-state machines and agents
64 Implementation of an FSM model
65 Implementing the entry actions
66 Timers within FSM
67 Implement shared state using agents
68 Waiting for the state update
69 System integration
70 Normalizer
71 Implementing endpoints using Apache Camel
72 Implement a consumer endpoint receiving messages from an external system
73 Implement a producer endpoint sending messages to an external system
74 Implementing an HTTP interface
75 Implementing a REST endpoint with akka-http
76 Streaming
77 Copying files with sources and sinks
78 Materializing runnable graphs
79 Processing events with flows
80 Handling errors in streams
81 Streaming HTTP
82 Custom marshallers and unmarshallers for content type and negotiation
83 Fan in and fan out with the graph DSL
84 Merging flows
85 Mediating between producers and consumers
86 Rate-detaching parts of a graph
87 Clustering
88 Cluster membership
89 Leaving the cluster
90 Clustered job processing
91 Work distribution using routers
92 Resilient jobs
93 Testing the cluster
94 Summary
95 Actor persistence
96 Persisting state without updates
97 Persistent actors
98 Testing
99 Persistence query
100 Serialization
101 Clustered persistence
102 Cluster sharding
103 Performance tips
104 Performance parameters
105 Performance measurement of actors
106 Performance measurement of actors
107 Collecting processing data
108 Improving performance by addressing bottlenecks
109 Configure dispatcher
110 Changing thread pool size statically
111 Using a dynamic thread pool size
112 Changing thread releasing
113 Looking ahead
114 Akka Distributed Data
Resolve the captcha to access the links!