12 ms·
The Status of HTTP/3
- tambre 7y ago> with almost 300,000 services using it across the world The Shodan search given scans headers for all requests. So the vast majority of results are sites using Google Fonts, Maps, etc.
- MarionG 7y agoAccording to W3Techs, 2.4% of the top 10m sites and 7.1% of the top 1k sites support HTTP/3: https://w3techs.com/technologies/breakdown/ce-http3/ranking https://w3techs.com/technologies/breakdown/ce-http3/ranking
- skrowl 7y agoSeems more verbose than https://caniuse.com/#feat=http3 https://caniuse.com/#feat=http3 TLDR - No browsers support it (without flag / config changes) yet.
- SquareWheel 7y agoIn the age of evergreen browsers, it's possible to go from 0% to 85% in just a few weeks time. Upgrading web servers will be the real bottleneck.
- Avamander 7y agonginx will get H3 this year, so I think we'll see a massive uptick in adoption.
- LinuxBender 7y agonice! might be a while for haproxy [1] if ever and i've not been on apache's IRC in a long time so no idea if they are considering adding it to core. [1] - https://github.com/haproxy/haproxy/issues/62 https://github.com/haproxy/haproxy/issues/62
- thenewnewguy 7y agoDo you know where I can watch the status on that?
- Avamander 7y agohttps://trac.nginx.org/nginx/ticket/1057 https://trac.nginx.org/nginx/ticket/1057 and https://trac.nginx.org/nginx/roadmap https://trac.nginx.org/nginx/roadmap
- skrowl 7y agoThis guy has clearly never heard of mobile Safari / iOS
- tyingq 7y agoBecause QIC is UDP based, Chrome first runs a race with TCP just in case you're sitting behind some device that blocks UDP. I wonder how much bandwidth this will waste globally.
- xfalcox 7y agoI wonder if Happy Eyeballs means that there are 4 races in total for systems under dual-stack...
- yeaaaaah 7y agoAll the more reason not to bother with IPv4.
- eximius 7y agoMost global bandwidth is from video streaming, so most of the data isn't in the first couple packets. So the number would probably be surprisingly large but also a very small fraction of overall traffic.
- sebazzz 7y agoIsn't that like any device behind NAT?
- tyingq 7y agoYes. NAT, firewalls with admins that don't know what QUIC is, various corporate MITM boxes, etc.
- big_chungus 7y agoMost NAT still allows UDP hole-punching (STUN/TURN/ICE) unless specifically blocked (which a depressing number still do).
- stephenjudkins 7y agoNo. Most NATs handle UDP sessions trivially as long as one end of the connection is not behind a NAT itself. Tricks like UDP hole punching are necessary only between two endpoints that are both behind NATs.
- Seenso 7y agoWhy are they calling it HTTP/3 and not just keeping the QUIC name?
- kbenson 7y agoWell, why did we call it http/2 and not just keep the SPDY name? Probably because it's easier to know what's being talked about if we keep the historical protocol name. If the submission title was "The status of QUIC" I wouldn't have remembered it had anything to do with HTTP.
- treve 7y agoTwo reasons I can think of: 1. HTTP/2 was a 'new serialization' of the core HTTP data model. HTTP/3 is too, so since it was ratified it made sense to use HTTP/3 to keep things consistent. 2. QUIC still exists, but it's now the underlying framing/messaging protocol on top of UDP. I can imagine future internet protocols being developed on top of QUIC that don't need HTTP/3.
- yeaaaaah 7y agoYup. For example there's a draft proposal for DNS-over-QUIC: https://tools.ietf.org/id/draft-huitema-quic-dnsoquic-06.html https://tools.ietf.org/id/draft-huitema-quic-dnsoquic-06.htm...
- MrStonedOne 7y agoThat would be like calling http/1 'tcp'.
- Matthias247 7y agoYou can use QUIC without HTTP/3. QUIC streams are just bidirectional Streams without HTTP semantics, and can therefore carry arbitrary data. The HTTP mapping on top of QUIC is called HTTP/3.
- microcolonel 7y agoThe IETF is reserving the QUIC name for the underlying transport protocol, which has been separated from HTTP/3. Google's QUIC has them tightly coupled, so it's just "QUIC", whereas IETF QUIC is a general transport protocol (like TCP or SCTP, but technically implemented on top of UDP) for multi-stream connections, and HTTP/3 is a HTTP application protocol on top of QUIC.
- xfalcox 7y agoI created a container image of Discourse using nginx with the cloudflare patch to enable HTTP/3[1] and for some reason the same config that works fine in HTTP/2 loses the content-type header on Google Chrome. It works just fine in Firefox... 1. https://github.com/cloudflare/quiche/tree/master/extras/nginx https://github.com/cloudflare/quiche/tree/master/extras/ngin...
- mholt 7y agoThis article omits that Caddy has had long-running experimental support for HTTP/3 for a couple of years now: https://caddyserver.com/docs/json/apps/http/servers/experimental_http3/ https://caddyserver.com/docs/json/apps/http/servers/experime...
- teruakohatu 7y agoCaddy's strange official binary licencing did them no favours. The licensing makes more sense now but they are off people's radar.
- PhilippGille 7y agoThis might change with Caddy 2.0.
- htfy96 7y agoOne thing that drives me off from Caddy is that many features don't compose with each other well. I understand this might be a sacrifice for a simpler user interface, but the composition of declarative-style configurations is always a mess compared to imperative ones like nginx.conf
- mholt 7y agoThanks for the feedback. (To clarify, nginx's config is also declarative... well, mostly: they got in trouble for mixing declarative and imperative [1].) You'd be surprised what we've been able to accomplish with upgrades to Caddy's configuration in Caddy 2. Its config is technically declarative, but the underlying JSON structure [2] implies a procedural flow, enabling you to compose certain behaviors that almost feels imperative. When Caddy 2 release candidates go out in a couple months, try it out with both the Caddyfile (soon to be majorly improved in beta 13) and the underlying JSON and you'll see what I mean. Oh, but if you want to still use your nginx config, go ahead (WIP) [3]. :) [1]: https://www.nginx.com/resources/wiki/start/topics/depth/ifisevil/ https://www.nginx.com/resources/wiki/start/topics/depth/ifis... [2]: https://caddyserver.com/docs/json/ https://caddyserver.com/docs/json/ [3]: https://github.com/caddyserver/nginx-adapter https://github.com/caddyserver/nginx-adapter
- WhatIsDukkha 7y agoFrom a brief look at the Rust side - Actix uses Tokio Quiche doesn't Quinn does but doesn't look quite ready and I don't see any integration attempts with Actix yet.
- axaxs 7y agoI hate to be a curmudgeon, but I can't help but think that designing a new service over UDP isn't the best idea. DNS has been fighting off wave after wave of attack vectors, some that realistically cannot even be fixed. Making it immune to these vectors is going to look a lot like a slapped together TCP over UDP...
- faeyanpiraat 7y agocurmudgeon (noun): a bad-tempered person, especially an old one.
- john37386 7y agoTotally agree with you. Many big corporations totally block UDP at ISP level because there is no easy/magic solutions against amplified DDoS. They usually use some internal backend for DNS, Ntp, routed through other ISP. I am afraid that businesses that will host HTTP/3 will be less secure in terms of availavility.
- microcolonel 7y agoThe fact that many corps block UDP doesn't have anything to do with the necessity of QUIC. QUIC is on top of UDP because we tried with SCTP, but is never coming. For people who have reasonably configured UDP, it offers a benefit; the fact that some people have broken UDP is neither here nor there. HTTP/2 continues to be an option for TCP-only networks.
- profmonocle 7y ago> I am afraid that businesses that will host HTTP/3 will be less secure in terms of availavility. Presumably most HTTP/3 implementations will gracefully fall back to HTTP/2 (or 1.1) if UDP is filtered. Chrome's existing QUIC implementation already does this. Every Google property has had QUIC enabled for quite a while now (at least 4-5 years), so if UDP blocking would cause availability issues, affected businesses would've noticed by now.
- wahern 7y ago
- whatsmyusername 7y agoYeah I'm not deploying this, pretty much ever. I'll gladly eat the overhead of TCP to be able to avoid the reflection and spoofing issues of UDP.
- Rusky 7y agoThe only reason QUIC is built on top of UDP is because ossification prevents it from being built on top of IP. It's essentially at the same level as TCP- and provides similar mechanisms to avoid UDP's issues.
- toast0 7y agoGoogle is building TCP over UDP because they're unwilling to fix TCP on Android. Apple has shown that TCP is not ossified. They have innovative features like Path MTU probing/blackhole detection [1] and multipath TCP [2]. [1] This actually isn't innovative, but Android hasn't enabled it, even though it was widely available since before Android existed; maybe enabling it is an innovation? [2] Initially for Siri only, but now available to applications if you make the right incantations. I haven't been able to actually use it, and I'm pretty sure there's some hidden performance issues. For example, there's no reasonable way to make all the substreams of a MPTCP connection go to the same network queue, and you probably want that for performance, but that would be a problem with QUICs multipath features as well; I haven't seen if anybody made reasonable configuration for MPTCP yet, either.
- whatsmyusername 7y agoThat's my point, I don't want something at the same level of TCP because then you have to solve the same problems that TCP already solves. Whitelisting patterns are incredibly common. Breaking that breaks a lot of stuff.
- Animats 7y agoAll this to support more ads per page. All this is only a win mostly if you have a huge number of little assets from different sources. Ads, trackers, icon buttons, malware, etc. If it's all coming from one source, HTTP/2 is good enough. If it's mostly one big file, HTTP/1 is good enough.
- NilsIRL 7y ago> All this to support more ads per page. I'm also very afraid of the future of Web Assembly. Both of these technologies i'm afraid aren't going to make things better, faster and more lightweight. They are just going to allow the bloat of the web to become worse without noticeable symptoms.
- baby 7y agoThis made me think of the problem of highways: the more lane you add, the more cars come to use your road and congestion is not reduced. This is a problem with computers in general. For example IDEs and simple electron apps taking huge amounts of memory.
- gsich 7y agoIt's the reverse of Moore's law: https://en.m.wikipedia.org/wiki/Wirth%27s_law https://en.m.wikipedia.org/wiki/Wirth%27s_law
- generj 7y agoThe problem with highways is called induced or latent demand. It’s a known problem in a lot of fields. https://en.m.wikipedia.org/wiki/Induced_demand https://en.m.wikipedia.org/wiki/Induced_demand
- derefr 7y agoWho cares about the WebAssembly on the web? I'm looking forward to WebAssembly because it'll mean that Electron will become the new JRE: a lightweight, portable, feature-rich "full-fat GUI" application platform. ;)
- 7y ago
- jrumbut 7y agoFor the builder of small to medium (say, 10k to 1 million monthly users, some media but not the primarily focus) websites, apps, APIs, etc, is it time to begin deploying HTTP/2 or even 3? How would one make the decision, what factors would influence it? What are some of the best books/essays arguing either direction? I believe in maintaining best practices even if you can get away with sloppiness on a specific project, to be good and fast at doing things the right way, but I honestly can't tell where the new protocols fall.
- GABeech 7y agoHTTP/2 absolutely there are a ton of wins with some of the work they did. Especially around content loading and ssl. HTTP/3? Meh. We've started into the realm of solving google scale problems in HTTP standards that have marginal if any benefit to the 99%
- 1_player 7y ago> google scale problems [...] that have marginal if any benefit to the 99% Such as connection migration over different networks? Who ever needs that? "Sorry, call dropped. I was leaving the house and I lost connection to the Wifi..."
- chrismorgan 7y agoI’d tend to say it the other way round, actually: Compared with HTTP/1.1, HTTP/2 has known regressions which can be catastrophic on poor-quality connections, mostly due to TCP head-of-line blocking. At Fastmail we found concrete performance problems for some users from deploying HTTP/2 so that we rolled it back for a while and tried again later after shuffling a couple of things around to mitigate the worst such problems (can’t remember what we actually did). But even so, a small fraction of our users will get a worse experience from HTTP/2 than from HTTP/1.1. (Don’t think I’m speaking against HTTP/2; overall it’s an improvement for performance over HTTP/1.1, often a big improvement. But for developing things like interactive apps, it’s helpful to understand the differences and their effects.) HTTP/3, meanwhile, does not suffer from such problems (which is most of why they made it). The main risk is that it’s less likely to work at all—but browsers take that into consideration and fall back to HTTP over TCP (HTTP/1.1 or HTTP/2) smoothly. Presuming you have capable server software, I’d honestly consider deploying HTTP/3 to be lower risk than deploying HTTP/2. One should also consider the robustness of the HTTP/2 or HTTP/3 implementation. Consider such things as this variety of DoS attacks against HTTP/2 from the last six months: https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-002.md https://github.com/Netflix/security-bulletins/blob/master/ad.... It’s improbable that these are are only major attack vectors in HTTP/2 and HTTP/3 implementations.
- bruntonjeeves 7y agoI'll start worrying about HTTP/3 the same time I start worrying about IPv6, never.
- K0SM0S 7y agoSlight tangent that actually shocked me when I learned about it: the OSI model that everyone keeps talking about is actually not the "official" nor "real" implementation we use. The actual protocol (and conceptual model) you really want to learn and work with is simply called "Internet Protocol Suite", commonly known as "TCP/IP". Consider this comparison between OSI and TCP/IP models from Wikipedia[1]: > The OSI protocol suite that was specified as part of the OSI project was considered by many as too complicated and inefficient, and to a large extent unimplementable. Taking the "forklift upgrade" approach to networking, it specified eliminating all existing networking protocols and replacing them at all layers of the stack. This made implementation difficult, and was resisted by many vendors and users with significant investments in other network technologies. In addition, the protocols included so many optional features that many vendors' implementations were not interoperable. > Although the OSI model is often still referenced, the Internet protocol suite has become the standard for networking. TCP/IP's pragmatic approach to computer networking and to independent implementations of simplified protocols made it a practical methodology. Some protocols and specifications in the OSI stack remain in use, one example being IS-IS, which was specified for OSI as ISO/IEC 10589:2002 and adapted for Internet use with TCP/IP as RFC 1142 There's a similar discussion on the TCP/IP article as well[2], highlighting the impracticality of OSI "layers" in terms of implementation. > The IETF protocol development effort is not concerned with strict layering. Some of its protocols may not fit cleanly into the OSI model, although RFCs sometimes refer to it and often use the old OSI layer numbers. The IETF has repeatedly stated[citation needed] that Internet protocol and architecture development is not intended to be OSI-compliant. RFC 3439, addressing Internet architecture, contains a section entitled: "Layering Considered Harmful". In practice, a short discussion about SSL/TLS is enough to point the inadequacies of OSI, and orient one towards conforming their conceptual model closer to TCP/IP and relevant RFC's. The advice I follow personally, given the "popularity" of OSI (people call "layer 1-7" as if it were an actual thing, 90% of the blogs and literature uses the OSI model), is to simply translate into TCP/IP lingo/concepts in your mind whenever you read/speak about it. Not everyone will get it around you, but at least you'll have a more solid implementation should you be working with low-levels of the net stack. For reference, RFC 1122[3] defines the Internet Protocol Suite with 4 layers: application, transport, internet (or internetwork, the idea of routing) and link. Does not assume or require a physical layer in the spec itself — hence it works on 'anything' from USB to Fiber passing by Ethernet or Bluetooth and PCIe/Thunderbolt if you just follow the protocol. [1]: https://en.wikipedia.org/wiki/OSI_model#Comparison_with_TCP/IP_model https://en.wikipedia.org/wiki/OSI_model#Comparison_with_TCP/... [2]: https://en.wikipedia.org/wiki/Internet_protocol_suite#Comparison_of_TCP/IP_and_OSI_layering https://en.wikipedia.org/wiki/Internet_protocol_suite#Compar... [3]: https://tools.ietf.org/html/rfc1122#section-1.1.3 https://tools.ietf.org/html/rfc1122#section-1.1.3
- 3xblah 7y ago"HTTP/1.1 keep-alive connections, though, do not support sending multiple requests out at the same time, which again resulted in a bottleneck due to the growing complexity of Web pages." Is this true. Below we use HTTP/1.1 pipelining to send multiple requests (30) over a single TCP connection in order to print short descriptions of the last 30 infoq.com articles posted to HN. http11 () { while read x;do case $x in https://*)x1=${x#https://*/};;http://*)x1=${x#http://*/};;*)x1=${x#*/};esac;[ $x1 != $x ]||x1="";x2=${x#*//};x3=${x2%%/*};printf "GET /$x1 HTTP/1.1\r\nHost: $x3\r\nConnection: keep-alive\r\n\r\n";done|sed '/^$/d;N;$!P;$!D;$d';printf "Connection: close\r\n\r\n"; } curl https://news.ycombinator.com/from?site=infoq.com|grep -o "https://www.infoq[^\"?]*"| http11 |openssl s_client -connect www.infoq.com:443 -ign_eof -quiet 2>/dev/null|sed -n '/@id/p;/^ \"description\": \"/p'
- gsnedders 7y agoWith HTTP/1.1 pipelining, you can't reliably start sending the second request until the first response is complete. As such, you can't have multiple requests out at the same time. It's also very much linear.
- 3xblah 7y ago"With HTTP/1.1 pipelining, you can't reliably start sending the second request until the first response is complete." In the example, all 30 requests were sent at the same time. openssl did not wait for any responses. This example can be repeated again and again and every time, all the responses are received, in order. It is reliable. Not sure who "you" refers to in the above statement, however if it applies to me then that statement is incorrect. I have been using HTTP/1.1 pipelining outside the browser for decades. HTTP/1.1 was written for HTTP clients. Browsers are just one type of client, not the only type. More than half the traffic on the internet is initiated by non-interactive clients. Besides headless, that excludes browsers. From RFC 2616: user agent The client which initiates a request. These are often browsers, editors, spiders (web-traversing robots), or other end user tools.
- gsnedders 7y ago
- udippant 7y agoFacebook has also open sourced implementation of HTTP3 (https://github.com/facebook/proxygen#quic-and-http3 https://github.com/facebook/proxygen#quic-and-http3) and IEFT QUIC (https://github.com/facebookincubator/mvfst https://github.com/facebookincubator/mvfst).
- fredrik-j 7y agoCan anyone now give a reasonable ETA for the HTTP/3 RFC:s? I see that the WG charter has one milestone in May 2020, and Daniel Stenberg of curl has mentioned early 2020 before. In addition, AFAIU, both Chrome and Firefox have implementations ready, though still behind flags. Is it likely that we'll see actual deployments and a wider rollout already in 2020?
- jeltz 7y agoI saw a talk from Daniel about a month ago and then he said he had no idea.
- throw0101a 7y agoFrom the article: > HTTP/2, derived from the now deprecated SPDY protocol, introduced the concept of first-class streams embedded in the same connection. Was this not done by SCTP? * https://en.wikipedia.org/wiki/Stream_Control_Transmission_Protocol#Message-based_multi-streaming https://en.wikipedia.org/wiki/Stream_Control_Transmission_Pr... It's just that (a) network boxes often block 'unknown' protocols, and (b) web servers/browsers did not bother implementing the protocol.
- WorldMaker 7y agoYes, my impression of both HTTP/2 and HTTP/3 efforts is that they learned a lot from how many middle boxes clobber SCTP. I've heard the UDP-based QUIC that HTTP/3 uses described before as "middle box safe SCTP", though it does differ in details it attempts to accomplish much the same things but piggybacking over UDP.