Producto independienteServidor HTTP, HTTP/2, gRPC & Google Cloud
sgcHTTP: servidor HTTP, componentes de HTTP/2, gRPC y Google Cloud para Delphi y C++ Builder
Un servidor HTTP, un gateway FastCGI / SCGI y cinco componentes cliente. TsgcHTTPServer publica endpoints HTTP y archivos estáticos desde tu propia aplicación: configura Port, gestiona OnCommandGet y pon Active a true. TsgcHTTPGateway reenvía sus peticiones a PHP-FPM y a servidores FastCGI o SCGI de Python, de modo que las aplicaciones PHP y Python se ejecutan detrás de tu servidor, sin Apache ni nginx por delante. TsgcHTTP2Client habla HTTP/2 con streams multiplexados sobre una sola conexión TLS y compresión de cabeceras HPACK. TsgcGRPCClient es un cliente gRPC construido encima, para llamadas unarias y en streaming de Protocol Buffers. Tres clases más llegan a Google Cloud sobre HTTPS puro: Pub/Sub, Calendar y Firebase Cloud Messaging. sgcHTTP es independiente, incluye el runtime sgcWebSockets Core sobre el que están construidos el servidor, el gateway y los cinco clientes.
Runtime incluidosgcWebSockets CoreEl servidor HTTP, más el runtime HTTP, TLS y JSON bajo los cinco clientes
HTTP/2TsgcHTTP2Client
gRPCTsgcGRPCClient
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.
4Componentes en la paletaServidor HTTP, gateway FastCGI / SCGI, cliente HTTP/2 y cliente gRPC, una sola página en la paleta
5Clases cliente en totalHTTP/2, gRPC y tres clientes de Google Cloud
3Servicios de Google CloudPub/Sub, Calendar y Firebase Cloud Messaging
100%Código fuente incluidoEl servidor HTTP, el gateway, los cinco clientes y el runtime Core incluido
12Meses de actualizacionesCada versión publicada mientras tu licencia esté activa
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, el gateway, 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. Tampoco lo necesita el gateway FastCGI / SCGI, que funciona con el Indy estándar que se incluye con RAD Studio.
QUÉ INCLUYE
Cuatro componentes en la paleta, tres clientes de Google Cloud
El servidor HTTP, el gateway FastCGI / SCGI, 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, el gateway en la unidad sgcHTTP_Gateway, 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.
TsgcHTTPGateway reenvía las peticiones que reciben TsgcHTTPServer o TsgcWebSocketHTTPServer a servidores de aplicaciones FastCGI y SCGI por TCP: PHP mediante PHP-FPM o php-cgi -b, y aplicaciones Python servidas por un servidor SCGI o FastCGI como flup. Hace el trabajo de mod_proxy_fcgi y mod_proxy_scgi de Apache o de fastcgi_pass y scgi_pass de nginx, así que no hay Apache ni nginx delante de tu servidor Delphi. Registra handlers con Handlers.Add('*.php', 'fcgi://127.0.0.1:9000') o Handlers.Add('/app/', 'scgi://127.0.0.1:4000'), que se asocian por extensión, prefijo o ruta exacta, y luego llama a Process desde OnCommandGet y OnCommandOther. Devuelve true cuando un handler ha coincidido y la respuesta está rellena, y false cuando tu propio código responde a la petición. El gateway construye el entorno CGI según la RFC 3875, interpreta la respuesta CGI con su estado, las redirecciones y cada cabecera Set-Cookie, y responde 502, 503 o 504 cuando falla un backend, notificado a través de OnError. Funciona con el Indy estándar que se incluye con RAD Studio, en Windows y Linux.
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.
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.
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.
Las seis 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. El gateway FastCGI / SCGI solo necesita el servidor tras el que se sitúa y la librería Indy estándar.
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 gateway funciona con Indy estándar
TsgcHTTPGateway solo necesita el runtime Core incluido y la librería Indy estándar que se incluye con RAD Studio, sin sgcCustomIndy. Habla FastCGI y SCGI sobre TCP puro con un backend que ya está en marcha, y almacena en búfer cada respuesta antes de que el servidor la envíe.
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 el servidor en sgcHTTP_Server y el gateway en sgcHTTP_Gateway, 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, sgcHTTP_Gateway;
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;
// FastCGI / SCGI gateway: PHP and Python behind the same server
FGateway := TsgcHTTPGateway.Create(nil);
FGateway.Handlers.Add('*.php', 'fcgi://127.0.0.1:9000');
FGateway.Handlers.Add('/app/', 'scgi://127.0.0.1:4000');
// 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// *.php and /app/ go to the backends, the rest is answered hereif FGateway.Process(AContext, ARequestInfo, AResponseInfo) then
Exit;
if ARequestInfo.Document = '/api/status'thenbegin
AResponseInfo.ContentType := 'application/json';
AResponseInfo.ContentText := '{"status":"ok"}';
end;
end;
// include: sgcHTTP.hpp, sgcHTTP_Server.hpp, sgcHTTP_Gateway.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;
// FastCGI / SCGI gateway: PHP and Python behind the same server
FGateway = new TsgcHTTPGateway(this);
FGateway->Handlers->Add("*.php", "fcgi://127.0.0.1:9000");
FGateway->Handlers->Add("/app/", "scgi://127.0.0.1:4000");
// 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)
{
// *.php and /app/ go to the backends, the rest is answered hereif (FGateway->Process(AContext, ARequestInfo, AResponseInfo))
return;
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. El gateway FastCGI / SCGI usa el Indy estándar que se incluye con RAD Studio, en Windows y Linux.
TsgcHTTP2Client y TsgcGRPCClientConstruidos sobre sgcCustomIndy para ALPN
Windows Win32Windows Win64Linux64macOSiOSAndroid
Clientes de Google CloudHTTPS puro, no necesita sgcCustomIndy
Windows Win32Windows Win64Linux64macOSiOSAndroid
TsgcHTTPGatewayIndy estándar, no necesita sgcCustomIndy
Windows Win32Windows Win64Linux64
Soporte de IDEUn único árbol de código, paquetes de diseño por versión
Delphi 7 a 13C++ Builder
Instalador de pruebaLa prueba All-Access de sgcWebSockets incluye los componentes de sgcHTTP
Una sola descarga, el servidor, el gateway y los cinco clientes
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
Gateway FastCGI / SCGI para PHP y Python
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.
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.
3,000+Desarrolladores
20+Años
761+Componentes
30+Integraciones de API
5Plataformas
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
HTTP moderno, gRPC y Google Cloud desde código nativo
Un servidor HTTP con gateway FastCGI / SCGI, HTTP/2 multiplexado, gRPC en streaming y tres clientes de Google Cloud, con el runtime incluido y el código fuente completo en la caja. Descarga hoy mismo el instalador de prueba All-Access y prueba todos los componentes.