Auteur Sujet: Linux: Réaliser un test de débit descendant/montant avec CURL  (Lu 56672 fois)

0 Membres et 2 Invités sur ce sujet

kgersen

  • Modérateur
  • Abonné Free Pro
  • *
  • Messages: 8 421
  • Paris (75)
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #36 le: 22 novembre 2022 à 16:32:52 »
ton handler ul/upload.php:

./nspeed post --http2 https://bouygues.testdebit.info/ul/upload.php 1g post --http1.1 https://bouygues.testdebit.info/ul/upload.php 1g
Jobs:
  0-HTTP POST https://bouygues.testdebit.info/ul/upload.php
  1-HTTP POST https://bouygues.testdebit.info/ul/upload.php
running...
all done
   Job| Read speed| Write speed| Time| Bytes read| Bytes written|command
 Job 0|      0 bps|  173.0 Mbps| 7.98|        0 B|      172.7 MB|post -http2 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 3.817 ms - )
 Job 1|      0 bps|  736.1 Mbps| 7.99|        0 B|      734.7 MB|post -http1.1 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 3.505 ms - )
 Total|      0 bps|  909.0 Mbps| 7.99|        0 B|      907.4 MB|

seul ca dépasse jamais 200 Mbps en upload avec HTTP/2.

avec 4 flux:

./nspeed post -n 4 --http2 https://bouygues.testdebit.info/ul/upload.php 1g
Jobs:
  0-HTTP POST https://bouygues.testdebit.info/ul/upload.php
  1-HTTP POST https://bouygues.testdebit.info/ul/upload.php
  2-HTTP POST https://bouygues.testdebit.info/ul/upload.php
  3-HTTP POST https://bouygues.testdebit.info/ul/upload.php
running...
all done
   Job| Read speed| Write speed| Time| Bytes read| Bytes written|command
 Job 0|      0 bps|  225.0 Mbps| 7.98|        0 B|      224.6 MB|post -http2 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 2.985 ms - )
 Job 1|      0 bps|  222.8 Mbps| 7.99|        0 B|      222.4 MB|post -http2 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 3.84 ms - )
 Job 2|      0 bps|  220.5 Mbps| 7.99|        0 B|      220.1 MB|post -http2 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 3.145 ms - )
 Job 3|      0 bps|  224.3 Mbps| 7.98|        0 B|      223.7 MB|post -http2 https://bouygues.testdebit.info/ul/upload.php 1.0 GB (89.84.1.186:443 - 4.158 ms - )
 Total|      0 bps|  892.4 Mbps| 7.99|        0 B|      890.7 MB|


vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #37 le: 22 novembre 2022 à 17:33:38 »
J'ai mis en place https://bouygues.testdebit.info/ul/

Le fichier index.php qui est appelé quand on va sur cette URL est minimaliste :
<!DOCTYPE html>
<html lang="fr">
 <head><title>Net-test</title></head>
 <body><?php echo "<p>URL pour réaliser un test de débit montant</p>"?></body>
</html>

Je vais faire quelques tests pour H2WindowSize et H2StreamMaxMemSize.

Merci d'avoir vu que la valeur par défaut n'est pas pertinente pour un test de débit.

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #38 le: 22 novembre 2022 à 18:26:43 »
J'ai mis H2WindowSize 16777216 dans /etc/apache2/mods-enabled/http2.conf

16 Mo est la valeur qui était configurée pour TCP (et donc utilisé pour HTTP/1.1) :

3/ Optimisations réseau et swappiness :

nano /etc/sysctl.d/90-server-optimization.conf
Copier / coller le texte ci-dessous dans le fichier :
# Reduce the swap
vm.swappiness = 1

# TCP congestion control protocol for high-speed and long-distance networks
net.ipv4.tcp_congestion_control=bbr
net.core.default_qdisc=fq

# Disable the memorization of previous tests, in order to avoid that the server burns the tests following a limited performance
net.ipv4.tcp_no_metrics_save=1

# Increase TCP buffers
net.ipv4.tcp_rmem=4096 131072 16777216
net.ipv4.tcp_wmem=4096 87380 16777216
net.core.rmem_max=16777216
net.core.wmem_max=16777216

# Increase the queue within the Linux kernel where traffic is stored after reception from the NIC
net.core.netdev_max_backlog=4000

