konokenj.cdk-api-mcp-server 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-imagebuilder-alpha/README.md

@@ -36,6 +36,377 @@ EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketpl
 that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
 test phase during the test stage.
 
+### Image Recipe
+
+#### Image Recipe Basic Usage
+
+Create an image recipe with the required base image:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MyImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+```
+
+#### Image Recipe Base Images
+
+To create a recipe, you have to select a base image to build and customize from. This base image can be referenced from
+various sources, such as from SSM parameters, AWS Marketplace products, and AMI IDs directly.
+
+##### SSM Parameters
+
+Using SSM parameter references:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'SsmImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+
+// Using an SSM parameter construct
+const parameter = ssm.StringParameter.fromStringParameterName(
+  this,
+  'BaseImageParameter',
+  '/aws/service/ami-windows-latest/Windows_Server-2022-English-Full-Base'
+);
+const windowsRecipe = new imagebuilder.ImageRecipe(this, 'WindowsImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameter(parameter)
+});
+```
+
+##### AMI IDs
+
+When you have a specific AMI to use:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'AmiImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromAmiId('ami-12345678')
+});
+```
+
+##### Marketplace Images
+
+For marketplace base images:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MarketplaceImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromMarketplaceProductId('prod-1234567890abcdef0')
+});
+```
+
+#### Image Recipe Components
+
+Components from various sources, such as custom-owned, AWS-owned, or AWS Marketplace-owned, can optionally be included
+in recipes. For parameterized components, you are able to provide the parameters to use in the recipe, which will be
+applied during the image build when executing components.
+
+##### Custom Components in Image Recipes
+
+Add your own components to the recipe:
+
+```ts
+const customComponent = new imagebuilder.Component(this, 'MyComponent', {
+  platform: imagebuilder.Platform.LINUX,
+  data: imagebuilder.ComponentData.fromJsonObject({
+    schemaVersion: imagebuilder.ComponentSchemaVersion.V1_0,
+    phases: [
+      {
+        name: imagebuilder.ComponentPhaseName.BUILD,
+        steps: [
+          {
+            name: 'install-app',
+            action: imagebuilder.ComponentAction.EXECUTE_BASH,
+            inputs: {
+              commands: ['yum install -y my-application']
+            }
+          }
+        ]
+      }
+    ]
+  })
+});
+
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'ComponentImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: customComponent
+    }
+  ]
+});
+```
+
+##### AWS-Managed Components in Image Recipes
+
+Use pre-built AWS components:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'AwsManagedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: imagebuilder.AwsManagedComponent.updateOS(this, 'UpdateOS', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    },
+    {
+      component: imagebuilder.AwsManagedComponent.awsCliV2(this, 'AwsCli', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    }
+  ]
+});
+```
+
+##### Component Parameters in Image Recipes
+
+Pass parameters to components that accept them:
+
+```ts
+const parameterizedComponent = imagebuilder.Component.fromComponentName(
+  this,
+  'ParameterizedComponent',
+  'my-parameterized-component'
+);
+
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'ParameterizedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: parameterizedComponent,
+      parameters: {
+        environment: imagebuilder.ComponentParameterValue.fromString('production'),
+        version: imagebuilder.ComponentParameterValue.fromString('1.0.0')
+      }
+    }
+  ]
+});
+```
+
+#### Image Recipe Configuration
+
+##### Block Device Configuration
+
+Configure storage for the build instance:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'BlockDeviceImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  blockDevices: [
+    {
+      deviceName: '/dev/sda1',
+      volume: ec2.BlockDeviceVolume.ebs(100, {
+        encrypted: true,
+        volumeType: ec2.EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3
+      })
+    }
+  ]
+});
+```
+
+##### AMI Tagging
+
+Tag the output AMI:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'TaggedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  amiTags: {
+    Environment: 'Production',
+    Application: 'WebServer',
+    Owner: 'DevOps Team'
+  }
+});
+```
+
+### Container Recipe
+
+A container recipe is similar to an image recipe but specifically for container images. It defines the base container
+image and components applied to produce the desired configuration for the output container image. Container recipes work
+with Docker images from DockerHub, Amazon ECR, or Amazon-managed container images as starting points.
+
+#### Container Recipe Basic Usage
+
+Create a container recipe with the required base image and target repository:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'MyContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  )
+});
+```
+
+#### Container Recipe Base Images
+
+##### DockerHub Images
+
+Using public Docker Hub images:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'DockerHubContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  )
+});
+```
+
+##### ECR Images
+
+Using images from your own ECR repositories:
+
+```ts
+const sourceRepo = ecr.Repository.fromRepositoryName(this, 'SourceRepo', 'my-base-image');
+const targetRepo = ecr.Repository.fromRepositoryName(this, 'TargetRepo', 'my-container-repo');
+
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'EcrContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromEcr(sourceRepo, '1.0.0'),
+  targetRepository: imagebuilder.Repository.fromEcr(targetRepo)
+});
+```
+
+##### ECR Public Images
+
+Using images from Amazon ECR Public:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'EcrPublicContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromEcrPublic('amazonlinux', 'amazonlinux', '2023'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  )
+});
+```
+
+#### Container Recipe Components
+
+##### Custom Components in Container Recipes
+
+Add your own components to the container recipe:
+
+```ts
+const customComponent = new imagebuilder.Component(this, 'MyComponent', {
+  platform: imagebuilder.Platform.LINUX,
+  data: imagebuilder.ComponentData.fromJsonObject({
+    schemaVersion: imagebuilder.ComponentSchemaVersion.V1_0,
+    phases: [
+      {
+        name: imagebuilder.ComponentPhaseName.BUILD,
+        steps: [
+          {
+            name: 'install-app',
+            action: imagebuilder.ComponentAction.EXECUTE_BASH,
+            inputs: {
+              commands: ['yum install -y my-container-application']
+            }
+          }
+        ]
+      }
+    ]
+  })
+});
+
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'ComponentContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  ),
+  components: [
+    {
+      component: customComponent
+    }
+  ]
+});
+```
+
+##### AWS-Managed Components in Container Recipes
+
+Use pre-built AWS components:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'AwsManagedContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  ),
+  components: [
+    {
+      component: imagebuilder.AwsManagedComponent.updateOS(this, 'UpdateOS', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    },
+    {
+      component: imagebuilder.AwsManagedComponent.awsCliV2(this, 'AwsCli', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    }
+  ]
+});
+```
+
+#### Container Recipe Configuration
+
+##### Custom Dockerfile
+
+Provide your own Dockerfile template:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'CustomDockerfileContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  ),
+  dockerfile: imagebuilder.DockerfileData.fromInline(`
+FROM {{{ imagebuilder:parentImage }}}
+CMD ["echo", "Hello, world!"]
+{{{ imagebuilder:environments }}}
+{{{ imagebuilder:components }}}
+`)
+});
+```
+
+##### Instance Configuration
+
+Configure the build instance:
+
+```ts
+const containerRecipe = new imagebuilder.ContainerRecipe(this, 'InstanceConfigContainerRecipe', {
+  baseImage: imagebuilder.BaseContainerImage.fromDockerHub('amazonlinux', 'latest'),
+  targetRepository: imagebuilder.Repository.fromEcr(
+    ecr.Repository.fromRepositoryName(this, 'Repository', 'my-container-repo')
+  ),
+  // Custom ECS-optimized AMI for building
+  instanceImage: imagebuilder.ContainerInstanceImage.fromSsmParameterName(
+    '/aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id'
+  ),
+  // Additional storage for build process
+  instanceBlockDevices: [
+    {
+      deviceName: '/dev/xvda',
+      volume: ec2.BlockDeviceVolume.ebs(50, {
+        encrypted: true,
+        volumeType: ec2.EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3
+      })
+    }
+  ]
+});
+```
+
 ### Component
 
 A component defines the sequence of steps required to customize an instance during image creation (build component) or
