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
246 lines • 34.3 kB
JavaScript
;
var _a, _b;
Object.defineProperty(exports, "__esModule", { value: true });
exports.IngressBackend = exports.Ingress = exports.HttpIngressPathType = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const cdk8s_1 = require("cdk8s");
const base = require("./base");
const k8s = require("./imports/k8s");
/**
* Specify how the path is matched against request paths.
*
* @see https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types
*/
var HttpIngressPathType;
(function (HttpIngressPathType) {
/**
* Matches the URL path exactly.
*/
HttpIngressPathType["PREFIX"] = "Prefix";
/**
* Matches based on a URL path prefix split by '/'.
*/
HttpIngressPathType["EXACT"] = "Exact";
/**
* Matching is specified by the underlying IngressClass.
*/
HttpIngressPathType["IMPLEMENTATION_SPECIFIC"] = "ImplementationSpecific";
})(HttpIngressPathType = exports.HttpIngressPathType || (exports.HttpIngressPathType = {}));
/**
* 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.
*/
class Ingress extends base.Resource {
constructor(scope, id, props = {}) {
super(scope, id);
this.resourceType = 'ingresses';
this._rulesPerHost = {};
this._tlsConfig = [];
this.apiObject = new k8s.KubeIngress(this, 'Resource', {
metadata: props.metadata,
spec: {
defaultBackend: cdk8s_1.Lazy.any({ produce: () => this._defaultBackend?._toKube() }),
ingressClassName: props.className,
rules: cdk8s_1.Lazy.any({ produce: () => this.synthRules() }),
tls: cdk8s_1.Lazy.any({ produce: () => this.tlsConfig() }),
},
});
if (props.defaultBackend) {
this.addDefaultBackend(props.defaultBackend);
}
this.addRules(...props.rules ?? []);
if (props.tls) {
this.addTls(props.tls);
}
this.node.addValidation({ validate: () => this._validate() });
}
_validate() {
if (!this._defaultBackend && Object.keys(this._rulesPerHost).length === 0) {
return ['ingress with no rules or default backend'];
}
return [];
}
/**
* 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) {
this.addRules({ backend });
}
/**
* 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, backend) {
if (!host) {
throw new Error('host must not be an empty string');
}
this.addRules({ host, backend });
}
/**
* 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, path, backend, pathType) {
if (!host) {
throw new Error('host must not be an empty string');
}
this.addRules({ host, backend, path, pathType });
}
/**
* 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, backend, pathType) {
this.addRules({ backend, path, pathType });
}
/**
* Adds rules to this ingress.
* @param rules The rules to add
*/
addRules(...rules) {
for (const rule of rules) {
// default backend is not really a rule
if (!rule.host && !rule.path) {
if (this._defaultBackend) {
throw new Error('a default backend is already defined for this ingress');
}
this._defaultBackend = rule.backend;
continue;
}
const host = rule.host ?? '';
const backend = rule.backend;
const path = rule.path ?? '/';
const pathType = rule.pathType ?? HttpIngressPathType.PREFIX;
if (path && !path.startsWith('/')) {
throw new Error(`ingress paths must begin with a "/": ${path}`);
}
const routes = this._rulesPerHost[host] = this._rulesPerHost[host] ?? [];
// check if we already have a rule for this host/path
if (routes.find(r => r.path === path)) {
throw new Error(`there is already an ingress rule for ${host}${path}`);
}
routes.push({
backend: backend._toKube(),
path,
pathType,
});
}
}
synthRules() {
const rules = new Array();
for (const [host, paths] of Object.entries(this._rulesPerHost)) {
rules.push({
host: host ? host : undefined,
http: { paths: paths.sort(sortByPath) },
});
}
return rules.length > 0 ? rules : undefined;
}
addTls(tls) {
this._tlsConfig.push(...tls);
}
tlsConfig() {
if (this._tlsConfig.length == 0) {
return undefined;
}
const tls = new Array();
for (const entry of this._tlsConfig) {
tls.push({
hosts: entry.hosts,
secretName: entry.secret?.name,
});
}
return tls;
}
}
exports.Ingress = Ingress;
_a = JSII_RTTI_SYMBOL_1;
Ingress[_a] = { fqn: "cdk8s-plus-25.Ingress", version: "2.22.79" };
/**
* The backend for an ingress path.
*/
class IngressBackend {
constructor(backend) {
this.backend = backend;
}
/**
* A Kubernetes `Service` to use as the backend for this path.
* @param serv The service object.
*/
static fromService(serv, options = {}) {
if (serv.ports.length === 0) {
throw new Error('service does not expose any ports');
}
let servicePort;
if (serv.ports.length === 1) {
servicePort = serv.ports[0].port;
}
else {
if (options.port !== undefined) {
const found = serv.ports.find(p => p.port === options.port);
if (found) {
servicePort = found.port;
}
else {
throw new Error(`service exposes ports ${serv.ports.map(p => p.port).join(',')} but backend is defined to use port ${options.port}`);
}
}
else {
throw new Error(`unable to determine service port since service exposes multiple ports: ${serv.ports.map(x => x.port).join(',')}`);
}
}
if (options.port !== undefined && servicePort !== options.port) {
throw new Error(`backend defines port ${options.port} but service exposes port ${servicePort}`);
}
return new IngressBackend({
service: {
name: serv.name,
port: { number: servicePort },
},
});
}
/**
* 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) {
return new IngressBackend({
resource: {
kind: resource.kind,
name: resource.name,
apiGroup: resource.apiGroup,
},
});
}
/**
* @internal
*/
_toKube() { return this.backend; }
}
exports.IngressBackend = IngressBackend;
_b = JSII_RTTI_SYMBOL_1;
IngressBackend[_b] = { fqn: "cdk8s-plus-25.IngressBackend", version: "2.22.79" };
function sortByPath(lhs, rhs) {
const p1 = lhs.path ?? '';
const p2 = rhs.path ?? '';
return p1.localeCompare(p2);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ingress.js","sourceRoot":"","sources":["../src/ingress.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as secret from './secret';\nimport * as service from './service';\n\n/**\n * Properties for `Ingress`.\n */\nexport interface IngressProps extends base.ResourceProps {\n  /**\n   * The default backend services requests that do not match any rule.\n   *\n   * Using this option or the `addDefaultBackend()` method is equivalent to\n   * adding a rule with both `path` and `host` undefined.\n   */\n  readonly defaultBackend?: IngressBackend;\n\n  /**\n   * Routing rules for this ingress.\n   *\n   * Each rule must define an `IngressBackend` that will receive the requests\n   * that match this rule. If both `host` and `path` are not specifiec, this\n   * backend will be used as the default backend of the ingress.\n   *\n   * You can also add rules later using `addRule()`, `addHostRule()`,\n   * `addDefaultBackend()` and `addHostDefaultBackend()`.\n   */\n  readonly rules?: IngressRule[];\n\n\n  /**\n   * TLS settings for this ingress.\n   *\n   * Using this option tells the ingress controller to expose a TLS endpoint.\n   * Currently the Ingress only supports a single TLS port, 443. If multiple\n   * members of this list specify different hosts, they will be multiplexed on\n   * the same port according to the hostname specified through the SNI TLS\n   * extension, if the ingress controller fulfilling the ingress supports SNI.\n   */\n  readonly tls?: IngressTls[];\n\n  /**\n   * Class Name for this ingress.\n   *\n   * This field is a reference to an IngressClass resource that contains\n   * additional Ingress configuration, including the name of the Ingress controller.\n   */\n  readonly className?: string;\n}\n\n/**\n * Specify how the path is matched against request paths.\n *\n * @see https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types\n */\nexport enum HttpIngressPathType {\n  /**\n   * Matches the URL path exactly.\n   */\n  PREFIX = 'Prefix',\n\n  /**\n   * Matches based on a URL path prefix split by '/'.\n   */\n  EXACT = 'Exact',\n\n  /**\n   * Matching is specified by the underlying IngressClass.\n   */\n  IMPLEMENTATION_SPECIFIC = 'ImplementationSpecific',\n}\n\n/**\n * Ingress is a collection of rules that allow inbound connections to reach the\n * endpoints defined by a backend. An Ingress can be configured to give services\n * externally-reachable urls, load balance traffic, terminate SSL, offer name\n * based virtual hosting etc.\n */\nexport class Ingress extends base.Resource {\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'ingresses';\n\n  private readonly _rulesPerHost: { [host: string]: k8s.HttpIngressPath[] } = {};\n  private _defaultBackend?: IngressBackend;\n  private readonly _tlsConfig: IngressTls[] = [];\n\n  constructor(scope: Construct, id: string, props: IngressProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeIngress(this, 'Resource', {\n      metadata: props.metadata,\n      spec: {\n        defaultBackend: Lazy.any({ produce: () => this._defaultBackend?._toKube() }),\n        ingressClassName: props.className,\n        rules: Lazy.any({ produce: () => this.synthRules() }),\n        tls: Lazy.any({ produce: () => this.tlsConfig() }),\n      },\n    });\n\n    if (props.defaultBackend) {\n      this.addDefaultBackend(props.defaultBackend);\n    }\n\n    this.addRules(...props.rules ?? []);\n\n    if (props.tls) {\n      this.addTls(props.tls);\n    }\n\n    this.node.addValidation({ validate: () => this._validate() });\n  }\n\n  private _validate() {\n    if (!this._defaultBackend && Object.keys(this._rulesPerHost).length === 0) {\n      return ['ingress with no rules or default backend'];\n    }\n    return [];\n  }\n\n  /**\n   * Defines the default backend for this ingress. A default backend capable of\n   * servicing requests that don't match any rule.\n   *\n   * @param backend The backend to use for requests that do not match any rule.\n   */\n  public addDefaultBackend(backend: IngressBackend) {\n    this.addRules({ backend });\n  }\n\n  /**\n   * Specify a default backend for a specific host name. This backend will be used as a catch-all for requests\n   * targeted to this host name (the `Host` header matches this value).\n   *\n   * @param host The host name to match\n   * @param backend The backend to route to\n   */\n  public addHostDefaultBackend(host: string, backend: IngressBackend) {\n    if (!host) { throw new Error('host must not be an empty string'); }\n    this.addRules({ host, backend });\n  }\n\n  /**\n   * Adds an ingress rule applied to requests to a specific host and a specific\n   * HTTP path (the `Host` header matches this value).\n   *\n   * @param host The host name\n   * @param path The HTTP path\n   * @param backend The backend to route requests to\n   * @param pathType How the path is matched against request paths\n   */\n  public addHostRule(host: string, path: string, backend: IngressBackend, pathType?: HttpIngressPathType) {\n    if (!host) { throw new Error('host must not be an empty string'); }\n    this.addRules({ host, backend, path, pathType });\n  }\n\n  /**\n   * Adds an ingress rule applied to requests sent to a specific HTTP path.\n   *\n   * @param path The HTTP path\n   * @param backend The backend to route requests to\n   * @param pathType How the path is matched against request paths\n   */\n  public addRule(path: string, backend: IngressBackend, pathType?: HttpIngressPathType) {\n    this.addRules({ backend, path, pathType });\n  }\n\n  /**\n   * Adds rules to this ingress.\n   * @param rules The rules to add\n   */\n  public addRules(...rules: IngressRule[]) {\n    for (const rule of rules) {\n\n      // default backend is not really a rule\n      if (!rule.host && !rule.path) {\n        if (this._defaultBackend) {\n          throw new Error('a default backend is already defined for this ingress');\n        }\n        this._defaultBackend = rule.backend;\n        continue;\n      }\n\n      const host = rule.host ?? '';\n      const backend = rule.backend;\n      const path = rule.path ?? '/';\n      const pathType = rule.pathType ?? HttpIngressPathType.PREFIX;\n\n      if (path && !path.startsWith('/')) {\n        throw new Error(`ingress paths must begin with a \"/\": ${path}`);\n      }\n\n      const routes = this._rulesPerHost[host] = this._rulesPerHost[host] ?? [];\n\n      // check if we already have a rule for this host/path\n      if (routes.find(r => r.path === path)) {\n        throw new Error(`there is already an ingress rule for ${host}${path}`);\n      }\n\n      routes.push({\n        backend: backend._toKube(),\n        path,\n        pathType,\n      });\n    }\n  }\n\n  private synthRules(): undefined | k8s.IngressRule[] {\n    const rules = new Array<k8s.IngressRule>();\n\n    for (const [host, paths] of Object.entries(this._rulesPerHost)) {\n      rules.push({\n        host: host ? host : undefined,\n        http: { paths: paths.sort(sortByPath) },\n      });\n    }\n\n    return rules.length > 0 ? rules : undefined;\n  }\n\n  public addTls(tls: IngressTls[]) {\n    this._tlsConfig.push(...tls);\n  }\n\n  private tlsConfig(): undefined | k8s.IngressTls[] {\n    if (this._tlsConfig.length == 0) {\n      return undefined;\n    }\n\n    const tls = new Array<k8s.IngressTls>();\n    for (const entry of this._tlsConfig) {\n      tls.push({\n        hosts: entry.hosts,\n        secretName: entry.secret?.name,\n      });\n    }\n\n    return tls;\n  }\n}\n\n/**\n * Options for setting up backends for ingress rules.\n */\nexport interface ServiceIngressBackendOptions {\n  /**\n   * The port to use to access the service.\n   *\n   * - This option will fail if the service does not expose any ports.\n   * - If the service exposes multiple ports, this option must be specified.\n   * - If the service exposes a single port, this option is optional and if\n   *   specified, it must be the same port exposed by the service.\n   *\n   * @default - if the service exposes a single port, this port will be used.\n   */\n  readonly port?: number;\n}\n\n/**\n * The backend for an ingress path.\n */\nexport class IngressBackend {\n  /**\n   * A Kubernetes `Service` to use as the backend for this path.\n   * @param serv The service object.\n   */\n  public static fromService(serv: service.Service, options: ServiceIngressBackendOptions = {}) {\n    if (serv.ports.length === 0) {\n      throw new Error('service does not expose any ports');\n    }\n\n    let servicePort;\n    if (serv.ports.length === 1) {\n      servicePort = serv.ports[0].port;\n    } else {\n      if (options.port !== undefined) {\n        const found = serv.ports.find(p => p.port === options.port);\n        if (found) {\n          servicePort = found.port;\n        } else {\n          throw new Error(`service exposes ports ${serv.ports.map(p => p.port).join(',')} but backend is defined to use port ${options.port}`);\n        }\n      } else {\n        throw new Error(`unable to determine service port since service exposes multiple ports: ${serv.ports.map(x => x.port).join(',')}`);\n      }\n    }\n\n    if (options.port !== undefined && servicePort !== options.port) {\n      throw new Error(`backend defines port ${options.port} but service exposes port ${servicePort}`);\n    }\n\n    return new IngressBackend({\n      service: {\n        name: serv.name,\n        port: { number: servicePort },\n      },\n    });\n  }\n\n  /**\n   * A Resource backend is an ObjectRef to another Kubernetes resource\n   * within the same namespace as the Ingress object.\n   * A common usage for a Resource backend is to ingress data to an object\n   * storage backend with static assets.\n   */\n  public static fromResource(resource: base.IResource) {\n    return new IngressBackend({\n      resource: {\n        kind: resource.kind,\n        name: resource.name,\n        apiGroup: resource.apiGroup,\n      },\n    });\n  }\n\n  private constructor(private readonly backend: k8s.IngressBackend) {\n\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube() { return this.backend; }\n}\n\n/**\n * Represents the rules mapping the paths under a specified host to the related\n * backend services. Incoming requests are first evaluated for a host match,\n * then routed to the backend associated with the matching path.\n */\nexport interface IngressRule {\n  /**\n   * Backend defines the referenced service endpoint to which the traffic will\n   * be forwarded to.\n   */\n  readonly backend: IngressBackend;\n\n  /**\n   * Host is the fully qualified domain name of a network host, as defined by\n   * RFC 3986. Note the following deviations from the \"host\" part of the URI as\n   * defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue\n   * can only apply to the IP in the Spec of the parent Ingress. 2. The `:`\n   * delimiter is not respected because ports are not allowed. Currently the\n   * port of an Ingress is implicitly :80 for http and :443 for https. Both\n   * these may change in the future. Incoming requests are matched against the\n   * host before the IngressRuleValue.\n   *\n   * @default - If the host is unspecified, the Ingress routes all traffic based\n   * on the specified IngressRuleValue.\n   */\n  readonly host?: string;\n\n  /**\n   * Path is an extended POSIX regex as defined by IEEE Std 1003.1, (i.e this\n   * follows the egrep/unix syntax, not the perl syntax) matched against the\n   * path of an incoming request. Currently it can contain characters disallowed\n   * from the conventional \"path\" part of a URL as defined by RFC 3986. Paths\n   * must begin with a '/'.\n   *\n   * @default - If unspecified, the path defaults to a catch all sending traffic\n   * to the backend.\n   */\n  readonly path?: string;\n\n  /**\n   * Specify how the path is matched against request paths. By default, path\n   * types will be matched by prefix.\n   *\n   * @see https://kubernetes.io/docs/concepts/services-networking/ingress/#path-types\n   */\n  readonly pathType?: HttpIngressPathType;\n}\n\n/**\n * Represents the TLS configuration mapping that is passed to the ingress\n * controller for SSL termination.\n */\nexport interface IngressTls {\n\n  /**\n   * Hosts are a list of hosts included in the TLS certificate. The values in\n   * this list must match the name/s used in the TLS Secret.\n   *\n   * @default - If unspecified, it defaults to the wildcard host setting for\n   * the loadbalancer controller fulfilling this Ingress.\n   */\n  readonly hosts?: string[];\n\n  /**\n   * Secret is the secret that contains the certificate and key used to\n   * terminate SSL traffic on 443. If the SNI host in a listener conflicts with\n   * the \"Host\" header field used by an IngressRule, the SNI host is used for\n   * termination and value of the Host header is used for routing.\n   *\n   * @default - If unspecified, it allows SSL routing based on SNI hostname.\n   */\n  readonly secret?: secret.ISecret;\n}\n\nfunction sortByPath(lhs: k8s.HttpIngressPath, rhs: k8s.HttpIngressPath) {\n  const p1 = lhs.path ?? '';\n  const p2 = rhs.path ?? '';\n  return p1.localeCompare(p2);\n}\n"]}