feature request: Support EC2 capacity reservation creation and available-capacity transfers

[AndreKurait]

Additional version check — 2026-10-08

Still blocked at the first CreateCapacityReservation call with the same unimplemented-action error. No reservation is created and the move branch is not reached, so no successful creation, move, or cancellation is claimed.

The comparison used an unmodified localstack/localstack-pro:2026.8.1 Linux ARM64 image,
repository digest sha256:4aef81c531684570d7b3cfd2805afa02194c929d52bbeedabb7d4874798b1572.
Vendor packages were localstack-core 2026.8.1, moto-ext 5.1.48, and bundled
boto3/botocore 1.43.78. HTTP probes used a separate boto3/botocore 1.43.101
client; the process-local security-group probe used the bundled interpreter.
The same scripts were used, with no custom extensions or provider source changes.
Owned test containers and the disposable network were removed.
This is a second specifically tested version, not a claim to have tested the latest release.

---

Existing report search

I searched the LocalStack issue tracker and current organization Discussions for this operation and failure. I did not find an existing report for this exact reproduction.

Current behavior

The unmodified LocalStack reproduction is blocked at the first CreateCapacityReservation call, which returns InternalFailure:

The create_capacity_reservation action has not been implemented

The intended public-API flow creates two active, targeted, unlimited reservations in the same account and Availability Zone, both with t3.micro, Linux/UNIX, and default tenancy. The source would have two unused instances of capacity and the destination one; it would then move one, leaving both records nonempty.

No reservation was created and no move call was reached in this unmodified run. I am not claiming an independently reproduced move failure on this baseline. The attached script includes the requested follow-on transfer and idempotence checks for when creation is supported. Its empty cleanup list means there were no created records; it does not prove cancellation support.

No instances are launched, and no application workload or Docker guest is needed. The disposable LocalStack parent and its network were removed afterward.

Expected behavior

Support creation of these compatible capacity-reservation records, then moving one available unit from source to destination: total and available counts should change from (2, 1) to (1, 2). Return the moved count and updated reservation records. Repeating the same client token should not transfer capacity twice. Finally, the caller should be able to cancel the records.

References: CreateCapacityReservation and MoveCapacityReservationInstances.

This minimal request concerns unused capacity only. It does not require moving running instances, splitting a reservation, or testing automatic cancellation after moving all source capacity. I have not run the reproducer on live AWS.

Environment

• Tested on 2026-10-08, Linux, using localstack/localstack-pro:2026.7.5.
• Repository digest: sha256:0d74e1d2d7ce13a3cb25fc64cf15eb225f1c95c762e56e057bc6a9ed0ed29306.
• Vendor-installed distributions: localstack-core 2026.7.5, moto-ext 5.1.46, moto.__version__ = 5.1.21.dev, boto3/botocore 1.43.51.
• Fresh disposable container, no application code, no custom extensions, no source patches.
• This is an affected-version report, not a claim that the latest LocalStack release or standalone Moto still has the defect.

This fresh Linux ARM64 run used a separate boto3/botocore 1.43.101 client and the unmodified pinned vendor image. The startup configuration matches the five ordinary API reproductions: DNS listener/default EC2-image downloads disabled, temporary state storage, no Docker socket or custom extension.

Steps to reproduce

Start a disposable instance on a free loopback port:

# LOCALSTACK_AUTH_TOKEN is read from your environment, never embedded in this report.
set -eu
container=$(docker run --rm -d \
  -p 127.0.0.1:4567:4566 -e LOCALSTACK_AUTH_TOKEN \
  -e DNS_ADDRESS=0 -e EC2_DOWNLOAD_DEFAULT_IMAGES=0 \
  --tmpfs /var/lib/localstack \
  localstack/localstack-pro:2026.7.5)
trap 'docker stop "$container" >/dev/null' EXIT
ready=false
for attempt in $(seq 1 60); do
  if curl --fail --silent http://127.0.0.1:4567/_localstack/health >/dev/null; then
    ready=true
    break
  fi
  sleep 1
done
"$ready"
python ec2_move_capacity.py --endpoint-url http://127.0.0.1:4567

