Skip to content
Packer AWS AMI Builder

Packer AWS AMI BuilderSkill

Released
4 views
MPL-2.0
Repository Docs

Summary

HashiCorp's official Packer skill for building Amazon Machine Images with the amazon-ebs builder, covering template structure, plugin pinning and the cost and timing caveats.

Features

  • Complete amazon-ebs builder template in HCL with required_plugins pinning
  • Parameterised region and source AMI selection
  • Warns that builds incur EC2, EBS and data-transfer costs and take 10-30 minutes
  • Links directly to the canonical Amazon EBS builder documentation
  • Part of HashiCorp's four-skill Packer plugin alongside Azure, Windows and registry-push skills

Install This Skill

Add this skill to your favorite AI agent in a few steps.

Any AI agent

This skill is plain instructions — it works with any assistant that accepts custom instructions or system prompts.

  1. Copy the skill content with the button below.
  2. Paste it into your agent's instruction file or system prompt (for example AGENTS.md, .cursorrules, or a custom instructions field).
  3. Ask the agent to apply the skill whenever the task matches.

Skill Content

Markdown Content

Copy this content and use it with your preferred AI agent

---
name: aws-ami-builder
description: Build Amazon Machine Images (AMIs) with Packer using the amazon-ebs builder. Use when creating custom AMIs for EC2 instances.
metadata:
  lifecycle-status: active
---

# AWS AMI Builder

Build Amazon Machine Images (AMIs) using Packer's `amazon-ebs` builder.

