HTTP/2 is here! Why the web needs it and its impact

HTTP/2 is here!
And why the web needs it
Nilesh Naik
Tata Consultancy Services

• How we got there
• Limitations of HTTP/1.1
• What’s new in HTTP/2
• Best practices of today are anti-patterns in
HTTP/2
• Impact on developer community
• Current implementations
• What’s next
What’s in here -

The web has changed significantly since then
1991
HTTP/0.9
1996
HTTP/1.0
1999
HTTP/1.1
2015
HTTP/2
HTTP Timeline
2009
SPDY

HTTP 0.9 (1991)
GET /index.htm
<html>
<head>
….
</head>
<body>
…
</body>
</html>

HTTP 1.0 (1996)
GET /index.htm HTTP/1.0
User-Agent: mozilla
Accept: text/html
HTTP/1.0 200 OK
<html>
<head>
….
</head>
<body>
…
</body>
</html>

HTTP 1.1 (1999)
GET /index.htm HTTP/1.0
User-Agent: mozilla
Accept: text/html
Connection: keep-alive
HTTP/1.0 200 OK
<html>
<head>
….
</head>
<body>
…
</body>
</html>

Early 90’s – McDonald’s
Single Request – Response model
Not much interaction

Early 90’s
 Most of the content was sent in response to single
request
 Minimal or no JS

Modern Web page - Amazon
- 308 requests, 8.1 MB data

Modern Web page
 External resources requested
 Multiple requests, Multiple response

Modern Web page - Ads
Much of the site isnt about content, its about Ads.

And yes, every TCP connection is closed with a 3-way
connection too!
Open connection: 3-way handshake
SYN
x= rand()
SYN ACK
X+1 y= rand()
ACK
x+1 y+1
Application
Data
0 ms
28 ms
56 ms
84 ms

 More resource intensive than ever before
 HTTP 1.1 was not built to handle that kind of load
 HTTP 1.1 does not use TCP optimally
800K
Transfer size
2300K
Transfer size
80 Objects
100 Objects
In the last 4 years..

HTTP requests are expensive!
Workarounds

Spriting
Text
To get just one flag…
Browser must download
and encode the whole
image
Spriting

Spriting - Contd.
 Makes development harder
 Impacts caching
 Every change would require a fresh download
 Larger files takes longer to download and display on browser

Inlining – Contd.
 data: urls instead of sprites
 Resources can’t be cached independently
 Development isn't easy

Concatenation
Merge multiple JavaScript/CSS files into one BIG file
Larger files to download
and parse

Larger files to download
and parse
Whole bundle is invalidated
if a single file changes
Concatenation – contd.
 Too much data when only a little is needed
 Too much to reload when a change is needed
 Annoyance for developers
 Impacts caching

Domain sharding
Browsers use 6-8 connections per host

Domain sharding – contd.
Sites use many host names to allow more connection

Domain sharding on Single Server
domain.com/index.html
images.domain.com/image.png
styles.domain.com/styles.css

Domain sharding – bbc.co.uk
www.bbc.co.uk
static.bbc.co.uk
nav.files.bbci.co.uk
homepage.files.bbci.co.uk
 Still suffers from head of blocking
 Every new connection takes up resources
 Every new host needs a name lookup
*http://yslow.org/

 Useful, but are really just Band-aids
 Annoying for the developers
 Adds a layer of tools
 Hampers caching
 Downloads too much
Hacks

Ideal Protocol Interaction
 Send minimal data to the server
 Download minimal data needed
 Extra data -> more time to transfer, adds latency (especially on mobile networks)

HTTP/1.1
 HTTP/1.x is “chatty”
 Several round-trips, adds latency

Announced in 2009
Target 50% reduction in PLT
Initial tests - 55% faster
On track to de facto standard

Enter HTTP/2 - RFC 7540
 Built on top of
SPDY
 One TCP
Connection
 Improved end-user
perceived latency
 Binary framing
layer

Connection
Stream
DATA HEADER
Request message
Response message
HEADER HEADERDATA
Stream
PRIORITY HEADER
Request message
Response message
HEADER DATA
…

An HTTP 1.x connection
Response
<HTML>
<HEAD>
--
</HEAD>
<BODY>
--
</BODY>
</HEAD>
Request
GET /index.html HTTP 1.1
User-Agent: mozilla
Accept: text/html
TCP Connection

An HTTP/2 connection
Response
0000100011
0110000100
0000100101
Request
000100010
100100100
001001000
TCP Connection

Demo
• https://http2.akamai.com/demo

Multiplexing
Head of
Line
Blocking
No Queuing
One connection
Many requests
Out of order
interleaved
HTTP/1.1 HTTP/2
Still serialized
Long download/long
think time can block
other requests

Multiplexing – network graph

Header Compression
 Unnecessary metadata (headers) add up
quickly
 100+ requests, with few KB of headers ->
hundreds of KB’s!
 Bytes are slow and expensive to transfer

Header Duplication – contd.
 Four requests
 2,596 bytes total
 1,797 redundant bytes

HPACK – Header Compression - RFC 7541
Compresses Headers
Avoids sending duplicated/repeated headers

Server push
 Similar to Inlining
 Resources pushed directly to client’s cache
 Opportunity for servers to become smarter
– Don’t push on every request
– Push based upon observed traffic pattern
Browser can
reject push

Implementations
 H2O
 mod_h2 (Apache)
Server push – Cache Digest
Process
request
Digest of
/main.js &
/main.css
<html>
<script src="/main.js">
<link rel="stylesheet" href="/main.css">
<link rel=STYLESHEET href="/foo.css">
<body>
… generated response …

Priortization – HTTP/1.x
In HTTP/1, Prioritization is a browser heuristic
• CSS and images first, followed by images

Priortization – HTTP/2
In HTTP/2, it’s hinted by the client, determined by the
server

Stream Priority
Stream Weight: <int> 1..256
• Lower the number, higher the priority

Stream Dependency
Stream
Root
Weight: 15
Dependency: {Stream id}
• Streams aren't isolated, they can be dependent on others
• If no dependency then id set to zero.

HTTP/2 User Impact
Faster page loads
More response loading
More HTTPS

Uses binary format instead of text
Debugging can be a problem
No more telnet
Why?

TLS Overhead
• World is moving towards https
already
• ALPN makes impact minimal
• Cost of certificates and
administrative overhead

Hosting .NET Apps
IIS 10 on Windows 10
Windows Server 2016
Nginx

Hosting Java Apps
Apache HTTP 2.4.17+
Jetty 9.3+
Tomcat 8.5

Hosting Node Apps
node-http2
node-spdy
ExpressJS 5.0

HTTP/2 on JVM
JDK 8 and upwards required
Include ALPN extensions in class path
Included in JDK 9

Implementations
https://github.com/http2/http2-spec/wiki/Implementations

HTTP/1.x workaround will hurt HTTP/2 perf
Inlining
Spriting
Concatenating
Sharding

QUIC
Runs on top of UDP
Goodness of SPDY and HTTP/2
No head of line blocking in QUIC!
QUIC TCP + TLS
New connection 100 ms
Repeat connnection 0 ms RTT
New connection 300 ms
Repeat connection 200 ms RTT

HTTP/2 is here! Why the web needs it and its impact

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Viewers also liked

Viewers also liked (17)

Similar to HTTP/2 is here! Why the web needs it and its impact

Similar to HTTP/2 is here! Why the web needs it and its impact (20)

More from IndicThreads

More from IndicThreads (20)

Recently uploaded

Recently uploaded (20)

HTTP/2 is here! Why the web needs it and its impact