VEJA FUNCIONANDO

Veja o sgcHTTP em dois minutos

Um servidor HTTP, clientes HTTP/2 e gRPC para Delphi e C++Builder, além de integrações prontas com Google Cloud, Amazon e Apple Push.

ANTES DE COMPRAR

Duas coisas que vale saber antes

O que o sgcHTTP precisa de você, e o que não precisa. As duas respostas são curtas.

O sgcHTTP é autossuficiente

Autônomo, o runtime sgcWebSockets Core está incluído: o servidor HTTP, a pilha de cliente HTTP/TLS pela qual todo cliente envia as suas requisições, e a camada JSON que decodifica as respostas do Google Cloud. Um único SKU, um único instalador.

Toda licença inclui o código-fonte completo, então o servidor HTTP, os cinco clientes e o runtime por baixo deles são depurados passo a passo no seu próprio debugger, em vez de desaparecer dentro de um binário.

Complemento necessário para dois dos cinco

HTTP/2 & gRPC precisam do sgcCustomIndy

O HTTP/2 negocia o protocolo h2 com ALPN durante o handshake TLS, e a biblioteca Indy padrão que acompanha o RAD Studio não suporta ALPN. O cliente HTTP/2 e o cliente gRPC do sgcHTTP são construídos sobre o sgcCustomIndy em vez disso, que está sempre incluído quando você pede o sgcHTTP, e o preço exibido já o cobre.

Os três clientes Google Cloud, Pub/Sub, Calendar e Firebase Cloud Messaging, são HTTPS puro. Eles rodam sobre o runtime Core puro e não precisam do sgcCustomIndy de forma alguma.

O QUE VEM NA CAIXA

Três componentes de paleta, três clientes Google Cloud

O servidor HTTP, o cliente HTTP/2 e o cliente gRPC são componentes não visuais na página de paleta SGC HTTP. O servidor é declarado na unit sgcHTTP_Server do runtime Core embutido, os dois clientes na unit sgcHTTP. Solte um em um formulário ou crie-o em código, defina as opções de conexão, conecte os eventos e chame os métodos de requisição tipados. Os três clientes Google Cloud vivem na mesma unit como classes apenas de código, não há nada para soltar em um formulário: crie um, defina GoogleCloudOptions, e chame os métodos diretamente.

Servidor HTTP1 componente

Publique endpoints HTTP e arquivos estáticos

O TsgcHTTPServer transforma a sua aplicação Delphi ou C++ Builder em um servidor HTTP. Defina Port, trate OnCommandGet, defina Active como true, e cada requisição chega ao seu código com os seus objetos de requisição e resposta, enquanto o OnCommandOther cobre verbos como PUT e DELETE. Aponte DocumentRoot para uma pasta e o servidor devolve arquivos estáticos a partir dela. O HTTPCompression comprime as respostas, o KeepAlive reaproveita conexões, o SessionState com OnSessionStart e OnSessionEnd acompanha as sessões, o MaxRequestBodySize limita o tamanho dos corpos das requisições e o HTTPUploadFiles grava em disco os arquivos enviados. Para produção, SSL e SSLOptions ativam o TLS, Authentication e OnAuthentication protegem os seus endpoints, e ThreadPool e MaxConnections controlam como ele escala. É o mesmo motor do servidor WebSocket do sgcWebSockets, sem a parte WebSocket, e vem com o runtime Core embutido.

TsgcHTTPServer Vem com o runtime Core

HTTP/21 componente

Streams multiplexados sobre uma única conexão TLS

O TsgcHTTP2Client fala HTTP/2 (RFC 9113): múltiplas requisições compartilham uma única conexão TCP como streams independentes, então uma resposta lenta não bloqueia as outras atrás dela. Os cabeçalhos são comprimidos com HPACK, e o protocolo h2 é negociado durante o handshake TLS via ALPN, a razão pela qual o componente é construído sobre o sgcCustomIndy em vez da biblioteca Indy padrão. Todo verbo é coberto, Connect, Get, Post, Put, Patch, Delete e Options, cada um com uma chamada síncrona e uma gêmea Async. Eventos expõem o ciclo de vida da conexão: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment para corpos em chunks, OnHTTP2PushPromise para server push, OnHTTP2GoAway e OnHTTP2Disconnect. HTTP2Options configura o frame de settings local, e TLSOptions e Authentication vêm do restante da pilha HTTP do sgc.

TsgcHTTP2Client Requer sgcCustomIndy

gRPC1 componente

RPC unário e em streaming sobre o cliente HTTP/2

O TsgcGRPCClient é construído sobre o cliente HTTP/2, então herda a conexão multiplexada e adiciona o formato de wire do gRPC por cima: mensagens Protocol Buffers com prefixo de tamanho sobre streams HTTP/2. Call e CallAsync cobrem RPCs unários, ServerStreamingCall lida com um stream de respostas para uma requisição, e OpenClientStream/SendStreamMessage/CloseClientStream mais OpenBidiStream/SendBidiMessage/CloseBidiStream cobrem RPCs de client-streaming e bidirectional-streaming. OnGRPCResponse, OnGRPCStreamMessage e OnGRPCStreamEnd entregam o tráfego, e RetryPolicy, Interceptors e ServiceConfig adicionam comportamento de retry, lógica transversal e configuração de serviço sem tocar nos pontos de chamada. Assim como o cliente HTTP/2 sobre o qual é construído, ele precisa do sgcCustomIndy para o ALPN.