**Reference:** [Amazon EBS Builder](https://developer.hashicorp.com/packer/integrations/hashicorp/amazon/latest/components/builder/ebs)

> **Note:** Building AMIs incurs AWS costs (EC2 instances, EBS storage, data transfer). Builds typically take 10-30 minutes depending on provisioning complexity.

## Basic AMI Template

```hcl
packer {
  required_plugins {
    amazon = {
      source  = "github.com/hashicorp/amazon"
      version = "~> 1.3"
    }
  }
}

variable "region" {
  type    = string
  default = "us-west-2"
}

locals {
  timestamp = regex_replace(timestamp(), "[- TZ:]", "")
}

source "amazon-ebs" "ubuntu" {
  region        = var.region
  instance_type = "t3.micro"

  source_ami_filter {
    filters = {
      name                = "ubuntu/images/*ubuntu-jammy-22.04-amd64-server-*"
      root-device-type    = "ebs"
      virtualization-type = "hvm"
    }
    most_recent = true
    owners      = ["099720109477"] # Canonical
  }

  ssh_username = "ubuntu"
  ami_name     = "my-app-${local.timestamp}"

  tags = {
    Name      = "my-app"
    BuildDate = local.timestamp
  }
}

build {
  sources = ["source.amazon-ebs.ubuntu"]

  provisioner "shell" {
    inline = [
      "sudo apt-get update",
      "sudo apt-get upgrade -y",
    ]
  }
}
```

## Common Source AMI Filters

### Ubuntu 22.04 LTS
```hcl
source_ami_filter {
  filters = {
    name                = "ubuntu/images/*ubuntu-jammy-22.04-amd64-server-*"
    root-device-type    = "ebs"
    virtualization-type = "hvm"
  }
  most_recent = true
  owners      = ["099720109477"] # Canonical
}
```

### Amazon Linux 2023
```hcl
source_ami_filter {
  filters = {
    name                = "al2023-ami-*-x86_64"
    root-device-type    = "ebs"
    virtualization-type = "hvm"
  }
  most_recent = true
  owners      = ["amazon"]
}
```

## Multi-Region AMI

```hcl
source "amazon-ebs" "ubuntu" {
  region        = "us-west-2"
  instance_type = "t3.micro"

  source_ami_filter {
    filters = {
      name = "ubuntu/images/*ubuntu-jammy-22.04-amd64-server-*"
    }
    most_recent = true
    owners      = ["099720109477"]
  }

  ssh_username = "ubuntu"
  ami_name     = "my-app-${local.timestamp}"

  # Copy to additional regions
  ami_regions = ["us-east-1", "us-east-2", "eu-west-1"]
}
```

## Authentication

Packer uses AWS credential resolution:

1. Environment variables: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`
2. AWS credentials file: `~/.aws/credentials`
3. IAM instance profile (when running on EC2)

```bash
export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_REGION="us-west-2"

packer build .
```

## Build Commands

```bash
# Initialize plugins
packer init .

# Validate template
packer validate .

# Build AMI
packer build .

# Build with variables
packer build -var "region=us-east-1" .
```

## Common Issues

**SSH Timeout**
- Ensure security group allows SSH (port 22)
- Verify subnet has internet access

**AMI Already Exists**
- AMI names must be unique
- Use timestamp in name: `my-app-${local.timestamp}`

**Volume Size Too Small**
- Check source AMI's volume size
- Set `launch_block_device_mappings.volume_size` accordingly

## References

- [Amazon EBS Builder](https://developer.hashicorp.com/packer/integrations/hashicorp/amazon/latest/components/builder/ebs)
- [AWS AMI Documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html)

Usage Instructions

Learn how to use this skill with different AI agents.

Claude Desktop

claude plugin marketplace add hashicorp/agent-skills then claude plugin install packer@hashicorp to get all four Packer skills.

Example Usage

Write me a Packer template that bakes an Ubuntu 24.04 AMI in eu-west-1 with our Datadog agent pre-installed.

Description

aws-ami-builder is one of four Packer skills in HashiCorp's official agent-skills repository, which also publishes sixteen Terraform skills. It teaches an agent to write and run Packer templates that produce Amazon Machine Images using the amazon-ebs builder — the standard path for baking golden images for EC2.

The skill leads with a working HCL template rather than prose: a packer block pinning the github.com/hashicorp/amazon plugin to ~> 1.3, a parameterised region variable, source AMI selection, and the build and provisioner structure around it. Pinning the plugin version in required_plugins is the detail that matters most in practice, because an unpinned Packer build is not reproducible across machines or CI runners.

It is also honest about the operational cost, which most tutorials skip: building AMIs incurs real AWS charges — EC2 instance time, EBS storage and data transfer — and a build typically takes 10 to 30 minutes depending on how much provisioning happens inside the image. That is the difference between an agent that offers to "just try a build" and one that tells you what the attempt costs first.

The skill points at HashiCorp's canonical Amazon EBS Builder documentation rather than restating it, so it stays current as the builder evolves. Its sibling Packer skills cover Azure image building, Windows image builds, and pushing finished artifacts to a registry.

Installation. npx skills add hashicorp/agent-skills/plugins/packer/skills/aws-ami-builder for this skill alone, or claude plugin marketplace add hashicorp/agent-skills followed by claude plugin install packer@hashicorp for the whole Packer bundle. Licensed MPL-2.0.

Best for platform teams maintaining golden AMIs and anyone whose CI pipeline bakes images. It assumes AWS credentials and Packer are already installed, and it deliberately does not cover Terraform provisioning of the resulting AMI — that is what the Terraform skills in the same repository are for.

Covered in the Weekly

Related Skills

Diagnoses wrong gradients in differentiable NVIDIA Warp programs by measuring first — comparing autodiff against finite differences on a shrunk reproduction before proposing any fix.

3 views
New

Google's official skill for the gws CLI — drive Gmail, Drive, Calendar, Sheets, Docs, Chat and Admin APIs from an agent, with Model Armor screening.

4 views 1 copies
New

Netlify's official skill for zero-config managed Postgres — querying from Functions, Drizzle setup, migrations and per-preview database branches.

3 views

Official WordPress skill for Gutenberg block work: block.json, attributes and serialization, dynamic rendering, and the deprecation path that keeps existing content valid.

3 views 1 copies
Browse all skills →