aws-cdk
Version:
AWS CDK CLI, the command line tool for CDK apps
202 lines • 31.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.EnvironmentAccess = void 0;
const environment_resources_1 = require("./environment-resources");
const placeholders_1 = require("./placeholders");
const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
const private_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private");
const util_1 = require("../../util");
const mode_1 = require("../plugin/mode");
/**
* Access particular AWS resources, based on information from the CX manifest
*
* It is not possible to grab direct access to AWS credentials; 9 times out of 10
* we have to allow for role assumption, and role assumption can only work if
* there is a CX Manifest that contains a role ARN.
*
* This class exists so new code isn't tempted to go and get SDK credentials directly.
*/
class EnvironmentAccess {
constructor(sdkProvider, toolkitStackName, ioHelper) {
this.sdkProvider = sdkProvider;
this.sdkCache = new Map();
this.environmentResources = new environment_resources_1.EnvironmentResourcesRegistry(toolkitStackName);
this.ioHelper = ioHelper;
}
/**
* Resolves the environment for a stack.
*/
async resolveStackEnvironment(stack) {
return this.sdkProvider.resolveEnvironment(stack.environment);
}
/**
* Get an SDK to access the given stack's environment for stack operations
*
* Will ask plugins for readonly credentials if available, use the default
* AWS credentials if not.
*
* Will assume the deploy role if configured on the stack. Check the default `deploy-role`
* policies to see what you can do with this role.
*/
async accessStackForReadOnlyStackOperations(stack) {
return this.accessStackForStackOperations(stack, mode_1.Mode.ForReading);
}
/**
* Get an SDK to access the given stack's environment for stack operations
*
* Will ask plugins for mutating credentials if available, use the default AWS
* credentials if not. The `mode` parameter is only used for querying
* plugins.
*
* Will assume the deploy role if configured on the stack. Check the default `deploy-role`
* policies to see what you can do with this role.
*/
async accessStackForMutableStackOperations(stack) {
return this.accessStackForStackOperations(stack, mode_1.Mode.ForWriting);
}
/**
* Get an SDK to access the given stack's environment for environmental lookups
*
* Will use a plugin if available, use the default AWS credentials if not.
* The `mode` parameter is only used for querying plugins.
*
* Will assume the lookup role if configured on the stack. Check the default `lookup-role`
* policies to see what you can do with this role. It can generally read everything
* in the account that does not require KMS access.
*
* ---
*
* For backwards compatibility reasons, there are some scenarios that are handled here:
*
* 1. The lookup role may not exist (it was added in bootstrap stack version 7). If so:
* a. Return the default credentials if the default credentials are for the stack account
* (you will notice this as `isFallbackCredentials=true`).
* b. Throw an error if the default credentials are not for the stack account.
*
* 2. The lookup role may not have the correct permissions (for example, ReadOnlyAccess was added in
* bootstrap stack version 8); the stack will have a minimum version number on it.
* a. If it does not we throw an error which should be handled in the calling
* function (and fallback to use a different role, etc)
*
* Upon success, caller will have an SDK for the right account, which may or may not have
* the right permissions.
*/
async accessStackForLookup(stack) {
if (!stack.environment) {
throw new api_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
}
const lookupEnv = await this.prepareSdk({
environment: stack.environment,
mode: mode_1.Mode.ForReading,
assumeRoleArn: stack.lookupRole?.arn,
assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,
assumeRoleAdditionalOptions: stack.lookupRole?.assumeRoleAdditionalOptions,
});
// if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version
if (lookupEnv.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {
const version = await lookupEnv.resources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);
if (version < stack.lookupRole.requiresBootstrapStackVersion) {
throw new api_1.ToolkitError(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'. To get rid of this error, please upgrade to bootstrap version >= ${stack.lookupRole.requiresBootstrapStackVersion}`);
}
}
if (lookupEnv.isFallbackCredentials) {
const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
}
return lookupEnv;
}
/**
* Get an SDK to access the given stack's environment for reading stack attributes
*
* Will use a plugin if available, use the default AWS credentials if not.
* The `mode` parameter is only used for querying plugins.
*
* Will try to assume the lookup role if given, will use the regular stack operations
* access (deploy-role) otherwise. When calling this, you should assume that you will get
* the least privileged role, so don't try to use it for anything the `deploy-role`
* wouldn't be able to do. Also you cannot rely on being able to read encrypted anything.
*/
async accessStackForLookupBestEffort(stack) {
if (!stack.environment) {
throw new api_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
}
try {
return await this.accessStackForLookup(stack);
}
catch (e) {
await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`${(0, util_1.formatErrorMessage)(e)}`));
}
return this.accessStackForStackOperations(stack, mode_1.Mode.ForReading);
}
/**
* Get an SDK to access the given stack's environment for stack operations
*
* Will use a plugin if available, use the default AWS credentials if not.
* The `mode` parameter is only used for querying plugins.
*
* Will assume the deploy role if configured on the stack. Check the default `deploy-role`
* policies to see what you can do with this role.
*/
async accessStackForStackOperations(stack, mode) {
if (!stack.environment) {
throw new api_1.ToolkitError(`The stack ${stack.displayName} does not have an environment`);
}
return this.prepareSdk({
environment: stack.environment,
mode,
assumeRoleArn: stack.assumeRoleArn,
assumeRoleExternalId: stack.assumeRoleExternalId,
assumeRoleAdditionalOptions: stack.assumeRoleAdditionalOptions,
});
}
/**
* Prepare an SDK for use in the given environment and optionally with a role assumed.
*/
async prepareSdk(options) {
const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(options.environment);
// Substitute any placeholders with information about the current environment
const { assumeRoleArn } = await (0, placeholders_1.replaceEnvPlaceholders)({
assumeRoleArn: options.assumeRoleArn,
}, resolvedEnvironment, this.sdkProvider);
const stackSdk = await this.cachedSdkForEnvironment(resolvedEnvironment, options.mode, {
assumeRoleArn,
assumeRoleExternalId: options.assumeRoleExternalId,
assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,
});
return {
sdk: stackSdk.sdk,
resolvedEnvironment,
resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),
// If we asked for a role, did not successfully assume it, and yet got here without an exception: that
// means we must have fallback credentials.
isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,
didAssumeRole: stackSdk.didAssumeRole,
replacePlaceholders: async (str) => {
const ret = await (0, placeholders_1.replaceEnvPlaceholders)({ str }, resolvedEnvironment, this.sdkProvider);
return ret.str;
},
};
}
async cachedSdkForEnvironment(environment, mode, options) {
const cacheKeyElements = [
environment.account,
environment.region,
`${mode}`,
options?.assumeRoleArn ?? '',
options?.assumeRoleExternalId ?? '',
];
if (options?.assumeRoleAdditionalOptions) {
cacheKeyElements.push(JSON.stringify(options.assumeRoleAdditionalOptions));
}
const cacheKey = cacheKeyElements.join(':');
const existing = this.sdkCache.get(cacheKey);
if (existing) {
return existing;
}
const ret = await this.sdkProvider.forEnvironment(environment, mode, options);
this.sdkCache.set(cacheKey, ret);
return ret;
}
}
exports.EnvironmentAccess = EnvironmentAccess;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-access.js","sourceRoot":"","sources":["environment-access.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport type { SDK } from '../aws-auth';\nimport type { EnvironmentResources } from './environment-resources';\nimport { EnvironmentResourcesRegistry } from './environment-resources';\nimport type { StringWithoutPlaceholders } from './placeholders';\nimport { replaceEnvPlaceholders } from './placeholders';\nimport { ToolkitError } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport { IO, type IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { formatErrorMessage } from '../../util';\nimport type { CredentialsOptions, SdkForEnvironment, SdkProvider } from '../aws-auth/sdk-provider';\nimport { Mode } from '../plugin/mode';\n\n/**\n * Access particular AWS resources, based on information from the CX manifest\n *\n * It is not possible to grab direct access to AWS credentials; 9 times out of 10\n * we have to allow for role assumption, and role assumption can only work if\n * there is a CX Manifest that contains a role ARN.\n *\n * This class exists so new code isn't tempted to go and get SDK credentials directly.\n */\nexport class EnvironmentAccess {\n  private readonly sdkCache = new Map<string, SdkForEnvironment>();\n  private readonly environmentResources: EnvironmentResourcesRegistry;\n  private readonly ioHelper: IoHelper;\n\n  constructor(private readonly sdkProvider: SdkProvider, toolkitStackName: string, ioHelper: IoHelper) {\n    this.environmentResources = new EnvironmentResourcesRegistry(toolkitStackName);\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Resolves the environment for a stack.\n   */\n  public async resolveStackEnvironment(stack: cxapi.CloudFormationStackArtifact): Promise<cxapi.Environment> {\n    return this.sdkProvider.resolveEnvironment(stack.environment);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will ask plugins for readonly credentials if available, use the default\n   * AWS credentials if not.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  public async accessStackForReadOnlyStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    return this.accessStackForStackOperations(stack, Mode.ForReading);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will ask plugins for mutating credentials if available, use the default AWS\n   * credentials if not.  The `mode` parameter is only used for querying\n   * plugins.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  public async accessStackForMutableStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    return this.accessStackForStackOperations(stack, Mode.ForWriting);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for environmental lookups\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will assume the lookup role if configured on the stack. Check the default `lookup-role`\n   * policies to see what you can do with this role. It can generally read everything\n   * in the account that does not require KMS access.\n   *\n   * ---\n   *\n   * For backwards compatibility reasons, there are some scenarios that are handled here:\n   *\n   *  1. The lookup role may not exist (it was added in bootstrap stack version 7). If so:\n   *     a. Return the default credentials if the default credentials are for the stack account\n   *        (you will notice this as `isFallbackCredentials=true`).\n   *     b. Throw an error if the default credentials are not for the stack account.\n   *\n   *  2. The lookup role may not have the correct permissions (for example, ReadOnlyAccess was added in\n   *     bootstrap stack version 8); the stack will have a minimum version number on it.\n   *     a. If it does not we throw an error which should be handled in the calling\n   *        function (and fallback to use a different role, etc)\n   *\n   * Upon success, caller will have an SDK for the right account, which may or may not have\n   * the right permissions.\n   */\n  public async accessStackForLookup(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    const lookupEnv = await this.prepareSdk({\n      environment: stack.environment,\n      mode: Mode.ForReading,\n      assumeRoleArn: stack.lookupRole?.arn,\n      assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: stack.lookupRole?.assumeRoleAdditionalOptions,\n    });\n\n    // if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version\n    if (lookupEnv.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {\n      const version = await lookupEnv.resources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);\n      if (version < stack.lookupRole.requiresBootstrapStackVersion) {\n        throw new ToolkitError(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'. To get rid of this error, please upgrade to bootstrap version >= ${stack.lookupRole.requiresBootstrapStackVersion}`);\n      }\n    }\n    if (lookupEnv.isFallbackCredentials) {\n      const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));\n    }\n    return lookupEnv;\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for reading stack attributes\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will try to assume the lookup role if given, will use the regular stack operations\n   * access (deploy-role) otherwise. When calling this, you should assume that you will get\n   * the least privileged role, so don't try to use it for anything the `deploy-role`\n   * wouldn't be able to do. Also you cannot rely on being able to read encrypted anything.\n   */\n  public async accessStackForLookupBestEffort(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    try {\n      return await this.accessStackForLookup(stack);\n    } catch (e: any) {\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${formatErrorMessage(e)}`));\n    }\n    return this.accessStackForStackOperations(stack, Mode.ForReading);\n  }\n\n  /**\n   * Get an SDK to access the given stack's environment for stack operations\n   *\n   * Will use a plugin if available, use the default AWS credentials if not.\n   * The `mode` parameter is only used for querying plugins.\n   *\n   * Will assume the deploy role if configured on the stack. Check the default `deploy-role`\n   * policies to see what you can do with this role.\n   */\n  private async accessStackForStackOperations(stack: cxapi.CloudFormationStackArtifact, mode: Mode): Promise<TargetEnvironment> {\n    if (!stack.environment) {\n      throw new ToolkitError(`The stack ${stack.displayName} does not have an environment`);\n    }\n\n    return this.prepareSdk({\n      environment: stack.environment,\n      mode,\n      assumeRoleArn: stack.assumeRoleArn,\n      assumeRoleExternalId: stack.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: stack.assumeRoleAdditionalOptions,\n    });\n  }\n\n  /**\n   * Prepare an SDK for use in the given environment and optionally with a role assumed.\n   */\n  private async prepareSdk(\n    options: PrepareSdkRoleOptions,\n  ): Promise<TargetEnvironment> {\n    const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(options.environment);\n\n    // Substitute any placeholders with information about the current environment\n    const { assumeRoleArn } = await replaceEnvPlaceholders({\n      assumeRoleArn: options.assumeRoleArn,\n    }, resolvedEnvironment, this.sdkProvider);\n\n    const stackSdk = await this.cachedSdkForEnvironment(resolvedEnvironment, options.mode, {\n      assumeRoleArn,\n      assumeRoleExternalId: options.assumeRoleExternalId,\n      assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions,\n    });\n\n    return {\n      sdk: stackSdk.sdk,\n      resolvedEnvironment,\n      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),\n      // If we asked for a role, did not successfully assume it, and yet got here without an exception: that\n      // means we must have fallback credentials.\n      isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,\n      didAssumeRole: stackSdk.didAssumeRole,\n      replacePlaceholders: async <A extends string | undefined>(str: A) => {\n        const ret = await replaceEnvPlaceholders({ str }, resolvedEnvironment, this.sdkProvider);\n        return ret.str;\n      },\n    };\n  }\n\n  private async cachedSdkForEnvironment(\n    environment: cxapi.Environment,\n    mode: Mode,\n    options?: CredentialsOptions,\n  ) {\n    const cacheKeyElements = [\n      environment.account,\n      environment.region,\n      `${mode}`,\n      options?.assumeRoleArn ?? '',\n      options?.assumeRoleExternalId ?? '',\n    ];\n\n    if (options?.assumeRoleAdditionalOptions) {\n      cacheKeyElements.push(JSON.stringify(options.assumeRoleAdditionalOptions));\n    }\n\n    const cacheKey = cacheKeyElements.join(':');\n    const existing = this.sdkCache.get(cacheKey);\n    if (existing) {\n      return existing;\n    }\n    const ret = await this.sdkProvider.forEnvironment(environment, mode, options);\n    this.sdkCache.set(cacheKey, ret);\n    return ret;\n  }\n}\n\n/**\n * SDK obtained by assuming the deploy role\n * for a given environment\n */\nexport interface TargetEnvironment {\n  /**\n   * The SDK for the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * The resolved environment for the stack\n   * (no more 'unknown-account/unknown-region')\n   */\n  readonly resolvedEnvironment: cxapi.Environment;\n\n  /**\n   * Access class for environmental resources to help the deployment\n   */\n  readonly resources: EnvironmentResources;\n\n  /**\n   * Whether or not we assumed a role in the process of getting these credentials\n   */\n  readonly didAssumeRole: boolean;\n\n  /**\n   * Whether or not these are fallback credentials\n   *\n   * Fallback credentials means that assuming the intended role failed, but the\n   * base credentials happen to be for the right account so we just picked those\n   * and hope the future SDK calls succeed.\n   *\n   * This is a backwards compatibility mechanism from around the time we introduced\n   * deployment roles.\n   */\n  readonly isFallbackCredentials: boolean;\n\n  /**\n   * Replace environment placeholders according to the current environment\n   */\n  replacePlaceholders(x: string | undefined): Promise<StringWithoutPlaceholders | undefined>;\n}\n\ninterface PrepareSdkRoleOptions {\n  readonly environment: cxapi.Environment;\n  readonly mode: Mode;\n  readonly assumeRoleArn?: string;\n  readonly assumeRoleExternalId?: string;\n  readonly assumeRoleAdditionalOptions?: { [key: string]: any };\n}\n"]}