cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/service.d.ts

@@ -0,0 +1,289 @@
+import { ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as base from './base';
+import * as container from './container';
+import * as k8s from './imports/k8s';
+import * as ingress from './ingress';
+import * as pod from './pod';
+/**
+ * Properties for `Service`.
+ */
+export interface ServiceProps extends base.ResourceProps {
+    /**
+     * Which pods should the service select and route to.
+     *
+     * You can pass one of the following:
+     *
+     * - An instance of `Pod` or any workload resource (e.g `Deployment`, `StatefulSet`, ...)
+     * - Pods selected by the `Pods.select` function. Note that in this case only labels can be specified.
+     *
+     * @default - unset, the service is assumed to have an external process managing
+     * its endpoints, which Kubernetes will not modify.
+     *
+     * @example
+     *
+     * // select the pods of a specific deployment
+     * const backend = new kplus.Deployment(this, 'Backend', ...);
+     * new kplus.Service(this, 'Service', { selector: backend });
+     *
+     * // select all pods labeled with the `tier=backend` label
+     * const backend = kplus.Pod.labeled({ tier: 'backend' });
+     * new kplus.Service(this, 'Service', { selector: backend });
+     */
+    readonly selector?: pod.IPodSelector;
+    /**
+     * The IP address of the service and is usually assigned randomly by the
+     * master. If an address is specified manually and is not in use by others, it
+     * will be allocated to the service; otherwise, creation of the service will
+     * fail. This field can not be changed through updates. Valid values are
+     * "None", empty string (""), or a valid IP address. "None" can be specified
+     * for headless services when proxying is not required. Only applies to types
+     * ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName.
+     *
+     * @see https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
+     * @default - Automatically assigned.
+     *
+     */
+    readonly clusterIP?: string;
+    /**
+     * A list of IP addresses for which nodes in the cluster will also accept
+     * traffic for this service. These IPs are not managed by Kubernetes. The user
+     * is responsible for ensuring that traffic arrives at a node with this IP. A
+     * common example is external load-balancers that are not part of the
+     * Kubernetes system.
+     *
+     * @default - No external IPs.
+     */
+    readonly externalIPs?: string[];
+    /**
+     * Determines how the Service is exposed.
+     *
+     * More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
+     *
+     * @default ServiceType.ClusterIP
+     */
+    readonly type?: ServiceType;
+    /**
+     * The ports this service binds to.
+     *
+     * If the selector of the service is a managed pod / workload,
+     * its ports will are automatically extracted and used as the default value.
+     * Otherwise, no ports are bound.
+     *
+     * @default - either the selector ports, or none.
+     */
+    readonly ports?: ServicePort[];
+    /**
+     * The externalName to be used when ServiceType.EXTERNAL_NAME is set
+     *
+     * @default - No external name.
+     */
+    readonly externalName?: string;
+    /**
+     * A list of CIDR IP addresses, if specified and supported by the platform,
+     * will restrict traffic through the cloud-provider load-balancer to the specified client IPs.
+     *
+     * More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/
+     */
+    readonly loadBalancerSourceRanges?: string[];
+    /**
+     * The publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service
+     * should disregard any indications of ready/not-ready
+     *
+     * More info: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#servicespec-v1-core
+     *
+     * @default - false
+     */
+    readonly publishNotReadyAddresses?: boolean;
+}
+/**
+ * Options for exposing a service using an ingress.
+ */
+export interface ExposeServiceViaIngressOptions {
+    /**
+     * The type of the path
+     *
+     * @default HttpIngressPathType.PREFIX
+     */
+    readonly pathType?: ingress.HttpIngressPathType;
+    /**
+     * The ingress to add rules to.
+     *
+     * @default - An ingress will be automatically created.
+     */
+    readonly ingress?: ingress.Ingress;
+}
+/**
+ * For some parts of your application (for example, frontends) you may want to expose a Service onto an
+ * external IP address, that's outside of your cluster.
+ * Kubernetes ServiceTypes allow you to specify what kind of Service you want.
+ * The default is ClusterIP.
+ */
+export declare enum ServiceType {
+    /**
+     * Exposes the Service on a cluster-internal IP.
+     * Choosing this value makes the Service only reachable from within the cluster.
+     * This is the default ServiceType
+     */
+    CLUSTER_IP = "ClusterIP",
+    /**
+     * Exposes the Service on each Node's IP at a static port (the NodePort).
+     * A ClusterIP Service, to which the NodePort Service routes, is automatically created.
+     * You'll be able to contact the NodePort Service, from outside the cluster,
+     * by requesting <NodeIP>:<NodePort>.
+     */
+    NODE_PORT = "NodePort",
+    /**
+     * Exposes the Service externally using a cloud provider's load balancer.
+     * NodePort and ClusterIP Services, to which the external load balancer routes,
+     * are automatically created.
+     */
+    LOAD_BALANCER = "LoadBalancer",
+    /**
+     * Maps the Service to the contents of the externalName field (e.g. foo.bar.example.com), by returning a CNAME record with its value.
+     * No proxying of any kind is set up.
+     *
+     * > Note: You need either kube-dns version 1.7 or CoreDNS version 0.0.8 or higher to use the ExternalName type.
+     */
+    EXTERNAL_NAME = "ExternalName"
+}
+/**
+ * Options to add a deployment to a service.
+ */
+export interface AddDeploymentOptions extends ServiceBindOptions {
+    /**
+     * The port number the service will bind to.
+     *
+     * @default - Copied from the first container of the deployment.
+     */
+    readonly port?: number;
+}
+/**
+ * An abstract way to expose an application running on a set of Pods as a network service.
+ * With Kubernetes you don't need to modify your application to use an unfamiliar service discovery mechanism.
+ * Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.
+ *
+ * For example, consider a stateless image-processing backend which is running with 3 replicas. Those replicas are fungible—frontends do not care which backend they use.
+ * While the actual Pods that compose the backend set may change, the frontend clients should not need to be aware of that,
+ * nor should they need to keep track of the set of backends themselves.
+ * The Service abstraction enables this decoupling.
+ *
+ * If you're able to use Kubernetes APIs for service discovery in your application, you can query the API server for Endpoints,
+ * that get updated whenever the set of Pods in a Service changes. For non-native applications, Kubernetes offers ways to place a network port
+ * or load balancer in between your application and the backend Pods.
+ */
+export declare class Service extends base.Resource {
+    /**
+     * The IP address of the service and is usually assigned randomly by the
+     * master.
+     */
+    readonly clusterIP?: string;
+    /**
+     * Determines how the Service is exposed.
+     */
+    readonly type: ServiceType;
+    /**
+     * The externalName to be used for EXTERNAL_NAME types
+     */
+    readonly externalName?: string;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "services";
+    private readonly _externalIPs;
+    private readonly _selector;
+    private readonly _ports;
+    private readonly _loadBalancerSourceRanges?;
+    private readonly _publishNotReadyAddresses?;
+    constructor(scope: Construct, id: string, props?: ServiceProps);
+    /**
+     * Expose a service via an ingress using the specified path.
+     *
+     * @param path The path to expose the service under.
+     * @param options Additional options.
+     *
+     * @returns The `Ingress` resource that was used.
+     */
+    exposeViaIngress(path: string, options?: ExposeServiceViaIngressOptions): ingress.Ingress;
+    /**
+     * Ports for this service.
+     *
+     * Use `bind()` to bind additional service ports.
+     */
+    get ports(): ServicePort[];
+    /**
+     * Return the first port of the service.
+     */
+    get port(): number;
+    /**
+     * Configure a port the service will bind to.
+     * This method can be called multiple times.
+     *
+     * @param port The port definition.
+     */
+    bind(port: number, options?: ServiceBindOptions): void;
+    /**
+     * Require this service to select pods matching the selector.
+     *
+     * Note that invoking this method multiple times acts as an AND operator
+     * on the resulting labels.
+     */
+    select(selector: pod.IPodSelector): void;
+    /**
+     * Require this service to select pods with this label.
+     *
+     * Note that invoking this method multiple times acts as an AND operator
+     * on the resulting labels.
+     */
+    selectLabel(key: string, value: string): void;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.ServiceSpec;
+}
+/**
+ * Options for `Service.bind`.
+ */
+export interface ServiceBindOptions {
+    /**
+     * The name of this port within the service. This must be a DNS_LABEL. All
+     * ports within a ServiceSpec must have unique names. This maps to the 'Name'
+     * field in EndpointPort objects. Optional if only one ServicePort is defined
+     * on this service.
+     */
+    readonly name?: string;
+    /**
+     * The port on each node on which this service is exposed when type=NodePort
+     * or LoadBalancer. Usually assigned by the system. If specified, it will be
+     * allocated to the service if unused or else creation of the service will
+     * fail. Default is to auto-allocate a port if the ServiceType of this Service
+     * requires one.
+     *
+     * @see https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport
+     *
+     * @default - auto-allocate a port if the ServiceType of this Service requires one.
+     */
+    readonly nodePort?: number;
+    /**
+     * The IP protocol for this port. Supports "TCP", "UDP", and "SCTP". Default is TCP.
+     *
+     * @default Protocol.TCP
+     */
+    readonly protocol?: container.Protocol;
+    /**
+     * The port number the service will redirect to.
+     *
+     * @default - The value of `port` will be used.
+     */
+    readonly targetPort?: number;
+}
+/**
+ * Definition of a service port.
+ */
+export interface ServicePort extends ServiceBindOptions {
+    /**
+     * The port number the service will bind to.
+     */
+    readonly port: number;
+}

package/lib/service.js

@@ -0,0 +1,182 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = exports.ServiceType = 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");
+const ingress = require("./ingress");
+/**
+ * For some parts of your application (for example, frontends) you may want to expose a Service onto an
+ * external IP address, that's outside of your cluster.
+ * Kubernetes ServiceTypes allow you to specify what kind of Service you want.
+ * The default is ClusterIP.
+ */
+var ServiceType;
+(function (ServiceType) {
+    /**
+     * Exposes the Service on a cluster-internal IP.
+     * Choosing this value makes the Service only reachable from within the cluster.
+     * This is the default ServiceType
+     */
+    ServiceType["CLUSTER_IP"] = "ClusterIP";
+    /**
+     * Exposes the Service on each Node's IP at a static port (the NodePort).
+     * A ClusterIP Service, to which the NodePort Service routes, is automatically created.
+     * You'll be able to contact the NodePort Service, from outside the cluster,
+     * by requesting <NodeIP>:<NodePort>.
+     */
+    ServiceType["NODE_PORT"] = "NodePort";
+    /**
+     * Exposes the Service externally using a cloud provider's load balancer.
+     * NodePort and ClusterIP Services, to which the external load balancer routes,
+     * are automatically created.
+     */
+    ServiceType["LOAD_BALANCER"] = "LoadBalancer";
+    /**
+     * Maps the Service to the contents of the externalName field (e.g. foo.bar.example.com), by returning a CNAME record with its value.
+     * No proxying of any kind is set up.
+     *
+     * > Note: You need either kube-dns version 1.7 or CoreDNS version 0.0.8 or higher to use the ExternalName type.
+     */
+    ServiceType["EXTERNAL_NAME"] = "ExternalName";
+})(ServiceType || (exports.ServiceType = ServiceType = {}));
+/**
+ * An abstract way to expose an application running on a set of Pods as a network service.
+ * With Kubernetes you don't need to modify your application to use an unfamiliar service discovery mechanism.
+ * Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.
+ *
+ * For example, consider a stateless image-processing backend which is running with 3 replicas. Those replicas are fungible—frontends do not care which backend they use.
+ * While the actual Pods that compose the backend set may change, the frontend clients should not need to be aware of that,
+ * nor should they need to keep track of the set of backends themselves.
+ * The Service abstraction enables this decoupling.
+ *
+ * If you're able to use Kubernetes APIs for service discovery in your application, you can query the API server for Endpoints,
+ * that get updated whenever the set of Pods in a Service changes. For non-native applications, Kubernetes offers ways to place a network port
+ * or load balancer in between your application and the backend Pods.
+ */
+class Service extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'services';
+        this.apiObject = new k8s.KubeService(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.clusterIP = props.clusterIP;
+        this.externalName = props.externalName;
+        if (props.externalName !== undefined) {
+            this.type = ServiceType.EXTERNAL_NAME;
+        }
+        else {
+            this.type = props.type ?? ServiceType.CLUSTER_IP;
+        }
+        this._externalIPs = props.externalIPs ?? [];
+        this._ports = [];
+        this._selector = {};
+        this._loadBalancerSourceRanges = props.loadBalancerSourceRanges;
+        this._publishNotReadyAddresses = props.publishNotReadyAddresses;
+        if (props.selector) {
+            this.select(props.selector);
+        }
+        for (const port of props.ports ?? []) {
+            this.bind(port.port, port);
+        }
+    }
+    /**
+     * Expose a service via an ingress using the specified path.
+     *
+     * @param path The path to expose the service under.
+     * @param options Additional options.
+     *
+     * @returns The `Ingress` resource that was used.
+     */
+    exposeViaIngress(path, options = {}) {
+        const ingr = options.ingress ?? new ingress.Ingress(this, 'Ingress');
+        ingr.addRule(path, ingress.IngressBackend.fromService(this), options.pathType);
+        return ingr;
+    }
+    /**
+     * Ports for this service.
+     *
+     * Use `bind()` to bind additional service ports.
+     */
+    get ports() {
+        return [...this._ports];
+    }
+    /**
+     * Return the first port of the service.
+     */
+    get port() {
+        return [...this._ports][0].port;
+    }
+    /**
+     * Configure a port the service will bind to.
+     * This method can be called multiple times.
+     *
+     * @param port The port definition.
+     */
+    bind(port, options = {}) {
+        this._ports.push({ ...options, port });
+    }
+    /**
+     * Require this service to select pods matching the selector.
+     *
+     * Note that invoking this method multiple times acts as an AND operator
+     * on the resulting labels.
+     */
+    select(selector) {
+        const labels = selector.toPodSelectorConfig().labelSelector._toKube().matchLabels ?? {};
+        for (const [key, value] of Object.entries(labels)) {
+            this._selector[key] = value;
+        }
+    }
+    /**
+     * Require this service to select pods with this label.
+     *
+     * Note that invoking this method multiple times acts as an AND operator
+     * on the resulting labels.
+     */
+    selectLabel(key, value) {
+        this._selector[key] = value;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        if (this._ports.length === 0 && this.type !== ServiceType.EXTERNAL_NAME) {
+            throw new Error('A service must be configured with a port');
+        }
+        if (this.type === ServiceType.EXTERNAL_NAME && this.externalName === undefined) {
+            throw new Error('A service with type EXTERNAL_NAME requires an externalName prop');
+        }
+        const ports = [];
+        for (const port of this._ports) {
+            ports.push({
+                name: port.name,
+                port: port.port,
+                targetPort: port.targetPort ? k8s.IntOrString.fromNumber(port.targetPort) : undefined,
+                nodePort: port.nodePort,
+                protocol: port.protocol,
+            });
+        }
+        return this.type !== ServiceType.EXTERNAL_NAME ? {
+            clusterIp: this.clusterIP,
+            externalIPs: this._externalIPs,
+            externalName: this.externalName,
+            type: this.type,
+            selector: this._selector,
+            ports: ports,
+            loadBalancerSourceRanges: this._loadBalancerSourceRanges,
+            publishNotReadyAddresses: this._publishNotReadyAddresses,
+        } : {
+            type: this.type,
+            externalName: this.externalName,
+        };
+    }
+}
+exports.Service = Service;
+_a = JSII_RTTI_SYMBOL_1;
+Service[_a] = { fqn: "cdk8s-plus-34.Service", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport * as container from './container';\nimport * as k8s from './imports/k8s';\nimport * as ingress from './ingress';\nimport * as pod from './pod';\n\n/**\n * Properties for `Service`.\n */\nexport interface ServiceProps extends base.ResourceProps {\n  /**\n   * Which pods should the service select and route to.\n   *\n   * You can pass one of the following:\n   *\n   * - An instance of `Pod` or any workload resource (e.g `Deployment`, `StatefulSet`, ...)\n   * - Pods selected by the `Pods.select` function. Note that in this case only labels can be specified.\n   *\n   * @default - unset, the service is assumed to have an external process managing\n   * its endpoints, which Kubernetes will not modify.\n   *\n   * @example\n   *\n   * // select the pods of a specific deployment\n   * const backend = new kplus.Deployment(this, 'Backend', ...);\n   * new kplus.Service(this, 'Service', { selector: backend });\n   *\n   * // select all pods labeled with the `tier=backend` label\n   * const backend = kplus.Pod.labeled({ tier: 'backend' });\n   * new kplus.Service(this, 'Service', { selector: backend });\n   */\n  readonly selector?: pod.IPodSelector;\n\n  /**\n   * The IP address of the service and is usually assigned randomly by the\n   * master. If an address is specified manually and is not in use by others, it\n   * will be allocated to the service; otherwise, creation of the service will\n   * fail. This field can not be changed through updates. Valid values are\n   * \"None\", empty string (\"\"), or a valid IP address. \"None\" can be specified\n   * for headless services when proxying is not required. Only applies to types\n   * ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName.\n   *\n   * @see https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies\n   * @default - Automatically assigned.\n   *\n   */\n  readonly clusterIP?: string;\n\n  /**\n   * A list of IP addresses for which nodes in the cluster will also accept\n   * traffic for this service. These IPs are not managed by Kubernetes. The user\n   * is responsible for ensuring that traffic arrives at a node with this IP. A\n   * common example is external load-balancers that are not part of the\n   * Kubernetes system.\n   *\n   * @default - No external IPs.\n   */\n  readonly externalIPs?: string[];\n\n  /**\n   * Determines how the Service is exposed.\n   *\n   * More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types\n   *\n   * @default ServiceType.ClusterIP\n   */\n  readonly type?: ServiceType;\n\n  /**\n   * The ports this service binds to.\n   *\n   * If the selector of the service is a managed pod / workload,\n   * its ports will are automatically extracted and used as the default value.\n   * Otherwise, no ports are bound.\n   *\n   * @default - either the selector ports, or none.\n   */\n  readonly ports?: ServicePort[];\n\n  /**\n   * The externalName to be used when ServiceType.EXTERNAL_NAME is set\n   *\n   * @default - No external name.\n   */\n  readonly externalName?: string;\n\n  /**\n   * A list of CIDR IP addresses, if specified and supported by the platform,\n   * will restrict traffic through the cloud-provider load-balancer to the specified client IPs.\n   *\n   * More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/\n   */\n  readonly loadBalancerSourceRanges?: string[];\n\n  /**\n   * The publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service\n   * should disregard any indications of ready/not-ready\n   *\n   * More info: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#servicespec-v1-core\n   *\n   * @default - false\n   */\n  readonly publishNotReadyAddresses?: boolean;\n\n}\n\n/**\n * Options for exposing a service using an ingress.\n */\nexport interface ExposeServiceViaIngressOptions {\n\n  /**\n   * The type of the path\n   *\n   * @default HttpIngressPathType.PREFIX\n   */\n  readonly pathType?: ingress.HttpIngressPathType;\n\n  /**\n   * The ingress to add rules to.\n   *\n   * @default - An ingress will be automatically created.\n   */\n  readonly ingress?: ingress.Ingress;\n}\n\n/**\n * For some parts of your application (for example, frontends) you may want to expose a Service onto an\n * external IP address, that's outside of your cluster.\n * Kubernetes ServiceTypes allow you to specify what kind of Service you want.\n * The default is ClusterIP.\n */\nexport enum ServiceType {\n\n  /**\n   * Exposes the Service on a cluster-internal IP.\n   * Choosing this value makes the Service only reachable from within the cluster.\n   * This is the default ServiceType\n   */\n  CLUSTER_IP = 'ClusterIP',\n\n  /**\n   * Exposes the Service on each Node's IP at a static port (the NodePort).\n   * A ClusterIP Service, to which the NodePort Service routes, is automatically created.\n   * You'll be able to contact the NodePort Service, from outside the cluster,\n   * by requesting <NodeIP>:<NodePort>.\n   */\n  NODE_PORT = 'NodePort',\n\n  /**\n   * Exposes the Service externally using a cloud provider's load balancer.\n   * NodePort and ClusterIP Services, to which the external load balancer routes,\n   * are automatically created.\n   */\n  LOAD_BALANCER = 'LoadBalancer',\n\n  /**\n   * Maps the Service to the contents of the externalName field (e.g. foo.bar.example.com), by returning a CNAME record with its value.\n   * No proxying of any kind is set up.\n   *\n   * > Note: You need either kube-dns version 1.7 or CoreDNS version 0.0.8 or higher to use the ExternalName type.\n   */\n  EXTERNAL_NAME = 'ExternalName',\n}\n\n/**\n * Options to add a deployment to a service.\n */\nexport interface AddDeploymentOptions extends ServiceBindOptions {\n  /**\n   * The port number the service will bind to.\n   *\n   * @default - Copied from the first container of the deployment.\n   */\n  readonly port?: number;\n}\n\n/**\n * An abstract way to expose an application running on a set of Pods as a network service.\n * With Kubernetes you don't need to modify your application to use an unfamiliar service discovery mechanism.\n * Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.\n *\n * For example, consider a stateless image-processing backend which is running with 3 replicas. Those replicas are fungible—frontends do not care which backend they use.\n * While the actual Pods that compose the backend set may change, the frontend clients should not need to be aware of that,\n * nor should they need to keep track of the set of backends themselves.\n * The Service abstraction enables this decoupling.\n *\n * If you're able to use Kubernetes APIs for service discovery in your application, you can query the API server for Endpoints,\n * that get updated whenever the set of Pods in a Service changes. For non-native applications, Kubernetes offers ways to place a network port\n * or load balancer in between your application and the backend Pods.\n */\nexport class Service extends base.Resource {\n\n  /**\n   * The IP address of the service and is usually assigned randomly by the\n   * master.\n   */\n  public readonly clusterIP?: string;\n\n  /**\n   * Determines how the Service is exposed.\n   */\n  public readonly type: ServiceType;\n\n  /**\n   * The externalName to be used for EXTERNAL_NAME types\n   */\n  public readonly externalName?: string;\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'services';\n\n  private readonly _externalIPs: string[];\n  private readonly _selector: Record<string, string>;\n  private readonly _ports: ServicePort[];\n  private readonly _loadBalancerSourceRanges?: string[];\n  private readonly _publishNotReadyAddresses?: boolean;\n\n  constructor(scope: Construct, id: string, props: ServiceProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeService(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this.clusterIP = props.clusterIP;\n    this.externalName = props.externalName;\n\n    if (props.externalName !== undefined) {\n      this.type = ServiceType.EXTERNAL_NAME;\n    } else {\n      this.type = props.type ?? ServiceType.CLUSTER_IP;\n    }\n\n    this._externalIPs = props.externalIPs ?? [];\n    this._ports = [];\n    this._selector = { };\n    this._loadBalancerSourceRanges = props.loadBalancerSourceRanges;\n    this._publishNotReadyAddresses = props.publishNotReadyAddresses;\n\n    if (props.selector) {\n      this.select(props.selector);\n    }\n\n    for (const port of props.ports ?? []) {\n      this.bind(port.port, port);\n    }\n  }\n\n  /**\n   * Expose a service via an ingress using the specified path.\n   *\n   * @param path The path to expose the service under.\n   * @param options Additional options.\n   *\n   * @returns The `Ingress` resource that was used.\n   */\n  public exposeViaIngress(path: string, options: ExposeServiceViaIngressOptions = {}): ingress.Ingress {\n    const ingr = options.ingress ?? new ingress.Ingress(this, 'Ingress');\n    ingr.addRule(path, ingress.IngressBackend.fromService(this), options.pathType);\n    return ingr;\n  }\n\n  /**\n   * Ports for this service.\n   *\n   * Use `bind()` to bind additional service ports.\n   */\n  public get ports() {\n    return [...this._ports];\n  }\n\n  /**\n   * Return the first port of the service.\n   */\n  public get port(): number {\n    return [...this._ports][0].port;\n  }\n\n  /**\n   * Configure a port the service will bind to.\n   * This method can be called multiple times.\n   *\n   * @param port The port definition.\n   */\n  public bind(port: number, options: ServiceBindOptions = { }) {\n    this._ports.push({ ...options, port });\n  }\n\n  /**\n   * Require this service to select pods matching the selector.\n   *\n   * Note that invoking this method multiple times acts as an AND operator\n   * on the resulting labels.\n   */\n  public select(selector: pod.IPodSelector) {\n    const labels = selector.toPodSelectorConfig().labelSelector._toKube().matchLabels ?? {};\n    for (const [key, value] of Object.entries(labels)) {\n      this._selector[key] = value;\n    }\n  }\n\n  /**\n   * Require this service to select pods with this label.\n   *\n   * Note that invoking this method multiple times acts as an AND operator\n   * on the resulting labels.\n   */\n  public selectLabel(key: string, value: string) {\n    this._selector[key] = value;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.ServiceSpec {\n    if (this._ports.length === 0 && this.type !== ServiceType.EXTERNAL_NAME) {\n      throw new Error('A service must be configured with a port');\n    }\n\n    if (this.type === ServiceType.EXTERNAL_NAME && this.externalName === undefined) {\n      throw new Error('A service with type EXTERNAL_NAME requires an externalName prop');\n    }\n\n    const ports: k8s.ServicePort[] = [];\n\n    for (const port of this._ports) {\n      ports.push({\n        name: port.name,\n        port: port.port,\n        targetPort: port.targetPort ? k8s.IntOrString.fromNumber(port.targetPort) : undefined,\n        nodePort: port.nodePort,\n        protocol: port.protocol,\n      });\n    }\n\n    return this.type !== ServiceType.EXTERNAL_NAME ? {\n      clusterIp: this.clusterIP,\n      externalIPs: this._externalIPs,\n      externalName: this.externalName,\n      type: this.type,\n      selector: this._selector,\n      ports: ports,\n      loadBalancerSourceRanges: this._loadBalancerSourceRanges,\n      publishNotReadyAddresses: this._publishNotReadyAddresses,\n    } : {\n      type: this.type,\n      externalName: this.externalName,\n    };\n  }\n}\n\n/**\n * Options for `Service.bind`.\n */\nexport interface ServiceBindOptions {\n  /**\n   * The name of this port within the service. This must be a DNS_LABEL. All\n   * ports within a ServiceSpec must have unique names. This maps to the 'Name'\n   * field in EndpointPort objects. Optional if only one ServicePort is defined\n   * on this service.\n   */\n  readonly name?: string;\n\n  /**\n   * The port on each node on which this service is exposed when type=NodePort\n   * or LoadBalancer. Usually assigned by the system. If specified, it will be\n   * allocated to the service if unused or else creation of the service will\n   * fail. Default is to auto-allocate a port if the ServiceType of this Service\n   * requires one.\n   *\n   * @see https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport\n   *\n   * @default - auto-allocate a port if the ServiceType of this Service requires one.\n   */\n  readonly nodePort?: number;\n\n  /**\n   * The IP protocol for this port. Supports \"TCP\", \"UDP\", and \"SCTP\". Default is TCP.\n   *\n   * @default Protocol.TCP\n   */\n  readonly protocol?: container.Protocol;\n\n  /**\n   * The port number the service will redirect to.\n   *\n   * @default - The value of `port` will be used.\n   */\n  readonly targetPort?: number;\n}\n\n/**\n * Definition of a service port.\n */\nexport interface ServicePort extends ServiceBindOptions {\n\n  /**\n   * The port number the service will bind to.\n   */\n  readonly port: number;\n}\n"]}