sgcQUIC Évite les allers-retours. QUIC natif.

TCP plus TLS demande trois allers-retours avant que le premier octet de réponse n’arrive. QUIC fusionne le transport et la poignée de main cryptographique en une seule, et une connexion reprise peut envoyer des données dès le tout premier paquet. sgcQUIC offre à Delphi, C++ Builder et .NET un transport QUIC natif et un client et serveur HTTP/3 construits dessus, sur le moteur QUIC d’OpenSSL 3.5.

Un complément de sgcWebSockets Enterprise. Voir les tarifs →
  • RFC 9000, 9114, 9204
  • WebTransport (RFC 9220)
  • 0-RTT
  • Migration de connexion
  • Delphi
  • C++ Builder
  • .NET
  • 4Composants sur une seule page de la palette
  • 4RFC : 9000, 9114, 9204 et 9220
  • 1Aller-retour avant les données, contre trois pour TCP plus TLS
  • 0-RTTPremière requête dans le premier paquet d’une session reprise
  • 3Langages : Delphi, C++ Builder et .NET
Pourquoi QUIC

La même sécurité TLS 1.3. Moins d’allers-retours sur le réseau.

La poignée de main du transport, celle de TLS et la première requête coûtent chacune un aller-retour sur TCP. QUIC transporte les trois en un seul échange.

TCP + TLS 1.3 QUIC (HTTP/3) Client Serveur Client Serveur SYN SYN-ACK ACK ClientHello ServerHello, certificat Finished GET /pets/42 200 OK 3 allers-retours avant les données Initial + Handshake + GET Handshake + 200 OK 1 aller-retour avant les données Sur une session reprise 0-RTT : GET + données anticipées La même sécurité TLS 1.3. Moins d’allers-retours sur le réseau.

TCP + TLS : trois allers-retours

SYN, SYN-ACK et ACK ouvrent le socket. ClientHello, ServerHello et Finished établissent TLS. C’est seulement ensuite que part la première requête.

QUIC : un aller-retour

QUIC fusionne le transport et la poignée de main cryptographique en un seul échange, donc la requête voyage avec la poignée de main et la réponse revient avec elle.

Reprise : 0-RTT

Un client déjà connecté peut envoyer sa première requête dans le tout premier paquet, avant la fin de la poignée de main.

Regarde-le tourner

QUIC et HTTP/3 depuis Delphi, en quelques minutes.

Un démarrage rapide commenté et sous-titré : un serveur et un client HTTP/3, puis une connexion QUIC brute avec plusieurs flux. Rien ne se télécharge avant que tu appuies sur lecture.

Démarrage rapide sgcQUIC

Lance un serveur et un client HTTP/3, et ouvre une connexion QUIC brute depuis Delphi.

  1. Le client HTTP/3Crée-le, appelle Get avec une URL et lis la réponse. Les verbes, les codes d’état et les en-têtes sont ceux que tu connais déjà.
  2. Synchrone ou asynchroneGère OnResponse et OnError, puis appelle GetAsync, et la requête s’exécute sans bloquer ta fenêtre.
  3. Le serveur HTTP/3Crée un TsgcHTTP3Server, donne-lui un port, un certificat et une clé privée, et gère OnH3Request.
  4. QUIC brut et plusieurs fluxTsgcQUICClient seul, avec EnableMultiStream pour des flux indépendants, chacun ordonné et contrôlé en flux.
  5. Avant de déployerQUIC passe par UDP, donc un pare-feu qui n’ouvre que le port TCP 443 le bloque.
Quatre composants

QUIC brut, ou HTTP/3 par-dessus.

Utilise TsgcQUICClient et TsgcQUICServer pour un transport nu avec ton propre format de trames, ou prends directement TsgcHTTP3Client et TsgcHTTP3Server quand le format sur le fil est HTTP.

Client & serveur QUIC

TsgcQUICClient et TsgcQUICServer parlent QUIC brut : plusieurs flux indépendants sur une connexion chiffrée, datagrammes non fiables et migration de connexion quand l’adresse IP du client change en pleine session.

Voir les composants QUIC →

Client & serveur HTTP/3

TsgcHTTP3Client et TsgcHTTP3Server ajoutent la sémantique HTTP par-dessus : en-têtes de requête et de réponse compressés avec QPACK, découverte Alt-Svc, et les mêmes méthodes et codes d’état que ton code HTTP/2 utilise déjà.

Voir les composants HTTP/3 →

Reprise de session 0-RTT

Un client déjà connecté peut envoyer sa première requête dans le tout premier paquet, avant la fin de la poignée de main.

Migration de connexion

