cdk8s-plus-36 0.0.1 → 2.0.1

package/lib/container.js

@@ -0,0 +1,944 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Env = exports.EnvFrom = exports.Cpu = exports.MountPropagation = exports.Container = exports.ContainerRestartPolicy = exports.ImagePullPolicy = exports.EnvValue = exports.ResourceFieldPaths = exports.EnvFieldPaths = exports.ContainerSecurityContext = exports.Protocol = exports.SeccompProfileType = exports.Capability = void 0;
+exports.extractContainerPorts = extractContainerPorts;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const k8s = __importStar(require("./imports/k8s"));
+const probe = __importStar(require("./probe"));
+const utils_1 = require("./utils");
+/**
+ * Capability - complete list of POSIX capabilities
+ */
+var Capability;
+(function (Capability) {
+    /**
+     * ALL
+     */
+    Capability["ALL"] = "ALL";
+    /**
+     * CAP_AUDIT_CONTROL
+     */
+    Capability["AUDIT_CONTROL"] = "AUDIT_CONTROL";
+    /**
+     * CAP_AUDIT_READ
+     */
+    Capability["AUDIT_READ"] = "AUDIT_READ";
+    /**
+     * CAP_AUDIT_WRITE
+     */
+    Capability["AUDIT_WRITE"] = "AUDIT_WRITE";
+    /**
+     * CAP_BLOCK_SUSPEND
+     */
+    Capability["BLOCK_SUSPEND"] = "BLOCK_SUSPEND";
+    /**
+     * CAP_BPF
+     */
+    Capability["BPF"] = "BPF";
+    /**
+     * CAP_CHECKPOINT_RESTORE
+     */
+    Capability["CHECKPOINT_RESTORE"] = "CHECKPOINT_RESTORE";
+    /**
+     * CAP_CHOWN
+     */
+    Capability["CHOWN"] = "CHOWN";
+    /**
+     * CAP_DAC_OVERRIDE
+     */
+    Capability["DAC_OVERRIDE"] = "DAC_OVERRIDE";
+    /**
+     * CAP_DAC_READ_SEARCH
+     */
+    Capability["DAC_READ_SEARCH"] = "DAC_READ_SEARCH";
+    /**
+     * CAP_FOWNER
+     */
+    Capability["FOWNER"] = "FOWNER";
+    /**
+     * CAP_FSETID
+     */
+    Capability["FSETID"] = "FSETID";
+    /**
+     * CAP_IPC_LOCK
+     */
+    Capability["IPC_LOCK"] = "IPC_LOCK";
+    /**
+     * CAP_IPC_OWNER
+     */
+    Capability["IPC_OWNER"] = "IPC_OWNER";
+    /**
+     * CAP_KILL
+     */
+    Capability["KILL"] = "KILL";
+    /**
+     * CAP_LEASE
+     */
+    Capability["LEASE"] = "LEASE";
+    /**
+     * CAP_LINUX_IMMUTABLE
+     */
+    Capability["LINUX_IMMUTABLE"] = "LINUX_IMMUTABLE";
+    /**
+     * CAP_MAC_ADMIN
+     */
+    Capability["MAC_ADMIN"] = "MAC_ADMIN";
+    /**
+     * CAP_MAC_OVERRIDE
+     */
+    Capability["MAC_OVERRIDE"] = "MAC_OVERRIDE";
+    /**
+     * CAP_MKNOD
+     */
+    Capability["MKNOD"] = "MKNOD";
+    /**
+     * CAP_NET_ADMIN
+     */
+    Capability["NET_ADMIN"] = "NET_ADMIN";
+    /**
+     * CAP_NET_BIND_SERVICE
+     */
+    Capability["NET_BIND_SERVICE"] = "NET_BIND_SERVICE";
+    /**
+     * CAP_NET_BROADCAST
+     */
+    Capability["NET_BROADCAST"] = "NET_BROADCAST";
+    /**
+     * CAP_NET_RAW
+     */
+    Capability["NET_RAW"] = "NET_RAW";
+    /**
+     * CAP_PERFMON
+     */
+    Capability["PERFMON"] = "PERFMON";
+    /**
+     * CAP_SETGID
+     */
+    Capability["SETGID"] = "SETGID";
+    /**
+     * CAP_SETFCAP
+     */
+    Capability["SETFCAP"] = "SETFCAP";
+    /**
+     * CAP_SETPCAP
+     */
+    Capability["SETPCAP"] = "SETPCAP";
+    /**
+     * CAP_SETUID
+     */
+    Capability["SETUID"] = "SETUID";
+    /**
+     * CAP_SYS_ADMIN
+     */
+    Capability["SYS_ADMIN"] = "SYS_ADMIN";
+    /**
+     * CAP_SYS_BOOT
+     */
+    Capability["SYS_BOOT"] = "SYS_BOOT";
+    /**
+     * CAP_SYS_CHROOT
+     */
+    Capability["SYS_CHROOT"] = "SYS_CHROOT";
+    /**
+     * CAP_SYS_MODULE
+     */
+    Capability["SYS_MODULE"] = "SYS_MODULE";
+    /**
+     * CAP_SYS_NICE
+     */
+    Capability["SYS_NICE"] = "SYS_NICE";
+    /**
+     * CAP_SYS_PACCT
+     */
+    Capability["SYS_PACCT"] = "SYS_PACCT";
+    /**
+     * CAP_SYS_PTRACE
+     */
+    Capability["SYS_PTRACE"] = "SYS_PTRACE";
+    /**
+     * CAP_SYS_RAWIO
+     */
+    Capability["SYS_RAWIO"] = "SYS_RAWIO";
+    /**
+     * CAP_SYS_RESOURCE
+     */
+    Capability["SYS_RESOURCE"] = "SYS_RESOURCE";
+    /**
+     * CAP_SYS_TIME
+     */
+    Capability["SYS_TIME"] = "SYS_TIME";
+    /**
+     * CAP_SYS_TTY_CONFIG
+     */
+    Capability["SYS_TTY_CONFIG"] = "SYS_TTY_CONFIG";
+    /**
+     * CAP_SYSLOG
+     */
+    Capability["SYSLOG"] = "SYSLOG";
+    /**
+     * CAP_WAKE_ALARM
+     */
+    Capability["WAKE_ALARM"] = "WAKE_ALARM";
+})(Capability || (exports.Capability = Capability = {}));
+var SeccompProfileType;
+(function (SeccompProfileType) {
+    /**
+    * A profile defined in a file on the node should be used
+    */
+    SeccompProfileType["LOCALHOST"] = "Localhost";
+    /**
+    * The container runtime default profile should be used
+    */
+    SeccompProfileType["RUNTIME_DEFAULT"] = "RuntimeDefault";
+    /**
+    * No profile should be applied
+    */
+    SeccompProfileType["UNCONFINED"] = "Unconfined";
+})(SeccompProfileType || (exports.SeccompProfileType = SeccompProfileType = {}));
+/**
+ * Network protocols.
+ */
+var Protocol;
+(function (Protocol) {
+    /**
+     * TCP.
+     */
+    Protocol["TCP"] = "TCP";
+    /**
+     * UDP.
+     */
+    Protocol["UDP"] = "UDP";
+    /**
+     * SCTP.
+     */
+    Protocol["SCTP"] = "SCTP";
+})(Protocol || (exports.Protocol = Protocol = {}));
+/**
+ * Container security attributes and settings.
+ */
+class ContainerSecurityContext {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.ContainerSecurityContext", version: "2.0.1" };
+    ensureNonRoot;
+    privileged;
+    readOnlyRootFilesystem;
+    user;
+    group;
+    allowPrivilegeEscalation;
+    capabilities;
+    seccompProfile;
+    constructor(props = {}) {
+        if (props.seccompProfile?.localhostProfile && props.seccompProfile.type != SeccompProfileType.LOCALHOST) {
+            throw new Error('localhostProfile must only be set if type is "Localhost"');
+        }
+        this.ensureNonRoot = props.ensureNonRoot ?? true;
+        this.privileged = props.privileged ?? false;
+        this.readOnlyRootFilesystem = props.readOnlyRootFilesystem ?? true;
+        this.user = props.user;
+        this.group = props.group;
+        this.allowPrivilegeEscalation = props.allowPrivilegeEscalation ?? false;
+        this.capabilities = props.capabilities;
+        this.seccompProfile = props.seccompProfile;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            runAsGroup: this.group,
+            runAsUser: this.user,
+            runAsNonRoot: this.ensureNonRoot,
+            privileged: this.privileged,
+            readOnlyRootFilesystem: this.readOnlyRootFilesystem,
+            allowPrivilegeEscalation: this.allowPrivilegeEscalation,
+            capabilities: this.capabilities,
+            seccompProfile: this.seccompProfile,
+        };
+    }
+}
+exports.ContainerSecurityContext = ContainerSecurityContext;
+var EnvFieldPaths;
+(function (EnvFieldPaths) {
+    /**
+     * The name of the pod.
+     */
+    EnvFieldPaths["POD_NAME"] = "metadata.name";
+    /**
+     * The namespace of the pod.
+     */
+    EnvFieldPaths["POD_NAMESPACE"] = "metadata.namespace";
+    /**
+     * The uid of the pod.
+     */
+    EnvFieldPaths["POD_UID"] = "metadata.uid";
+    /**
+     * The labels of the pod.
+     */
+    EnvFieldPaths["POD_LABEL"] = "metadata.labels";
+    /**
+     * The annotations of the pod.
+     */
+    EnvFieldPaths["POD_ANNOTATION"] = "metadata.annotations";
+    /**
+     * The ipAddress of the pod.
+     */
+    EnvFieldPaths["POD_IP"] = "status.podIP";
+    /**
+     * The service account name of the pod.
+     */
+    EnvFieldPaths["SERVICE_ACCOUNT_NAME"] = "spec.serviceAccountName";
+    /**
+     * The name of the node.
+     */
+    EnvFieldPaths["NODE_NAME"] = "spec.nodeName";
+    /**
+     * The ipAddress of the node.
+     */
+    EnvFieldPaths["NODE_IP"] = "status.hostIP";
+    /**
+     * The ipAddresess of the pod.
+     */
+    EnvFieldPaths["POD_IPS"] = "status.podIPs";
+})(EnvFieldPaths || (exports.EnvFieldPaths = EnvFieldPaths = {}));
+var ResourceFieldPaths;
+(function (ResourceFieldPaths) {
+    /**
+     * CPU limit of the container.
+     */
+    ResourceFieldPaths["CPU_LIMIT"] = "limits.cpu";
+    /**
+     * Memory limit of the container.
+     */
+    ResourceFieldPaths["MEMORY_LIMIT"] = "limits.memory";
+    /**
+     * CPU request of the container.
+     */
+    ResourceFieldPaths["CPU_REQUEST"] = "requests.cpu";
+    /**
+     * Memory request of the container.
+     */
+    ResourceFieldPaths["MEMORY_REQUEST"] = "requests.memory";
+    /**
+     * Ephemeral storage limit of the container.
+     */
+    ResourceFieldPaths["STORAGE_LIMIT"] = "limits.ephemeral-storage";
+    /**
+     * Ephemeral storage request of the container.
+     */
+    ResourceFieldPaths["STORAGE_REQUEST"] = "requests.ephemeral-storage";
+})(ResourceFieldPaths || (exports.ResourceFieldPaths = ResourceFieldPaths = {}));
+/**
+ * Utility class for creating reading env values from various sources.
+ */
+class EnvValue {
+    value;
+    valueFrom;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.EnvValue", version: "2.0.1" };
+    /**
+     * Create a value by reading a specific key inside a config map.
+     *
+     * @param configMap - The config map.
+     * @param key - The key to extract the value from.
+     * @param options - Additional options.
+     */
+    static fromConfigMap(configMap, key, options = {}) {
+        const source = {
+            configMapKeyRef: {
+                name: configMap.name,
+                key,
+                optional: options.optional,
+            },
+        };
+        return new EnvValue(undefined, source);
+    }
+    /**
+     * Defines an environment value from a secret JSON value.
+     *
+     * @param secretValue The secret value (secrent + key)
+     * @param options Additional options
+     */
+    static fromSecretValue(secretValue, options = {}) {
+        const source = {
+            secretKeyRef: {
+                name: secretValue.secret.name,
+                key: secretValue.key,
+                optional: options.optional,
+            },
+        };
+        return new EnvValue(undefined, source);
+    }
+    /**
+     * Create a value from the given argument.
+     *
+     * @param value - The value.
+     */
+    static fromValue(value) {
+        return new EnvValue(value);
+    }
+    /**
+     *
+     * Create a value from a field reference.
+     *
+     * @param fieldPath: The field reference.
+     * @param options: Additional options.
+     */
+    static fromFieldRef(fieldPath, options = {}) {
+        let needsKey = false;
+        if (fieldPath === EnvFieldPaths.POD_LABEL || fieldPath === EnvFieldPaths.POD_ANNOTATION) {
+            needsKey = true;
+        }
+        if (needsKey && options.key === undefined) {
+            throw new Error(`${fieldPath} requires a key`);
+        }
+        const source = {
+            fieldRef: {
+                fieldPath: (`${fieldPath}` + (needsKey ? `['${options.key}']` : '')),
+                ...(options.apiVersion ? { apiVersion: options.apiVersion } : {}),
+            },
+        };
+        return new EnvValue(undefined, source);
+    }
+    /**
+     * Create a value from a resource.
+     *
+     * @param resource: Resource to select the value from.
+     * @param options: Additional options.
+     */
+    static fromResource(resource, options = {}) {
+        const source = {
+            resourceFieldRef: {
+                resource: `${resource}`,
+                ...(options.divisor ? { divisor: k8s.IntOrString.fromString(options.divisor) } : {}),
+                ...(options.container ? { containerName: options.container.name } : {}),
+            },
+        };
+        return new EnvValue(undefined, source);
+    }
+    /**
+     * Create a value from a key in the current process environment.
+     *
+     * @param key - The key to read.
+     * @param options - Additional options.
+     */
+    static fromProcess(key, options = {}) {
+        const value = process.env[key];
+        if (options.required && !value) {
+            throw new Error(`Missing ${key} env variable`);
+        }
+        return EnvValue.fromValue(value);
+    }
+    constructor(value, valueFrom) {
+        this.value = value;
+        this.valueFrom = valueFrom;
+    }
+}
+exports.EnvValue = EnvValue;
+var ImagePullPolicy;
+(function (ImagePullPolicy) {
+    /**
+     * Every time the kubelet launches a container, the kubelet queries the container image registry
+     * to resolve the name to an image digest. If the kubelet has a container image with that exact
+     * digest cached locally, the kubelet uses its cached image; otherwise, the kubelet downloads
+     * (pulls) the image with the resolved digest, and uses that image to launch the container.
+     *
+     * Default is Always if ImagePullPolicy is omitted and either the image tag is :latest or
+     * the image tag is omitted.
+     */
+    ImagePullPolicy["ALWAYS"] = "Always";
+    /**
+     * The image is pulled only if it is not already present locally.
+     *
+     * Default is IfNotPresent if ImagePullPolicy is omitted and the image tag is present but
+     * not :latest
+     */
+    ImagePullPolicy["IF_NOT_PRESENT"] = "IfNotPresent";
+    /**
+     * The image is assumed to exist locally. No attempt is made to pull the image.
+     */
+    ImagePullPolicy["NEVER"] = "Never";
+})(ImagePullPolicy || (exports.ImagePullPolicy = ImagePullPolicy = {}));
+/**
+ * RestartPolicy defines the restart behavior of individual containers in a pod.
+ * This field may only be set for init containers, and the only allowed value is "Always".
+ * For non-init containers or when this field is not specified,
+ * the restart behavior is defined by the Pod's restart policy and the container type.
+ * Setting the RestartPolicy as "Always" for the init container will have the following effect:
+ * this init container will be continually restarted on exit until all regular containers have terminated.
+ * Once all regular containers have completed, all init containers with restartPolicy "Always" will be shut down.
+ * This lifecycle differs from normal init containers and is often referred to as a "sidecar" container.
+ *
+ * @see https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/
+ */
+var ContainerRestartPolicy;
+(function (ContainerRestartPolicy) {
+    /**
+     * If an init container is created with its restartPolicy set to Always,
+     * it will start and remain running during the entire life of the Pod.
+     * For regular containers, this is ignored by Kubernetes.
+     */
+    ContainerRestartPolicy["ALWAYS"] = "Always";
+})(ContainerRestartPolicy || (exports.ContainerRestartPolicy = ContainerRestartPolicy = {}));
+/**
+ * A single application container that you want to run within a pod.
+ */
+class Container {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Container", version: "2.0.1" };
+    /**
+     * The port number that was configured for this container.
+     * If undefined, either the container doesn't expose a port, or its
+     * port configuration is stored in the `ports` field.
+     */
+    portNumber;
+    /**
+     * Volume mounts configured for this container.
+     */
+    mounts;
+    /**
+     * Image pull policy for this container
+     */
+    imagePullPolicy;
+    /**
+     * The container image.
+     */
+    image;
+    /**
+     * The name of the container.
+     */
+    name;
+    /**
+     * The working directory inside the container.
+     */
+    workingDir;
+    /**
+     * Compute resources (CPU and memory requests and limits) required by the container
+     * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     */
+    resources;
+    /**
+     * The security context of the container.
+     */
+    securityContext;
+    /**
+     * The environment of the container.
+     */
+    env;
+    /**
+     * The restart policy of the container.
+     */
+    restartPolicy;
+    _command;
+    _args;
+    _ports = [];
+    _readiness;
+    _liveness;
+    _startup;
+    _lifecycle;
+    constructor(props) {
+        if (props instanceof Container) {
+            throw new Error('Attempted to construct a container from a Container object.');
+        }
+        const defaultResourceSpec = {
+            cpu: {
+                request: Cpu.millis(1000),
+                limit: Cpu.millis(1500),
+            },
+            memory: {
+                request: cdk8s_1.Size.mebibytes(512),
+                limit: cdk8s_1.Size.mebibytes(2048),
+            },
+        };
+        if (props.port && props.portNumber) {
+            throw new Error('Either \'port\' or \'portNumber\' is allowed. Use \'portNumber\' since \'port\' is deprecated');
+        }
+        const portNumber = props.portNumber ?? props.port;
+        const defaultProbeConfiguration = probe.Probe.fromTcpSocket({ port: portNumber });
+        this.name = props.name ?? 'main';
+        this.image = props.image;
+        this.portNumber = portNumber;
+        this._command = props.command;
+        this._args = props.args;
+        this._readiness = props.readiness;
+        this._liveness = props.liveness;
+        this._startup = props.startup ?? (this.portNumber ? defaultProbeConfiguration : undefined);
+        this._lifecycle = props.lifecycle;
+        this.resources = props.resources ?? defaultResourceSpec;
+        this.workingDir = props.workingDir;
+        this.mounts = props.volumeMounts ?? [];
+        this.imagePullPolicy = props.imagePullPolicy ?? ImagePullPolicy.ALWAYS;
+        this.securityContext = new ContainerSecurityContext(props.securityContext);
+        this.env = new Env(props.envFrom ?? [], props.envVariables ?? {});
+        this.restartPolicy = props.restartPolicy;
+        if (this.portNumber) {
+            this.addPort({
+                number: this.portNumber,
+            });
+        }
+        for (const port of props.ports ?? []) {
+            this.addPort(port);
+        }
+    }
+    /**
+     * @deprecated - use `portNumber`.
+     */
+    get port() {
+        return this.portNumber;
+    }
+    /**
+     * Ports exposed by this containers.
+     * Returns a copy, use `addPort` to modify.
+     */
+    get ports() {
+        return [...this._ports];
+    }
+    /**
+     * Entrypoint array (the command to execute when the container starts).
+     * @returns a copy of the entrypoint array, cannot be modified
+     */
+    get command() {
+        return this._command ? [...this._command] : undefined;
+    }
+    /**
+     * Arguments to the entrypoint.
+     *
+     * @returns a copy of the arguments array, cannot be modified.
+     */
+    get args() {
+        return this._args ? [...this._args] : undefined;
+    }
+    /**
+     * Mount a volume to a specific path so that it is accessible by the container.
+     * Every pod that is configured to use this container will autmoatically have access to the volume.
+     *
+     * @param path - The desired path in the container.
+     * @param storage - The storage to mount.
+     */
+    mount(path, storage, options = {}) {
+        this.mounts.push({ path, volume: storage.asVolume(), ...options });
+    }
+    /**
+     * Add a port to expose from this container.
+     */
+    addPort(port) {
+        const names = this._ports.map(p => p.name).filter(x => x);
+        const numberProtocols = this._ports.map(p => `${p.number}/${p.protocol || Protocol.TCP}`);
+        if (port.name && names.includes(port.name)) {
+            throw new Error(`Port with name ${port.name} already exists`);
+        }
+        const protocol = `${port.number}/${port.protocol || Protocol.TCP}`;
+        if (numberProtocols.includes(protocol)) {
+            throw new Error(`Port with number ${port.number} and protocol ${port.protocol || Protocol.TCP} already exists`);
+        }
+        this._ports.push(port);
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const volumeMounts = [];
+        for (const mount of this.mounts) {
+            volumeMounts.push({
+                name: mount.volume.name,
+                mountPath: mount.path,
+                readOnly: mount.readOnly,
+                mountPropagation: mount.propagation,
+                subPath: mount.subPath,
+                subPathExpr: mount.subPathExpr,
+            });
+        }
+        const ports = new Array();
+        for (const port of this.ports) {
+            ports.push({
+                containerPort: port.number,
+                protocol: port.protocol?.toString(),
+                name: port.name,
+                hostPort: port.hostPort,
+                hostIp: port.hostIp,
+            });
+        }
+        // Resource requests and limits
+        const cpuLimit = this.resources?.cpu?.limit?.amount;
+        const cpuRequest = this.resources?.cpu?.request?.amount;
+        const memoryLimit = this.resources?.memory?.limit;
+        const memoryRequest = this.resources?.memory?.request;
+        const ephemeralStorageLimit = this.resources?.ephemeralStorage?.limit;
+        const ephemeralStorageRequest = this.resources?.ephemeralStorage?.request;
+        const limits = {};
+        const requests = {};
+        if (cpuLimit) {
+            limits.cpu = k8s.Quantity.fromString(cpuLimit);
+        }
+        if (memoryLimit) {
+            limits.memory = k8s.Quantity.fromString(memoryLimit.toMebibytes().toString() + 'Mi');
+        }
+        if (ephemeralStorageLimit) {
+            limits['ephemeral-storage'] = k8s.Quantity.fromString(ephemeralStorageLimit.toGibibytes().toString() + 'Gi');
+        }
+        if (cpuRequest) {
+            requests.cpu = k8s.Quantity.fromString(cpuRequest);
+        }
+        if (memoryRequest) {
+            requests.memory = k8s.Quantity.fromString(memoryRequest.toMebibytes().toString() + 'Mi');
+        }
+        if (ephemeralStorageRequest) {
+            requests['ephemeral-storage'] = k8s.Quantity.fromString(ephemeralStorageRequest.toGibibytes().toString() + 'Gi');
+        }
+        let resourceRequirements = undefined;
+        if (Object.keys(limits).length > 0 || Object.keys(requests).length > 0) {
+            resourceRequirements = {
+                limits: (0, utils_1.undefinedIfEmpty)(limits),
+                requests: (0, utils_1.undefinedIfEmpty)(requests),
+            };
+        }
+        const env = this.env._toKube();
+        return {
+            name: this.name,
+            image: this.image,
+            imagePullPolicy: this.imagePullPolicy,
+            ports: (0, utils_1.undefinedIfEmpty)(ports),
+            volumeMounts: (0, utils_1.undefinedIfEmpty)(volumeMounts),
+            command: this.command,
+            args: this.args,
+            workingDir: this.workingDir,
+            env: env.variables,
+            envFrom: env.from,
+            readinessProbe: this._readiness?._toKube(this),
+            livenessProbe: this._liveness?._toKube(this),
+            startupProbe: this._startup?._toKube(this),
+            lifecycle: this._lifecycle ? {
+                postStart: this._lifecycle.postStart?._toKube(this),
+                preStop: this._lifecycle.preStop?._toKube(this),
+            } : undefined,
+            resources: resourceRequirements,
+            restartPolicy: this.restartPolicy,
+            securityContext: this.securityContext._toKube(),
+        };
+    }
+}
+exports.Container = Container;
+var MountPropagation;
+(function (MountPropagation) {
+    /**
+     * This volume mount will not receive any subsequent mounts that are mounted
+     * to this volume or any of its subdirectories by the host. In similar
+     * fashion, no mounts created by the Container will be visible on the host.
+     *
+     * This is the default mode.
+     *
+     * This mode is equal to `private` mount propagation as described in the Linux
+     * kernel documentation
+     */
+    MountPropagation["NONE"] = "None";
+    /**
+     * This volume mount will receive all subsequent mounts that are mounted to
+     * this volume or any of its subdirectories.
+     *
+     * In other words, if the host mounts anything inside the volume mount, the
+     * Container will see it mounted there.
+     *
+     * Similarly, if any Pod with Bidirectional mount propagation to the same
+     * volume mounts anything there, the Container with HostToContainer mount
+     * propagation will see it.
+     *
+     * This mode is equal to `rslave` mount propagation as described in the Linux
+     * kernel documentation
+     */
+    MountPropagation["HOST_TO_CONTAINER"] = "HostToContainer";
+    /**
+     * This volume mount behaves the same the HostToContainer mount. In addition,
+     * all volume mounts created by the Container will be propagated back to the
+     * host and to all Containers of all Pods that use the same volume
+     *
+     * A typical use case for this mode is a Pod with a FlexVolume or CSI driver
+     * or a Pod that needs to mount something on the host using a hostPath volume.
+     *
+     * This mode is equal to `rshared` mount propagation as described in the Linux
+     * kernel documentation
+     *
+     * Caution: Bidirectional mount propagation can be dangerous. It can damage
+     * the host operating system and therefore it is allowed only in privileged
+     * Containers. Familiarity with Linux kernel behavior is strongly recommended.
+     * In addition, any volume mounts created by Containers in Pods must be
+     * destroyed (unmounted) by the Containers on termination.
+     *
+     */
+    MountPropagation["BIDIRECTIONAL"] = "Bidirectional";
+})(MountPropagation || (exports.MountPropagation = MountPropagation = {}));
+/**
+ * Represents the amount of CPU.
+ * The amount can be passed as millis or units.
+ */
+class Cpu {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Cpu", version: "2.0.1" };
+    static millis(amount) {
+        return new Cpu(amount + 'm');
+    }
+    static units(amount) {
+        return new Cpu(amount.toString());
+    }
+    amount;
+    constructor(amount) {
+        this.amount = amount;
+    }
+}
+exports.Cpu = Cpu;
+/**
+ * A collection of env variables defined in other resources.
+ */
+class EnvFrom {
+    configMap;
+    prefix;
+    sec;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.EnvFrom", version: "2.0.1" };
+    constructor(configMap, prefix, sec) {
+        this.configMap = configMap;
+        this.prefix = prefix;
+        this.sec = sec;
+    }
+    ;
+    /**
+     * @internal
+     */
+    _toKube() {
+        // a single `k8s.EnvFromSource` may only specify one of `configMapRef` / `secretRef`.
+        // if both a config map and a secret are configured on this instance, they must be
+        // rendered as separate entries, otherwise the resulting manifest is invalid.
+        const sources = new Array();
+        if (this.configMap) {
+            sources.push({
+                configMapRef: { name: this.configMap.name },
+                prefix: this.prefix,
+            });
+        }
+        if (this.sec) {
+            sources.push({
+                secretRef: { name: this.sec.name },
+                prefix: this.prefix,
+            });
+        }
+        return sources;
+    }
+}
+exports.EnvFrom = EnvFrom;
+function extractContainerPorts(selector) {
+    if (!selector) {
+        return [];
+    }
+    // we don't use instanceof intentionally since it can create
+    // cyclic import problems.
+    const containers = selector.containers ?? [];
+    return containers.flatMap(c => c.ports);
+}
+/**
+ * Container environment variables.
+ */
+class Env {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Env", version: "2.0.1" };
+    /**
+     * Selects a ConfigMap to populate the environment variables with.
+     * The contents of the target ConfigMap's Data field will represent
+     * the key-value pairs as environment variables.
+     */
+    static fromConfigMap(configMap, prefix) {
+        return new EnvFrom(configMap, prefix, undefined);
+    }
+    /**
+     * Selects a Secret to populate the environment variables with.
+     * The contents of the target Secret's Data field will represent
+     * the key-value pairs as environment variables.
+     */
+    static fromSecret(secr) {
+        return new EnvFrom(undefined, undefined, secr);
+    }
+    _sources;
+    _variables;
+    constructor(sources, variables) {
+        this._sources = sources;
+        this._variables = variables;
+    }
+    /**
+     * Add a single variable by name and value.
+     * The variable value can come from various dynamic sources such a secrets of config maps.
+     * Use `EnvValue.fromXXX` to select sources.
+     */
+    addVariable(name, value) {
+        this._variables[name] = value;
+    }
+    /**
+     * The environment variables for this container.
+     * Returns a copy. To add environment variables use `container.env.addVariable()`.
+     */
+    get variables() {
+        return { ...this._variables };
+    }
+    /**
+     * Add a collection of variables by copying from another source.
+     * Use `Env.fromXXX` functions to select sources.
+     */
+    copyFrom(from) {
+        this._sources.push(from);
+    }
+    /**
+     * The list of sources used to populate the container environment,
+     * in addition to the `variables`.
+     *
+     * Returns a copy. To add a source use `container.env.copyFrom()`.
+     */
+    get sources() {
+        return [...this._sources];
+    }
+    renderEnv(env) {
+        const result = new Array();
+        for (const [name, v] of Object.entries(env)) {
+            result.push({
+                name,
+                value: v.value,
+                valueFrom: v.valueFrom,
+            });
+        }
+        return result;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            from: (0, utils_1.undefinedIfEmpty)(this._sources.flatMap(s => s._toKube())),
+            variables: (0, utils_1.undefinedIfEmpty)(this.renderEnv(this._variables)),
+        };
+    }
+}
+exports.Env = Env;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.js","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size } from 'cdk8s';\nimport * as configmap from './config-map';\nimport * as handler from './handler';\nimport * as k8s from './imports/k8s';\nimport * as probe from './probe';\nimport * as secret from './secret';\nimport { undefinedIfEmpty } from './utils';\nimport * as volume from './volume';\n\n/**\n * Capability - complete list of POSIX capabilities\n */\nexport enum Capability {\n  /**\n   * ALL\n   */\n  ALL = 'ALL',\n  /**\n   * CAP_AUDIT_CONTROL\n   */\n  AUDIT_CONTROL = 'AUDIT_CONTROL',\n  /**\n   * CAP_AUDIT_READ\n   */\n  AUDIT_READ = 'AUDIT_READ',\n  /**\n   * CAP_AUDIT_WRITE\n   */\n  AUDIT_WRITE = 'AUDIT_WRITE',\n  /**\n   * CAP_BLOCK_SUSPEND\n   */\n  BLOCK_SUSPEND = 'BLOCK_SUSPEND',\n  /**\n   * CAP_BPF\n   */\n  BPF = 'BPF',\n  /**\n   * CAP_CHECKPOINT_RESTORE\n   */\n  CHECKPOINT_RESTORE = 'CHECKPOINT_RESTORE',\n  /**\n   * CAP_CHOWN\n   */\n  CHOWN = 'CHOWN',\n  /**\n   * CAP_DAC_OVERRIDE\n   */\n  DAC_OVERRIDE = 'DAC_OVERRIDE',\n  /**\n   * CAP_DAC_READ_SEARCH\n   */\n  DAC_READ_SEARCH = 'DAC_READ_SEARCH',\n  /**\n   * CAP_FOWNER\n   */\n  FOWNER = 'FOWNER',\n  /**\n   * CAP_FSETID\n   */\n  FSETID = 'FSETID',\n  /**\n   * CAP_IPC_LOCK\n   */\n  IPC_LOCK = 'IPC_LOCK',\n  /**\n   * CAP_IPC_OWNER\n   */\n  IPC_OWNER = 'IPC_OWNER',\n  /**\n   * CAP_KILL\n   */\n  KILL = 'KILL',\n  /**\n   * CAP_LEASE\n   */\n  LEASE = 'LEASE',\n  /**\n   * CAP_LINUX_IMMUTABLE\n   */\n  LINUX_IMMUTABLE = 'LINUX_IMMUTABLE',\n  /**\n   * CAP_MAC_ADMIN\n   */\n  MAC_ADMIN = 'MAC_ADMIN',\n  /**\n   * CAP_MAC_OVERRIDE\n   */\n  MAC_OVERRIDE = 'MAC_OVERRIDE',\n  /**\n   * CAP_MKNOD\n   */\n  MKNOD = 'MKNOD',\n  /**\n   * CAP_NET_ADMIN\n   */\n  NET_ADMIN = 'NET_ADMIN',\n  /**\n   * CAP_NET_BIND_SERVICE\n   */\n  NET_BIND_SERVICE = 'NET_BIND_SERVICE',\n  /**\n   * CAP_NET_BROADCAST\n   */\n  NET_BROADCAST = 'NET_BROADCAST',\n  /**\n   * CAP_NET_RAW\n   */\n  NET_RAW = 'NET_RAW',\n  /**\n   * CAP_PERFMON\n   */\n  PERFMON = 'PERFMON',\n  /**\n   * CAP_SETGID\n   */\n  SETGID = 'SETGID',\n  /**\n   * CAP_SETFCAP\n   */\n  SETFCAP = 'SETFCAP',\n  /**\n   * CAP_SETPCAP\n   */\n  SETPCAP = 'SETPCAP',\n  /**\n   * CAP_SETUID\n   */\n  SETUID = 'SETUID',\n  /**\n   * CAP_SYS_ADMIN\n   */\n  SYS_ADMIN = 'SYS_ADMIN',\n  /**\n   * CAP_SYS_BOOT\n   */\n  SYS_BOOT = 'SYS_BOOT',\n  /**\n   * CAP_SYS_CHROOT\n   */\n  SYS_CHROOT = 'SYS_CHROOT',\n  /**\n   * CAP_SYS_MODULE\n   */\n  SYS_MODULE = 'SYS_MODULE',\n  /**\n   * CAP_SYS_NICE\n   */\n  SYS_NICE = 'SYS_NICE',\n  /**\n   * CAP_SYS_PACCT\n   */\n  SYS_PACCT = 'SYS_PACCT',\n  /**\n   * CAP_SYS_PTRACE\n   */\n  SYS_PTRACE = 'SYS_PTRACE',\n  /**\n   * CAP_SYS_RAWIO\n   */\n  SYS_RAWIO = 'SYS_RAWIO',\n  /**\n   * CAP_SYS_RESOURCE\n   */\n  SYS_RESOURCE = 'SYS_RESOURCE',\n  /**\n   * CAP_SYS_TIME\n   */\n  SYS_TIME = 'SYS_TIME',\n  /**\n   * CAP_SYS_TTY_CONFIG\n   */\n  SYS_TTY_CONFIG = 'SYS_TTY_CONFIG',\n  /**\n   * CAP_SYSLOG\n   */\n  SYSLOG = 'SYSLOG',\n  /**\n   * CAP_WAKE_ALARM\n   */\n  WAKE_ALARM = 'WAKE_ALARM',\n}\n\nexport enum SeccompProfileType {\n  /**\n  * A profile defined in a file on the node should be used\n  */\n  LOCALHOST = 'Localhost',\n  /**\n  * The container runtime default profile should be used\n  */\n  RUNTIME_DEFAULT = 'RuntimeDefault',\n  /**\n  * No profile should be applied\n  */\n  UNCONFINED = 'Unconfined',\n}\n\nexport interface SeccompProfile {\n  /**\n   * localhostProfile indicates a profile defined in a file on the node should be used.\n   * The profile must be preconfigured on the node to work. Must be a descending path,\n   * relative to the kubelet's configured seccomp profile location.\n   * Must only be set if type is \"Localhost\".\n   *\n   * @default - empty string\n   */\n  readonly localhostProfile?: string;\n  /**\n   * Indicates which kind of seccomp profile will be applied\n   */\n  readonly type: SeccompProfileType;\n}\n\nexport interface ContainerSecutiryContextCapabilities {\n  /**\n   * Added capabilities\n   */\n  readonly add?: Capability[];\n\n  /**\n   * Removed capabilities\n   */\n  readonly drop?: Capability[];\n}\n\n/**\n * Properties for `ContainerSecurityContext`\n */\nexport interface ContainerSecurityContextProps {\n\n  /**\n    * The UID to run the entrypoint of the container process.\n    *\n    * @default - 25000. An arbitrary number bigger than 9999 is selected here.\n    * This is so that the container is blocked to access host files even if\n    * somehow it manages to get access to host file system.\n    */\n  readonly user?: number;\n\n  /**\n    * The GID to run the entrypoint of the container process.\n    *\n    * @default - 26000. An arbitrary number bigger than 9999 is selected here.\n    * This is so that the container is blocked to access host files even if\n    * somehow it manages to get access to host file system.\n    */\n  readonly group?: number;\n\n  /**\n    * Indicates that the container must run as a non-root user.\n    * If true, the Kubelet will validate the image at runtime to ensure that it does\n    * not run as UID 0 (root) and fail to start the container if it does.\n    *\n    * @default true\n    */\n  readonly ensureNonRoot?: boolean;\n\n  /**\n   * Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host.\n   *\n   * @default false\n   */\n  readonly privileged?: boolean;\n\n  /**\n   * Whether this container has a read-only root filesystem.\n   *\n   * @default true\n   */\n  readonly readOnlyRootFilesystem?: boolean;\n\n  /**\n   * Whether a process can gain more privileges than its parent process.\n   *\n   * @default false\n   */\n  readonly allowPrivilegeEscalation?: boolean;\n\n  /**\n   * POSIX capabilities for running containers\n   *\n   * @default none\n   */\n  readonly capabilities?: ContainerSecutiryContextCapabilities;\n\n  /**\n  * Container's seccomp profile settings. Only one profile source may be set\n  *\n  * @default none\n  */\n  readonly seccompProfile?: SeccompProfile;\n}\n\n/**\n * Represents a network port in a single container.\n */\nexport interface ContainerPort {\n\n  /**\n   * Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.\n   */\n  readonly number: number;\n\n  /**\n   * What host IP to bind the external port to.\n   *\n   * @default - 127.0.0.1.\n   */\n  readonly hostIp?: string;\n\n  /**\n   * Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536.\n   * Most containers do not need this.\n   *\n   * @default - auto generated by kubernetes and might change on restarts.\n   */\n  readonly hostPort?: number;\n\n  /**\n   * If specified, this must be an IANA_SVC_NAME and unique within the pod.\n   * Each named port in a pod must have a unique name.\n   * Name for the port that can be referred to by services.\n   *\n   * @default - port is not named.\n   */\n  readonly name?: string;\n\n  /**\n   * Protocol for port. Must be UDP, TCP, or SCTP. Defaults to \"TCP\".\n   *\n   * @default Protocol.TCP\n   */\n  readonly protocol?: Protocol;\n\n}\n\n/**\n * Network protocols.\n */\nexport enum Protocol {\n\n  /**\n   * TCP.\n   */\n  TCP = 'TCP',\n\n  /**\n   * UDP.\n   */\n  UDP = 'UDP',\n\n  /**\n   * SCTP.\n   */\n  SCTP = 'SCTP',\n}\n\n\n/**\n * Container security attributes and settings.\n */\nexport class ContainerSecurityContext {\n\n  public readonly ensureNonRoot: boolean;\n  public readonly privileged: boolean;\n  public readonly readOnlyRootFilesystem: boolean;\n  public readonly user?: number;\n  public readonly group?: number;\n  public readonly allowPrivilegeEscalation?: boolean;\n  public readonly capabilities?: ContainerSecutiryContextCapabilities;\n  public readonly seccompProfile?: SeccompProfile;\n\n  constructor(props: ContainerSecurityContextProps = {}) {\n    if (props.seccompProfile?.localhostProfile && props.seccompProfile.type != SeccompProfileType.LOCALHOST) {\n      throw new Error('localhostProfile must only be set if type is \"Localhost\"');\n    }\n    this.ensureNonRoot = props.ensureNonRoot ?? true;\n    this.privileged = props.privileged ?? false;\n    this.readOnlyRootFilesystem = props.readOnlyRootFilesystem ?? true;\n    this.user = props.user;\n    this.group = props.group;\n    this.allowPrivilegeEscalation = props.allowPrivilegeEscalation ?? false;\n    this.capabilities = props.capabilities;\n    this.seccompProfile = props.seccompProfile;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.SecurityContext {\n    return {\n      runAsGroup: this.group,\n      runAsUser: this.user,\n      runAsNonRoot: this.ensureNonRoot,\n      privileged: this.privileged,\n      readOnlyRootFilesystem: this.readOnlyRootFilesystem,\n      allowPrivilegeEscalation: this.allowPrivilegeEscalation,\n      capabilities: this.capabilities,\n      seccompProfile: this.seccompProfile,\n    };\n  }\n\n}\n\nexport enum EnvFieldPaths {\n  /**\n   * The name of the pod.\n   */\n  POD_NAME = 'metadata.name',\n\n  /**\n   * The namespace of the pod.\n   */\n  POD_NAMESPACE = 'metadata.namespace',\n\n  /**\n   * The uid of the pod.\n   */\n  POD_UID = 'metadata.uid',\n\n  /**\n   * The labels of the pod.\n   */\n  POD_LABEL = 'metadata.labels',\n\n  /**\n   * The annotations of the pod.\n   */\n  POD_ANNOTATION = 'metadata.annotations',\n\n  /**\n   * The ipAddress of the pod.\n   */\n  POD_IP = 'status.podIP',\n\n  /**\n   * The service account name of the pod.\n   */\n  SERVICE_ACCOUNT_NAME = 'spec.serviceAccountName',\n\n  /**\n   * The name of the node.\n   */\n  NODE_NAME = 'spec.nodeName',\n\n  /**\n   * The ipAddress of the node.\n   */\n  NODE_IP = 'status.hostIP',\n\n  /**\n   * The ipAddresess of the pod.\n   */\n  POD_IPS = 'status.podIPs',\n}\n\nexport enum ResourceFieldPaths {\n  /**\n   * CPU limit of the container.\n   */\n  CPU_LIMIT = 'limits.cpu',\n\n  /**\n   * Memory limit of the container.\n   */\n  MEMORY_LIMIT = 'limits.memory',\n\n  /**\n   * CPU request of the container.\n   */\n  CPU_REQUEST = 'requests.cpu',\n\n  /**\n   * Memory request of the container.\n   */\n  MEMORY_REQUEST = 'requests.memory',\n\n  /**\n   * Ephemeral storage limit of the container.\n   */\n  STORAGE_LIMIT = 'limits.ephemeral-storage',\n\n  /**\n   * Ephemeral storage request of the container.\n   */\n  STORAGE_REQUEST = 'requests.ephemeral-storage',\n}\n\n/**\n * Options to specify an envionment variable value from a ConfigMap key.\n */\nexport interface EnvValueFromConfigMapOptions {\n\n  /**\n   * Specify whether the ConfigMap or its key must be defined.\n   *\n   * @default false\n   */\n  readonly optional?: boolean;\n}\n\n/**\n * Options to specify an environment variable value from a Secret.\n */\nexport interface EnvValueFromSecretOptions {\n\n  /**\n   * Specify whether the Secret or its key must be defined.\n   *\n   * @default false\n   */\n  readonly optional?: boolean;\n\n}\n\n/**\n * Options to specify an environment variable value from the process environment.\n */\nexport interface EnvValueFromProcessOptions {\n\n  /**\n   * Specify whether the key must exist in the environment.\n   * If this is set to true, and the key does not exist, an error will thrown.\n   *\n   * @default false\n   */\n  readonly required?: boolean;\n}\n\n/**\n * Options to specify an environment variable value from a field reference.\n */\nexport interface EnvValueFromFieldRefOptions {\n  /**\n   * Version of the schema the FieldPath is written in terms of.\n   */\n  readonly apiVersion?: string;\n\n  /**\n   * The key to select the pod label or annotation.\n   */\n  readonly key?: string;\n}\n\n/**\n * Options to specify an environment variable value from a resource.\n */\nexport interface EnvValueFromResourceOptions {\n  /**\n   * The container to select the value from.\n   */\n  readonly container?: Container;\n\n  /**\n   * The output format of the exposed resource.\n   */\n  readonly divisor?: string;\n}\n\n/**\n * Utility class for creating reading env values from various sources.\n */\nexport class EnvValue {\n\n  /**\n   * Create a value by reading a specific key inside a config map.\n   *\n   * @param configMap - The config map.\n   * @param key - The key to extract the value from.\n   * @param options - Additional options.\n   */\n  public static fromConfigMap(configMap: configmap.IConfigMap, key: string, options: EnvValueFromConfigMapOptions = {}): EnvValue {\n\n    const source: k8s.EnvVarSource = {\n      configMapKeyRef: {\n        name: configMap.name,\n        key,\n        optional: options.optional,\n      },\n    };\n    return new EnvValue(undefined, source);\n  }\n\n  /**\n   * Defines an environment value from a secret JSON value.\n   *\n   * @param secretValue The secret value (secrent + key)\n   * @param options Additional options\n   */\n  public static fromSecretValue(secretValue: secret.SecretValue, options: EnvValueFromSecretOptions = {}): EnvValue {\n    const source: k8s.EnvVarSource = {\n      secretKeyRef: {\n        name: secretValue.secret.name,\n        key: secretValue.key,\n        optional: options.optional,\n      },\n    };\n\n    return new EnvValue(undefined, source);\n  }\n\n  /**\n   * Create a value from the given argument.\n   *\n   * @param value - The value.\n   */\n  public static fromValue(value: string): EnvValue {\n    return new EnvValue(value);\n  }\n\n  /**\n   *\n   * Create a value from a field reference.\n   *\n   * @param fieldPath: The field reference.\n   * @param options: Additional options.\n   */\n  public static fromFieldRef(fieldPath: EnvFieldPaths, options: EnvValueFromFieldRefOptions = {}): EnvValue {\n    let needsKey: boolean = false;\n\n    if (fieldPath === EnvFieldPaths.POD_LABEL || fieldPath === EnvFieldPaths.POD_ANNOTATION) {\n      needsKey = true;\n    }\n\n    if (needsKey && options.key === undefined) {\n      throw new Error(`${fieldPath} requires a key`);\n    }\n\n    const source: k8s.EnvVarSource = {\n      fieldRef: {\n        fieldPath: (`${fieldPath}` + (needsKey ? `['${options.key}']` : '')),\n        ...(options.apiVersion ? { apiVersion: options.apiVersion } : {}),\n      },\n    };\n\n    return new EnvValue(undefined, source);\n  }\n\n  /**\n   * Create a value from a resource.\n   *\n   * @param resource: Resource to select the value from.\n   * @param options: Additional options.\n   */\n  public static fromResource(resource: ResourceFieldPaths, options: EnvValueFromResourceOptions = {}): EnvValue {\n    const source: k8s.EnvVarSource = {\n      resourceFieldRef: {\n        resource: `${resource}`,\n        ... (options.divisor ? { divisor: k8s.IntOrString.fromString(options.divisor) } : {}),\n        ... (options.container ? { containerName: options.container.name } : {}),\n      },\n    };\n\n    return new EnvValue(undefined, source);\n  }\n\n  /**\n   * Create a value from a key in the current process environment.\n   *\n   * @param key - The key to read.\n   * @param options - Additional options.\n   */\n  public static fromProcess(key: string, options: EnvValueFromProcessOptions = {}): EnvValue {\n\n    const value = process.env[key];\n\n    if (options.required && !value) {\n      throw new Error(`Missing ${key} env variable`);\n    }\n\n    return EnvValue.fromValue(value!);\n  }\n\n  private constructor(public readonly value?: any, public readonly valueFrom?: any) { }\n}\n\nexport enum ImagePullPolicy {\n  /**\n   * Every time the kubelet launches a container, the kubelet queries the container image registry\n   * to resolve the name to an image digest. If the kubelet has a container image with that exact\n   * digest cached locally, the kubelet uses its cached image; otherwise, the kubelet downloads\n   * (pulls) the image with the resolved digest, and uses that image to launch the container.\n   *\n   * Default is Always if ImagePullPolicy is omitted and either the image tag is :latest or\n   * the image tag is omitted.\n   */\n  ALWAYS = 'Always',\n\n  /**\n   * The image is pulled only if it is not already present locally.\n   *\n   * Default is IfNotPresent if ImagePullPolicy is omitted and the image tag is present but\n   * not :latest\n   */\n  IF_NOT_PRESENT = 'IfNotPresent',\n\n  /**\n   * The image is assumed to exist locally. No attempt is made to pull the image.\n   */\n  NEVER = 'Never',\n}\n\n/**\n * Container lifecycle properties.\n */\nexport interface ContainerLifecycle {\n\n  /**\n   * This hook is executed immediately after a container is created. However,\n   * there is no guarantee that the hook will execute before the container ENTRYPOINT.\n   *\n   * @default - No post start handler.\n   */\n  readonly postStart?: handler.Handler;\n\n  /**\n   * This hook is called immediately before a container is terminated due to an API request or management\n   * event such as a liveness/startup probe failure, preemption, resource contention and others.\n   * A call to the PreStop hook fails if the container is already in a terminated or completed state\n   * and the hook must complete before the TERM signal to stop the container can be sent.\n   * The Pod's termination grace period countdown begins before the PreStop hook is executed,\n   * so regardless of the outcome of the handler, the container will eventually terminate\n   * within the Pod's termination grace period. No parameters are passed to the handler.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination\n   *\n   * @default - No pre stop handler.\n   */\n  readonly preStop?: handler.Handler;\n\n}\n\n/**\n * RestartPolicy defines the restart behavior of individual containers in a pod.\n * This field may only be set for init containers, and the only allowed value is \"Always\".\n * For non-init containers or when this field is not specified,\n * the restart behavior is defined by the Pod's restart policy and the container type.\n * Setting the RestartPolicy as \"Always\" for the init container will have the following effect:\n * this init container will be continually restarted on exit until all regular containers have terminated.\n * Once all regular containers have completed, all init containers with restartPolicy \"Always\" will be shut down.\n * This lifecycle differs from normal init containers and is often referred to as a \"sidecar\" container.\n *\n * @see https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/\n */\nexport enum ContainerRestartPolicy {\n\n  /**\n   * If an init container is created with its restartPolicy set to Always,\n   * it will start and remain running during the entire life of the Pod.\n   * For regular containers, this is ignored by Kubernetes.\n   */\n  ALWAYS = 'Always',\n}\n/**\n * Properties for creating a container.\n */\nexport interface ContainerProps extends ContainerOpts {\n\n  /**\n   * Docker image name.\n   */\n  readonly image: string;\n}\n\n/**\n * Optional properties of a container.\n */\nexport interface ContainerOpts {\n  /**\n   * Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated.\n   *\n   * @default 'main'\n   */\n  readonly name?: string;\n\n  /**\n   * @deprecated - use `portNumber`.\n   */\n  readonly port?: number;\n\n  /**\n   * Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536.\n   *\n   * This is a convinience property if all you need a single TCP numbered port.\n   * In case more advanced configuartion is required, use the `ports` property.\n   *\n   * This port is added to the list of ports mentioned in the `ports` property.\n   *\n   * @default - Only the ports mentiond in the `ports` property are exposed.\n   */\n  readonly portNumber?: number;\n\n  /**\n   * List of ports to expose from this container.\n   *\n   * @default - Only the port mentioned in the `portNumber` property is exposed.\n   */\n  readonly ports?: ContainerPort[];\n\n  /**\n   * Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment.\n   * If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME).\n   * Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated.\n   * More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\n   *\n   * @default - The docker image's ENTRYPOINT.\n   */\n  readonly command?: string[];\n\n  /**\n   * Arguments to the entrypoint. The docker image's CMD is used if `command` is\n   * not provided.\n   *\n   * Variable references $(VAR_NAME) are expanded using the container's\n   * environment. If a variable cannot be resolved, the reference in the input\n   * string will be unchanged. The $(VAR_NAME) syntax can be escaped with a\n   * double $$, ie: $$(VAR_NAME). Escaped references will never be expanded,\n   * regardless of whether the variable exists or not.\n   *\n   * Cannot be updated.\n   *\n   * @see https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell\n   * @default []\n   */\n  readonly args?: string[];\n\n  /**\n   * Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated.\n   *\n   * @default - The container runtime's default.\n   */\n  readonly workingDir?: string;\n\n  /**\n   * Environment variables to set in the container.\n   *\n   * @default - No environment variables.\n   */\n  readonly envVariables?: { [name: string]: EnvValue };\n\n  /**\n   * List of sources to populate environment variables in the container.\n   * When a key exists in multiple sources, the value associated with\n   * the last source will take precedence. Values defined by the `envVariables` property\n   * with a duplicate key will take precedence.\n   *\n   * @default - No sources.\n   */\n  readonly envFrom?: EnvFrom[];\n\n  /**\n   * Pod volumes to mount into the container's filesystem. Cannot be updated.\n   */\n  readonly volumeMounts?: VolumeMount[];\n\n  /**\n   * Image pull policy for this container\n   * @default ImagePullPolicy.ALWAYS\n   */\n  readonly imagePullPolicy?: ImagePullPolicy;\n\n  /**\n   * Determines when the container is ready to serve traffic.\n   *\n   * @default - no readiness probe is defined\n   */\n  readonly readiness?: probe.Probe;\n\n  /**\n   * Periodic probe of container liveness. Container will be restarted if the probe fails.\n   *\n   * @default - no liveness probe is defined\n   */\n  readonly liveness?: probe.Probe;\n\n  /**\n   * StartupProbe indicates that the Pod has successfully initialized.\n   * If specified, no other probes are executed until this completes successfully\n   *\n   * @default - If a port is provided, then knocks on that port\n   * to determine when the container is ready for readiness and\n   * liveness probe checks.\n   * Otherwise, no startup probe is defined.\n   */\n  readonly startup?: probe.Probe;\n\n  /**\n   * Describes actions that the management system should take in response to container lifecycle events.\n   */\n  readonly lifecycle?: ContainerLifecycle;\n\n  /**\n   * Compute resources (CPU and memory requests and limits) required by the container\n   * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\n   *\n   * @default\n   *    cpu:\n   *      request: 1000 millis\n   *      limit: 1500 millis\n   *    memory:\n   *      request: 512 mebibytes\n   *      limit: 2048 mebibytes\n   */\n  readonly resources?: ContainerResources;\n\n  /**\n   * SecurityContext defines the security options the container should be run with.\n   * If set, the fields override equivalent fields of the pod's security context.\n   *\n   * @see https://kubernetes.io/docs/tasks/configure-pod-container/security-context/\n   * @default\n   *\n   *   ensureNonRoot: true\n   *   privileged: false\n   *   readOnlyRootFilesystem: true\n   *   allowPrivilegeEscalation: false\n   *   user: 25000\n   *   group: 26000\n   */\n  readonly securityContext?: ContainerSecurityContextProps;\n\n  /**\n   * Kubelet will start init containers with restartPolicy=Always in the order with other init containers,\n   * but instead of waiting for its completion, it will wait for the container startup completion\n   * Currently, only accepted value is Always\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/\n   * @default - no restart policy is defined and the pod restart policy is applied\n   */\n  readonly restartPolicy?: ContainerRestartPolicy;\n}\n\n/**\n * A single application container that you want to run within a pod.\n */\nexport class Container {\n\n  /**\n   * The port number that was configured for this container.\n   * If undefined, either the container doesn't expose a port, or its\n   * port configuration is stored in the `ports` field.\n   */\n  public readonly portNumber?: number;\n\n  /**\n   * Volume mounts configured for this container.\n   */\n  public readonly mounts: VolumeMount[];\n\n  /**\n   * Image pull policy for this container\n   */\n  public readonly imagePullPolicy: ImagePullPolicy;\n\n  /**\n   * The container image.\n   */\n  public readonly image: string;\n\n  /**\n   * The name of the container.\n   */\n  public readonly name: string;\n\n  /**\n   * The working directory inside the container.\n   */\n  public readonly workingDir?: string;\n\n  /**\n   * Compute resources (CPU and memory requests and limits) required by the container\n   * @see https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/\n   */\n  public readonly resources?: ContainerResources;\n\n  /**\n   * The security context of the container.\n   */\n  public readonly securityContext: ContainerSecurityContext;\n\n  /**\n   * The environment of the container.\n   */\n  public readonly env: Env;\n\n  /**\n   * The restart policy of the container.\n   */\n  public readonly restartPolicy?: ContainerRestartPolicy;\n\n  private readonly _command?: readonly string[];\n  private readonly _args?: readonly string[];\n  private readonly _ports: ContainerPort[] = [];\n  private readonly _readiness?: probe.Probe;\n  private readonly _liveness?: probe.Probe;\n  private readonly _startup?: probe.Probe;\n  private readonly _lifecycle?: ContainerLifecycle;\n\n  constructor(props: ContainerProps) {\n    if (props instanceof Container) {\n      throw new Error('Attempted to construct a container from a Container object.');\n    }\n\n    const defaultResourceSpec: ContainerResources = {\n      cpu: {\n        request: Cpu.millis(1000),\n        limit: Cpu.millis(1500),\n      },\n      memory: {\n        request: Size.mebibytes(512),\n        limit: Size.mebibytes(2048),\n      },\n    };\n\n    if (props.port && props.portNumber) {\n      throw new Error('Either \\'port\\' or \\'portNumber\\' is allowed. Use \\'portNumber\\' since \\'port\\' is deprecated');\n    }\n\n    const portNumber = props.portNumber ?? props.port;\n    const defaultProbeConfiguration: probe.Probe = probe.Probe.fromTcpSocket({ port: portNumber });\n\n    this.name = props.name ?? 'main';\n    this.image = props.image;\n    this.portNumber = portNumber;\n    this._command = props.command;\n    this._args = props.args;\n    this._readiness = props.readiness;\n    this._liveness = props.liveness;\n    this._startup = props.startup ?? (this.portNumber ? defaultProbeConfiguration : undefined);\n    this._lifecycle = props.lifecycle;\n    this.resources = props.resources ?? defaultResourceSpec;\n    this.workingDir = props.workingDir;\n    this.mounts = props.volumeMounts ?? [];\n    this.imagePullPolicy = props.imagePullPolicy ?? ImagePullPolicy.ALWAYS;\n    this.securityContext = new ContainerSecurityContext(props.securityContext);\n    this.env = new Env(props.envFrom ?? [], props.envVariables ?? {});\n    this.restartPolicy = props.restartPolicy;\n\n    if (this.portNumber) {\n      this.addPort({\n        number: this.portNumber,\n      });\n    }\n\n    for (const port of props.ports ?? []) {\n      this.addPort(port);\n    }\n  }\n\n  /**\n   * @deprecated - use `portNumber`.\n   */\n  public get port(): number | undefined {\n    return this.portNumber;\n  }\n\n  /**\n   * Ports exposed by this containers.\n   * Returns a copy, use `addPort` to modify.\n   */\n  public get ports(): ContainerPort[] {\n    return [...this._ports];\n  }\n\n  /**\n   * Entrypoint array (the command to execute when the container starts).\n   * @returns a copy of the entrypoint array, cannot be modified\n   */\n  public get command(): string[] | undefined {\n    return this._command ? [...this._command] : undefined;\n  }\n\n  /**\n   * Arguments to the entrypoint.\n   *\n   * @returns a copy of the arguments array, cannot be modified.\n   */\n  public get args(): string[] | undefined {\n    return this._args ? [...this._args] : undefined;\n  }\n\n  /**\n   * Mount a volume to a specific path so that it is accessible by the container.\n   * Every pod that is configured to use this container will autmoatically have access to the volume.\n   *\n   * @param path - The desired path in the container.\n   * @param storage - The storage to mount.\n   */\n  public mount(path: string, storage: volume.IStorage, options: MountOptions = {}) {\n    this.mounts.push({ path, volume: storage.asVolume(), ...options });\n  }\n\n  /**\n   * Add a port to expose from this container.\n   */\n  public addPort(port: ContainerPort) {\n\n    const names = this._ports.map(p => p.name).filter(x => x);\n    const numberProtocols = this._ports.map(p => `${p.number}/${p.protocol || Protocol.TCP}`);\n\n    if (port.name && names.includes(port.name)) {\n      throw new Error(`Port with name ${port.name} already exists`);\n    }\n\n    const protocol = `${port.number}/${port.protocol || Protocol.TCP}`;\n    if (numberProtocols.includes(protocol)) {\n      throw new Error(`Port with number ${port.number} and protocol ${port.protocol || Protocol.TCP} already exists`);\n    }\n\n    this._ports.push(port);\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.Container {\n    const volumeMounts: k8s.VolumeMount[] = [];\n\n    for (const mount of this.mounts) {\n      volumeMounts.push({\n        name: mount.volume.name,\n        mountPath: mount.path,\n        readOnly: mount.readOnly,\n        mountPropagation: mount.propagation,\n        subPath: mount.subPath,\n        subPathExpr: mount.subPathExpr,\n      });\n    }\n\n    const ports = new Array<k8s.ContainerPort>();\n\n    for (const port of this.ports) {\n      ports.push({\n        containerPort: port.number,\n        protocol: port.protocol?.toString(),\n        name: port.name,\n        hostPort: port.hostPort,\n        hostIp: port.hostIp,\n      });\n    }\n\n    // Resource requests and limits\n    const cpuLimit = this.resources?.cpu?.limit?.amount;\n    const cpuRequest = this.resources?.cpu?.request?.amount;\n    const memoryLimit = this.resources?.memory?.limit;\n    const memoryRequest = this.resources?.memory?.request;\n    const ephemeralStorageLimit = this.resources?.ephemeralStorage?.limit;\n    const ephemeralStorageRequest = this.resources?.ephemeralStorage?.request;\n\n    const limits: { [key: string]: k8s.Quantity } = {};\n    const requests: { [key: string]: k8s.Quantity } = {};\n\n    if (cpuLimit) {\n      limits.cpu = k8s.Quantity.fromString(cpuLimit);\n    }\n    if (memoryLimit) {\n      limits.memory = k8s.Quantity.fromString(memoryLimit.toMebibytes().toString() + 'Mi');\n    }\n    if (ephemeralStorageLimit) {\n      limits['ephemeral-storage'] = k8s.Quantity.fromString(ephemeralStorageLimit.toGibibytes().toString() + 'Gi');\n    }\n    if (cpuRequest) {\n      requests.cpu = k8s.Quantity.fromString(cpuRequest);\n    }\n    if (memoryRequest) {\n      requests.memory = k8s.Quantity.fromString(memoryRequest.toMebibytes().toString() + 'Mi');\n    }\n    if (ephemeralStorageRequest) {\n      requests['ephemeral-storage'] = k8s.Quantity.fromString(ephemeralStorageRequest.toGibibytes().toString() + 'Gi');\n    }\n\n    let resourceRequirements: k8s.ResourceRequirements | undefined = undefined;\n    if (Object.keys(limits).length > 0 || Object.keys(requests).length > 0) {\n      resourceRequirements = {\n        limits: undefinedIfEmpty(limits),\n        requests: undefinedIfEmpty(requests),\n      };\n    }\n\n    const env = this.env._toKube();\n\n    return {\n      name: this.name,\n      image: this.image,\n      imagePullPolicy: this.imagePullPolicy,\n      ports: undefinedIfEmpty(ports),\n      volumeMounts: undefinedIfEmpty(volumeMounts),\n      command: this.command,\n      args: this.args,\n      workingDir: this.workingDir,\n      env: env.variables,\n      envFrom: env.from,\n      readinessProbe: this._readiness?._toKube(this),\n      livenessProbe: this._liveness?._toKube(this),\n      startupProbe: this._startup?._toKube(this),\n      lifecycle: this._lifecycle ? {\n        postStart: this._lifecycle.postStart?._toKube(this),\n        preStop: this._lifecycle.preStop?._toKube(this),\n      } : undefined,\n      resources: resourceRequirements,\n      restartPolicy: this.restartPolicy,\n      securityContext: this.securityContext._toKube(),\n    };\n  }\n}\n\n/**\n * Options for mounts.\n */\nexport interface MountOptions {\n  /**\n   * Determines how mounts are propagated from the host to container and the\n   * other way around. When not set, MountPropagationNone is used.\n   *\n   * Mount propagation allows for sharing volumes mounted by a Container to\n   * other Containers in the same Pod, or even to other Pods on the same node.\n   *\n   * @default MountPropagation.NONE\n   */\n  readonly propagation?: MountPropagation;\n\n  /**\n   * Mounted read-only if true, read-write otherwise (false or unspecified).\n   * Defaults to false.\n   *\n   * @default false\n   */\n  readonly readOnly?: boolean;\n\n  /**\n   * Path within the volume from which the container's volume should be mounted.).\n   *\n   * @default \"\" the volume's root\n   */\n  readonly subPath?: string;\n\n  /**\n   * Expanded path within the volume from which the container's volume should be\n   * mounted. Behaves similarly to SubPath but environment variable references\n   * $(VAR_NAME) are expanded using the container's environment. Defaults to \"\"\n   * (volume's root).\n   *\n   * `subPathExpr` and `subPath` are mutually exclusive.\n   *\n   * @default \"\" volume's root.\n   */\n  readonly subPathExpr?: string;\n}\n\n/**\n * Mount a volume from the pod to the container.\n */\nexport interface VolumeMount extends MountOptions {\n  /**\n   * The volume to mount.\n   */\n  readonly volume: volume.Volume;\n\n  /**\n   * Path within the container at which the volume should be mounted. Must not\n   * contain ':'.\n   */\n  readonly path: string;\n}\n\nexport enum MountPropagation {\n  /**\n   * This volume mount will not receive any subsequent mounts that are mounted\n   * to this volume or any of its subdirectories by the host. In similar\n   * fashion, no mounts created by the Container will be visible on the host.\n   *\n   * This is the default mode.\n   *\n   * This mode is equal to `private` mount propagation as described in the Linux\n   * kernel documentation\n   */\n  NONE = 'None',\n\n  /**\n   * This volume mount will receive all subsequent mounts that are mounted to\n   * this volume or any of its subdirectories.\n   *\n   * In other words, if the host mounts anything inside the volume mount, the\n   * Container will see it mounted there.\n   *\n   * Similarly, if any Pod with Bidirectional mount propagation to the same\n   * volume mounts anything there, the Container with HostToContainer mount\n   * propagation will see it.\n   *\n   * This mode is equal to `rslave` mount propagation as described in the Linux\n   * kernel documentation\n   */\n  HOST_TO_CONTAINER = 'HostToContainer',\n\n  /**\n   * This volume mount behaves the same the HostToContainer mount. In addition,\n   * all volume mounts created by the Container will be propagated back to the\n   * host and to all Containers of all Pods that use the same volume\n   *\n   * A typical use case for this mode is a Pod with a FlexVolume or CSI driver\n   * or a Pod that needs to mount something on the host using a hostPath volume.\n   *\n   * This mode is equal to `rshared` mount propagation as described in the Linux\n   * kernel documentation\n   *\n   * Caution: Bidirectional mount propagation can be dangerous. It can damage\n   * the host operating system and therefore it is allowed only in privileged\n   * Containers. Familiarity with Linux kernel behavior is strongly recommended.\n   * In addition, any volume mounts created by Containers in Pods must be\n   * destroyed (unmounted) by the Containers on termination.\n   *\n   */\n  BIDIRECTIONAL = 'Bidirectional',\n}\n\n/**\n * CPU and memory compute resources\n */\nexport interface ContainerResources {\n  readonly cpu?: CpuResources;\n  readonly memory?: MemoryResources;\n  readonly ephemeralStorage?: EphemeralStorageResources;\n}\n\n/**\n * CPU request and limit\n */\nexport interface CpuResources {\n  readonly request?: Cpu;\n  readonly limit?: Cpu;\n}\n\n/**\n * Represents the amount of CPU.\n * The amount can be passed as millis or units.\n */\nexport class Cpu {\n  static millis(amount: number): Cpu {\n    return new Cpu(amount + 'm');\n  }\n  static units(amount: number): Cpu {\n    return new Cpu(amount.toString());\n  }\n  amount: string;\n  private constructor(amount: string) {\n    this.amount = amount;\n  }\n}\n\n/**\n * Memory request and limit\n */\nexport interface MemoryResources {\n  readonly request?: Size;\n  readonly limit?: Size;\n}\n\n/**\n * Emphemeral storage request and limit\n */\nexport interface EphemeralStorageResources {\n  readonly request?: Size;\n  readonly limit?: Size;\n}\n\n/**\n * A collection of env variables defined in other resources.\n */\nexport class EnvFrom {\n\n  constructor(\n    private readonly configMap?: configmap.IConfigMap,\n    private readonly prefix?: string,\n    private readonly sec?: secret.ISecret) { };\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.EnvFromSource[] {\n    // a single `k8s.EnvFromSource` may only specify one of `configMapRef` / `secretRef`.\n    // if both a config map and a secret are configured on this instance, they must be\n    // rendered as separate entries, otherwise the resulting manifest is invalid.\n    const sources = new Array<k8s.EnvFromSource>();\n\n    if (this.configMap) {\n      sources.push({\n        configMapRef: { name: this.configMap.name },\n        prefix: this.prefix,\n      });\n    }\n\n    if (this.sec) {\n      sources.push({\n        secretRef: { name: this.sec.name },\n        prefix: this.prefix,\n      });\n    }\n\n    return sources;\n  }\n\n}\n\nexport function extractContainerPorts(selector?: any): ContainerPort[] {\n\n  if (!selector) { return []; }\n\n  // we don't use instanceof intentionally since it can create\n  // cyclic import problems.\n  const containers: Container[] = (selector as any).containers ?? [];\n\n  return containers.flatMap(c => c.ports);\n}\n\n/**\n * Container environment variables.\n */\nexport class Env {\n\n  /**\n   * Selects a ConfigMap to populate the environment variables with.\n   * The contents of the target ConfigMap's Data field will represent\n   * the key-value pairs as environment variables.\n   */\n  public static fromConfigMap(configMap: configmap.IConfigMap, prefix?: string): EnvFrom {\n    return new EnvFrom(configMap, prefix, undefined);\n  }\n\n  /**\n   * Selects a Secret to populate the environment variables with.\n   * The contents of the target Secret's Data field will represent\n   * the key-value pairs as environment variables.\n   */\n  public static fromSecret(secr: secret.ISecret): EnvFrom {\n    return new EnvFrom(undefined, undefined, secr);\n  }\n\n  private readonly _sources: EnvFrom[];\n  private readonly _variables: { [key: string]: EnvValue };\n\n  public constructor(sources: EnvFrom[], variables: { [name: string]: EnvValue }) {\n    this._sources = sources;\n    this._variables = variables;\n  }\n\n  /**\n   * Add a single variable by name and value.\n   * The variable value can come from various dynamic sources such a secrets of config maps.\n   * Use `EnvValue.fromXXX` to select sources.\n   */\n  public addVariable(name: string, value: EnvValue) {\n    this._variables[name] = value;\n  }\n\n  /**\n   * The environment variables for this container.\n   * Returns a copy. To add environment variables use `container.env.addVariable()`.\n   */\n  public get variables(): { [name: string]: EnvValue } {\n    return { ...this._variables };\n  }\n\n  /**\n   * Add a collection of variables by copying from another source.\n   * Use `Env.fromXXX` functions to select sources.\n   */\n  public copyFrom(from: EnvFrom) {\n    this._sources.push(from);\n  }\n\n  /**\n   * The list of sources used to populate the container environment,\n   * in addition to the `variables`.\n   *\n   * Returns a copy. To add a source use `container.env.copyFrom()`.\n   */\n  public get sources(): EnvFrom[] {\n    return [...this._sources];\n  }\n\n  private renderEnv(env: { [name: string]: EnvValue }): k8s.EnvVar[] {\n    const result = new Array<k8s.EnvVar>();\n    for (const [name, v] of Object.entries(env)) {\n      result.push({\n        name,\n        value: v.value,\n        valueFrom: v.valueFrom,\n      });\n    }\n    return result;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): { variables?: k8s.EnvVar[]; from?: k8s.EnvFromSource[] } {\n    return {\n      from: undefinedIfEmpty(this._sources.flatMap(s => s._toKube())),\n      variables: undefinedIfEmpty(this.renderEnv(this._variables)),\n    };\n  }\n}\n"]}