High performing API with HTTP/2

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 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

What is performance ? Performance is hard to deﬁne but
in this talk we will study how HTTP/2 protocol is a better transport for scaling microservices

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 Backend Workers HTTP/2 connection

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

Eclipse Vert.x Open source project started in 2012 Created by
Tim Fox Eclipse / Apache licensing A toolkit for building reactive applications for the JVM 7K ⋆ on Built on top of https://vertx.io @vertx_project

Vert.x Latest and greatest Vert.x 3.4.2 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!->{…}

Non-blocking IO beneﬁts ✓ Handle many connections with a few
threads - focus on protocol concurrency - minimize system calls - more efﬁcient for pipelined/multiplexed protocols ✓ Get away from thread pools - removes unnecessary bottlenecks - easier capacity planning - focus on protocol concurrency ✓ Gracefully handle slow connection - remain responsive - don’t impact other connections

Thread pool concurrency Backend Event Loop HTTP/2 connection

(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

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!!!

High performing API with HTTP/2

High performing API with HTTP/2

More Decks by Julien Viet

Other Decks in Programming

Featured

Transcript