Standalone product HTTP-server, HTTP/2, gRPC & Google Cloud

sgcHTTP: HTTP-server, HTTP/2-, gRPC- en Google Cloud-componenten voor Delphi & C++ Builder

Een HTTP-server, een FastCGI / SCGI-gateway en vijf clientcomponenten. TsgcHTTPServer publiceert HTTP-endpoints en statische bestanden vanuit je eigen applicatie: stel Port in, verwerk OnCommandGet, zet Active. TsgcHTTPGateway stuurt de requests door naar PHP-FPM en naar Python FastCGI- of SCGI-servers, zodat PHP- en Python-applicaties achter je server draaien zonder Apache of nginx ervoor. TsgcHTTP2Client spreekt HTTP/2 met gemultiplexte streams over één TLS-verbinding en HPACK-headercompressie. TsgcGRPCClient is een gRPC-client die erop is gebouwd, voor unary en streaming Protocol Buffers-aanroepen. Drie andere klassen bereiken Google Cloud via gewone HTTPS: Pub/Sub, Calendar en Firebase Cloud Messaging. sgcHTTP is standalone, het levert de sgcWebSockets Core runtime mee waarop de server, de gateway en alle vijf de clients zijn gebouwd.

Volledige broncode
Delphi 7 tot 13 & C++ Builder
Meegeleverde runtime sgcWebSockets Core De HTTP-server, plus de HTTP-, TLS- en JSON-runtime onder elke client
HTTP/2 TsgcHTTP2Client
gRPC TsgcGRPCClient

Bekijk sgcHTTP in twee minuten

Een HTTP-server, HTTP/2- en gRPC-clients voor Delphi en C++Builder, plus kant-en-klare integraties met Google Cloud, Amazon en Apple Push.

4 Paletcomponenten HTTP-server, FastCGI / SCGI-gateway, HTTP/2-client & gRPC-client, één pagina op het palet
5 Klassen in totaal HTTP/2, gRPC en drie Google Cloud-clients
3 Google Cloud-diensten Pub/Sub, Calendar en Firebase Cloud Messaging
100% Broncode inbegrepen De HTTP-server, de gateway, alle vijf clients en de meegeleverde Core runtime
12 Maanden updates Elke release die verschijnt zolang je licentie actief is

Twee dingen die je eerst moet weten

Wat sgcHTTP van je nodig heeft, en wat niet. Beide antwoorden zijn kort.

sgcHTTP is zelfstandig

Standalone, de sgcWebSockets Core runtime is inbegrepen: de HTTP-server, de HTTP/TLS-clientstack waarmee elke client zijn requests verstuurt, en de JSON-laag die de Google Cloud-responses decodeert. Eén SKU, één installer.

Bij elke licentie krijg je de volledige broncode, zodat je door de HTTP-server, de gateway, alle vijf clients en de runtime eronder heen kunt stappen in je eigen debugger in plaats van ze in een binary te zien verdwijnen.

Add-on nodig voor twee van de vijf

HTTP/2 & gRPC hebben sgcCustomIndy nodig

HTTP/2 onderhandelt tijdens de TLS-handshake met ALPN over het h2-protocol, en de standaard Indy-bibliotheek die met RAD Studio wordt meegeleverd ondersteunt geen ALPN. De HTTP/2-client en de gRPC-client van sgcHTTP zijn in plaats daarvan gebouwd op sgcCustomIndy, dat altijd is inbegrepen wanneer je sgcHTTP bestelt, en de getoonde prijs dekt het al.

De drie Google Cloud-clients, Pub/Sub, Calendar en Firebase Cloud Messaging, zijn gewone HTTPS. Ze draaien op de kale Core runtime en hebben sgcCustomIndy helemaal niet nodig. Dat geldt ook voor de FastCGI / SCGI-gateway, die werkt met de standaard Indy die met RAD Studio wordt geleverd.

Vier paletcomponenten, drie Google Cloud-clients

De HTTP-server, de FastCGI / SCGI-gateway, de HTTP/2-client en de gRPC-client zijn niet-visuele componenten op de paletpagina SGC HTTP. De server is gedeclareerd in de sgcHTTP_Server-unit van de meegeleverde Core runtime, de gateway in de sgcHTTP_Gateway-unit, de twee clients in de sgcHTTP-unit. Zet er een op een formulier of maak hem in code aan, stel de verbindingsopties in, koppel de events, en roep dan de getypeerde requestmethoden aan. De drie Google Cloud-clients staan in dezelfde unit als code-only klassen, er is niets om op een formulier te zetten: maak er een aan, stel GoogleCloudOptions in, en roep de methoden rechtstreeks aan.

HTTP-server1 component

Publiceer HTTP-endpoints en statische bestanden

