sgcHTTP HTTP-Server, HTTP/2 und gRPC nativ in Delphi. Google Cloud inklusive.

Ein HTTP-Server und fünf Client-Komponenten. TsgcHTTPServer veröffentlicht HTTP-Endpunkte und statische Dateien aus deiner eigenen Anwendung. TsgcHTTP2Client spricht HTTP/2 mit gemultiplexten Streams über eine TLS-Verbindung und HPACK-Header-Kompression. TsgcGRPCClient ist ein darauf aufbauender gRPC-Client für Unary- und Streaming-Aufrufe mit Protocol Buffers. Drei weitere Klassen erreichen Google Cloud über reines HTTPS: Pub/Sub, Calendar und Firebase Cloud Messaging.

Ein eigenständiges Paket von sgcWebSockets, Core-Runtime enthalten. Preise ansehen →
  • HTTP-Server
  • HTTP/2
  • gRPC
  • Google Cloud
  • HPACK & ALPN
  • Delphi 7 bis 13
  • C++ Builder
  • 3Palette-Komponenten: der HTTP-Server sowie der HTTP/2- und der gRPC-Client
  • 5Client-Klassen insgesamt
  • 3Google-Cloud-Dienste: Pub/Sub, Calendar und FCM
  • 1Eigenständiger Installer, Core-Runtime enthalten
  • 100%Quellcode in jeder Lizenz enthalten
Sieh es laufen

sgcHTTP in zwei Minuten erleben.

Ein vertonter Schnellstart mit Untertiteln: ein HTTP/2-Client sendet viele Anfragen über eine Verbindung, danach läuft ein gRPC-Aufruf über denselben Transport, alles aus Delphi. Nichts wird geladen, bevor du auf Play drückst.

sgcHTTP-Schnellstart

Einen HTTP/2-Endpunkt aufrufen und einen gRPC-Aufruf absetzen, aus Delphi.

  1. Den HTTP/2-Client erstellenErstelle einen TsgcHTTP2Client, behandle OnHTTP2Response und rufe Get auf. Das Protokoll h2 wird beim TLS-Handshake über ALPN ausgehandelt.
  2. Viele Anfragen, eine VerbindungDie Anfragen teilen sich eine einzige TCP-Verbindung als unabhängige Streams, sodass eine langsame Antwort die anderen dahinter nicht blockiert.
  3. gRPC auf demselben TransportWeise den HTTP/2-Client dem gRPC-Client zu und rufe eine Methode über Dienst und Name auf. Nachrichten werden als längenpräfixierte Protocol Buffers übertragen.
  4. Vier RPC-MusterUnary, Server-Streaming, Client-Streaming und bidirektionales Streaming, jeweils mit eigener Methode an TsgcGRPCClient.
Zwei Palette-Komponenten

Ein HTTP/2-Client und gRPC obendrauf.

Beide Komponenten sind in der Unit sgcHTTP deklariert, und TsgcGRPCClient führt seine eigene HTTP/2-Verbindung über die Eigenschaft Client.

Der HTTP/2-Client im sgcHTTP-Schnellstart: der Delphi-Code neben sechs Anfragen, die über einen Socket laufen

Gemultiplexte Streams über eine TLS-Verbindung

TsgcHTTP2Client spricht HTTP/2 (RFC 9113): mehrere Anfragen teilen sich eine einzige TCP-Verbindung als unabhängige Streams. Header werden mit HPACK komprimiert, und h2 wird beim TLS-Handshake über ALPN ausgehandelt. Jedes Verb ist abgedeckt, Get, Post, Put, Patch, Delete und Options, jeweils mit einem synchronen Aufruf und einem Async-Zwilling.

gRPC im sgcHTTP-Schnellstart: ein TsgcGRPCClient nutzt einen TsgcHTTP2Client als Transport, dazu die vier aufgelisteten RPC-Muster

Unary- und Streaming-RPC auf dem HTTP/2-Client

TsgcGRPCClient erbt die gemultiplexte Verbindung und setzt das gRPC-Wire-Format obendrauf. Aufrufen und CallAsync decken Unary-RPCs ab, ServerStreamingCall verarbeitet einen Strom von Antworten auf eine Anfrage, und OpenClientStream und OpenBidiStream decken Client-Streaming und bidirektionales Streaming ab. RetryPolicy, Interceptors und ServiceConfig ergänzen Wiederholungsverhalten und übergreifende Logik, ohne die Aufrufstellen anzufassen.

