imagebuilder / Client / create_container_recipe

create_container_recipe#

imagebuilder.Client.create_container_recipe(**kwargs)#

Creates a new container recipe. Container recipes define how images are configured, tested, and assessed.

Request Syntax

response = client.create_container_recipe(
    containerType='DOCKER',
    name='string',
    description='string',
    semanticVersion='string',
    components=[
        {
            'componentArn': 'string',
            'parameters': [
                {
                    'name': 'string',
                    'value': [
                        'string',
                    ]
                },
            ]
        },
    ],
    instanceConfiguration={
        'image': 'string',
        'blockDeviceMappings': [
            {
                'deviceName': 'string',
                'ebs': {
                    'encrypted': True|False,
                    'deleteOnTermination': True|False,
                    'iops': 123,
                    'kmsKeyId': 'string',
                    'snapshotId': 'string',
                    'volumeSize': 123,
                    'volumeType': 'standard'|'io1'|'io2'|'gp2'|'gp3'|'sc1'|'st1',
                    'throughput': 123
                },
                'virtualName': 'string',
                'noDevice': 'string'
            },
        ]
    },
    dockerfileTemplateData='string',
    dockerfileTemplateUri='string',
    platformOverride='Windows'|'Linux',
    imageOsVersionOverride='string',
    parentImage='string',
    tags={
        'string': 'string'
    },
    workingDirectory='string',
    targetRepository={
        'service': 'ECR',
        'repositoryName': 'string'
    },
    kmsKeyId='string',
    clientToken='string'
)

Parameters:

containerType (string) –
[REQUIRED]

The type of container to create.
name (string) –
[REQUIRED]

The name of the container recipe.
description (string) – The description of the container recipe.
semanticVersion (string) –
[REQUIRED]

The semantic version of the container recipe. This version follows the semantic version syntax.

Note
The semantic version has four nodes: <major>.<minor>.<patch>/<build>. You can assign values for the first three, and can filter on all of them.

Assignment: For the first three nodes you can assign any positive integer value, including zero, with an upper limit of 2^30-1, or 1073741823 for each node. Image Builder automatically assigns the build number to the fourth node.

Patterns: You can use any numeric pattern that adheres to the assignment requirements for the nodes that you can assign. For example, you might choose a software version pattern, such as 1.0.0, or a date, such as 2021.01.01.
components (list) –
[REQUIRED]

Components for build and test that are included in the container recipe. Recipes require a minimum of one build component, and can have a maximum of 20 build and test components in any combination.
- (dict) –
  
  Configuration details of the component.
  - componentArn (string) – [REQUIRED]
    
    The Amazon Resource Name (ARN) of the component.
  - parameters (list) –
    
    A group of parameter settings that Image Builder uses to configure the component for a specific recipe.
    - (dict) –
      
      Contains a key/value pair that sets the named component parameter.
      - name (string) – [REQUIRED]
        
        The name of the component parameter to set.
      - value (list) – [REQUIRED]
        
        Sets the value for the named component parameter.
        
        (string) –
instanceConfiguration (dict) –
A group of options that can be used to configure an instance for building and testing container images.
- image (string) –
  
  The AMI ID to use as the base image for a container build and test instance. If not specified, Image Builder will use the appropriate ECS-optimized AMI as a base image.
- blockDeviceMappings (list) –
  
  Defines the block devices to attach for building an instance from this Image Builder AMI.
  - (dict) –
    
    Defines block device mappings for the instance used to configure your image.
    - deviceName (string) –
      
      The device to which these mappings apply.
    - ebs (dict) –
      
      Use to manage Amazon EBS-specific configuration for this mapping.
      - encrypted (boolean) –
        
        Use to configure device encryption.
      - deleteOnTermination (boolean) –
        
        Use to configure delete on termination of the associated device.
      - iops (integer) –
        
        Use to configure device IOPS.
      - kmsKeyId (string) –
        
        Use to configure the KMS key to use when encrypting the device.
      - snapshotId (string) –
        
        The snapshot that defines the device contents.
      - volumeSize (integer) –
        
        Use to override the device’s volume size.
      - volumeType (string) –
        
        Use to override the device’s volume type.
      - throughput (integer) –
        
        For GP3 volumes only – The throughput in MiB/s that the volume supports.
    - virtualName (string) –
      
      Use to manage instance ephemeral devices.
    - noDevice (string) –
      
      Use to remove a mapping from the base image.
dockerfileTemplateData (string) – The Dockerfile template used to build your image as an inline data blob.
dockerfileTemplateUri (string) – The Amazon S3 URI for the Dockerfile that will be used to build your container image.
platformOverride (string) – Specifies the operating system platform when you use a custom base image.
imageOsVersionOverride (string) – Specifies the operating system version for the base image.
parentImage (string) –
[REQUIRED]

The base image for the container recipe.
tags (dict) –
Tags that are attached to the container recipe.
- (string) –
  - (string) –
workingDirectory (string) – The working directory for use during build and test workflows.
targetRepository (dict) –
[REQUIRED]

The destination repository for the container image.
- service (string) – [REQUIRED]
  
  Specifies the service in which this image was registered.
- repositoryName (string) – [REQUIRED]
  
  The name of the container repository where the output container image is stored. This name is prefixed by the repository location.
kmsKeyId (string) – Identifies which KMS key is used to encrypt the container image.
clientToken (string) –
[REQUIRED]

The client token used to make this request idempotent.

This field is autopopulated if not provided.

Return type:

dict

Returns:

Response Syntax

{
    'requestId': 'string',
    'clientToken': 'string',
    'containerRecipeArn': 'string'
}

Response Structure

(dict) –
- requestId (string) –
  
  The request ID that uniquely identifies this request.
- clientToken (string) –
  
  The client token used to make this request idempotent.
- containerRecipeArn (string) –
  
  Returns the Amazon Resource Name (ARN) of the container recipe that the request created.

Exceptions

imagebuilder.Client.exceptions.ServiceException
imagebuilder.Client.exceptions.ClientException
imagebuilder.Client.exceptions.ServiceUnavailableException
imagebuilder.Client.exceptions.InvalidRequestException
imagebuilder.Client.exceptions.IdempotentParameterMismatchException
imagebuilder.Client.exceptions.ForbiddenException
imagebuilder.Client.exceptions.CallRateLimitExceededException
imagebuilder.Client.exceptions.InvalidVersionNumberException
imagebuilder.Client.exceptions.ResourceInUseException
imagebuilder.Client.exceptions.ResourceAlreadyExistsException
imagebuilder.Client.exceptions.ServiceQuotaExceededException