TsgcHTTPServer verandert je Delphi- of C++ Builder-applicatie in een HTTP-server. Stel Port in, verwerk OnCommandGet, zet Active op true, en elk request bereikt je code met zijn request- en response-objecten, terwijl OnCommandOther methoden zoals PUT en DELETE afdekt. Wijs DocumentRoot naar een map en de server levert er statische bestanden uit. HTTPCompression comprimeert responses, KeepAlive hergebruikt verbindingen, SessionState met OnSessionStart en OnSessionEnd houdt sessies bij, MaxRequestBodySize begrenst de grootte van request-bodies en HTTPUploadFiles slaat geüploade bestanden op schijf op. Voor productie schakelen SSL en SSLOptions TLS in, beveiligen Authentication en OnAuthentication je endpoints, en bepalen ThreadPool en MaxConnections hoe hij schaalt. Het is dezelfde engine als de sgcWebSockets WebSocket-server zonder het WebSocket-gedeelte, en hij wordt geleverd met de meegeleverde Core runtime.

TsgcHTTPServer Wordt geleverd met de Core runtime
FastCGI / SCGI-gateway1 component

PHP- en Python-applicaties achter je server

TsgcHTTPGateway stuurt requests die TsgcHTTPServer of TsgcWebSocketHTTPServer ontvangt door naar FastCGI- en SCGI-applicatieservers via TCP: PHP via PHP-FPM of php-cgi -b, en Python-applicaties die door een SCGI- of FastCGI-server zoals flup worden aangeboden. Ze doet het werk van Apache mod_proxy_fcgi en mod_proxy_scgi of nginx fastcgi_pass en scgi_pass, dus er staat geen Apache of nginx voor je Delphi-server. Registreer handlers met Handlers.Add('*.php', 'fcgi://127.0.0.1:9000') of Handlers.Add('/app/', 'scgi://127.0.0.1:4000'), gekoppeld op extensie, prefix of exact pad, en roep daarna Process aan vanuit OnCommandGet en OnCommandOther. Ze geeft true terug wanneer een handler overeenkomt en het antwoord is gevuld, en false wanneer je eigen code het request beantwoordt. De gateway bouwt de CGI-omgeving volgens RFC 3875, parseert het CGI-antwoord met status, redirects en elke Set-Cookie-header, en antwoordt met 502, 503 of 504 wanneer een backend faalt, gemeld via OnError. Ze werkt met de standaard Indy die met RAD Studio wordt geleverd, op Windows en Linux.

TsgcHTTPGateway Geen sgcCustomIndy nodig
HTTP/21 component

Gemultiplexte streams over één TLS-verbinding

TsgcHTTP2Client spreekt HTTP/2 (RFC 9113): meerdere requests delen één TCP-verbinding als onafhankelijke streams, zodat één trage response de andere niet blokkeert. Headers worden gecomprimeerd met HPACK, en het h2-protocol wordt tijdens de TLS-handshake onderhandeld via ALPN, de reden waarom het component op sgcCustomIndy is gebouwd in plaats van op de standaard Indy-bibliotheek. Elk werkwoord is gedekt, Connect, Get, Post, Put, Patch, Delete en Options, elk met een synchrone aanroep en een Async-tegenhanger. Events tonen de levenscyclus van de verbinding: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment voor chunked bodies, OnHTTP2PushPromise voor server push, OnHTTP2GoAway en OnHTTP2Disconnect. HTTP2Options configureert het lokale settings-frame, en TLSOptions en Authentication komen over uit de rest van de sgc HTTP-stack.

TsgcHTTP2Client Vereist sgcCustomIndy
gRPC1 component

Unary en streaming RPC op de HTTP/2-client

TsgcGRPCClient is gebouwd op de HTTP/2-client, dus het erft de gemultiplexte verbinding en voegt daar het gRPC-wireformaat aan toe: Protocol Buffers-berichten met lengtevoorvoegsel over HTTP/2-streams. Call en CallAsync dekken unary RPC's, ServerStreamingCall behandelt een stroom van responses op één request, en OpenClientStream/SendStreamMessage/CloseClientStream plus OpenBidiStream/SendBidiMessage/CloseBidiStream dekken client-streaming en bidirectionele streaming RPC's. OnGRPCResponse, OnGRPCStreamMessage en OnGRPCStreamEnd leveren het verkeer af, en RetryPolicy, Interceptors en ServiceConfig voegen retrygedrag, cross-cutting logica en serviceconfiguratie toe zonder de aanroeppunten aan te raken. Net als de HTTP/2-client waarop het is gebouwd, heeft het sgcCustomIndy nodig voor ALPN.

TsgcGRPCClient Vereist sgcCustomIndy
Google Cloud3 klassen

