Pourquoi l'implémentation de WebSocket est-elle plus lente que HTTP/2 Push lors du transfert de plusieurs fichiers? (Node.js/Go)

Question

J'ai expérimenté avec les bibliothèques WebSockets et HTTP/2 dans Node and Go. Ma configuration de base est de créer un client et un serveur, d'envoyer à plusieurs reprises un fichier depuis le serveur et de mesurer le temps jusqu'à ce que chaque fichier soit disponible sur le client. À ma grande surprise, l'implémentation HTTP/2 Push est nettement meilleure que WebSocket (plus de 5 fois plus rapide dans le temps total). Est-ce que je fais quelque chose de mal?

Mes serveurs ci-dessous Gorilla WebSocket et node-ws:

Go

package main 

import (
    "net/http" 
    "io/ioutil" 
    "log" 
    "github.com/gorilla/websocket" 
) 

var file []byte 

var upgrader = websocket.Upgrader{ 
    ReadBufferSize: 1024, 
    WriteBufferSize: 1024, 
} 

func handler(w http.ResponseWriter, r *http.Request) { 
    conn, err := upgrader.Upgrade(w, r, nil) 
    if err != nil { 
     log.Fatal(err) 
    } 

    for i := 0; i < 100; i++ { 
     conn.WriteMessage(2, file) 
    } 
} 

func main() { 
    file, _ = ioutil.ReadFile("<path-to-file>") 

    http.HandleFunc("/", handler) 
    err := http.ListenAndServeTLS(":443", "<path-to-cert>", "<path-to-key>", nil) 
    if err != nil { 
    panic("ListenAndServe: " + err.Error()) 
    } 
} 

Noeud

const WebSocket = require('ws'); 
const https = require('https'); 
const fs = require('fs'); 

const options = { 
    key: fs.readFileSync('<path-to-key>'), 
    cert: fs.readFileSync('<path-to-cert>') 
}; 

var file = fs.readFileSync('<path-to-file>') 

var httpServer = new https.createServer(options).listen(443); 

var wss = new WebSocket.Server({ 
    server: httpServer, 
    perMessageDeflate: false 
}); 

wss.on('connection', function(ws) { 
    for (let i = 0; i < repetition; i++) { 
    ws.send(file); 
    } 
}); 

Answer 1

Voir https://github.com/gorilla/websocket/issues/228. L'OP mesurait le temps d'ouverture des flux avec HTTP/2 Push, pas le temps de transférer toutes les données sur les flux. L'OP a constaté que Websockets sont plus rapides que HTTP/2 push.