cdk8s-plus-25
Version:
cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-25 synthesizes Kubernetes manifests for Kubernetes 1.25.0
231 lines (230 loc) • 8.93 kB
TypeScript
import { ApiObject } from 'cdk8s';
import { Construct } from 'constructs';
import * as base from './base';
import * as k8s from './imports/k8s';
import * as secret from './secret';
import * as service from './service';
/**
* Properties for `Ingress`.
*/
export interface IngressProps extends base.ResourceProps {
/**
* The default backend services requests that do not match any rule.
*
* Using this option or the `addDefaultBackend()` method is equivalent to
* adding a rule with both `path` and `host` undefined.
*/
readonly defaultBackend?: IngressBackend;
/**
* Routing rules for this ingress.
*
* Each rule must define an `IngressBackend` that will receive the requests
* that match this rule. If both `host` and `path` are not specifiec, this
* backend will be used as the default backend of the ingress.
*
* You can also add rules later using `addRule()`, `addHostRule()`,
* `addDefaultBackend()` and `addHostDefaultBackend()`.
*/
readonly rules?: IngressRule[];
/**
* TLS settings for this ingress.
*
* Using this option tells the ingress controller to expose a TLS endpoint.
* Currently the Ingress only supports a single TLS port, 443. If multiple
* members of this list specify different hosts, they will be multiplexed on
* the same port according to the hostname specified through the SNI TLS
* extension, if the ingress controller fulfilling the ingress supports SNI.
*/
readonly tls?: IngressTls[];
/**
* Class Name for this ingress.
*
* This field is a reference to an IngressClass resource that contains
* additional Ingress configuration, including the name of the Ingress controller.
*/
readonly className?: string;
}
/**
* Specify how the path is matched against request paths.
*
* @see https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types
*/
export declare enum HttpIngressPathType {
/**
* Matches the URL path exactly.
*/
PREFIX = "Prefix",
/**
* Matches based on a URL path prefix split by '/'.
*/
EXACT = "Exact",
/**
* Matching is specified by the underlying IngressClass.
*/
IMPLEMENTATION_SPECIFIC = "ImplementationSpecific"
}
/**
* Ingress is a collection of rules that allow inbound connections to reach the
* endpoints defined by a backend. An Ingress can be configured to give services
* externally-reachable urls, load balance traffic, terminate SSL, offer name
* based virtual hosting etc.
*/
export declare class Ingress extends base.Resource {
/**
* @see base.Resource.apiObject
*/
protected readonly apiObject: ApiObject;
readonly resourceType = "ingresses";
private readonly _rulesPerHost;
private _defaultBackend?;
private readonly _tlsConfig;
constructor(scope: Construct, id: string, props?: IngressProps);
private _validate;
/**
* Defines the default backend for this ingress. A default backend capable of
* servicing requests that don't match any rule.
*
* @param backend The backend to use for requests that do not match any rule.
*/
addDefaultBackend(backend: IngressBackend): void;
/**
* Specify a default backend for a specific host name. This backend will be used as a catch-all for requests
* targeted to this host name (the `Host` header matches this value).
*
* @param host The host name to match
* @param backend The backend to route to
*/
addHostDefaultBackend(host: string, backend: IngressBackend): void;
/**
* Adds an ingress rule applied to requests to a specific host and a specific
* HTTP path (the `Host` header matches this value).
*
* @param host The host name
* @param path The HTTP path
* @param backend The backend to route requests to
* @param pathType How the path is matched against request paths
*/
addHostRule(host: string, path: string, backend: IngressBackend, pathType?: HttpIngressPathType): void;
/**
* Adds an ingress rule applied to requests sent to a specific HTTP path.
*
* @param path The HTTP path
* @param backend The backend to route requests to
* @param pathType How the path is matched against request paths
*/
addRule(path: string, backend: IngressBackend, pathType?: HttpIngressPathType): void;
/**
* Adds rules to this ingress.
* @param rules The rules to add
*/
addRules(...rules: IngressRule[]): void;
private synthRules;
addTls(tls: IngressTls[]): void;
private tlsConfig;
}
/**
* Options for setting up backends for ingress rules.
*/
export interface ServiceIngressBackendOptions {
/**
* The port to use to access the service.
*
* - This option will fail if the service does not expose any ports.
* - If the service exposes multiple ports, this option must be specified.
* - If the service exposes a single port, this option is optional and if
* specified, it must be the same port exposed by the service.
*
* @default - if the service exposes a single port, this port will be used.
*/
readonly port?: number;
}
/**
* The backend for an ingress path.
*/
export declare class IngressBackend {
private readonly backend;
/**
* A Kubernetes `Service` to use as the backend for this path.
* @param serv The service object.
*/
static fromService(serv: service.Service, options?: ServiceIngressBackendOptions): IngressBackend;
/**
* A Resource backend is an ObjectRef to another Kubernetes resource
* within the same namespace as the Ingress object.
* A common usage for a Resource backend is to ingress data to an object
* storage backend with static assets.
*/
static fromResource(resource: base.IResource): IngressBackend;
private constructor();
/**
* @internal
*/
_toKube(): k8s.IngressBackend;
}
/**
* Represents the rules mapping the paths under a specified host to the related
* backend services. Incoming requests are first evaluated for a host match,
* then routed to the backend associated with the matching path.
*/
export interface IngressRule {
/**
* Backend defines the referenced service endpoint to which the traffic will
* be forwarded to.
*/
readonly backend: IngressBackend;
/**
* Host is the fully qualified domain name of a network host, as defined by
* RFC 3986. Note the following deviations from the "host" part of the URI as
* defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue
* can only apply to the IP in the Spec of the parent Ingress. 2. The `:`
* delimiter is not respected because ports are not allowed. Currently the
* port of an Ingress is implicitly :80 for http and :443 for https. Both
* these may change in the future. Incoming requests are matched against the
* host before the IngressRuleValue.
*
* @default - If the host is unspecified, the Ingress routes all traffic based
* on the specified IngressRuleValue.
*/
readonly host?: string;
/**
* Path is an extended POSIX regex as defined by IEEE Std 1003.1, (i.e this
* follows the egrep/unix syntax, not the perl syntax) matched against the
* path of an incoming request. Currently it can contain characters disallowed
* from the conventional "path" part of a URL as defined by RFC 3986. Paths
* must begin with a '/'.
*
* @default - If unspecified, the path defaults to a catch all sending traffic
* to the backend.
*/
readonly path?: string;
/**
* Specify how the path is matched against request paths. By default, path
* types will be matched by prefix.
*
* @see https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types
*/
readonly pathType?: HttpIngressPathType;
}
/**
* Represents the TLS configuration mapping that is passed to the ingress
* controller for SSL termination.
*/
export interface IngressTls {
/**
* Hosts are a list of hosts included in the TLS certificate. The values in
* this list must match the name/s used in the TLS Secret.
*
* @default - If unspecified, it defaults to the wildcard host setting for
* the loadbalancer controller fulfilling this Ingress.
*/
readonly hosts?: string[];
/**
* Secret is the secret that contains the certificate and key used to
* terminate SSL traffic on 443. If the SNI host in a listener conflicts with
* the "Host" header field used by an IngressRule, the SNI host is used for
* termination and value of the Host header is used for routing.
*
* @default - If unspecified, it allows SSL routing based on SNI hostname.
*/
readonly secret?: secret.ISecret;
}