@@ -47,7 +418,7 @@ EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketpl
 that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
 test phase during the test stage.
 
-#### Basic Usage
+#### Basic Component Usage
 
 Create a component with the required properties: platform and component data.
 
@@ -232,13 +603,13 @@ const component = new imagebuilder.Component(this, 'EncryptedComponent', {
             name: 'secure-setup',
             action: imagebuilder.ComponentAction.EXECUTE_BASH,
             inputs: {
-              commands: ['echo "This component data is encrypted with KMS"'],
-            },
-          },
-        ],
-      },
-    ],
-  }),
+              commands: ['echo "This component data is encrypted with KMS"']
+            }
+          }
+        ]
+      }
+    ]
+  })
 });
 ```
 
@@ -479,3 +850,227 @@ containerDistributionConfiguration.addContainerDistributions({
   containerTags: ['latest', 'latest-1.0']
 });
 ```
+
+### Workflow
+
+Workflows define the sequence of steps that Image Builder performs during image creation. There are three workflow types: BUILD (image building), TEST (testing images), and DISTRIBUTION (distributing container images).
+
+#### Basic Workflow Usage
+
+Create a workflow with the required properties: workflow type and workflow data.
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'MyWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent',
+        },
+      },
+      {
+        name: 'ExecuteComponents',
+        action: imagebuilder.WorkflowAction.EXECUTE_COMPONENTS,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId',
+      },
+    ],
+  }),
+});
+```
+
+#### Workflow Data Sources
+
+##### Inline Workflow Data
+
+Use `WorkflowData.fromInline()` for existing YAML/JSON definitions:
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'InlineWorkflow', {
+  workflowType: imagebuilder.WorkflowType.TEST,
+  data: imagebuilder.WorkflowData.fromInline(`
+schemaVersion: 1.0
+steps:
+  - name: LaunchTestInstance
+    action: LaunchInstance
+    onFailure: Abort
+    inputs:
+      waitFor: ssmAgent
+  - name: RunTests
+    action: RunCommand
+    onFailure: Abort
+    inputs:
+      instanceId.$: "$.stepOutputs.LaunchTestInstance.instanceId"
+      commands: ['./run-tests.sh']
+  - name: TerminateTestInstance
+    action: TerminateInstance
+    onFailure: Continue
+    inputs:
+      instanceId.$: "$.stepOutputs.LaunchTestInstance.instanceId"
+`),
+});
+```
+
+##### JSON Object Workflow Data
+
+Most developer-friendly approach using JavaScript objects:
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'JsonWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent'
+        }
+      },
+      {
+        name: 'ExecuteComponents',
+        action: imagebuilder.WorkflowAction.EXECUTE_COMPONENTS,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      }
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId'
+      }
+    ]
+  })
+});
+```
+
+##### S3 Workflow Data
+
+For those workflows you want to upload or have uploaded to S3:
+
+```ts
+// Upload a local file
+const workflowFromAsset = new imagebuilder.Workflow(this, 'AssetWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromAsset(this, 'WorkflowAsset', './my-workflow.yml'),
+});
+
+// Reference an existing S3 object
+const bucket = s3.Bucket.fromBucketName(this, 'WorkflowBucket', 'my-workflows-bucket');
+const workflowFromS3 = new imagebuilder.Workflow(this, 'S3Workflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromS3(bucket, 'workflows/my-workflow.yml'),
+});
+```
+
+#### Encrypt workflow data with a KMS key
+
+You can encrypt workflow data with a KMS key, so that only principals with access to decrypt with the key are able to access the workflow data.
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'EncryptedWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  kmsKey: new kms.Key(this, 'WorkflowKey'),
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent',
+        },
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId',
+      },
+    ],
+  }),
+});
+```
+
+#### AWS-Managed Workflows
+
+AWS provides a collection of workflows for common scenarios:
+
+```ts
+// Build workflows
+const buildImageWorkflow = imagebuilder.AwsManagedWorkflow.buildImage(this, 'BuildImage');
+const buildContainerWorkflow = imagebuilder.AwsManagedWorkflow.buildContainer(this, 'BuildContainer');
+
+// Test workflows  
+const testImageWorkflow = imagebuilder.AwsManagedWorkflow.testImage(this, 'TestImage');
+const testContainerWorkflow = imagebuilder.AwsManagedWorkflow.testContainer(this, 'TestContainer');
+
+// Distribution workflows
+const distributeContainerWorkflow = imagebuilder.AwsManagedWorkflow.distributeContainer(this, 'DistributeContainer');
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/mixins-preview/README.md

@@ -55,11 +55,11 @@ The `.with()` method is available after importing `@aws-cdk/mixins-preview/with`
 
 ## Creating Custom Mixins
 
-Mixins are simple classes that implement the `IMixin` interface:
+Mixins are simple classes that implement the `IMixin` interface (usually by extending the abstract `Mixin` class:
 
 ```typescript
 // Simple mixin that enables versioning
