Eigenständiges ProduktHTTP-Server, HTTP/2, gRPC & Google Cloud
sgcHTTP: HTTP-Server, HTTP/2-, gRPC- & Google-Cloud-Komponenten für Delphi & C++ Builder
Ein HTTP-Server, ein FastCGI / SCGI Gateway und fünf Client-Komponenten. TsgcHTTPServer veröffentlicht HTTP-Endpunkte und statische Dateien aus deiner eigenen Anwendung: setze Port, behandle OnCommandGet, setze Active. TsgcHTTPGateway leitet dessen Anfragen an PHP-FPM sowie an Python-FastCGI- oder SCGI-Server weiter, sodass PHP- und Python-Anwendungen hinter deinem Server laufen, ohne Apache oder nginx davor. TsgcHTTP2Client spricht HTTP/2 mit gemultiplexten Streams über eine einzige TLS-Verbindung und HPACK-Header-Kompression. TsgcGRPCClient ist ein darauf aufgebauter gRPC-Client, für Unary- und Streaming-Protocol-Buffers-Aufrufe. Drei weitere Klassen erreichen Google Cloud über reines HTTPS: Pub/Sub, Calendar und Firebase Cloud Messaging. sgcHTTP ist eigenständig, es bringt die sgcWebSockets Core Runtime mit, auf der der Server, das Gateway und alle fünf Clients aufbauen.
Mitgelieferte RuntimesgcWebSockets CoreDer HTTP-Server, dazu die HTTP-, TLS- und JSON-Runtime unter jedem Client
HTTP/2TsgcHTTP2Client
gRPCTsgcGRPCClient
SIEH ES IN AKTION
sgcHTTP in zwei Minuten
Ein HTTP-Server, HTTP/2- und gRPC-Clients für Delphi und C++Builder, dazu fertige Integrationen für Google Cloud, Amazon und Apple Push.
4Paletten-KomponentenHTTP-Server, FastCGI / SCGI Gateway, HTTP/2-Client & gRPC-Client, eine Seite auf der Palette
5Client-Klassen insgesamtHTTP/2, gRPC und drei Google-Cloud-Clients
3Google-Cloud-DienstePub/Sub, Calendar und Firebase Cloud Messaging
100%Quellcode enthaltenDer HTTP-Server, das Gateway, alle fünf Clients und die mitgelieferte Core Runtime
12Monate UpdatesJede Version, die veröffentlicht wird, während deine Lizenz aktiv ist
VOR DEM KAUF
Zwei Dinge, die du vorher wissen solltest
Was sgcHTTP von dir braucht, und was nicht. Beide Antworten sind kurz.
sgcHTTP ist in sich geschlossen
Eigenständig ist die sgcWebSockets Core Runtime enthalten: der HTTP-Server, der HTTP/TLS-Client-Stack, über den jeder Client seine Anfragen sendet, und die JSON-Schicht, die Google-Cloud-Antworten dekodiert. Eine SKU, ein Installer.
Jeder Lizenz liegt der volle Quellcode bei, du kannst also den HTTP-Server, das Gateway, alle fünf Clients und die Runtime darunter in deinem eigenen Debugger durchsteppen, statt sie in einer Binärdatei verschwinden zu sehen.
Add-on erforderlich für zwei von fünf
HTTP/2 & gRPC brauchen sgcCustomIndy
HTTP/2 handelt das h2-Protokoll während des TLS-Handshakes per ALPN aus, und die Standard-Indy-Bibliothek, die mit RAD Studio ausgeliefert wird, unterstützt kein ALPN. Der HTTP/2-Client und der gRPC-Client von sgcHTTP bauen stattdessen auf sgcCustomIndy auf, das beim Bestellen von sgcHTTP immer enthalten ist, und der angezeigte Preis deckt es bereits ab.
Die drei Google-Cloud-Clients, Pub/Sub, Calendar und Firebase Cloud Messaging, sind reines HTTPS. Sie laufen auf der bloßen Core Runtime und brauchen sgcCustomIndy überhaupt nicht. Das gilt auch für das FastCGI / SCGI Gateway, das mit der Standard-Indy-Bibliothek arbeitet, die mit RAD Studio ausgeliefert wird.
WAS ENTHALTEN IST
Vier Paletten-Komponenten, drei Google-Cloud-Clients
Der HTTP-Server, das FastCGI / SCGI Gateway, der HTTP/2-Client und der gRPC-Client sind nicht-visuelle Komponenten auf der Palettenseite SGC HTTP. Der Server ist in der Unit sgcHTTP_Server der mitgelieferten Core Runtime deklariert, das Gateway in der Unit sgcHTTP_Gateway, die beiden Clients in der Unit sgcHTTP. Ziehe eine davon auf ein Formular oder erzeuge sie im Code, setze die Verbindungsoptionen, verdrahte die Ereignisse und rufe dann die typisierten Anfragemethoden auf. Die drei Google-Cloud-Clients leben als reine Code-Klassen in derselben Unit, es gibt nichts auf ein Formular zu ziehen: Erzeuge eine, setze GoogleCloudOptions und rufe ihre Methoden direkt auf.
HTTP-Server1 Komponente
HTTP-Endpunkte und statische Dateien veröffentlichen
TsgcHTTPServer macht aus deiner Delphi- oder C++-Builder-Anwendung einen HTTP-Server. Setze Port, behandle OnCommandGet, setze Active auf true, und jede Anfrage erreicht deinen Code mit ihren Request- und Response-Objekten, während OnCommandOther Verben wie PUT und DELETE abdeckt. Richte DocumentRoot auf einen Ordner, und der Server liefert statische Dateien daraus aus. HTTPCompression komprimiert Antworten, KeepAlive verwendet Verbindungen wieder, SessionState mit OnSessionStart und OnSessionEnd verfolgt Sitzungen, MaxRequestBodySize begrenzt Request-Bodys und HTTPUploadFiles speichert hochgeladene Dateien auf der Festplatte. Für den Produktivbetrieb aktivieren SSL und SSLOptions TLS, Authentication und OnAuthentication schützen deine Endpunkte, und ThreadPool und MaxConnections steuern, wie er skaliert. Es ist dieselbe Engine wie der sgcWebSockets-WebSocket-Server, nur ohne den WebSocket-Teil, und er wird mit der mitgelieferten Core Runtime ausgeliefert.
TsgcHTTPGateway leitet Anfragen, die TsgcHTTPServer oder TsgcWebSocketHTTPServer empfängt, über TCP an FastCGI- und SCGI-Anwendungsserver weiter: PHP über PHP-FPM oder php-cgi -b, und Python-Anwendungen, die von einem SCGI- oder FastCGI-Server bedient werden, zum Beispiel flup. Es übernimmt die Aufgabe von Apache mod_proxy_fcgi und mod_proxy_scgi oder von nginx fastcgi_pass und scgi_pass, sodass kein Apache oder nginx vor deinem Delphi-Server nötig ist. Registriere Handler mit Handlers.Add('*.php', 'fcgi://127.0.0.1:9000') oder Handlers.Add('/app/', 'scgi://127.0.0.1:4000'), zugeordnet nach Erweiterung, Präfix oder exaktem Pfad, und rufe dann Process aus OnCommandGet und OnCommandOther auf. Es liefert true, wenn ein Handler gepasst hat und die Antwort gefüllt ist, und false, wenn dein eigener Code die Anfrage beantwortet. Das Gateway baut die CGI-Umgebung nach RFC 3875 auf, parst die CGI-Antwort mit Status, Weiterleitungen und jedem Set-Cookie-Header und antwortet mit 502, 503 oder 504, wenn ein Backend ausfällt, gemeldet über OnError. Es arbeitet mit der Standard-Indy-Bibliothek, die mit RAD Studio ausgeliefert wird, unter Windows und Linux.
Gemultiplexte Streams über eine einzige TLS-Verbindung
TsgcHTTP2Client spricht HTTP/2 (RFC 9113): Mehrere Anfragen teilen sich eine einzige TCP-Verbindung als unabhängige Streams, eine langsame Antwort blockiert also nicht die anderen dahinter. Header werden mit HPACK komprimiert, und das h2-Protokoll wird während des TLS-Handshakes per ALPN ausgehandelt, weshalb die Komponente auf sgcCustomIndy statt auf der Standard-Indy-Bibliothek aufbaut. Jedes Verb ist abgedeckt, Connect, Get, Post, Put, Patch, Delete und Options, jedes mit einem synchronen Aufruf und einem Async-Gegenstück. Ereignisse machen den Verbindungs-Lebenszyklus sichtbar: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment für chunked Bodies, OnHTTP2PushPromise für Server Push, OnHTTP2GoAway und OnHTTP2Disconnect. HTTP2Options konfiguriert den lokalen Settings-Frame, und TLSOptions sowie Authentication übernehmen aus dem übrigen sgc-HTTP-Stack.
TsgcGRPCClient baut auf dem HTTP/2-Client auf, erbt also die gemultiplexte Verbindung und ergänzt darüber das gRPC-Wire-Format: längenpräfixierte Protocol-Buffers-Nachrichten über HTTP/2-Streams. Call und CallAsync decken Unary-RPCs ab, ServerStreamingCall behandelt einen Antwort-Stream zu einer Anfrage, und OpenClientStream/SendStreamMessage/CloseClientStream plus OpenBidiStream/SendBidiMessage/CloseBidiStream decken Client-Streaming- und bidirektionale Streaming-RPCs ab. OnGRPCResponse, OnGRPCStreamMessage und OnGRPCStreamEnd liefern den Datenverkehr, und RetryPolicy, Interceptors und ServiceConfig ergänzen Retry-Verhalten, übergreifende Logik und Service-Konfiguration, ohne die Aufrufstellen anzufassen. Wie der HTTP/2-Client, auf dem er aufbaut, braucht er sgcCustomIndy für ALPN.
Pub/Sub, Calendar und Push-Benachrichtigungen, reines HTTPS
Drei weitere Klassen erreichen Google-Cloud-Dienste über reines HTTPS, authentifiziert mit einem Google-Service-Konto, und keine davon braucht sgcCustomIndy. TsgcHTTPGoogleCloud_PubSub_Client veröffentlicht und holt Nachrichten ab und verwaltet Topics, Subscriptions und Snapshots: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription und der Rest der Pub/Sub-REST-Oberfläche. TsgcHTTPGoogleCloud_Calendar_Client umhüllt die Google Calendar API v3: NewCalendar, NewEvent, LoadEvents und LoadCalendars, mit den Ereignissen OnGetCalendar und OnGetCalendarEvent für die Synchronisierung. TsgcHTTPGoogleCloud_FCM_Client sendet mit einem Aufruf, SendMessage, eine Push-Benachrichtigungs-Payload an ein Firebase-Projekt. Alle drei sind reine Code-Klassen: eine erzeugen, GoogleCloudOptions setzen, die Methoden aufrufen.
Die sechs Klassen teilen sich sauber danach auf, was sie darunter brauchen. HTTP/2 und gRPC brauchen ALPN, was sgcCustomIndy bedeutet. Google Cloud braucht nichts weiter als HTTPS und ein Service-Konto, was die mitgelieferte Core Runtime bereits liefert. Das FastCGI / SCGI Gateway braucht nur den Server, hinter dem es sitzt, und die Standard-Indy-Bibliothek.
HTTP/2 braucht ALPN, also braucht es sgcCustomIndy
Application-Layer Protocol Negotiation wählt h2 während des TLS-Handshakes, und die Standard-Indy-Bibliothek, die mit RAD Studio ausgeliefert wird, hat keine ALPN-Unterstützung. TsgcHTTP2Client baut stattdessen auf sgcCustomIndy auf, eSeGeCes angepasstem Indy-Build.
gRPC ist Protocol Buffers auf dem HTTP/2-Client
TsgcGRPCClient öffnet keine eigene Verbindung, seine Client-Eigenschaft ist ein TsgcHTTP2Client. Unary-, Server-Streaming-, Client-Streaming- und bidirektionale Aufrufe reisen darunter alle als HTTP/2-Streams.
Google Cloud ist HTTPS plus ein Service-Konto
Die drei Google-Cloud-Clients authentifizieren sich mit GoogleCloudOptions.JWT, der Projekt-ID, der Client-E-Mail und dem privaten Schlüssel eines Google-Service-Kontos, und rufen die REST-APIs über den reinen HTTPS-Stack der Core Runtime auf. OnAuthToken und OnAuthTokenError machen den Token-Austausch sichtbar.
Das Gateway läuft auf Standard-Indy
TsgcHTTPGateway braucht nur die mitgelieferte Core Runtime und die Standard-Indy-Bibliothek, die mit RAD Studio ausgeliefert wird, kein sgcCustomIndy. Es spricht FastCGI und SCGI über reines TCP mit einem Backend, das bereits läuft, und puffert jede Antwort, bevor der Server sie sendet.
Die Core Runtime ist im Lieferumfang
Eigenständig ist die sgcWebSockets Core Runtime enthalten. Sie steuert TsgcHTTPServer und den HTTP/TLS-Client-Stack bei, über den jeder der fünf Clients seine Aufrufe absetzt, und ihr voller Quellcode ist Teil des Pakets wie alles andere.
SCHNELLSTART
HTTP-Server, HTTP/2 und gRPC, nebeneinander
Die beiden Clients sind in der Unit sgcHTTP deklariert, der Server in sgcHTTP_Server und das Gateway in sgcHTTP_Gateway, und TsgcGRPCClient trägt seine eigene HTTP/2-Verbindung über seine Client-Eigenschaft. Derselbe Code kompiliert in Delphi 7 bis 13 und 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\"}";
}
}
PLATTFORMEN
Eine Abhängigkeit für zwei Clients, keine für drei
Der HTTP/2-Client und der gRPC-Client bauen auf sgcCustomIndy auf, das denselben Plattformumfang wie sgcWebSockets selbst abdeckt. Die Google-Cloud-Clients sind reines HTTPS, sie laufen also überall dort, wo die Core Runtime läuft. Das FastCGI / SCGI Gateway verwendet die Standard-Indy-Bibliothek, die mit RAD Studio ausgeliefert wird, unter Windows und Linux.
TsgcHTTP2Client & TsgcGRPCClientAufgebaut auf sgcCustomIndy für ALPN
Windows Win32Windows Win64Linux64macOSiOSAndroid
Google-Cloud-ClientsReines HTTPS, kein sgcCustomIndy nötig
Windows Win32Windows Win64Linux64macOSiOSAndroid
TsgcHTTPGatewayStandard-Indy, kein sgcCustomIndy nötig
Windows Win32Windows Win64Linux64
IDE-UnterstützungEin Quellbaum, Designtime-Pakete je Version
Delphi 7 bis 13C++ Builder
Trial-InstallerDer All-Access-Trial von sgcWebSockets enthält die sgcHTTP-Komponenten
Ein Download, der Server, das Gateway und alle fünf Clients
sgcHTTP wird eigenständig lizenziert, ab €398 für einen einzelnen Entwickler. Alle Lizenzen enthalten den vollen Quellcode, 1 Jahr Updates und 50% bis 70% Verlängerungsrabatt: 50%, wenn du ein Paket verlängerst, 60% bei zwei, 70% bei drei oder mehr. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP und sgcREST zählen jeweils als ein Paket. sgcHTTP ist auch im All-Access-Bundle enthalten.
sgcHTTP
€398
Single-, Team- und Site-Lizenzen verfügbar.
HTTP-Server mit statischen Dateien, Sitzungen & TLS
FastCGI / SCGI Gateway für PHP & Python
HTTP/2-Client mit Multiplexing & HPACK
gRPC-Client, Unary- & Streaming-RPC
Google Cloud Pub/Sub-, Calendar- & FCM-Clients
sgcWebSockets Core Runtime enthalten
Delphi 7 bis 13 & C++ Builder
Vollständiger Quellcode
1 Jahr Updates
HTTP/2 und gRPC brauchen das Add-on sgcCustomIndy. Es ist immer in deiner Bestellung enthalten, und der angezeigte Preis deckt es bereits ab.
An der Kasse erscheinen drei Positionen: die Berechtigung für die sgcWebSockets Core Runtime, die mit null berechnet wird, das sgcHTTP-Paket selbst, und das immer enthaltene sgcCustomIndy-Add-on. Alle Preisdetails.
3,000+Entwickler
20+Jahre
761+Komponenten
30+API-Integrationen
5Plattformen
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordere innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen
Modernes HTTP, gRPC und Google Cloud aus nativem Code
Ein HTTP-Server mit FastCGI / SCGI Gateway, gemultiplextes HTTP/2, streamendes gRPC und drei Google-Cloud-Clients, mit enthaltener Runtime und vollständigem Quellcode im Lieferumfang. Lade den All-Access-Trial-Installer herunter und probiere noch heute jede Komponente aus.