Produkt samodzielnySerwer HTTP, HTTP/2, gRPC i Google Cloud
sgcHTTP: serwer HTTP, komponenty HTTP/2, gRPC i Google Cloud dla Delphi i C++ Builder
Serwer HTTP, brama FastCGI / SCGI i pięć komponentów klienckich. TsgcHTTPServer publikuje punkty końcowe HTTP i pliki statyczne z twojej własnej aplikacji: ustaw Port, obsłuż OnCommandGet, ustaw Active. TsgcHTTPGateway przekazuje jego żądania do PHP-FPM oraz do serwerów Python FastCGI lub SCGI, więc aplikacje PHP i Python działają za Twoim serwerem, bez Apache ani nginx z przodu. TsgcHTTP2Client mówi w HTTP/2, z multipleksowanymi strumieniami przez jedno połączenie TLS i kompresją nagłówków HPACK. TsgcGRPCClient to zbudowany na nim klient gRPC, do wywołań unarnych i strumieniowych Protocol Buffers. Trzy kolejne klasy sięgają do Google Cloud przez zwykłe HTTPS: Pub/Sub, Calendar i Firebase Cloud Messaging. sgcHTTP jest samodzielny, zawiera środowisko uruchomieniowe sgcWebSockets Core, na którym zbudowane są serwer, brama i wszystkie pięć klientów.
Środowisko w zestawiesgcWebSockets CoreSerwer HTTP oraz środowisko HTTP, TLS i JSON pod każdym klientem
HTTP/2TsgcHTTP2Client
gRPCTsgcGRPCClient
ZOBACZ, JAK TO DZIAŁA
Zobacz sgcHTTP w dwie minuty
Serwer HTTP, klienci HTTP/2 i gRPC dla Delphi i C++Builder, a do tego gotowe integracje z Google Cloud, Amazon i Apple Push.
4Komponenty na palecieSerwer HTTP, brama FastCGI / SCGI, klient HTTP/2 i klient gRPC, jedna strona na palecie
5Klas klienckich łącznieHTTP/2, gRPC oraz trzy klienty Google Cloud
3Usług Google CloudPub/Sub, Calendar i Firebase Cloud Messaging
100%Kod źródłowy w zestawieSerwer HTTP, brama, wszystkich pięciu klientów oraz dołączone środowisko uruchomieniowe Core
12Miesięcy aktualizacjiKażde wydanie opublikowane w czasie aktywności twojej licencji
ZANIM KUPISZ
Dwie rzeczy, które warto wiedzieć najpierw
Czego sgcHTTP od ciebie wymaga i czego nie. Obie odpowiedzi są krótkie.
sgcHTTP jest samowystarczalny
Samodzielnie, środowisko uruchomieniowe sgcWebSockets Core jest w zestawie: serwer HTTP, stos klienta HTTP/TLS, przez który każdy klient wysyła swoje żądania, oraz warstwa JSON, która dekoduje odpowiedzi Google Cloud. Jedno SKU, jeden instalator.
Pełny kod źródłowy jest dostarczany z każdą licencją, więc serwer HTTP, brama, wszystkich pięciu klientów oraz środowisko uruchomieniowe pod nimi prześledzisz krok po kroku we własnym debugerze, zamiast oglądać je znikające w pliku binarnym.
Dodatek wymagany dla dwóch z pięciu
HTTP/2 i gRPC wymagają sgcCustomIndy
HTTP/2 negocjuje protokół h2 przez ALPN podczas uzgadniania TLS, a standardowa biblioteka Indy dostarczana z RAD Studio nie obsługuje ALPN. Klient HTTP/2 i klient gRPC w sgcHTTP są zamiast tego zbudowane na sgcCustomIndy, który jest zawsze wliczony w zamówienie sgcHTTP, a pokazana cena już go obejmuje.
Trzy klienty Google Cloud, Pub/Sub, Calendar i Firebase Cloud Messaging, to zwykłe HTTPS. Działają na samym środowisku uruchomieniowym Core i w ogóle nie potrzebują sgcCustomIndy. Nie potrzebuje go także brama FastCGI / SCGI, która działa ze standardowym Indy dostarczanym z RAD Studio.
CO JEST W ZESTAWIE
Cztery komponenty palety, trzy klienty Google Cloud
Serwer HTTP, brama FastCGI / SCGI, klient HTTP/2 i klient gRPC to komponenty niewizualne na stronie palety SGC HTTP. Serwer jest zadeklarowany w module sgcHTTP_Server dołączonego środowiska Core, brama w module sgcHTTP_Gateway, a oba klienty w module sgcHTTP. Umieść jeden na formularzu albo utwórz go w kodzie, ustaw opcje połączenia, podłącz zdarzenia, a następnie wywołuj typowane metody żądań. Trzy klienty Google Cloud znajdują się w tym samym module jako klasy dostępne wyłącznie z kodu, nie ma nic do umieszczenia na formularzu: utwórz jeden, ustaw GoogleCloudOptions i wywołuj jego metody bezpośrednio.
Serwer HTTP1 komponent
Publikuj punkty końcowe HTTP i pliki statyczne
TsgcHTTPServer zamienia twoją aplikację Delphi lub C++ Builder w serwer HTTP. Ustaw Port, obsłuż OnCommandGet, ustaw Active na true, a każde żądanie trafia do twojego kodu wraz z obiektami żądania i odpowiedzi, natomiast OnCommandOther obsługuje metody takie jak PUT i DELETE. Wskaż DocumentRoot na folder, a serwer będzie zwracał z niego pliki statyczne. HTTPCompression kompresuje odpowiedzi, KeepAlive ponownie wykorzystuje połączenia, SessionState wraz z OnSessionStart i OnSessionEnd śledzi sesje, MaxRequestBodySize ogranicza rozmiar treści żądań, a HTTPUploadFiles zapisuje przesłane pliki na dysku. W produkcji SSL i SSLOptions włączają TLS, Authentication i OnAuthentication chronią twoje punkty końcowe, a ThreadPool i MaxConnections kontrolują skalowanie. To ten sam silnik co serwer WebSocket sgcWebSockets, bez części WebSocket, i jest dostarczany z dołączonym środowiskiem uruchomieniowym Core.
TsgcHTTPGateway przekazuje żądania odebrane przez TsgcHTTPServer lub TsgcWebSocketHTTPServer do serwerów aplikacji FastCGI i SCGI przez TCP: PHP przez PHP-FPM lub php-cgi -b oraz aplikacje Python obsługiwane przez serwer SCGI lub FastCGI, taki jak flup. Pełni zadanie Apache mod_proxy_fcgi i mod_proxy_scgi albo nginx fastcgi_pass i scgi_pass, więc przed Twoim serwerem Delphi nie ma Apache ani nginx. Zarejestruj handlery przez Handlers.Add('*.php', 'fcgi://127.0.0.1:9000') lub Handlers.Add('/app/', 'scgi://127.0.0.1:4000'), dopasowywane po rozszerzeniu, prefiksie lub dokładnej ścieżce, a następnie wywołaj Process z OnCommandGet i OnCommandOther. Zwraca true, gdy pasował handler i odpowiedź jest wypełniona, oraz false, gdy na żądanie odpowiada Twój własny kod. Brama buduje środowisko CGI zgodne z RFC 3875, parsuje odpowiedź CGI wraz ze statusem, przekierowaniami i każdym nagłówkiem Set-Cookie, a gdy backend zawodzi, odpowiada kodem 502, 503 lub 504, zgłaszanym przez OnError. Działa ze standardowym Indy dostarczanym z RAD Studio, w systemach Windows i Linux.
Multipleksowane strumienie przez jedno połączenie TLS
TsgcHTTP2Client mówi w HTTP/2 (RFC 9113): wiele żądań dzieli jedno połączenie TCP jako niezależne strumienie, więc jedna wolna odpowiedź nie blokuje pozostałych czekających za nią. Nagłówki są kompresowane HPACK, a protokół h2 jest negocjowany podczas uzgadniania TLS przez ALPN, co jest powodem, dla którego komponent jest zbudowany na sgcCustomIndy zamiast na standardowej bibliotece Indy. Pokryty jest każdy czasownik: Connect, Get, Post, Put, Patch, Delete i Options, każdy z wywołaniem synchronicznym i bliźniaczym Async. Zdarzenia ujawniają cykl życia połączenia: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment dla treści podzielonych na fragmenty (chunked), OnHTTP2PushPromise dla server push, OnHTTP2GoAway i OnHTTP2Disconnect. HTTP2Options konfiguruje lokalną ramkę ustawień, a TLSOptions i Authentication przenoszą się z reszty stosu sgc HTTP.
TsgcGRPCClient jest zbudowany na kliencie HTTP/2, więc dziedziczy połączenie multipleksowane i dokłada na nim format transmisji gRPC: wiadomości Protocol Buffers poprzedzone długością, przesyłane strumieniami HTTP/2. Call i CallAsync obsługują RPC unarne, ServerStreamingCall obsługuje strumień odpowiedzi na jedno żądanie, a OpenClientStream/SendStreamMessage/CloseClientStream wraz z OpenBidiStream/SendBidiMessage/CloseBidiStream obsługują RPC strumieniowane po stronie klienta oraz dwukierunkowe. OnGRPCResponse, OnGRPCStreamMessage i OnGRPCStreamEnd dostarczają ruch, a RetryPolicy, Interceptors i ServiceConfig dodają zachowanie ponawiania, logikę przekrojową i konfigurację usługi bez dotykania miejsc wywołań. Podobnie jak klient HTTP/2, na którym jest zbudowany, potrzebuje sgcCustomIndy dla ALPN.
Pub/Sub, Calendar i powiadomienia push, zwykłe HTTPS
Trzy kolejne klasy sięgają do usług Google Cloud przez zwykłe HTTPS, uwierzytelniane kontem usługi Google, i żadna z nich nie potrzebuje sgcCustomIndy. TsgcHTTPGoogleCloud_PubSub_Client publikuje i pobiera wiadomości oraz zarządza tematami, subskrypcjami i migawkami: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription i reszta powierzchni REST Pub/Sub. TsgcHTTPGoogleCloud_Calendar_Client opakowuje Google Calendar API v3: NewCalendar, NewEvent, LoadEvents i LoadCalendars, ze zdarzeniami OnGetCalendar i OnGetCalendarEvent do synchronizacji. TsgcHTTPGoogleCloud_FCM_Client wysyła ładunek powiadomienia push do projektu Firebase jednym wywołaniem, SendMessage. Wszystkie trzy to klasy dostępne wyłącznie z kodu: utwórz jedną, ustaw GoogleCloudOptions, wywołuj metody.
Sześć klas dzieli się wyraźnie według tego, czego potrzebują pod spodem. HTTP/2 i gRPC potrzebują ALPN, co oznacza sgcCustomIndy. Google Cloud nie potrzebuje niczego poza HTTPS i kontem usługi, co dołączone środowisko uruchomieniowe Core już zapewnia. Brama FastCGI / SCGI potrzebuje tylko serwera, za którym stoi, oraz standardowej biblioteki Indy.
HTTP/2 potrzebuje ALPN, więc potrzebuje sgcCustomIndy
Application-Layer Protocol Negotiation wybiera h2 podczas uzgadniania TLS, a standardowa biblioteka Indy dostarczana z RAD Studio nie ma obsługi ALPN. TsgcHTTP2Client jest zamiast tego zbudowany na sgcCustomIndy, niestandardowej kompilacji Indy firmy eSeGeCe.
gRPC to Protocol Buffers na kliencie HTTP/2
TsgcGRPCClient nie otwiera własnego połączenia, jego właściwość Client to TsgcHTTP2Client. Wywołania unarne, strumieniowane po stronie serwera, po stronie klienta i dwukierunkowe wszystkie podróżują pod spodem jako strumienie HTTP/2.
Google Cloud to HTTPS plus konto usługi
Trzy klienty Google Cloud uwierzytelniają się przez GoogleCloudOptions.JWT: identyfikator projektu, adres e-mail klienta i klucz prywatny konta usługi Google, a następnie wywołują API REST przez zwykły stos HTTPS środowiska uruchomieniowego Core. OnAuthToken i OnAuthTokenError ujawniają wymianę tokenów.
Brama działa na standardowym Indy
TsgcHTTPGateway potrzebuje tylko dołączonego środowiska uruchomieniowego Core i standardowej biblioteki Indy dostarczanej z RAD Studio, bez sgcCustomIndy. Mówi w FastCGI i SCGI przez zwykłe TCP z backendem, który już działa, i buforuje każdą odpowiedź, zanim serwer ją wyśle.
Środowisko uruchomieniowe Core jest w zestawie
Samodzielnie, środowisko uruchomieniowe sgcWebSockets Core jest w zestawie. Dostarcza TsgcHTTPServer oraz stos klienta HTTP/TLS, przez który wywołuje każdy z pięciu klientów, a jego pełne źródło jest częścią pakietu, tak jak wszystko inne.
SZYBKI START
Serwer HTTP, HTTP/2 i gRPC, obok siebie
Dwa klienty są zadeklarowane w module sgcHTTP, serwer w sgcHTTP_Server, a brama w sgcHTTP_Gateway, natomiast TsgcGRPCClient niesie własne połączenie HTTP/2 przez swoją właściwość Client. Ten sam kod kompiluje się w Delphi od 7 do 13 oraz w C++ Builder.
uses
sgcHTTP, sgcHTTP_Server, sgcHTTP_Gateway;
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;
// 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: 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// *.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// HTTP server: endpoints and static files
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: 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)
{
// *.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\"}";
}
}
PLATFORMY
Jedna zależność dla dwóch klientów, żadna dla trzech
Klient HTTP/2 i klient gRPC są zbudowane na sgcCustomIndy, który obejmuje ten sam zakres platform co samo sgcWebSockets. Klienty Google Cloud to zwykłe HTTPS, więc działają wszędzie tam, gdzie działa środowisko uruchomieniowe Core. Brama FastCGI / SCGI używa standardowego Indy dostarczanego z RAD Studio, w systemach Windows i Linux.
TsgcHTTP2Client & TsgcGRPCClientZbudowane na sgcCustomIndy dla ALPN
Windows Win32Windows Win64Linux64macOSiOSAndroid
Klienty Google CloudZwykłe HTTPS, sgcCustomIndy niepotrzebne
sgcHTTP jest licencjonowany samodzielnie, już od €398 dla jednego programisty. Wszystkie licencje obejmują pełny kod źródłowy, 1 rok aktualizacji oraz od 50% do 70% rabatu na odnowienie: 50% przy odnowieniu jednego pakietu, 60% przy dwóch, 70% przy trzech lub więcej. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP i sgcREST liczą się każdy jako jeden pakiet. sgcHTTP jest również objęty pakietem All-Access.
sgcHTTP
€398
Dostępne licencje Single, Team i Site.
Serwer HTTP z plikami statycznymi, sesjami i TLS
Brama FastCGI / SCGI dla PHP i Python
Klient HTTP/2 z multipleksowaniem i HPACK
Klient gRPC, RPC unarne i strumieniowe
Klienty Google Cloud Pub/Sub, Calendar i FCM
Środowisko uruchomieniowe sgcWebSockets Core w zestawie
Delphi od 7 do 13 i C++ Builder
Pełny kod źródłowy
1 rok aktualizacji
HTTP/2 i gRPC potrzebują dodatku sgcCustomIndy. Jest zawsze wliczony w zamówienie, a pokazana cena już go obejmuje.
Zamówienie zawiera trzy pozycje: uprawnienie do środowiska uruchomieniowego sgcWebSockets Core, naliczane jako zero, sam pakiet sgcHTTP oraz dodatek sgcCustomIndy, zawsze wliczony. Pełne szczegóły cennika.
3,000+Programistów
20+Lat
761+Komponentów
30+Integracji API
5Platform
30-dniowa gwarancja zwrotu pieniędzyNie jesteś zadowolony? Poproś o pełny zwrot pieniędzy w ciągu 30 dni od zakupu. Zobacz politykę zwrotów
Nowoczesne HTTP, gRPC i Google Cloud z natywnego kodu
Serwer HTTP z bramą FastCGI / SCGI, multipleksowane HTTP/2, strumieniowany gRPC oraz trzy klienty Google Cloud, ze środowiskiem uruchomieniowym w zestawie i pełnym kodem źródłowym w pakiecie. Pobierz już dziś instalator próbny All-Access i wypróbuj każdy komponent.