This document provides an introduction to HTTP/2, including: - HTTP/1.x has drawbacks like occupying one TCP connection per request and slow start-up times. - HTTP/2 aims to address these by being binary based, multiplexed, compressed and allowing server push. - It grew out of SPDY and was standardized by the IETF, maintaining the HTTP paradigm while improving performance.

1. What is HTTP/2?
Okis Chuang
2017/06/04

2. Intro to HTTP/2
Why HTTP/2
HTTP/1.x drawbacks nowadays
Workarounds for speeding up HTTP/1.1
Goal of HTTP/2
Features of HTTP/2
Demo

3. Do you know…

4. Atom has already
adopted HTTP/2

5. Intro to HTTP/2
Why HTTP/2
HTTP/1.x drawbacks nowadays
Workarounds for speeding up HTTP/1.1
Goal of HTTP/2
Features of HTTP/2
Demo

6. The IETF HTTP Working Group
HTTP/2 is a replacement for how HTTP is
expressed “on the wire.” It is not a ground-up
rewrite of the protocol

7. HTTP/1.x Drawbacks
Occupy a TCP connection per request
TCP 3-way handshake
Slow-start of TCP flow control
HTTP Pipelining vs. Head-Of-Line Blocking
(HOL)

8. Headers are sent with
every request…
. Accept-Ranges:bytes
. Access-Control-Allow-Origin:*
. Age:147613
. Cache-Control:max-age=31536000, public
. Content-Encoding:gzip
. Content-Length:23993
. Content-Type:text/css
. Date:Sat, 03 Jun 2017 07:13:47 GMT
. Expires:Fri, 01 Jun 2018 14:13:33 GMT
. Last-Modified:Sat, 01 Jan 2000 00:00:00 GMT
. Server:GitHub.com
. Timing-Allow-Origin:*
. Vary:Accept-Encoding
. Via:1.1 varnish
. X-Cache:HIT
. X-Cache-Hits:39503
. X-Fastly-Request-ID:4e6f64d3b645f29d9f71564cafa495c30445eca2
. X-GitHub-Request-Id:F9FC:22433:1761B1:1D1A91:5930210D
. X-Served-By:cache-itm7427-ITM

10. Spriting/Inlining
Image Sprite
save loading time by
merging many smaller
pictures into a bigger one
Resource Inlining
Embed data resource
inside css or html
(DataURI)

11. Concatenation
A.K.A Bundle
Combining multiple javascript files into a bigger one
instead of making multiple requests separately
Inconvenient to developer
Redundant download due to a small change

12. Domain Sharding
Splitting resources across multiple domains to
improve page load time
Avg 40 TCP connections for a page according
to http://httparchive.org/

14. HTTP Pipelining
Pipeline multiple HTTP requests into a TCP connection to server
without waiting each response
Default disabled by browsers like Chrome and Firefox

15. Intro to HTTP/2
Why HTTP/2
HTTP/1.x drawbacks nowadays
Workarounds for speeding up HTTP/1.1
Goal of HTTP/2
Features of HTTP/2
Demo

16. HTTP/2
IETF and HTTPbis workgroup
“bis” is a suffix of name used to describe
upgrade of protocol
From SPDY/3 draft -> HTTP/2 draft-00

17. Boundaries for HTTP/2
Maintain HTTP/1.x paradigm
http:// and https:// URLs cannot be changed
Be able to proxy HTTP/1 request to HTTP/2
Then proxies must be able to map HTTP/2 features to
HTTP/1.x clients 1-1 mapping
Remove or reduce optional parts or protocol
No more minor version

18. HTTP/2 for Existing URI
schemes
HTTP/1.1 has defined a way to do upgrade - header
One more Round-Trip (SPDY team wouldn’t accept the penalty)
SPDY achieve this by only implementing SPDY over TLS (no
extra protocol)
NPN (Next Protocol Negotiation)
Server list out all supported protocols for client to choose

19. HTTP/2 vs. TLS
SPDY depends on TLS and HTTP/2 bases on SPDY
BUT TLS is optional in HTTP/2
Chrome and Firefox implement it based on TLS (leaders say so)
long-running debate about whether dictate cipher suites for using TLS
NPN -> ALPN (Application Layer Protocol Negotiation)
Main difference: who decide protocol negotiation?
ALPN: client sends out a prioritized list to server and server decide which one to be
used
NPN: server sends out a list for client to choose

20. Intro to HTTP/2
Why HTTP/2
HTTP/1.x drawbacks nowadays
Workarounds for speeding up HTTP/1.1
History from SPDY to HTTP/2
Goal of HTTP/2
Features of HTTP/2
Demo

21. One persistent connection per origin

22. HTTP/2 is a binary protocol

23. Binary framing layer
EASY to PARSE

24. Frame, Message, Stream

25. Multiplexed
The ability to break down HTTP message into
independent frames, interleave them, and
reassemble them
https://http2.akamai.com/demo
see Chrome Dev Tool

26. Multiplexed

27. Stream Prioritization

28. HTTP/1.x v.s HTTP/2

29. Header Compression
Using HPACK compression format to reduce overhead
Static and Dynamic table
Allows the transmitted headers to be encoded via Huffman code
Literal values are (optionally) encoded with a static Huffman code
previously seen headers - transferring indexed value
https://http2.github.io/http2-spec/compression.html

30. Header Compression

31. Server push
https://http2.golang.org/serverpush
chrome://net-internals/#events&q=type:HTTP2_SESSION%20is:active
node-http2 implementation

32. Flow Control
TCP flow control is not granular enough - doesn’t provide
app-level to regulate individual stream
It is directional
It is credit-based
It cannot be disabled
It is hop-by-hop, not end-to-end

33. CURL vs. HTTP/2
Nghttp2
Similar use to HTTP/1.x
Negotiation
Using upgrade header to support HTTP2
Using TLS library - beware of OpenSSL version
—http2 option of CLI
curl_easy_setopt - SURLOPT_HTTP_VERSION
CURL_HTTP_VERSION_2
Multiplexing

34. HTTP/1.x v.s HTTP/2
https://http2.golang.org/gophertiles
https://http2.golang.org/

35. References
https://http2.github.io
https://bagder.gitbooks.io/http2-explained
bit.ly/http2-opt
https://http2.github.io/http2-
spec/compression.html