Muutke küpsiste eelistusi

E-raamat: Reactive Applications with Akka.NET

3.77/5 (26 hinnangut Goodreads-ist)
  • Formaat: 280 pages
  • Ilmumisaeg: 05-Mar-2019
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638355656
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 41,07 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Reactive Applications with Akka.NETSuurem pilt
  • Formaat: 280 pages
  • Ilmumisaeg: 05-Mar-2019
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638355656
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Developing applications in a reactive style ensures that the experience

is always responsive. Akka.NET is a framework for building

distributed, message-driven applications which are able to stay

responsive for the user even in the face of failure or when faced with

more users. It makes it easy for .NET developers to write applications

which are able to react to changes in their environment.

 

Reactive Applications with Akka.NET begins with an overview of  

reactive and a sample application written in the reactive style. Readers

will learn concepts of the actor model and what these mean in a realworld

reactive context. This hands-on book builds on fundamental

concepts that teach how to create reliable and resilient applications. It

also teaches useful Akka.NET features for building real-world

applications. By the end of the book, readers will be able to look at a

problem domain and understand how to create applications which are

able to withstand modern demands.

 

Key features:

 

Hands-on examples that build on fundamental concepts  

 

Building real-world applications with Akka.NET  

 

Designing an Internet of Things architecture with reactive in  

mind

 

How to create applications that can withstand modern demands  

 

   

AUDIENCE

Readers should be comfortable with C# or F# and the .NET framework. No

previous reactive experience needed.

 

ABOUT THE TECHNOLOGY

Developing applications in a reactive style ensures that the experience is

always responsive. Akka.NET is a framework for building distributed,

message-driven applications which are able to stay responsive for the user