Un identifiant de connexion désigne la session, pas l’adresse IP, donc un téléphone qui passe du Wi-Fi au réseau mobile garde ses flux ouverts.

WebTransport

Flux bidirectionnels et datagrammes non fiables sur une seule requête Extended CONNECT, pour les clients navigateur qui parlent WebTransport.

QUIC natif, sans dépendance externe

La poignée de main QUIC et TLS 1.3 s’exécute sur le moteur QUIC propre à OpenSSL 3.5. Il n’y a aucune bibliothèque QUIC séparée à compiler ni à embarquer.

Fondé sur les standards

QUIC et HTTP/3, à la lettre des RFC.

sgcQUIC n’est pas une implémentation partielle. Le transport, le découpage en trames, la compression des en-têtes et l’extension WebTransport sont tous couverts, sur le moteur QUIC natif d’OpenSSL 3.5.

RFC 9000

Le protocole de transport QUIC : flux, datagrammes, contrôle de flux et migration de connexion.

RFC 9114

HTTP/3, la même sémantique de requête et de réponse que HTTP/2, portée par des flux QUIC.

RFC 9204

Compression d’en-têtes QPACK, conçue pour la livraison des flux QUIC dans le désordre.

RFC 9220

WebTransport sur HTTP/3, flux bidirectionnels et datagrammes sur une seule requête Extended CONNECT.

Le code

Une requête en HTTP/3.

La même forme que n’importe quel autre client HTTP de sgcWebSockets : définis des propriétés, gère un événement, appelle une méthode. Côté serveur, c’est un composant et un gestionnaire.

uses
  sgcHTTP3_Client;
var
  vClient: TsgcHTTP3Client;
begin
  vClient := TsgcHTTP3Client.Create(nil);
  vClient.Host := 'api.example.com';
  vClient.Port := 443;
  vClient.OnResponse :=
    procedure(Sender: TObject; const AStatus: Integer; const ABody: string)
    begin
      Memo1.Lines.Add(Format('%d: %s', [AStatus, ABody]));
    end;
  vClient.OnAltSvc :=
    procedure(Sender: TObject; const AAltSvc: string)
    begin
      Memo1.Lines.Add('Alt-Svc: ' + AAltSvc);  // h3 advertised over HTTP/2
    end;
  vClient.Connect;
  vClient.Get('/pets/42');
end;
uses
  sgcQUIC_Client;
var
  vQUIC: TsgcQUICClient;
begin
  vQUIC := TsgcQUICClient.Create(nil);
  vQUIC.Host := 'quic.example.com';
  vQUIC.Port := 4433;
  vQUIC.EnableMultiStream := True;
  vQUIC.OnQUICConnect :=
    procedure(Sender: TObject)
    var
      vStreamId: Int64;
    begin
      vStreamId := vQUIC.OpenStream;
      vQUIC.WriteData(vStreamId, 'ping');
    end;
  vQUIC.OnQUICStreamData :=
    procedure(Sender: TObject; const AStreamId: Int64; const AData: string)
    begin
      Memo1.Lines.Add(Format('stream %d: %s', [AStreamId, AData]));
    end;
  vQUIC.Active := True;
end;
uses
  sgcHTTP3_Server;

procedure TForm1.FormCreate(Sender: TObject);
begin
  FServer := TsgcHTTP3Server.Create(nil);
  FServer.Port := 443;
  FServer.QUICOptions.SSLOptions.CertFile := 'server.crt';
  FServer.QUICOptions.SSLOptions.KeyFile  := 'server.key';

  // One handler for every incoming HTTP/3 request
  FServer.OnH3Request :=
    procedure(const Ctx: TsgcHTTP3Context)
    begin
      if Ctx.Path = '/pets/42' then
        Ctx.RespondJSON(200, '{"name":"Rex"}')
      else
        Ctx.Respond(404, 'Not found');
    end;

  FServer.Active := True;
end;
  1. Un port, un certificat, deux protocolesTsgcHTTP3Server parle HTTP/3 sur QUIC via un port UDP. Associe-le à un serveur HTTP/2 existant et les clients anciens continuent de fonctionner en TCP, avec le même certificat que ton serveur HTTP/2 charge déjà.
  2. Alt-Svc, pour des mises à niveau automatiquesUne réponse HTTP/2 ordinaire porte un en-tête Alt-Svc: h3=":443". Les clients qui le comprennent ouvrent QUIC à la requête suivante, sans redirection ni second domaine.
  3. WebTransport, sur le même portUne requête Extended CONNECT fait passer un flux en WebTransport, ce qui donne à un client navigateur des flux bidirectionnels et des datagrammes en plus des requêtes HTTP/3 ordinaires.