TsgcGRPCClient Requer sgcCustomIndy

Google Cloud3 classes

Pub/Sub, Calendar e notificações push, HTTPS puro

Mais três classes alcançam serviços Google Cloud sobre HTTPS puro, autenticadas com uma conta de serviço Google, e nenhuma delas precisa do sgcCustomIndy. O TsgcHTTPGoogleCloud_PubSub_Client publica e lê mensagens e gerencia tópicos, assinaturas e snapshots: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription e o resto da superfície REST do Pub/Sub. O TsgcHTTPGoogleCloud_Calendar_Client encapsula a Google Calendar API v3: NewCalendar, NewEvent, LoadEvents e LoadCalendars, com os eventos OnGetCalendar e OnGetCalendarEvent para sincronização. O TsgcHTTPGoogleCloud_FCM_Client envia um payload de notificação push para um projeto Firebase com uma única chamada, SendMessage. As três são classes apenas de código: crie uma, defina GoogleCloudOptions, chame os métodos.

TsgcHTTPGoogleCloud_PubSub_Client TsgcHTTPGoogleCloud_Calendar_Client TsgcHTTPGoogleCloud_FCM_Client

COMO FUNCIONA

Duas dependências, não cinco

As cinco classes se dividem de forma clara pelo que precisam por baixo. HTTP/2 e gRPC precisam de ALPN, o que significa sgcCustomIndy. O Google Cloud não precisa de nada além de HTTPS e uma conta de serviço, o que o runtime Core embutido já fornece.

HTTP/2 precisa de ALPN, então precisa do sgcCustomIndy

O Application-Layer Protocol Negotiation escolhe h2 durante o handshake TLS, e a biblioteca Indy padrão que acompanha o RAD Studio não tem suporte a ALPN. O TsgcHTTP2Client é construído sobre o sgcCustomIndy, o build Indy personalizado da eSeGeCe, em vez disso.

gRPC é Protocol Buffers em cima do cliente HTTP/2

O TsgcGRPCClient não abre a sua própria conexão, a sua propriedade Client é um TsgcHTTP2Client. As chamadas unárias, server-streaming, client-streaming e bidirecionais viajam como streams HTTP/2 por baixo.

Google Cloud é HTTPS mais uma conta de serviço

Os três clientes Google Cloud se autenticam com GoogleCloudOptions.JWT, o id de projeto, o e-mail de cliente e a chave privada de uma conta de serviço Google, e chamam as APIs REST sobre a pilha HTTPS pura do runtime Core. OnAuthToken e OnAuthTokenError expõem a troca de token.

O runtime Core está na caixa

Autônomo, o runtime sgcWebSockets Core está incluído. Ele contribui com o TsgcHTTPServer e a pilha de cliente HTTP/TLS que cada um dos cinco clientes chama, e o seu código-fonte completo faz parte do pacote como tudo o mais.

INÍCIO RÁPIDO

Servidor HTTP, HTTP/2 e gRPC, lado a lado

Os dois clientes são declarados na unit sgcHTTP e o servidor na unit sgcHTTP_Server, e o TsgcGRPCClient carrega a sua própria conexão HTTP/2 através da propriedade Client. O mesmo código compila do Delphi 7 ao 13 e no C++ Builder.

uses
  sgcHTTP, sgcHTTP_Server;

var
  Server: TsgcHTTPServer;
  HTTP2: TsgcHTTP2Client;
  GRPC: TsgcGRPCClient;
begin
  // Servidor HTTP: endpoints e arquivos estáticos
  Server := TsgcHTTPServer.Create(nil);
  Server.Port := 8080;
  Server.DocumentRoot := 'C:\www';
  Server.OnCommandGet := ServerCommandGet;
  Server.Active := True;

  // HTTP/2: requisições multiplexadas sobre uma única conexão TLS
  HTTP2 := TsgcHTTP2Client.Create(nil);
  HTTP2.Host := 'https://api.example.com';
  HTTP2.OnHTTP2Response := HTTP2Response;
  HTTP2.Active := True;

  HTTP2.GetAsync('/v1/status');

  // gRPC: construído sobre o cliente HTTP/2, RPC unário e em streaming
  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

// Servidor HTTP: endpoints e arquivos estáticos
TsgcHTTPServer *Server = new TsgcHTTPServer(this);
Server->Port = 8080;
Server->DocumentRoot = "C:\\www";
Server->OnCommandGet = ServerCommandGet;
Server->Active = true;

// HTTP/2: requisições multiplexadas sobre uma única conexão TLS
TsgcHTTP2Client *HTTP2 = new TsgcHTTP2Client(this);
HTTP2->Host = "https://api.example.com";
HTTP2->OnHTTP2Response = HTTP2Response;
HTTP2->Active = true;

