Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that EC2 Image Builder can respond with.

Structs

AccountAggregation

Contains counts of vulnerability findings from image scans that run when you create new Image Builder images, or build new versions of existing images. The vulnerability counts are grouped by severity level. The counts are aggregated across resources to create the final tally for the account that owns them.

AdditionalInstanceConfiguration

In addition to your infrastructure configuration, these settings provide an extra layer of control over your build instances. You can also specify commands to run on launch for all of your build instances.

Image Builder does not automatically install the Systems Manager agent on Windows instances. If your base image includes the Systems Manager agent, then the AMI that you create will also include the agent. For Linux instances, if the base image does not already include the Systems Manager agent, Image Builder installs it. For Linux instances where Image Builder installs the Systems Manager agent, you can choose whether to keep it for the AMI that you create.

Ami

Details of an Amazon EC2 AMI.

AmiDistributionConfiguration

Define and configure the output AMIs of the pipeline.

Component

A detailed view of a component.

ComponentConfiguration

Configuration details of the component.

ComponentParameter

Contains a key/value pair that sets the named component parameter.

ComponentParameterDetail

Defines a parameter that is used to provide configuration details for the component.

ComponentState

A group of fields that describe the current status of components.

ComponentSummary

A high-level summary of a component.

ComponentVersion

The defining characteristics of a specific version of an Amazon Web Services TOE component.

Container

A container encapsulates the runtime environment for an application.

ContainerDistributionConfiguration

Container distribution settings for encryption, licensing, and sharing in a specific Region.

ContainerRecipe

A container recipe.

ContainerRecipeSummary

A summary of a container recipe

CvssScore

Amazon Inspector generates a risk score for each finding. This score helps you to prioritize findings, to focus on the most critical findings and the most vulnerable resources. The score uses the Common Vulnerability Scoring System (CVSS) format. This format is a modification of the base CVSS score that the National Vulnerability Database (NVD) provides. For more information about severity levels, see Severity levels for Amazon Inspector findings in the Amazon Inspector User Guide.

CvssScoreAdjustment

Details about an adjustment that Amazon Inspector made to the CVSS score for a finding.

CvssScoreDetails

Details about the source of the score, and the factors that determined the adjustments to create the final score.

Distribution

Defines the settings for a specific Region.

DistributionConfiguration

A distribution configuration.

DistributionConfigurationSummary

A high-level overview of a distribution configuration.

EbsInstanceBlockDeviceSpecification

Amazon EBS-specific block device mapping specifications.

EcrConfiguration

Settings that Image Builder uses to configure the ECR repository and the output container images that Amazon Inspector scans.

FastLaunchConfiguration

Define and configure faster launching for output Windows AMIs.

FastLaunchLaunchTemplateSpecification

Identifies the launch template that the associated Windows AMI uses for launching an instance when faster launching is enabled.

You can specify either the launchTemplateName or the launchTemplateId, but not both.

FastLaunchSnapshotConfiguration

Configuration settings for creating and managing pre-provisioned snapshots for a fast-launch enabled Windows AMI.

Filter

A filter name and value pair that is used to return a more specific list of results from a list operation. Filters can be used to match a set of resources by specific criteria, such as tags, attributes, or IDs.

Image

An Image Builder image. You must specify exactly one recipe for the image – either a container recipe (containerRecipe), which creates a container image, or an image recipe (imageRecipe), which creates an AMI.

ImageAggregation

Contains vulnerability counts for a specific image.

ImagePackage

A software package that's installed on top of the base image to create a customized image.

ImagePipeline

Details of an image pipeline.

ImagePipelineAggregation

Contains vulnerability counts for a specific image pipeline.

ImageRecipe

An image recipe.

ImageRecipeSummary

A summary of an image recipe.

ImageScanFinding

Contains details about a vulnerability scan finding.

ImageScanFindingAggregation

This returns exactly one type of aggregation, based on the filter that Image Builder applies in its API action.

ImageScanFindingsFilter

A name value pair that Image Builder applies to streamline results from the vulnerability scan findings list action.

ImageScanState

Shows the vulnerability scan status for a specific image, and the reason for that status.

ImageScanningConfiguration

