@paulo_raca/cdk-skylight 0.0.0

package/lib/skylight-compute/windows-node.js

@@ -0,0 +1,219 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainWindowsNode = 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 custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+/**
+ * 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()
+ *
+ */
+class DomainWindowsNode extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        props.iamManagedPoliciesList = props.iamManagedPoliciesList ?? [
+            aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+            aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('SecretsManagerReadWrite'),
+        ];
+        props.usePrivateSubnet = props.usePrivateSubnet ?? false;
+        props.userData = props.userData ?? '';
+        props.windowsMachine = props.windowsMachine ?? true;
+        this.passwordObject = props.passwordObject ?? undefined;
+        this.vpc = props.vpc;
+        const nodeImage = new aws_cdk_lib_1.aws_ec2.LookupMachineImage({
+            name: props.amiName ?? '*Windows_Server-2022-English-Full-Base*',
+            windows: props.windowsMachine,
+        });
+        this.nodeRole = new aws_cdk_lib_1.aws_iam.Role(this, 'iam-Role', {
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal('ec2.amazonaws.com'),
+            managedPolicies: props.iamManagedPoliciesList,
+        });
+        const securityGroup = new aws_cdk_lib_1.aws_ec2.SecurityGroup(this, 'SecurityGroup', {
+            vpc: this.vpc,
+        });
+        // Setting static logical ID for the Worker, to allow further customization
+        const workerName = 'EC2Node' + id;
+        workerName.replace(/[^0-9a-z]/gi, ''); //convert string to alphanumeric
+        if (props.domainName && this.passwordObject) {
+            this.passwordObject.grantRead(this.nodeRole);
+            // Create CloudFormation Config set to allow the Domain join report back to Cloudformation only after reboot.
+            const config = aws_cdk_lib_1.aws_ec2.CloudFormationInit.fromConfigSets({
+                configSets: {
+                    domainJoinRestart: ['domainJoin', 'signal'],
+                },
+                configs: {
+                    domainJoin: new aws_cdk_lib_1.aws_ec2.InitConfig([
+                        aws_cdk_lib_1.aws_ec2.InitCommand.shellCommand(
+                        // Step1 : Domain Join using the Secret provided
+                        `powershell.exe -command  "Invoke-Command -ScriptBlock {[string]$SecretAD  = '${this.passwordObject.secretName}' ;$SecretObj = Get-SECSecretValue -SecretId $SecretAD ;[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json) ;$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force ;$username   = 'Admin@' + '${props.domainName}' ;$credential = New-Object System.Management.Automation.PSCredential($username,$password) ;Add-Computer -DomainName ${props.domainName} -Credential $credential; Restart-Computer -Force}"`, {
+                            waitAfterCompletion: aws_cdk_lib_1.aws_ec2.InitCommandWaitDuration.forever(),
+                        }),
+                    ]),
+                    signal: new aws_cdk_lib_1.aws_ec2.InitConfig([
+                        aws_cdk_lib_1.aws_ec2.InitCommand.shellCommand(
+                        // Step 3: CloudFormation signal
+                        `cfn-signal.exe --success=true --resource=${workerName} --stack=${aws_cdk_lib_1.Stack.of(this).stackName} --region=${aws_cdk_lib_1.Stack.of(this).region}`, {
+                            waitAfterCompletion: aws_cdk_lib_1.aws_ec2.InitCommandWaitDuration.none(),
+                        }),
+                    ]),
+                },
+            });
+            const attachInitOptions = {
+                platform: aws_cdk_lib_1.aws_ec2.OperatingSystemType.WINDOWS,
+                configSets: ['domainJoinRestart'],
+                instanceRole: this.nodeRole,
+                userData: aws_cdk_lib_1.aws_ec2.UserData.custom(''),
+                embedFingerprint: false,
+            };
+            this.instance = new aws_cdk_lib_1.aws_ec2.Instance(this, 'Domain-Instance', {
+                instanceType: new aws_cdk_lib_1.aws_ec2.InstanceType(props.instanceType ?? 'm5.large'),
+                machineImage: nodeImage,
+                vpc: this.vpc,
+                role: this.nodeRole,
+                securityGroup: securityGroup,
+                vpcSubnets: this.vpc.selectSubnets({
+                    subnetType: props.usePrivateSubnet
+                        ? aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_WITH_NAT
+                        : aws_cdk_lib_1.aws_ec2.SubnetType.PUBLIC,
+                    onePerAz: true,
+                }),
+                init: config,
+                initOptions: attachInitOptions,
+            });
+            // Override the logical ID name so it can be refereed before initialized
+            const CfnInstance = this.instance.node.defaultChild;
+            CfnInstance.overrideLogicalId(workerName);
+            // Override the default UserData script to execute only the cfn-init (without cfn-signal) as we want cfn-signal to be executed after reboot. More details here: https://aws.amazon.com/premiumsupport/knowledge-center/create-complete-bootstrapping/
+            CfnInstance.userData = aws_cdk_lib_1.Fn.base64(`<powershell>cfn-init.exe -v -s ${aws_cdk_lib_1.Stack.of(this).stackName} -r ${workerName} --configsets=domainJoinRestart --region ${aws_cdk_lib_1.Stack.of(this).region}</powershell>`);
+            // Override the default 5M timeout to support longer Windows boot time
+            CfnInstance.cfnOptions.creationPolicy = {
+                resourceSignal: {
+                    count: 1,
+                    timeout: 'PT30M',
+                },
+            };
+        }
+        else {
+            this.instance = new aws_cdk_lib_1.aws_ec2.Instance(this, 'NonDomain-Instance', {
+                instanceType: new aws_cdk_lib_1.aws_ec2.InstanceType(props.instanceType ?? 'm5.large'),
+                machineImage: nodeImage,
+                vpc: this.vpc,
+                role: this.nodeRole,
+                securityGroup: securityGroup,
+                vpcSubnets: this.vpc.selectSubnets({
+                    subnetType: props.usePrivateSubnet
+                        ? aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_WITH_NAT
+                        : aws_cdk_lib_1.aws_ec2.SubnetType.PUBLIC,
+                    onePerAz: true,
+                }),
+            });
+        }
+        // Append the user data
+        if (props.userData != '') {
+            this.instance.addUserData(props.userData);
+        }
+        new aws_cdk_lib_1.CfnOutput(this, 'InstanceId', {
+            value: `InstanceId: ${this.instance.instanceId}; dnsName: ${this.instance.instancePublicDnsName}`,
+        });
+    }
+    /**
+     * Running bash scripts on the Node with SSM Document.
+     * i.e: runPsCommands(["echo 'hello world'", "echo 'Second command'"], "myScript")
+     */
+    runShellCommands(ShellCommands, id) {
+        new aws_cdk_lib_1.aws_ssm.CfnAssociation(this, id, {
+            name: 'AWS-RunShellScript',
+            parameters: {
+                commands: ShellCommands,
+            },
+            targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],
+            maxErrors: '5',
+            maxConcurrency: '1',
+        });
+    }
+    /**
+     * Running PowerShell scripts on the Node with SSM Document.
+     * i.e: runPsCommands(["Write-host 'Hello world'", "Write-host 'Second command'"], "myScript")
+     */
+    runPsCommands(psCommands, id) {
+        new aws_cdk_lib_1.aws_ssm.CfnAssociation(this, id, {
+            name: 'AWS-RunPowerShellScript',
+            parameters: {
+                commands: psCommands,
+            },
+            targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],
+            maxErrors: '5',
+            maxConcurrency: '1',
+        });
+    }
+    /**
+     * 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) {
+        this.instance.connections.allowFrom(aws_cdk_lib_1.aws_ec2.Peer.ipv4(ipaddress), aws_cdk_lib_1.aws_ec2.Port.tcp(3389), 'Allow RDP');
+    }
+    /**
+     * 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, id) {
+        var commands = ['$oneTimePS = {'];
+        psCommands.forEach((command) => {
+            commands.push(command);
+        });
+        commands.push('}', `[string]$SecretAD  = '${this.passwordObject.secretName}'`, '$SecretObj = Get-SECSecretValue -SecretId $SecretAD', '[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)', '$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force', "$username   = 'Admin'", '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)', 'New-Item -ItemType Directory -Path c:\\Scripts', '$tempScriptPath = "C:\\Scripts\\$PID.ps1"', '$oneTimePS | set-content $tempScriptPath', '# Create a scheduled task on startup to execute the mapping', '$action = New-ScheduledTaskAction -Execute "Powershell.exe" -Argument $tempScriptPath', '$trigger =  New-ScheduledTaskTrigger -Once -At (get-date).AddSeconds(10); ', '$trigger.EndBoundary = (get-date).AddSeconds(60).ToString("s") ', 'Register-ScheduledTask -Force -Action $action -Trigger $trigger -TaskName "Task $PID to run with DomainAdmin" -Description "Workaround to run the code with domain admin" -RunLevel Highest -User $username -Password $Secret.Password');
+        new aws_cdk_lib_1.aws_ssm.CfnAssociation(this, id, {
+            name: 'AWS-RunPowerShellScript',
+            parameters: {
+                commands: commands,
+            },
+            targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],
+            maxErrors: '5',
+            maxConcurrency: '1',
+        });
+    }
+    startInstance() {
+        new custom_resources_1.AwsCustomResource(this, 'start-instance-needed-' + this.instance.instanceId, {
+            policy: custom_resources_1.AwsCustomResourcePolicy.fromSdkCalls({
+                resources: custom_resources_1.AwsCustomResourcePolicy.ANY_RESOURCE,
+            }),
+            onUpdate: {
+                service: 'EC2',
+                action: 'startInstances', // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/EC2.html#startInstances-property
+                parameters: {
+                    InstanceIds: [this.instance.instanceId],
+                },
+                physicalResourceId: {
+                    id: 'startInstance-' + this.instance.instanceId,
+                },
+            },
+        });
+    }
+}
+exports.DomainWindowsNode = DomainWindowsNode;
+_a = JSII_RTTI_SYMBOL_1;
+DomainWindowsNode[_a] = { fqn: "cdk-skylight.compute.DomainWindowsNode", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-node.js","sourceRoot":"","sources":["../../src/skylight-compute/windows-node.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_iam as iam,\n  aws_ec2 as ec2,\n  aws_ssm as ssm,\n  CfnOutput,\n  aws_ec2,\n  Stack,\n  Fn,\n  aws_secretsmanager,\n} from 'aws-cdk-lib';\nimport { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport {\n  AwsCustomResource,\n  AwsCustomResourcePolicy,\n} from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\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 IDomainWindowsNodeProps {\n  /**\n   * IAM Instance role permissions\n   * @default - 'AmazonSSMManagedInstanceCore, AmazonSSMDirectoryServiceAccess'.\n   */\n  iamManagedPoliciesList?: iam.IManagedPolicy[];\n  /**\n   * The EC2 Instance type to use\n   *\n   * @default - 'm5.2xlarge'.\n   */\n  instanceType?: string;\n  /**\n   * Choose if to launch the instance in Private or in Public subnet\n   * Private = Subnet that routes to the internet, but not vice versa.\n   * Public = Subnet that routes to the internet and vice versa.\n   * @default - Private.\n   */\n  usePrivateSubnet?: boolean;\n  /**\n   * The name of the AMI to search in SSM (ec2.LookupNodeImage) supports Regex\n   *  @default - 'Windows_Server-2022-English-Full'\n   */\n  amiName?: string;\n  /**\n   * Specific UserData to use\n   *\n   * The UserData may still be mutated after creation.\n   *\n   *  @default - 'undefined'\n   */\n  userData?: string;\n\n  domainName?: string;\n  passwordObject?: aws_secretsmanager.ISecret;\n\n  /**\n   * @default - 'true'\n   */\n  windowsMachine?: boolean;\n\n  /**\n   * The VPC to use\n   */\n  vpc: ec2.IVpc;\n}\n\n/**\n * A Domain Windows Node represents one Windows EC2 instance configured with Active Directory.\n *\n * The DomainWindowsNode can be customized to different instance sizes and additional permissions set just like any other EC2 Instance.\n * You can use this construct to run elevated domain tasks with domain permissions or run your application in a single instance setup.\n *\n * 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.\n *\n * You can send tasks to that machine using the provided methods: runPsCommands() and runPSwithDomainAdmin()\n *\n */\nexport class DomainWindowsNode extends Construct {\n  readonly instance: ec2.Instance;\n  readonly nodeRole: iam.Role;\n  readonly vpc: ec2.IVpc;\n  readonly passwordObject?: ISecret;\n\n  constructor(scope: Construct, id: string, props: IDomainWindowsNodeProps) {\n    super(scope, id);\n    props.iamManagedPoliciesList = props.iamManagedPoliciesList ?? [\n      iam.ManagedPolicy.fromAwsManagedPolicyName(\n        'AmazonSSMManagedInstanceCore',\n      ),\n      iam.ManagedPolicy.fromAwsManagedPolicyName('SecretsManagerReadWrite'),\n    ];\n\n    props.usePrivateSubnet = props.usePrivateSubnet ?? false;\n    props.userData = props.userData ?? '';\n    props.windowsMachine = props.windowsMachine ?? true;\n    this.passwordObject = props.passwordObject ?? undefined;\n\n    this.vpc = props.vpc;\n\n    const nodeImage = new ec2.LookupMachineImage({\n      name: props.amiName ?? '*Windows_Server-2022-English-Full-Base*',\n      windows: props.windowsMachine,\n    });\n\n    this.nodeRole = new iam.Role(this, 'iam-Role', {\n      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n      managedPolicies: props.iamManagedPoliciesList,\n    });\n\n    const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {\n      vpc: this.vpc,\n    });\n\n    // Setting static logical ID for the Worker, to allow further customization\n    const workerName = 'EC2Node' + id;\n    workerName.replace(/[^0-9a-z]/gi, ''); //convert string to alphanumeric\n\n    if (props.domainName && this.passwordObject) {\n      this.passwordObject.grantRead(this.nodeRole);\n\n      // Create CloudFormation Config set to allow the Domain join report back to Cloudformation only after reboot.\n      const config = ec2.CloudFormationInit.fromConfigSets({\n        configSets: {\n          domainJoinRestart: ['domainJoin', 'signal'],\n        },\n        configs: {\n          domainJoin: new ec2.InitConfig([\n            ec2.InitCommand.shellCommand(\n              // Step1 : Domain Join using the Secret provided\n              `powershell.exe -command  \"Invoke-Command -ScriptBlock {[string]$SecretAD  = '${this.passwordObject.secretName}' ;$SecretObj = Get-SECSecretValue -SecretId $SecretAD ;[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json) ;$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force ;$username   = 'Admin@' + '${props.domainName}' ;$credential = New-Object System.Management.Automation.PSCredential($username,$password) ;Add-Computer -DomainName ${props.domainName} -Credential $credential; Restart-Computer -Force}\"`,\n              {\n                waitAfterCompletion: ec2.InitCommandWaitDuration.forever(),\n              },\n            ),\n          ]),\n          signal: new ec2.InitConfig([\n            ec2.InitCommand.shellCommand(\n              // Step 3: CloudFormation signal\n              `cfn-signal.exe --success=true --resource=${workerName} --stack=${\n                Stack.of(this).stackName\n              } --region=${Stack.of(this).region}`,\n              {\n                waitAfterCompletion: ec2.InitCommandWaitDuration.none(),\n              },\n            ),\n          ]),\n        },\n      });\n      const attachInitOptions: ec2.AttachInitOptions = {\n        platform: ec2.OperatingSystemType.WINDOWS,\n        configSets: ['domainJoinRestart'],\n        instanceRole: this.nodeRole,\n        userData: aws_ec2.UserData.custom(''),\n        embedFingerprint: false,\n      };\n\n      this.instance = new ec2.Instance(this, 'Domain-Instance', {\n        instanceType: new ec2.InstanceType(props.instanceType ?? 'm5.large'),\n        machineImage: nodeImage,\n        vpc: this.vpc,\n        role: this.nodeRole,\n        securityGroup: securityGroup,\n        vpcSubnets: this.vpc.selectSubnets({\n          subnetType: props.usePrivateSubnet\n            ? ec2.SubnetType.PRIVATE_WITH_NAT\n            : ec2.SubnetType.PUBLIC,\n          onePerAz: true,\n        }),\n        init: config,\n        initOptions: attachInitOptions,\n      });\n\n      // Override the logical ID name so it can be refereed before initialized\n      const CfnInstance = this.instance.node.defaultChild as ec2.CfnInstance;\n      CfnInstance.overrideLogicalId(workerName);\n\n      // Override the default UserData script to execute only the cfn-init (without cfn-signal) as we want cfn-signal to be executed after reboot. More details here: https://aws.amazon.com/premiumsupport/knowledge-center/create-complete-bootstrapping/\n      CfnInstance.userData = Fn.base64(\n        `<powershell>cfn-init.exe -v -s ${\n          Stack.of(this).stackName\n        } -r ${workerName} --configsets=domainJoinRestart --region ${\n          Stack.of(this).region\n        }</powershell>`,\n      );\n\n      // Override the default 5M timeout to support longer Windows boot time\n      CfnInstance.cfnOptions.creationPolicy = {\n        resourceSignal: {\n          count: 1,\n          timeout: 'PT30M',\n        },\n      };\n    } else {\n      this.instance = new ec2.Instance(this, 'NonDomain-Instance', {\n        instanceType: new ec2.InstanceType(props.instanceType ?? 'm5.large'),\n        machineImage: nodeImage,\n        vpc: this.vpc,\n        role: this.nodeRole,\n        securityGroup: securityGroup,\n        vpcSubnets: this.vpc.selectSubnets({\n          subnetType: props.usePrivateSubnet\n            ? ec2.SubnetType.PRIVATE_WITH_NAT\n            : ec2.SubnetType.PUBLIC,\n          onePerAz: true,\n        }),\n      });\n    }\n\n    // Append the user data\n    if (props.userData != '') {\n      this.instance.addUserData(props.userData);\n    }\n\n    new CfnOutput(this, 'InstanceId', {\n      value: `InstanceId: ${this.instance.instanceId}; dnsName: ${this.instance.instancePublicDnsName}`,\n    });\n  }\n\n  /**\n   * Running bash scripts on the Node with SSM Document.\n   * i.e: runPsCommands([\"echo 'hello world'\", \"echo 'Second command'\"], \"myScript\")\n   */\n  runShellCommands(ShellCommands: string[], id: string) {\n    new ssm.CfnAssociation(this, id, {\n      name: 'AWS-RunShellScript',\n      parameters: {\n        commands: ShellCommands,\n      },\n      targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],\n      maxErrors: '5',\n      maxConcurrency: '1',\n    });\n  }\n\n  /**\n   * Running PowerShell scripts on the Node with SSM Document.\n   * i.e: runPsCommands([\"Write-host 'Hello world'\", \"Write-host 'Second command'\"], \"myScript\")\n   */\n  runPsCommands(psCommands: string[], id: string) {\n    new ssm.CfnAssociation(this, id, {\n      name: 'AWS-RunPowerShellScript',\n      parameters: {\n        commands: psCommands,\n      },\n      targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],\n      maxErrors: '5',\n      maxConcurrency: '1',\n    });\n  }\n  /**\n   * Open the security group of the Node Node to specific IP address on port 3389\n   * i.e: openRDP(\"1.1.1.1/32\")\n   */\n  openRDP(ipaddress: string) {\n    this.instance.connections.allowFrom(\n      ec2.Peer.ipv4(ipaddress),\n      ec2.Port.tcp(3389),\n      'Allow RDP',\n    );\n  }\n\n  /**\n   * Running PowerShell scripts on the Node with SSM Document with Domain Admin (Using the Secret used to join the machine to the domain)\n   * i.e: runPsCommands([\"Write-host 'Hello world'\", \"Write-host 'Second command'\"], \"myScript\")\n   * The provided psCommands will be stored in C:\\Scripts and will be run with scheduled task with Domain Admin rights\n   */\n  runPSwithDomainAdmin(psCommands: string[], id: string) {\n    var commands = ['$oneTimePS = {'];\n    psCommands.forEach((command: string) => {\n      commands.push(command);\n    });\n    commands.push(\n      '}',\n      `[string]$SecretAD  = '${this.passwordObject!.secretName}'`,\n      '$SecretObj = Get-SECSecretValue -SecretId $SecretAD',\n      '[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',\n      '$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',\n      \"$username   = 'Admin'\",\n      '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',\n      'New-Item -ItemType Directory -Path c:\\\\Scripts',\n      '$tempScriptPath = \"C:\\\\Scripts\\\\$PID.ps1\"',\n      '$oneTimePS | set-content $tempScriptPath',\n      '# Create a scheduled task on startup to execute the mapping',\n      '$action = New-ScheduledTaskAction -Execute \"Powershell.exe\" -Argument $tempScriptPath',\n      '$trigger =  New-ScheduledTaskTrigger -Once -At (get-date).AddSeconds(10); ',\n      '$trigger.EndBoundary = (get-date).AddSeconds(60).ToString(\"s\") ',\n      'Register-ScheduledTask -Force -Action $action -Trigger $trigger -TaskName \"Task $PID to run with DomainAdmin\" -Description \"Workaround to run the code with domain admin\" -RunLevel Highest -User $username -Password $Secret.Password',\n    );\n    new ssm.CfnAssociation(this, id, {\n      name: 'AWS-RunPowerShellScript',\n      parameters: {\n        commands: commands,\n      },\n      targets: [{ key: 'InstanceIds', values: [this.instance.instanceId] }],\n      maxErrors: '5',\n      maxConcurrency: '1',\n    });\n  }\n\n  startInstance() {\n    new AwsCustomResource(\n      this,\n      'start-instance-needed-' + this.instance.instanceId,\n      {\n        policy: AwsCustomResourcePolicy.fromSdkCalls({\n          resources: AwsCustomResourcePolicy.ANY_RESOURCE,\n        }),\n        onUpdate: {\n          service: 'EC2',\n          action: 'startInstances', // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/EC2.html#startInstances-property\n          parameters: {\n            InstanceIds: [this.instance.instanceId],\n          },\n          physicalResourceId: {\n            id: 'startInstance-' + this.instance.instanceId,\n          },\n        },\n      },\n    );\n  }\n}\n"]}

package/lib/skylight-storage/fsx-windows.d.ts

@@ -0,0 +1,82 @@
+/**
+ *  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 as ec2, aws_fsx } from 'aws-cdk-lib';
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { DomainWindowsNode } from '../skylight-compute';
+/**
+ * The properties for the PersistentStorage class.
+ */
+export interface IFSxWindowsProps {
+    /**
+     * The Filesystem size in GB
+     *
+     * @default - 200.
+     */
+    fileSystemSize?: number;
+    /**
+     * The Filesystem throughput in MBps
+     *
+     * @default - 128.
+     */
+    throughputMbps?: number;
+    /**
+     * Choosing Single-AZ or Multi-AZ file system deployment
+     * See: https://docs.aws.amazon.com/fsx/latest/WindowsGuide/high-availability-multiAZ.html
+     * @default - true.
+     */
+    multiAZ?: boolean;
+    /**
+     * Deploy the Amazon FSx file system in private subnet or public subnet
+     * See: https://docs.aws.amazon.com/fsx/latest/WindowsGuide/high-availability-multiAZ.html
+     * @default - true.
+     */
+    fileSystemInPrivateSubnet?: boolean;
+    /**
+     * The VPC to use, must have private subnets.
+     */
+    vpc: ec2.IVpc;
+    directoryId: string;
+    ssmParameters?: IFSxWindowsParameters;
+}
+export interface IFSxWindowsParameters {
+    /**
+     * The name of the parameter to save the FSxEndpoint DNS Endpoint
+     * @default - 'FSxEndpoint-DNS'.
+     */
+    dnsEndpoint?: string;
+    /**
+     * The SSM namespace to read/write parameters to
+     * @default - 'cdk-skylight'.
+     */
+    namespace?: string;
+}
+/**
+* A FSxWindows represents an integration pattern of Amazon FSx and Managed AD in a specific VPC.
+
+* The Construct creates Amazon FSx for Windows
+* The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createFolder)
+*
+* The createFolder() method creates an SMB Folder in the FSx filesystem, using the domain admin user.
+* Please note: When calling createFolder() 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 .
+ *
+ */
+export declare class FSxWindows extends Construct {
+    readonly ssmParameters: IFSxWindowsParameters;
+    readonly fsxObject: aws_fsx.CfnFileSystem;
+    readonly props: IFSxWindowsProps;
+    constructor(scope: Construct, id: string, props: IFSxWindowsProps);
+    createWorker(domainName: string, domainPassword: ISecret): DomainWindowsNode;
+    createFolder(worker: DomainWindowsNode, folderName: string, secretName: ISecret): void;
+}

package/lib/skylight-storage/fsx-windows.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSxWindows = 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_compute_1 = require("../skylight-compute");
+/**
+* A FSxWindows represents an integration pattern of Amazon FSx and Managed AD in a specific VPC.
+
+* The Construct creates Amazon FSx for Windows
+* The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createFolder)
+*
+* The createFolder() method creates an SMB Folder in the FSx filesystem, using the domain admin user.
+* Please note: When calling createFolder() 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 FSxWindows extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.props.fileSystemInPrivateSubnet =
+            props.fileSystemInPrivateSubnet ?? true;
+        this.props.throughputMbps = props.throughputMbps ?? 128;
+        this.props.fileSystemSize = props.fileSystemSize ?? 200;
+        this.props.multiAZ = props.multiAZ ?? true;
+        this.ssmParameters = props.ssmParameters ?? {};
+        this.ssmParameters.dnsEndpoint =
+            this.ssmParameters?.dnsEndpoint ?? 'FSxEndpoint-DNS';
+        if (this.ssmParameters.namespace) {
+            this.ssmParameters.namespace = `${this.ssmParameters.namespace}/storage/fsx`;
+        }
+        else {
+            this.ssmParameters.namespace = 'cdk-skylight/storage/fsx';
+        }
+        const subnets = this.props.vpc.selectSubnets({
+            subnetType: props.fileSystemInPrivateSubnet
+                ? aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_WITH_NAT
+                : aws_cdk_lib_1.aws_ec2.SubnetType.PUBLIC,
+        }).subnetIds;
+        const windows_configuration = {
+            throughputCapacity: this.props.throughputMbps,
+            activeDirectoryId: props.directoryId,
+            deploymentType: this.props.multiAZ ? 'MULTI_AZ_1' : 'SINGLE_AZ_2',
+            preferredSubnetId: this.props.multiAZ ? subnets[0] : undefined,
+        };
+        const sg = new aws_cdk_lib_1.aws_ec2.SecurityGroup(this, id + '-FSxSG', {
+            vpc: this.props.vpc,
+        });
+        // Allow access from inside the VPC
+        sg.addIngressRule(aws_cdk_lib_1.aws_ec2.Peer.ipv4(props.vpc.vpcCidrBlock), aws_cdk_lib_1.aws_ec2.Port.allTcp());
+        const fsx_props = {
+            fileSystemType: 'WINDOWS',
+            subnetIds: props.multiAZ ? [subnets[0], subnets[1]] : [subnets[0]],
+            windowsConfiguration: windows_configuration,
+            storageCapacity: props.fileSystemSize,
+            securityGroupIds: [sg.securityGroupId],
+        };
+        this.fsxObject = new aws_cdk_lib_1.aws_fsx.CfnFileSystem(this, (id = id + '-FSxObject'), fsx_props);
+        new aws_cdk_lib_1.aws_ssm.StringParameter(this, 'ssm-dns-fsxEndpoint', {
+            parameterName: `/${this.ssmParameters.namespace}/${this.ssmParameters.dnsEndpoint}`,
+            stringValue: this.fsxObject.getAtt('DNSName').toString(),
+        });
+    }
+    createWorker(domainName, domainPassword) {
+        return new skylight_compute_1.DomainWindowsNode(this, 'FSxWindowsWorker', {
+            vpc: this.props.vpc,
+            instanceType: 't3.small',
+            iamManagedPoliciesList: [
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('SecretsManagerReadWrite'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonFSxReadOnlyAccess'),
+            ],
+            domainName: domainName,
+            passwordObject: domainPassword,
+        });
+    }
+    createFolder(worker, folderName, secretName) {
+        worker.startInstance();
+        worker.runPSwithDomainAdmin([
+            `$FSX = '${this.fsxObject
+                .getAtt('DNSName')
+                .toString()}' ## Amazon FSx DNS Name`,
+            '$FSxPS = (Get-FSXFileSystem | ? {$_.DNSName -contains $FSX}).WindowsConfiguration.RemoteAdministrationEndpoint',
+            `$FolderName = '${folderName}'`,
+            `[string]$SecretAD  = '${secretName}'`,
+            '$SecretObj = Get-SECSecretValue -SecretId $SecretAD',
+            '[PSCustomObject]$Secret = ($SecretObj.SecretString  | ConvertFrom-Json)',
+            '$password   = $Secret.Password | ConvertTo-SecureString -asPlainText -Force',
+            " $username   = $Secret.Domain + '\\' + $Secret.UserID ",
+            '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',
+            '# Create the folder (the shared driver to the hosts)',
+            'New-Item -ItemType Directory -Name $FolderName -Path \\\\$FSX\\D$\\',
+            '# Set NTFS Permissions',
+            '# ACL',
+            '$ACL = Get-Acl \\\\$FSx\\D$\\$FolderName',
+            '$permission = "NT AUTHORITY\\Authenticated Users","FullControl","Allow"',
+            '$Ar = New-Object System.Security.AccessControl.FileSystemAccessRule $permission',
+            '$ACL.SetAccessRule($Ar)',
+            'Set-Acl \\\\$FSX\\D$\\$FolderName $ACL',
+            '# Create the Share and set the share permissions',
+            '$Session = New-PSSession -ComputerName $FSxPS -ConfigurationName FsxRemoteAdmin',
+            'Import-PsSession $Session',
+            'New-FSxSmbShare -Name $FolderName -Path "D:\\$FolderName" -Description "Shared folder with gMSA access" -Credential $domain_admin_credential -FolderEnumerationMode AccessBased',
+            '$accessList="NT AUTHORITY\\Authenticated Users"',
+            'Grant-FSxSmbShareaccess -Name $FolderName -AccountName $accessList -accessRight Full -Confirm:$false',
+            'Disconnect-PSSession -Session $Session',
+            'Stop-Computer -ComputerName localhost',
+        ], 'createFolder');
+    }
+}
+exports.FSxWindows = FSxWindows;
+_a = JSII_RTTI_SYMBOL_1;
+FSxWindows[_a] = { fqn: "cdk-skylight.storage.FSxWindows", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fsx-windows.js","sourceRoot":"","sources":["../../src/skylight-storage/fsx-windows.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 { aws_ec2 as ec2, aws_ssm, aws_fsx, aws_iam } from 'aws-cdk-lib';\nimport { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport { DomainWindowsNode } from '../skylight-compute';\n\n/**\n * The properties for the PersistentStorage class.\n */\nexport interface IFSxWindowsProps {\n  /**\n   * The Filesystem size in GB\n   *\n   * @default - 200.\n   */\n  fileSystemSize?: number;\n  /**\n   * The Filesystem throughput in MBps\n   *\n   * @default - 128.\n   */\n  throughputMbps?: number;\n  /**\n   * Choosing Single-AZ or Multi-AZ file system deployment\n   * See: https://docs.aws.amazon.com/fsx/latest/WindowsGuide/high-availability-multiAZ.html\n   * @default - true.\n   */\n  multiAZ?: boolean;\n  /**\n   * Deploy the Amazon FSx file system in private subnet or public subnet\n   * See: https://docs.aws.amazon.com/fsx/latest/WindowsGuide/high-availability-multiAZ.html\n   * @default - true.\n   */\n  fileSystemInPrivateSubnet?: boolean;\n  /**\n   * The VPC to use, must have private subnets.\n   */\n\n  vpc: ec2.IVpc;\n\n  directoryId: string;\n\n  ssmParameters?: IFSxWindowsParameters;\n}\n\nexport interface IFSxWindowsParameters {\n  /**\n   * The name of the parameter to save the FSxEndpoint DNS Endpoint\n   * @default - 'FSxEndpoint-DNS'.\n   */\n  dnsEndpoint?: 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 FSxWindows represents an integration pattern of Amazon FSx and Managed AD in a specific VPC.\n\n* The Construct creates Amazon FSx for Windows\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 createFolder)\n*\n* The createFolder() method creates an SMB Folder in the FSx filesystem, using the domain admin user.\n* Please note: When calling createFolder() 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 FSxWindows extends Construct {\n  readonly ssmParameters: IFSxWindowsParameters;\n  readonly fsxObject: aws_fsx.CfnFileSystem;\n  readonly props: IFSxWindowsProps;\n  constructor(scope: Construct, id: string, props: IFSxWindowsProps) {\n    super(scope, id);\n    this.props = props;\n    this.props.fileSystemInPrivateSubnet =\n      props.fileSystemInPrivateSubnet ?? true;\n    this.props.throughputMbps = props.throughputMbps ?? 128;\n    this.props.fileSystemSize = props.fileSystemSize ?? 200;\n    this.props.multiAZ = props.multiAZ ?? true;\n    this.ssmParameters = props.ssmParameters ?? {};\n    this.ssmParameters.dnsEndpoint =\n      this.ssmParameters?.dnsEndpoint ?? 'FSxEndpoint-DNS';\n\n    if (this.ssmParameters.namespace) {\n      this.ssmParameters.namespace = `${this.ssmParameters.namespace}/storage/fsx`;\n    } else {\n      this.ssmParameters.namespace = 'cdk-skylight/storage/fsx';\n    }\n\n    const subnets = this.props.vpc.selectSubnets({\n      subnetType: props.fileSystemInPrivateSubnet\n        ? ec2.SubnetType.PRIVATE_WITH_NAT\n        : ec2.SubnetType.PUBLIC,\n    }).subnetIds;\n\n    const windows_configuration: aws_fsx.CfnFileSystem.WindowsConfigurationProperty =\n      {\n        throughputCapacity: this.props.throughputMbps,\n        activeDirectoryId: props.directoryId,\n        deploymentType: this.props.multiAZ ? 'MULTI_AZ_1' : 'SINGLE_AZ_2',\n        preferredSubnetId: this.props.multiAZ ? subnets[0] : undefined,\n      };\n\n    const sg = new ec2.SecurityGroup(this, id + '-FSxSG', {\n      vpc: this.props.vpc,\n    });\n\n    // Allow access from inside the VPC\n    sg.addIngressRule(ec2.Peer.ipv4(props.vpc.vpcCidrBlock), ec2.Port.allTcp());\n\n    const fsx_props: aws_fsx.CfnFileSystemProps = {\n      fileSystemType: 'WINDOWS',\n      subnetIds: props.multiAZ ? [subnets[0], subnets[1]] : [subnets[0]],\n      windowsConfiguration: windows_configuration,\n      storageCapacity: props.fileSystemSize,\n      securityGroupIds: [sg.securityGroupId],\n    };\n\n    this.fsxObject = new aws_fsx.CfnFileSystem(\n      this,\n      (id = id + '-FSxObject'),\n      fsx_props,\n    );\n\n    new aws_ssm.StringParameter(this, 'ssm-dns-fsxEndpoint', {\n      parameterName: `/${this.ssmParameters.namespace}/${this.ssmParameters.dnsEndpoint}`,\n      stringValue: this.fsxObject.getAtt('DNSName').toString(),\n    });\n  }\n\n  createWorker(domainName: string, domainPassword: ISecret): DomainWindowsNode {\n    return new DomainWindowsNode(this, 'FSxWindowsWorker', {\n      vpc: this.props.vpc,\n      instanceType: 't3.small',\n      iamManagedPoliciesList: [\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonSSMManagedInstanceCore',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'SecretsManagerReadWrite',\n        ),\n        aws_iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'AmazonFSxReadOnlyAccess',\n        ),\n      ],\n      domainName: domainName,\n      passwordObject: domainPassword,\n    });\n  }\n\n  createFolder(\n    worker: DomainWindowsNode,\n    folderName: string,\n    secretName: ISecret,\n  ) {\n    worker.startInstance();\n    worker.runPSwithDomainAdmin(\n      [\n        `$FSX = '${this.fsxObject\n          .getAtt('DNSName')\n          .toString()}' ## Amazon FSx DNS Name`,\n        '$FSxPS = (Get-FSXFileSystem | ? {$_.DNSName -contains $FSX}).WindowsConfiguration.RemoteAdministrationEndpoint',\n        `$FolderName = '${folderName}'`,\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.Domain + '\\\\' + $Secret.UserID \",\n        '$domain_admin_credential = New-Object System.Management.Automation.PSCredential($username,$password)',\n        '# Create the folder (the shared driver to the hosts)',\n        'New-Item -ItemType Directory -Name $FolderName -Path \\\\\\\\$FSX\\\\D$\\\\',\n        '# Set NTFS Permissions',\n        '# ACL',\n        '$ACL = Get-Acl \\\\\\\\$FSx\\\\D$\\\\$FolderName',\n        '$permission = \"NT AUTHORITY\\\\Authenticated Users\",\"FullControl\",\"Allow\"',\n        '$Ar = New-Object System.Security.AccessControl.FileSystemAccessRule $permission',\n        '$ACL.SetAccessRule($Ar)',\n        'Set-Acl \\\\\\\\$FSX\\\\D$\\\\$FolderName $ACL',\n        '# Create the Share and set the share permissions',\n        '$Session = New-PSSession -ComputerName $FSxPS -ConfigurationName FsxRemoteAdmin',\n        'Import-PsSession $Session',\n        'New-FSxSmbShare -Name $FolderName -Path \"D:\\\\$FolderName\" -Description \"Shared folder with gMSA access\" -Credential $domain_admin_credential -FolderEnumerationMode AccessBased',\n        '$accessList=\"NT AUTHORITY\\\\Authenticated Users\"',\n        'Grant-FSxSmbShareaccess -Name $FolderName -AccountName $accessList -accessRight Full -Confirm:$false',\n        'Disconnect-PSSession -Session $Session',\n        'Stop-Computer -ComputerName localhost',\n      ],\n      'createFolder',\n    );\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+export * from './fsx-windows';

package/lib/skylight-storage/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("./fsx-windows"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2t5bGlnaHQtc3RvcmFnZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mc3gtd2luZG93cyc7Il19