MÍRALO FUNCIONAR

sgcHTTP en dos minutos

Un servidor HTTP, clientes HTTP/2 y gRPC para Delphi y C++Builder, más integraciones listas para usar con Google Cloud, Amazon y Apple Push.

ANTES DE COMPRAR

Dos cosas que conviene saber primero

Qué necesita sgcHTTP de tu parte, y qué no necesita. Las dos respuestas son breves.

sgcHTTP es autocontenido

Independiente, el runtime sgcWebSockets Core viene 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 SKU, un solo instalador.

El código fuente completo se entrega con cada licencia, así que puedes recorrer paso a paso el servidor HTTP, los cinco clientes y el runtime que hay debajo en tu propio depurador, en lugar de verlos desaparecer dentro de un binario.

Complemento necesario para dos de cinco

HTTP/2 y gRPC necesitan sgcCustomIndy

HTTP/2 negocia el protocolo h2 con ALPN durante el handshake TLS, y la librería Indy estándar que se instala con RAD Studio no admite ALPN. El cliente HTTP/2 y el cliente gRPC de sgcHTTP están construidos en su lugar sobre sgcCustomIndy, que siempre se incluye al pedir sgcHTTP, y el precio que se muestra ya lo cubre.

Los tres clientes de Google Cloud, Pub/Sub, Calendar y Firebase Cloud Messaging, son HTTPS puro. Funcionan sobre el runtime Core sin más y no necesitan sgcCustomIndy en absoluto.

QUÉ INCLUYE

Tres componentes en la paleta, tres clientes de Google Cloud

El servidor HTTP, el cliente HTTP/2 y el cliente gRPC son componentes no visuales en la página de paleta SGC HTTP. El servidor está declarado en la unidad sgcHTTP_Server del runtime Core incluido, los dos clientes en la unidad sgcHTTP. Suéltalo en un formulario o créalo por código, configura las opciones de conexión, conecta los eventos y luego llama a los métodos de petición tipados. Los tres clientes de Google Cloud viven en la misma unidad como clases solo de código, no hay nada que soltar en un formulario: crea uno, configura GoogleCloudOptions y llama a sus métodos directamente.

Servidor HTTP1 componente

Publica endpoints HTTP y archivos estáticos

TsgcHTTPServer convierte tu aplicación Delphi o C++ Builder en un servidor HTTP. Configura Port, gestiona OnCommandGet y pon Active a true, y cada petición llega a tu código con sus objetos de petición y respuesta, mientras que OnCommandOther cubre verbos como PUT y DELETE. Apunta DocumentRoot a una carpeta y el servidor devuelve archivos estáticos desde ella. HTTPCompression comprime las respuestas, KeepAlive reutiliza las conexiones, SessionState con OnSessionStart y OnSessionEnd gestiona las sesiones, MaxRequestBodySize limita el tamaño de los cuerpos de petición y HTTPUploadFiles guarda en disco los archivos subidos. Para producción, SSL y SSLOptions activan TLS, Authentication y OnAuthentication protegen tus endpoints, y ThreadPool y MaxConnections controlan cómo escala. Es el mismo motor que el servidor WebSocket de sgcWebSockets sin la parte WebSocket, y se incluye con el runtime Core.

TsgcHTTPServer Se incluye con el runtime Core

HTTP/21 componente

Streams multiplexados sobre una sola conexión TLS

TsgcHTTP2Client habla HTTP/2 (RFC 9113): varias peticiones comparten una sola conexión TCP como streams independientes, así que una respuesta lenta no bloquea a las demás que van detrás. Las cabeceras se comprimen con HPACK, y el protocolo h2 se negocia durante el handshake TLS mediante ALPN, la razón por la que el componente está construido sobre sgcCustomIndy en lugar de la librería Indy estándar. Se cubren todos los verbos, Connect, Get, Post, Put, Patch, Delete y Options, cada uno con una llamada síncrona y un gemelo Async. Los eventos exponen el ciclo de vida de la conexión: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment para cuerpos fragmentados, OnHTTP2PushPromise para el server push, OnHTTP2GoAway y OnHTTP2Disconnect. HTTP2Options configura el frame de settings local, y TLSOptions y Authentication se heredan del resto de la pila HTTP de sgc.

