sgcHTTP Server HTTP, HTTP/2 e gRPC, nativi in Delphi. anche Google Cloud.

Un server HTTP e cinque componenti client. TsgcHTTPServer pubblica endpoint HTTP e file statici dalla tua applicazione. TsgcHTTP2Client parla HTTP/2 con stream multiplexati su una sola connessione TLS e compressione degli header HPACK. TsgcGRPCClient è un client gRPC costruito sopra di esso, per chiamate Protocol Buffers unarie e in streaming. Altre tre classi raggiungono Google Cloud su semplice HTTPS: Pub/Sub, Calendar e Firebase Cloud Messaging.

Un pacchetto autonomo di sgcWebSockets, con il runtime Core incluso. Vedi i prezzi →
  • Server HTTP
  • HTTP/2
  • gRPC
  • Google Cloud
  • HPACK & ALPN
  • Delphi da 7 a 13
  • C++ Builder
  • 3Componenti in palette: il server HTTP, il client HTTP/2 e il client gRPC
  • 5Classi client in tutto
  • 3Servizi Google Cloud: Pub/Sub, Calendar e FCM
  • 1Installer autonomo, runtime Core incluso
  • 100%Codice sorgente incluso in ogni licenza
Guardalo in azione

Scopri sgcHTTP in due minuti.

Un avvio rapido con voce narrante e sottotitoli: un client HTTP/2 che invia molte richieste su una sola connessione, poi una chiamata gRPC sullo stesso trasporto, il tutto da Delphi. Non si scarica nulla finché non premi play.

Avvio rapido di sgcHTTP

Chiama un endpoint HTTP/2 ed esegui una chiamata gRPC, da Delphi.

  1. Crea il client HTTP/2Crea un TsgcHTTP2Client, gestisci OnHTTP2Response e chiama Get. Il protocollo h2 viene negoziato durante l'handshake TLS tramite ALPN.
  2. Molte richieste, una sola connessioneLe richieste condividono una singola connessione TCP come stream indipendenti, quindi una risposta lenta non blocca quelle che la seguono.
  3. gRPC sullo stesso trasportoAssegna il client HTTP/2 al client gRPC e chiama un metodo per servizio e nome. I messaggi viaggiano come Protocol Buffers con prefisso di lunghezza.
  4. Quattro pattern RPCUnario, streaming del server, streaming del client e streaming bidirezionale, ciascuno con il proprio metodo su TsgcGRPCClient.
Due componenti in palette

Un client HTTP/2, e gRPC che ci viaggia sopra.

Entrambi i componenti sono dichiarati nell'unità sgcHTTP, e TsgcGRPCClient porta la propria connessione HTTP/2 attraverso la sua proprietà Client.

Il client HTTP/2 nell'avvio rapido di sgcHTTP: il codice Delphi accanto a sei richieste in volo su un solo socket

Stream multiplexati su una sola connessione TLS

TsgcHTTP2Client parla HTTP/2 (RFC 9113): più richieste condividono una singola connessione TCP come stream indipendenti. Gli header sono compressi con HPACK e h2 viene negoziato durante l'handshake TLS tramite ALPN. Ogni verbo è coperto, Get, Post, Put, Patch, Delete e Options, ciascuno con una chiamata sincrona e una gemella Async.

gRPC nell'avvio rapido di sgcHTTP: un TsgcGRPCClient che usa un TsgcHTTP2Client come trasporto, con i quattro pattern RPC elencati

RPC unarie e in streaming sul client HTTP/2

TsgcGRPCClient eredita la connessione multiplexata e aggiunge sopra il formato di trasmissione gRPC. Call e CallAsync coprono le RPC unarie, ServerStreamingCall gestisce un flusso di risposte a una richiesta, e OpenClientStream e OpenBidiStream coprono lo streaming del client e quello bidirezionale. RetryPolicy, Interceptors e ServiceConfig aggiungono il comportamento di retry e la logica trasversale senza toccare i punti di chiamata.

Un server, cinque classi client

Due dipendenze, non cinque.

Le cinque classi si dividono nettamente in base a ciò che richiedono sotto. HTTP/2 e gRPC richiedono ALPN, il che significa sgcCustomIndy. Google Cloud non richiede altro che HTTPS e un service account, che il runtime Core incluso già fornisce. Il server HTTP proviene dal runtime stesso.

Server HTTP

TsgcHTTPServer pubblica endpoint HTTP dalla tua applicazione. Imposta Port, gestisci OnCommandGet, imposta Active e ogni richiesta arriva al tuo codice. OnCommandOther copre verbi come PUT e DELETE. È incluso nel runtime Core.

HTTP/2

TsgcHTTP2Client multiplexa stream indipendenti su una sola connessione TLS, comprime gli header con HPACK e negozia h2 tramite ALPN. Connect, Get, Post, Put, Patch, Delete e Options, sincroni o Async.

