bug: EC2 DescribeInstances group filters miss the second security group on an ASG instance

[AndreKurait]

Additional version check — 2026-10-08

Still reproduced: the ASG instance contains both groups, but only the first group's ID/name matches. The bundled-Moto result remains separate from Docker-backed EC2 execution.

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 found the matching upstream Moto issue #10114, which is closed. This report concerns the still-affected LocalStack bundled distribution; I am not opening another Moto issue. The proposed #10115 and #10145 are closed and were not merged, so their status alone does not identify a verified fixed LocalStack release. I found no matching current LocalStack Discussion.

Current behavior

An instance launched from an Auto Scaling launch template has two security groups in its DescribeInstances response. Adding instance.group-id or instance.group-name for the first group finds the instance; the same filter for the second attached group returns no instances.

Filter added to the same ASG-tag filter	Expected count	Observed count
First group ID	1	1
Second group ID	1	0
First group name	1	1
Second group name	1	0

This minimal case was reproduced in process against the unmodified Moto distribution bundled in the LocalStack image, using moto.mock_aws(). It is not a Docker-backed EC2 guest launch test, and I have not established whether current standalone upstream Moto has the same defect.

Expected behavior

Each attached group should match the instance. Multiple values within a filter should retain OR semantics, and different filters should retain AND semantics.

Reference: DescribeInstances filters.

Could you confirm the LocalStack release carrying the correction for the linked upstream report? I am reporting the tested bundled moto-ext behavior, without claiming current standalone Moto remains affected.

Environment

• Tested on 2026-10-07, 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.

Fresh confirmation on 2026-10-08: the same four filter results reproduced on Linux ARM64 using the bundled moto.mock_aws() and boto3/botocore 1.43.51, in an isolated read-only container with networking disabled. The container was removed after the run. A separate socket-free endpoint attempt could not launch a Docker guest; it is not used as evidence for this model/filter result.

Steps to reproduce

Save the Python code below as ec2_security_group_filters.py, then run it against the bundled Python environment:

docker run --rm -i --entrypoint /opt/code/localstack/.venv/bin/python \
  localstack/localstack-pro:2026.7.5 - < ec2_security_group_filters.py

This process-local reproduction needs no running LocalStack edge, license token, application image, or Docker socket. Every synthetic resource exists only inside moto.mock_aws(), which discards that state on exit, including assertion failures.

This script also has an optional loopback endpoint mode; that mode requires a provider supporting its model-only placeholder AMI and is not the evidence for this report.

Complete standalone reproducer: ec2_security_group_filters.py

"""Minimal EC2/Auto Scaling filter regression; stock Moto or a local endpoint."""
import argparse
import importlib.metadata
import json
from contextlib import nullcontext
from urllib.parse import urlsplit

import boto3
from botocore.config import Config


def run(endpoint=None):
    options = {
        "region_name": "us-east-1",
        "aws_access_key_id": "test",
        "aws_secret_access_key": "test",
        "config": Config(proxies={}, retries={"max_attempts": 0}),
    }
    if endpoint:
        parsed = urlsplit(endpoint)
        if parsed.hostname not in {"localhost", "127.0.0.1", "::1"}:
            raise ValueError("This reproducer accepts only a loopback endpoint")
        options["endpoint_url"] = endpoint
    ec2 = boto3.client("ec2", **options)
    autoscaling = boto3.client("autoscaling", **options)
    vpc = subnet = template = None
    groups = []
    asg_name = None
    try:
        vpc = ec2.create_vpc(CidrBlock="10.254.0.0/16")["Vpc"]["VpcId"]
        subnet = ec2.create_subnet(VpcId=vpc, CidrBlock="10.254.0.0/24")["Subnet"]["SubnetId"]
        names = ["repro-first", "repro-second"]
        for name in names:
            groups.append(ec2.create_security_group(
                GroupName=name, Description="Filter reproducer", VpcId=vpc,
            )["GroupId"])
        template = ec2.create_launch_template(
            LaunchTemplateName="filter-" + vpc,
            LaunchTemplateData={
                "ImageId": "ami-12345678",
                "InstanceType": "t3.micro",
                "SecurityGroupIds": groups,
            },
        )["LaunchTemplate"]["LaunchTemplateId"]
        asg_name = "filter-" + vpc
        autoscaling.create_auto_scaling_group(
            AutoScalingGroupName=asg_name, MinSize=1, MaxSize=1, DesiredCapacity=1,
            VPCZoneIdentifier=subnet,
            LaunchTemplate={"LaunchTemplateId": template, "Version": "1"},
        )

        def instances(filters):
            return [
                instance for reservation in ec2.describe_instances(Filters=filters)["Reservations"]
                for instance in reservation["Instances"]
            ]

        base = [{"Name": "tag:aws:autoscaling:groupName", "Values": [asg_name]}]
        baseline = instances(base)
        assert len(baseline) == 1, baseline
        expected = [baseline[0]["InstanceId"]]
        assert {group["GroupId"] for group in baseline[0]["SecurityGroups"]} == set(groups)
        result = {"baseline": expected, "returned_groups": baseline[0]["SecurityGroups"], "filters": {}}
        for key, values in [("instance.group-id", groups), ("instance.group-name", names)]:
            for value in values:
                result["filters"][key + "=" + value] = sorted(
                    instance["InstanceId"]
                    for instance in instances(base + [{"Name": key, "Values": [value]}])
                )
        print(json.dumps(result, indent=2), flush=True)
        assert all(value == expected for value in result["filters"].values()), (
            "Each attached security group must match the same instance"
        )
    finally:
        if asg_name:
            autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg_name, ForceDelete=True)
        if template:
            ec2.delete_launch_template(LaunchTemplateId=template)
        for group in groups:
            ec2.delete_security_group(GroupId=group)
        if subnet:
            ec2.delete_subnet(SubnetId=subnet)
        if vpc:
            ec2.delete_vpc(VpcId=vpc)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--endpoint-url", help="Loopback LocalStack endpoint; otherwise use moto.mock_aws")
    arguments = parser.parse_args()
    versions = {}
    for package in ("moto", "moto-ext", "boto3", "botocore", "localstack-core"):
        try:
            versions[package] = importlib.metadata.version(package)
        except importlib.metadata.PackageNotFoundError:
            pass
    print(json.dumps({"versions": versions}), flush=True)
    if arguments.endpoint_url:
        scope = nullcontext()
    else:
        from moto import mock_aws
        scope = mock_aws()
    with scope:
        run(arguments.endpoint_url)

[EddEcho]

Hi @AndreKurait Thanks for the detailed report and reproducer. We were able to reproduce the issue on 2026.8.1 and on our latest dev build, and it's now with our engineering team for review. We'll update this thread once a fix is available so you can test it.