Un serveur HTTP et cinq composants clients. TsgcHTTPServer publie des points d’accès HTTP et des fichiers statiques depuis ta propre application. TsgcHTTP2Client parle HTTP/2 avec des flux multiplexés sur une seule connexion TLS et la compression d’en-têtes HPACK. TsgcGRPCClient est un client gRPC construit par-dessus, pour des appels Protocol Buffers unaires et en streaming. Trois autres classes accèdent à Google Cloud en HTTPS simple : Pub/Sub, Calendar et Firebase Cloud Messaging.
Un démarrage rapide commenté et sous-titré : un client HTTP/2 qui envoie de nombreuses requêtes sur une seule connexion, puis un appel gRPC qui emprunte ce même transport, le tout depuis Delphi. Rien n’est téléchargé tant que tu n’appuies pas sur lecture.
Appelle un point de terminaison HTTP/2 et fais un appel gRPC, depuis Delphi.
Les deux composants sont déclarés dans l’unité sgcHTTP, et TsgcGRPCClient porte sa propre connexion HTTP/2 via sa propriété Client.
TsgcHTTP2Client parle HTTP/2 (RFC 9113) : plusieurs requêtes partagent une même connexion TCP sous forme de flux indépendants. Les en-têtes sont compressés avec HPACK, et h2 est négocié pendant la poignée de main TLS via ALPN. Tous les verbes sont couverts, Get, Post, Put, Patch, Delete et Options, chacun avec un appel synchrone et son jumeau Async.
TsgcGRPCClient hérite de la connexion multiplexée et ajoute par-dessus le format de câble gRPC. Call et CallAsync couvrent les RPC unaires, ServerStreamingCall gère un flux de réponses à une seule requête, et OpenClientStream et OpenBidiStream couvrent le streaming client et le streaming bidirectionnel. RetryPolicy, Interceptors et ServiceConfig ajoutent les nouvelles tentatives et la logique transversale sans toucher aux sites d’appel.
Les cinq classes se répartissent nettement selon ce dont elles ont besoin en dessous. HTTP/2 et gRPC ont besoin d’ALPN, donc de sgcCustomIndy. Google Cloud n’a besoin de rien d’autre que HTTPS et d’un compte de service, ce que le runtime Core inclus fournit déjà. Le serveur HTTP vient de ce runtime lui-même.
TsgcHTTPServer publie des points d’accès HTTP depuis ta propre application. Définis Port, gère OnCommandGet, passe Active à true, et chaque requête arrive dans ton code. OnCommandOther couvre les verbes comme PUT et DELETE. Il est livré avec le runtime Core inclus.
Pointe DocumentRoot vers un dossier et le serveur en renvoie les fichiers statiques. HTTPUploadFiles enregistre sur disque les fichiers envoyés, MaxRequestBodySize plafonne la taille des corps de requête, et HTTPCompression et KeepAlive gardent les réponses légères et les connexions ouvertes.
SSL et SSLOptions activent TLS, Authentication et OnAuthentication protègent les points d’accès, SessionState suit les sessions, et ThreadPool et MaxConnections contrôlent la montée en charge. Le même moteur que le serveur WebSocket, sans la partie WebSocket.
TsgcHTTP2Client multiplexe des flux indépendants sur une seule connexion TLS, compresse les en-têtes avec HPACK et négocie h2 via ALPN. Connect, Get, Post, Put, Patch, Delete et Options, en synchrone ou en Async.
TsgcGRPCClient s’appuie sur le client HTTP/2 : des messages Protocol Buffers préfixés par leur longueur sur des flux HTTP/2, avec des RPC unaires, en streaming serveur, en streaming client et bidirectionnels, plus une politique de nouvelles tentatives et des intercepteurs.
TsgcHTTPGoogleCloud_PubSub_Client, TsgcHTTPGoogleCloud_Calendar_Client et TsgcHTTPGoogleCloud_FCM_Client accèdent à Pub/Sub, Calendar et Firebase Cloud Messaging, authentifiés avec un compte de service Google. Aucun n’a besoin de sgcCustomIndy.
Les événements exposent le cycle de vie de la connexion : OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment pour les corps fragmentés, OnHTTP2PushPromise pour le push serveur, OnHTTP2GoAway et OnHTTP2Disconnect. Rien du cycle de vie des flux ne t’est caché.
Les clients HTTP/2 et gRPC reposent sur sgcCustomIndy, qui couvre la même gamme de plateformes que sgcWebSockets lui-même. Les clients Google Cloud utilisent du HTTPS simple, donc ils tournent partout où tourne le runtime Core. De Delphi 7 à RAD Studio 13, et C++ Builder.
Chaque licence inclut le code source complet du serveur HTTP, des cinq clients et du runtime fourni, donc les implémentations au niveau du câble se parcourent pas à pas dans ton propre débogueur. Le déploiement est sans redevances.
Crée le composant, définis un port ou pointe-le vers un hôte, branche l’événement et c’est parti. Le même code se compile de Delphi 7 à 13 et en 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
// serveur HTTP : points d’accès et fichiers statiques
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;La même forme en Object Pascal et en C++ Builder. La matrice complète des fonctionnalités →
Ce que sgcHTTP attend de toi, et ce qu’il n’attend pas. Les deux réponses sont courtes, et toutes deux figurent sur cette page plutôt que dans les petites lignes.
classe requiert sgcCustomIndy
TsgcHTTPServer non, livré avec le runtime Core
TsgcHTTP2Client oui, pour ALPN
TsgcGRPCClient oui, s’appuie sur TsgcHTTP2Client
TsgcHTTPGoogleCloud_PubSub_Client non, HTTPS simple
TsgcHTTPGoogleCloud_Calendar_Client non, HTTPS simple
TsgcHTTPGoogleCloud_FCM_Client non, HTTPS simple
HTTP/2 négocie h2 avec ALPN pendant la poignée de main TLS.
La bibliothèque Indy standard livrée avec RAD Studio
ne gère pas ALPN, donc HTTP/2 et gRPC sont tous deux
construits sur sgcCustomIndy.Le runtime sgcWebSockets Core est inclus : le serveur HTTP, la pile cliente HTTP/TLS par laquelle passent les requêtes de chaque client, et la couche JSON qui décode les réponses de Google Cloud. Un seul installeur, code source complet inclus.
La négociation ALPN n’est pas prise en charge par la bibliothèque Indy standard, donc TsgcHTTP2Client et, par extension, TsgcGRPCClient sont construits sur sgcCustomIndy. Il est toujours inclus quand tu commandes sgcHTTP, et le prix affiché le couvre déjà.
Les trois clients Google Cloud s’authentifient avec l’identifiant de projet, l’e-mail client et la clé privée d’un compte de service Google, et appellent les API REST via la pile HTTPS simple du runtime Core. Pas de bibliothèque native, pas de sgcCustomIndy.
sgcHTTP cible de Delphi 7 à RAD Studio 13 et C++ Builder. Les mêmes composants figurent aussi dans sgcWebSockets Enterprise, donc une licence Enterprise ou All-Access existante peut déjà te couvrir. L’installeur d’essai est l’essai sgcWebSockets All-Access, ce qui permet d’évaluer dès aujourd’hui le serveur HTTP et les cinq clients.
sgcHTTP implémente les interfaces publiées de HTTP/2, de gRPC et de l’API REST de Google Cloud au lieu d’encapsuler un SDK fournisseur. Les flux, les en-têtes, les RPC et les notifications push sont donc de vrais méthodes et événements, et avec le code source complet, rien entre les deux n’est une boîte noire.
sgcHTTP inclut le runtime sgcWebSockets Core sur lequel il est construit, et le complément sgcCustomIndy dont HTTP/2 et gRPC ont besoin est toujours inclus. Chaque licence est livrée avec le code source complet et un déploiement sans redevances.
1 licence développeur. Utilisation sur une machine à la fois.
2 licences développeur. Utilisation sur deux machines à la fois.
Développeurs illimités. Toutes les machines de l’entreprise.
Composants clients HTTP/2, gRPC et Google Cloud pour Delphi et C++ Builder, avec le runtime sgcWebSockets Core inclus. Tu as déjà sgcWebSockets Enterprise ? Les mêmes composants s’y trouvent aussi.
Voir les tarifs et les licencesPlébiscité par des développeurs Delphi, C++ Builder, Lazarus et .NET dans le monde entier.
Votre bibliothèque sgcWebSockets est très utile et facile à configurer. Continuez votre excellent travail !
sgcWebSockets est incroyable et votre support est le meilleur !
Merci beaucoup pour votre aide et votre support, j’adore vos composants.
HTTP/2 multiplexé, gRPC en streaming et trois clients Google Cloud, avec le runtime sgcWebSockets Core inclus et le code source complet livré.
PrésentationMatrice des fonctionnalitésClient HTTP/2Client gRPC
sgcHTTP partage ses conventions avec les autres bibliothèques de composants eSeGeCe pour Delphi, C++ Builder et .NET. Elles sont livrées avec le code source complet et se déploient sans redevances.
WebSocket, HTTP/2, MQTT, AMQP, WebRTC, IA et plus de 30 intégrations d’API pour Delphi, C++ Builder, Lazarus et .NET. Son édition Enterprise inclut aussi gRPC.
Composants serveur REST, serveur OpenAPI et client OpenAPI pour Delphi et C++ Builder. Publie des API REST à partir d’un contrat OpenAPI 3.x, ou consomme n’importe quelle API décrite par OpenAPI.
Client OAuth2, client JWT et prise en charge de WebAuthn pour Delphi et C++ Builder. Autonome, avec le runtime sgcWebSockets Core inclus.
Composants clients MQTT, AMQP 0.9.1 et 1.0, Apache Kafka et STOMP pour Delphi et C++ Builder. Autonome, avec le runtime sgcWebSockets Core inclus.
Composants clients Telegram et WhatsApp Business pour Delphi et C++ Builder. Autonome, avec le runtime sgcWebSockets Core inclus.
Composants IA, LLM et MCP pour Delphi et C++ Builder. Sept fournisseurs de LLM derrière un seul composant, plus MCP, embeddings et synthèse vocale.
Composants HTML et d’interface côté serveur sur Bootstrap 5 et htmx pour Delphi, C++ Builder et .NET.
Transport QUIC brut et client et serveur HTTP/3, avec WebTransport. Une extension de sgcWebSockets Enterprise.
Parser OpenAPI 3.x, générateur de SDK Pascal natif, composant serveur OpenAPI, et plus de 1 195 SDK cloud préconçus.
XAdES, PAdES, CAdES et ASiC pour les documents, Authenticode, ClickOnce, NuGet et VSIX pour le code.
Crée, édite, affiche, signe, caviarde et valide des fichiers PDF en pur Object Pascal, sans DLL à déployer. Licence séparée.
Windows Hello, capteurs d’empreintes digitales et Windows Biometric Framework pour Delphi et C++ Builder.
Composants Indy TCP/IP mis à jour avec TLS moderne, IPv6 et HTTP/2, de Delphi 7 à 13.
