feat(apisix-standalone): support upstream healthcheck and service discovery (#333)

Author: bzp2010

libs/backend-apisix-standalone/README.md

@@ -39,9 +39,3 @@ The ADC will ignore the resource-type level `conf_version` and resource level `m
 They will not be exported to a YAML file. Updates to conf_version and modifiedIndex will only occur during synchronization.
 
 Their values will be reset to that moment's timestamp when they are created or updated.
-
-### Differences in upstream
-
-This backend's upstream converter will not support the configuration of the APISIX health checker or service discovery.
-
-The reason for this is that this backend will primarily be used in an Ingress Controller scenario. In this scenario, the Kubernetes Endpoints mechanism and probes will implement these two capabilities.

libs/backend-apisix-standalone/src/operator.ts

@@ -448,6 +448,10 @@ export class Operator extends ADCSDK.backend.BackendEventSource {
       keepalive_pool: res.keepalive_pool,
       pass_host: res.pass_host,
       upstream_host: res.upstream_host,
+      checks: res.checks,
+      discovery_type: res.discovery_type,
+      service_name: res.service_name,
+      discovery_args: res.discovery_args,
     } satisfies typing.Upstream as typing.Upstream;
     if (parentId)
       upstream.labels = {

libs/backend-apisix-standalone/src/transformer.ts

@@ -31,6 +31,11 @@ export const toADC = (input: typing.APISIXStandalone) => {
     // Empty Lua tables will be encoded as "{}" rather than "[]" by cjson,
     // so this must be handled separately to prevent unexpected diff results.
     nodes: !isEmpty(upstream.nodes) ? upstream.nodes : [],
+
+    checks: upstream.checks,
+    discovery_type: upstream.discovery_type,
+    service_name: upstream.service_name,
+    discovery_args: upstream.discovery_args,
   });
   return {
     services:

libs/backend-apisix-standalone/src/typing.ts

@@ -41,6 +41,27 @@ const RouteSchema = z.strictObject({
 });
 export type Route = z.infer<typeof RouteSchema>;
 
+const upstreamHealthCheckPassiveHealthy = z.strictObject({
+  http_statuses: z
+    .array(z.coerce.number().int().min(200).max(599))
+    .min(1)
+    .default([200, 302])
+    .optional(),
+  successes: z.coerce.number().int().min(1).max(254).default(2).optional(),
+});
+const upstreamHealthCheckPassiveUnhealthy = z.strictObject({
+  http_statuses: z
+    .array(z.coerce.number().int().min(200).max(599))
+    .min(1)
+    .default([429, 404, 500, 501, 502, 503, 504, 505])
+    .optional(),
+  http_failures: z.coerce.number().int().min(1).max(254).default(5).optional(),
+  tcp_failures: z.coerce.number().int().min(1).max(254).default(2).optional(),
+  timeouts: z.coerce.number().int().min(1).max(254).default(3).optional(),
+});
+const upstreamHealthCheckType = z
+  .union([z.literal('http'), z.literal('https'), z.literal('tcp')])
+  .default('http');
 const UpstreamSchema = z.strictObject({
   ...ModifiedIndex,
   ...Metadata,
@@ -99,9 +120,44 @@ const UpstreamSchema = z.strictObject({
     })
     .optional(),
 
-  // Will not include health checks and service discovery configurations,
-  // which are implemented by other components on the target ecosystem,
-  // such as Kubernetes and Ingress Controller.
+  checks: z
+    .strictObject({
+      active: z
+        .strictObject({
+          type: upstreamHealthCheckType.optional(),
+          timeout: z.coerce.number().default(1).optional(),
+          concurrency: z.coerce.number().default(10).optional(),
+          host: z.string().min(1).optional(),
+          port: z.coerce.number().int().min(1).max(65535).optional(),
+          http_path: z.string().default('/').optional(),
+          https_verify_cert: z.boolean().default(true).optional(),
+          http_request_headers: z.array(z.string()).min(1).optional(),
+          healthy: z
+            .strictObject({
+              ...upstreamHealthCheckPassiveHealthy.shape,
+              interval: z.coerce.number().int().min(1).default(1),
+            })
+            .optional(),
+          unhealthy: z
+            .strictObject({
+              ...upstreamHealthCheckPassiveUnhealthy.shape,
+              interval: z.coerce.number().int().min(1).default(1),
+            })
+            .optional(),
+        })
+        .optional(),
+      passive: z
+        .strictObject({
+          type: upstreamHealthCheckType.optional(),
+          healthy: upstreamHealthCheckPassiveHealthy.optional(),
+          unhealthy: upstreamHealthCheckPassiveUnhealthy.optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+  discovery_type: z.string().optional(),
+  service_name: z.string().optional(),
+  discovery_args: z.record(z.string(), z.any()).optional(),
 });
 export type Upstream = z.infer<typeof UpstreamSchema>;
 

libs/sdk/src/core/index.ts

@@ -83,35 +83,35 @@ export interface UpstreamKeepalivePool {
   requests: number;
 }
 export interface UpstreamHealthCheck {
-  active: UpstreamHealthCheckActive;
-  passive: UpstreamHealthCheckPassive;
+  active?: UpstreamHealthCheckActive;
+  passive?: UpstreamHealthCheckPassive;
 }
 export interface UpstreamHealthCheckActive {
   type?: 'http' | 'https' | 'tcp';
   timeout?: number;
   concurrency?: number;
-  host: string;
-  port: number;
-  http_path: string;
-  https_verify_cert: boolean;
-  http_request_headers: Array<string>;
-  healthy: UpstreamHealthCheckActiveHealthy;
-  unhealthy: UpstreamHealthCheckActiveUnhealthy;
+  host?: string;
+  port?: number;
+  http_path?: string;
+  https_verify_cert?: boolean;
+  http_request_headers?: Array<string>;
+  healthy?: UpstreamHealthCheckActiveHealthy;
+  unhealthy?: UpstreamHealthCheckActiveUnhealthy;
 }
 export interface UpstreamHealthCheckPassive {
-  type: string;
-  healthy: UpstreamHealthCheckPassiveHealthy;
-  unhealthy: UpstreamHealthCheckPassiveUnhealthy;
+  type?: 'http' | 'https' | 'tcp';
+  healthy?: UpstreamHealthCheckPassiveHealthy;
+  unhealthy?: UpstreamHealthCheckPassiveUnhealthy;
 }
 export interface UpstreamHealthCheckPassiveHealthy {
-  http_statuses: Array<number>;
-  successes: number;
+  http_statuses?: Array<number>;
+  successes?: number;
 }
 export interface UpstreamHealthCheckPassiveUnhealthy {
-  http_statuses: Array<number>;
-  http_failures: number;
-  tcp_failures: number;
-  timeouts: number;
+  http_statuses?: Array<number>;
+  http_failures?: number;
+  tcp_failures?: number;
+  timeouts?: number;
 }
 
 export type UpstreamHealthCheckActiveHealthy = {