Run the block in a disposable shell. Port 4567 must be free. The client needs boto3; it uses only dummy credentials and a loopback endpoint. It creates disposable resources and cleans them up in finally; the shell trap removes the container even when the script reports failure. A nonzero exit is expected while the reported discrepancy is present. No Docker socket mount or application services are required.

Complete standalone reproducer: ec2_move_capacity.py

"""Reproduce EC2 capacity transfer using disposable loopback records only."""
import argparse
import json
from urllib.parse import urlsplit
import uuid

import boto3
from botocore.config import Config
from botocore.exceptions import ClientError


def run(endpoint):
    url = urlsplit(endpoint)
    if (url.scheme != "http" or url.hostname not in {"127.0.0.1", "localhost", "::1"}
            or url.username or url.password or url.query or url.fragment
            or url.path not in {"", "/"}):
        raise ValueError("Use an explicit loopback HTTP LocalStack endpoint")
    ec2 = boto3.client(
        "ec2", endpoint_url=endpoint, region_name="us-east-1",
        aws_access_key_id="test", aws_secret_access_key="test",
        config=Config(proxies={}, retries={"max_attempts": 0},
                      connect_timeout=3, read_timeout=15),
    )
    ids, report = [], {}

    def describe(identifier):
        row = ec2.describe_capacity_reservations(
            CapacityReservationIds=[identifier])["CapacityReservations"][0]
        return {key: row.get(key) for key in (
            "CapacityReservationId", "State", "InstanceType", "InstancePlatform",
            "AvailabilityZone", "Tenancy", "InstanceMatchCriteria",
            "TotalInstanceCount", "AvailableInstanceCount",
        )}

    try:
        for count in (2, 1):
            result = ec2.create_capacity_reservation(
                InstanceType="t3.micro", InstancePlatform="Linux/UNIX",
                AvailabilityZone="us-east-1a", Tenancy="default",
                InstanceMatchCriteria="targeted", EndDateType="unlimited",
                InstanceCount=count,
            )
            ids.append(result["CapacityReservation"]["CapacityReservationId"])
        report["before"] = [describe(identifier) for identifier in ids]
        assert [row["State"] for row in report["before"]] == ["active", "active"]
        assert [row["AvailableInstanceCount"] for row in report["before"]] == [2, 1]
        request = {
            "SourceCapacityReservationId": ids[0],
            "DestinationCapacityReservationId": ids[1],
            "InstanceCount": 1,
            "ClientToken": uuid.uuid4().hex,
        }
        try:
            result = ec2.move_capacity_reservation_instances(**request)
            report["move_http_status"] = result["ResponseMetadata"]["HTTPStatusCode"]
            report["moved_instance_count"] = result.get("InstanceCount")
            report["after"] = [describe(identifier) for identifier in ids]
            ec2.move_capacity_reservation_instances(**request)
            report["after_same_token_retry"] = [describe(identifier) for identifier in ids]
            report["passed"] = (
                report["move_http_status"] == 200
                and report["moved_instance_count"] == 1
                and [row["TotalInstanceCount"] for row in report["after"]] == [1, 2]
                and [row["AvailableInstanceCount"] for row in report["after"]] == [1, 2]
                and report["after_same_token_retry"] == report["after"]
            )
        except ClientError as error:
            report["move_http_status"] = error.response["ResponseMetadata"]["HTTPStatusCode"]
            report["move_error"] = error.response["Error"]
            report["after_rejected_move"] = [describe(identifier) for identifier in ids]
            report["passed"] = False
    finally:
        cleanup = []
        for identifier in ids:
            ec2.cancel_capacity_reservation(CapacityReservationId=identifier)
            cleanup.append(describe(identifier))
        report["cleanup"] = cleanup
        report["all_created_reservations_cancelled"] = all(
            row["State"] == "cancelled" for row in cleanup)
        print(json.dumps(report, indent=2, sort_keys=True), flush=True)
    assert report["passed"], "Available capacity transfer or token idempotence failed"
    assert report["all_created_reservations_cancelled"], "Reservation cleanup failed"


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--endpoint-url", default="http://127.0.0.1:4566")
    run(parser.parse_args().endpoint_url)

[Anze1508]

Hi @AndreKurait, thanks for the detailed report. I have logged the four operations as a feature request in EC2. I will inform you once they are implemented.