Pub/Sub, Calendar en pushmeldingen, gewone HTTPS

Drie andere klassen bereiken Google Cloud-diensten via gewone HTTPS, geauthenticeerd met een Google-serviceaccount, en geen enkele heeft sgcCustomIndy nodig. TsgcHTTPGoogleCloud_PubSub_Client publiceert en haalt berichten op en beheert topics, abonnementen en snapshots: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription en de rest van het Pub/Sub REST-oppervlak. TsgcHTTPGoogleCloud_Calendar_Client pakt de Google Calendar API v3 in: NewCalendar, NewEvent, LoadEvents en LoadCalendars, met OnGetCalendar- en OnGetCalendarEvent-events voor synchronisatie. TsgcHTTPGoogleCloud_FCM_Client verstuurt met één aanroep, SendMessage, een pushmeldingspayload naar een Firebase-project. Alle drie zijn code-only klassen: maak er een aan, stel GoogleCloudOptions in, roep de methoden aan.

TsgcHTTPGoogleCloud_PubSub_Client TsgcHTTPGoogleCloud_Calendar_Client TsgcHTTPGoogleCloud_FCM_Client

Twee afhankelijkheden, niet zes

De zes klassen splitsen zich netjes op basis van wat ze eronder nodig hebben. HTTP/2 en gRPC hebben ALPN nodig, wat sgcCustomIndy betekent. Google Cloud heeft niets nodig behalve HTTPS en een serviceaccount, wat de meegeleverde Core runtime al biedt. De FastCGI / SCGI-gateway heeft alleen de server nodig waarachter ze staat en de standaard Indy-bibliotheek.

HTTP/2 heeft ALPN nodig, dus het heeft sgcCustomIndy nodig

Application-Layer Protocol Negotiation kiest h2 tijdens de TLS-handshake, en de standaard Indy-bibliotheek die met RAD Studio wordt meegeleverd heeft geen ALPN-ondersteuning. TsgcHTTP2Client is in plaats daarvan gebouwd op sgcCustomIndy, eSeGeCe's aangepaste Indy-build.

gRPC is Protocol Buffers dat meelift op de HTTP/2-client

TsgcGRPCClient opent geen eigen verbinding, de Client-eigenschap ervan is een TsgcHTTP2Client. Unary, server-streaming, client-streaming en bidirectionele aanroepen reizen allemaal als HTTP/2-streams eronder.

Google Cloud is HTTPS plus een serviceaccount

De drie Google Cloud-clients authenticeren met GoogleCloudOptions.JWT, de project-id, client-e-mail en private key van een Google-serviceaccount, en roepen de REST-API's aan via de gewone HTTPS-stack van de Core runtime. OnAuthToken en OnAuthTokenError tonen de tokenuitwisseling.

De gateway draait op standaard Indy

TsgcHTTPGateway heeft alleen de meegeleverde Core runtime en de standaard Indy-bibliotheek van RAD Studio nodig, geen sgcCustomIndy. Ze spreekt FastCGI en SCGI over gewone TCP met een backend die al draait, en buffert elk antwoord voordat de server het verstuurt.

De Core runtime zit in de doos

Standalone, de sgcWebSockets Core runtime is inbegrepen. Ze levert TsgcHTTPServer en de HTTP/TLS-clientstack waar elk van de vijf clients doorheen aanroept, en de volledige broncode ervan maakt net als al het andere deel uit van het pakket.

HTTP-server, HTTP/2 en gRPC, naast elkaar

De twee clients zijn gedeclareerd in de sgcHTTP-unit, de server in sgcHTTP_Server en de gateway in sgcHTTP_Gateway, en TsgcGRPCClient draagt zijn eigen HTTP/2-verbinding via zijn Client-eigenschap. Dezelfde code compileert in Delphi 7 tot 13 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 here
  if FGateway.Process(AContext, ARequestInfo, AResponseInfo) then
    Exit;
  if ARequestInfo.Document = '/api/status' then
  begin
    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 here
  if (FGateway->Process(AContext, ARequestInfo, AResponseInfo))
    return;
  if (ARequestInfo->Document == "/api/status")
  {
    AResponseInfo->ContentType = "application/json";
    AResponseInfo->ContentText = "{\"status\":\"ok\"}";
  }
}

Eén afhankelijkheid voor twee clients, geen voor drie

De HTTP/2-client en de gRPC-client bouwen voort op sgcCustomIndy, dat hetzelfde platformbereik dekt als sgcWebSockets zelf. De Google Cloud-clients zijn gewone HTTPS, dus ze draaien overal waar de Core runtime dat ook doet. De FastCGI / SCGI-gateway gebruikt de standaard Indy die met RAD Studio wordt geleverd, op Windows en Linux.

