EBS Volume Builder

Type: amazon-ebsvolume

The amazon-ebsvolume Packer builder is able to create Amazon Elastic Block Store volumes which are prepopulated with filesystems or data.

This builder creates EBS volumes by launching an EC2 instance from a source AMI. One or more EBS volumes are attached to the running instance, allowing them to be provisioned into from the running machine. Once provisioning is complete the source machine is destroyed. The provisioned volumes are kept intact.

This is all done in your own AWS account. The builder will create temporary key pairs, security group rules, etc. that provide it temporary access to the instance while the image is being created.

The builder does not manage EBS Volumes. Once it creates volumes and stores it in your account, it is up to you to use, delete, etc. the volumes.

Configuration Reference

There are many configuration options available for the builder. In addition to the items listed here, you will want to look at the general configuration references for AMI, BlockDevices, Access, Run and Communicator configuration references, which are necessary for this build to succeed and can be found further down the page.

Optional:

• ena_support (boolean) - Enable enhanced networking (ENA but not SriovNetSupport) on HVM-compatible AMIs. If set, add ec2:ModifyInstanceAttribute to your AWS IAM policy. Note: you must make sure enhanced networking is enabled on your instance. See Amazon's documentation on enabling enhanced networking.

• sriov_support (bool) - Enable enhanced networking (SriovNetSupport but not ENA) on HVM-compatible AMIs. If true, add ec2:ModifyInstanceAttribute to your AWS IAM policy. Note: you must make sure enhanced networking is enabled on your instance. See Amazon's documentation on enabling enhanced networking. Default false.

• ebs_volumes (BlockDevices) - Add the block device mappings to the AMI. If you add instance store volumes or EBS volumes in addition to the root device volume, the created AMI will contain block device mapping information for those volumes. Amazon creates snapshots of the source instance's root volume and any other EBS volumes described here. When you launch an instance from this new AMI, the instance automatically launches with these additional volumes, and will restore them from snapshots taken from the source instance. See the BlockDevices documentation for fields.

• run_volume_tags (map[string]string) - Key/value pair tags to apply to the volumes of the instance that is launched to create EBS Volumes. These tags will not appear in the tags of the resulting EBS volumes unless they're duplicated under tags in the ebs_volumes setting. This is a template engine, see Build template data for more information.

  Note: The tags specified here will be temporarily applied to volumes specified in ebs_volumes - but only while the instance is being created. Packer will replace all tags on the volume with the tags configured in the ebs_volumes section as soon as the instance is reported as 'ready'.

• run_volume_tag ([]{key string, value string}) - Same as run_volume_tags but defined as a singular repeatable block containing a key and a value field. In HCL2 mode the dynamic_block will allow you to create those programatically.

Access Configuration

Required:

