Produto autônomoServidor HTTP, HTTP/2, gRPC & Google Cloud
sgcHTTP: componentes de servidor HTTP, HTTP/2, gRPC e Google Cloud para Delphi e C++ Builder
Um servidor HTTP, um gateway FastCGI / SCGI e cinco componentes cliente. O TsgcHTTPServer publica endpoints HTTP e arquivos estáticos a partir da sua própria aplicação: defina Port, trate OnCommandGet, defina Active. O TsgcHTTPGateway encaminha as requisições dele para o PHP-FPM e para servidores FastCGI ou SCGI de Python, de modo que aplicações PHP e Python rodam atrás do seu servidor, sem Apache nem nginx na frente. O TsgcHTTP2Client fala HTTP/2 com streams multiplexados sobre uma única conexão TLS e compressão de cabeçalhos HPACK. O TsgcGRPCClient é um cliente gRPC construído sobre ele, para chamadas unárias e em streaming de Protocol Buffers. Mais três classes alcançam o Google Cloud sobre HTTPS puro: Pub/Sub, Calendar e Firebase Cloud Messaging. O sgcHTTP é autônomo, ele já traz embutido o runtime sgcWebSockets Core sobre o qual o servidor, o gateway e os cinco clientes são construídos.
Runtime embutidosgcWebSockets CoreO servidor HTTP, mais o runtime de HTTP, TLS e JSON por baixo de todos os clientes
HTTP/2TsgcHTTP2Client
gRPCTsgcGRPCClient
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.
4Componentes de paletaServidor HTTP, gateway FastCGI / SCGI, cliente HTTP/2 & cliente gRPC, uma página na paleta
5Classes cliente no totalHTTP/2, gRPC e três clientes Google Cloud
3Serviços Google CloudPub/Sub, Calendar e Firebase Cloud Messaging
100%Código-fonte incluídoO servidor HTTP, o gateway, os cinco clientes e o runtime Core embutido
12Meses de atualizaçõesToda versão lançada enquanto a sua licença estiver ativa
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, o gateway, 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 gateway FastCGI / SCGI também não, pois funciona com o Indy padrão que acompanha o RAD Studio.
O QUE VEM NA CAIXA
Quatro componentes de paleta, três clientes Google Cloud
O servidor HTTP, o gateway FastCGI / SCGI, 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, o gateway na unit sgcHTTP_Gateway, 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.
O TsgcHTTPGateway encaminha as requisições recebidas pelo TsgcHTTPServer ou pelo TsgcWebSocketHTTPServer para servidores de aplicação FastCGI e SCGI via TCP: PHP por meio do PHP-FPM ou do php-cgi -b, e aplicações Python servidas por um servidor SCGI ou FastCGI como o flup. Ele faz o trabalho do mod_proxy_fcgi e do mod_proxy_scgi do Apache ou do fastcgi_pass e do scgi_pass do nginx, então não há Apache nem nginx na frente do seu servidor Delphi. Registre handlers com Handlers.Add('*.php', 'fcgi://127.0.0.1:9000') ou Handlers.Add('/app/', 'scgi://127.0.0.1:4000'), correspondidos por extensão, prefixo ou caminho exato, e depois chame Process a partir de OnCommandGet e OnCommandOther. Ele retorna true quando um handler correspondeu e a resposta está preenchida, e false quando o seu próprio código responde à requisição. O gateway monta o ambiente CGI da RFC 3875, interpreta a resposta CGI com o status, os redirecionamentos e todos os cabeçalhos Set-Cookie, e responde 502, 503 ou 504 quando um backend falha, informado por meio de OnError. Funciona com o Indy padrão que acompanha o RAD Studio, no Windows e no Linux.
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.
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.
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.
As seis 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. O gateway FastCGI / SCGI precisa apenas do servidor atrás do qual ele fica e da biblioteca Indy padrão.
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 gateway roda no Indy padrão
O TsgcHTTPGateway precisa apenas do runtime Core embutido e da biblioteca Indy padrão que acompanha o RAD Studio, sem sgcCustomIndy. Ele fala FastCGI e SCGI sobre TCP puro com um backend que já está em execução, e armazena em buffer cada resposta antes de o servidor enviá-la.
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 o servidor na unit sgcHTTP_Server e o gateway na unit sgcHTTP_Gateway, 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, sgcHTTP_Gateway;
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;
// FastCGI / SCGI gateway: PHP and Python behind the same server
FGateway := TsgcHTTPGateway.Create(nil);
FGateway.Handlers.Add('*.php', 'fcgi://127.0.0.1:9000');
FGateway.Handlers.Add('/app/', 'scgi://127.0.0.1:4000');
// 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// *.php and /app/ go to the backends, the rest is answered hereif FGateway.Process(AContext, ARequestInfo, AResponseInfo) then
Exit;
if ARequestInfo.Document = '/api/status'thenbegin
AResponseInfo.ContentType := 'application/json';
AResponseInfo.ContentText := '{"status":"ok"}';
end;
end;
// include: sgcHTTP.hpp, sgcHTTP_Server.hpp, sgcHTTP_Gateway.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;
// FastCGI / SCGI gateway: PHP and Python behind the same server
FGateway = new TsgcHTTPGateway(this);
FGateway->Handlers->Add("*.php", "fcgi://127.0.0.1:9000");
FGateway->Handlers->Add("/app/", "scgi://127.0.0.1:4000");
// 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)
{
// *.php and /app/ go to the backends, the rest is answered hereif (FGateway->Process(AContext, ARequestInfo, AResponseInfo))
return;
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. O gateway FastCGI / SCGI usa o Indy padrão que acompanha o RAD Studio, no Windows e no Linux.
TsgcHTTP2Client & TsgcGRPCClientConstruídos sobre o sgcCustomIndy para o ALPN
Windows Win32Windows Win64Linux64macOSiOSAndroid
Clientes Google CloudHTTPS puro, sem necessidade de sgcCustomIndy
Windows Win32Windows Win64Linux64macOSiOSAndroid
TsgcHTTPGatewayIndy padrão, sem necessidade de sgcCustomIndy
Windows Win32Windows Win64Linux64
Suporte de IDEUma única árvore de código-fonte, pacotes de design-time por versão
Delphi 7 a 13C++ Builder
Instalador de avaliaçãoA avaliação All-Access do sgcWebSockets inclui os componentes sgcHTTP
Um único download, o servidor, o gateway e os cinco clientes
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
Gateway FastCGI / SCGI para PHP & Python
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.
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.
3,000+Desenvolvedores
20+Anos
761+Componentes
30+Integrações de API
5Plataformas
Garantia de reembolso de 30 diasNão ficou satisfeito? Solicite o reembolso total em até 30 dias após a compra. Ver política de reembolso
HTTP moderno, gRPC e Google Cloud a partir de código nativo
Um servidor HTTP com gateway FastCGI / SCGI, HTTP/2 multiplexado, gRPC em streaming e três clientes Google Cloud, com o runtime embutido e o código-fonte completo na caixa. Baixe o instalador de avaliação All-Access e experimente todos os componentes hoje mesmo.