# Reduce the threshold where a DDOS impacts the server
net.ipv4.tcp_max_syn_backlog = 4096

# Increase number of incoming connections
net.core.somaxconn = 4096

Avec une latence de 200ms (simulée via NetEm) cela améliore bien les résultats, toutefois le débit montant s'écroule, après quelques secondes, mais c'est peut-être lié au proxy du travail. Il faut que je teste depuis un accès internet neutre.

Je n'ai pas encore défini la bonne valeur pour H2StreamMaxMemSize

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #39 le: 23 novembre 2022 à 22:03:41 »
J'ai donc commencé par réaliser des tests, depuis ma ligne SFR FttH 1 Gb/s symétrique, en rajoutant 200 ms via NetEM pour avoir une latence de 204 ms bout en out avec le serveur.

Contenu du fichier /etc/apache2/mods-enabled/http2.conf
<IfModule !mpm_prefork>
    Protocols h2 h2c http/1.1
    H2WindowSize 16777216
</IfModule>

Serveur Cubic / Latence 204ms / WindowSize serveur 16 Mo / WindowSize client valeur par défaut :
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://bouygues.testdebit.info/1G.iso => 14,2 Mo/s
- Descendant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null https://bouygues.testdebit.info/1G.iso => 14,0 Mo/s
- Descendant HTTP/2 en clair : curl --http2 -o /dev/null http://bouygues.testdebit.info/1G.iso => 14,2 Mo/s
- Descendant HTTP/2 chiffré : curl --http2 -o /dev/null https://bouygues.testdebit.info/1G.iso => 14,1 Mo/s

- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" http://bouygues.testdebit.info/ul/ => 10,3 Mo/s
- Montant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" https://bouygues.testdebit.info/ul/ => 9,89 Mo/s
- Montant HTTP/2 en clair : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" http://bouygues.testdebit.info/ul/ => 10,2 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://bouygues.testdebit.info/ul/ => 0,687 Mo/s


Les résultats sont mauvais, j'impute ça sur la WindowSize de mon client, un Ubuntu 22.10 avec les paramètres par défaut. Je monte donc la WindowSize du client à 16 Mo, comme sur le serveur :

Serveur Cubic / Latence 204ms / WindowSize serveur 16 Mo / WindowSize client 16 Mo :
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://bouygues.testdebit.info/1G.iso => 19,0 Mo/s
- Descendant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null https://bouygues.testdebit.info/1G.iso => 17,9 Mo/s
- Descendant HTTP/2 en clair : curl --http2 -o /dev/null http://bouygues.testdebit.info/1G.iso => 18,8 Mo/s
- Descendant HTTP/2 chiffré : curl --http2 -o /dev/null https://bouygues.testdebit.info/1G.iso => 20,1 Mo/s

- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" http://bouygues.testdebit.info/ul/ => 17,8 Mo/s
- Montant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" https://bouygues.testdebit.info/ul/ => 17,2 Mo/s
- Montant HTTP/2 en clair : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" http://bouygues.testdebit.info/ul/ => 21,5 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://bouygues.testdebit.info/ul/ => 0,616 Mo/s

Modification des paramètres serveur H2StreamMaxMemSize 65536 => H2StreamMaxMemSize 16777216
Contenu du fichier /etc/apache2/mods-enabled/http2.conf
<IfModule !mpm_prefork>
    Protocols h2 h2c http/1.1
    H2WindowSize 16777216
    H2StreamMaxMemSize 16777216
</IfModule>

- Descendant HTTP/2 en clair :  18,8 Mo/s => 21,2 Mo/s (résultats très proches vu les variations de débit en Cubic)
- Descendant HTTP/2 chiffré : 20,1 Mo/s => 19,5 Mo/s (résultats très proches vu les variations de débit en Cubic)
- Montant HTTP/2 en clair : 21,5 Mo/s => 21,4 Mo/s (résultats très proches vu les variations de débit en Cubic)
- Montant HTTP/2 chiffré : 0,616 Mo/s => 2,44 Mo/s

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #40 le: 23 novembre 2022 à 22:37:24 »
Les débits dans les tests précédant ont tendance a pas mal fluctuer. J'ai relevé le débit moyen sur un fichier de 1 Go, mais la moyenne est bien entachée par des baisses de débit.

