@paulo_raca/cdk-skylight 0.0.0

package/lib/skylight-authentication/ad-authentication.js

@@ -0,0 +1,232 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsManagedMicrosoftAdR53 = exports.AwsManagedMicrosoftAd = exports.AwsManagedMicrosoftConfigurationStoreType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+// Imports
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const skylight = require("../index");
+var AwsManagedMicrosoftConfigurationStoreType;
+(function (AwsManagedMicrosoftConfigurationStoreType) {
+    AwsManagedMicrosoftConfigurationStoreType["SSM"] = "AWS Systems Manager Parameter Store";
+})(AwsManagedMicrosoftConfigurationStoreType || (exports.AwsManagedMicrosoftConfigurationStoreType = AwsManagedMicrosoftConfigurationStoreType = {}));
+/**
+ * A Ad Authentication represents an integration pattern of Managed AD and Route 53 Resolver in a specific VPC
+ *
+ * The Construct creates Managed AD with the provided Secret (Secrets Manager) or generates a new Secret.
+ * The secret saved to SSM parameter store so others can use it with other Constructs (Such as Windows node or FSx)
+ * The provided VPC or the new created VPC will be configured to forward DNS requests to the Managed AD with Route53 Resolvers
+ * The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createADGroup)
+ *
+ * The createADGroup() method creates an Active Directory permission group in the domain, using the domain admin user.
+ * Please note: When calling createADGroup() API, a Lambda will be created to start the worker machine (Using AWS-SDK),
+ * then each command will be scheduled with State Manager, and the instance will be shut down after complete.
+ *
+ */
+class AwsManagedMicrosoftAd extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.props.domainName = props.domainName ?? 'domain.aws';
+        this.props.edition = props.edition ?? 'Standard';
+        this.props.secretName = props.secretName ?? `${props.domainName}-secret`;
+        this.props.createWorker = props.createWorker ?? true;
+        this.adParameters = props.configurationStore ?? {
+            configurationStoreType: AwsManagedMicrosoftConfigurationStoreType.SSM,
+        };
+        this.adParameters.secretPointer =
+            this.adParameters.secretPointer ?? 'domain-secret';
+        this.adParameters.directoryIDPointer =
+            this.adParameters.directoryIDPointer ?? 'directoryID';
+        if (this.adParameters.namespace) {
+            this.adParameters.namespace = `${this.adParameters.namespace}/authentication/mad`;
+        }
+        else {
+            this.adParameters.namespace = 'cdk-skylight/authentication/mad';
+        }
+        this.secret =
+            this.props.secret ??
+                new aws_cdk_lib_1.aws_secretsmanager.Secret(this, 'Secret', {
+                    generateSecretString: {
+                        secretStringTemplate: JSON.stringify({
+                            Domain: props.domainName,
+                            UserID: 'Admin',
+                        }),
+                        generateStringKey: 'Password',
+                        excludePunctuation: true,
+                    },
+                    secretName: props.secretName,
+                });
+        new aws_cdk_lib_1.aws_ssm.StringParameter(this, 'mad-secretName-pointer', {
+            parameterName: `/${this.adParameters.namespace}/${this.adParameters.secretPointer}`,
+            stringValue: this.props.secretName,
+        });
+        let subnets;
+        if (props.vpcSubnets) {
+            if (props.vpcSubnets.hasPublic || props.vpcSubnets.subnets.length !== 2) {
+                throw new Error('A public subnet or not exactly 2 subnets where passed in, please pass in two private subnets');
+            }
+            subnets = props.vpcSubnets;
+        }
+        else {
+            subnets =
+                props.vpc.selectSubnets({
+                    subnetType: aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_WITH_NAT,
+                }) ??
+                    props.vpc.selectSubnets({
+                        subnetType: aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_ISOLATED,
+                    });
+        }
+        new aws_cdk_lib_1.CfnOutput(this, 'secret-value-hint', {
+            value: `aws secretsmanager get-secret-value --secret-id ${this.secret.secretArn} --query SecretString --output text --region ${aws_cdk_lib_1.Stack.of(scope).region}`,
+        });
+        this.microsoftAD = new aws_cdk_lib_1.aws_directoryservice.CfnMicrosoftAD(this, 'AWS-Managed-Microsoft-AD', {
+            password: this.secret
+                .secretValueFromJson('Password')
+                .unsafeUnwrap().toString(),
+            edition: props.edition,
+            name: this.props.domainName,
+            vpcSettings: {
+                subnetIds: [subnets.subnetIds[0], subnets.subnetIds[1]],
+                vpcId: props.vpc.vpcId,
+            },
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'mad-dns-ips', {
+            value: `${aws_cdk_lib_1.Fn.join(',', this.microsoftAD.attrDnsIpAddresses)}`,
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'mad-dns-name', {
+            value: `${this.props.domainName}`,
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'mad-directoyID', {
+            value: `${this.microsoftAD.ref}`,
+        });
+        new aws_cdk_lib_1.aws_ssm.StringParameter(this, 'mad-directoryID-pointer', {
+            parameterName: `/${this.adParameters.namespace}/${this.adParameters.directoryIDPointer}`,
+            stringValue: this.microsoftAD.ref,
+        });
+        if (this.props.createWorker) {
+            this.domainWindowsNode = this.createWorker(this.props.domainName, this.secret);
+            this.domainWindowsNode.runPSwithDomainAdmin([
+                'Add-WindowsFeature RSAT-AD-PowerShell',
+                'Stop-Computer -ComputerName localhost',
+            ], 'ad-powershell');
+            this.domainWindowsNode.instance.node.addDependency(this.microsoftAD);
+        }
+        else {
+            this.domainWindowsNode = undefined;
+        }
+    }
+    // Creates DomainWindowsNode that will be used to run admin-tasks to this directory
+    createWorker(domainName, domainPassword) {
+        return new skylight.compute.DomainWindowsNode(this, 'madWorker', {
+            domainName: domainName,
+            passwordObject: domainPassword,
+            vpc: this.props.vpc,
+            instanceType: 't3.small',
+            usePrivateSubnet: true,
+        });
+    }
+    // The function creates a Lambda to Start the Windows Worker, then creates SSM Document and Desired state in State Manager to schedule this document on the Worker.
+    createADGroup(groupName, groupDescription) {
+        if (this.domainWindowsNode) {
+            this.domainWindowsNode.startInstance();
+            this.domainWindowsNode.runPSwithDomainAdmin([
+                `New-ADGroup -Name "${groupDescription}" -SamAccountName "${groupName}" -GroupScope DomainLocal`,
+                'Stop-Computer -ComputerName localhost',
+            ], 'createAdGroup');
+        }
+        else {
+            console.log("Can't create AD group when no Worker is defined");
+        }
+    }
+    // Experimental
+    createServiceAccount(adServiceAccountName, servicePrincipalNames, principalsAllowedToRetrieveManagedPassword) {
+        if (this.domainWindowsNode) {
+            this.domainWindowsNode.runPSwithDomainAdmin([
+                `New-ADServiceAccount -Name "${adServiceAccountName}" -DnsHostName "${adServiceAccountName}.${this.props.domainName}" -ServicePrincipalNames "${servicePrincipalNames}" -PrincipalsAllowedToRetrieveManagedPassword "${principalsAllowedToRetrieveManagedPassword}"`,
+            ], 'createServiceAccount');
+        }
+        else {
+            console.log("Can't createServiceAccount when no Worker is defined");
+        }
+    }
+}
+exports.AwsManagedMicrosoftAd = AwsManagedMicrosoftAd;
+_a = JSII_RTTI_SYMBOL_1;
+AwsManagedMicrosoftAd[_a] = { fqn: "cdk-skylight.authentication.AwsManagedMicrosoftAd", version: "0.0.0" };
+/**
+ * A Ad Authentication represents an integration pattern of Managed AD and Route 53 Resolver in a specific VPC
+ *
+ * The Construct creates Managed AD with the provided Secret (Secrets Manager) or generates a new Secret.
+ * The secret saved to SSM parameter store so others can use it with other Constructs (Such as Windows node or FSx)
+ * The provided VPC or the new created VPC will be configured to forward DNS requests to the Managed AD with Route53 Resolvers
+ * The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createADGroup)
+ *
+ * The createADGroup() method creates an Active Directory permission group in the domain, using the domain admin user.
+ * Please note: When calling createADGroup() API, a Lambda will be created to start the worker machine (Using AWS-SDK),
+ * then each command will be scheduled with State Manager, and the instance will be shut down after complete.
+ *
+ */
+class AwsManagedMicrosoftAdR53 extends AwsManagedMicrosoftAd {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        let subnets;
+        if (props.vpcSubnets) {
+            if (props.vpcSubnets.hasPublic || props.vpcSubnets.subnets.length !== 2) {
+                throw new Error('A public subnet or not exactly 2 subnets where passed in, please pass in two private subnets');
+            }
+            subnets = props.vpcSubnets;
+        }
+        else {
+            subnets =
+                props.vpc.selectSubnets({
+                    subnetType: aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_WITH_NAT,
+                }) ??
+                    props.vpc.selectSubnets({
+                        subnetType: aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_ISOLATED,
+                    });
+        }
+        const sg = new aws_cdk_lib_1.aws_ec2.SecurityGroup(this, 'r53-outbound-resolver-SG', {
+            vpc: props.vpc,
+        });
+        sg.addIngressRule(aws_cdk_lib_1.aws_ec2.Peer.ipv4(props.vpc.vpcCidrBlock), aws_cdk_lib_1.aws_ec2.Port.udp(53));
+        sg.addIngressRule(aws_cdk_lib_1.aws_ec2.Peer.ipv4(props.vpc.vpcCidrBlock), aws_cdk_lib_1.aws_ec2.Port.tcp(53));
+        const outBoundResolver = new aws_cdk_lib_1.aws_route53resolver.CfnResolverEndpoint(this, 'R53-Resolver-Endpoint', {
+            direction: 'OUTBOUND',
+            ipAddresses: subnets.subnetIds.map((s) => {
+                return { subnetId: s };
+            }),
+            securityGroupIds: [sg.securityGroupId],
+        });
+        const resolverRules = new aws_cdk_lib_1.aws_route53resolver.CfnResolverRule(this, 'R53-Resolve-Rule', {
+            domainName: this.props.domainName,
+            resolverEndpointId: outBoundResolver.ref,
+            ruleType: 'FORWARD',
+            targetIps: [
+                { ip: aws_cdk_lib_1.Fn.select(0, this.microsoftAD.attrDnsIpAddresses) },
+                { ip: aws_cdk_lib_1.Fn.select(1, this.microsoftAD.attrDnsIpAddresses) },
+            ],
+        });
+        new aws_cdk_lib_1.aws_route53resolver.CfnResolverRuleAssociation(this, 'R53-Resolver-Association', {
+            resolverRuleId: resolverRules.attrResolverRuleId,
+            vpcId: props.vpc.vpcId,
+        });
+    }
+}
+exports.AwsManagedMicrosoftAdR53 = AwsManagedMicrosoftAdR53;
+_b = JSII_RTTI_SYMBOL_1;
+AwsManagedMicrosoftAdR53[_b] = { fqn: "cdk-skylight.authentication.AwsManagedMicrosoftAdR53", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ad-authentication.js","sourceRoot":"","sources":["../../src/skylight-authentication/ad-authentication.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n// Imports\nimport {\n  aws_directoryservice as mad,\n  aws_ec2 as ec2,\n  aws_route53resolver as r53resolver,\n  aws_secretsmanager as secretsmanager,\n  aws_ssm,\n  CfnOutput,\n  Fn,\n  Stack,\n} from 'aws-cdk-lib';\nimport { CfnMicrosoftAD } from 'aws-cdk-lib/aws-directoryservice';\nimport { SelectedSubnets } from 'aws-cdk-lib/aws-ec2';\nimport { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport * as skylight from '../index';\n/**\n * The properties for the AwsManagedMicrosoftAd class.\n */\nexport interface IAwsManagedMicrosoftAdProps {\n  /**\n   * The domain name for the Active Directory Domain.\n   *\n   * @default - 'domain.aws'.\n   */\n  domainName?: string;\n  /**\n   * The edition to use for the Active Directory Domain.\n   * Allowed values: Enterprise | Standard\n   * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-directoryservice-microsoftad.html#cfn-directoryservice-microsoftad-edition\n   * @default - 'Standard'.\n   */\n  edition?: string;\n  /**\n   * The secrets manager secret to use must be in format:\n   * '{Domain: <domain.name>, UserID: 'Admin', Password: '<password>'}'\n   * @default - 'Randomly generated and stored in Secret Manager'.\n   */\n  secret?: secretsmanager.ISecret;\n  /**\n   * The secret name to save the Domain Admin object\n   * @default - '<domain.name>-secret'.\n   */\n  secretName?: string;\n  /**\n   * The VPC to use, must have private subnets.\n   */\n  vpc: ec2.IVpc;\n  /**\n   * VPC subnet selection, subnets must be private and exactly 2\n   */\n  vpcSubnets?: ec2.SelectedSubnets;\n  /**\n   * The configuration store to save the directory parameters (After deployed)\n   */\n  configurationStore?: IAwsManagedMicrosoftAdParameters;\n\n  /**\n   * Create Domain joined machine to be used to run Powershell commands to that directory. (i.e Create Ad Group)\n   * @default - 'true'.\n   */\n  createWorker?: boolean;\n}\n\nexport enum AwsManagedMicrosoftConfigurationStoreType {\n  SSM = 'AWS Systems Manager Parameter Store',\n}\n\n/**\n * The properties of an DomainWindowsNodeProps, requires Active Directory parameter to read the Secret to join the domain\n * Default setting: Domain joined, m5.2xlarge, latest windows, Managed by SSM.\n */\nexport interface IAwsManagedMicrosoftAdParameters {\n  /**\n   * The name of the Configuration Store Type to use\n   * @default - 'AWS Systems Manager Parameter Store'.\n   */\n  configurationStoreType?: AwsManagedMicrosoftConfigurationStoreType;\n  /**\n   * The name of the SSM Object that contains the secret name in Secrets Manager\n   * @default - 'domain-secret'.\n   */\n  secretPointer?: string;\n\n  /**\n   * The name of the SSM Object that contains the Directory ID\n   * @default - 'directoryID'.\n   */\n  directoryIDPointer?: string;\n\n  /**\n   * The SSM namespace to read/write parameters to\n   * @default - 'cdk-skylight'.\n   */\n  namespace?: string;\n}\n\n/**\n * A Ad Authentication represents an integration pattern of Managed AD and Route 53 Resolver in a specific VPC\n *\n * The Construct creates Managed AD with the provided Secret (Secrets Manager) or generates a new Secret.\n * The secret saved to SSM parameter store so others can use it with other Constructs (Such as Windows node or FSx)\n * The provided VPC or the new created VPC will be configured to forward DNS requests to the Managed AD with Route53 Resolvers\n * The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createADGroup)\n *\n * The createADGroup() method creates an Active Directory permission group in the domain, using the domain admin user.\n * Please note: When calling createADGroup() API, a Lambda will be created to start the worker machine (Using AWS-SDK),\n * then each command will be scheduled with State Manager, and the instance will be shut down after complete.\n *\n */\nexport class AwsManagedMicrosoftAd extends Construct {\n  readonly microsoftAD: CfnMicrosoftAD;\n  readonly adParameters: IAwsManagedMicrosoftAdParameters;\n  readonly props: IAwsManagedMicrosoftAdProps;\n  readonly domainWindowsNode?: skylight.compute.DomainWindowsNode;\n  readonly secret: ISecret;\n  constructor(\n    scope: Construct,\n    id: string,\n    props: IAwsManagedMicrosoftAdProps,\n  ) {\n    super(scope, id);\n    this.props = props;\n    this.props.domainName = props.domainName ?? 'domain.aws';\n    this.props.edition = props.edition ?? 'Standard';\n    this.props.secretName = props.secretName ?? `${props.domainName}-secret`;\n    this.props.createWorker = props.createWorker ?? true;\n\n    this.adParameters = props.configurationStore ?? {\n      configurationStoreType: AwsManagedMicrosoftConfigurationStoreType.SSM,\n    };\n    this.adParameters.secretPointer =\n      this.adParameters.secretPointer ?? 'domain-secret';\n\n    this.adParameters.directoryIDPointer =\n      this.adParameters.directoryIDPointer ?? 'directoryID';\n\n    if (this.adParameters.namespace) {\n      this.adParameters.namespace = `${this.adParameters.namespace}/authentication/mad`;\n    } else {\n      this.adParameters.namespace = 'cdk-skylight/authentication/mad';\n    }\n\n    this.secret =\n      this.props.secret ??\n      new secretsmanager.Secret(this, 'Secret', {\n        generateSecretString: {\n          secretStringTemplate: JSON.stringify({\n            Domain: props.domainName,\n            UserID: 'Admin',\n          }),\n          generateStringKey: 'Password',\n          excludePunctuation: true,\n        },\n        secretName: props.secretName,\n      });\n\n    new aws_ssm.StringParameter(this, 'mad-secretName-pointer', {\n      parameterName: `/${this.adParameters.namespace}/${this.adParameters.secretPointer}`,\n      stringValue: this.props.secretName,\n    });\n\n    let subnets: SelectedSubnets;\n    if (props.vpcSubnets) {\n      if (props.vpcSubnets.hasPublic || props.vpcSubnets.subnets.length !== 2) {\n        throw new Error(\n          'A public subnet or not exactly 2 subnets where passed in, please pass in two private subnets',\n        );\n      }\n      subnets = props.vpcSubnets;\n    } else {\n      subnets =\n        props.vpc.selectSubnets({\n          subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,\n        }) ??\n        props.vpc.selectSubnets({\n          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,\n        });\n    }\n\n    new CfnOutput(this, 'secret-value-hint', {\n      value: `aws secretsmanager get-secret-value --secret-id ${\n        this.secret.secretArn\n      } --query SecretString --output text --region ${Stack.of(scope).region}`,\n    });\n\n    this.microsoftAD = new mad.CfnMicrosoftAD(\n      this,\n      'AWS-Managed-Microsoft-AD',\n      {\n        password: this.secret\n          .secretValueFromJson('Password')\n          .unsafeUnwrap().toString(),\n        edition: props.edition,\n        name: this.props.domainName,\n        vpcSettings: {\n          subnetIds: [subnets.subnetIds[0], subnets.subnetIds[1]],\n          vpcId: props.vpc.vpcId,\n        },\n      },\n    );\n\n    new CfnOutput(this, 'mad-dns-ips', {\n      value: `${Fn.join(',', this.microsoftAD.attrDnsIpAddresses)}`,\n    });\n\n    new CfnOutput(this, 'mad-dns-name', {\n      value: `${this.props.domainName}`,\n    });\n\n    new CfnOutput(this, 'mad-directoyID', {\n      value: `${this.microsoftAD.ref}`,\n    });\n\n    new aws_ssm.StringParameter(this, 'mad-directoryID-pointer', {\n      parameterName: `/${this.adParameters.namespace}/${this.adParameters.directoryIDPointer}`,\n      stringValue: this.microsoftAD.ref,\n    });\n\n    if (this.props.createWorker) {\n      this.domainWindowsNode = this.createWorker(\n        this.props.domainName,\n        this.secret,\n      );\n      this.domainWindowsNode.runPSwithDomainAdmin(\n        [\n          'Add-WindowsFeature RSAT-AD-PowerShell',\n          'Stop-Computer -ComputerName localhost',\n        ],\n        'ad-powershell',\n      );\n      this.domainWindowsNode.instance.node.addDependency(this.microsoftAD);\n    } else {\n      this.domainWindowsNode = undefined;\n    }\n  }\n\n  // Creates DomainWindowsNode that will be used to run admin-tasks to this directory\n  createWorker(\n    domainName: string,\n    domainPassword: ISecret,\n  ): skylight.compute.DomainWindowsNode {\n    return new skylight.compute.DomainWindowsNode(this, 'madWorker', {\n      domainName: domainName,\n      passwordObject: domainPassword,\n      vpc: this.props.vpc,\n      instanceType: 't3.small',\n      usePrivateSubnet: true,\n    });\n  }\n\n  // The function creates a Lambda to Start the Windows Worker, then creates SSM Document and Desired state in State Manager to schedule this document on the Worker.\n  createADGroup(groupName: string, groupDescription: string) {\n    if (this.domainWindowsNode) {\n      this.domainWindowsNode.startInstance();\n      this.domainWindowsNode.runPSwithDomainAdmin(\n        [\n          `New-ADGroup -Name \"${groupDescription}\" -SamAccountName \"${groupName}\" -GroupScope DomainLocal`,\n          'Stop-Computer -ComputerName localhost',\n        ],\n        'createAdGroup',\n      );\n    } else {\n      console.log(\"Can't create AD group when no Worker is defined\");\n    }\n  }\n\n  // Experimental\n  createServiceAccount(\n    adServiceAccountName: string,\n    servicePrincipalNames: string,\n    principalsAllowedToRetrieveManagedPassword: string,\n  ) {\n    if (this.domainWindowsNode) {\n      this.domainWindowsNode.runPSwithDomainAdmin(\n        [\n          `New-ADServiceAccount -Name \"${adServiceAccountName}\" -DnsHostName \"${adServiceAccountName}.${this.props.domainName}\" -ServicePrincipalNames \"${servicePrincipalNames}\" -PrincipalsAllowedToRetrieveManagedPassword \"${principalsAllowedToRetrieveManagedPassword}\"`,\n        ],\n        'createServiceAccount',\n      );\n    } else {\n      console.log(\"Can't createServiceAccount when no Worker is defined\");\n    }\n  }\n}\n\n/**\n * A Ad Authentication represents an integration pattern of Managed AD and Route 53 Resolver in a specific VPC\n *\n * The Construct creates Managed AD with the provided Secret (Secrets Manager) or generates a new Secret.\n * The secret saved to SSM parameter store so others can use it with other Constructs (Such as Windows node or FSx)\n * The provided VPC or the new created VPC will be configured to forward DNS requests to the Managed AD with Route53 Resolvers\n * The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createADGroup)\n *\n * The createADGroup() method creates an Active Directory permission group in the domain, using the domain admin user.\n * Please note: When calling createADGroup() API, a Lambda will be created to start the worker machine (Using AWS-SDK),\n * then each command will be scheduled with State Manager, and the instance will be shut down after complete.\n *\n */\nexport class AwsManagedMicrosoftAdR53 extends AwsManagedMicrosoftAd {\n  constructor(\n    scope: Construct,\n    id: string,\n    props: IAwsManagedMicrosoftAdProps,\n  ) {\n    super(scope, id, props);\n\n    let subnets: SelectedSubnets;\n    if (props.vpcSubnets) {\n      if (props.vpcSubnets.hasPublic || props.vpcSubnets.subnets.length !== 2) {\n        throw new Error(\n          'A public subnet or not exactly 2 subnets where passed in, please pass in two private subnets',\n        );\n      }\n      subnets = props.vpcSubnets;\n    } else {\n      subnets =\n        props.vpc.selectSubnets({\n          subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,\n        }) ??\n        props.vpc.selectSubnets({\n          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,\n        });\n    }\n\n    const sg = new ec2.SecurityGroup(this, 'r53-outbound-resolver-SG', {\n      vpc: props.vpc,\n    });\n    sg.addIngressRule(ec2.Peer.ipv4(props.vpc.vpcCidrBlock), ec2.Port.udp(53));\n    sg.addIngressRule(ec2.Peer.ipv4(props.vpc.vpcCidrBlock), ec2.Port.tcp(53));\n\n    const outBoundResolver = new r53resolver.CfnResolverEndpoint(\n      this,\n      'R53-Resolver-Endpoint',\n      {\n        direction: 'OUTBOUND',\n        ipAddresses: subnets.subnetIds.map((s) => {\n          return { subnetId: s };\n        }),\n        securityGroupIds: [sg.securityGroupId],\n      },\n    );\n\n    const resolverRules = new r53resolver.CfnResolverRule(\n      this,\n      'R53-Resolve-Rule',\n      {\n        domainName: this.props.domainName!,\n        resolverEndpointId: outBoundResolver.ref,\n        ruleType: 'FORWARD',\n        targetIps: [\n          { ip: Fn.select(0, this.microsoftAD.attrDnsIpAddresses) },\n          { ip: Fn.select(1, this.microsoftAD.attrDnsIpAddresses) },\n        ],\n      },\n    );\n\n    new r53resolver.CfnResolverRuleAssociation(\n      this,\n      'R53-Resolver-Association',\n      {\n        resolverRuleId: resolverRules.attrResolverRuleId,\n        vpcId: props.vpc.vpcId,\n      },\n    );\n  }\n}\n"]}

package/lib/skylight-authentication/index.d.ts

@@ -0,0 +1 @@
+export * from './ad-authentication';

package/lib/skylight-authentication/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ad-authentication"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2t5bGlnaHQtYXV0aGVudGljYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWQtYXV0aGVudGljYXRpb24nOyJdfQ==

package/lib/skylight-compute/eks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './windows-eks-cluster';
+export * from './windows-eks-nodes';

package/lib/skylight-compute/eks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./windows-eks-cluster"), exports);
+__exportStar(require("./windows-eks-nodes"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2t5bGlnaHQtY29tcHV0ZS9la3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdEQUFzQztBQUN0QyxzREFBb0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dpbmRvd3MtZWtzLWNsdXN0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi93aW5kb3dzLWVrcy1ub2Rlcyc7Il19

package/lib/skylight-compute/eks/windows-eks-cluster.d.ts

@@ -0,0 +1,38 @@
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import { aws_ec2, aws_eks } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export interface IWindowsEKSClusterProps {
+    vpc: aws_ec2.IVpc;
+    /**
+       * The Windows EKS Cluster parameters
+       * @default - 'No default'.
+       */
+    eksSsmParameters?: IWindowsEKSClusterParameters;
+}
+export interface IWindowsEKSClusterParameters {
+    /**
+       * The name of the SSM Object that contains the EKS Cluster name
+       * @default - 'windows-eks-cluster-name'.
+       */
+    clusterNamePointer?: string;
+    /**
+       * The SSM namespace to read/write parameters to
+       * @default - 'cdk-skylight/compute/eks'.
+       */
+    namespace?: string;
+}
+export declare class WindowsEKSCluster extends Construct {
+    readonly eksCluster: aws_eks.Cluster;
+    constructor(scope: Construct, id: string, props: IWindowsEKSClusterProps);
+}

package/lib/skylight-compute/eks/windows-eks-cluster.js

@@ -0,0 +1,77 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsEKSCluster = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+// Imports
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+class WindowsEKSCluster extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        props.eksSsmParameters = props.eksSsmParameters ?? {};
+        props.eksSsmParameters.clusterNamePointer =
+            props.eksSsmParameters.clusterNamePointer ?? 'windows-eks-cluster-name';
+        if (props.eksSsmParameters.namespace) {
+            props.eksSsmParameters.namespace = `${props.eksSsmParameters.namespace}/compute/eks`;
+        }
+        else {
+            props.eksSsmParameters.namespace = 'cdk-skylight/compute/eks';
+        }
+        const eks_role = new aws_cdk_lib_1.aws_iam.Role(this, 'eks-instance-role', {
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal('ec2.amazonaws.com'),
+            roleName: 'eks-node-role' + id,
+            managedPolicies: [
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEKSWorkerNodePolicy'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEC2ContainerRegistryReadOnly'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEKS_CNI_Policy'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMDirectoryServiceAccess'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AWSKeyManagementServicePowerUser'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEKSClusterPolicy'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEKSVPCResourceController'),
+            ],
+        });
+        this.eksCluster = new aws_cdk_lib_1.aws_eks.Cluster(this, 'WindowsEKSCluster', {
+            version: aws_cdk_lib_1.aws_eks.KubernetesVersion.V1_21,
+            vpc: props.vpc,
+        });
+        this.eksCluster.awsAuth.addRoleMapping(eks_role, {
+            groups: ['system:bootstrappers', 'system:nodes'],
+            username: 'system:node:{{EC2PrivateDNSName}}',
+        });
+        // https://docs.aws.amazon.com/eks/latest/userguide/windows-support.html#enable-windows-support
+        const yaml_file = {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: {
+                name: 'amazon-vpc-cni',
+                namespace: 'kube-system',
+            },
+            data: {
+                'enable-windows-ipam': 'true',
+            },
+        };
+        this.eksCluster.addManifest('WindowsSupport', yaml_file);
+        new aws_cdk_lib_1.aws_ssm.StringParameter(this, 'clusterNamePointer', {
+            parameterName: `/${props.eksSsmParameters.namespace}/${props.eksSsmParameters.clusterNamePointer}`,
+            stringValue: this.eksCluster.clusterName,
+        });
+    }
+}
+exports.WindowsEKSCluster = WindowsEKSCluster;
+_a = JSII_RTTI_SYMBOL_1;
+WindowsEKSCluster[_a] = { fqn: "cdk-skylight.compute.WindowsEKSCluster", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-eks-cluster.js","sourceRoot":"","sources":["../../../src/skylight-compute/eks/windows-eks-cluster.ts"],"names":[],"mappings":";;;;;AAAA;;;;;;;;;;;GAWG;AAEH,UAAU;AACV,6CAAiE;AACjE,2CAAuC;AA0BvC,MAAa,iBAAkB,SAAQ,sBAAS;IAE9C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA8B;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAC;QACtD,KAAK,CAAC,gBAAgB,CAAC,kBAAkB;YAC1C,KAAK,CAAC,gBAAgB,CAAC,kBAAkB,IAAI,0BAA0B,CAAC;QAEvE,IAAI,KAAK,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC;YACrC,KAAK,CAAC,gBAAgB,CAAC,SAAS,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,SAAS,cAAc,CAAC;QACvF,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,gBAAgB,CAAC,SAAS,GAAG,0BAA0B,CAAC;QAChE,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,qBAAO,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE;YAC3D,SAAS,EAAE,IAAI,qBAAO,CAAC,gBAAgB,CAAC,mBAAmB,CAAC;YAC5D,QAAQ,EAAE,eAAe,GAAG,EAAE;YAC9B,eAAe,EAAE;gBACf,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,8BAA8B,CAC/B;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,2BAA2B,CAC5B;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,oCAAoC,CACrC;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAAC,sBAAsB,CAAC;gBACtE,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,iCAAiC,CAClC;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,kCAAkC,CACnC;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,wBAAwB,CACzB;gBACD,qBAAO,CAAC,aAAa,CAAC,wBAAwB,CAC5C,gCAAgC,CACjC;aACF;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,IAAI,qBAAO,CAAC,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE;YAC/D,OAAO,EAAE,qBAAO,CAAC,iBAAiB,CAAC,KAAK;YACxC,GAAG,EAAE,KAAK,CAAC,GAAG;SACf,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE;YAC/C,MAAM,EAAE,CAAC,sBAAsB,EAAE,cAAc,CAAC;YAChD,QAAQ,EAAE,mCAAmC;SAC9C,CAAC,CAAC;QAEH,+FAA+F;QAC/F,MAAM,SAAS,GAAG;YAChB,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,WAAW;YACjB,QAAQ,EAAE;gBACR,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,aAAa;aACzB;YACD,IAAI,EAAE;gBACJ,qBAAqB,EAAE,MAAM;aAC9B;SACF,CAAC;QACF,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;QAEzD,IAAI,qBAAO,CAAC,eAAe,CAAC,IAAI,EAAE,oBAAoB,EAAE;YACtD,aAAa,EAAE,IAAI,KAAK,CAAC,gBAAgB,CAAC,SAAS,IAAI,KAAK,CAAC,gBAAgB,CAAC,kBAAkB,EAAE;YAClG,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW;SACzC,CAAC,CAAC;IACL,CAAC;;AAxEH,8CAyEC","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n// Imports\nimport { aws_ec2, aws_eks, aws_iam, aws_ssm } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\n\nexport interface IWindowsEKSClusterProps {\n  vpc: aws_ec2.IVpc;\n\n  /**\n\t * The Windows EKS Cluster parameters\n\t * @default - 'No default'.\n\t */\n  eksSsmParameters?: IWindowsEKSClusterParameters;\n}\n\nexport interface IWindowsEKSClusterParameters {\n  /**\n\t * The name of the SSM Object that contains the EKS Cluster name\n\t * @default - 'windows-eks-cluster-name'.\n\t */\n  clusterNamePointer?: string;\n\n  /**\n\t * The SSM namespace to read/write parameters to\n\t * @default - 'cdk-skylight/compute/eks'.\n\t */\n  namespace?: string;\n}\n\nexport class WindowsEKSCluster extends Construct {\n  readonly eksCluster: aws_eks.Cluster;\n  constructor(scope: Construct, id: string, props: IWindowsEKSClusterProps) {\n    super(scope, id);\n\n    props.eksSsmParameters = props.eksSsmParameters ?? {};\n    props.eksSsmParameters.clusterNamePointer =\n\t\t\tprops.eksSsmParameters.clusterNamePointer ?? 'windows-eks-cluster-name';\n\n    if (props.eksSsmParameters.namespace) {\n      props.eksSsmParameters.namespace = `${props.eksSsmParameters.namespace}/compute/eks`;\n    } else {\n      props.eksSsmParameters.namespace = 'cdk-skylight/compute/eks';\n    }\n\n    const eks_role = new aws_iam.Role(this, 'eks-instance-role', {\n      assumedBy: new aws_iam.ServicePrincipal('ec2.amazonaws.com'),\n      roleName: 'eks-node-role' + id,\n      managedPolicies: [\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonSSMManagedInstanceCore',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonEKSWorkerNodePolicy',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonEC2ContainerRegistryReadOnly',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonEKS_CNI_Policy'),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonSSMDirectoryServiceAccess',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AWSKeyManagementServicePowerUser',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonEKSClusterPolicy',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonEKSVPCResourceController',\n        ),\n      ],\n    });\n\n    this.eksCluster = new aws_eks.Cluster(this, 'WindowsEKSCluster', {\n      version: aws_eks.KubernetesVersion.V1_21,\n      vpc: props.vpc,\n    });\n\n    this.eksCluster.awsAuth.addRoleMapping(eks_role, {\n      groups: ['system:bootstrappers', 'system:nodes'],\n      username: 'system:node:{{EC2PrivateDNSName}}',\n    });\n\n    // https://docs.aws.amazon.com/eks/latest/userguide/windows-support.html#enable-windows-support\n    const yaml_file = {\n      apiVersion: 'v1',\n      kind: 'ConfigMap',\n      metadata: {\n        name: 'amazon-vpc-cni',\n        namespace: 'kube-system',\n      },\n      data: {\n        'enable-windows-ipam': 'true',\n      },\n    };\n    this.eksCluster.addManifest('WindowsSupport', yaml_file);\n\n    new aws_ssm.StringParameter(this, 'clusterNamePointer', {\n      parameterName: `/${props.eksSsmParameters.namespace}/${props.eksSsmParameters.clusterNamePointer}`,\n      stringValue: this.eksCluster.clusterName,\n    });\n  }\n}\n"]}

package/lib/skylight-compute/eks/windows-eks-nodes.d.ts

@@ -0,0 +1,68 @@
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import { aws_autoscaling, aws_ec2, aws_eks, aws_iam } from 'aws-cdk-lib';
+import { AutoScalingGroup } from 'aws-cdk-lib/aws-autoscaling';
+import { Construct } from 'constructs';
+import * as skylight from '../../index';
+export interface IRuntimeNodes {
+    /**
+     * Method to add userData to the nodes
+     */
+    addUserData(...commands: string[]): void;
+    /**
+     * Method to configure the Nodes to part of AD Domain
+     * Secret: The secrets manager secret to use must be in format:
+     * '{Domain: <domain.name>, UserID: 'Admin', Password: '<password>'}' (From cdk-skylight.AwsManagedMicrosoftAdR53 Object)
+     */
+    addAdDependency?(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters): void;
+    /**
+     * Method to configure persistent storage dependency to the hosts by using Global Mapping.
+     */
+    addStorageDependency(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters, fsxParametersStore: skylight.storage.IFSxWindowsParameters, folderName: string): void;
+    /**
+     * Method to add the nodes to specific Cluster
+     */
+    addEKSDependency?(eksCluster: aws_eks.Cluster): void;
+    /**
+     * Method to add support for LocalCredFile <Experimental>
+     */
+    addLocalCredFile?(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters, ADGroupName: string, AccountName: string): void;
+}
+export interface IWindowsEKSNodesProps {
+    vpc: aws_ec2.IVpc;
+    /**
+     * The SSM namespace to save parameters to
+     * @default - 'cdk-skylight'.
+     */
+    namespace?: string;
+    /**
+     * The instance to use
+     * @default - 'm5.large'.
+     */
+    instanceType?: aws_ec2.InstanceType;
+}
+export declare class WindowsEKSNodes extends Construct implements IRuntimeNodes {
+    readonly asg: AutoScalingGroup;
+    readonly windowsWorkersRole: aws_iam.Role;
+    readonly asgResource: aws_autoscaling.CfnAutoScalingGroup;
+    readonly vpc: aws_ec2.IVpc;
+    readonly nodesSg: aws_ec2.SecurityGroup;
+    constructor(scope: Construct, id: string, props: IWindowsEKSNodesProps);
+    addUserData(...commands: string[]): void;
+    addAdDependency(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters): void;
+    runPowerShellSSMDocument(name: string, commands: string[]): void;
+    gMSAWebHookAutoInstall(eksCluster: aws_eks.Cluster, privateSignerName: string, awsaccountid: string, awsregion: string): void;
+    addStorageDependency(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters, fsxParametersStore: skylight.storage.IFSxWindowsParameters, folderName: string): void;
+    addEKSDependency(eksCluster: aws_eks.Cluster): void;
+    addLocalCredFile(adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters, ADGroupName: string, AccountName: string): void;
+}