@paulo_raca/cdk-skylight 0.0.0

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

@@ -0,0 +1,250 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsEKSNodes = 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.
+ */
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const skylight = require("../../index");
+class WindowsEKSNodes extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        props.namespace = props.namespace ?? 'cdk-skylight';
+        props.instanceType =
+            props.instanceType ?? new aws_cdk_lib_1.aws_ec2.InstanceType('m5.large');
+        this.vpc = props.vpc;
+        const windows_machineImage = new aws_cdk_lib_1.aws_ec2.LookupMachineImage({
+            name: '*Windows_Server-2019-English-Full-EKS_Optimized-1.21*',
+            windows: true,
+        });
+        this.nodesSg = new aws_cdk_lib_1.aws_ec2.SecurityGroup(this, id + '-securityGroup', {
+            vpc: this.vpc,
+        });
+        this.windowsWorkersRole = new aws_cdk_lib_1.aws_iam.Role(this, 'windows-eks-workers-instance-role', {
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal('ec2.amazonaws.com'),
+            roleName: 'windows-eks-workers-instance-role',
+            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('SecretsManagerReadWrite'),
+            ],
+        });
+        this.asg = new aws_cdk_lib_1.aws_autoscaling.AutoScalingGroup(this, 'WindowsInstancesCapacity', {
+            vpc: props.vpc,
+            role: this.windowsWorkersRole,
+            minCapacity: 2,
+            securityGroup: this.nodesSg,
+            maxCapacity: 10,
+            instanceType: props.instanceType,
+            machineImage: windows_machineImage,
+        });
+        this.asgResource = this.asg.node.children.find((c) => c.cfnResourceType ===
+            'AWS::AutoScaling::AutoScalingGroup');
+    }
+    addUserData(...commands) {
+        this.asg.addUserData(...commands);
+    }
+    addAdDependency(adParametersStore) {
+        const secretName = aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(this, `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`);
+        this.addUserData(`
+			#domain join with secret from secret manager
+			[string]$SecretAD  = "${secretName}"
+			$SecretObj = Get-SECSecretValue -SecretId $SecretAD
+			[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)
+			$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force
+			$username   = $Secret.UserID + "@" + $Secret.Domain
+			$credential = New-Object System.Management.Automation.PSCredential($username,$password)
+			Add-Computer -DomainName $Secret.Domain -Credential $credential
+			Restart-Computer -Force
+		`);
+    }
+    runPowerShellSSMDocument(name, commands) {
+        new aws_cdk_lib_1.aws_ssm.CfnAssociation(this, name, {
+            name: 'AWS-RunPowerShellScript',
+            parameters: {
+                commands: commands,
+            },
+            targets: [
+                {
+                    key: 'tag:aws:autoscaling:groupName',
+                    values: [this.asg.autoScalingGroupName],
+                },
+            ],
+        });
+    }
+    gMSAWebHookAutoInstall(eksCluster, privateSignerName, awsaccountid, awsregion) {
+        const certmanager = new aws_cdk_lib_1.aws_iam.ManagedPolicy(this, 'webHookECR', {
+            description: 'Allow WebHook',
+            statements: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    effect: aws_cdk_lib_1.aws_iam.Effect.ALLOW,
+                    actions: [
+                        'ecr:CreateRepository',
+                        'ecr:DescribeImages',
+                        'ecr:GetAuthorizationToken',
+                        'ecr:GetDownloadUrlForLayer',
+                        'ecr:BatchGetImage',
+                        'ecr:BatchCheckLayerAvailability',
+                        'ecr:GetDownloadUrlForLayer',
+                        'ecr:PutImage',
+                        'ecr:InitiateLayerUpload',
+                        'ecr:UploadLayerPart',
+                        'ecr:CompleteLayerUpload',
+                    ],
+                    resources: ['arn:aws:ecr:*:*:repository/certmanager-ca-controller'],
+                }),
+            ],
+        });
+        const describeCluster = new aws_cdk_lib_1.aws_iam.ManagedPolicy(this, 'AllowWebHookEKSCluster', {
+            description: 'Allow WebHook',
+            statements: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    effect: aws_cdk_lib_1.aws_iam.Effect.ALLOW,
+                    actions: ['eks:DescribeCluster'],
+                    resources: [`arn:aws:eks:*:${awsaccountid}:cluster/*`],
+                }),
+            ],
+        });
+        const allowAuthorizationToken = new aws_cdk_lib_1.aws_iam.ManagedPolicy(this, 'AllowWebHookECRCluster', {
+            description: 'Allow WebHook',
+            statements: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    effect: aws_cdk_lib_1.aws_iam.Effect.ALLOW,
+                    actions: ['ecr:GetAuthorizationToken'],
+                    resources: ['*'],
+                }),
+            ],
+        });
+        const node = new skylight.compute.DomainWindowsNode(this, 'eksWorkerForGMSA', {
+            vpc: this.vpc,
+            windowsMachine: false,
+            iamManagedPoliciesList: [
+                certmanager,
+                describeCluster,
+                allowAuthorizationToken,
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+            ],
+            amiName: '*amzn2-ami-hvm-x86_64*',
+            instanceType: 't3.small',
+        });
+        this.asg.connections.allowFrom(node.instance, aws_cdk_lib_1.aws_ec2.Port.tcp(443));
+        eksCluster.awsAuth.addRoleMapping(node.nodeRole, {
+            groups: ['system:masters'],
+            username: 'admin',
+        });
+        node.runShellCommands([
+            'sudo -i',
+            'yum install -y git',
+            'git clone https://github.com/aws-samples/amazon-eks-gmsa-admission-webhook-autoinstall',
+            'cd amazon-eks-gmsa-admission-webhook-autoinstall/',
+            `bash installation.sh ${awsaccountid} ${awsregion} ${eksCluster.clusterName} ${privateSignerName}/my-signer AL2`,
+        ], 'webHookInstallation');
+    }
+    addStorageDependency(adParametersStore, fsxParametersStore, folderName) {
+        const secretName = aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(this, `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`);
+        const fsxEndpoint = aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(this, `/${fsxParametersStore.namespace}/${fsxParametersStore.dnsEndpoint}`);
+        const smbPath = `\\\\${fsxEndpoint}\\${folderName}`;
+        const commands = [
+            '$bootfix = {',
+            '$LocalDrive = Get-SmbGlobalMapping',
+            'if ($LocalDrive -eq $null)',
+            '{',
+            ` [string]$SecretAD  = '${secretName}'`,
+            ' $SecretObj = Get-SECSecretValue -SecretId $SecretAD',
+            ' [PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',
+            ' $password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',
+            " $username   = $Secret.UserID + '@' + $Secret.Domain",
+            ' $domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',
+            ` New-SmbGlobalMapping -RemotePath '${smbPath}' -Credential $domain_admin_credential -LocalPath G: -Persistent $true -RequirePrivacy $true -ErrorAction Stop`,
+            '}',
+            '}',
+            'New-Item -ItemType Directory -Path c:\\Scripts',
+            '$bootfix | set-content c:\\Scripts\\bootfix.ps1',
+            '# Create a scheduled task on startup to execute the mapping',
+            "$action = New-ScheduledTaskAction -Execute 'Powershell.exe' -Argument 'c:\\scripts\\bootfix.ps1'",
+            '$trigger =  New-ScheduledTaskTrigger -AtStartup',
+            ` [string]$SecretAD  = '${secretName}'`,
+            ' $SecretObj = Get-SECSecretValue -SecretId $SecretAD',
+            ' [PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',
+            " $username   = $Secret.UserID + '@' + $Secret.Domain",
+            "Register-ScheduledTask -Action $action -Trigger $trigger -TaskName 'SmbGlobalMapping' -Description 'Mapping the SMB share and adding machine to gMSA' -RunLevel Highest -User $username -Password $Secret.Password",
+            '# Running the boot fix now',
+            '& $bootfix',
+            '',
+        ];
+        this.runPowerShellSSMDocument('SMBGlobalMapping', commands);
+    }
+    addEKSDependency(eksCluster) {
+        const commands = [
+            '# Joining EKS Cluster',
+            "[string]$EKSBootstrapScriptFile = 'C:\\Program Files\\Amazon\\EKS\\Start-EKSBootstrap.ps1'",
+            `powershell -File $EKSBootstrapScriptFile -EKSClusterName '${eksCluster.clusterName}'`,
+        ];
+        this.runPowerShellSSMDocument('EKSBootstrap', commands);
+        eksCluster.awsAuth.addRoleMapping(this.windowsWorkersRole, {
+            groups: [
+                'system:bootstrappers',
+                'system:nodes',
+                'eks:kube-proxy-windows',
+            ],
+            username: 'system:node:{{EC2PrivateDNSName}}',
+        });
+        eksCluster.connectAutoScalingGroupCapacity(this.asg, {
+            bootstrapEnabled: false, //Windows Bootstrap done manually
+        });
+    }
+    addLocalCredFile(adParametersStore, ADGroupName, AccountName) {
+        const secretName = aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(this, `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`);
+        const commands = [
+            '# Getting AD Password',
+            `[string]$SecretAD  = '${secretName}'`,
+            '$SecretObj = Get-SECSecretValue -SecretId $SecretAD',
+            '[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',
+            '$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',
+            "$username   = $Secret.UserID + '@' + $Secret.Domain",
+            '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',
+            'Add-WindowsFeature RSAT-AD-PowerShell',
+            'Install-PackageProvider NuGet -Force',
+            'Install-Module CredentialSpec -Force',
+            'Set-PSRepository PSGallery -InstallationPolicy Trusted',
+            `New-ADGroup -Name "${ADGroupName} AD Group" -SamAccountName ${ADGroupName}"" -GroupScope DomainLocal -Credential $domain_admin_credential`,
+            `New-ADServiceAccount -Name "${AccountName}" -DnsHostName "${AccountName}.$Secret.Domain" -ServicePrincipalNames "host/${AccountName}", "host/${AccountName}.$Secret.Domain" -PrincipalsAllowedToRetrieveManagedPassword "${ADGroupName}" -Credential $domain_admin_credential`,
+            `Add-ADGroupMember -Identity '${ADGroupName}' -Members $env:computername$ -Credential $domain_admin_credential`,
+            '# Saves the cred file to C:\\ProgramData\\Docker\\CredentialSpecs (default)',
+            '#Here upload to S3 the CredFile',
+            '$bootfix = {',
+            `New-CredentialSpec -AccountName ${AccountName}`,
+            '}',
+            '# Scheduling onboot',
+            '$trigger =  New-ScheduledTaskTrigger -AtStartup',
+            '$bootfix | set-content c:\\Scripts\\gMSA.ps1',
+            "$action = New-ScheduledTaskAction -Execute 'Powershell.exe' -Argument 'c:\\scripts\\gMSA.ps1'",
+            "Register-ScheduledTask -Action $action -Trigger $trigger -TaskName 'CreateCredSpecFile' -Description 'CreateCredFile and saves it in default folder' -RunLevel Highest -User $username -Password $Secret.Password",
+            '# Reboot to apply changes',
+            'Restart-Computer -Force',
+            '',
+        ];
+        this.runPowerShellSSMDocument('gMSA_AD_Group_CredFile', commands);
+    }
+}
+exports.WindowsEKSNodes = WindowsEKSNodes;
+_a = JSII_RTTI_SYMBOL_1;
+WindowsEKSNodes[_a] = { fqn: "cdk-skylight.compute.WindowsEKSNodes", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-eks-nodes.js","sourceRoot":"","sources":["../../../src/skylight-compute/eks/windows-eks-nodes.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\nimport {\n  aws_autoscaling,\n  aws_ec2,\n  aws_eks,\n  aws_iam,\n  aws_ssm,\n  CfnResource,\n} from 'aws-cdk-lib';\nimport { AutoScalingGroup } from 'aws-cdk-lib/aws-autoscaling';\nimport { Construct } from 'constructs';\nimport * as skylight from '../../index';\n\nexport interface IRuntimeNodes {\n  /**\n   * Method to add userData to the nodes\n   */\n  addUserData(...commands: string[]): void;\n  /**\n   * Method to configure the Nodes to part of AD Domain\n   * Secret: The secrets manager secret to use must be in format:\n   * '{Domain: <domain.name>, UserID: 'Admin', Password: '<password>'}' (From cdk-skylight.AwsManagedMicrosoftAdR53 Object)\n   */\n  addAdDependency?(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters\n  ): void;\n  /**\n   * Method to configure persistent storage dependency to the hosts by using Global Mapping.\n   */\n  addStorageDependency(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters,\n    fsxParametersStore: skylight.storage.IFSxWindowsParameters,\n    folderName: string\n  ): void;\n\n  /**\n   * Method to add the nodes to specific Cluster\n   */\n  addEKSDependency?(eksCluster: aws_eks.Cluster): void;\n\n  /**\n   * Method to add support for LocalCredFile <Experimental>\n   */\n  addLocalCredFile?(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters,\n    ADGroupName: string,\n    AccountName: string\n  ): void;\n}\n\nexport interface IWindowsEKSNodesProps {\n  vpc: aws_ec2.IVpc;\n  /**\n   * The SSM namespace to save parameters to\n   * @default - 'cdk-skylight'.\n   */\n  namespace?: string;\n\n  /**\n   * The instance to use\n   * @default - 'm5.large'.\n   */\n  instanceType?: aws_ec2.InstanceType;\n}\n\nexport class WindowsEKSNodes extends Construct implements IRuntimeNodes {\n  readonly asg: AutoScalingGroup;\n  readonly windowsWorkersRole: aws_iam.Role;\n  readonly asgResource: aws_autoscaling.CfnAutoScalingGroup;\n  readonly vpc: aws_ec2.IVpc;\n  readonly nodesSg: aws_ec2.SecurityGroup;\n\n  constructor(scope: Construct, id: string, props: IWindowsEKSNodesProps) {\n    super(scope, id);\n\n    props.namespace = props.namespace ?? 'cdk-skylight';\n    props.instanceType =\n      props.instanceType ?? new aws_ec2.InstanceType('m5.large');\n\n    this.vpc = props.vpc;\n\n    const windows_machineImage = new aws_ec2.LookupMachineImage({\n      name: '*Windows_Server-2019-English-Full-EKS_Optimized-1.21*',\n      windows: true,\n    });\n\n    this.nodesSg = new aws_ec2.SecurityGroup(this, id + '-securityGroup', {\n      vpc: this.vpc,\n    });\n    this.windowsWorkersRole = new aws_iam.Role(\n      this,\n      'windows-eks-workers-instance-role',\n      {\n        assumedBy: new aws_iam.ServicePrincipal('ec2.amazonaws.com'),\n        roleName: 'windows-eks-workers-instance-role',\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(\n            'AmazonEKS_CNI_Policy',\n          ),\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            'SecretsManagerReadWrite',\n          ),\n        ],\n      },\n    );\n\n    this.asg = new aws_autoscaling.AutoScalingGroup(\n      this,\n      'WindowsInstancesCapacity',\n      {\n        vpc: props.vpc,\n        role: this.windowsWorkersRole,\n        minCapacity: 2,\n        securityGroup: this.nodesSg,\n        maxCapacity: 10,\n        instanceType: props.instanceType,\n        machineImage: windows_machineImage,\n      },\n    );\n\n    this.asgResource = this.asg.node.children.find(\n      (c) =>\n        (c as CfnResource).cfnResourceType ===\n        'AWS::AutoScaling::AutoScalingGroup',\n    ) as aws_autoscaling.CfnAutoScalingGroup;\n  }\n\n  addUserData(...commands: string[]) {\n    this.asg.addUserData(...commands);\n  }\n\n  addAdDependency(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters,\n  ) {\n    const secretName = aws_ssm.StringParameter.valueForStringParameter(\n      this,\n      `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`,\n    );\n\n    this.addUserData(`\n\t\t\t#domain join with secret from secret manager\n\t\t\t[string]$SecretAD  = \"${secretName}\"\n\t\t\t$SecretObj = Get-SECSecretValue -SecretId $SecretAD\n\t\t\t[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)\n\t\t\t$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force\n\t\t\t$username   = $Secret.UserID + \"@\" + $Secret.Domain\n\t\t\t$credential = New-Object System.Management.Automation.PSCredential($username,$password)\n\t\t\tAdd-Computer -DomainName $Secret.Domain -Credential $credential\n\t\t\tRestart-Computer -Force\n\t\t`);\n  }\n\n  runPowerShellSSMDocument(name: string, commands: string[]) {\n    new aws_ssm.CfnAssociation(this, name, {\n      name: 'AWS-RunPowerShellScript',\n      parameters: {\n        commands: commands,\n      },\n      targets: [\n        {\n          key: 'tag:aws:autoscaling:groupName',\n          values: [this.asg.autoScalingGroupName],\n        },\n      ],\n    });\n  }\n\n  gMSAWebHookAutoInstall(\n    eksCluster: aws_eks.Cluster,\n    privateSignerName: string,\n    awsaccountid: string,\n    awsregion: string,\n  ) {\n    const certmanager = new aws_iam.ManagedPolicy(this, 'webHookECR', {\n      description: 'Allow WebHook',\n      statements: [\n        new aws_iam.PolicyStatement({\n          effect: aws_iam.Effect.ALLOW,\n          actions: [\n            'ecr:CreateRepository',\n            'ecr:DescribeImages',\n            'ecr:GetAuthorizationToken',\n            'ecr:GetDownloadUrlForLayer',\n            'ecr:BatchGetImage',\n            'ecr:BatchCheckLayerAvailability',\n            'ecr:GetDownloadUrlForLayer',\n            'ecr:PutImage',\n            'ecr:InitiateLayerUpload',\n            'ecr:UploadLayerPart',\n            'ecr:CompleteLayerUpload',\n          ],\n          resources: ['arn:aws:ecr:*:*:repository/certmanager-ca-controller'],\n        }),\n      ],\n    });\n\n    const describeCluster = new aws_iam.ManagedPolicy(\n      this,\n      'AllowWebHookEKSCluster',\n      {\n        description: 'Allow WebHook',\n        statements: [\n          new aws_iam.PolicyStatement({\n            effect: aws_iam.Effect.ALLOW,\n            actions: ['eks:DescribeCluster'],\n            resources: [`arn:aws:eks:*:${awsaccountid}:cluster/*`],\n          }),\n        ],\n      },\n    );\n\n    const allowAuthorizationToken = new aws_iam.ManagedPolicy(\n      this,\n      'AllowWebHookECRCluster',\n      {\n        description: 'Allow WebHook',\n        statements: [\n          new aws_iam.PolicyStatement({\n            effect: aws_iam.Effect.ALLOW,\n            actions: ['ecr:GetAuthorizationToken'],\n            resources: ['*'],\n          }),\n        ],\n      },\n    );\n\n    const node = new skylight.compute.DomainWindowsNode(\n      this,\n      'eksWorkerForGMSA',\n      {\n        vpc: this.vpc,\n        windowsMachine: false,\n        iamManagedPoliciesList: [\n          certmanager,\n          describeCluster,\n          allowAuthorizationToken,\n          aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n            'AmazonSSMManagedInstanceCore',\n          ),\n        ],\n        amiName: '*amzn2-ami-hvm-x86_64*',\n        instanceType: 't3.small',\n      },\n    );\n\n    this.asg.connections.allowFrom(node.instance, aws_ec2.Port.tcp(443));\n\n    eksCluster.awsAuth.addRoleMapping(node.nodeRole, {\n      groups: ['system:masters'],\n      username: 'admin',\n    });\n\n    node.runShellCommands(\n      [\n        'sudo -i',\n        'yum install -y git',\n        'git clone https://github.com/aws-samples/amazon-eks-gmsa-admission-webhook-autoinstall',\n        'cd amazon-eks-gmsa-admission-webhook-autoinstall/',\n        `bash installation.sh ${awsaccountid} ${awsregion} ${eksCluster.clusterName} ${privateSignerName}/my-signer AL2`,\n      ],\n      'webHookInstallation',\n    );\n  }\n\n  addStorageDependency(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters,\n    fsxParametersStore: skylight.storage.IFSxWindowsParameters,\n    folderName: string,\n  ) {\n    const secretName = aws_ssm.StringParameter.valueForStringParameter(\n      this,\n      `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`,\n    );\n\n    const fsxEndpoint = aws_ssm.StringParameter.valueForStringParameter(\n      this,\n      `/${fsxParametersStore.namespace}/${fsxParametersStore.dnsEndpoint}`,\n    );\n\n    const smbPath = `\\\\\\\\${fsxEndpoint}\\\\${folderName}`;\n\n    const commands = [\n      '$bootfix = {',\n      '$LocalDrive = Get-SmbGlobalMapping',\n      'if ($LocalDrive -eq $null)',\n      '{',\n      ` [string]$SecretAD  = '${secretName}'`,\n      ' $SecretObj = Get-SECSecretValue -SecretId $SecretAD',\n      ' [PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',\n      ' $password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',\n      \" $username   = $Secret.UserID + '@' + $Secret.Domain\",\n      ' $domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',\n      ` New-SmbGlobalMapping -RemotePath '${smbPath}' -Credential $domain_admin_credential -LocalPath G: -Persistent $true -RequirePrivacy $true -ErrorAction Stop`,\n      '}',\n      '}',\n      'New-Item -ItemType Directory -Path c:\\\\Scripts',\n      '$bootfix | set-content c:\\\\Scripts\\\\bootfix.ps1',\n      '# Create a scheduled task on startup to execute the mapping',\n      \"$action = New-ScheduledTaskAction -Execute 'Powershell.exe' -Argument 'c:\\\\scripts\\\\bootfix.ps1'\",\n      '$trigger =  New-ScheduledTaskTrigger -AtStartup',\n      ` [string]$SecretAD  = '${secretName}'`,\n      ' $SecretObj = Get-SECSecretValue -SecretId $SecretAD',\n      ' [PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',\n      \" $username   = $Secret.UserID + '@' + $Secret.Domain\",\n      \"Register-ScheduledTask -Action $action -Trigger $trigger -TaskName 'SmbGlobalMapping' -Description 'Mapping the SMB share and adding machine to gMSA' -RunLevel Highest -User $username -Password $Secret.Password\",\n      '# Running the boot fix now',\n      '& $bootfix',\n      '',\n    ];\n    this.runPowerShellSSMDocument('SMBGlobalMapping', commands);\n  }\n\n  addEKSDependency(eksCluster: aws_eks.Cluster) {\n    const commands = [\n      '# Joining EKS Cluster',\n      \"[string]$EKSBootstrapScriptFile = 'C:\\\\Program Files\\\\Amazon\\\\EKS\\\\Start-EKSBootstrap.ps1'\",\n      `powershell -File $EKSBootstrapScriptFile -EKSClusterName '${eksCluster.clusterName}'`,\n    ];\n    this.runPowerShellSSMDocument('EKSBootstrap', commands);\n    eksCluster.awsAuth.addRoleMapping(this.windowsWorkersRole, {\n      groups: [\n        'system:bootstrappers',\n        'system:nodes',\n        'eks:kube-proxy-windows',\n      ],\n      username: 'system:node:{{EC2PrivateDNSName}}',\n    });\n    eksCluster.connectAutoScalingGroupCapacity(this.asg, {\n      bootstrapEnabled: false, //Windows Bootstrap done manually\n    });\n  }\n\n  addLocalCredFile(\n    adParametersStore: skylight.authentication.IAwsManagedMicrosoftAdParameters,\n    ADGroupName: string,\n    AccountName: string,\n  ) {\n    const secretName = aws_ssm.StringParameter.valueForStringParameter(\n      this,\n      `/${adParametersStore.namespace}/${adParametersStore.secretPointer}`,\n    );\n\n    const commands = [\n      '# Getting AD Password',\n      `[string]$SecretAD  = '${secretName}'`,\n      '$SecretObj = Get-SECSecretValue -SecretId $SecretAD',\n      '[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',\n      '$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',\n      \"$username   = $Secret.UserID + '@' + $Secret.Domain\",\n      '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',\n      'Add-WindowsFeature RSAT-AD-PowerShell',\n      'Install-PackageProvider NuGet -Force',\n      'Install-Module CredentialSpec -Force',\n      'Set-PSRepository PSGallery -InstallationPolicy Trusted',\n      `New-ADGroup -Name \"${ADGroupName} AD Group\" -SamAccountName ${ADGroupName}\"\" -GroupScope DomainLocal -Credential $domain_admin_credential`,\n      `New-ADServiceAccount -Name \"${AccountName}\" -DnsHostName \"${AccountName}.$Secret.Domain\" -ServicePrincipalNames \"host/${AccountName}\", \"host/${AccountName}.$Secret.Domain\" -PrincipalsAllowedToRetrieveManagedPassword \"${ADGroupName}\" -Credential $domain_admin_credential`,\n      `Add-ADGroupMember -Identity '${ADGroupName}' -Members $env:computername$ -Credential $domain_admin_credential`,\n      '# Saves the cred file to C:\\\\ProgramData\\\\Docker\\\\CredentialSpecs (default)',\n      '#Here upload to S3 the CredFile',\n      '$bootfix = {',\n      `New-CredentialSpec -AccountName ${AccountName}`,\n      '}',\n      '# Scheduling onboot',\n      '$trigger =  New-ScheduledTaskTrigger -AtStartup',\n      '$bootfix | set-content c:\\\\Scripts\\\\gMSA.ps1',\n      \"$action = New-ScheduledTaskAction -Execute 'Powershell.exe' -Argument 'c:\\\\scripts\\\\gMSA.ps1'\",\n      \"Register-ScheduledTask -Action $action -Trigger $trigger -TaskName 'CreateCredSpecFile' -Description 'CreateCredFile and saves it in default folder' -RunLevel Highest -User $username -Password $Secret.Password\",\n      '# Reboot to apply changes',\n      'Restart-Computer -Force',\n      '',\n    ];\n\n    this.runPowerShellSSMDocument('gMSA_AD_Group_CredFile', commands);\n  }\n}\n"]}

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

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

package/lib/skylight-compute/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-node"), exports);
+__exportStar(require("./eks"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2t5bGlnaHQtY29tcHV0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vd2luZG93cy1ub2RlJztcbmV4cG9ydCAqIGZyb20gJy4vZWtzJzsiXX0=

package/lib/skylight-compute/windows-node.d.ts

@@ -0,0 +1,102 @@
+/**
+ *  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_iam as iam, aws_ec2 as ec2, aws_secretsmanager } from 'aws-cdk-lib';
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+/**
+ * The properties of an DomainWindowsNodeProps, requires Active Directory parameter to read the Secret to join the domain
+ * Default setting: Domain joined, m5.2xlarge, latest windows, Managed by SSM.
+ */
+export interface IDomainWindowsNodeProps {
+    /**
+     * IAM Instance role permissions
+     * @default - 'AmazonSSMManagedInstanceCore, AmazonSSMDirectoryServiceAccess'.
+     */
+    iamManagedPoliciesList?: iam.IManagedPolicy[];
+    /**
+     * The EC2 Instance type to use
+     *
+     * @default - 'm5.2xlarge'.
+     */
+    instanceType?: string;
+    /**
+     * Choose if to launch the instance in Private or in Public subnet
+     * Private = Subnet that routes to the internet, but not vice versa.
+     * Public = Subnet that routes to the internet and vice versa.
+     * @default - Private.
+     */
+    usePrivateSubnet?: boolean;
+    /**
+     * The name of the AMI to search in SSM (ec2.LookupNodeImage) supports Regex
+     *  @default - 'Windows_Server-2022-English-Full'
+     */
+    amiName?: string;
+    /**
+     * Specific UserData to use
+     *
+     * The UserData may still be mutated after creation.
+     *
+     *  @default - 'undefined'
+     */
+    userData?: string;
+    domainName?: string;
+    passwordObject?: aws_secretsmanager.ISecret;
+    /**
+     * @default - 'true'
+     */
+    windowsMachine?: boolean;
+    /**
+     * The VPC to use
+     */
+    vpc: ec2.IVpc;
+}
+/**
+ * A Domain Windows Node represents one Windows EC2 instance configured with Active Directory.
+ *
+ * The DomainWindowsNode can be customized to different instance sizes and additional permissions set just like any other EC2 Instance.
+ * You can use this construct to run elevated domain tasks with domain permissions or run your application in a single instance setup.
+ *
+ * The machine will be joined to the provided Active Directory domain using a custom CloudFormation bootstrap that will wait until the required reboot to join the domain. Then it will register the machine in SSM and pull tasks from the SSM State manager.
+ *
+ * You can send tasks to that machine using the provided methods: runPsCommands() and runPSwithDomainAdmin()
+ *
+ */
+export declare class DomainWindowsNode extends Construct {
+    readonly instance: ec2.Instance;
+    readonly nodeRole: iam.Role;
+    readonly vpc: ec2.IVpc;
+    readonly passwordObject?: ISecret;
+    constructor(scope: Construct, id: string, props: IDomainWindowsNodeProps);
+    /**
+     * Running bash scripts on the Node with SSM Document.
+     * i.e: runPsCommands(["echo 'hello world'", "echo 'Second command'"], "myScript")
+     */
+    runShellCommands(ShellCommands: string[], id: string): void;
+    /**
+     * Running PowerShell scripts on the Node with SSM Document.
+     * i.e: runPsCommands(["Write-host 'Hello world'", "Write-host 'Second command'"], "myScript")
+     */
+    runPsCommands(psCommands: string[], id: string): void;
+    /**
+     * Open the security group of the Node Node to specific IP address on port 3389
+     * i.e: openRDP("1.1.1.1/32")
+     */
+    openRDP(ipaddress: string): void;
+    /**
+     * Running PowerShell scripts on the Node with SSM Document with Domain Admin (Using the Secret used to join the machine to the domain)
+     * i.e: runPsCommands(["Write-host 'Hello world'", "Write-host 'Second command'"], "myScript")
+     * The provided psCommands will be stored in C:\Scripts and will be run with scheduled task with Domain Admin rights
+     */
+    runPSwithDomainAdmin(psCommands: string[], id: string): void;
+    startInstance(): void;
+}