TsgcHTTP2Client Requiere sgcCustomIndy

gRPC1 componente

RPC unario y en streaming sobre el cliente HTTP/2

TsgcGRPCClient está construido sobre el cliente HTTP/2, así que hereda la conexión multiplexada y añade encima el formato de red de gRPC: mensajes Protocol Buffers con prefijo de longitud sobre streams HTTP/2. Call y CallAsync cubren las RPC unarias, ServerStreamingCall gestiona un stream de respuestas para una petición, y OpenClientStream/SendStreamMessage/CloseClientStream junto con OpenBidiStream/SendBidiMessage/CloseBidiStream cubren las RPC de streaming de cliente y bidireccional. OnGRPCResponse, OnGRPCStreamMessage y OnGRPCStreamEnd entregan el tráfico, y RetryPolicy, Interceptors y ServiceConfig añaden comportamiento de reintento, lógica transversal y configuración del servicio sin tocar los puntos de llamada. Igual que el cliente HTTP/2 sobre el que está construido, necesita sgcCustomIndy para ALPN.

TsgcGRPCClient Requiere sgcCustomIndy

Google Cloud3 clases

Pub/Sub, Calendar y notificaciones push, HTTPS puro

Tres clases más llegan a los servicios de Google Cloud sobre HTTPS puro, autenticadas con una cuenta de servicio de Google, y ninguna necesita sgcCustomIndy. TsgcHTTPGoogleCloud_PubSub_Client publica y extrae mensajes y gestiona topics, suscripciones y snapshots: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription y el resto de la superficie REST de Pub/Sub. TsgcHTTPGoogleCloud_Calendar_Client envuelve la Google Calendar API v3: NewCalendar, NewEvent, LoadEvents y LoadCalendars, con los eventos OnGetCalendar y OnGetCalendarEvent para la sincronización. TsgcHTTPGoogleCloud_FCM_Client envía un payload de notificación push a un proyecto de Firebase con una sola llamada, SendMessage. Las tres son clases solo de código: crea una, configura GoogleCloudOptions y llama a sus métodos.

TsgcHTTPGoogleCloud_PubSub_Client TsgcHTTPGoogleCloud_Calendar_Client TsgcHTTPGoogleCloud_FCM_Client

CÓMO FUNCIONA

Dos dependencias, no cinco

Las cinco clases se dividen claramente según lo que necesitan por debajo. HTTP/2 y gRPC necesitan ALPN, lo que significa sgcCustomIndy. Google Cloud no necesita nada más allá de HTTPS y una cuenta de servicio, algo que el runtime Core incluido ya proporciona.

HTTP/2 necesita ALPN, así que necesita sgcCustomIndy

Application-Layer Protocol Negotiation elige h2 durante el handshake TLS, y la librería Indy estándar que se instala con RAD Studio no admite ALPN. TsgcHTTP2Client está construido en su lugar sobre sgcCustomIndy, la librería Indy personalizada de eSeGeCe.

gRPC es Protocol Buffers viajando sobre el cliente HTTP/2

TsgcGRPCClient no abre su propia conexión, su propiedad Client es un TsgcHTTP2Client. Las llamadas unarias, de streaming de servidor, de streaming de cliente y bidireccionales viajan todas como streams HTTP/2 por debajo.

Google Cloud es HTTPS más una cuenta de servicio

Los tres clientes de Google Cloud se autentican con GoogleCloudOptions.JWT, el project id, el client email y la private key de una cuenta de servicio de Google, y llaman a las API REST sobre la pila HTTPS pura del runtime Core. OnAuthToken y OnAuthTokenError exponen el intercambio de tokens.

El runtime Core viene en la caja

Independiente, el runtime sgcWebSockets Core viene incluido. Aporta TsgcHTTPServer y la pila cliente HTTP/TLS por la que llaman los cinco clientes, y su código fuente completo forma parte del paquete como todo lo demás.