Je recommence donc l'expérience avec un serveur BBR (même latence, même configuration excepté Cubic remplacé par BBR) et client BBR.

Serveur BBR / Latence 204ms / WindowSize serveur 16 Mo / WindowSize client 16 Mo :
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://paris.testdebit.info/1G.iso => 34,7 Mo/s
- Descendant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null https://paris.testdebit.info/1G.iso => 33,6 Mo/s
- Descendant HTTP/2 en clair : curl --http2 -o /dev/null http://paris.testdebit.info/1G.iso => 32,2 Mo/s
- Descendant HTTP/2 chiffré : curl --http2 -o /dev/null https://paris.testdebit.info/1G.iso => 32,7 Mo/s

- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 34,1 Mo/s
- Montant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 34,2 Mo/s
- Montant HTTP/2 en clair : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 34,7 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 0,594 Mo/s

Modification des paramètres serveur H2StreamMaxMemSize 65536 => H2StreamMaxMemSize 16777216
Contenu du fichier /etc/apache2/mods-enabled/http2.conf
<IfModule !mpm_prefork>
    Protocols h2 h2c http/1.1
    H2WindowSize 16777216
    H2StreamMaxMemSize 16777216
</IfModule>

- Descendant HTTP/2 en clair :  32,2 Mo/s => 33,1 Mo/s (résultats très proches)
- Descendant HTTP/2 chiffré : 32,7 Mo/s => 30,4 Mo/s (résultats très proches)
- Montant HTTP/2 en clair : 34,7 Mo/s => 35,0 Mo/s (résultats très proches)
- Montant HTTP/2 chiffré : 0,594 Mo/s => 2,080 Mo/s

Conclusion :
- Il y a un problème sur le débit Montant HTTP/2 chiffré
- Le gain apporté par "H2StreamMaxMemSize 16777216" n'est pas évident, je me demande si c'est une bonne idée de modifier cette variable.

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #41 le: 23 novembre 2022 à 22:58:23 »
Même test, uniquement en HTTP/2 avec une faible latence (4ms) sur un serveur BBR :

Serveur BBR / Latence 4ms / WindowSize serveur 16 Mo / WindowSize client 16 Mo :
- Descendant HTTP/2 en clair : curl --http2 -o /dev/null http://paris.testdebit.info/1G.iso => 111 Mo/s
- Descendant HTTP/2 chiffré : curl --http2 -o /dev/null https://paris.testdebit.info/1G.iso => 110 Mo/s

- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 110 Mo/s
- Montant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 110 Mo/s
- Montant HTTP/2 en clair : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 110 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 28,4 Mo/s

Modification des paramètres serveur H2StreamMaxMemSize 65536 => H2StreamMaxMemSize 16777216
Contenu du fichier /etc/apache2/mods-enabled/http2.conf
<IfModule !mpm_prefork>
    Protocols h2 h2c http/1.1
    H2WindowSize 16777216
    H2StreamMaxMemSize 16777216
</IfModule>

- Descendant HTTP/2 en clair :  111 Mo/s => 111 Mo/s (résultats très proches)
- Descendant HTTP/2 chiffré : 110 Mo/s => 96,9 Mo/s
- Montant HTTP/2 en clair : 110 Mo/s => 109 Mo/s (résultats très proches)
- Montant HTTP/2 chiffré : 28,4 Mo/s => 37,0 Mo/s

J'ai refait de nombreuses fois le test descendant HTTP/2 chiffré avec et sans H2StreamMaxMemSize 16777216 et je confirme que H2StreamMaxMemSize 16777216 fait baisser le débit sensiblement.

J'ai donc remis les serveurs Bouygues.testdebit.info et paris.testdebit.info avec la valeur par défaut (H2StreamMaxMemSize 65536)

kgersen

  • Modérateur
  • Abonné Free Pro
  • *
  • Messages: 8 421
  • Paris (75)
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #42 le: 23 novembre 2022 à 23:22:29 »
il n'y a pas d'HTTP/2 en clair dans tes tests la. L'option --http2 avec un url en "http:..." fera du HTTP1.1 (curl --http2 n'impose pas HTTP/2 , c'est juste qu'il le préfère s'il est dispo).
Pour faire du HTTP/2 sans chiffrement , c'est H2C. il faut que ton serveur le supporte  (a priori oui) et utiliser l'option curl "--http2-prior-knowledge" et "http:" dans l'url.