Contains settings for Image Builder image resource and container image scans.

ImageState

Image status and the reason for that status.

ImageSummary

An image summary.

ImageTestsConfiguration

Configure image tests for your pipeline build. Tests run after building the image, to verify that the AMI or container image is valid before distributing it.

ImageVersion

The defining characteristics of a specific version of an Image Builder image.

InfrastructureConfiguration

Details of the infrastructure configuration.

InfrastructureConfigurationSummary

The infrastructure used when building Amazon EC2 AMIs.

InspectorScoreDetails

Information about the factors that influenced the score that Amazon Inspector assigned for a finding.

InstanceBlockDeviceMapping

Defines block device mappings for the instance used to configure your image.

InstanceConfiguration

Defines a custom base AMI and block device mapping configurations of an instance used for building and testing container images.

InstanceMetadataOptions

The instance metadata options that apply to the HTTP requests that pipeline builds use to launch EC2 build and test instances. For more information about instance metadata options, see Configure the instance metadata options in the Amazon EC2 User Guide for Linux instances, or Configure the instance metadata options in the Amazon EC2 Windows Guide for Windows instances.

LaunchPermissionConfiguration

Describes the configuration for a launch permission. The launch permission modification request is sent to the Amazon EC2 ModifyImageAttribute API on behalf of the user for each Region they have selected to distribute the AMI. To make an AMI public, set the launch permission authorized accounts to all. See the examples for making an AMI public at Amazon EC2 ModifyImageAttribute.

LaunchTemplateConfiguration

Identifies an Amazon EC2 launch template to use for a specific account.

LifecycleExecution

Contains metadata from a runtime instance of a lifecycle policy.

LifecycleExecutionResource

Contains details for a resource that the runtime instance of the lifecycle policy identified for action.

LifecycleExecutionResourceAction

The lifecycle policy action that was identified for the impacted resource.

LifecycleExecutionResourceState

Contains the state of an impacted resource that the runtime instance of the lifecycle policy identified for action.

LifecycleExecutionResourcesImpactedSummary

Contains details for an image resource that was identified for a lifecycle action.

LifecycleExecutionSnapshotResource

Contains the state of an impacted snapshot resource that the runtime instance of the lifecycle policy identified for action.

LifecycleExecutionState

The current state of the runtime instance of the lifecycle policy.

LifecyclePolicy

The configuration details for a lifecycle policy resource.

LifecyclePolicyDetail

The configuration details for a lifecycle policy resource.

LifecyclePolicyDetailAction

Contains selection criteria for the lifecycle policy.

LifecyclePolicyDetailActionIncludeResources

Specifies how the lifecycle policy should apply actions to selected resources.

LifecyclePolicyDetailExclusionRules

Specifies resources that lifecycle policy actions should not apply to.

LifecyclePolicyDetailExclusionRulesAmis

Defines criteria for AMIs that are excluded from lifecycle actions.

LifecyclePolicyDetailExclusionRulesAmisLastLaunched

Defines criteria to exclude AMIs from lifecycle actions based on the last time they were used to launch an instance.

LifecyclePolicyDetailFilter

Defines filters that the lifecycle policy uses to determine impacted resource.

LifecyclePolicyResourceSelection

Resource selection criteria for the lifecycle policy.

LifecyclePolicyResourceSelectionRecipe

Specifies an Image Builder recipe that the lifecycle policy uses for resource selection.

LifecyclePolicySummary

Contains a summary of lifecycle policy resources.

Logging

Logging configuration defines where Image Builder uploads your logs.

OutputResources

The resources produced by this image.

PackageVulnerabilityDetails

Information about package vulnerability findings.

Placement

By default, EC2 instances run on shared tenancy hardware. This means that multiple Amazon Web Services accounts might share the same physical hardware. When you use dedicated hardware, the physical server that hosts your instances is dedicated to your Amazon Web Services account. Instance placement settings contain the details for the physical hardware where instances that Image Builder launches during image creation will run.

ProductCodeListItem

Information about a single product code.

Remediation

Information about how to remediate a finding.

RemediationRecommendation

Details about the recommended course of action to remediate the finding.

ResourceState

The current state of an impacted resource.