Ein Server, fünf Client-Klassen

Zwei Abhängigkeiten, nicht fünf.

Die fünf Klassen lassen sich sauber danach trennen, was sie darunter brauchen. HTTP/2 und gRPC brauchen ALPN, also sgcCustomIndy. Google Cloud braucht nur HTTPS und ein Dienstkonto, und beides liefert die enthaltene Core-Runtime bereits. Der HTTP-Server stammt aus dieser Runtime selbst.

HTTP-Server

TsgcHTTPServer veröffentlicht HTTP-Endpunkte aus deiner eigenen Anwendung. Setze Port, behandle OnCommandGet, setze Active, und jede Anfrage erreicht deinen Code. OnCommandOther deckt Verben wie PUT und DELETE ab. Er ist in der enthaltenen Core-Runtime enthalten.

HTTP/2

TsgcHTTP2Client multiplext unabhängige Streams über eine TLS-Verbindung, komprimiert Header mit HPACK und handelt h2 über ALPN aus. Connect, Get, Post, Put, Patch, Delete und Options, synchron oder Async.

gRPC

TsgcGRPCClient setzt auf dem HTTP/2-Client auf: längenpräfixierte Protocol-Buffers-Nachrichten über HTTP/2-Streams, mit Unary-, Server-Streaming-, Client-Streaming- und bidirektionalen RPCs, dazu Wiederholungsrichtlinie und Interceptors.

Google Cloud, reines HTTPS

TsgcHTTPGoogleCloud_PubSub_Client, TsgcHTTPGoogleCloud_Calendar_Client und TsgcHTTPGoogleCloud_FCM_Client erreichen Pub/Sub, Calendar und Firebase Cloud Messaging, authentifiziert mit einem Google-Dienstkonto. Keiner von ihnen braucht sgcCustomIndy.

Server-Push und Chunked-Bodies

Ereignisse zeigen den Lebenszyklus der Verbindung: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment für Chunked-Bodies, OnHTTP2PushPromise für Server-Push, OnHTTP2GoAway und OnHTTP2Disconnect. Nichts am Lebenszyklus der Streams bleibt vor dir verborgen.

Eine Abhängigkeit für zwei, keine für drei

Die HTTP/2- und gRPC-Clients bauen auf sgcCustomIndy auf, das denselben Plattformumfang wie sgcWebSockets selbst abdeckt. Die Google-Cloud-Clients nutzen reines HTTPS und laufen daher überall dort, wo die Core-Runtime läuft. Delphi 7 bis RAD Studio 13 und C++ Builder.

Voller Quellcode in der Box

Jede Lizenz enthält den vollen Quellcode des HTTP-Servers, aller fünf Clients und der enthaltenen Runtime, sodass sich die Wire-Level-Implementierungen in deinem eigenen Debugger durchlaufen lassen. Die Weitergabe ist lizenzgebührenfrei.

Der Code

HTTP-Server, HTTP/2 und gRPC, nebeneinander.

Client erstellen, auf einen Host richten, das Antwort-Ereignis anbinden und senden. Derselbe Code kompiliert in Delphi 7 bis 13 und C++ Builder.

uses
  sgcHTTP;
var
  HTTP2: TsgcHTTP2Client;
begin
  // 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');
end;

procedure TForm1.HTTP2Response(Sender: TObject;
  const Connection: TsgcHTTP2ConnectionClient;
  const Request: TsgcHTTP2RequestProperty;
  const Response: TsgcHTTP2ResponseProperty);
begin
  Memo1.Lines.Add(Response.DataString);
end;
uses
  sgcHTTP;
var
  GRPC: TsgcGRPCClient;
begin
  // 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.GRPCResponse(Sender: TObject;
  const aResponse: TsgcGRPCResponse);
begin
  Memo1.Lines.Add(aResponse.DataString);
end;
uses
  sgcHTTP_Server;
var
  Server: TsgcHTTPServer;