TsgcHTTP2Client & TsgcGRPCClient Gebouwd op sgcCustomIndy voor ALPN
Windows Win32 Windows Win64 Linux64 macOS iOS Android
Google Cloud-clients Gewone HTTPS, geen sgcCustomIndy nodig
Windows Win32 Windows Win64 Linux64 macOS iOS Android
TsgcHTTPGateway Standaard Indy, geen sgcCustomIndy nodig
Windows Win32 Windows Win64 Linux64
IDE-ondersteuning Eén broncodeboom, design-time packages per versie
Delphi 7 tot 13 C++ Builder
Proefinstaller De sgcWebSockets All-Access-proefversie bevat de sgcHTTP-componenten
Eén download, de server, de gateway en alle vijf clients

Download de proefinstaller →

Een standalone package

sgcHTTP wordt zelfstandig gelicentieerd, vanaf €398 voor één ontwikkelaar. Alle licenties bevatten volledige broncode, 1 jaar updates en 50% tot 70% verlengingskorting: 50% als je één pakket verlengt, 60% bij twee, 70% bij drie of meer. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP en sgcREST tellen elk als een pakket. sgcHTTP zit ook in het All-Access-pakket.

sgcHTTP

€398

Single-, Team- en Site-licenties beschikbaar.

  • HTTP-server met statische bestanden, sessies & TLS
  • FastCGI / SCGI-gateway voor PHP & Python
  • HTTP/2-client met multiplexing & HPACK
  • gRPC-client, unary & streaming RPC
  • Google Cloud Pub/Sub-, Calendar- & FCM-clients
  • sgcWebSockets Core runtime inbegrepen
  • Delphi 7 tot 13 & C++ Builder
  • Volledige broncode
  • 1 jaar updates

HTTP/2 en gRPC hebben de sgcCustomIndy-add-on nodig. Het is altijd inbegrepen in je bestelling, en de getoonde prijs dekt het al.

Bij het afrekenen staan drie regels: het recht op de sgcWebSockets Core runtime, dat op nul wordt gefactureerd, het sgcHTTP-pakket zelf, en de sgcCustomIndy-add-on, altijd inbegrepen. Volledige prijsinformatie.

3,000+Ontwikkelaars
20+Jaar
761+Componenten
30+API-integraties
5Platformen
Niet-goed-geld-terug-garantie van 30 dagenNiet tevreden? Vraag binnen 30 dagen na aankoop een volledige terugbetaling aan. Bekijk het terugbetalingsbeleid

Moderne HTTP, gRPC en Google Cloud vanuit native code

Een HTTP-server met een FastCGI / SCGI-gateway, gemultiplexte HTTP/2, streaming gRPC en drie Google Cloud-clients, met de runtime inbegrepen en volledige broncode in de doos. Download de All-Access-proefinstaller en probeer vandaag nog elk component.

Andere producten van eSeGeCe

Combineer sgcHTTP met onze andere componentbibliotheken voor Delphi, C++ Builder en .NET.

sgcCustomIndy

De aangepaste Indy-bibliotheek waarop de HTTP/2- en gRPC-clients van sgcHTTP zijn gebouwd: ALPN, TLS 1.3 en statische OpenSSL-linking.

Meer informatie →

sgcWebSockets

De volledige bibliotheek: WebSocket-clients en -servers, HTTP/2, gRPC, IoT-, P2P- en AI-componenten. De Enterprise-editie bevat ook gRPC.

Meer informatie →

sgcAI

AI-, LLM- en MCP-componenten. Eén chatcomponent bereikt OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok en Mistral.

Meer informatie →

sgcMQ

Native MQTT 3.1.1/5.0-, AMQP 0.9.1-, AMQP 1.0-, Apache Kafka- en STOMP-clientcomponenten, met de Core runtime inbegrepen.

Meer informatie →

sgcCrypto

Cryptografiebibliotheek voor Delphi en C++ Builder: symmetrische en asymmetrische versleuteling, hashing en sleutelbeheer. Gratis vanaf sgcWebSockets Standard, of standalone.

Meer informatie →

sgcSocial

WhatsApp Business Cloud API- en Telegram TDLib-clientcomponenten, met de Core runtime inbegrepen.

Meer informatie →

sgcQUIC

QUIC- (RFC 9000) en HTTP/3-client- en servercomponenten (RFC 9114), gebouwd op de native OpenSSL 3.5 QUIC-engine.

Meer informatie →

sgcWebRTC

Volledige WebRTC-media-engine voor Delphi en C++ Builder: audio- en video-oproepen, datakanalen en schermdelen, met STUN/TURN/ICE ingebouwd. Een add-on voor sgcWebSockets Enterprise.

Meer informatie →