Muutke küpsiste eelistusi

E-raamat: Learn Microservices with Spring Boot: A Practical Approach to RESTful Services using RabbitMQ, Eureka, Ribbon, Zuul and Cucumber

3.81/5 (56 hinnangut Goodreads-ist)
  • Formaat: PDF+DRM
  • Ilmumisaeg: 08-Dec-2017
  • Kirjastus: APress
  • Keel: eng
  • ISBN-13: 9781484231654
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 34,57 €*
  • * 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.
Learn Microservices with Spring Boot: A Practical Approach to RESTful Services using RabbitMQ, Eureka, Ribbon, Zuul and CucumberSuurem pilt
  • Formaat: PDF+DRM
  • Ilmumisaeg: 08-Dec-2017
  • Kirjastus: APress
  • Keel: eng
  • ISBN-13: 9781484231654
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. 

Build a microservices architecture with Spring Boot, by evolving an application from a small monolith to an event-driven architecture composed of several services. This book follows an incremental approach to teach microservice structure, test-driven development, Eureka, Ribbon, Zuul, and end-to-end tests with Cucumber.

Author Moises Macero follows a very pragmatic approach to explain the benefits of using this type of software architecture, instead of keeping you distracted with theoretical concepts. He covers some of the state-of-the-art techniques in computer programming, from a practical point of view. You’ll focus on what's important, starting with the minimum viable product but keeping the flexibility to evolve it.

What You'll Learn
  • Build microservices with Spring Boot
  • Use event-driven architecture and messaging with RabbitMQ
  • Create RESTful services with Spring
  • Master service discovery with Eureka and load balancing with Ribbon
  • Route requests with Zuul as your API gateway
  • Write end-to-end rests for an event-driven architecture using Cucumber
  • Carry out continuous integration and deployment

Who This Book Is For

Those with at least some prior experience with Java programming. Some prior exposure to Spring Boot recommended but not required.


About the Author ix
About the Technical Reviewer xi
Chapter 1 Introduction
1(8)
Setting the Scene
1(1)
Who Are You?
2(1)
How Is This Book Different from Other Books and Guides?
3(2)
Reasoning Behind the Techniques
3(1)
Learning: An Incremental Process
4(1)
Is This a Guide or a Book?
4(1)
Contents
5(2)
From the Basics to Advanced Topics
5(1)
Skeleton with Spring Boot, the Professional Way
5(1)
Test-Driven Development
6(1)
Connecting Microservices
6(1)
Event-Driven System
6(1)
End-to-End Testing
7(1)
Summary
7(2)
Chapter 2 The Basic Spring Boot Application
9(14)
Business Requirements
9(1)
The Skeleton App
10(3)
Skinny vs. Real-Life Apps
10(1)
Creating the Skeleton
11(2)
Warming Up: Some TDD in Action
13(8)
Summary
21(2)
Chapter 3 A Real Three-Tier Spring Boot Application
23(76)
Introduction
23(3)
Completing the Basics
26(7)
Designing the Domain
33(5)
The Business Logic Layer
38(3)
The Presentation Layer (REST API)
41(12)
The Multiplication Controller
43(5)
The Results Controller
48(5)
The Frontend (Web Client)
53(5)
Playing with the Application (Part I)
58(1)
New Requirements for Data Persistence
59(4)
Refactoring the Code
63(5)
The Data Layer
68(19)
The Data Model
71(6)
The Repositories
77(10)
Completing User Story 2: Going Through the Layers
87(7)
Playing with the Application (Part II)
94(3)
Summary
97(2)
Chapter 4 Starting with Microservices
99(80)
The Small Monolith Approach
99(7)
Analyzing the Monolith
103(2)
Moving Forward
105(1)
Gamification Basics
106(2)
Points, Badges, and Leaderboards
106(1)
Applying It to the Example
107(1)
Moving to a Microservices Architecture
108(2)
Separation of Concerns and Loose Coupling
108(1)
Independent Changes
109(1)
Scalability
109(1)
Connecting Microservices
110(2)
Event-Driven Architecture
112(7)
Related Techniques
113(1)
Pros and Cons of Event-Driven Architecture
114(3)
Further Reading
117(1)
Applying Event-Driven Architecture to the Application
118(1)
Going Event-Driven with RabbitMQ and Spring AMQP
119(2)
Using RabbitMQ in Your System
120(1)
Spring AMQP
121(1)
Sending Events from Multiplication
121(33)
RabbitMQ Configuration
122(3)
Modeling the Event
125(3)
Sending the Event: Dispatcher Pattern
128(6)
Deeper Look at the New Gamification Microservice
134(20)
Receiving Events with RabbitMQ
154(6)
The Subscriber's Side
154(1)
RabbitMQ Configuration
154(3)
The Event Handler
157(3)
Requesting Data Between Microservices
160(13)
Combining Reactive Patterns and REST
160(2)
Keeping Domains Isolated
162(3)
Implementing the REST Client
165(5)
Updating Gamification's Business Logic
170(3)
Playing with the Microservices
173(3)
Summary
176(3)
Chapter 5 The Microservices Journey Through Tools
179(88)
Introduction
179(1)
Extracting the UI and Connecting It to Gamification
180(20)
Moving the Static Content
182(2)
Connecting UI with Gamification
184(3)
Changes to Existing Services
187(3)
A New, Better UI with (Almost) No Effort
190(10)
The Current Architecture
200(2)
Service Discovery and Load Balancing
202(7)
Service Discovery
202(3)
Load Balancing
205(2)
Polyglot Systems, Eureka, and Ribbon
207(2)
Routing with an API Gateway
209(9)
The API Gateway Pattern
209(5)
Zuul, Eureka, and Ribbon Working Together
214(4)
Hands-On Code
218(36)
Implementing the API Gateway with Zuul
218(19)
Playing with Service Discovery
237(4)
Are Our Microservices Ready to Scale?
241(3)
Load Balancing with Ribbon
244(10)
Circuit Breakers and REST Clients
254(9)
Circuit Breakers with Hystrix
254(1)
Hystrix and Zuul
255(3)
Hystrix from a REST Client
258(3)
REST Consumers with Feign
261(2)
Microservices Patterns and PaaS
263(1)
Summary
264(3)
Chapter 6 Testing the Distributed System
267(48)
Introduction
267(2)
Setting the Scene
269(2)
How Cucumber Works
271(2)
Hands-On Code
273(41)
Creating an Empty Project and Choosing the Tools
274(4)
Making the System Testable
278(9)
Writing the First Cucumber Test
287(4)
Linking a Feature to Java Code
291(11)
The Supporting Classes
302(6)
Reusing Steps Across Features
308(3)
Running Tests and Checking Reports
311(3)
Summary
314(1)
Appendix A Upgrading to Spring Boot 2.0
315(8)
Introduction
315(1)
Upgrading the Dependencies
316(3)
Fixing the Breaking Changes
319(2)
The CrudRepository Interface Does Not Include findOne()
319(1)
Actuator Endpoints Have Been Moved
320(1)
Applying Optional Updates
321(1)
The WebMvcConfigurerAdapter Class Has Been Deprecated
321(1)
Working with Spring Boot 2.0
322(1)
Afterword 323(2)
Index 325
Moises Macero has been a software developer since he was a kid.  He has also worked at start-ups where being a full-stack developer is essential.  In his career, Moises has most often worked in development, design and architecture - for small and large projects, and in both agile and "waterfall" environments.  
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97814842316542e.html
Märksõnad: