cdk8s-plus-32 2.0.0

package/lib/secret.js

@@ -0,0 +1,185 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerConfigSecret = exports.TlsSecret = exports.ServiceAccountTokenSecret = exports.SshAuthSecret = exports.BasicAuthSecret = exports.Secret = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+const base = require("./base");
+const container_1 = require("./container");
+const k8s = require("./imports/k8s");
+class ImportedSecret extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'secrets';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubeSecret.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return '';
+    }
+    get kind() {
+        return k8s.KubeSecret.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+    envValue(key, options) {
+        return container_1.EnvValue.fromSecretValue({ secret: this, key }, options);
+    }
+}
+/**
+ * Kubernetes Secrets let you store and manage sensitive information, such as
+ * passwords, OAuth tokens, and ssh keys. Storing confidential information in a
+ * Secret is safer and more flexible than putting it verbatim in a Pod
+ * definition or in a container image.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret
+ */
+class Secret extends base.Resource {
+    /**
+     * Imports a secret from the cluster as a reference.
+     */
+    static fromSecretName(scope, id, name) {
+        return new ImportedSecret(scope, id, name);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'secrets';
+        this.stringData = props.stringData ?? {};
+        this.immutable = props.immutable ?? false;
+        this.apiObject = new k8s.KubeSecret(this, 'Resource', {
+            metadata: props.metadata,
+            type: props.type,
+            stringData: this.stringData,
+            immutable: this.immutable,
+        });
+    }
+    /**
+     * Adds a string data field to the secret.
+     * @param key Key
+     * @param value Value
+     */
+    addStringData(key, value) {
+        this.stringData[key] = value;
+    }
+    /**
+     * Gets a string data by key or undefined
+     * @param key Key
+     */
+    getStringData(key) {
+        return this.stringData[key];
+    }
+    envValue(key, options) {
+        return container_1.EnvValue.fromSecretValue({ secret: this, key }, options);
+    }
+}
+exports.Secret = Secret;
+_a = JSII_RTTI_SYMBOL_1;
+Secret[_a] = { fqn: "cdk8s-plus-32.Secret", version: "2.0.0" };
+/**
+ * Create a secret for basic authentication.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#basic-authentication-secret
+ */
+class BasicAuthSecret extends Secret {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            type: 'kubernetes.io/basic-auth',
+            stringData: {
+                username: props.username,
+                password: props.password,
+            },
+            immutable: props.immutable,
+            metadata: props.metadata,
+        });
+    }
+}
+exports.BasicAuthSecret = BasicAuthSecret;
+_b = JSII_RTTI_SYMBOL_1;
+BasicAuthSecret[_b] = { fqn: "cdk8s-plus-32.BasicAuthSecret", version: "2.0.0" };
+/**
+ * Create a secret for ssh authentication.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#ssh-authentication-secrets
+ */
+class SshAuthSecret extends Secret {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            type: 'kubernetes.io/ssh-auth',
+            stringData: {
+                'ssh-privatekey': props.sshPrivateKey,
+            },
+            immutable: props.immutable,
+            metadata: props.metadata,
+        });
+    }
+}
+exports.SshAuthSecret = SshAuthSecret;
+_c = JSII_RTTI_SYMBOL_1;
+SshAuthSecret[_c] = { fqn: "cdk8s-plus-32.SshAuthSecret", version: "2.0.0" };
+/**
+ * Create a secret for a service account token.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#service-account-token-secrets
+ */
+class ServiceAccountTokenSecret extends Secret {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            type: 'kubernetes.io/service-account-token',
+            metadata: props.metadata,
+            immutable: props.immutable,
+        });
+        this.metadata.addAnnotation('kubernetes.io/service-account.name', props.serviceAccount.name);
+    }
+}
+exports.ServiceAccountTokenSecret = ServiceAccountTokenSecret;
+_d = JSII_RTTI_SYMBOL_1;
+ServiceAccountTokenSecret[_d] = { fqn: "cdk8s-plus-32.ServiceAccountTokenSecret", version: "2.0.0" };
+/**
+ * Create a secret for storing a TLS certificate and its associated key.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#tls-secrets
+ */
+class TlsSecret extends Secret {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            type: 'kubernetes.io/tls',
+            stringData: {
+                'tls.crt': props.tlsCert,
+                'tls.key': props.tlsKey,
+            },
+            immutable: props.immutable,
+            metadata: props.metadata,
+        });
+    }
+}
+exports.TlsSecret = TlsSecret;
+_e = JSII_RTTI_SYMBOL_1;
+TlsSecret[_e] = { fqn: "cdk8s-plus-32.TlsSecret", version: "2.0.0" };
+/**
+ * Create a secret for storing credentials for accessing a container image
+ * registry.
+ *
+ * @see https://kubernetes.io/docs/concepts/configuration/secret/#docker-config-secrets
+ */
+class DockerConfigSecret extends Secret {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            type: 'kubernetes.io/dockerconfigjson',
+            stringData: {
+                '.dockerconfigjson': JSON.stringify(props.data),
+            },
+            immutable: props.immutable,
+            metadata: props.metadata,
+        });
+    }
+}
+exports.DockerConfigSecret = DockerConfigSecret;
+_f = JSII_RTTI_SYMBOL_1;
+DockerConfigSecret[_f] = { fqn: "cdk8s-plus-32.DockerConfigSecret", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret.js","sourceRoot":"","sources":["../src/secret.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport { EnvValue, EnvValueFromSecretOptions } from './container';\nimport * as k8s from './imports/k8s';\nimport * as serviceaccount from './service-account';\n\n/**\n * Common properties for `Secret`.\n */\nexport interface CommonSecretProps extends base.ResourceProps {\n\n  /**\n   * If set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified).\n   * If not set to true, the field can be modified at any time.\n   *\n   * @default false\n   */\n  readonly immutable?: boolean;\n\n}\n\n/**\n * Options for `Secret`.\n */\nexport interface SecretProps extends CommonSecretProps {\n  /**\n   * stringData allows specifying non-binary secret data in string form. It is\n   * provided as a write-only convenience method. All keys and values are merged\n   * into the data field on write, overwriting any existing values. It is never\n   * output when reading from the API.\n   */\n  readonly stringData?: { [key: string]: string };\n\n  /**\n   * Optional type associated with the secret.  Used to facilitate programmatic\n   * handling of secret data by various controllers.\n   *\n   * @default undefined - Don't set a type.\n   */\n  readonly type?: string;\n\n}\n\nexport interface ISecret extends base.IResource {\n  /**\n   * Returns EnvValue object from a secret's key.\n   * @param key Secret's key\n   * @param options Additional EnvValue options\n   */\n  envValue(key: string, options?: EnvValueFromSecretOptions): EnvValue;\n}\n\n/**\n * Represents a specific value in JSON secret.\n */\nexport interface SecretValue {\n  /**\n   * The secret\n   */\n  readonly secret: ISecret;\n\n  /**\n   * The JSON key\n   */\n  readonly key: string;\n}\n\nclass ImportedSecret extends Construct implements ISecret {\n\n  private readonly _name: string;\n\n  public readonly resourceType = 'secrets';\n\n  constructor(scope: Construct, id: string, name: string) {\n    super(scope, id);\n    this._name = name;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get apiVersion(): string {\n    return k8s.KubeSecret.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return '';\n  }\n\n  public get kind(): string {\n    return k8s.KubeSecret.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n  public envValue(key: string, options?: EnvValueFromSecretOptions): EnvValue {\n    return EnvValue.fromSecretValue({ secret: this, key }, options);\n  }\n\n}\n\n/**\n * Kubernetes Secrets let you store and manage sensitive information, such as\n * passwords, OAuth tokens, and ssh keys. Storing confidential information in a\n * Secret is safer and more flexible than putting it verbatim in a Pod\n * definition or in a container image.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret\n */\nexport class Secret extends base.Resource implements ISecret {\n\n  /**\n   * Imports a secret from the cluster as a reference.\n   */\n  public static fromSecretName(scope: Construct, id: string, name: string): ISecret {\n    return new ImportedSecret(scope, id, name);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'secrets';\n\n  /**\n   * Whether or not the secret is immutable.\n   */\n  public readonly immutable: boolean;\n\n  private readonly stringData: { [key: string]: string };\n\n  public constructor(scope: Construct, id: string, props: SecretProps = { }) {\n    super(scope, id);\n\n    this.stringData = props.stringData ?? {};\n\n    this.immutable = props.immutable ?? false;\n    this.apiObject = new k8s.KubeSecret(this, 'Resource', {\n      metadata: props.metadata,\n      type: props.type,\n      stringData: this.stringData,\n      immutable: this.immutable,\n    });\n  }\n\n  /**\n   * Adds a string data field to the secret.\n   * @param key Key\n   * @param value Value\n   */\n  public addStringData(key: string, value: string) {\n    this.stringData[key] = value;\n  }\n\n  /**\n   * Gets a string data by key or undefined\n   * @param key Key\n   */\n  public getStringData(key: string): string | undefined {\n    return this.stringData[key];\n  }\n\n  public envValue(key: string, options?: EnvValueFromSecretOptions): EnvValue {\n    return EnvValue.fromSecretValue({ secret: this, key }, options);\n  }\n}\n\n/**\n * Options for `BasicAuthSecret`.\n */\nexport interface BasicAuthSecretProps extends CommonSecretProps {\n  /**\n   * The user name for authentication\n   */\n  readonly username: string;\n\n  /**\n   * The password or token for authentication\n   */\n  readonly password: string;\n}\n\n/**\n * Create a secret for basic authentication.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret/#basic-authentication-secret\n */\nexport class BasicAuthSecret extends Secret {\n  public constructor(scope: Construct, id: string, props: BasicAuthSecretProps) {\n    super(scope, id, {\n      type: 'kubernetes.io/basic-auth',\n      stringData: {\n        username: props.username,\n        password: props.password,\n      },\n      immutable: props.immutable,\n      metadata: props.metadata,\n    });\n  }\n}\n\n/**\n * Options for `SshAuthSecret`.\n */\nexport interface SshAuthSecretProps extends CommonSecretProps {\n  /**\n   * The SSH private key to use\n   */\n  readonly sshPrivateKey: string;\n}\n\n/**\n * Create a secret for ssh authentication.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret/#ssh-authentication-secrets\n */\nexport class SshAuthSecret extends Secret {\n  public constructor(scope: Construct, id: string, props: SshAuthSecretProps) {\n    super(scope, id, {\n      type: 'kubernetes.io/ssh-auth',\n      stringData: {\n        'ssh-privatekey': props.sshPrivateKey,\n      },\n      immutable: props.immutable,\n      metadata: props.metadata,\n    });\n  }\n}\n\n/**\n * Options for `ServiceAccountTokenSecret`.\n */\nexport interface ServiceAccountTokenSecretProps extends CommonSecretProps {\n  /**\n   * The service account to store a secret for\n   */\n  readonly serviceAccount: serviceaccount.IServiceAccount;\n}\n\n/**\n * Create a secret for a service account token.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret/#service-account-token-secrets\n */\nexport class ServiceAccountTokenSecret extends Secret {\n  public constructor(scope: Construct, id: string, props: ServiceAccountTokenSecretProps) {\n    super(scope, id, {\n      type: 'kubernetes.io/service-account-token',\n      metadata: props.metadata,\n      immutable: props.immutable,\n    });\n\n    this.metadata.addAnnotation('kubernetes.io/service-account.name', props.serviceAccount.name);\n  }\n}\n\n/**\n * Options for `TlsSecret`.\n */\nexport interface TlsSecretProps extends CommonSecretProps {\n  /**\n   * The TLS cert\n   */\n  readonly tlsCert: string;\n\n  /**\n   * The TLS key\n   */\n  readonly tlsKey: string;\n}\n\n/**\n * Create a secret for storing a TLS certificate and its associated key.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret/#tls-secrets\n */\nexport class TlsSecret extends Secret {\n  public constructor(scope: Construct, id: string, props: TlsSecretProps) {\n    super(scope, id, {\n      type: 'kubernetes.io/tls',\n      stringData: {\n        'tls.crt': props.tlsCert,\n        'tls.key': props.tlsKey,\n      },\n      immutable: props.immutable,\n      metadata: props.metadata,\n    });\n  }\n}\n\n/**\n * Options for `DockerConfigSecret`.\n */\nexport interface DockerConfigSecretProps extends CommonSecretProps {\n  /**\n   * JSON content to provide for the `~/.docker/config.json` file. This will\n   * be stringified and inserted as stringData.\n   *\n   * @see https://docs.docker.com/engine/reference/commandline/cli/#sample-configuration-file\n   */\n  readonly data: { [key: string]: any };\n}\n\n/**\n * Create a secret for storing credentials for accessing a container image\n * registry.\n *\n * @see https://kubernetes.io/docs/concepts/configuration/secret/#docker-config-secrets\n */\nexport class DockerConfigSecret extends Secret {\n  public constructor(scope: Construct, id: string, props: DockerConfigSecretProps) {\n    super(scope, id, {\n      type: 'kubernetes.io/dockerconfigjson',\n      stringData: {\n        '.dockerconfigjson': JSON.stringify(props.data),\n      },\n      immutable: props.immutable,\n      metadata: props.metadata,\n    });\n  }\n}\n"]}

package/lib/service-account.d.ts

@@ -0,0 +1,83 @@
+import { ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as base from './base';
+import * as rb from './role-binding';
+import * as secret from './secret';
+export interface IServiceAccount extends base.IResource, rb.ISubject {
+}
+/**
+ * Properties for initialization of `ServiceAccount`.
+ */
+export interface ServiceAccountProps extends base.ResourceProps {
+    /**
+     * List of secrets allowed to be used by pods running using this
+     * ServiceAccount.
+     *
+     * @see https://kubernetes.io/docs/concepts/configuration/secret
+     */
+    readonly secrets?: secret.ISecret[];
+    /**
+     * Indicates whether pods running as this service account
+     * should have an API token automatically mounted. Can be overridden at the pod level.
+     *
+     * @default false
+     * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-default-service-account-to-access-the-api-server
+     */
+    readonly automountToken?: boolean;
+}
+export interface FromServiceAccountNameOptions {
+    /**
+     * The name of the namespace the service account belongs to.
+     *
+     * @default "default"
+     */
+    readonly namespaceName?: string;
+}
+/**
+ * A service account provides an identity for processes that run in a Pod.
+ *
+ * When you (a human) access the cluster (for example, using kubectl), you are
+ * authenticated by the apiserver as a particular User Account (currently this
+ * is usually admin, unless your cluster administrator has customized your
+ * cluster). Processes in containers inside pods can also contact the apiserver.
+ * When they do, they are authenticated as a particular Service Account (for
+ * example, default).
+ *
+ * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account
+ */
+export declare class ServiceAccount extends base.Resource implements IServiceAccount, rb.ISubject {
+    /**
+     * Imports a service account from the cluster as a reference.
+     * @param name The name of the service account resource.
+     * @param options additional options.
+     */
+    static fromServiceAccountName(scope: Construct, id: string, name: string, options?: FromServiceAccountNameOptions): IServiceAccount;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "serviceaccounts";
+    private readonly _secrets;
+    /**
+     * Whether or not a token is automatically mounted for this
+     * service account.
+     */
+    readonly automountToken: boolean;
+    constructor(scope: Construct, id: string, props?: ServiceAccountProps);
+    /**
+     * Allow a secret to be accessed by pods using this service account.
+     * @param secr The secret
+     */
+    addSecret(secr: secret.ISecret): void;
+    /**
+     * List of secrets allowed to be used by pods running using this service
+     * account.
+     *
+     * Returns a copy. To add a secret, use `addSecret()`.
+     */
+    get secrets(): secret.ISecret[];
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration(): rb.SubjectConfiguration;
+}

package/lib/service-account.js

@@ -0,0 +1,105 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceAccount = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base = require("./base");
+const k8s = require("./imports/k8s");
+const utils_1 = require("./utils");
+class ImportedServiceAccount extends constructs_1.Construct {
+    constructor(scope, id, name, options = {}) {
+        super(scope, id);
+        this.resourceType = 'serviceaccounts';
+        this._name = name;
+        this._namespaceName = options.namespaceName ?? 'default';
+    }
+    toSubjectConfiguration() {
+        return {
+            kind: this.kind,
+            name: this.name,
+            apiGroup: this.apiGroup,
+            namespace: this._namespaceName,
+        };
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubeServiceAccount.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return '';
+    }
+    get kind() {
+        return k8s.KubeServiceAccount.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * A service account provides an identity for processes that run in a Pod.
+ *
+ * When you (a human) access the cluster (for example, using kubectl), you are
+ * authenticated by the apiserver as a particular User Account (currently this
+ * is usually admin, unless your cluster administrator has customized your
+ * cluster). Processes in containers inside pods can also contact the apiserver.
+ * When they do, they are authenticated as a particular Service Account (for
+ * example, default).
+ *
+ * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account
+ */
+class ServiceAccount extends base.Resource {
+    /**
+     * Imports a service account from the cluster as a reference.
+     * @param name The name of the service account resource.
+     * @param options additional options.
+     */
+    static fromServiceAccountName(scope, id, name, options = {}) {
+        return new ImportedServiceAccount(scope, id, name, options);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'serviceaccounts';
+        this._secrets = props.secrets ?? [];
+        this.automountToken = props.automountToken ?? false;
+        this.apiObject = new k8s.KubeServiceAccount(this, 'Resource', {
+            metadata: props.metadata,
+            secrets: cdk8s_1.Lazy.any({ produce: () => (0, utils_1.undefinedIfEmpty)(this._secrets.map(s => ({ name: s.name }))) }),
+            automountServiceAccountToken: this.automountToken,
+        });
+    }
+    /**
+     * Allow a secret to be accessed by pods using this service account.
+     * @param secr The secret
+     */
+    addSecret(secr) {
+        this._secrets.push(secr);
+    }
+    /**
+     * List of secrets allowed to be used by pods running using this service
+     * account.
+     *
+     * Returns a copy. To add a secret, use `addSecret()`.
+     */
+    get secrets() {
+        return [...this._secrets];
+    }
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration() {
+        return {
+            kind: this.kind,
+            name: this.name,
+            apiGroup: this.apiGroup,
+            namespace: this.metadata.namespace,
+        };
+    }
+}
+exports.ServiceAccount = ServiceAccount;
+_a = JSII_RTTI_SYMBOL_1;
+ServiceAccount[_a] = { fqn: "cdk8s-plus-32.ServiceAccount", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-account.js","sourceRoot":"","sources":["../src/service-account.ts"],"names":[],"mappings":";;;;;AAAA,iCAAwC;AACxC,2CAAuC;AACvC,+BAA+B;AAC/B,qCAAqC;AAGrC,mCAA2C;AAuC3C,MAAM,sBAAuB,SAAQ,sBAAS;IAO5C,YAAY,KAAgB,EAAE,EAAU,EAAE,IAAY,EAAE,UAAyC,EAAE;QACjG,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAHH,iBAAY,GAAG,iBAAiB,CAAC;QAI/C,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,aAAa,IAAI,SAAS,CAAC;IAC3D,CAAC;IAEM,sBAAsB;QAC3B,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,cAAc;SAC/B,CAAC;IACJ,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC;IAC/C,CAAC;IAED,IAAW,QAAQ;QACjB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAW,IAAI;QACb,OAAO,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC;IACzC,CAAC;IAED,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CAEF;AAED;;;;;;;;;;;GAWG;AACH,MAAa,cAAe,SAAQ,IAAI,CAAC,QAAQ;IAE/C;;;;OAIG;IACI,MAAM,CAAC,sBAAsB,CAAC,KAAgB,EAAE,EAAU,EAAE,IAAY,EAAE,UAAyC,EAAE;QAC1H,OAAO,IAAI,sBAAsB,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC;IAiBD,YAAY,KAAgB,EAAE,EAAU,EAAE,QAA6B,EAAG;QACxE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAXH,iBAAY,GAAG,iBAAiB,CAAC;QAa/C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QACpC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,IAAI,KAAK,CAAC;QAEpD,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE;YAC5D,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,OAAO,EAAE,YAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAA,wBAAgB,EAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClG,4BAA4B,EAAE,IAAI,CAAC,cAAc;SAClD,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,IAAoB;QACnC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,IAAW,OAAO;QAChB,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,sBAAsB;QAC3B,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC;IACJ,CAAC;;AAnEH,wCAqEC","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as rb from './role-binding';\nimport * as secret from './secret';\nimport { undefinedIfEmpty } from './utils';\n\n\nexport interface IServiceAccount extends base.IResource, rb.ISubject {\n\n}\n\n/**\n * Properties for initialization of `ServiceAccount`.\n */\nexport interface ServiceAccountProps extends base.ResourceProps {\n  /**\n   * List of secrets allowed to be used by pods running using this\n   * ServiceAccount.\n   *\n   * @see https://kubernetes.io/docs/concepts/configuration/secret\n   */\n  readonly secrets?: secret.ISecret[];\n\n  /**\n   * Indicates whether pods running as this service account\n   * should have an API token automatically mounted. Can be overridden at the pod level.\n   *\n   * @default false\n   * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-default-service-account-to-access-the-api-server\n   */\n  readonly automountToken?: boolean;\n}\n\nexport interface FromServiceAccountNameOptions {\n\n  /**\n   * The name of the namespace the service account belongs to.\n   *\n   * @default \"default\"\n   */\n  readonly namespaceName?: string;\n}\n\nclass ImportedServiceAccount extends Construct implements IServiceAccount {\n\n  private readonly _name: string;\n  private readonly _namespaceName: string;\n\n  public readonly resourceType = 'serviceaccounts';\n\n  constructor(scope: Construct, id: string, name: string, options: FromServiceAccountNameOptions = {}) {\n    super(scope, id);\n    this._name = name;\n    this._namespaceName = options.namespaceName ?? 'default';\n  }\n\n  public toSubjectConfiguration(): rb.SubjectConfiguration {\n    return {\n      kind: this.kind,\n      name: this.name,\n      apiGroup: this.apiGroup,\n      namespace: this._namespaceName,\n    };\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get apiVersion(): string {\n    return k8s.KubeServiceAccount.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return '';\n  }\n\n  public get kind(): string {\n    return k8s.KubeServiceAccount.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * A service account provides an identity for processes that run in a Pod.\n *\n * When you (a human) access the cluster (for example, using kubectl), you are\n * authenticated by the apiserver as a particular User Account (currently this\n * is usually admin, unless your cluster administrator has customized your\n * cluster). Processes in containers inside pods can also contact the apiserver.\n * When they do, they are authenticated as a particular Service Account (for\n * example, default).\n *\n * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account\n */\nexport class ServiceAccount extends base.Resource implements IServiceAccount, rb.ISubject {\n\n  /**\n   * Imports a service account from the cluster as a reference.\n   * @param name The name of the service account resource.\n   * @param options additional options.\n   */\n  public static fromServiceAccountName(scope: Construct, id: string, name: string, options: FromServiceAccountNameOptions = {}): IServiceAccount {\n    return new ImportedServiceAccount(scope, id, name, options);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'serviceaccounts';\n\n  private readonly _secrets: secret.ISecret[];\n\n  /**\n   * Whether or not a token is automatically mounted for this\n   * service account.\n   */\n  public readonly automountToken: boolean;\n\n  constructor(scope: Construct, id: string, props: ServiceAccountProps = { }) {\n    super(scope, id);\n\n    this._secrets = props.secrets ?? [];\n    this.automountToken = props.automountToken ?? false;\n\n    this.apiObject = new k8s.KubeServiceAccount(this, 'Resource', {\n      metadata: props.metadata,\n      secrets: Lazy.any({ produce: () => undefinedIfEmpty(this._secrets.map(s => ({ name: s.name }))) }),\n      automountServiceAccountToken: this.automountToken,\n    });\n  }\n\n  /**\n   * Allow a secret to be accessed by pods using this service account.\n   * @param secr The secret\n   */\n  public addSecret(secr: secret.ISecret) {\n    this._secrets.push(secr);\n  }\n\n  /**\n   * List of secrets allowed to be used by pods running using this service\n   * account.\n   *\n   * Returns a copy. To add a secret, use `addSecret()`.\n   */\n  public get secrets() {\n    return [...this._secrets];\n  }\n\n  /**\n   * @see ISubect.toSubjectConfiguration()\n   */\n  public toSubjectConfiguration(): rb.SubjectConfiguration {\n    return {\n      kind: this.kind,\n      name: this.name,\n      apiGroup: this.apiGroup,\n      namespace: this.metadata.namespace,\n    };\n  }\n\n}"]}