INICIO RÁPIDO

Servidor HTTP, HTTP/2 y gRPC, lado a lado

Los dos clientes están declarados en la unidad sgcHTTP y el servidor en sgcHTTP_Server, y TsgcGRPCClient lleva su propia conexión HTTP/2 a través de su propiedad Client. El mismo código compila en Delphi 7 a 13 y en C++ Builder.

uses
  sgcHTTP, sgcHTTP_Server;

var
  Server: TsgcHTTPServer;
  HTTP2: TsgcHTTP2Client;
  GRPC: TsgcGRPCClient;
begin
  // HTTP server: endpoints and static files
  Server := TsgcHTTPServer.Create(nil);
  Server.Port := 8080;
  Server.DocumentRoot := 'C:\www';
  Server.OnCommandGet := ServerCommandGet;
  Server.Active := True;

  // 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');

  // 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.HTTP2Response(Sender: TObject;
  const Connection: TsgcHTTP2ConnectionClient;
  const Request: TsgcHTTP2RequestProperty;
  const Response: TsgcHTTP2ResponseProperty);
begin
  Memo1.Lines.Add(Response.DataString);
end;

procedure TForm1.GRPCResponse(Sender: TObject;
  const aResponse: TsgcGRPCResponse);
begin
  Memo1.Lines.Add(aResponse.DataString);
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;

// include: sgcHTTP.hpp, sgcHTTP_Server.hpp

// HTTP server: endpoints and static files
TsgcHTTPServer *Server = new TsgcHTTPServer(this);
Server->Port = 8080;
Server->DocumentRoot = "C:\\www";
Server->OnCommandGet = ServerCommandGet;
Server->Active = true;

// HTTP/2: multiplexed requests over one TLS connection
TsgcHTTP2Client *HTTP2 = new TsgcHTTP2Client(this);
HTTP2->Host = "https://api.example.com";
HTTP2->OnHTTP2Response = HTTP2Response;
HTTP2->Active = true;

HTTP2->GetAsync("/v1/status");

// gRPC: built on the HTTP/2 client, unary and streaming RPC
TsgcGRPCClient *GRPC = new TsgcGRPCClient(this);
GRPC->Client->Host = "https://grpc.example.com";
GRPC->OnGRPCResponse = GRPCResponse;

GRPC->CallAsync("example.OrderService", "GetOrder", RequestBytes);

void __fastcall TForm1::HTTP2Response(TObject *Sender,
    const TsgcHTTP2ConnectionClient* Connection,
    const TsgcHTTP2RequestProperty* Request,
    const TsgcHTTP2ResponseProperty* Response)
{
  Memo1->Lines->Add(Response->DataString);
}

void __fastcall TForm1::GRPCResponse(TObject *Sender,
    const TsgcGRPCResponse* aResponse)
{
  Memo1->Lines->Add(aResponse->DataString);
}

void __fastcall TForm1::ServerCommandGet(TIdContext *AContext,
    TIdHTTPRequestInfo *ARequestInfo, TIdHTTPResponseInfo *AResponseInfo)
{
  if (ARequestInfo->Document == "/api/status")
  {
    AResponseInfo->ContentType = "application/json";
    AResponseInfo->ContentText = "{\"status\":\"ok\"}";
  }
}

PLATAFORMAS

Una dependencia para dos clientes, ninguna para tres

El cliente HTTP/2 y el cliente gRPC se construyen sobre sgcCustomIndy, que cubre el mismo rango de plataformas que el propio sgcWebSockets. Los clientes de Google Cloud son HTTPS puro, así que se ejecutan en cualquier lugar donde lo haga el runtime Core.

TsgcHTTP2Client y TsgcGRPCClient Construidos sobre sgcCustomIndy para ALPN

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Clientes de Google Cloud HTTPS puro, no necesita sgcCustomIndy

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Soporte de IDE Un único árbol de código, paquetes de diseño por versión

Delphi 7 a 13 C++ Builder

Instalador de prueba La prueba All-Access de sgcWebSockets incluye los componentes de sgcHTTP