• access_key (string) - The access key used to communicate with AWS. [Learn how to set this] (/docs/builders/amazon#specifying-amazon-credentials). On EBS, this is not required if you are using use_vault_aws_engine for authentication instead.
• region (string) - The name of the region, such as us-east-1, in which to launch the EC2 instance to create the AMI. When chroot building, this value is guessed from environment.
• secret_key (string) - The secret key used to communicate with AWS. Learn how to set this. This is not required if you are using use_vault_aws_engine for authentication instead.

Optional:

• custom_endpoint_ec2 (string) - This option is useful if you use a cloud provider whose API is compatible with aws EC2. Specify another endpoint like this https://ec2.custom.endpoint.com.

• decode_authorization_messages (bool) - Enable automatic decoding of any encoded authorization (error) messages using the sts:DecodeAuthorizationMessage API. Note: requires that the effective user/role have permissions to sts:DecodeAuthorizationMessage on resource *. Default false.

• insecure_skip_tls_verify (bool) - This allows skipping TLS verification of the AWS EC2 endpoint. The default is false.

• max_retries (int) - This is the maximum number of times an API call is retried, in the case where requests are being throttled or experiencing transient failures. The delay between the subsequent API calls increases exponentially.

• mfa_code (string) - The MFA TOTP code. This should probably be a user variable since it changes all the time.

• profile (string) - The profile to use in the shared credentials file for AWS. See Amazon's documentation on specifying profiles for more details.

• skip_region_validation (bool) - Set to true if you want to skip validation of the ami_regions configuration option. Default false.

• skip_metadata_api_check (bool) - Skip Metadata Api Check

• token (string) - The access token to use. This is different from the access key and secret key. If you're not sure what this is, then you probably don't need it. This will also be read from the AWS_SESSION_TOKEN environmental variable.

• vault_aws_engine (VaultAWSEngineOptions) - Get credentials from Hashicorp Vault's aws secrets engine. You must already have created a role to use. For more information about generating credentials via the Vault engine, see the Vault docs. If you set this flag, you must also set the below options:

  • name (string) - Required. Specifies the name of the role to generate credentials against. This is part of the request URL.
  • engine_name (string) - The name of the aws secrets engine. In the Vault docs, this is normally referred to as "aws", and Packer will default to "aws" if engine_name is not set.
  • role_arn (string)- The ARN of the role to assume if credential_type on the Vault role is assumed_role. Must match one of the allowed role ARNs in the Vault role. Optional if the Vault role only allows a single AWS role ARN; required otherwise.
  • ttl (string) - Specifies the TTL for the use of the STS token. This is specified as a string with a duration suffix. Valid only when credential_type is assumed_role or federation_token. When not specified, the default_sts_ttl set for the role will be used. If that is also not set, then the default value of 3600s will be used. AWS places limits on the maximum TTL allowed. See the AWS documentation on the DurationSeconds parameter for AssumeRole (for assumed_role credential types) and GetFederationToken (for federation_token credential types) for more details.
  {
      "vault_aws_engine": {
          "name": "myrole",
          "role_arn": "myarn",
          "ttl": "3600s"
      }
  }
  

AMI Configuration

Optional:

• snapshot_groups (array of strings) - A list of groups that have access to create volumes from the snapshot(s). By default no groups have permission to create volumes from the snapshot(s). all will make the snapshot publicly accessible.

• snapshot_users (array of strings) - A list of account IDs that have access to create volumes from the snapshot(s). By default no additional users other than the user creating the AMI has permissions to create volumes from the backing snapshot(s).

Block Devices Configuration

Block devices can be nested in the ebs_volumes array.

These will be attached when booting a new instance from your AMI. Your options here may vary depending on the type of VM you use.

Example use case:

The following mapping will tell Packer to encrypt the root volume of the build instance at launch using a specific non-default kms key:

[{
        "device_name": "/dev/sda1",
        "encrypted": true,
        "kms_key_id": "1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d"
}]

Documentation for Block Devices Mappings can be found here: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html

Optional:

• delete_on_termination (bool) - Indicates whether the EBS volume is deleted on instance termination. Default false. NOTE: If this value is not explicitly set to true and volumes are not cleaned up by an alternative method, additional volumes will accumulate after every build.
• device_name (string) - The device name exposed to the instance (for example, /dev/sdh or xvdh). Required for every device in the block device mapping.
• encrypted (boolean) - Indicates whether or not to encrypt the volume. By default, Packer will keep the encryption setting to what it was in the source image. Setting false will result in an unencrypted device, and true will result in an encrypted one.
• iops (int64) - The number of I/O operations per second (IOPS) that the volume supports. See the documentation on IOPs for more information
• no_device (bool) - Suppresses the specified device included in the block device mapping of the AMI.
• snapshot_id (string) - The ID of the snapshot.
• virtual_name (string) - The virtual device name. See the documentation on Block Device Mapping for more information.
• volume_type (string) - The volume type. gp2 for General Purpose (SSD) volumes, io1 for Provisioned IOPS (SSD) volumes, st1 for Throughput Optimized HDD, sc1 for Cold HDD, and standard for Magnetic volumes.
• volume_size (int64) - The size of the volume, in GiB. Required if not specifying a snapshot_id.
• kms_key_id (string) - ID, alias or ARN of the KMS key to use for boot volume encryption. This only applies to the main region, other regions where the AMI will be copied will be encrypted by the default EBS KMS key. For valid formats see KmsKeyId in the AWS API docs - CopyImage This field is validated by Packer, when using an alias, you will have to prefix kms_key_id with alias/.

• tags (map[string]string) - Key/value pair tags to apply to the volume. These are retained after the builder completes. This is a template engine, see Build template data for more information.
• tag ([]{key string, value string}) - Same as tags but defined as a singular repeatable block containing a key and a value field. In HCL2 mode the dynamic_block will allow you to create those programatically.

Run Configuration

Required:

• instance_type (string) - The EC2 instance type to use while building the AMI, such as t2.small.
• source_ami (string) - The source AMI whose root volume will be copied and provisioned on the currently running instance. This must be an EBS-backed AMI with a root volume snapshot that you have access to. Note: this is not used when from_scratch is set to true.

Optional:

• associate_public_ip_address (bool) - If using a non-default VPC, public IP addresses are not provided by default. If this is true, your new instance will get a Public IP. default: false

• availability_zone (string) - Destination availability zone to launch instance in. Leave this empty to allow Amazon to auto-assign.

• block_duration_minutes (int64) - Requires spot_price to be set. The required duration for the Spot Instances (also known as Spot blocks). This value must be a multiple of 60 (60, 120, 180, 240, 300, or 360). You can't specify an Availability Zone group or a launch group if you specify a duration.

• disable_stop_instance (bool) - Packer normally stops the build instance after all provisioners have run. For Windows instances, it is sometimes desirable to run Sysprep which will stop the instance for you. If this is set to true, Packer will not stop the instance but will assume that you will send the stop signal yourself through your final provisioner. You can do this with a windows-shell provisioner. Note that Packer will still wait for the instance to be stopped, and failing to send the stop signal yourself, when you have set this flag to true, will cause a timeout. Example of a valid shutdown command:

  {
    "type": "windows-shell",
    "inline": ["\"c:\\Program Files\\Amazon\\Ec2ConfigService\\ec2config.exe\" -sysprep"]
  }
  

• ebs_optimized (bool) - Mark instance as EBS Optimized. Default false.

• enable_t2_unlimited (bool) - Enabling T2 Unlimited allows the source instance to burst additional CPU beyond its available CPU Credits for as long as the demand exists. This is in contrast to the standard configuration that only allows an instance to consume up to its available CPU Credits. See the AWS documentation for T2 Unlimited and the T2 Unlimited Pricing section of the Amazon EC2 On-Demand Pricing document for more information. By default this option is disabled and Packer will set up a T2 Standard instance instead.

  To use T2 Unlimited you must use a T2 instance type, e.g. t2.micro. Additionally, T2 Unlimited cannot be used in conjunction with Spot Instances, e.g. when the spot_price option has been configured. Attempting to do so will cause an error.

  Warning! Additional costs may be incurred by enabling T2 Unlimited - even for instances that would usually qualify for the AWS Free Tier.

• iam_instance_profile (string) - The name of an IAM instance profile to launch the EC2 instance with.

• skip_profile_validation (bool) - Whether or not to check if the IAM instance profile exists. Defaults to false

• temporary_iam_instance_profile_policy_document (*PolicyDocument) - Temporary IAM instance profile policy document If IamInstanceProfile is specified it will be used instead. Example:

  {
      "Version": "2012-10-17",
      "Statement": [
          {
              "Action": [
              "logs:*"
              ],
              "Effect": "Allow",
              "Resource": "*"
          }
      ]
  }
  

• shutdown_behavior (string) - Automatically terminate instances on shutdown in case Packer exits ungracefully. Possible values are stop and terminate. Defaults to stop.

• security_group_filter (SecurityGroupFilterOptions) - Filters used to populate the security_group_ids field. Example:

  {
    "security_group_filter": {
      "filters": {
        "tag:Class": "packer"
      }
    }
  }
  

  This selects the SG's with tag Class with the value packer.

  • filters (map of strings) - filters used to select a security_group_ids. Any filter described in the docs for DescribeSecurityGroups is valid.

  security_group_ids take precedence over this.

• run_tags (map[string]string) - Key/value pair tags to apply to the instance that is that is launched to create the EBS volumes. This is a template engine, see Build template data for more information.

• run_tag ([]{key string, value string}) - Same as run_tags but defined as a singular repeatable block containing a key and a value field. In HCL2 mode the dynamic_block will allow you to create those programatically.

• security_group_id (string) - The ID (not the name) of the security group to assign to the instance. By default this is not set and Packer will automatically create a new temporary security group to allow SSH access. Note that if this is specified, you must be sure the security group allows access to the ssh_port given below.

• security_group_ids ([]string) - A list of security groups as described above. Note that if this is specified, you must omit the security_group_id.

• source_ami_filter (AmiFilterOptions) - Filters used to populate the source_ami field. Example:

  {
    "source_ami_filter": {
      "filters": {
        "virtualization-type": "hvm",
        "name": "ubuntu/images/\*ubuntu-xenial-16.04-amd64-server-\*",
        "root-device-type": "ebs"
      },
      "owners": ["099720109477"],
      "most_recent": true
    }
  }
  

  This selects the most recent Ubuntu 16.04 HVM EBS AMI from Canonical. NOTE: This will fail unless exactly one AMI is returned. In the above example, most_recent will cause this to succeed by selecting the newest image.

  • filters (map of strings) - filters used to select a source_ami. NOTE: This will fail unless exactly one AMI is returned. Any filter described in the docs for DescribeImages is valid.

  • owners (array of strings) - Filters the images by their owner. You may specify one or more AWS account IDs, "self" (which will use the account whose credentials you are using to run Packer), or an AWS owner alias: for example, amazon, aws-marketplace, or microsoft. This option is required for security reasons.

  • most_recent (boolean) - Selects the newest created image when true. This is most useful for selecting a daily distro build.

    You may set this in place of source_ami or in conjunction with it. If you set this in conjunction with source_ami, the source_ami will be added to the filter. The provided source_ami must meet all of the filtering criteria provided in source_ami_filter; this pins the AMI returned by the filter, but will cause Packer to fail if the source_ami does not exist.

• spot_instance_types ([]string) - a list of acceptable instance types to run your build on. We will request a spot instance using the max price of spot_price and the allocation strategy of "lowest price". Your instance will be launched on an instance type of the lowest available price that you have in your list. This is used in place of instance_type. You may only set either spot_instance_types or instance_type, not both. This feature exists to help prevent situations where a Packer build fails because a particular availability zone does not have capacity for the specific instance_type requested in instance_type.

• spot_price (string) - With Spot Instances, you pay the Spot price that's in effect for the time period your instances are running. Spot Instance prices are set by Amazon EC2 and adjust gradually based on long-term trends in supply and demand for Spot Instance capacity.

  When this field is set, it represents the maximum hourly price you are willing to pay for a spot instance. If you do not set this value, it defaults to a maximum price equal to the on demand price of the instance. In the situation where the current Amazon-set spot price exceeds the value set in this field, Packer will not launch an instance and the build will error. In the situation where the Amazon-set spot price is less than the value set in this field, Packer will launch and you will pay the Amazon-set spot price, not this maximum value. For more information, see the Amazon docs on spot pricing.

• spot_price_auto_product (string) - Required if spot_price is set to auto. This tells Packer what sort of AMI you're launching to find the best spot price. This must be one of: Linux/UNIX, SUSE Linux, Windows, Linux/UNIX (Amazon VPC), SUSE Linux (Amazon VPC), Windows (Amazon VPC)

• spot_tags (map[string]string) - Requires spot_price to be set. Key/value pair tags to apply tags to the spot request that is issued.

• spot_tag ([]{key string, value string}) - Same as spot_tags but defined as a singular repeatable block containing a key and a value field. In HCL2 mode the dynamic_block will allow you to create those programatically.

• subnet_filter (SubnetFilterOptions) - Filters used to populate the subnet_id field. Example:

  {
    "subnet_filter": {
      "filters": {
        "tag:Class": "build"
      },
      "most_free": true,
      "random": false
    }
  }
  

  This selects the Subnet with tag Class with the value build, which has the most free IP addresses. NOTE: This will fail unless exactly one Subnet is returned. By using most_free or random one will be selected from those matching the filter.

  • filters (map of strings) - filters used to select a subnet_id. NOTE: This will fail unless exactly one Subnet is returned. Any filter described in the docs for DescribeSubnets is valid.

  • most_free (boolean) - The Subnet with the most free IPv4 addresses will be used if multiple Subnets matches the filter.

  • random (boolean) - A random Subnet will be used if multiple Subnets matches the filter. most_free have precendence over this.

    subnet_id take precedence over this.

• subnet_id (string) - If using VPC, the ID of the subnet, such as subnet-12345def, where Packer will launch the EC2 instance. This field is required if you are using an non-default VPC.

• temporary_key_pair_name (string) - The name of the temporary key pair to generate. By default, Packer generates a name that looks like packer_<UUID>, where <UUID> is a 36 character unique identifier.

• temporary_security_group_source_cidrs ([]string) - A list of IPv4 CIDR blocks to be authorized access to the instance, when packer is creating a temporary security group.

  The default is [0.0.0.0/0] (i.e., allow any IPv4 source). This is only used when security_group_id or security_group_ids is not specified.

• user_data (string) - User data to apply when launching the instance. Note that you need to be careful about escaping characters due to the templates being JSON. It is often more convenient to use user_data_file, instead. Packer will not automatically wait for a user script to finish before shutting down the instance this must be handled in a provisioner.

• user_data_file (string) - Path to a file that will be used for the user data when launching the instance.

• vpc_filter (VpcFilterOptions) - Filters used to populate the vpc_id field. Example:

  {
    "vpc_filter": {
      "filters": {
        "tag:Class": "build",
        "isDefault": "false",
        "cidr": "/24"
      }
    }
  }
  

  This selects the VPC with tag Class with the value build, which is not the default VPC, and have a IPv4 CIDR block of /24. NOTE: This will fail unless exactly one VPC is returned.

  • filters (map of strings) - filters used to select a vpc_id. NOTE: This will fail unless exactly one VPC is returned. Any filter described in the docs for DescribeVpcs is valid.

  vpc_id take precedence over this.

• vpc_id (string) - If launching into a VPC subnet, Packer needs the VPC ID in order to create a temporary security group within the VPC. Requires subnet_id to be set. If this field is left blank, Packer will try to get the VPC ID from the subnet_id.

• windows_password_timeout (duration string | ex: "1h5m2s") - The timeout for waiting for a Windows password for Windows instances. Defaults to 20 minutes. Example value: 10m

• ssh_interface (string) - One of public_ip, private_ip, public_dns, or private_dns. If set, either the public IP address, private IP address, public DNS name or private DNS name will be used as the host for SSH. The default behaviour if inside a VPC is to use the public IP address if available, otherwise the private IP address will be used. If not in a VPC the public DNS name will be used. Also works for WinRM.

  Where Packer is configured for an outbound proxy but WinRM traffic should be direct, ssh_interface must be set to private_dns and <region>.compute.internal included in the NO_PROXY environment variable.

Communicator Configuration

Optional:

• communicator (string) - Packer currently supports three kinds of communicators:

  • none - No communicator will be used. If this is set, most provisioners also can't be used.

  • ssh - An SSH connection will be established to the machine. This is usually the default.

  • winrm - A WinRM connection will be established.

  In addition to the above, some builders have custom communicators they can use. For example, the Docker builder has a "docker" communicator that uses docker exec and docker cp to execute scripts and copy files.

• pause_before_connecting (duration string | ex: "1h5m2s") - We recommend that you enable SSH or WinRM as the very last step in your guest's bootstrap script, but sometimes you may have a race condition where you need Packer to wait before attempting to connect to your guest.

  If you end up in this situation, you can use the template option pause_before_connecting. By default, there is no pause. For example:

  {
    "communicator": "ssh",
    "ssh_username": "myuser",
    "pause_before_connecting": "10m"
  }
  

  In this example, Packer will check whether it can connect, as normal. But once a connection attempt is successful, it will disconnect and then wait 10 minutes before connecting to the guest and beginning provisioning.

• ssh_host (string) - The address to SSH to. This usually is automatically configured by the builder.
• ssh_port (int) - The port to connect to SSH. This defaults to 22.
• ssh_username (string) - The username to connect to SSH with. Required if using SSH.
• ssh_password (string) - A plaintext password to use to authenticate with SSH.
• ssh_keypair_name (string) - If specified, this is the key that will be used for SSH with the machine. The key must match a key pair name loaded up into the remote. By default, this is blank, and Packer will generate a temporary keypair unless ssh_password is used. ssh_private_key_file or ssh_agent_auth must be specified when ssh_keypair_name is utilized.
• temporary_key_pair_name (string) - The name of the temporary key pair to generate. By default, Packer generates a name that looks like packer_<UUID>, where <UUID> is a 36 character unique identifier.
• ssh_clear_authorized_keys (bool) - If true, Packer will attempt to remove its temporary key from ~/.ssh/authorized_keys and /root/.ssh/authorized_keys. This is a mostly cosmetic option, since Packer will delete the temporary private key from the host system regardless of whether this is set to true (unless the user has set the -debug flag). Defaults to "false"; currently only works on guests with sed installed.
• ssh_private_key_file (string) - Path to a PEM encoded private key file to use to authenticate with SSH. The ~ can be used in path and will be expanded to the home directory of current user.
• ssh_pty (bool) - If true, a PTY will be requested for the SSH connection. This defaults to false.
• ssh_timeout (duration string | ex: "1h5m2s") - The time to wait for SSH to become available. Packer uses this to determine when the machine has booted so this is usually quite long. Example value: 10m.
• ssh_agent_auth (bool) - If true, the local SSH agent will be used to authenticate connections to the source instance. No temporary keypair will be created, and the values of ssh_password and ssh_private_key_file will be ignored. The environment variable SSH_AUTH_SOCK must be set for this option to work properly.
• ssh_disable_agent_forwarding (bool) - If true, SSH agent forwarding will be disabled. Defaults to false.
• ssh_handshake_attempts (int) - The number of handshakes to attempt with SSH once it can connect. This defaults to 10.
• ssh_bastion_host (string) - A bastion host to use for the actual SSH connection.
• ssh_bastion_port (int) - The port of the bastion host. Defaults to 22.
• ssh_bastion_agent_auth (bool) - If true, the local SSH agent will be used to authenticate with the bastion host. Defaults to false.
• ssh_bastion_username (string) - The username to connect to the bastion host.
• ssh_bastion_password (string) - The password to use to authenticate with the bastion host.
• ssh_bastion_interactive (bool) - If true, the keyboard-interactive used to authenticate with bastion host.
• ssh_bastion_private_key_file (string) - Path to a PEM encoded private key file to use to authenticate with the bastion host. The ~ can be used in path and will be expanded to the home directory of current user.
• ssh_file_transfer_method (string) - scp or sftp - How to transfer files, Secure copy (default) or SSH File Transfer Protocol.
• ssh_proxy_host (string) - A SOCKS proxy host to use for SSH connection
• ssh_proxy_port (int) - A port of the SOCKS proxy. Defaults to 1080.
• ssh_proxy_username (string) - The optional username to authenticate with the proxy server.
• ssh_proxy_password (string) - The optional password to use to authenticate with the proxy server.
• ssh_keep_alive_interval (duration string | ex: "1h5m2s") - How often to send "keep alive" messages to the server. Set to a negative value (-1s) to disable. Example value: 10s. Defaults to 5s.
• ssh_read_write_timeout (duration string | ex: "1h5m2s") - The amount of time to wait for a remote command to end. This might be useful if, for example, packer hangs on a connection after a reboot. Example: 5m. Disabled by default.
• ssh_remote_tunnels ([]string) -
• ssh_local_tunnels ([]string) -
• ssh_public_key ([]byte) - SSH Internals
• ssh_private_key ([]byte) - SSH Private Key

Basic Example

{
  "type": "amazon-ebsvolume",
  "secret_key": "YOUR SECRET KEY HERE",
  "access_key": "YOUR KEY HERE",
  "region": "us-east-1",
  "ssh_username": "ubuntu",
  "instance_type": "t2.medium",
  "source_ami": "ami-40d28157",
  "ebs_volumes": [
    {
      "volume_type": "gp2",
      "device_name": "/dev/xvdf",
      "delete_on_termination": false,
      "tags": {
        "zpool": "data",
        "Name": "Data1"
      },
      "volume_size": 10
    },
    {
      "volume_type": "gp2",
      "device_name": "/dev/xvdg",
      "tags": {
        "zpool": "data",
        "Name": "Data2"
      },
      "delete_on_termination": false,
      "volume_size": 10
    },
    {
      "volume_size": 10,
      "tags": {
        "Name": "Data3",
        "zpool": "data"
      },
      "delete_on_termination": false,
      "device_name": "/dev/xvdh",
      "volume_type": "gp2"
    }
  ]
}

Further information on locating AMI IDs and their relationship to instance types and regions can be found in the AWS EC2 Documentation for Linux or for Windows.

Accessing the Instance to Debug

If you need to access the instance to debug for some reason, run the builder with the -debug flag. In debug mode, the Amazon builder will save the private key in the current directory and will output the DNS or IP information as well. You can use this information to access the instance as it is running.

Build template data

In configuration directives marked as a template engine above, the following variables are available:

• BuildRegion - The region (for example eu-central-1) where Packer is building the AMI.
• SourceAMI - The source AMI ID (for example ami-a2412fcd) used to build the AMI.
• SourceAMIName - The source AMI Name (for example ubuntu/images/ebs-ssd/ubuntu-xenial-16.04-amd64-server-20180306) used to build the AMI.
• SourceAMIOwner - The source AMI owner ID.
• SourceAMIOwnerName - The source AMI owner alias/name (for example amazon).
• SourceAMITags - The source AMI Tags, as a map[string]string object.

Build function template engine variables

For the build function of template engine, the following variables are available:

• SourceAMIName - The source AMI Name (for example ubuntu/images/ebs-ssd/ubuntu-xenial-16.04-amd64-server-20180306) used to build the AMI.

Which SSH Options to use:

This chart breaks down what Packer does if you set any of the below SSH options: