feat(imagebuilder-alpha): add support for Image Recipe Construct (#36092)

### Issue

aws/aws-cdk-rfcs#789

### Reason for this change

This change adds a new alpha module for EC2 Image Builder L2 Constructs (@aws-cdk/aws-imagebuilder-alpha), as outlined in aws/aws-cdk-rfcs#789. This PR specifically implements the ImageRecipe construct.

### Description of changes

This change implements the `ImageRecipe` construct, which is a higher-level construct of [CfnImageRecipe](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_imagebuilder.CfnImageRecipe.html).

#### Example

```ts
const userData = ec2.UserData.forLinux();
userData.addS3DownloadCommand({
  bucket: s3.Bucket.fromBucketName(this, 'Bucket', `test-bucket-${this.account}`),
  bucketKey: 'test-key',
  localFile: 's3-executable.sh',
});
userData.addExecuteFileCommand({ filePath: 's3-executable.sh' });
userData.addCommands('User Data complete!');

const imageRecipe = new imagebuilder.ImageRecipe(this, 'ImageRecipe', {
  imageRecipeName: 'test-image-recipe',
  imageRecipeVersion: '1.0.0',
  description: 'An Image Recipe',
  // Use an AL2023 base image
  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
    this,
    'MachineImage',
    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64',
  ),
  // Use an AWS-managed component, shared component, self-owned component with parameters, and marketplace component
  components: [
    {
      component: imagebuilder.AwsManagedComponent.updateOS(this, 'UpdateOS', {
        platform: imagebuilder.Platform.Linux,
      }),
    },
    {
      component: imagebuilder.Component.fromComponentArn(
        this,
        'ComplianceTestComponent',
        `arn:${this.partition}:imagebuilder:${this.region}:123456789012:component/compliance-test/2025.x.x.x`,
      ),
    },
    {
      component: imagebuilder.AwsMarketplaceComponent.fromAwsMarketplaceComponentAttributes(
        this,
        'MarketplaceComponent',
        {
          name: 'marketplace-component-name',
          marketplaceProductId: '12345678-1234-1234-1234-123456789012',
        },
      ),
    },
    {
      component: imagebuilder.Component.fromComponentAttributes(this, 'CustomComponent', {
        componentName: 'custom-component',
      }),
      parameters: {
        CUSTOM_PARAMETER_KEY: imagebuilder.ComponentParameterValue.fromString('custom-parameter-value'),
      },
    },
  ],
  workingDirectory: '/var/tmp',
  // Optional - retain the SSM agent after the build, and apply custom userdata
  uninstallSsmAgentAfterBuild: false,
  userDataOverride: userData,
  // Optional - attach additional block device to the build instance
  blockDevices: [
    {
      deviceName: '/dev/sda1',
      mappingEnabled: true,
      volume: ec2.BlockDeviceVolume.ebs(50, {
        deleteOnTermination: true,
        iops: 1000,
        volumeType: ec2.EbsDeviceVolumeType.GP3,
        throughput: 1000,
        encrypted: true,
        kmsKey: kms.Key.fromLookup(this, 'VolumeKey', { aliasName: 'alias/volume-encryption-key' }),
      }),
    },
  ],
  // Optional - specify tags to apply to the output AMI
  amiTags: {
    Environment: 'production',
  },
});
```

### Describe any new or updated permissions being added

N/A - new L2 construct in alpha module

### Description of how you validated changes

Validated with unit tests and integration tests. Manually verified generated CFN templates as well.

### Checklist
- [x] My code adheres to the [CONTRIBUTING GUIDE](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and [DESIGN GUIDELINES](https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md)

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: tarunb12

packages/@aws-cdk/aws-imagebuilder-alpha/README.md

@@ -36,6 +36,202 @@ 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

packages/@aws-cdk/aws-imagebuilder-alpha/lib/base-image.ts

@@ -1,6 +1,66 @@
 import * as ecr from 'aws-cdk-lib/aws-ecr';
 import * as ssm from 'aws-cdk-lib/aws-ssm';
 
+/**
+ * Represents a base image that is used to start from in EC2 Image Builder image builds
+ */
+export class BaseImage {
+  /**
+   * The AMI ID to use as a base image in an image recipe
+   *
+   * @param amiId The AMI ID to use as the base image
+   */
+  public static fromAmiId(amiId: string): BaseImage {
+    return new BaseImage(amiId);
+  }
+
+  /**
+   * The marketplace product ID for an AMI product to use as the base image in an image recipe
+   *
+   * @param productId The Marketplace AMI product ID to use as the base image
+   */
+  public static fromMarketplaceProductId(productId: string): BaseImage {
+    return new BaseImage(productId);
+  }
+
+  /**
+   * The SSM parameter to use as the base image in an image recipe
+   *
+   * @param parameter The SSM parameter to use as the base image
+   */
+  public static fromSsmParameter(parameter: ssm.IParameter): BaseImage {
+    return new BaseImage(`ssm:${parameter.parameterArn}`);
+  }
+
+  /**
+   * The parameter name for the SSM parameter to use as the base image in an image recipe
+   *
+   * @param parameterName The name of the SSM parameter to use as the base image
+   */
+  public static fromSsmParameterName(parameterName: string): BaseImage {
+    return new BaseImage(`ssm:${parameterName}`);
+  }
+
+  /**
+   * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,
+   * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.
+   *
+   * @param baseImageString The base image as a direct string value
+   */
+  public static fromString(baseImageString: string): BaseImage {
+    return new BaseImage(baseImageString);
+  }
+
+  /**
+   * The rendered base image to use
+   **/
+  public readonly image: string;
+
+  protected constructor(image: string) {
+    this.image = image;
+  }
+}
+
 /**
  * Represents a base image that is used to start from in EC2 Image Builder image builds
  */
@@ -80,7 +140,7 @@ export class ContainerInstanceImage {
   }
 
   /**
-   * The name of the SSM parameter used to launch the instance for building the container image
+   * The ARN of the SSM parameter used to launch the instance for building the container image
    *
    * @param parameterName The name of the SSM parameter used as the container instance image
    */

packages/@aws-cdk/aws-imagebuilder-alpha/lib/container-recipe.ts

@@ -9,6 +9,7 @@ import { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';
 import { Construct } from 'constructs';
 import { BaseContainerImage, ContainerInstanceImage } from './base-image';
 import { Repository } from './distribution-configuration';
+import { IImageRecipe } from './image-recipe';
 import { OSVersion } from './os-version';
 import { ComponentConfiguration, IRecipeBase } from './recipe-base';
 
@@ -378,6 +379,15 @@ export abstract class ContainerRecipeBase extends cdk.Resource implements IConta
   public _isContainerRecipe(): this is IContainerRecipe {
     return true;
   }
+
+  /**
+   * Indicates whether the recipe is an Image Recipe
+   *
+   * @internal
+   */
+  public _isImageRecipe(): this is IImageRecipe {
+    return false;
+  }
 }
 
 /**