Standalone productHTTP-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.
Meegeleverde runtimesgcWebSockets CoreDe HTTP-server, plus de HTTP-, TLS- en JSON-runtime onder elke client
HTTP/2TsgcHTTP2Client
gRPCTsgcGRPCClient
ZIE HET IN ACTIE
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.
4PaletcomponentenHTTP-server, FastCGI / SCGI-gateway, HTTP/2-client & gRPC-client, één pagina op het palet
5Klassen in totaalHTTP/2, gRPC en drie Google Cloud-clients
3Google Cloud-dienstenPub/Sub, Calendar en Firebase Cloud Messaging
100%Broncode inbegrepenDe HTTP-server, de gateway, alle vijf clients en de meegeleverde Core runtime
12Maanden updatesElke release die verschijnt zolang je licentie actief is
Voordat je koopt
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.
Wat er in de doos zit
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.
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.
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.
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.
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.
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.
Snelstart
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 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\"}";
}
}
Platforms
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 & TsgcGRPCClientGebouwd op sgcCustomIndy voor ALPN
Windows Win32Windows Win64Linux64macOSiOSAndroid
Google Cloud-clientsGewone HTTPS, geen sgcCustomIndy nodig
Windows Win32Windows Win64Linux64macOSiOSAndroid
TsgcHTTPGatewayStandaard Indy, geen sgcCustomIndy nodig
Windows Win32Windows Win64Linux64
IDE-ondersteuningEén broncodeboom, design-time packages per versie
Delphi 7 tot 13C++ Builder
ProefinstallerDe sgcWebSockets All-Access-proefversie bevat de sgcHTTP-componenten
Eén download, de server, de gateway en alle vijf clients
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.
Cryptografiebibliotheek voor Delphi en C++ Builder: symmetrische en asymmetrische versleuteling, hashing en sleutelbeheer. Gratis vanaf sgcWebSockets Standard, of standalone.
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.