VOIS-LE À L'ŒUVRE

Découvre sgcHTTP en deux minutes

Un serveur HTTP, des clients HTTP/2 et gRPC pour Delphi et C++Builder, avec des intégrations Google Cloud, Amazon et Apple Push prêtes à l’emploi.

AVANT D'ACHETER

Deux choses à savoir d'abord

Ce que sgcHTTP attend de toi, et ce qu'il n'attend pas. Les deux réponses sont courtes.

sgcHTTP est autonome

Autonome, le runtime sgcWebSockets Core est inclus : le serveur HTTP, la pile client HTTP/TLS par laquelle chaque client envoie ses requêtes, et la couche JSON qui décode les réponses Google Cloud. Une seule référence, un seul installateur.

Le code source complet accompagne chaque licence, le serveur HTTP, les cinq clients et le runtime en dessous se tracent donc dans ton propre débogueur au lieu de disparaître dans un binaire.

Complément requis pour deux composants sur cinq

HTTP/2 et gRPC ont besoin de sgcCustomIndy

HTTP/2 négocie le protocole h2 avec ALPN pendant la poignée de main TLS, et la bibliothèque Indy standard livrée avec RAD Studio ne prend pas en charge ALPN. Le client HTTP/2 et le client gRPC de sgcHTTP sont donc bâtis sur sgcCustomIndy, toujours inclus quand tu commandes sgcHTTP, et le prix affiché le couvre déjà.

Les trois clients Google Cloud, Pub/Sub, Calendar et Firebase Cloud Messaging, sont en HTTPS pur. Ils tournent sur le runtime Core nu et n'ont pas du tout besoin de sgcCustomIndy.

CE QUE TU REÇOIS

Trois composants de palette, trois clients Google Cloud

Le serveur HTTP, le client HTTP/2 et le client gRPC sont des composants non visuels sur la page de palette SGC HTTP. Le serveur est déclaré dans l'unité sgcHTTP_Server du runtime Core inclus, les deux clients dans l'unité sgcHTTP. Dépose-en un sur une fiche ou crée-le en code, règle les options de connexion, branche les événements, puis appelle les méthodes de requête typées. Les trois clients Google Cloud vivent dans la même unité comme des classes pur code, rien à déposer sur une fiche : crée une instance, règle GoogleCloudOptions, et appelle directement ses méthodes.

Serveur HTTP1 composant

Des points d'accès HTTP et des fichiers statiques depuis ton application

TsgcHTTPServer transforme ton application Delphi ou C++ Builder en serveur HTTP. Règle Port, gère OnCommandGet, passe Active à true, et chaque requête arrive dans ton code avec ses objets de requête et de réponse, tandis que OnCommandOther couvre les verbes comme PUT et DELETE. Pointe DocumentRoot vers un dossier et le serveur renvoie les fichiers statiques qu'il contient. HTTPCompression compresse les réponses, KeepAlive réutilise les connexions, SessionState avec OnSessionStart et OnSessionEnd suit les sessions, MaxRequestBodySize plafonne la taille des corps de requête et HTTPUploadFiles enregistre les fichiers uploadés sur disque. En production, SSL et SSLOptions activent TLS, Authentication et OnAuthentication protègent tes points d'accès, et ThreadPool et MaxConnections contrôlent la montée en charge. C'est le même moteur que le serveur WebSocket de sgcWebSockets, sans la partie WebSocket, et il est livré avec le runtime Core inclus.

TsgcHTTPServer Inclus dans le runtime Core

HTTP/21 composant

Des flux multiplexés sur une seule connexion TLS

TsgcHTTP2Client parle HTTP/2 (RFC 9113) : plusieurs requêtes partagent une seule connexion TCP sous forme de flux indépendants, une réponse lente ne bloque donc pas les autres derrière elle. Les en-têtes sont compressés avec HPACK, et le protocole h2 est négocié pendant la poignée de main TLS via ALPN, raison pour laquelle le composant est bâti sur sgcCustomIndy plutôt que sur la bibliothèque Indy standard. Chaque verbe est couvert, Connect, Get, Post, Put, Patch, Delete et Options, chacun avec un appel synchrone et un jumeau Async. Des é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. HTTP2Options configure la trame de réglages locale, et TLSOptions et Authentication proviennent du reste de la pile HTTP sgc.

TsgcHTTP2Client Nécessite sgcCustomIndy

gRPC1 composant

RPC unaires et en streaming sur le client HTTP/2

TsgcGRPCClient est bâti sur le client HTTP/2, il hérite donc de la connexion multiplexée et ajoute par-dessus le format de câble gRPC : des messages Protocol Buffers préfixés par leur longueur, transportés sur des flux HTTP/2. Call et CallAsync couvrent les RPC unaires, ServerStreamingCall gère un flux de réponses pour une seule requête, et OpenClientStream/SendStreamMessage/CloseClientStream plus OpenBidiStream/SendBidiMessage/CloseBidiStream couvrent les RPC en streaming client et bidirectionnel. OnGRPCResponse, OnGRPCStreamMessage et OnGRPCStreamEnd délivrent le trafic, et RetryPolicy, Interceptors et ServiceConfig ajoutent la logique de réessai, la logique transversale et la configuration de service sans toucher aux points d'appel. Comme le client HTTP/2 sur lequel il repose, il a besoin de sgcCustomIndy pour ALPN.

TsgcGRPCClient Nécessite sgcCustomIndy

Google Cloud3 classes

Pub/Sub, Calendar et notifications push, en HTTPS pur

Trois autres classes atteignent des services Google Cloud en HTTPS pur, authentifiées avec un compte de service Google, et aucune n'a besoin de sgcCustomIndy. TsgcHTTPGoogleCloud_PubSub_Client publie et récupère des messages et gère les sujets, abonnements et instantanés : Publish, Pull, Acknowledge, CreateTopic, CreateSubscription et le reste de la surface REST de Pub/Sub. TsgcHTTPGoogleCloud_Calendar_Client encapsule l'API Google Calendar v3 : NewCalendar, NewEvent, LoadEvents et LoadCalendars, avec les événements OnGetCalendar et OnGetCalendarEvent pour la synchronisation. TsgcHTTPGoogleCloud_FCM_Client envoie une charge utile de notification push à un projet Firebase en un seul appel, SendMessage. Les trois sont des classes pur code : crée une instance, règle GoogleCloudOptions, appelle les méthodes.

TsgcHTTPGoogleCloud_PubSub_Client TsgcHTTPGoogleCloud_Calendar_Client TsgcHTTPGoogleCloud_FCM_Client

COMMENT ÇA MARCHE

Deux dépendances, pas cinq

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 de plus que HTTPS et un compte de service, que le runtime Core inclus fournit déjà.

HTTP/2 a besoin d'ALPN, donc de sgcCustomIndy

Application-Layer Protocol Negotiation choisit h2 pendant la poignée de main TLS, et la bibliothèque Indy standard livrée avec RAD Studio n'a aucune prise en charge d'ALPN. TsgcHTTP2Client est donc bâti sur sgcCustomIndy, la version Indy modifiée d'eSeGeCe.

gRPC, c'est Protocol Buffers porté par le client HTTP/2

TsgcGRPCClient n'ouvre pas sa propre connexion, sa propriété Client est un TsgcHTTP2Client. Les appels unaires, en streaming serveur, en streaming client et bidirectionnels voyagent tous comme des flux HTTP/2 en dessous.

Google Cloud, c'est HTTPS plus un compte de service

Les trois clients Google Cloud s'authentifient avec GoogleCloudOptions.JWT, l'id de projet, l'e-mail client et la clé privée d'un compte de service Google, et appellent les API REST sur la pile HTTPS pure du runtime Core. OnAuthToken et OnAuthTokenError exposent l'échange de token.

Le runtime Core est dans la boîte

Autonome, le runtime sgcWebSockets Core est inclus. Il fournit TsgcHTTPServer et la pile client HTTP/TLS par laquelle chacun des cinq clients passe, et son code source complet fait partie du package comme tout le reste.

DÉMARRAGE RAPIDE

Serveur HTTP, HTTP/2 et gRPC, côte à côte

Les deux clients sont déclarés dans l'unité sgcHTTP et le serveur dans sgcHTTP_Server, et TsgcGRPCClient porte sa propre connexion HTTP/2 via sa propriété Client. Le même code se compile de Delphi 7 à 13 et sur C++ Builder.

uses
  sgcHTTP, sgcHTTP_Server;

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;

  // 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
  if ARequestInfo.Document = '/api/status' then
  begin
    AResponseInfo.ContentType := 'application/json';
    AResponseInfo.ContentText := '{"status":"ok"}';
  end;
end;

// include: sgcHTTP.hpp, sgcHTTP_Server.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;

// 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)
{
  if (ARequestInfo->Document == "/api/status")
  {
    AResponseInfo->ContentType = "application/json";
    AResponseInfo->ContentText = "{\"status\":\"ok\"}";
  }
}

PLATEFORMES

Une dépendance pour deux clients, aucune pour trois

