High Performances microservices with HTTP/2 and gRPC

High performances microservices with HTTP/2 and gRPC

Julien Viet Open source developer for 15+ years Current @vertx_project
lead Principal software engineer at Marseille Java User Group Leader ! https://www.julienviet.com/ " http://github.com/vietj # @julienviet  https://www.mixcloud.com/cooperdbi/

Page Load Time as bandwidth increases 1000 1550 2100 2650
3200 1Mbps 2Mbps 2Mbps 4Mbps 5Mbps 6Mbps 7Mbps 8Mbps 9Mbps10Mbps Page Load Time as latency decrease 1000 1750 2500 3250 4000 200 ms 180 ms 160 ms 140 ms 120 ms 100 ms 80 ms 60 ms 40 ms 20 ms

Web performance state of the art

% Persistent connections

% Multiple connections

% Domain sharding

% Content Delivery Networks

% Caching

% Compression and miniﬁcation

Still a bottleneck! GET OK GET OK

HTTP/2 A better TCP transport for actual HTTP request and
responses Same HTTP semantics RFC7540 : Hypertext Protocol version 2 RFC7541 : Header Compression for HTTP/2

HTTP/2 H2 TLS/SSL Mandatory for browsers ALPN extension to negotiate
HTTP/1 or HTTP/2 H2C Clear text Via HTTP/1 upgrade or directly

HTTP/2 framed protocol Deﬁnes a set of frames encoded in
binary on a single connection Settings Headers Data Flow control Push, Priority, Ping Reset

Settings frames First frame exchanged by client and server Max
concurrency Max frame size etc…

Request headers GET /index.html HTTP/1.1\r\n Host: www.free.fr\r\n User-Agent: Mozilla/5.0\r\n Accept-Encoding:
text/html\r\n Accept-Language: en-US\r\n \r\n 00003501250000000300 0000000f824488355217 caf3a69a3f874189f1e3 c2f2d852af2d9f7a88d0 7f66a281b0dae0508749 7ca589d34d1f51842d4b 70dd length type ﬂags stream_id 2x smaller

Subsequent request headers GET /products.html HTTP/1.1\r\n Host: www.free.fr\r\n User-Agent: Mozilla/5.0\r\n
Accept-Encoding: text/html\r\n Accept-Language: en-US\r\n \r\n 00001701250000000500 0000000f82448aaec3c9 691285e74d347f87c2c1 c0bf 4x smaller

Response headers + data HTTP/1.1 200 OK\r\n Content-Type: text/html\r\n Cache-Control:
max-age=86400\r\n Content-Length: 37\r\n \r\n <html><body>Hello World </body> </html> 0000250001000000033c 68746d6c3e3c626f6479 3e48656c6c6f20576f72 6c643c2f626f64793e3c 2f68746d6c3e 00001f01240000000300 0000000f885f87497ca5 89d34d1f588aa47e561c c581e71a003f5c023337 length type ﬂags stream_id

HTTP/2 concurrency works!

Scalable microservices with HTTP/2

Target architectures service service gateway backend service backend

High performance microservices … what is performance ? Performance is
hard to deﬁne but in this talk we will study how HTTP/2 protocol can help to scale services

Context 0.1 ms < ping <1 ms 1 G <
bandwidth < 10 G 1 ms < service time < 100 ms 100 b < body size < 10 kb

HTTP/1 vs HTTP/2 server HTTP/1 vs HTTP/2 backend client 20
ms think time

performed (req/sec) 0 200 400 600 800 planned (req /
sec) 0 100 200 300 400 500 600 700 800 HTTP/1 - 8 connections

HTTP/1.1 Client Server }20ms Backend GET response request 200 OK
}

performed (req / sec) 0 300 600 900 1200 planned
(req / sec) 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 HTTP/1 - 8 connections HTTP/2 - 1 connection / max_concurrent_streams 20

HTTP/2 multiplexing Client Server 20ms Backend GET response request 200
OK } } }

Capacity planning Conﬁgure MAX_CONCURRENT_STREAM Backend connection sizing Avoid thread pools

Thread pool concurrency

(req / sec) 0 1000 2000 3000 4000 5000 HTTP/2 thread pool

Eclipse Vert.x is a toolkit for building reactive and polyglot
applications for the JVM

Vert.x Latest and greatest Vert.x 3.4.1 Scala and Kotlin support
RxJava improvements MQTT server Kafka client gRPC support Web client Inﬁnispan cluster manager and much more!

Toolkit Embeddable Composable Modular Minimum dependencies Classloading / Injection free

Reactive Non blocking Event driven Distributed Rxiﬁed APIs Reactive-streams

HTTP/2 with Vert.x Client / Server h2 / h2c HTTP
Request / response API HTTP/2 speciﬁc features for extensions

Event driven & NIO selectors ' disk operations ( timers
) messages  database etc…

Reactor pattern with Event Loop Single thread

Events at scale & ' ' ' ' ' '
( ( ( ( (      & & & & & buffer ->{…} timerID ->{…} asyncFile ->{…} rows ->{…} ) ) ) ) ) message ->{…}

Event Loop beneﬁts Easier to scale Mechanical sympathetic Simple concurrency
model

Event Loop concurrency

(req / sec) 0 1000 2000 3000 4000 5000 HTTP/2 thread pool HTTP/2 non blocking

Going multicore

Multi-reactor pattern

(req / sec) 0 1000 3000 5000 7000 9000 11000 13000 HTTP/2 blocking HTTP/2 non blocking -1 core HTTP/2 non blocking - 2 cores

Scalable microservices with gRPC

RPC on top of HTTP/2 Protobuf 3 Bidirectional streaming vertx-grpc
/ vertx-grpc-compiler-java

Vert.x integration Event loop integration SSL/TLS integration

REACTIVE ECOSYSTEM

Building Reactive Microservices in Java https://developers.redhat.com/promotions/building-reactive-microservices-in-java/

TL;DR; Unleash concurrency with HTTP/2 and gRPC Non blocking is
a key factor for high concurrency Vert.x is a great ﬁt for HTTP/2 Reactive ecosystem Easy to scale

Merci Modern app development with Eclipse Vert.x and RxJava at
11H20 / Salle 139 QA Come grab your Vert.x sticker!

High Performances microservices with HTTP/2 and...

High Performances microservices with HTTP/2 and gRPC

More Decks by Julien Viet

Other Decks in Programming

Featured

Transcript