sgcQUIC Ahórrate los viajes de ida y vuelta. QUIC nativo.

TCP más TLS necesita tres viajes de ida y vuelta antes de que llegue el primer byte de una respuesta. QUIC reúne el transporte y el handshake criptográfico en uno solo, y una conexión reanudada puede enviar datos en el primer paquete. sgcQUIC ofrece a Delphi, C++ Builder y .NET un transporte QUIC nativo y un cliente y servidor HTTP/3 construidos encima, sobre el motor QUIC de OpenSSL 3.5.

Un complemento para sgcWebSockets Enterprise. Ver precios →
  • RFC 9000, 9114, 9204
  • WebTransport (RFC 9220)
  • 0-RTT
  • Migración de conexión
  • Delphi
  • C++ Builder
  • .NET
  • 4Componentes en una sola página de la paleta
  • 4RFC: 9000, 9114, 9204 y 9220
  • 1Viaje de ida y vuelta antes de los datos, frente a tres de TCP más TLS
  • 0-RTTPrimera petición en el primer paquete de una sesión reanudada
  • 3Lenguajes: Delphi, C++ Builder y .NET
Por qué QUIC

La misma seguridad TLS 1.3. Menos viajes por la red.

El handshake de transporte, el handshake TLS y la primera petición cuestan cada uno un viaje de ida y vuelta sobre TCP. QUIC transporta los tres en un solo intercambio.

TCP + TLS 1.3 QUIC (HTTP/3) Cliente Servidor Cliente Servidor SYN SYN-ACK ACK ClientHello ServerHello, cert Finished GET /pets/42 200 OK 3 viajes de ida y vuelta antes de los datos Initial + Handshake + GET Handshake + 200 OK 1 viaje de ida y vuelta antes de los datos En una sesión reanudada 0-RTT: GET + datos tempranos La misma seguridad TLS 1.3. Menos viajes por la red.

TCP + TLS: tres viajes de ida y vuelta

SYN, SYN-ACK y ACK abren el socket. ClientHello, ServerHello y Finished configuran TLS. Solo entonces sale la primera petición.

QUIC: un viaje de ida y vuelta

QUIC reúne el transporte y el handshake criptográfico en un solo intercambio, así la petición viaja con el handshake y la respuesta vuelve con él.

Reanudada: 0-RTT

Un cliente que ya se ha conectado antes puede enviar su primera petición en el primer paquete, antes de que termine el handshake.

Míralo en marcha

QUIC y HTTP/3 desde Delphi, en pocos minutos.

Un inicio rápido narrado y subtitulado: un servidor y un cliente HTTP/3, y después una conexión QUIC en bruto con varios streams. No se descarga nada hasta que pulsas reproducir.

Inicio rápido de sgcQUIC

Ejecuta un servidor y un cliente HTTP/3, y abre una conexión QUIC en bruto desde Delphi.

  1. El cliente HTTP/3Créalo, llama a Get con una URL y lee la respuesta. Los verbos, los códigos de estado y las cabeceras son los que ya conoces.
  2. Síncrono o asíncronoGestiona OnResponse y OnError, llama a GetAsync y la petición se ejecuta sin bloquear tu formulario.
  3. El servidor HTTP/3Crea un TsgcHTTP3Server, asígnale un puerto, un certificado y una clave privada, y gestiona OnH3Request.
  4. QUIC en bruto y muchos streamsTsgcQUICClient por sí solo, con EnableMultiStream para streams independientes, cada uno ordenado y con control de flujo.
  5. Antes de desplegarQUIC viaja sobre UDP, así que un cortafuegos que solo abre el TCP 443 lo bloquea.
Cuatro componentes

QUIC en bruto, o HTTP/3 encima.

Usa TsgcQUICClient y TsgcQUICServer para un transporte desnudo con tu propio entramado, o ve directo a TsgcHTTP3Client y TsgcHTTP3Server cuando el formato en el cable es HTTP.