Una sola descarga, el servidor y los cinco clientes

Descargar el instalador de prueba →

PRECIOS

Un paquete independiente

sgcHTTP se licencia por separado, desde €398 para un solo desarrollador. Todas las licencias incluyen código fuente completo, 1 año de actualizaciones y un descuento de renovación del 50% al 70%: un 50% al renovar un pack, un 60% con dos y un 70% con tres o más. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP y sgcREST cuentan cada uno como un pack. sgcHTTP también está incluido en el paquete All-Access.

sgcHTTP

€398

Disponible en licencias Single, Team y Site.

Servidor HTTP con archivos estáticos, sesiones y TLS
Cliente HTTP/2 con multiplexación y HPACK
Cliente gRPC, RPC unario y en streaming
Clientes de Google Cloud Pub/Sub, Calendar y FCM
Runtime sgcWebSockets Core incluido
Delphi 7 a 13 y C++ Builder
Código fuente completo
1 año de actualizaciones

HTTP/2 y gRPC necesitan el complemento sgcCustomIndy. Siempre se incluye en tu pedido, y el precio que se muestra ya lo cubre.

Comprar licencia Single €398

Team €648 Site €1,048

El pedido muestra tres líneas: el derecho de uso del runtime sgcWebSockets Core, que se factura a cero, el propio paquete sgcHTTP, y el complemento sgcCustomIndy, siempre incluido. Todos los detalles de precios.

MÁS DE ESEGECE

Otros productos de eSeGeCe

Combina sgcHTTP con nuestras otras librerías de componentes para Delphi, C++ Builder y .NET.

sgcCustomIndy

La librería Indy personalizada sobre la que están construidos los clientes HTTP/2 y gRPC de sgcHTTP: ALPN, TLS 1.3 y enlazado estático de OpenSSL.

Más información →

sgcWebSockets

La librería completa: clientes y servidores WebSocket, HTTP/2, gRPC, IoT, P2P y componentes de IA. Su edición Enterprise también incluye gRPC.

Más información →

sgcAI

Componentes de IA, LLM y MCP. Un solo componente de chat llega a OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok y Mistral.

Más información →

sgcMQ

Componentes cliente nativos de MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka y STOMP, con el runtime Core incluido.

Más información →

sgcCrypto

Cifrado simétrico y asimétrico, funciones hash y algoritmos post-cuánticos. Se incluye gratis desde sgcWebSockets Standard.

Más información →

sgcSocial

Componentes cliente de WhatsApp Business Cloud API y Telegram TDLib, con el runtime Core incluido.

Más información →

sgcQUIC

Componentes cliente y servidor de QUIC (RFC 9000) y HTTP/3 (RFC 9114) construidos sobre el motor QUIC nativo de OpenSSL 3.5.

Más información →

sgcWebRTC

Motor WebRTC completo: llamadas de audio/vídeo, canales de datos y compartición de pantalla. Un complemento para sgcWebSockets Enterprise.

Más información →

sgcHTTP: servidor HTTP, componentes de HTTP/2, gRPC y Google Cloud para Delphi y C++ Builder

sgcHTTP en dos minutos

Dos cosas que conviene saber primero

sgcHTTP es autocontenido

HTTP/2 y gRPC necesitan sgcCustomIndy

Tres componentes en la paleta, tres clientes de Google Cloud

Publica endpoints HTTP y archivos estáticos

Streams multiplexados sobre una sola conexión TLS

RPC unario y en streaming sobre el cliente HTTP/2

Pub/Sub, Calendar y notificaciones push, HTTPS puro

Dos dependencias, no cinco

Servidor HTTP, HTTP/2 y gRPC, lado a lado

Una dependencia para dos clientes, ninguna para tres

Un paquete independiente

sgcHTTP

HTTP moderno, gRPC y Google Cloud desde código nativo

Otros productos de eSeGeCe

sgcCustomIndy

sgcWebSockets

sgcAI

sgcMQ

sgcCrypto

sgcSocial

sgcQUIC

sgcWebRTC