-class CustomVersioningMixin implements IMixin {
+class CustomVersioningMixin extends Mixin implements IMixin {
   supports(construct: any): boolean {
     return construct instanceof s3.CfnBucket;
   }
@@ -131,7 +131,7 @@ For every CloudFormation resource, CDK Mixins automatically generates type-safe
 
 ```typescript
 import '@aws-cdk/mixins-preview/with';
-import { CfnBucketPropsMixin } from '@aws-cdk/mixins-preview/aws-s3/mixins';
+
 
 const bucket = new s3.Bucket(scope, "Bucket")
   .with(new CfnBucketPropsMixin({
@@ -146,6 +146,8 @@ const bucket = new s3.Bucket(scope, "Bucket")
 Property mixins support two merge strategies:
 
 ```typescript
+declare const bucket: s3.CfnBucket;
+
 // MERGE (default): Deep merges properties with existing values
 Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { versioningConfiguration: { status: "Enabled" } },
@@ -155,16 +157,16 @@ Mixins.of(bucket).apply(new CfnBucketPropsMixin(
 // OVERWRITE: Replaces existing property values
 Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { versioningConfiguration: { status: "Enabled" } },
-  { strategy: PropertyMergeStrategy.OVERWRITE }
+  { strategy: PropertyMergeStrategy.OVERRIDE }
 ));
 ```
 
 Property mixins are available for all AWS services:
 
 ```typescript
-import { CfnLogGroupMixin } from '@aws-cdk/mixins-preview/aws-logs/mixins';
-import { CfnFunctionMixin } from '@aws-cdk/mixins-preview/aws-lambda/mixins';
-import { CfnTableMixin } from '@aws-cdk/mixins-preview/aws-dynamodb/mixins';
+import { CfnLogGroupPropsMixin } from '@aws-cdk/mixins-preview/aws_logs/mixins';
+import { CfnFunctionPropsMixin } from '@aws-cdk/mixins-preview/aws_lambda/mixins';
+import { CfnTablePropsMixin } from '@aws-cdk/mixins-preview/aws_dynamodb/mixins';
 ```
 
 ## Error Handling

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appconfig/integ.configuration-kms.ts

@@ -6,6 +6,7 @@ import {
   ConfigurationContent,
   HostedConfiguration,
 } from 'aws-cdk-lib/aws-appconfig';
+import * as path from 'path';
 
 const app = new App();
 
@@ -21,7 +22,7 @@ const appConfigApp = new Application(stack, 'MyAppConfig', {
 
 new HostedConfiguration(stack, 'MyHostedConfigFromFile', {
   application: appConfigApp,
-  content: ConfigurationContent.fromFile('config.json'),
+  content: ConfigurationContent.fromFile(path.join(__dirname, 'config.json')),
   kmsKey,
 });