feat(cli): allow to parallelize asset build

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/app.js

@@ -707,6 +707,28 @@ class DockerStackWithCustomFile extends cdk.Stack {
   }
 }
 
+class MultipleDockerAssetsStack extends cdk.Stack {
+  constructor(parent, id, props) {
+    super(parent, id, props);
+
+    new docker.DockerImageAsset(this, 'image1', {
+      directory: path.join(__dirname, 'docker-concurrent/image1')
+    });
+    new docker.DockerImageAsset(this, 'image2', {
+      directory: path.join(__dirname, 'docker-concurrent/image2')
+    });
+    new docker.DockerImageAsset(this, 'image3', {
+      directory: path.join(__dirname, 'docker-concurrent/image3')
+    });
+
+    // Add at least a single resource (WaitConditionHandle), otherwise this stack will never
+    // be deployed (and its assets never built)
+    new cdk.CfnResource(this, 'Handle', {
+      type: 'AWS::CloudFormation::WaitConditionHandle'
+    });
+  }
+}
+
 /**
  * A stack that will never succeed deploying (done in a way that CDK cannot detect but CFN will complain about)
  */
@@ -921,6 +943,7 @@ switch (stackSet) {
     new DockerStack(app, `${stackPrefix}-docker`);
     new DockerInUseStack(app, `${stackPrefix}-docker-in-use`);
     new DockerStackWithCustomFile(app, `${stackPrefix}-docker-with-custom-file`);
+    new MultipleDockerAssetsStack(app, `${stackPrefix}-multiple-docker-assets`);
 
     new NotificationArnsStack(app, `${stackPrefix}-notification-arns`);
 

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/docker-concurrent/image1/Dockerfile

@@ -0,0 +1,2 @@
+FROM public.ecr.aws/docker/library/alpine:latest
+RUN echo "image1"

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/docker-concurrent/image2/Dockerfile

@@ -0,0 +1,2 @@
+FROM public.ecr.aws/docker/library/alpine:latest
+RUN echo "image2"

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/docker-concurrent/image3/Dockerfile

@@ -0,0 +1,2 @@
+FROM public.ecr.aws/docker/library/alpine:latest
+RUN echo "image3"

packages/@aws-cdk-testing/cli-integ/tests/cli-integ-tests/deploy/cdk-deploy-stack-with-multiple-docker-assets.integtest.ts

@@ -0,0 +1,12 @@
+import { integTest, withDefaultFixture } from '../../../lib';
+
+jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
+
+integTest(
+  'deploy stack with multiple docker assets',
+  withDefaultFixture(async (fixture) => {
+    await fixture.cdkDeploy('multiple-docker-assets', {
+      options: ['--asset-parallelism', '--asset-build-concurrency', '3'],
+    });
+  }),
+);

packages/@aws-cdk-testing/cli-integ/tests/toolkit-lib-integ-tests/toolkit-deploy-stack-with-multiple-docker-assets.integtest.ts

@@ -0,0 +1,27 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import * as toolkit from '@aws-cdk/toolkit-lib';
+import { assemblyFromCdkAppDir, toolkitFromFixture } from './toolkit-helpers';
+import { integTest, withDefaultFixture } from '../../lib';
+
+jest.setTimeout(2 * 60 * 60_000); // Includes the time to acquire locks, worst-case single-threaded runtime
+
+integTest(
+  'toolkit deploy stack with multiple docker assets',
+  withDefaultFixture(async (fixture) => {
+    const tk = toolkitFromFixture(fixture);
+
+    const assembly = await assemblyFromCdkAppDir(tk, fixture);
+
+    const stacks: toolkit.StackSelector = {
+      strategy: toolkit.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,
+      patterns: [fixture.fullStackName('multiple-docker-assets')],
+    };
+
+    await tk.deploy(assembly, {
+      stacks,
+      assetParallelism: true,
+      assetBuildConcurrency: 3,
+    });
+    await tk.destroy(assembly, { stacks });
+  }),
+);

packages/@aws-cdk/toolkit-lib/lib/actions/deploy/index.ts

@@ -214,6 +214,15 @@ export interface DeployOptions extends BaseDeployOptions {
    */
   readonly assetParallelism?: boolean;
 
+  /**
+   * Maximum number of asset builds to run in parallel
+   *
+   * This setting only has an effect if `assetParallelism` is set to `true`.
+   *
+   * @default 1
+   */
+  readonly assetBuildConcurrency?: number;
+
   /**
    * When to build assets
    *

packages/@aws-cdk/toolkit-lib/lib/toolkit/toolkit.ts

@@ -823,7 +823,7 @@ export class Toolkit extends CloudAssemblySourceBuilder {
 
     const graphConcurrency: Concurrency = {
       'stack': concurrency,
-      'asset-build': 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
+      'asset-build': (options.assetParallelism ?? true) ? options.assetBuildConcurrency ?? 1 : 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
       'asset-publish': (options.assetParallelism ?? true) ? 8 : 1, // This will be I/O-bound, 8 in parallel seems reasonable
     };
 

packages/@aws-cdk/toolkit-lib/test/actions/deploy.test.ts

@@ -1,6 +1,7 @@
 import { StackParameters } from '../../lib/actions/deploy';
 import type { DeployStackOptions, DeployStackResult } from '../../lib/api/deployments';
 import * as deployments from '../../lib/api/deployments';
+import { WorkGraphBuilder } from '../../lib/api/work-graph';
 import { Toolkit } from '../../lib/toolkit';
 import { builderFixture, cdkOutFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 
@@ -161,6 +162,83 @@ IAM Statement Changes
         forcePublish: true,
       }));
     });
+
+    describe('assetBuildConcurrency', () => {
+      let buildSpy: jest.SpyInstance;
+
+      afterEach(() => {
+        buildSpy?.mockRestore();
+      });
+
+      test('is passed when assetParallelism is true', async () => {
+        const mockWorkGraph = {
+          doParallel: jest.fn().mockResolvedValue(undefined),
+          removeUnnecessaryAssets: jest.fn().mockResolvedValue(undefined),
+        };
+        buildSpy = jest.spyOn(WorkGraphBuilder.prototype, 'build').mockReturnValue(mockWorkGraph as any);
+
+        const cx = await builderFixture(toolkit, 'stack-with-asset');
+
+        await toolkit.deploy(cx, {
+          assetParallelism: true,
+          assetBuildConcurrency: 4,
+        });
+
+        expect(mockWorkGraph.doParallel).toHaveBeenCalledWith(
+          expect.objectContaining({
+            'asset-build': 4,
+          }),
+          expect.anything(),
+        );
+      });
+
+      test('is ignored when assetParallelism is false', async () => {
+        const mockWorkGraph = {
+          doParallel: jest.fn().mockResolvedValue(undefined),
+          removeUnnecessaryAssets: jest.fn().mockResolvedValue(undefined),
+        };
+        buildSpy = jest.spyOn(WorkGraphBuilder.prototype, 'build').mockReturnValue(mockWorkGraph as any);
+
+        const cx = await builderFixture(toolkit, 'stack-with-asset');
+
+        await toolkit.deploy(cx, {
+          assetParallelism: false,
+          assetBuildConcurrency: 4,
+        });
+
+        expect(mockWorkGraph.doParallel).toHaveBeenCalledWith(
+          expect.objectContaining({
+            'asset-build': 1,
+          }),
+          expect.anything(),
+        );
+      });
+
+      test.each([
+        true,
+        false,
+        undefined,
+      ])('defaults to 1 when assetParallelism=%s and assetBuildConcurrency is not specified', async (assetParallelism) => {
+        const mockWorkGraph = {
+          doParallel: jest.fn().mockResolvedValue(undefined),
+          removeUnnecessaryAssets: jest.fn().mockResolvedValue(undefined),
+        };
+        buildSpy = jest.spyOn(WorkGraphBuilder.prototype, 'build').mockReturnValue(mockWorkGraph as any);
+
+        const cx = await builderFixture(toolkit, 'stack-with-asset');
+
+        await toolkit.deploy(cx, {
+          assetParallelism,
+        });
+
+        expect(mockWorkGraph.doParallel).toHaveBeenCalledWith(
+          expect.objectContaining({
+            'asset-build': 1,
+          }),
+          expect.anything(),
+        );
+      });
+    });
   });
 
   describe('deployment results', () => {

packages/aws-cdk/lib/cli/cdk-toolkit.ts

@@ -705,7 +705,7 @@ export class CdkToolkit {
 
     const graphConcurrency: Concurrency = {
       'stack': concurrency,
-      'asset-build': 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
+      'asset-build': (options.assetParallelism ?? true) ? options.assetBuildConcurrency ?? 1 : 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
       'asset-publish': (options.assetParallelism ?? true) ? 8 : 1, // This will be I/O-bound, 8 in parallel seems reasonable
     };
 
@@ -1766,6 +1766,15 @@ export interface DeployOptions extends CfnDeployOptions, WatchOptions {
    */
   readonly assetParallelism?: boolean;
 
+  /**
+   * Maximum number of asset builds to run in parallel
+   *
+   * This setting only has an effect if `assetParallelism` is set to `true`.
+   *
+   * @default 1
+   */
+  readonly assetBuildConcurrency?: number;
+
   /**
    * When to build assets
    *

packages/aws-cdk/lib/cli/cli-config.ts

@@ -208,6 +208,7 @@ export async function makeConfig(): Promise<CliConfig> {
           },
           'concurrency': { type: 'number', desc: 'Maximum number of simultaneous deployments (dependency permitting) to execute.', default: 1, requiresArg: true },
           'asset-parallelism': { type: 'boolean', desc: 'Whether to build/publish assets in parallel' },
+          'asset-build-concurrency': { type: 'number', desc: 'Maximum number of asset builds to run in parallel', default: 1, requiresArg: true },
           'asset-prebuild': { type: 'boolean', desc: 'Whether to build all assets before deploying the first stack (useful for failing Docker builds)', default: true },
           'ignore-no-stacks': { type: 'boolean', desc: 'Whether to deploy if the app contains no stacks', default: false },
         },

packages/aws-cdk/lib/cli/cli-type-registry.json

@@ -548,6 +548,12 @@
           "type": "boolean",
           "desc": "Whether to build/publish assets in parallel"
         },
+        "asset-build-concurrency": {
+          "type": "number",
+          "desc": "Maximum number of asset builds to run in parallel",
+          "default": 1,
+          "requiresArg": true
+        },
         "asset-prebuild": {
           "type": "boolean",
           "desc": "Whether to build all assets before deploying the first stack (useful for failing Docker builds)",

packages/aws-cdk/lib/cli/cli.ts

@@ -407,6 +407,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
           traceLogs: args.logs,
           concurrency: args.concurrency,
           assetParallelism: configuration.settings.get(['assetParallelism']),
+          assetBuildConcurrency: configuration.settings.get(['assetBuildConcurrency']),
           assetBuildTime: configuration.settings.get(['assetPrebuild'])
             ? AssetBuildTime.ALL_BEFORE_DEPLOY
             : AssetBuildTime.JUST_IN_TIME,

packages/aws-cdk/lib/cli/convert-to-user-input.ts

@@ -140,6 +140,7 @@ export function convertYargsToUserInput(args: any): UserInput {
         logs: args.logs,
         concurrency: args.concurrency,
         assetParallelism: args.assetParallelism,
+        assetBuildConcurrency: args.assetBuildConcurrency,
         assetPrebuild: args.assetPrebuild,
         ignoreNoStacks: args.ignoreNoStacks,
         STACKS: args.STACKS,
@@ -425,6 +426,7 @@ export function convertConfigToUserInput(config: any): UserInput {
     logs: config.deploy?.logs,
     concurrency: config.deploy?.concurrency,
     assetParallelism: config.deploy?.assetParallelism,
+    assetBuildConcurrency: config.deploy?.assetBuildConcurrency,
     assetPrebuild: config.deploy?.assetPrebuild,
     ignoreNoStacks: config.deploy?.ignoreNoStacks,
   };

packages/aws-cdk/lib/cli/parse-command-line-arguments.ts

@@ -584,6 +584,12 @@ export function parseCommandLineArguments(args: Array<string>): any {
           type: 'boolean',
           desc: 'Whether to build/publish assets in parallel',
         })
+        .option('asset-build-concurrency', {
+          default: 1,
+          type: 'number',
+          desc: 'Maximum number of asset builds to run in parallel',
+          requiresArg: true,
+        })
         .option('asset-prebuild', {
           default: true,
           type: 'boolean',

packages/aws-cdk/lib/cli/user-configuration.ts

@@ -321,6 +321,7 @@ export async function commandLineArgumentsToSettings(ioHelper: IoHelper, argv: A
     rollback: argv.rollback,
     notices: argv.notices,
     assetParallelism: argv['asset-parallelism'],
+    assetBuildConcurrency: argv['asset-build-concurrency'],
     assetPrebuild: argv['asset-prebuild'],
     ignoreNoStacks: argv['ignore-no-stacks'],
     hotswap: {

packages/aws-cdk/lib/cli/user-input.ts

@@ -911,6 +911,13 @@ export interface DeployOptions {
    */
   readonly assetParallelism?: boolean;
 
+  /**
+   * Maximum number of asset builds to run in parallel
+   *
+   * @default - 1
+   */
+  readonly assetBuildConcurrency?: number;
+
   /**
    * Whether to build all assets before deploying the first stack (useful for failing Docker builds)
    *

packages/aws-cdk/lib/legacy/configuration.ts

@@ -307,6 +307,7 @@ function commandLineArgumentsToSettings(argv: Arguments): Settings {
     rollback: argv.rollback,
     notices: argv.notices,
     assetParallelism: argv['asset-parallelism'],
+    assetBuildConcurrency: argv['asset-build-concurrency'],
     assetPrebuild: argv['asset-prebuild'],
     ignoreNoStacks: argv['ignore-no-stacks'],
     hotswap: {