Klient API Kubernetes dla Delphi z OpenAPI

Każdy klaster Kubernetes publikuje swoje API w formie OpenAPI — ten sam opis, który konsumuje kubectl i każdy oficjalny klient językowy. Wskaż sgcOpenAPI na specyfikację i wyemituj typowaną jednostkę Delphi, która pozwala aplikacji Pascala listować pody, skalować deploymenty, obserwować zdarzenia i stosować manifesty przez zwykłe HTTPS API.

Kubernetes + sgcOpenAPI

Serwer API Kubernetes udostępnia swój własny dokument OpenAPI 2.0 pod /openapi/v2 i dokument OpenAPI 3 pod /openapi/v3. sgcOpenAPI akceptuje oba i konwertuje je do wspólnego modelu wewnętrznego.

Specyfikacja źródłowa

GET https://<cluster>/openapi/v3

Auth

Token bearer / certyfikat klienta / kubeconfig

Wygenerowana jednostka

sgcOpenAPI_Kubernetes

Platformy

Windows, macOS, Linux, iOS, Android

Pobierz specyfikację z klastra i wygeneruj

Każdy klaster obsługuje swoją własną specyfikację, co oznacza, że wygenerowany klient jest dokładnie zsynchronizowany z wersjami API, CRD i agregowanymi API zainstalowanymi na tym klastrze. Wygeneruj ponownie wobec innego klastra, aby wspierać inną wersję.

uses
  sgcOpenAPI_Parser, sgcOpenAPI_Generator;

var
  vParser: TsgcOpenAPIParser;
  vGen: TsgcOpenAPIGenerator;
begin
  vParser := TsgcOpenAPIParser.Create(nil);
  try
    // Load directly from the cluster (mTLS or bearer)
    vParser.LoadFromURL('https://10.0.0.1:6443/openapi/v3',
      ['Authorization: Bearer ' + vToken]);

    Memo1.Lines.Add(Format('k8s spec: %d paths, %d schemas',
      [vParser.Paths.Count, vParser.Schemas.Count]));

    vGen := TsgcOpenAPIGenerator.Create(nil);
    try
      vGen.Parser := vParser;
      vGen.OutputUnit := 'sgcOpenAPI_Kubernetes';
      vGen.OutputFolder := 'C:\Generated\k8s';
      vGen.GroupBy := gbTag;
      vGen.Generate;
    finally
      vGen.Free;
    end;
  finally
    vParser.Free;
  end;
end;

Generator emituje jedną klasę na grupę API/wersję Kubernetes — TsgcK8s_CoreV1, TsgcK8s_AppsV1, TsgcK8s_BatchV1, TsgcK8s_NetworkingV1, TsgcK8s_StorageV1, TsgcK8s_RbacV1 itp. — plus fasadę najwyższego poziomu TsgcKubernetes.

Listuj pody w przestrzeni nazw

Trzy linie, gdy uwierzytelnianie jest ustawione. Wynik to typowana TsgcK8sPodList, której elementy udostępniają każdy kontener, warunek i pole statusu z oficjalnej referencji API.

uses sgcOpenAPI_Kubernetes;

var
  vK8s: TsgcKubernetes;
  vPods: TsgcK8sPodList;
  vPod: TsgcK8sPod;
begin
  vK8s := TsgcKubernetes.Create(nil);
  try
    vK8s.Server := 'https://10.0.0.1:6443';
    vK8s.Token := vToken;
    vK8s.ClientCertFile := 'C:\kube\client.crt';
    vK8s.ClientKeyFile := 'C:\kube\client.key';
    vK8s.CACertFile := 'C:\kube\ca.crt';

    vPods := vK8s.CoreV1.ListNamespacedPod(
      Namespace := 'production',
      LabelSelector := 'app=api,tier=backend');
    try
      for vPod in vPods.Items do
        Memo1.Lines.Add(Format('%-30s  %s  node=%s',
          [vPod.Metadata.Name, vPod.Status.Phase, vPod.Spec.NodeName]));
    finally
      vPods.Free;
    end;
  finally
    vK8s.Free;
  end;
end;

Skaluj deployment i obserwuj zdarzenia

Skalowanie Deployment to PATCH wobec subzasobu /scale. Obserwowanie zdarzeń to długotrwały HTTP/1.1 chunked GET, który wygenerowany klient udostępnia jako typowany enumerable.

// Scale "api" Deployment in "production" to 5 replicas
var
  vScale: TsgcK8sScale;
begin
  vScale := vK8s.AppsV1.ReadNamespacedDeploymentScale(
    Name := 'api', Namespace := 'production');
  try
    vScale.Spec.Replicas := 5;
    vK8s.AppsV1.ReplaceNamespacedDeploymentScale(
      Name := 'api', Namespace := 'production',
      Body := vScale);
  finally
    vScale.Free;
  end;

  // Watch events on Pods in the same namespace
  for vEvent in vK8s.CoreV1.WatchNamespacedPodList(
    Namespace := 'production',
    ResourceVersion := vPods.Metadata.ResourceVersion,
    TimeoutSeconds := 600) do
  begin
    Memo1.Lines.Add(Format('[%s] %s — %s',
      [vEvent.EventType, vEvent.&Object.Metadata.Name,
       vEvent.&Object.Status.Phase]));
  end;
end;

Co daje Ci wygenerowana jednostka

Ponieważ specyfikacja jest pobierana z klastra, każda grupa API, wersja i CRD zainstalowane na tym klastrze trafia do jednostki Delphi.

Obciążenia

AppsV1 — Deployments, StatefulSets, DaemonSets, ReplicaSets. BatchV1 — Jobs, CronJobs. CoreV1 — Pods, ReplicationControllers.

Usługi i sieci

CoreV1 — Services, Endpoints, ConfigMaps, Secrets. NetworkingV1 — Ingress, IngressClass, NetworkPolicy. DiscoveryV1 — EndpointSlices.

Storage

StorageV1 — StorageClasses, VolumeAttachments, CSIDrivers, CSINodes. CoreV1 — PersistentVolumes, PersistentVolumeClaims.

RBAC i polityka

RbacV1 — Roles, RoleBindings, ClusterRoles, ClusterRoleBindings. PolicyV1 — PodDisruptionBudgets. AdmissionRegistrationV1 — ValidatingWebhookConfigurations.

Zasoby niestandardowe

CRD zainstalowane w Twoim klastrze pojawiają się automatycznie. Argo Rollouts, certyfikaty Cert Manager, Istio VirtualServices — jeśli operator zarejestrował schemat OpenAPI, sgcOpenAPI generuje dla niego typowaną klasę.

Strumienie watch + log

Długotrwałe endpointy (watch=true, log kontenera follow=true) są udostępniane jako enumerables, które dostarczają typowane zdarzenia, gdy tylko serwer je opróżnia.

Trzy rzeczy, na które należy uważać

Samopodpisane certyfikaty CA

Większość klastrów używa samopodpisanego cluster CA. Dostarcz pakiet CA z ~/.kube/config przez CACertFile lub wyłącz weryfikację całkowicie z InsecureSkipTLSVerify := True — przydatne dla klastrów deweloperskich, ale nigdy dla produkcji.

Wygaśnięcie tokenu ServiceAccount

Powiązane tokeny ServiceAccount (domyślne od Kubernetes 1.21) wygasają po jednej godzinie. Odśwież token, ponownie czytając /var/run/secrets/kubernetes.io/serviceaccount/token z wewnątrz klastra lub wywołując API TokenRequest z zewnątrz.

Server-Side Apply kontra PATCH

Nowoczesne kontrolery preferują Server-Side Apply z Content-Type: application/apply-patch+yaml. Generator emituje oba pomocniki — użyj PatchNamespacedDeployment dla tradycyjnych patchy strategic-merge i jawnej metody Apply dla SSA.

Z bloga

Parser OpenAPI Delphi

Jak parser obsługuje rzeczywiste specyfikacje OpenAPI — w tym agregowane API w stylu Kubernetes.

Czytaj wpis →

Klient OpenAPI + parser

Towarzyszący wpis, który wprowadza zarówno wrapper klienta, jak i wnętrzności parsera.

Czytaj wpis →

sgcOpenAPI 2026.6

Najnowsze notatki wydania dla sgcOpenAPI — nowe opcje generatora i ulepszenia parsera.

Czytaj wpis →

Napędzaj Kubernetes z Delphi już dziś

sgcOpenAPI dostarcza parser, generator kodu, serwer OpenAPI i pakiety SDK Amazon, Google, Microsoft i Azure — jeden produkt, trzy poziomy.