Cliente y servidor QUIC

TsgcQUICClient and TsgcQUICServer hablan QUIC en bruto: varios streams independientes en una sola conexión cifrada, datagramas no fiables y migración de conexión cuando cambia la dirección IP del cliente a mitad de sesión.

Ver los componentes QUIC →

Cliente y servidor HTTP/3

TsgcHTTP3Client and TsgcHTTP3Server añaden semántica HTTP encima: cabeceras de petición y respuesta comprimidas con QPACK, descubrimiento con Alt-Svc, y los mismos métodos y códigos de estado que ya usa tu código HTTP/2.

Ver los componentes HTTP/3 →

Reanudación de sesión 0-RTT

Un cliente que ya se ha conectado antes puede enviar su primera petición en el primer paquete, antes de que termine el handshake.

Migración de conexión

Un Connection ID identifica la sesión, no la dirección IP, así un teléfono que pasa de Wi-Fi a datos móviles mantiene abiertos sus streams.

WebTransport

Streams bidireccionales y datagramas no fiables sobre una sola petición Extended CONNECT, para clientes de navegador que hablan WebTransport.

QUIC nativo, sin dependencias externas

El handshake QUIC y TLS 1.3 se ejecuta sobre el propio motor QUIC de OpenSSL 3.5. No hay ninguna biblioteca QUIC aparte que compilar o incluir.

Construido sobre los estándares

QUIC y HTTP/3, al pie de la letra de las RFC.

sgcQUIC no es una implementación parcial. Cubre el transporte, el entramado, la compresión de cabeceras y la extensión WebTransport, sobre el motor QUIC nativo de OpenSSL 3.5.

RFC 9000

El protocolo de transporte QUIC: streams, datagramas, control de flujo y migración de conexión.

RFC 9114

HTTP/3, la misma semántica de petición y respuesta que HTTP/2, transportada sobre streams QUIC.

RFC 9204

Compresión de cabeceras QPACK, diseñada para la entrega de streams fuera de orden de QUIC.

RFC 9220

WebTransport sobre HTTP/3, streams bidireccionales y datagramas en una sola petición Extended CONNECT.

El código

Una petición sobre HTTP/3.

La misma forma que cualquier otro cliente HTTP de sgcWebSockets: asigna propiedades, gestiona un evento, llama a un método. El lado servidor es un componente y un manejador.

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 puerto, un certificado, dos protocolosTsgcHTTP3Server habla HTTP/3 sobre QUIC en un puerto UDP. Combínalo con un servidor HTTP/2 existente y los clientes antiguos siguen funcionando por TCP, con el mismo certificado que ya carga tu servidor HTTP/2.
  2. Alt-Svc, para que la actualización sea automáticaUna respuesta HTTP/2 normal lleva una cabecera Alt-Svc: h3=":443". Los clientes que la entienden abren QUIC en la siguiente petición, sin redirección ni un segundo dominio.
  3. WebTransport, en el mismo puertoUna petición Extended CONNECT convierte un stream en WebTransport y da a un cliente de navegador streams bidireccionales y datagramas junto a las peticiones HTTP/3 normales.

El cliente y el servidor comparten el mismo modelo de conexión, stream y datagrama en ambos lados. La matriz de características completa →

El componente de servidor HTTP/3

Parte de sgcWebSockets

Un complemento para sgcWebSockets Enterprise.

La licencia, el canal de soporte y el ritmo de actualizaciones son los que ya tienes. Cada licencia incluye el código fuente completo, un año de actualizaciones y distribución libre de royalties.

Single

1 licencia de desarrollador. Úsala en una máquina a la vez.

€149

Team

2 licencias de desarrollador. Úsalas en dos máquinas a la vez.

€249

Site

Desarrolladores ilimitados. Todas las máquinas de la empresa.

€399

sgcQUIC requiere sgcWebSockets Enterprise, que puedes añadir al mismo pedido. Cliente y servidor QUIC, cliente y servidor HTTP/3, QPACK, Alt-Svc y WebTransport, para Delphi, C++ Builder y .NET.

Ver precios y ediciones
Testimonios

Qué dicen los desarrolladores

La confianza de desarrolladores de Delphi, C++ Builder, Lazarus y .NET en todo el mundo.

Vuestra librería sgcWebSockets es muy útil y fácil de configurar. ¡Seguid así!
Simone Moretti Desarrollador Delphi
sgcWebSockets es increíble y vuestro soporte es el mejor.
Christian Meyer Fundador y CTO
Muchas gracias por vuestra ayuda y soporte, me encantan vuestros componentes.
Mark Steinfeld CTO

Entrega QUIC y HTTP/3 sin salir de tu IDE.

Transporte QUIC en bruto, cliente y servidor HTTP/3 y WebTransport, sobre el motor QUIC de OpenSSL 3.5. Código fuente completo y distribución libre de royalties, como complemento de sgcWebSockets Enterprise.

Más de eSeGeCe

Otros productos de eSeGeCe

sgcQUIC comparte convenciones con las demás bibliotecas de componentes de eSeGeCe para Delphi, C++ Builder y .NET. Se entregan con código fuente completo y se distribuyen libres de royalties.

sgcWebSockets

WebSocket, HTTP/2, MQTT, AMQP, WebRTC, IA y más de 30 integraciones de APIs. La licencia Enterprise sobre la que se construye sgcQUIC.

sgcHTML

Componentes HTML y de interfaz del lado del servidor sobre Bootstrap 5 y htmx. Sirve la interfaz renderizada sobre el mismo transporte HTTP/3.

sgcAI

Componentes de IA, LLM y MCP para Delphi y C++ Builder. Siete proveedores de LLM tras un único componente, además de MCP, embeddings y voz. Producto independiente, incluye el runtime de sgcWebSockets Core.

sgcMQ

Componentes cliente de MQTT, AMQP 0.9.1 y 1.0, Apache Kafka y STOMP para Delphi y C++ Builder. Producto independiente, incluye el runtime de sgcWebSockets Core.

sgcAuth

Cliente OAuth2, cliente JWT y compatibilidad con WebAuthn para Delphi y C++ Builder. Producto independiente, incluye el runtime de sgcWebSockets Core.

sgcHTTP

Servidor HTTP, cliente HTTP/2, cliente gRPC y clientes de Google Cloud Pub/Sub, Calendar y FCM para Delphi y C++ Builder. Producto independiente, incluye el runtime de sgcWebSockets Core.

sgcREST

Componentes de servidor REST, servidor OpenAPI y cliente OpenAPI para Delphi y C++ Builder. Producto independiente, incluye el runtime de sgcWebSockets Core.

sgcOpenAPI

Parser de OpenAPI 3.x, generador nativo de SDK en Pascal, componente de servidor OpenAPI y más de 1.195 SDK en la nube ya generados.

sgcSign

XAdES, PAdES, CAdES y ASiC para documentos, Authenticode, ClickOnce, NuGet y VSIX para código.

sgcPDF

Crea, edita, visualiza, firma, redacta y valida ficheros PDF en Object Pascal puro, sin DLL que distribuir. Se licencia por separado.

sgcBiometrics

Windows Hello, sensores de huella dactilar y Windows Biometric Framework para Delphi y C++ Builder.

sgcIndy

Componentes Indy TCP/IP actualizados con TLS moderno, IPv6 y HTTP/2 para Delphi 7 a 13.

Lo último del blog

Ver todas las publicaciones →

Estás viendo la vista sgcQUIC de eSeGeCe.

Mostrar otro enfoque →
Garantía de devolución de 30 días¿No estás satisfecho? Solicita un reembolso completo en los 30 días posteriores a la compra. Ver política de reembolso