Vérifies toujours dans tests le protocole HTTP réellement utilisé: remplace '-o /dev/null' par '-i' ca affichera le proto (en utilisant un petit fichier en upload ou download). pour voir le chiffrement utilisé -v.

Le BPR (Bandwidth*Delay Product) donne en théorie pour 1 Gbps et 16Mo de buffer un délai max de 130ms. Pour atteindre 1 Gbps avec 200ms il faut 23 Mo de buffer.

H2StreamMaxMemSize ne concerne que les flux sortants du serveur. cf https://httpd.apache.org/docs/2.4/mod/mod_http2.html#h2streammaxmemsize
H2WindowSize ne concerne que les flux entrants sur le serveur.
Dans les  2 cas se sont les buffers du mod_http2 d'apache, en dessous y'a les buffers de l'OS et au dessus les buffers applicatifs (de php dans le cas présent).

Sur ma ligne FeePro 1Gbps upload vers paris.testdebit.info (4 ms de latence):

http1.1 chiffré ou non: 118 Mo/s
http2 non chiffré: 54 Mo/s
http2 chiffré : 30 Mo/s

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #43 le: 24 novembre 2022 à 09:16:04 »
Exact, il faut utiliser --http2-prior-knowledge pour un flux en clair.
J'ai pris une latence de 200ms de façon à être sûr que la fenêtre TCP soit l'élément limitant.

J'ai réalisé de nouveaux tests avec les valeurs par défaut coté serveur :

Serveur BBR / Latence 204ms / WindowSize serveur 65535 octets / WindowSize client 16 Mo :
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://paris.testdebit.info/1G.iso => 34,5 Mo/s
- Descendant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null https://paris.testdebit.info/1G.iso => 34,9 Mo/s
- Descendant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null http://paris.testdebit.info/1G.iso => 34,2 Mo/s
- Descendant HTTP/2 chiffré : curl --http2 -o /dev/null https://paris.testdebit.info/1G.iso => 32,8 Mo/s

- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 35,0 Mo/s
- Montant HTTP/1.1 chiffré : curl --http1.1 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 34,5 Mo/s
- Montant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 0,474 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 0,282 Mo/s

Serveur BBR / Latence 204ms / WindowSize serveur 16 Mo / WindowSize client 16 Mo :
- Montant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null -F "file=@/tmp/temp.iso" http://paris.testdebit.info/ul/ => 0,918 Mo/s
- Montant HTTP/2 chiffré : curl --http2 -o /dev/null -F "file=@/tmp/temp.iso" https://paris.testdebit.info/ul/ => 0,584 Mo/s

Avec H2WindowSize 16777216, on gagne en débit montant en HTTP/2, mais il y a un élément qui limite la fenêtre quelque part. Curl ?

Coté OS client, j'ai :
net.ipv4.tcp_rmem=4096 131072 16777216
net.ipv4.tcp_wmem=4096 87380 16777216
net.core.rmem_max=16777216
net.core.wmem_max=16777216

Pour H2StreamMaxMemSize, j'ai l'impression, que c'est plus pour un serveur qui a du mal à générer les données que cela peut être intéressant d'augmenter la taille.

kgersen

  • Modérateur
  • Abonné Free Pro
  • *
  • Messages: 8 421
  • Paris (75)
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #44 le: 24 novembre 2022 à 12:03:20 »

Avec H2WindowSize 16777216, on gagne en débit montant en HTTP/2, mais il y a un élément qui limite la fenêtre quelque part. Curl ?


curl ... peut-etre. en principe curl utilise nghttp2 (visible avec curl -V).
tu peux installer le client nghttp2 pour faire des tests directs et voir si curl influe.

sudo apt install nghttp2-client

depuis mon Ubuntu  Ubuntu 22.04.1 LTS ca donne:
curl -V
curl 7.81.0 (x86_64-pc-linux-gnu) libcurl/7.81.0 OpenSSL/3.0.2 zlib/1.2.11 brotli/1.0.9 zstd/1.4.8 libidn2/2.3.2 libpsl/0.21.0 (+libidn2/2.3.2) libssh/0.9.6/openssl/zlib nghttp2/1.43.0 librtmp/2.3 OpenLDAP/2.5.13
Release-Date: 2022-01-05
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets zstd

nghttp --version
nghttp nghttp2/1.43.0