Le client et le serveur partagent le même modèle de connexion, de flux et de datagrammes des deux côtés. La matrice complète des fonctionnalités →

Le composant serveur HTTP/3

Une partie de sgcWebSockets

Un complément de sgcWebSockets Enterprise.

La licence, le canal de support et le rythme des mises à jour sont ceux que tu as déjà. Chaque licence inclut le code source complet, un an de mises à jour et la redistribution libre des binaires.

Single

1 licence développeur. Utilisation sur une machine à la fois.

€149

Team

2 licences développeur. Utilisation sur deux machines à la fois.

€249

Site

Développeurs illimités. Toutes les machines de l’entreprise.

€399

sgcQUIC nécessite sgcWebSockets Enterprise, que tu peux ajouter à la même commande. Client et serveur QUIC, client et serveur HTTP/3, QPACK, Alt-Svc et WebTransport, pour Delphi, C++ Builder et .NET.

Voir les tarifs et les éditions
Témoignages

Ce que disent les développeurs

Plébiscité par des développeurs Delphi, C++ Builder, Lazarus et .NET dans le monde entier.

Votre bibliothèque sgcWebSockets est très utile et facile à configurer. Continuez votre excellent travail !
Simone Moretti Développeur Delphi
sgcWebSockets est incroyable et votre support est le meilleur !
Christian Meyer Fondateur & CTO
Merci beaucoup pour votre aide et votre support, j’adore vos composants.
Mark Steinfeld CTO

Livre du QUIC et du HTTP/3 sans quitter ton IDE.

Transport QUIC brut, client et serveur HTTP/3 et WebTransport, sur le moteur QUIC d’OpenSSL 3.5. Code source complet, redistribution libre des binaires, en complément de sgcWebSockets Enterprise.

Plus d’eSeGeCe

Autres produits d’eSeGeCe

sgcQUIC partage ses conventions avec les autres bibliothèques de composants eSeGeCe pour Delphi, C++ Builder et .NET. Elles sont livrées avec le code source complet et se déploient sans redevance.

sgcWebSockets

WebSocket, HTTP/2, MQTT, AMQP, WebRTC, IA et plus de 30 intégrations d’API. La licence Enterprise sur laquelle s’appuie sgcQUIC.

sgcHTML

Composants HTML et d’interface côté serveur sur Bootstrap 5 et htmx. Sers l’interface rendue sur ce même transport HTTP/3.

sgcAI

Composants IA, LLM et MCP pour Delphi et C++ Builder. Sept fournisseurs de LLM derrière un seul composant, plus MCP, embeddings et synthèse vocale. Autonome, le runtime sgcWebSockets Core est inclus.

sgcMQ

Composants clients MQTT, AMQP 0.9.1 et 1.0, Apache Kafka et STOMP pour Delphi et C++ Builder. Autonome, le runtime sgcWebSockets Core est inclus.

sgcAuth

Client OAuth2, client JWT et prise en charge de WebAuthn pour Delphi et C++ Builder. Autonome, le runtime sgcWebSockets Core est inclus.

sgcHTTP

Serveur HTTP, client HTTP/2, client gRPC et clients Google Cloud Pub/Sub, Calendar et FCM pour Delphi et C++ Builder. Autonome, le runtime sgcWebSockets Core est inclus.

sgcREST

Serveur REST, serveur OpenAPI et composants clients OpenAPI pour Delphi et C++ Builder. Autonome, le runtime sgcWebSockets Core est inclus.

sgcOpenAPI

Parser OpenAPI 3.x, générateur de SDK Pascal natif, composant serveur OpenAPI, et plus de 1 195 SDK cloud préconçus.

sgcSign

XAdES, PAdES, CAdES et ASiC pour les documents, Authenticode, ClickOnce, NuGet et VSIX pour le code.

sgcPDF

Crée, édite, affiche, signe, caviarde et valide des fichiers PDF en pur Object Pascal, sans DLL à déployer. Licence séparée.

sgcBiometrics

Windows Hello, capteurs d’empreintes digitales et Windows Biometric Framework pour Delphi et C++ Builder.

sgcIndy

Composants Indy TCP/IP mis à jour avec TLS moderne, IPv6 et HTTP/2, de Delphi 7 à 13.

Les derniers articles du blog

Voir tous les articles →

Tu vois la vue sgcQUIC d’eSeGeCe.

Montre-moi un autre angle →
Garantie satisfait ou remboursé de 30 joursPas satisfait ? Demandez un remboursement intégral dans les 30 jours suivant l'achat. Voir la politique de remboursement