begin
  // HTTP server: endpoints and static files
  Server := TsgcHTTPServer.Create(nil);
  Server.Port := 8080;
  Server.DocumentRoot := 'C:\www';
  Server.OnCommandGet := ServerCommandGet;
  Server.Active := True;
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;
  1. Den Client erstellenDie Clients liegen in der Unit sgcHTTP, der Server in sgcHTTP_Server. TsgcGRPCClient führt seine eigene HTTP/2-Verbindung über die Eigenschaft Client.
  2. Auf einen Host richtenEin https://-Host genügt. ALPN handelt h2 beim TLS-Handshake aus, und HPACK komprimiert die Header.
  3. Das Antwort-Ereignis anbindenOnHTTP2Response und OnGRPCResponse liefern dir den dekodierten Body, samt Anfrage und Verbindung.
  4. Senden, synchron oder nichtJedes Verb und jeder RPC hat einen blockierenden Aufruf und einen Async-Zwilling, sodass der UI-Thread frei bleibt.

Dieselbe Form in Object Pascal und in C++ Builder. Die vollständige Funktionsmatrix →

Vor dem Kauf

Zwei Dinge, die du vorher wissen solltest.

Was sgcHTTP von dir braucht und was nicht. Beide Antworten sind kurz, und beide stehen auf dieser Seite statt im Kleingedruckten.

Abhängigkeiten pro Client
Client                              braucht sgcCustomIndy
TsgcHTTPServer                      nein, in der Core-Runtime enthalten
TsgcHTTP2Client                     ja, für ALPN
TsgcGRPCClient                      ja, setzt auf TsgcHTTP2Client auf
TsgcHTTPGoogleCloud_PubSub_Client   nein, reines HTTPS
TsgcHTTPGoogleCloud_Calendar_Client nein, reines HTTPS
TsgcHTTPGoogleCloud_FCM_Client      nein, reines HTTPS

HTTP/2 handelt h2 beim TLS-Handshake per ALPN aus.
  Die Standard-Indy-Bibliothek, die mit RAD Studio kommt,
  unterstützt kein ALPN, daher bauen HTTP/2 und gRPC
  stattdessen auf sgcCustomIndy auf.

sgcHTTP ist eigenständig

Die sgcWebSockets Core-Runtime ist enthalten: der HTTP-Server, der HTTP/TLS-Client-Stack, über den jeder Client ihre Anfragen sendet, und die JSON-Schicht, die Google-Cloud-Antworten dekodiert. Ein Installer, voller Quellcode in der Box.

HTTP/2 und gRPC brauchen sgcCustomIndy

Die ALPN-Aushandlung wird von der Standard-Indy-Bibliothek nicht unterstützt, daher basieren TsgcHTTP2Client und damit auch TsgcGRPCClient stattdessen auf sgcCustomIndy. Es ist bei jeder Bestellung von sgcHTTP immer enthalten, und der angezeigte Preis deckt es bereits ab.

Google Cloud braucht nur HTTPS

Die drei Google-Cloud-Clients authentifizieren sich mit Projekt-ID, Client-E-Mail und privatem Schlüssel eines Google-Dienstkontos und rufen die REST-APIs über den reinen HTTPS-Stack der Core-Runtime auf. Keine native Bibliothek, kein sgcCustomIndy.

Delphi und C++ Builder

sgcHTTP unterstützt Delphi 7 bis RAD Studio 13 und C++ Builder. Dieselben Komponenten stecken auch in sgcWebSockets Enterprise, sodass dich eine vorhandene Enterprise- oder All-Access-Lizenz möglicherweise schon abdeckt. Der Test-Installer ist die sgcWebSockets-All-Access-Testversion, daher lassen sich alle fünf Klassen schon heute testen.

sgcHTTP implementiert die veröffentlichten HTTP/2-, gRPC- und Google-Cloud-REST-Schnittstellen, statt ein Hersteller-SDK zu kapseln. Streams, Header, RPCs und Push-Benachrichtigungen sind daher Methoden und Ereignisse erster Klasse, und mit vollem Quellcode ist dazwischen nichts eine Blackbox.

Teil von sgcWebSockets

Ein einzelnes Paket von sgcWebSockets, eigenständig lizenziert.

sgcHTTP bündelt die sgcWebSockets Core-Runtime, auf der es aufbaut, und das Add-on sgcCustomIndy, das HTTP/2 und gRPC brauchen, ist immer enthalten. Jede Lizenz enthält vollen Quellcode und lizenzgebührenfreie Weitergabe.

Single

1 Entwicklerlizenz. Nutzung auf jeweils einem Rechner.

€398

Team

2 Entwicklerlizenzen. Nutzung auf jeweils zwei Rechnern.