HTTP2->GetAsync("/v1/status");

// gRPC: construído sobre o cliente HTTP/2, RPC unário e em streaming
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\"}";
  }
}

PLATAFORMAS

Uma dependência para dois clientes, nenhuma para três

O cliente HTTP/2 e o cliente gRPC são construídos sobre o sgcCustomIndy, que cobre a mesma faixa de plataformas do próprio sgcWebSockets. Os clientes Google Cloud são HTTPS puro, então rodam onde quer que o runtime Core rode.

TsgcHTTP2Client & TsgcGRPCClient Construídos sobre o sgcCustomIndy para o ALPN

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Clientes Google Cloud HTTPS puro, sem necessidade de sgcCustomIndy

Windows Win32 Windows Win64 Linux64 macOS iOS Android

Suporte de IDE Uma única árvore de código-fonte, pacotes de design-time por versão

Delphi 7 a 13 C++ Builder

Instalador de avaliação A avaliação All-Access do sgcWebSockets inclui os componentes sgcHTTP

Um único download, o servidor e os cinco clientes

Baixar o instalador de avaliação →

PREÇOS

Um pacote autônomo

O sgcHTTP é licenciado por conta própria, a partir de €398 para um único desenvolvedor. Todas as licenças incluem código-fonte completo, 1 ano de atualizações e de 50% a 70% de desconto na renovação: 50% ao renovar um pacote, 60% para dois, 70% para três ou mais. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP e sgcREST contam cada um como um pacote. O sgcHTTP também está incluído no pacote All-Access.

sgcHTTP

€398

Licenças Single, Team e Site disponíveis.

Servidor HTTP com arquivos estáticos, sessões & TLS
Cliente HTTP/2 com multiplexação & HPACK
Cliente gRPC, RPC unário & em streaming
Clientes Google Cloud Pub/Sub, Calendar & FCM
Runtime sgcWebSockets Core incluído
Delphi 7 a 13 & C++ Builder
Código-fonte completo
1 ano de atualizações

HTTP/2 e gRPC precisam do complemento sgcCustomIndy. Ele está sempre incluído no seu pedido, e o preço exibido já o cobre.

Comprar licença Single €398

Team €648 Site €1,048

O checkout lista três itens: o direito de uso do runtime sgcWebSockets Core, cobrado a zero, o próprio pacote sgcHTTP, e o complemento sgcCustomIndy, sempre incluído. Detalhes completos de preços.

MAIS DA ESEGECE

Outros produtos da eSeGeCe

Combine o sgcHTTP com as nossas outras bibliotecas de componentes para Delphi, C++ Builder e .NET.

sgcCustomIndy

A biblioteca Indy personalizada sobre a qual os clientes HTTP/2 e gRPC do sgcHTTP são construídos: ALPN, TLS 1.3 e linkagem estática do OpenSSL.

Saiba mais →

sgcWebSockets

A biblioteca completa: clientes e servidores WebSocket, HTTP/2, gRPC, IoT, P2P e componentes de IA. A sua edição Enterprise também inclui o gRPC.

Saiba mais →

sgcAI

Componentes de IA, LLM e MCP. Um único componente de chat alcança OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok e Mistral.

Saiba mais →

sgcMQ

Componentes cliente nativos de MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka e STOMP, com o runtime Core embutido.

Saiba mais →

sgcSocial

Componentes cliente de WhatsApp Business Cloud API e Telegram TDLib, com o runtime Core embutido.

Saiba mais →

sgcQUIC

Componentes cliente e servidor QUIC (RFC 9000) e HTTP/3 (RFC 9114) construídos sobre o mecanismo QUIC nativo do OpenSSL 3.5.

Saiba mais →

sgcWebRTC

Motor completo de mídia WebRTC: chamadas de áudio/vídeo, canais de dados e compartilhamento de tela. Um complemento do sgcWebSockets Enterprise.

Saiba mais →

sgcCrypto

Cifras simétricas e assimétricas, hashing e algoritmos pós-quânticos. Disponível gratuitamente a partir do sgcWebSockets Standard.

Saiba mais →

sgcHTTP: componentes de servidor HTTP, HTTP/2, gRPC e Google Cloud para Delphi e C++ Builder

Veja o sgcHTTP em dois minutos

Duas coisas que vale saber antes

O sgcHTTP é autossuficiente

HTTP/2 & gRPC precisam do sgcCustomIndy

Três componentes de paleta, três clientes Google Cloud

Publique endpoints HTTP e arquivos estáticos

Streams multiplexados sobre uma única conexão TLS

RPC unário e em streaming sobre o cliente HTTP/2

Pub/Sub, Calendar e notificações push, HTTPS puro

Duas dependências, não cinco

Servidor HTTP, HTTP/2 e gRPC, lado a lado

Uma dependência para dois clientes, nenhuma para três

Um pacote autônomo

sgcHTTP

HTTP moderno, gRPC e Google Cloud a partir de código nativo

Outros produtos da eSeGeCe

sgcCustomIndy

sgcWebSockets

sgcAI

sgcMQ

sgcSocial

sgcQUIC

sgcWebRTC

sgcCrypto