gRPC

TsgcGRPCClient viaggia sul client HTTP/2: messaggi Protocol Buffers con prefisso di lunghezza su stream HTTP/2, con RPC unarie, a streaming del server, a streaming del client e bidirezionali, più policy di retry e interceptor.

Google Cloud, semplice HTTPS

TsgcHTTPGoogleCloud_PubSub_Client, TsgcHTTPGoogleCloud_Calendar_Client and TsgcHTTPGoogleCloud_FCM_Client raggiungono Pub/Sub, Calendar e Firebase Cloud Messaging, autenticati con un service account Google. Nessuno di essi richiede sgcCustomIndy.

Server push e body a blocchi

Gli eventi espongono il ciclo di vita della connessione: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment per i body a blocchi, OnHTTP2PushPromise per il server push, OnHTTP2GoAway e OnHTTP2Disconnect. Nulla del ciclo di vita dello stream ti viene nascosto.

Una dipendenza per due, nessuna per tre

I client HTTP/2 e gRPC si basano su sgcCustomIndy, che copre la stessa gamma di piattaforme di sgcWebSockets. I client Google Cloud usano semplice HTTPS, quindi girano ovunque giri il runtime Core. Da Delphi 7 a RAD Studio 13, e C++ Builder.

Sorgente completo incluso

Ogni licenza include il sorgente completo del server HTTP, di tutti e cinque i client e del runtime incluso, così le implementazioni a livello di protocollo si seguono passo passo nel tuo debugger. La distribuzione è senza royalty.

Il codice

Server HTTP, HTTP/2 e gRPC, fianco a fianco.

Crea il client, puntalo a un host, collega l'evento di risposta e invia. Lo stesso codice si compila in Delphi da 7 a 13 e in 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. Crea il clientI client risiedono nell'unità sgcHTTP, il server in sgcHTTP_Server. TsgcGRPCClient porta la propria connessione HTTP/2 attraverso la sua proprietà Client.
  2. Puntalo a un hostBasta un host https://. ALPN negozia h2 durante l'handshake TLS e HPACK comprime gli header.
  3. Collega l'evento di rispostaOnHTTP2Response e OnGRPCResponse ti consegnano il body decodificato, con la richiesta e la connessione allegate.
  4. Invia, in modo sincrono o noOgni verbo e ogni RPC ha una chiamata bloccante e una gemella Async, così il thread della UI resta libero.

La stessa forma in Object Pascal e in C++ Builder. La matrice completa delle funzionalità →

Prima di acquistare

Due cose da sapere prima.

Cosa richiede sgcHTTP da te, e cosa no. Entrambe le risposte sono brevi, ed entrambe sono su questa pagina invece che nelle note in piccolo.

Dipendenze per client
client                              richiede sgcCustomIndy
TsgcHTTPServer                      no, incluso nel runtime Core
TsgcHTTP2Client                     sì, per ALPN
TsgcGRPCClient                      sì, viaggia su TsgcHTTP2Client
TsgcHTTPGoogleCloud_PubSub_Client   no, semplice HTTPS
TsgcHTTPGoogleCloud_Calendar_Client no, semplice HTTPS
TsgcHTTPGoogleCloud_FCM_Client      no, semplice HTTPS

HTTP/2 negozia h2 con ALPN durante l'handshake TLS.
  La libreria Indy standard fornita con RAD Studio
  non supporta ALPN, quindi sia HTTP/2 sia gRPC sono
  costruiti su sgcCustomIndy.

sgcHTTP è autonomo

Il runtime sgcWebSockets Core è incluso: il server HTTP, lo stack client HTTP/TLS attraverso cui ogni client invia le sue richieste e il livello JSON che decodifica le risposte di Google Cloud. Un solo installer, codice sorgente completo incluso.

HTTP/2 e gRPC richiedono sgcCustomIndy

La negoziazione ALPN non è supportata dalla libreria Indy standard, quindi TsgcHTTP2Client e, di conseguenza, TsgcGRPCClient sono costruiti su sgcCustomIndy. È sempre incluso quando ordini sgcHTTP, e il prezzo mostrato lo comprende già.

Google Cloud richiede solo HTTPS

I tre client Google Cloud si autenticano con l'id progetto, l'email client e la chiave privata di un service account Google, e chiamano le API REST sullo stack HTTPS semplice del runtime Core. Nessuna libreria nativa, nessun sgcCustomIndy.

Delphi e C++ Builder

sgcHTTP è destinato a Delphi da 7 a RAD Studio 13 e a C++ Builder. Gli stessi componenti sono presenti anche in sgcWebSockets Enterprise, quindi una licenza Enterprise o All-Access esistente potrebbe già coprirti. L'installer di prova è il trial di sgcWebSockets All-Access, così il server HTTP e tutti e cinque i client si possono valutare subito.