€648

Site

Unbegrenzte Entwicklerzahl. Alle Rechner im Unternehmen.

€1,048

HTTP/2-, gRPC- und Google-Cloud-Client-Komponenten für Delphi und C++ Builder, mit enthaltener sgcWebSockets Core-Runtime. Schon sgcWebSockets Enterprise im Einsatz? Dieselben Komponenten sind dort ebenfalls enthalten.

Preise und Lizenzen ansehen
REFERENZEN

Was Entwickler sagen

Vertrauen von Delphi-, C++ Builder-, Lazarus- und .NET-Entwicklern weltweit.

Eure sgcWebSockets-Bibliothek ist sehr nützlich und einfach einzurichten. Macht weiter so!
Simone Moretti Delphi-Entwickler
sgcWebSockets ist großartig und euer Support ist der beste!
Christian Meyer Gründer & CTO
Vielen Dank für eure Hilfe und Unterstützung, ich liebe eure Komponenten.
Mark Steinfeld CTO

Modernes HTTP, gRPC und Google Cloud aus nativem Code.

Ein HTTP-Server, gemultiplextes HTTP/2, Streaming-gRPC und drei Google-Cloud-Clients, mit enthaltener sgcWebSockets Core-Runtime und vollem Quellcode in der Box.

Mehr von eSeGeCe

Weitere Produkte von eSeGeCe

sgcHTTP teilt Konventionen mit den anderen eSeGeCe-Komponentenbibliotheken für Delphi, C++ Builder und .NET. Sie werden mit vollständigem Quellcode ausgeliefert und lassen sich lizenzgebührenfrei weitergeben.

sgcWebSockets

WebSocket, HTTP/2, MQTT, AMQP, WebRTC, KI und über 30 API-Integrationen für Delphi, C++ Builder, Lazarus und .NET. Die Enterprise-Edition enthält auch gRPC.

sgcREST

REST-Server-, OpenAPI-Server- und OpenAPI-Client-Komponenten für Delphi und C++ Builder. Veröffentliche REST-APIs aus einem OpenAPI-3.x-Vertrag, oder nutze jede über OpenAPI beschriebene API.

sgcAuth

OAuth2-Client, JWT-Client und WebAuthn-Unterstützung für Delphi und C++ Builder. Eigenständig, mit gebündelter sgcWebSockets-Core-Runtime.

sgcMQ

Client-Komponenten für MQTT, AMQP 0.9.1 und 1.0, Apache Kafka und STOMP für Delphi und C++ Builder. Eigenständig, die sgcWebSockets Core Runtime ist enthalten.

sgcSocial

Client-Komponenten für Telegram und WhatsApp Business für Delphi und C++ Builder. Eigenständig, mit gebündelter sgcWebSockets Core-Runtime.

sgcAI

KI-, LLM- und MCP-Komponenten für Delphi und C++ Builder. Sieben LLM-Anbieter hinter einer Komponente, dazu MCP, Embeddings und Sprache.

sgcHTML

Serverseitige HTML- und UI-Komponenten auf Basis von Bootstrap 5 und htmx für Delphi, C++ Builder und .NET.

sgcQUIC

Reiner QUIC-Transport sowie HTTP/3-Client und -Server mit WebTransport. Ein Add-on zu sgcWebSockets Enterprise.

sgcOpenAPI

OpenAPI-3.x-Parser, nativer Pascal-SDK-Generator, OpenAPI-Server-Komponente und 1.195+ vorgefertigte Cloud-SDKs.

sgcSign

XAdES, PAdES, CAdES und ASiC für Dokumente, Authenticode, ClickOnce, NuGet und VSIX für Code.

sgcPDF

PDF-Dateien erstellen, bearbeiten, ansehen, signieren, schwärzen und validieren in reinem Object Pascal, ganz ohne DLL. Wird eigenständig lizenziert.

sgcBiometrics

Windows Hello, Fingerabdrucksensoren und das Windows Biometric Framework für Delphi und C++ Builder.

sgcIndy

Aktualisierte Indy-TCP/IP-Komponenten mit modernem TLS, IPv6 und HTTP/2 für Delphi 7 bis 13.

Neues aus dem Blog

Alle Beiträge ansehen →

Du siehst gerade die Ansicht HTTP/2 & gRPC von eSeGeCe.

Zeig mir eine andere Perspektive →
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordere innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen