cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+export * from './base';
+export * from './config-map';
+export * from './container';
+export * from './cron-job';
+export * from './deployment';
+export * from './job';
+export * from './pod';
+export * from './secret';
+export * from './service-account';
+export * from './service';
+export * from './stateful-set';
+export * from './volume';
+export * from './ingress';
+export * from './probe';
+export * from './pvc';
+export * from './pv';
+export * from './handler';
+export * from './horizontal-pod-autoscaler';
+export * from './workload';
+export * from './daemon-set';
+export * from './role';
+export * from './role-binding';
+export * from './network-policy';
+export * from './namespace';
+export * from './api-resource';
+export * as k8s from './imports/k8s';

package/lib/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.k8s = void 0;
+__exportStar(require("./base"), exports);
+__exportStar(require("./config-map"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./cron-job"), exports);
+__exportStar(require("./deployment"), exports);
+__exportStar(require("./job"), exports);
+__exportStar(require("./pod"), exports);
+__exportStar(require("./secret"), exports);
+__exportStar(require("./service-account"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./stateful-set"), exports);
+__exportStar(require("./volume"), exports);
+__exportStar(require("./ingress"), exports);
+__exportStar(require("./probe"), exports);
+__exportStar(require("./pvc"), exports);
+__exportStar(require("./pv"), exports);
+__exportStar(require("./handler"), exports);
+__exportStar(require("./horizontal-pod-autoscaler"), exports);
+__exportStar(require("./workload"), exports);
+__exportStar(require("./daemon-set"), exports);
+__exportStar(require("./role"), exports);
+__exportStar(require("./role-binding"), exports);
+__exportStar(require("./network-policy"), exports);
+__exportStar(require("./namespace"), exports);
+__exportStar(require("./api-resource"), exports);
+exports.k8s = require("./imports/k8s");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5Q0FBdUI7QUFDdkIsK0NBQTZCO0FBQzdCLDhDQUE0QjtBQUM1Qiw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBQzdCLHdDQUFzQjtBQUN0Qix3Q0FBc0I7QUFDdEIsMkNBQXlCO0FBQ3pCLG9EQUFrQztBQUNsQyw0Q0FBMEI7QUFDMUIsaURBQStCO0FBQy9CLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLHdDQUFzQjtBQUN0Qix1Q0FBcUI7QUFDckIsNENBQTBCO0FBQzFCLDhEQUE0QztBQUM1Qyw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QixpREFBK0I7QUFDL0IsbURBQWlDO0FBQ2pDLDhDQUE0QjtBQUU1QixpREFBK0I7QUFDL0IsdUNBQXFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnLW1hcCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2Nyb24tam9iJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwbG95bWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2pvYic7XG5leHBvcnQgKiBmcm9tICcuL3BvZCc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldCc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UtYWNjb3VudCc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0ZWZ1bC1zZXQnO1xuZXhwb3J0ICogZnJvbSAnLi92b2x1bWUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmdyZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvYmUnO1xuZXhwb3J0ICogZnJvbSAnLi9wdmMnO1xuZXhwb3J0ICogZnJvbSAnLi9wdic7XG5leHBvcnQgKiBmcm9tICcuL2hhbmRsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9ob3Jpem9udGFsLXBvZC1hdXRvc2NhbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vd29ya2xvYWQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYWVtb24tc2V0JztcbmV4cG9ydCAqIGZyb20gJy4vcm9sZSc7XG5leHBvcnQgKiBmcm9tICcuL3JvbGUtYmluZGluZyc7XG5leHBvcnQgKiBmcm9tICcuL25ldHdvcmstcG9saWN5JztcbmV4cG9ydCAqIGZyb20gJy4vbmFtZXNwYWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9hcGktcmVzb3VyY2UnO1xuZXhwb3J0ICogYXMgazhzIGZyb20gJy4vaW1wb3J0cy9rOHMnO1xuIl19

package/lib/ingress.d.ts

@@ -0,0 +1,230 @@
+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;
+}

package/lib/ingress.js

@@ -0,0 +1,246 @@
+"use strict";
+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 = 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-34.Ingress", version: "2.0.0" };
+/**
+ * The backend for an ingress path.
+ */
+class IngressBackend {
+    /**
+     * 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,
+            },
+        });
+    }
+    constructor(backend) {
+        this.backend = backend;
+    }
+    /**
+     * @internal
+     */
+    _toKube() { return this.backend; }
+}
+exports.IngressBackend = IngressBackend;
+_b = JSII_RTTI_SYMBOL_1;
+IngressBackend[_b] = { fqn: "cdk8s-plus-34.IngressBackend", version: "2.0.0" };
+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"]}

package/lib/job.d.ts

@@ -0,0 +1,64 @@
+import { ApiObject, Duration } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as k8s from './imports/k8s';
+import * as workload from './workload';
+/**
+ * Properties for `Job`.
+ */
+export interface JobProps extends workload.WorkloadProps {
+    /**
+     * Specifies the duration the job may be active before the system tries to terminate it.
+     *
+     * @default - If unset, then there is no deadline.
+     */
+    readonly activeDeadline?: Duration;
+    /**
+     * Specifies the number of retries before marking this job failed.
+     *
+     * @default - If not set, system defaults to 6.
+     */
+    readonly backoffLimit?: number;
+    /**
+     * Limits the lifetime of a Job that has finished execution (either Complete
+     * or Failed). If this field is set, after the Job finishes, it is eligible to
+     * be automatically deleted. When the Job is being deleted, its lifecycle
+     * guarantees (e.g. finalizers) will be honored. If this field is set to zero,
+     * the Job becomes eligible to be deleted immediately after it finishes. This
+     * field is alpha-level and is only honored by servers that enable the
+     * `TTLAfterFinished` feature.
+     *
+     * @default - If this field is unset, the Job won't be automatically deleted.
+     */
+    readonly ttlAfterFinished?: Duration;
+}
+/**
+ * A Job creates one or more Pods and ensures that a specified number of them successfully terminate. As pods successfully complete,
+ * the Job tracks the successful completions. When a specified number of successful completions is reached, the task (ie, Job) is complete.
+ * Deleting a Job will clean up the Pods it created. A simple case is to create one Job object in order to reliably run one Pod to completion.
+ * The Job object will start a new Pod if the first Pod fails or is deleted (for example due to a node hardware failure or a node reboot).
+ * You can also use a Job to run multiple Pods in parallel.
+ */
+export declare class Job extends workload.Workload {
+    /**
+     * Duration before job is terminated. If undefined, there is no deadline.
+     */
+    readonly activeDeadline?: Duration;
+    /**
+     * Number of retries before marking failed.
+     */
+    readonly backoffLimit?: number;
+    /**
+     * TTL before the job is deleted after it is finished.
+     */
+    readonly ttlAfterFinished?: Duration;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "jobs";
+    constructor(scope: Construct, id: string, props?: JobProps);
+    /**
+     * @internal
+     */
+    _toKube(): k8s.JobSpec;
+}