sgcHTTP implementa le superfici pubblicate di HTTP/2, gRPC e Google Cloud REST invece di incapsulare un SDK di terze parti, quindi stream, header, RPC e notifiche push sono tutti metodi ed eventi di prima classe, e il codice sorgente completo significa che nulla nel mezzo è una scatola nera.

Parte di sgcWebSockets

Un singolo pacchetto di sgcWebSockets, con licenza propria.

sgcHTTP include il runtime sgcWebSockets Core su cui è costruito, e il componente aggiuntivo sgcCustomIndy richiesto da HTTP/2 e gRPC è sempre incluso. Ogni licenza comprende il codice sorgente completo e la distribuzione senza royalty.

Single

1 licenza sviluppatore. Uso su una macchina alla volta.

€398

Team

2 licenze sviluppatore. Uso su due macchine alla volta.

€648

Site

Sviluppatori illimitati. Tutte le macchine aziendali.

€1,048

Componenti client HTTP/2, gRPC e Google Cloud per Delphi e C++ Builder, con il runtime sgcWebSockets Core incluso. Usi già sgcWebSockets Enterprise? Gli stessi componenti sono presenti anche lì.

Vedi prezzi e licenze
Testimonianze

Cosa dicono gli sviluppatori

Scelta da sviluppatori Delphi, C++ Builder, Lazarus e .NET in tutto il mondo.

La vostra libreria sgcWebSockets è molto utile e semplice da configurare. Continuate così!
Simone Moretti Sviluppatore Delphi
sgcWebSockets è straordinario e il vostro supporto è il migliore!
Christian Meyer Fondatore e CTO
Grazie mille per il vostro aiuto e supporto, adoro i vostri componenti.
Mark Steinfeld CTO

HTTP moderno, gRPC e Google Cloud da codice nativo.

Un server HTTP, HTTP/2 multiplexato, gRPC in streaming e tre client Google Cloud, con il runtime sgcWebSockets Core incluso e il codice sorgente completo nella confezione.

L'ecosistema

Altri prodotti di eSeGeCe

sgcHTTP condivide le convenzioni con le altre librerie di componenti eSeGeCe per Delphi, C++ Builder e .NET. Includono il codice sorgente completo e si distribuiscono senza royalty.

sgcWebSockets

WebSocket, HTTP/2, MQTT, AMQP, WebRTC, IA e oltre 30 integrazioni API per Delphi, C++ Builder, Lazarus e .NET. La sua edizione Enterprise include anche gRPC.

sgcREST

Componenti server REST, server OpenAPI e client OpenAPI per Delphi e C++ Builder. Pubblica API REST da un contratto OpenAPI 3.x, oppure consuma qualsiasi API descritta con OpenAPI.

sgcAuth

Client OAuth2, client JWT e supporto WebAuthn per Delphi e C++ Builder. Autonomo, con il runtime sgcWebSockets Core incluso.

sgcMQ

Componenti client MQTT, AMQP 0.9.1 e 1.0, Apache Kafka e STOMP per Delphi e C++ Builder. Autonomo, con il runtime sgcWebSockets Core incluso.

sgcSocial

Componenti client Telegram e WhatsApp Business per Delphi e C++ Builder. Autonomo, con il runtime sgcWebSockets Core incluso.

sgcAI

Componenti AI, LLM e MCP per Delphi e C++ Builder. Sette provider LLM dietro un solo componente, più MCP, embeddings e voce.

sgcHTML

Componenti HTML e UI lato server su Bootstrap 5 e htmx per Delphi, C++ Builder e .NET.

sgcQUIC

Trasporto QUIC puro e un client e server HTTP/3, con WebTransport. Un componente aggiuntivo per sgcWebSockets Enterprise.

sgcOpenAPI

Parser OpenAPI 3.x, generatore di SDK Pascal nativi, componente server OpenAPI e oltre 1.195 SDK cloud già pronti.

sgcSign

XAdES, PAdES, CAdES e ASiC per i documenti, Authenticode, ClickOnce, NuGet e VSIX per il codice.

sgcPDF

Crea, modifica, visualizza, firma, oscura e convalida file PDF in puro Object Pascal, senza alcuna DLL da distribuire. Con licenza a parte.

sgcBiometrics

Windows Hello, sensori di impronte digitali e il Windows Biometric Framework per Delphi e C++ Builder.

sgcIndy

Componenti TCP/IP Indy aggiornati con TLS moderno, IPv6 e HTTP/2 per Delphi da 7 a 13.

Le ultime dal blog

Vedi tutti gli articoli →

Stai vedendo eSeGeCe dal punto di vista di server HTTP, HTTP/2 e gRPC.

Mostrami un altro punto di vista →
Garanzia soddisfatti o rimborsati di 30 giorniNon sei soddisfatto? Richiedi un rimborso completo entro 30 giorni dall'acquisto. Vedi la politica di rimborso