donc nghttp2/1.43.0

nghttp -s -n  -d /path/to/1G.dat http://paris.testdebit.info/ul/
pour faire un POST.

apres j'ai constaté que ce n'est pas stable en upload, ca oscille en 20 Mo/s et 50 Mo/s (avec curl).

kgersen

  • Modérateur
  • Abonné Free Pro
  • *
  • Messages: 8 421
  • Paris (75)
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #45 le: 24 novembre 2022 à 17:50:46 »
si tu ne veux pas trop perdre de temps, je te recommande quand meme de verifier que le souci n'est pas coté serveur Apache...

Tu peux eventuellement tester avec nginx qui a été optimisé pour HTTP/2
ou
Tu peux utiliser cette version 'light' de nspeed ici: https://github.com/nspeed-app/http2issue/releases/tag/v0.0.2
Ce binaire Linux ("nspeed-mini-linux-amd64") permet d'avoir un serveur http1.1 et http/2 sans chiffrement.
en le lancant avec l'option -s:
./nspeed-mini-linux-amd64 -stu aura 2 ports en écoute
server created and listening at 8765 (http1.1)
server created and listening at 9876 (http/2 cleartext)

tu peux faire des get et post dessus:
get:
curl -o /dev/null http://ip_du_serveur:8765/1000000000(il suffit de mettre une taille en octets apres le /)
post:
curl -F "file=@/path/to/1G.dat" http://localhost:8765/le serveur va répondre avec le débit donc ne pas mettre de redirection vers /dev/null
pour http/2
il faut utiliser l'option cleartext de curl donc --http2-prior-knowledge et le port 9876

Ca devrait déja te permettre de savoir si le souci vient d'Apache ou du client curl.

vivien

  • Administrateur
  • *
  • Messages: 43 133
    • Twitter LaFibre.info
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #46 le: 24 novembre 2022 à 21:45:39 »
Serveur : BBR, avec WindowSize de 16 Mo, OS  Ubuntu 22.04.1, hébergé par Bouygues (iso emplacement et configuration avec paris.testdebit.info) : nspeed.testdebit.info
Client : BBR, avec WindowSize de 16 Mo, OS : Ubuntu 22.10, lige FTTH RED 1 Gb/s symétrique

Latence de 4ms :
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://nspeed.testdebit.info:8765/1000000000 => 111 Mo/s
- Descendant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null http://nspeed.testdebit.info:9876/1000000000 => 111 Mo/s
- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/home/vgu/snap/1G.iso" http://nspeed.testdebit.info:8765/ => 110 Mo/s
- Montant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null -F "file=@/home/vgu/snap/1G.iso" http://nspeed.testdebit.info:9876/ => 109 Mo/s

Latence de 204ms : (+200ms simulée via NetEm)
- Descendant HTTP/1.1 en clair : curl --http1.1 -o /dev/null http://nspeed.testdebit.info:8765/1000000000 => 34,4 Mo/s
- Descendant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null http://nspeed.testdebit.info:9876/1000000000 => 33,6 Mo/s
- Montant HTTP/1.1 en clair : curl --http1.1 -o /dev/null -F "file=@/home/vgu/snap/1G.iso" http://nspeed.testdebit.info:8765/ => 35,5 Mo/s
- Montant HTTP/2 en clair : curl --http2-prior-knowledge -o /dev/null -F "file=@/home/vgu/snap/1G.iso" http://nspeed.testdebit.info:9876/ => 4,83 Mo/s

Conclusion : les résultats montrent d'excellentes performances avec nspeed, sauf pour le test montant HTTP/2. Les résultats sont meilleurs qu'avec Apache, car le débit est constant vers 5 Mo/s là où le débit chute avec apache, ce qui donne une moyenne plus faible.

Il y a clairement un problème avec Curl.

nspeed.testdebit.info reste en ligne si vous souhaitez tester.

kgersen

  • Modérateur
  • Abonné Free Pro
  • *
  • Messages: 8 421
  • Paris (75)
Linux: Réaliser un test de débit descendant/montant avec CURL
« Réponse #47 le: 24 novembre 2022 à 22:23:52 »
si on résume, avec latence , le sens client->serveur en http/2 n'est pas bon.

du coup c'est soit un problème de buffer sortant coté curl  ou buffer entrant coté serveur ?