ResourceStateUpdateExclusionRules

Additional rules to specify resources that should be exempt from ad-hoc lifecycle actions.

ResourceStateUpdateIncludeResources

Specifies if the lifecycle policy should apply actions to selected resources.

S3ExportConfiguration

Properties that configure export from your build instance to a compatible file format for your VM.

S3Logs

Amazon S3 logging configuration.

Schedule

A schedule configures when and how often a pipeline will automatically create a new image.

SeverityCounts

Includes counts by severity level for medium severity and higher level findings, plus a total for all of the findings for the specified filter.

SsmParameterConfiguration

Configuration for a single Parameter in the Amazon Web Services Systems Manager (SSM) Parameter Store in a given Region.

SystemsManagerAgent

Contains settings for the Systems Manager agent on your build instance.

TargetContainerRepository

The container repository where the output container image is stored.

VulnerabilityIdAggregation

Includes counts of image and pipeline resource findings by vulnerability.

VulnerablePackage

Information about a vulnerable package that Amazon Inspector identifies in a finding.

Workflow

Defines a process that Image Builder uses to build and test images during the image creation process.

WorkflowConfiguration

Contains control settings and configurable inputs for a workflow resource.

WorkflowExecutionMetadata

Metadata that includes details and status from this runtime instance of the workflow.

WorkflowParameter

Contains a key/value pair that sets the named workflow parameter.

WorkflowParameterDetail

Defines a parameter that's used to provide configuration details for the workflow.

WorkflowState

A group of fields that describe the current status of workflow.

WorkflowStepExecution

Contains runtime details for an instance of a workflow that ran for the associated image build version.

WorkflowStepMetadata

Runtime details and status for the workflow step.

WorkflowSummary

Contains metadata about the workflow resource.

WorkflowVersion

Contains details about this version of the workflow.

Enums

BuildType

When writing a match expression against BuildType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComponentFormat

When writing a match expression against ComponentFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComponentStatus

When writing a match expression against ComponentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ComponentType

When writing a match expression against ComponentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContainerRepositoryService

When writing a match expression against ContainerRepositoryService, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContainerType

When writing a match expression against ContainerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DiskImageFormat

When writing a match expression against DiskImageFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EbsVolumeType

When writing a match expression against EbsVolumeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ImageScanStatus

When writing a match expression against ImageScanStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ImageSource

When writing a match expression against ImageSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ImageStatus

When writing a match expression against ImageStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ImageType

When writing a match expression against ImageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecycleExecutionResourceActionName

When writing a match expression against LifecycleExecutionResourceActionName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecycleExecutionResourceStatus

When writing a match expression against LifecycleExecutionResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecycleExecutionStatus

When writing a match expression against LifecycleExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecyclePolicyDetailActionType

When writing a match expression against LifecyclePolicyDetailActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecyclePolicyDetailFilterType

When writing a match expression against LifecyclePolicyDetailFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecyclePolicyResourceType

When writing a match expression against LifecyclePolicyResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecyclePolicyStatus

When writing a match expression against LifecyclePolicyStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LifecyclePolicyTimeUnit

When writing a match expression against LifecyclePolicyTimeUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MarketplaceResourceType

When writing a match expression against MarketplaceResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OnWorkflowFailure

When writing a match expression against OnWorkflowFailure, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Ownership

When writing a match expression against Ownership, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PipelineExecutionStartCondition

When writing a match expression against PipelineExecutionStartCondition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PipelineStatus

When writing a match expression against PipelineStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Platform

When writing a match expression against Platform, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ProductCodeType

When writing a match expression against ProductCodeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceStatus

When writing a match expression against ResourceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SsmParameterDataType

When writing a match expression against SsmParameterDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TenancyType

When writing a match expression against TenancyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowExecutionStatus

When writing a match expression against WorkflowExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowStatus

When writing a match expression against WorkflowStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowStepActionType

When writing a match expression against WorkflowStepActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowStepExecutionRollbackStatus

When writing a match expression against WorkflowStepExecutionRollbackStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowStepExecutionStatus

When writing a match expression against WorkflowStepExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WorkflowType

When writing a match expression against WorkflowType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.