Le client HTTP/2 et le client gRPC reposent sur sgcCustomIndy, qui couvre la même gamme de plateformes que sgcWebSockets lui-même. Les clients Google Cloud sont en HTTPS pur, ils tournent donc partout où le runtime Core tourne.

TsgcHTTP2Client et TsgcGRPCClient Bâtis sur sgcCustomIndy pour ALPN

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Clients Google Cloud HTTPS pur, sgcCustomIndy non requis

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Prise en charge des IDE Une seule arborescence source, packages de conception par version

Delphi 7 à 13 C++ Builder

Installateur d'essai L'essai sgcWebSockets All-Access inclut les composants sgcHTTP

Un seul téléchargement, le serveur et les cinq clients

Télécharger l'installateur d'essai →

TARIFS

Un package autonome

sgcHTTP se licencie tout seul, à partir de €398 pour un développeur. Toutes les licences incluent le code source complet, 1 an de mises à jour et une remise de renouvellement de 50 % à 70 % : 50 % si tu renouvelles un pack, 60 % pour deux, 70 % pour trois ou plus. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP et sgcREST comptent chacun pour un pack. sgcHTTP est aussi inclus dans le pack All-Access.

sgcHTTP

€398

Licences Single, Team et Site disponibles.

Serveur HTTP avec fichiers statiques, sessions et TLS
Client HTTP/2 avec multiplexage et HPACK
Client gRPC, RPC unaires et en streaming
Clients Google Cloud Pub/Sub, Calendar et FCM
Runtime sgcWebSockets Core inclus
Delphi 7 à 13 et C++ Builder
Code source complet
1 an de mises à jour

HTTP/2 et gRPC ont besoin du complément sgcCustomIndy. Il est toujours inclus dans ta commande, et le prix affiché le couvre déjà.

Acheter une licence Single €398

Team €648 Site €1,048

Le paiement liste trois articles : le droit au runtime sgcWebSockets Core, facturé à zéro, le pack sgcHTTP lui-même, et le complément sgcCustomIndy, toujours inclus. Détail complet des tarifs.

PLUS D'ESEGECE

Autres produits d'eSeGeCe

Associe sgcHTTP à nos autres bibliothèques de composants pour Delphi, C++ Builder et .NET.

sgcCustomIndy

La bibliothèque Indy modifiée sur laquelle reposent les clients HTTP/2 et gRPC de sgcHTTP : ALPN, TLS 1.3 et liaison statique OpenSSL.

En savoir plus →

sgcWebSockets

La bibliothèque complète : clients et serveurs WebSocket, HTTP/2, gRPC, IoT, P2P et composants d'IA. Son édition Enterprise inclut aussi gRPC.

En savoir plus →

sgcAI

Composants IA, LLM et MCP. Un seul composant de chat atteint OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok et Mistral.

En savoir plus →

sgcMQ

Composants clients natifs MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka et STOMP, avec le runtime Core inclus.

En savoir plus →

sgcCrypto

Chiffrement symétrique et asymétrique, hachage et algorithmes post-quantiques. Livré gratuitement à partir de sgcWebSockets Standard.

En savoir plus →

sgcSocial

Composants clients WhatsApp Business Cloud API et Telegram TDLib, avec le runtime Core inclus.

En savoir plus →

sgcQUIC

Composants client et serveur QUIC (RFC 9000) et HTTP/3 (RFC 9114) bâtis sur le moteur QUIC natif d'OpenSSL 3.5.

En savoir plus →

sgcWebRTC

Moteur média WebRTC complet : appels audio/vidéo, canaux de données et partage d'écran. Un complément à sgcWebSockets Enterprise.

En savoir plus →

sgcHTTP : composants serveur HTTP, HTTP/2, gRPC et Google Cloud pour Delphi et C++ Builder

Découvre sgcHTTP en deux minutes

Deux choses à savoir d'abord

sgcHTTP est autonome

HTTP/2 et gRPC ont besoin de sgcCustomIndy

Trois composants de palette, trois clients Google Cloud

Des points d'accès HTTP et des fichiers statiques depuis ton application

Des flux multiplexés sur une seule connexion TLS

RPC unaires et en streaming sur le client HTTP/2

Pub/Sub, Calendar et notifications push, en HTTPS pur

Deux dépendances, pas cinq

Serveur HTTP, HTTP/2 et gRPC, côte à côte

Une dépendance pour deux clients, aucune pour trois

Un package autonome

sgcHTTP

HTTP moderne, gRPC et Google Cloud depuis du code natif

Autres produits d'eSeGeCe

sgcCustomIndy

sgcWebSockets

sgcAI

sgcMQ

sgcCrypto

sgcSocial

sgcQUIC

sgcWebRTC