even in the face of failure or when faced with more users.
Preface xi
Acknowledgments xii
About This Book xiii
About The Author xvi
About The Cover Illustration xvii
Part 1: The Road To Reactive
1 Why reactive?
3(8)
1.1 The heart of the Reactive Manifesto
4(2)
1.2 Reactive systems vs. reactive programming
6(1)
1.3 Applying Akka.NET
7(1)
Where to use Akka.NET
7(1)
Where not to use Akka.NET
8(1)
1.4 How does Akka.NET work?
8(3)
2 Reactive application design
11(12)
2.1 Basic reactive system design
12(1)
2.2 Reactive e-commerce application with actors
13(6)
A reactive shopping cart
13(2)
Changing states of actors
15(1)
Making the purchase
15(1)
Data transfer between services
16(1)
Scaling work with routers
17(1)
Wrapping up
18(1)
2.3 Building on reactive foundations
19(6)
Publishing the e-commerce application to the world
19(1)
Storing state within actors
20(1)
Scaling out across a cluster of machines
20(1)
Continuing to react to environmental changes
20(1)
Wrapping up
21(2)
Part 2: Digging In 23(126)
3 Your first Akka.NET application
25(18)
3.1 Setting up an application
26(1)
3.2 Actors
26(7)
What does an actor embody?
26(2)
What can an actor do?
28(1)
Defining an actor
29(4)
Wrapping up
33(1)
3.3 Deploying an actor
33(3)
The actor system
33(2)
Spawning an actor
35(1)
Wrapping up
36(1)
3.4 Communicating with actors
36(4)
Actor addresses and references
37(2)
Sending a message
39(1)
Wrapping up
40(1)
3.5 Case study: Actors, concurrency, and phone billing
40(3)
4 State, behavior, and actors
43(16)
4.1 Preparing for the next message
44(1)
4.2 Setting appropriate runtime behaviors
44(3)
Switchable behaviors
45(1)
Become and unbecome
45(2)
Wrapping up
47(1)
4.3 Finite state machines
47(10)
Understanding finite state machines
48(2)
Using finite state machines in a concurrency model
50(2)
Converting a finite state machine into an actor
52(2)
Using the finite state machine actor
54(3)
Wrapping up
57(1)
4.4 Case study: State machines, states and events, marketing analytics campaign
57(2)
5 Configuration, dependency injection, and logging
59(17)
5.1 Why do you need configuration?
60(1)
5.2 Configuring an actor deployment
60(4)
Understanding Props
61(2)
Wrapping up
63(1)
5.3 Dependency injection (DI)
64(3)
Introducing dependency injection
64(2)
Configuring a DI container
66(1)
Wrapping up
67(1)
5.4 C8onfiguring with HOCON
67(3)
What is HOCON?
67(2)
Loading configuration into an actor system
69(1)
Wrapping up
70(1)
5.5 Logging
70(3)
Why do you need logging?
70(1)
Writing to the log
71(1)
Customizing a logger deployment
72(1)
Wrapping up
73(1)
5.6 Case study: Configuration and distributed systems
73(3)
6 Failure handling
76(27)
6.1 Understanding failures
77(1)
6.2 Handling application-level failures
78(18)
Responding to application errors
79(2)
The Akka.NET supervision tree
81(5)
Failing fast
86(2)
The actor lifecycle
88(3)
Watching for the deaths of other actors
91(3)
Interface-level failures
94(1)
Wrapping up
95(1)
6.3 Understanding transport-level failures
96(5)
Writing applications that handle message loss
97(4)
Wrapping up
101(1)
6.4 Case study: Supervision, failure, chat hots
101(2)
7 Scaling in reactive systems
103(24)
7.1 Scaling up and scaling out
104(2)
7.2 Distributing work
106(5)
Routers
106(3)
Pools and groups
109(2)
Wrapping up
111(1)
7.3 Routing strategies
111(14)
Random routing
112(1)
Round-robin routing
113(1)
Smallest-mailbox router
114(2)
Consistent hashing
116(4)
Scatter-gather first-completed
120(2)
Tail-chopping router
122(2)
Wrapping up
124(1)
7.4 Case 8 study: Scaling, throughput, advertising systems
125(2)
8 Composing actor systems
127(22)
8.1 Introducing Akka.NET remoting
129(1)
8.2 Preparing to use remoting
130(2)
Installing Akka.Remote
130(1)
Configuring remoting for a project
130(2)
8.3 Communicating with remote actors
132(5)
Sending messages to remote actors
133(2)
Remote deployment of actors
135(2)
Wrapping up
137(1)
8.4 Elastic scale across machines
137(3)
Configuring a router to use multiple machines
138(2)
Wrapping up
140(1)
8.5 Failure handling across machines
140(3)
Supervisor strategies across a network
141(1)
Remoting DeathWatch
142(1)
Wrapping up
143(1)
8.6 Akka.Remote security
143(4)
Limiting messages that can be sent over the network
144(1)
Restricting available remote actor targets
144(3)
Wrapping up
147(1)
8.7 Case study: Remoting, network applications, web server, and backend server
147(2)
PART 3: Real-Life Usage 149(102)
9 Testing Akka.NET actors
151(22)
9.1 Introducing Akka.TestKit
153(1)
9.2 Unit testing actors
154(4)
Spawning test actors
155(1)
Validating internal data
156(1)
Testing FSMs
157(1)
Wrapping up
158(1)
9.3 Integration testing actors
158(6)
Creating test specifications
158(1)
Asserting message responses
159(2)
Time-based testing
161(2)
Test probes
163(1)
Wrapping up
164(1)
9.4 Testing distributed applications with MultiNode TestKit
164(7)
MultiNode specs
165(2)
Testing individual actor systems
167(1)
Barriers
168(1)
Testing for network failure
169(2)
Wrapping up
171(1)
9.5 Case study: Testing, test-driven development, unit testing
171(2)
10 Integrating Akka.NET
173(19)
10.1 Integrating with ASP.NET
175(4)
10.2 Integrating with SignalR
179(5)
Communicating through an actor
180(2)
Connecting to the user's web browser
182(2)
Wrapping up
184(1)
10.3 Custom integrations with akka.io
184(6)
Creating a listening socket
185(3)
Sending data through akka.io
188(2)
Wrapping up
190(1)
10.4 Case study: IO, integration, IoT applications
190(2)
11 Storing actor state with Akka.Persistence
192(22)
11.1 Understanding event sourcing
193(2)
11.2 Using Akka.Persistence
195(6)
persistent actors
195(4)
Configuring a journal
199(2)
Wrapping up
201(1)
11.3 Akka.Persistence performance tuning
201(3)
Snapshot stores
201(2)
Async write journals
203(1)
Wrapping up
204(1)
11.4 Akka.Persistence performance tuning
204(8)
At-least-once delivery
204(4)
Upgrade strategies for applications using event sourcing
208(4)
Wrapping up
212(1)
11.5 Case study: Persistence, storage, staged upgrades
212(2)
12 Building clustered applications with Akka.Cluster
214(29)
12.1 Introducing Akka.Cluster
215(4)
12.2 Cluster-aware routers
219(4)
Creating cluster-aware router groups
219(3)
Creating cluster-aware router pools
222(1)
Wrapping up
223(1)
12.3 Working with cluster gossip
223(2)
Retrieving cluster state
224(1)
Handling cluster gossip messages
224(1)
Wrapping up
225(1)
12.4 Cluster singleton
225(3)
Wrapping up
228(1)
12.5 Cluster sharding
228(5)
Creating a new shard
229(3)
Communicating with actors in a shard
232(1)
Handling passivation in shards
233(1)
Wrapping up
233(1)
12.6 Distributed publish-subscribe
233(5)
Topic messaging
234(2)
Point-to-point messaging
236(1)
Wrapping up
237(1)
12.7 Cluster client
238(3)
12.8 Case study: Clustering, scaling, cluster management
241(2)
13 Akka.NET and reactive programming in production
243(8)
13.1 Designing with actors
244(1)
13.2 Handling failure
245(1)
13.3 Designing for scale
246(1)
13.4 Handling configuration
247(1)
13.5 Ingesting data
247(1)
13.6 Testing
248(1)
13.7 Real-time integration
249(1)
13.8 Data persistence
249(1)
13.9 Cluster scale-out
250(1)
13.10 Conclusion
250(1)
Index 251
Anthony Brown has been developing software for several years, primarily



using the .NET framework. Hes a regular speaker at conferences on tools

and techniques to rapidly build systems that work.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97816383556566e.html
Märksõnad: