book

Vert.x in Action

Name: Vert.x in Action
Author: Julien Ponge
ISBN: 9781617295621

by Julien Ponge

November 2020

Intermediate to advanced

336 pages

9h 3m

English

Manning Publications

Read now

Unlock full access

Vert.x in Action
Copyright
dedication
brief contents
contents
front matter
forewordprefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A roadmapAbout the codeliveBook discussion forumabout the authorabout the cover illustration
Part 1. Fundamentals of asynchronous programming with Vert.x
1 Vert.x, asynchronous programming, and reactive systems
1.1 Being distributed and networked is the norm1.2 Not living on an isolated island1.3 There is no free lunch on the network1.4 The simplicity of blocking APIs1.5 Blocking APIs waste resources, increase costs1.6 Asynchronous programming with non-blocking I/O1.7 Multiplexing event-driven processing: The case of the event loop1.8 What is a reactive system?1.9 What else does reactive mean?1.10 What is Vert.x?1.11 Your first Vert.x application1.11.1 Preparing the project1.11.2 The VertxEcho class1.11.3 The role of callbacks1.11.4 So is this a reactive application?1.12 What are the alternatives to Vert.x?Summary
2 Verticles: The basic processing units of Vert.x
2.1 Writing a verticle2.1.1 Preparing the project2.1.2 The verticle class2.1.3 Running and first observations2.2 More on verticles2.2.1 Blocking and the event loop2.2.2 Asynchronous notification of life-cycle events2.2.3 Deploying verticles2.2.4 Passing configuration data2.3 When code needs to block2.3.1 Worker verticles2.3.2 The executeBlocking operation2.4 So what is really in a verticle?2.4.1 Verticles and their environment2.4.2 More on contexts2.4.3 Bridging Vert.x and non-Vert.x threading modelsSummary
3 Event bus: The backbone of a Vert.x application
3.1 What is the event bus?3.1.1 Is the event bus just another message broker?3.1.2 Point-to-point messaging3.1.3 Request-reply messaging3.1.4 Publish/subscribe messaging3.2 The event bus in an example3.2.1 Heat sensor verticle3.2.2 Listener verticle3.2.3 Sensor data verticle3.2.4 HTTP server verticle3.2.5 Bootstrapping the application3.3 Clustering and the distributed event bus3.3.1 Clustering in Vert.x3.3.2 From event bus to distributed event busSummary

4 Asynchronous data and event streams
4.1 Unified stream model4.2 What is back-pressure?4.3 Making a music-streaming jukebox4.3.1 Features and usage4.3.2 HTTP processing: The big picture4.3.3 Jukebox verticle basics4.3.4 Incoming HTTP connections4.3.5 Downloading as efficiently as possible4.3.6 Reading MP3 files, but not too fast4.4 Parsing simple streams4.5 Parsing complex streams4.6 A quick note on the stream fetch modeSummary
5 Beyond callbacks
5.1 Composing asynchronous operations: The edge service example5.1.1 Scenario5.1.2 Heat sensor verticles5.1.3 Snapshot service verticle5.2 Callbacks5.2.1 Implementation5.2.2 Running5.2.3 The “callback hell” is not the problem5.3 Futures and promises5.3.1 Futures and promises in Vert.x5.3.2 Future-based APIs in Vert.x 45.3.3 Interoperability with CompletionStage APIs5.3.4 Collector service with Vert.x futures5.4 Reactive extensions5.4.1 RxJava in a nutshell5.4.2 RxJava and Vert.x5.4.3 Collector service in RxJava5.5 Kotlin coroutines5.5.1 What is a coroutine?5.5.2 Vert.x and Kotlin coroutines5.5.3 Edge service with coroutines5.6 Which model should I use?Summary
6 Beyond the event bus
6.1 Revisiting heat sensors with a service API6.2 Return of the RPCs (remote procedure calls)6.3 Defining a service interface6.4 Service implementation6.5 Enabling proxy code generation6.6 Deploying event-bus services6.7 Service proxies beyond callbacks6.8 Testing and Vert.x6.8.1 Using JUnit 5 with Vert.x6.8.2 Testing DataVerticle6.8.3 Running the testsSummary
Part 2. Developing reactive services with Vert.x
7 Designing a reactive application
7.1 What makes an application reactive7.2 The 10k steps challenge scenario7.3 One application, many services7.4 Service specifications7.4.1 User profile service7.4.2 Ingestion service7.4.3 Activity service7.4.4 Public API7.4.5 User web application7.4.6 Event stats service7.4.7 Congrats service7.4.8 Dashboard web application7.5 Running the applicationSummary
8 The web stack
8.1 Exposing a public API8.1.1 Routing HTTP requests8.1.2 Making HTTP requests8.2 Access control with JWT tokens8.2.1 Using JWT tokens8.2.2 What is in a JWT token?8.2.3 Handling JWT tokens with Vert.x8.2.4 Issuing JWT tokens with Vert.x8.3 Cross-origin resource sharing (CORS)8.3.1 What is the problem?8.3.2 Supporting CORS with Vert.x8.4 A modern web frontend8.4.1 Vue.js8.4.2 Vue.js application structure and build integration8.4.3 Backend integration illustrated8.4.4 Static content serving with Vert.x8.5 Writing integration testsSummary
9 Messaging and event streaming with Vert.x
9.1 Event-driven services beyond HTTP with Vert.x9.1.1 What Vert.x provides9.1.2 The middleware and services that we’ll use9.1.3 What is AMQP (and a message broker)?9.1.4 What is Kafka?9.2 Reliably ingesting messages over HTTP and AMQP9.2.1 Ingesting from AMQP9.2.2 Translating AMQP messages to Kafka records9.2.3 Ingesting from HTTP9.3 Sending congratulation emails9.3.1 Listening for daily step update events9.3.2 Sending emails9.4 Integration tests9.4.1 Ingestion testing9.4.2 Congratulation email testingSummary
10 Persistent state management with databases
10.1 Databases and Vert.x10.1.1 What the Eclipse Vert.x stack provides10.1.2 A note on data/object mapping, and why you may not always need it10.2 User profile service with MongoDB10.2.1 Data model10.2.2 User profile API verticle and initialization10.2.3 Validating user input10.2.4 Adding users in MongoDB10.2.5 Authenticating a user10.2.6 Fetching a user’s data10.2.7 Updating a user’s data10.3 Activity service with PostgreSQL10.3.1 Data model10.3.2 Opening a connection pool10.3.3 Life of a device update event10.3.4 Inserting a new record10.3.5 Generating a device’s daily activity update10.3.6 Activity API queries10.4 Integration tests10.4.1 Testing the user profile service10.4.2 Testing the activity service API10.4.3 Testing the activity service’s event handlingSummary
11 End-to-end real-time reactive event processing
11.1 Advanced stream data processing with Kafka and RxJava11.1.1 Enriching daily device updates to generate user updates11.1.2 Computing device-update ingestion throughput using time-window aggregates11.1.3 Computing per-city trends using aggregation discriminants and time windows11.2 Real-time reactive web applications11.2.1 Forwarding Kafka records to the Vert.x event bus11.2.2 Bridging the event bus and web applications11.2.3 From Kafka to live web application updates11.3 Streams and state11.3.1 A stream of updates11.3.2 Hydrating the ranking state11.3.3 Periodically updating rankings from the updates streamSummary
12 Toward responsiveness with load and chaos testing
12.1 Initial experiments: Is the performance any good?12.1.1 Some considerations before load testing12.1.2 Simulating users with Locust12.1.3 Load testing the API with Hey12.2 Let’s do some chaos engineering12.2.1 Test plan12.2.2 Chaos testing with Pumba12.2.3 We are not resilient (yet)12.3 From “scalable” to “scalable and resilient”12.3.1 Enforcing timeouts12.3.2 Using a circuit breaker12.3.3 Resiliency and fallback strategiesSummary
13 Final notes: Container-native Vert.x
13.1 Heat sensors in a cloud13.1.1 Heat sensor service13.1.2 Sensor gateway13.1.3 Heat API13.1.4 Deploying to a local cluster13.2 Making the services work in Kubernetes13.2.1 Building container images13.2.2 Clustering and Kubernetes13.2.3 Kubernetes deployment and service resources13.3 First-class Kubernetes citizens13.3.1 Health checks13.3.2 Metrics13.4 The end of the beginningSummary
index

Overview

As enterprise applications become larger and more distributed, new architectural approaches like reactive designs, microservices, and event streams are required knowledge. The Vert.x framework provides a mature, rock-solid toolkit for building reactive applications using Java, Kotlin, or Scala. Vert.x in Action teaches you to build responsive, resilient, and scalable JVM applications with Vert.x using well-established reactive design patterns.

About the Technology
Vert.x is a collection of libraries for the Java virtual machine that simplify event-based and asynchronous programming. Vert.x applications handle tedious tasks like asynchronous communication, concurrent work, message and data persistence, plus they're easy to scale, modify, and maintain. Backed by the Eclipse Foundation and used by Red Hat and others, this toolkit supports code in a variety of languages.

About the Book
Vert.x in Action teaches you how to build production-quality reactive applications in Java. This book covers core Vert.x concepts, as well as the fundamentals of asynchronous and reactive programming. Learn to develop microservices by using Vert.x tools for database communications, persistent messaging, and test app resiliency. The patterns and techniques included here transfer to reactive technologies and frameworks beyond Vert.x.

What's Inside

Building reactive services
Responding to external service failures
Horizontal scaling
Vert.x toolkit architecture and Vert.x testing
Deploying with Docker and Kubernetes

About the Reader
For intermediate Java web developers.

About the Author
Julien Ponge is a principal software engineer at Red Hat, working on the Eclipse Vert.x project.

Quotes
If you want to understand Vert.x, how it works, and how best to tame it, this is the book for you.
- Sanket Naik, Aruba Networks

Provides a comprehensive overview of what the frame-work is capable of, and a solid introduction to reactive programming in general. Highly recommended!
- Damian Esteban, BetterPT

This is your complete toolbox for resilient Java applications!
- Michał Ambroziewicz, KYP.ai

All the information you need to build solid concurrent applications that can run at a massive scale.
- Jerry Stralko, Wolters Kluwer

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617295621Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills