Un servidor HTTP y cinco componentes cliente. TsgcHTTPServer publica endpoints HTTP y archivos estáticos desde tu propia aplicación. TsgcHTTP2Client habla HTTP/2 con flujos multiplexados sobre una sola conexión TLS y compresión de cabeceras HPACK. TsgcGRPCClient es un cliente gRPC construido sobre él, para llamadas Protocol Buffers unarias y de streaming. Otras tres clases llegan a Google Cloud por HTTPS simple: Pub/Sub, Calendar y Firebase Cloud Messaging.
Un inicio rápido narrado y subtitulado: un cliente HTTP/2 que envía muchas peticiones por una sola conexión y, después, una llamada gRPC sobre ese mismo transporte, todo desde Delphi. No se descarga nada hasta que pulses reproducir.
Llama a un endpoint HTTP/2 y haz una llamada gRPC, desde Delphi.
Ambos componentes se declaran en la unidad sgcHTTP y TsgcGRPCClient lleva su propia conexión HTTP/2 a través de su propiedad Client .
TsgcHTTP2Client habla HTTP/2 (RFC 9113): varias peticiones comparten una única conexión TCP como flujos independientes. Las cabeceras se comprimen con HPACK y h2 se negocia durante el handshake TLS mediante ALPN. Se cubren todos los verbos: Get, Post, Put, Patch, Delete y Options, cada uno con una llamada síncrona y una variante Async .
TsgcGRPCClient hereda la conexión multiplexada y añade encima el formato de transmisión gRPC. Call y CallAsync cubren los RPC unarios, ServerStreamingCall gestiona un flujo de respuestas a una petición, y OpenClientStream y OpenBidiStream cubren el streaming de cliente y el streaming bidireccional. RetryPolicy, Interceptors y ServiceConfig añaden reintentos y lógica transversal sin tocar los puntos de llamada.
Las cinco clases se reparten con claridad según lo que necesitan por debajo. HTTP/2 y gRPC necesitan ALPN, y eso significa sgcCustomIndy. Google Cloud no necesita nada más que HTTPS y una cuenta de servicio, algo que el runtime Core incluido ya ofrece. El servidor HTTP procede de ese mismo runtime.
TsgcHTTPServer publica endpoints HTTP desde tu propia aplicación. Establece Port, gestiona OnCommandGet, activa Active y cada petición llega a tu código. OnCommandOther cubre verbos como PUT y DELETE. Se incluye con el runtime Core.
Apunta DocumentRoot a una carpeta y el servidor devuelve los archivos estáticos desde ella. HTTPUploadFiles guarda en disco los archivos subidos, MaxRequestBodySize limita el tamaño de los cuerpos de petición, y HTTPCompression y KeepAlive mantienen las respuestas pequeñas y las conexiones abiertas.
SSL y SSLOptions activan TLS, Authentication y OnAuthentication protegen los endpoints, SessionState controla las sesiones, y ThreadPool y MaxConnections regulan cómo escala. El mismo motor que el servidor WebSocket, sin la parte WebSocket.
TsgcHTTP2Client multiplexa flujos independientes sobre una sola conexión TLS, comprime las cabeceras con HPACK y negocia h2 mediante ALPN. Connect, Get, Post, Put, Patch, Delete y Options, síncrono o Asyncregula el ritmo de los repintados.
TsgcGRPCClient se apoya en el cliente HTTP/2: mensajes Protocol Buffers con prefijo de longitud sobre flujos HTTP/2, con RPC unarios, de streaming de servidor, de streaming de cliente y bidireccionales, además de política de reintentos e interceptores.
TsgcHTTPGoogleCloud_PubSub_Client, TsgcHTTPGoogleCloud_Calendar_Client y TsgcHTTPGoogleCloud_FCM_Client llegan a Pub/Sub, Calendar y Firebase Cloud Messaging, autenticados con una cuenta de servicio de Google. Ninguno necesita sgcCustomIndy.
Los eventos exponen el ciclo de vida de la conexión: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment para cuerpos fragmentados, OnHTTP2PushPromise para server push, OnHTTP2GoAway y OnHTTP2Disconnect. Nada del ciclo de vida del flujo queda oculto.
Los clientes HTTP/2 y gRPC se construyen sobre sgcCustomIndy, que cubre el mismo rango de plataformas que el propio sgcWebSockets. Los clientes de Google Cloud usan HTTPS simple, así que funcionan allí donde funciona el runtime Core. De Delphi 7 a RAD Studio 13, y C++ Builder.
Cada licencia incluye el código fuente completo del servidor HTTP, de los cinco clientes y del runtime incluido, de modo que las implementaciones a nivel de red se recorren paso a paso en tu propio depurador. La distribución no paga royalties.
Crea el componente, define un puerto o apúntalo a un host, enlaza el evento y listo. El mismo código compila en Delphi 7 a 13 y en C++ Builder.
uses
sgcHTTP;
var
HTTP2: TsgcHTTP2Client;
begin
// HTTP/2: multiplexed requests over one TLS connection
HTTP2 := TsgcHTTP2Client.Create(nil);
HTTP2.Host := 'https://api.example.com';
HTTP2.OnHTTP2Response := HTTP2Response;
HTTP2.Active := True;
HTTP2.GetAsync('/v1/status');
end;
procedure TForm1.HTTP2Response(Sender: TObject;
const Connection: TsgcHTTP2ConnectionClient;
const Request: TsgcHTTP2RequestProperty;
const Response: TsgcHTTP2ResponseProperty);
begin
Memo1.Lines.Add(Response.DataString);
end;uses
sgcHTTP;
var
GRPC: TsgcGRPCClient;
begin
// gRPC: built on the HTTP/2 client, unary and streaming RPC
GRPC := TsgcGRPCClient.Create(nil);
GRPC.Client.Host := 'https://grpc.example.com';
GRPC.OnGRPCResponse := GRPCResponse;
GRPC.CallAsync('example.OrderService', 'GetOrder', RequestBytes);
end;
procedure TForm1.GRPCResponse(Sender: TObject;
const aResponse: TsgcGRPCResponse);
begin
Memo1.Lines.Add(aResponse.DataString);
end;uses
sgcHTTP_Server;
var
Server: TsgcHTTPServer;
begin
// HTTP server: endpoints and static files
Server := TsgcHTTPServer.Create(nil);
Server.Port := 8080;
Server.DocumentRoot := 'C:\www';
Server.OnCommandGet := ServerCommandGet;
Server.Active := True;
end;
procedure TForm1.ServerCommandGet(AContext: TIdContext;
ARequestInfo: TIdHTTPRequestInfo;
AResponseInfo: TIdHTTPResponseInfo);
begin
if ARequestInfo.Document = '/api/status' then
begin
AResponseInfo.ContentType := 'application/json';
AResponseInfo.ContentText := '{"status":"ok"}';
end;
end;La misma forma en Object Pascal y en C++ Builder. La matriz de características completa →
Qué necesita sgcHTTP de ti y qué no. Las dos respuestas son breves, y las dos están en esta página y no en la letra pequeña.
cliente necesita sgcCustomIndy
TsgcHTTPServer no, se incluye con el runtime Core
TsgcHTTP2Client sí, para ALPN
TsgcGRPCClient sí, se apoya en TsgcHTTP2Client
TsgcHTTPGoogleCloud_PubSub_Client no, HTTPS simple
TsgcHTTPGoogleCloud_Calendar_Client no, HTTPS simple
TsgcHTTPGoogleCloud_FCM_Client no, HTTPS simple
HTTP/2 negocia h2 con ALPN durante el handshake TLS.
La biblioteca Indy estándar que se incluye con RAD Studio
no admite ALPN, por lo que tanto HTTP/2 como gRPC se
construyen sobre sgcCustomIndy.El runtime Core de sgcWebSockets está incluido: el servidor HTTP, la pila cliente HTTP/TLS por la que cada cliente envía sus peticiones y la capa JSON que decodifica las respuestas de Google Cloud. Un solo instalador, con el código fuente completo.
La negociación ALPN no está soportada por la biblioteca Indy estándar, así que TsgcHTTP2Client y, por extensión, TsgcGRPCClient se construyen sobre sgcCustomIndy en su lugar. Siempre se incluye al pedir sgcHTTP, y el precio mostrado ya lo cubre.
Los tres clientes de Google Cloud se autentican con el id de proyecto, el correo de cliente y la clave privada de una cuenta de servicio de Google, y llaman a las API REST sobre la pila HTTPS simple del runtime Core. Sin biblioteca nativa, sin sgcCustomIndy.
sgcHTTP está dirigido a Delphi 7 hasta RAD Studio 13 y C++ Builder. Los mismos componentes también están dentro de sgcWebSockets Enterprise, así que una licencia Enterprise o All-Access que ya tengas puede cubrirte. El instalador de prueba es el de sgcWebSockets All-Access, por lo que hoy puedes evaluar las cinco clases.
sgcHTTP implementa las superficies publicadas de HTTP/2, gRPC y la API REST de Google Cloud en lugar de envolver un SDK de terceros, así que los flujos, las cabeceras, los RPC y las notificaciones push son métodos y eventos de primera clase, y con el código fuente completo nada de lo que hay en medio es una caja negra.
sgcHTTP incluye el runtime Core de sgcWebSockets sobre el que está construido, y el complemento sgcCustomIndy que necesitan HTTP/2 y gRPC se incluye siempre. Cada licencia incluye el código fuente completo y distribución sin royalties.
1 licencia de desarrollador. Úsala en una máquina a la vez.
2 licencias de desarrollador. Úsalas en dos máquinas a la vez.
Desarrolladores ilimitados. Todas las máquinas de la empresa.
Componentes cliente HTTP/2, gRPC y Google Cloud para Delphi y C++ Builder, con el runtime Core de sgcWebSockets incluido. ¿Ya tienes sgcWebSockets Enterprise? Los mismos componentes también están ahí.
Ver precios y licenciasLa 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í!
sgcWebSockets es increíble y vuestro soporte es el mejor.
Muchas gracias por vuestra ayuda y soporte, me encantan vuestros componentes.
Un servidor HTTP, HTTP/2 multiplexado, gRPC con streaming y tres clientes de Google Cloud, con el runtime Core de sgcWebSockets incluido y el código fuente completo.
Visión generalMatriz de característicasCliente HTTP/2Cliente gRPC
sgcHTTP comparte convenciones con las demás bibliotecas de componentes de eSeGeCe para Delphi, C++ Builder y .NET. Incluyen el código fuente completo y se distribuyen sin royalties.
WebSocket, HTTP/2, MQTT, AMQP, WebRTC, IA y más de 30 integraciones de API para Delphi, C++ Builder, Lazarus y .NET. Su edición Enterprise incluye también gRPC.
Componentes de servidor REST, servidor OpenAPI y cliente OpenAPI para Delphi y C++ Builder. Publica API REST a partir de un contrato OpenAPI 3.x o consume cualquier API descrita con OpenAPI.
Cliente OAuth2, cliente JWT y compatibilidad con WebAuthn para Delphi y C++ Builder. Producto independiente, incluye el runtime de sgcWebSockets Core.
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.
Componentes cliente de Telegram y WhatsApp Business para Delphi y C++ Builder. Independiente, con el runtime Core de sgcWebSockets incluido.
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.
Componentes HTML y de interfaz en el servidor sobre Bootstrap 5 y htmx para Delphi, C++ Builder y .NET.
Transporte QUIC en bruto y un cliente y servidor HTTP/3, con WebTransport. Un add-on de sgcWebSockets Enterprise.
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.
XAdES, PAdES, CAdES y ASiC para documentos, Authenticode, ClickOnce, NuGet y VSIX para código.
Crea, edita, visualiza, firma, redacta y valida archivos PDF en Object Pascal puro, sin ninguna DLL que implementar. Con licencia propia.
Windows Hello, sensores de huella dactilar y Windows Biometric Framework para Delphi y C++ Builder.
Componentes Indy TCP/IP actualizados con TLS moderno, IPv6 y HTTP/2 para Delphi 7 a 13.
