Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
release v1.4.18 (#1394)
Nahuel Nucera6afcdf90be1f
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 279a3c95..667a8dab 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,13 +7,28 @@ Versioning follows [Semantic Versioning](https://semver.org/).## [Unreleased]-### Fixed-- **Request headers — a field repeated across lines is no longer reduced to its last line** — the ASGI header dict was built with plain assignment, so when a client sent the same field twice the earlier line was discarded. The AWS SDK for Java v2 uploads exactly that way, emitting `Content-Encoding: gzip` and `Content-Encoding: aws-chunked` as separate lines: MiniStack saw only `aws-chunked`, stripped it as the chunk-framing marker it is, and stored the object with no content encoding at all — silently losing `gzip` for every Java SDK v2 caller, S3Proxy's `aws-s3` backend among them. Repeated field lines now combine into one comma-joined value as RFC 9110 5.2 requires (`Cookie` rejoins with `"; "` per RFC 9113 8.2.3), so `aws-chunked` is stripped from the joined list and the caller's encoding survives. Sending the header once, in either order, was already correct and is unchanged.+## [1.4.18] — 2026-08-16+### Added-- **SES v2 — email template CRUD and `SendEmail` with `Content.Template`** — the v2 `SendEmail` handler read only `Content.Simple` and `Content.Raw`, so a templated send was accepted with a `200` and a `MessageId` while the template was silently dropped, delivering an empty subject and body. `Content.Template` is now rendered through the same `{{placeholder}}` substitution v1 uses, from a stored template or from `TemplateContent` supplied inline, and a named template that doesn't exist fails the send with `NotFoundException` instead of delivering an empty email. `CreateEmailTemplate`, `GetEmailTemplate`, `UpdateEmailTemplate`, `DeleteEmailTemplate`, and `ListEmailTemplates` are served at `/v2/email/templates[/{TemplateName}]` over the shared v1 store, so a template created with `aws ses create-template` is sendable through `aws sesv2 send-email`. `ListEmailTemplates` paginates: `PageSize` accepts the documented 1–100 and defaults to 10, with an opaque `NextToken` returned only while further templates remain.+- **SES v2 — email template CRUD and `SendEmail` with `Content.Template`** — the v2 `SendEmail` handler read only `Content.Simple` and `Content.Raw`, so a templated send was accepted with a `200` and a `MessageId` while the template was silently dropped, delivering an empty subject and body. `Content.Template` is now rendered through the same `{{placeholder}}` substitution v1 uses, from a stored template or from `TemplateContent` supplied inline, and a named template that doesn't exist fails the send with `NotFoundException` instead of delivering an empty email. `CreateEmailTemplate`, `GetEmailTemplate`, `UpdateEmailTemplate`, `DeleteEmailTemplate`, and `ListEmailTemplates` are served at `/v2/email/templates[/{TemplateName}]` over the shared v1 store, so a template created with `aws ses create-template` is sendable through `aws sesv2 send-email`. `ListEmailTemplates` paginates: `PageSize` accepts the documented 1–100 and defaults to 10, with an opaque `NextToken` returned only while further templates remain. Contributed by @mikolajk0wal.+- **IoT Core — fleet indexing** — `SearchIndex` (`POST /indices/search`) and the indexing-configuration operations (`UpdateIndexingConfiguration` / `GetIndexingConfiguration` / `DescribeIndex` / `ListIndices`) were unimplemented. The `AWS_Things` index is `OFF` by default; enabling it with `UpdateIndexingConfiguration` (as Terraform's `aws_iot_indexing_configuration` does) lets `SearchIndex` answer `AND`-separated `thingName` / `thingTypeName` / `thingGroupNames` / `attributes.*` / `shadow.desired|reported.*` terms — `*`/`?` wildcards, numeric shadow compare, `maxResults`/`nextToken` paging with the documented ceiling of 100 — queried directly against the live registry and classic shadows. Searching while `thingIndexingMode` is `OFF` returns `ResourceNotFoundException`, and `REGISTRY` vs `REGISTRY_AND_SHADOW` gates the shadow terms. Contributed by @iot-rocket.+- **IoT Core — `RegisterCertificateWithoutCA` and the deprecated principal-policy operations** — `RegisterCertificateWithoutCA` (`POST /certificate/register-no-ca`) shares the `RegisterCertificate` store, returning `ResourceAlreadyExistsException` with `resourceId`/`resourceArn` on a duplicate PEM. The deprecated `AttachPrincipalPolicy` / `DetachPrincipalPolicy` / `ListPrincipalPolicies` / `ListPolicyPrincipals` map onto the modern policy-target store, with the principal in the `x-amzn-iot-principal` header and the policy name in `x-amzn-iot-policy`. Contributed by @iot-rocket.+- **RDS — Aurora MySQL compatibility objects** — Aurora MySQL provisioning that creates users with `AWSAuthenticationPlugin` and calls RDS-specific stored procedures failed against upstream MySQL images. MiniStack now builds ABI-matched MySQL 8.0/8.4 `AWSAuthenticationPlugin` artifacts (amd64/arm64), installs a reject-all compatibility plugin without changing password authentication, and adds the Aurora/RDS procedures, configuration surface, and predefined S3 roles those workflows expect. The path is automatic for supported MySQL images and can be disabled with `MINISTACK_MYSQL_IAM_AUTH=off`; the plugin deliberately rejects authentication, so the existing non-enforcement stance is unchanged. Contributed by @Areson.### Fixed-- **SES v2 — error responses carry `x-amzn-errortype`** — restJson1 resolves the error shape from that header, so without it SDKs surfaced a bare HTTP status instead of the modelled exception: boto3 reported `An error occurred (404)` rather than `NotFoundException`, and typed handling never matched on any SESv2 operation. The 1.3.24 sweep that added the header centrally in `error_response_json` reached `ses` but not `ses_v2`, which builds its error bodies itself; it is now set on all of them.+- **Request headers — a field repeated across lines is no longer reduced to its last line** — the ASGI header dict was built with plain assignment, so when a client sent the same field twice the earlier line was discarded. The AWS SDK for Java v2 uploads exactly that way, emitting `Content-Encoding: gzip` and `Content-Encoding: aws-chunked` as separate lines: MiniStack saw only `aws-chunked`, stripped it as the chunk-framing marker it is, and stored the object with no content encoding at all — silently losing `gzip` for every Java SDK v2 caller, S3Proxy's `aws-s3` backend among them. Repeated field lines now combine into one comma-joined value as RFC 9110 5.2 requires (`Cookie` rejoins with `"; "` per RFC 9113 8.2.3), so `aws-chunked` is stripped from the joined list and the caller's encoding survives. Sending the header once, in either order, was already correct and is unchanged. Contributed by @gaul.+- **SES v2 — error responses carry `x-amzn-errortype`** — restJson1 resolves the error shape from that header, so without it SDKs surfaced a bare HTTP status instead of the modelled exception: boto3 reported `An error occurred (404)` rather than `NotFoundException`, and typed handling never matched on any SESv2 operation. The 1.3.24 sweep that added the header centrally in `error_response_json` reached `ses` but not `ses_v2`, which builds its error bodies itself; it is now set on all of them. Contributed by @mikolajk0wal.+- **API Gateway — non-proxy (`AWS`) Lambda integrations return the handler's raw output** — `AWS` and `AWS_PROXY` shared one response path, so a custom-integration handler returning a plain document had it read as a `{statusCode, headers, body}` proxy envelope: a `statusCode` key in the data became the HTTP status and the rest was dropped. A non-proxy integration now serializes the return value as the response body with the integration response's status (200 by default); a standard Lambda error is passed through as the body at the default 200 status (as AWS does when no `selectionPattern` is configured), and an uninvokable or throttled backend is a `504` integration failure. `AWS_PROXY` is unchanged. Contributed by @iot-rocket.+- **IoT — topic-rule `WHERE` evaluation, SQL functions, and non-Lambda actions** — rules ignored the `WHERE` clause, so every publish matching the topic filter dispatched, and Lambda was the only action wired up. The rules engine now evaluates `WHERE` with AWS's three-valued (Undefined) logic — `=`/`<>`/`<`/`>`/`BETWEEN`/`IN`/`LIKE`/`IS NULL`/`regexp_matches`, `AND`/`OR`/`NOT`, and arithmetic — implements the `clientid` / `encode` / `isundefined` / `newuuid` / `regexp_matches` / `replace` / `timestamp` / `topic` functions (an unimplemented function resolves to Undefined and warns once), and dispatches the `republish`, `dynamoDBv2`, and `sns` actions, running the rule's `errorAction` on a delivery failure. Contributed by @iot-rocket.+- **API Gateway (REST / v1) — Lambda authorizer cache is scoped to the method ARN and stage** — the cache stored the allow/deny decision keyed on the identity source alone, so a cached `Allow` for `GET /alpha` also authorized `GET /beta`, and a verdict cached on one stage was served for another. It now caches the authorizer's policy document and re-evaluates it against each request's own method ARN, with the stage and API in the key; malformed authorizer output (missing `policyDocument` or `principalId`) answers `500` and is never cached. Contributed by @iot-rocket.+- **API Gateway (HTTP API / v2) — REQUEST-authorizer cache is scoped to the route ARN** — the v2 cache stored the verdict rather than the authorizer's response, so a cached `Allow` leaked across routes. It now caches the output (the policy document for an IAM-policy response, the `isAuthorized` boolean for a simple response) and re-evaluates the policy against each request's own route ARN, keyed on the identity source values and stage; caching requires at least one identity source and the cache is bounded. Contributed by @iot-rocket.+- **Lambda — a Docker-executor handler's callbacks resolve on native Linux engines** — `AWS_ENDPOINT_URL` inside a Lambda container is rewritten to `host.docker.internal`, which only resolves on Docker Desktop, so on a native Linux engine every nested SDK call a handler made died on DNS. Lambda containers now map `host.docker.internal` to `host-gateway` (as the ECS and EKS paths already do); an explicit `--add-host` still wins. Contributed by @iot-rocket.+- **IoT — MQTT `UNSUBSCRIBE` removes only the topic filters it names** — the MQTT-over-WebSocket bridge never read the filter list in the packet and unsubscribed every subscription the session held, so a client unsubscribing from one topic stopped receiving all the others. It now removes only the named filters (matched character-by-character per MQTT 3.1.1 §3.10.4, so a wildcard matches its own text), popping the id from every per-session map so a preserved `cleanSession=0` session cannot resurrect a removed filter, and a truncated payload unsubscribes what parsed rather than tearing the session down. Contributed by @iot-rocket.+- **TLS — minted leaf certificates carry an Authority Key Identifier** — `sign_leaf_certificate` omitted it, and RFC 5280 requires it on every certificate that is not self-issued. Python 3.13 enables `ssl.VERIFY_X509_STRICT` in `ssl.create_default_context()`, so any client on a current Python rejected what MiniStack minted with "Missing Authority Key Identifier" — `CreateKeysAndCertificate` certificates included. Contributed by @iot-rocket.+- **Lambda (Docker executor) — a failed init or a timed-out handler is reported once, not retried** — the RIE invoke loop's single connection-retry arm swallowed two terminal cases that both look like `OSError`: a failed `INIT` (RIE answers `502`, raised as `HTTPError`) and a read timeout (bare `TimeoutError`). A function whose module fails to import re-ran `INIT` ~10×/second up to its `Timeout` — a 900-second function pinned the emulator ~15 minutes — and the caller got a generic error instead of the real `Runtime.ImportModuleError`. Both are now terminal: an init failure returns `200` with `X-Amz-Function-Error: Unhandled` and the runtime's own error payload, a timeout answers `Runtime.ExitError` and recycles the container, and only genuine connection failures still retry within a bounded cold-start window. Contributed by @iot-rocket.+- **Lambda — `RecursiveLoop` is enforced** — `PutFunctionRecursionConfig` stored the setting and nothing read it, so a self-invoking function looped unchecked (an async self-invoke returns `202`, releases its worker, and never throttles). A per-request lineage depth now travels with direct Lambda → Lambda invocations; past ~16 hops the invocation is dropped with `RecursiveInvocationException` and a `RecursiveInvocationsDropped` metric, unless the function's `RecursiveLoop` is `Allow`. Loops that leave through SQS, SNS or S3 and back are not yet detected. Contributed by @iot-rocket.+- **Aurora DSQL — index and DDL error parity, including expression index keys** — the wire proxy now allows expression index keys on `CREATE INDEX ASYNC` (a volatile function is rejected `42P17: functions in index expression must be marked IMMUTABLE`, an expression in an `INCLUDE` column `0A000`) and aligns the surrounding errors with a live cluster: plain `CREATE INDEX` is always refused (`unsupported mode. please use CREATE INDEX ASYNC.`), `USING` / `CONCURRENTLY` / `WHERE` return DSQL's own messages, 9+ key columns `54011`, a nameless `IF NOT EXISTS` `42601`, and a primary-key column drop reports `cannot drop primary key column <name>`. Contributed by @ry-allan.+- **ALB — target responses are streamed instead of buffered** — the data plane read a target's entire response before returning, so a streaming or chunked target reached the client only once it had finished producing (measured time-to-first-byte for a 700 KB stream: 11.28s → 0.004s). It now relays the body as the target produces it, keeping the target's framing (`Content-Length` or chunked) and bounding an established connection by an idle timeout (default 60s) distinct from the 10s connect deadline; a target that dies mid-body surfaces as a truncated response rather than a clean one. Contributed by @uttom-akash.- **S3 — GetObject and HeadObject answer the conditional-read headers** — `If-Match`, `If-None-Match`, `If-Modified-Since` and `If-Unmodified-Since` were honoured on PutObject, CopyObject and DeleteObject but ignored on the reads, so every conditional read returned `200` and the whole body: a cache revalidating an unchanged object refetched it in full, and a read guarded against a concurrent overwrite never noticed one. Reads now answer `412 PreconditionFailed` or `304 Not Modified`, with the precedence RFC 9110 13.2.2 and the AWS GetObject reference define — an entity tag decides, and its date counterpart applies only in its absence — and a `412` preempts a `Range` rather than slicing a representation the caller rejected. The `304` keeps the validators (`ETag`, `Last-Modified`) and drops the headers describing a payload it cannot carry, `x-amz-checksum-*` included, which boto3 asks for by default and would otherwise try to validate against the empty body. Reported by @gaul.## [1.4.17] — 2026-08-14@@ -29,7 +44,6 @@ Versioning follows [Semantic Versioning](https://semver.org/).- **API Gateway (HTTP API / v2) — custom Lambda (`REQUEST`) authorizers are now invoked and enforced** — `_handle_execute_in_scope` only branched on `auth_type == "JWT"`, so a route with a `CUSTOM` authorization type (the type a route gets when it references a `REQUEST` authorizer) fell through unauthenticated: the authorizer Lambda was never invoked at all, regardless of whether the request carried a valid, invalid, or missing token. Adds a REQUEST-authorizer data-plane path mirroring the REST (v1) fix from 1.4.16 (`_authorize_request_v1`) — honors `authorizerPayloadFormatVersion` (1.0 IAM-policy-shaped event vs. 2.0), `enableSimpleResponses` (`{isAuthorized, context}`) vs. IAM policy (`{principalId, policyDocument, context}`) response formats, and `authorizerResultTtlInSeconds` caching — and populates `requestContext.authorizer.lambda` for the downstream integration. Reported against real-world usage; the earlier REST (v1) authorizer fix covered v1 only. Contributed by @ryan-bennett.- **EventBridge — API destination delivery no longer leaks credentials, and caller-supplied outbound values are validated** — API destination requests now validate every caller-controlled value before it reaches the wire. (1) Delivery and OAuth token requests no longer follow redirects, preventing credentials from reaching another host; `3xx` responses are non-retryable failures. (2) `InvocationEndpoint` and OAuth `AuthorizationEndpoint` must be dialable `http(s)://` URLs. The outbound opener also rejects non-HTTP(S) schemes, while loopback/private/link-local hosts remain allowed for the local emulator. (3) `HttpMethod` and `AuthorizationType` are validated against their API enums. (4) `ApiKeyName` can no longer override reserved headers. (5) `DeauthorizeConnection` removes authorization parameters, and delivery skips connections that are not `AUTHORIZED`. (6) OAuth token responses are capped at 1 MiB. Contributed by @t-rech.- **Lambda — uncaught handler exceptions report `X-Amz-Function-Error: Unhandled`** — the Docker/RIE executor read the error class off a response header the RIE never sets, so every failure was reported `Handled` and API Gateway consumers keying off the 502-for-Unhandled contract never took the error path. Headerless payloads are now classified by shape: the runtime's error serialization reports `Unhandled`, an HTTP-style envelope with `statusCode` stays `Handled`. Contributed by @iot-rocket.-- **TLS — minted leaf certificates carry an Authority Key Identifier** — `sign_leaf_certificate` omitted it, and RFC 5280 requires it on every certificate that is not self-issued. Python 3.13 enables `ssl.VERIFY_X509_STRICT` in `ssl.create_default_context()`, so any client on a current Python rejected what MiniStack minted with "Missing Authority Key Identifier" — `CreateKeysAndCertificate` certificates included. Contributed by @iot-rocket.- **IoT — `CreateThingType` is idempotent for identical re-creates** — re-creating an existing thing type always returned `ResourceAlreadyExistsException`, so a retried request or a re-run provisioning script failed where AWS succeeds. The same `thingTypeProperties` now return the existing ids — absent, `null` and empty compare equal, `searchableAttributes` is unordered — and only a real mismatch keeps the `409`, as `CreateThing` already did. Contributed by @iot-rocket.- **EC2 — `RevokeSecurityGroupIngress` / `RevokeSecurityGroupEgress` honour `SecurityGroupRuleIds`** — both read only `IpPermissions`, so a revoke by rule id (as Terraform does) returned `Return=true` while removing nothing, leaving the rule in place forever. Ids now resolve against the group's `sgr-*` rules, which are removed with their tags and echoed in `revokedSecurityGroupRuleSet`; one unknown id rejects the whole call with `InvalidSecurityGroupRuleId.NotFound`. Contributed by @iot-rocket.- **Cognito — `/oauth2/userInfo` returns custom attributes and the plain `username`** — the response filtered attributes through a fixed standard-OIDC allowlist, dropping `custom:` attributes; it now returns them (as AWS does for `openid` and `openid profile`), plus the plain `username` claim alongside `cognito:username`, and `middle_name`. Contributed by @rjmackay.diff --git a/README.md b/README.mdindex 4d5ef206..81163cd5 100644--- a/README.md+++ b/README.md@@ -431,7 +431,7 @@ subnet = ec2.create_subnet(| **WAF v2** | CreateWebACL, GetWebACL, UpdateWebACL, DeleteWebACL, ListWebACLs, AssociateWebACL, DisassociateWebACL, GetWebACLForResource, ListResourcesForWebACL, CreateIPSet, GetIPSet, UpdateIPSet, DeleteIPSet, ListIPSets, CreateRuleGroup, GetRuleGroup, UpdateRuleGroup, DeleteRuleGroup, ListRuleGroups, TagResource, UntagResource, ListTagsForResource, CheckCapacity, DescribeManagedRuleGroup | LockToken enforced on Update/Delete; resource associations tracked || **Step Functions** | CreateStateMachine, DeleteStateMachine, DescribeStateMachine, UpdateStateMachine, ListStateMachines, StartExecution, StartSyncExecution, StopExecution, DescribeExecution, DescribeStateMachineForExecution, ListExecutions, GetExecutionHistory, SendTaskSuccess, SendTaskFailure, SendTaskHeartbeat, CreateActivity, DeleteActivity, DescribeActivity, ListActivities, GetActivityTask, TestState, TagResource, UntagResource, ListTagsForResource | Full ASL interpreter; Retry/Catch; waitForTaskToken; Activities (worker pattern); Pass/Task/Choice/Wait/Succeed/Fail/Map/Parallel; TestState API with mock and inspectionLevel support; SFN_MOCK_CONFIG for AWS SFN Local compatible mock testing; intrinsic functions (States.StringToJson, States.JsonToString, States.JsonMerge, States.Format); nested startExecution.sync || **API Gateway v2** | CreateApi, GetApi, GetApis, UpdateApi, DeleteApi, CreateRoute, GetRoute, GetRoutes, UpdateRoute, DeleteRoute, CreateIntegration, GetIntegration, GetIntegrations, UpdateIntegration, DeleteIntegration, CreateRouteResponse, GetRouteResponse, GetRouteResponses, UpdateRouteResponse, DeleteRouteResponse, CreateIntegrationResponse, GetIntegrationResponse, GetIntegrationResponses, UpdateIntegrationResponse, DeleteIntegrationResponse, CreateStage, GetStage, GetStages, UpdateStage, DeleteStage, CreateDeployment, GetDeployment, GetDeployments, DeleteDeployment, CreateAuthorizer, GetAuthorizer, GetAuthorizers, UpdateAuthorizer, DeleteAuthorizer, TagResource, UntagResource, GetTags, PostToConnection, GetConnection, DeleteConnection | **HTTP API** and **WebSocket API** (`protocolType=WEBSOCKET`); Lambda proxy (`AWS_PROXY`), HTTP proxy (`HTTP_PROXY`), and MOCK integrations; HTTP data plane via `{apiId}.execute-api.localhost` Host header or path-based `/_aws/execute-api/{apiId}/{stage}/{path}` (no DNS/Host override needed — works from browsers on macOS and strict clients); `$default` stage served from the URL root (no stage segment in the path); per-API `corsConfiguration` applied to preflights + dispatched responses; request parameter mapping for HTTP_PROXY (`append/overwrite/remove` for headers/querystring plus `overwrite:path`) with context variables including `$context.authorizer.jwt.claims`; JWT data-plane authorization for HTTP routes (issuer/audience/time/scope checks) and claim propagation to integrations; qualified-alias integration URIs (`arn:...:function:<name>:<alias>`) resolve to the alias's target version; WebSocket data plane on the same two URL forms, with `$connect` / `$disconnect` / `$default` / custom-action routing, `$request.body.*` RouteSelectionExpression, `@connections` management API (PostToConnection / GetConnection / DeleteConnection), per-connection outbox for server-side push; `{param}` / `{proxy+}` matching; JWT/Lambda authorizer CRUD; pin `apiId` across runs with the `ms-custom-id` tag |-| **API Gateway v1** | CreateRestApi, GetRestApi, GetRestApis, UpdateRestApi, DeleteRestApi, CreateResource, GetResource, GetResources, UpdateResource, DeleteResource, PutMethod, GetMethod, DeleteMethod, UpdateMethod, PutMethodResponse, GetMethodResponse, DeleteMethodResponse, PutIntegration, GetIntegration, DeleteIntegration, UpdateIntegration, PutIntegrationResponse, GetIntegrationResponse, DeleteIntegrationResponse, CreateDeployment, GetDeployment, GetDeployments, UpdateDeployment, DeleteDeployment, CreateStage, GetStage, GetStages, UpdateStage, DeleteStage, CreateAuthorizer, GetAuthorizer, GetAuthorizers, UpdateAuthorizer, DeleteAuthorizer, CreateModel, GetModel, GetModels, DeleteModel, CreateDocumentationPart, GetDocumentationPart, GetDocumentationParts, UpdateDocumentationPart, DeleteDocumentationPart, CreateApiKey, GetApiKey, GetApiKeys, UpdateApiKey, DeleteApiKey, CreateUsagePlan, GetUsagePlan, GetUsagePlans, UpdateUsagePlan, DeleteUsagePlan, CreateUsagePlanKey, GetUsagePlanKeys, DeleteUsagePlanKey, CreateDomainName, GetDomainName, GetDomainNames, DeleteDomainName, CreateBasePathMapping, GetBasePathMapping, GetBasePathMappings, DeleteBasePathMapping, TagResource, UntagResource, GetTags | REST API (v1) protocol; Lambda proxy format 1.0 (AWS_PROXY), HTTP proxy (HTTP_PROXY), MOCK integration; data plane via `{apiId}.execute-api.localhost` Host header, path-based `/_aws/execute-api/{apiId}/{stage}/{path}`, or legacy `/restapis/{apiId}/{stage}/_user_request_/{path}`; qualified-alias integration URIs (`arn:...:function:<name>:<alias>`) resolve to the alias's target version; resource tree with `{param}` and `{proxy+}` path matching; TOKEN and REQUEST Lambda authorizers on the data plane, with the returned IAM policy evaluated against each request's own method ARN and `authorizerResultTtlInSeconds` caching the policy per stage and identity source; JSON Patch for all PATCH operations; state persistence; pin `id` across runs with the `ms-custom-id` tag |+| **API Gateway v1** | CreateRestApi, GetRestApi, GetRestApis, UpdateRestApi, DeleteRestApi, CreateResource, GetResource, GetResources, UpdateResource, DeleteResource, PutMethod, GetMethod, DeleteMethod, UpdateMethod, PutMethodResponse, GetMethodResponse, DeleteMethodResponse, PutIntegration, GetIntegration, DeleteIntegration, UpdateIntegration, PutIntegrationResponse, GetIntegrationResponse, DeleteIntegrationResponse, CreateDeployment, GetDeployment, GetDeployments, UpdateDeployment, DeleteDeployment, CreateStage, GetStage, GetStages, UpdateStage, DeleteStage, CreateAuthorizer, GetAuthorizer, GetAuthorizers, UpdateAuthorizer, DeleteAuthorizer, CreateModel, GetModel, GetModels, DeleteModel, CreateDocumentationPart, GetDocumentationPart, GetDocumentationParts, UpdateDocumentationPart, DeleteDocumentationPart, CreateApiKey, GetApiKey, GetApiKeys, UpdateApiKey, DeleteApiKey, CreateUsagePlan, GetUsagePlan, GetUsagePlans, UpdateUsagePlan, DeleteUsagePlan, CreateUsagePlanKey, GetUsagePlanKeys, DeleteUsagePlanKey, CreateDomainName, GetDomainName, GetDomainNames, DeleteDomainName, CreateBasePathMapping, GetBasePathMapping, GetBasePathMappings, DeleteBasePathMapping, TagResource, UntagResource, GetTags | REST API (v1) protocol; Lambda proxy format 1.0 (AWS_PROXY), non-proxy Lambda (AWS — the handler's output is the response body, mapping templates not modeled), HTTP proxy (HTTP_PROXY), MOCK integration; data plane via `{apiId}.execute-api.localhost` Host header, path-based `/_aws/execute-api/{apiId}/{stage}/{path}`, or legacy `/restapis/{apiId}/{stage}/_user_request_/{path}`; qualified-alias integration URIs (`arn:...:function:<name>:<alias>`) resolve to the alias's target version; resource tree with `{param}` and `{proxy+}` path matching; TOKEN and REQUEST Lambda authorizers on the data plane, with the returned IAM policy evaluated against each request's own method ARN and `authorizerResultTtlInSeconds` caching the policy per stage and identity source; JSON Patch for all PATCH operations; state persistence; pin `id` across runs with the `ms-custom-id` tag || **ELBv2 / ALB** | CreateLoadBalancer, DescribeLoadBalancers, DeleteLoadBalancer, DescribeLoadBalancerAttributes, ModifyLoadBalancerAttributes, CreateTargetGroup, DescribeTargetGroups, ModifyTargetGroup, DeleteTargetGroup, DescribeTargetGroupAttributes, ModifyTargetGroupAttributes, CreateListener, DescribeListeners, ModifyListener, DeleteListener, CreateRule, DescribeRules, ModifyRule, DeleteRule, SetRulePriorities, SetSubnets, SetIpAddressType, SetSecurityGroups, RegisterTargets, DeregisterTargets, DescribeTargetHealth, AddTags, RemoveTags, DescribeTags | Control plane + data plane; ALB→Lambda live traffic routing; `path-pattern`, `host-header`, `http-method`, `query-string`, `http-header` rule conditions; `forward`, `redirect`, `fixed-response` actions; data plane via `{lb-name}.alb.localhost` Host header or `/_alb/{lb-name}/` path prefix || **KMS** | CreateKey, ListKeys, DescribeKey, GetPublicKey, Sign, Verify, Encrypt, Decrypt, GenerateMac, VerifyMac, GenerateDataKey, GenerateDataKeyWithoutPlaintext, GenerateDataKeyPair, GenerateDataKeyPairWithoutPlaintext, CreateAlias, DeleteAlias, ListAliases, UpdateAlias, UpdateKeyDescription, EnableKeyRotation, DisableKeyRotation, GetKeyRotationStatus, GetKeyPolicy, PutKeyPolicy, ListKeyPolicies, EnableKey, DisableKey, ScheduleKeyDeletion, CancelKeyDeletion, TagResource, UntagResource, ListResourceTags | 32 actions; CMK specs: RSA (2048/3072/4096), ECC (SECG_P256K1, NIST P-256/384/521), Edwards25519 (`ECC_NIST_EDWARDS25519` — pure Ed25519 via `ED25519_SHA_512` with `MessageType=RAW`; `ED25519_PH_SHA_512` advertised in `SigningAlgorithms` but returns `UnsupportedOperationException` until Ed25519ph lands), HMAC (`HMAC_224`/`HMAC_256`/`HMAC_384`/`HMAC_512` with `KeyUsage=GENERATE_VERIFY_MAC`), and symmetric keys; PKCS1v15, PSS, and ECDSA signing; real RFC 2104 HMAC via `GenerateMac`/`VerifyMac` (4096-byte message cap, `KMSInvalidMacException` on mismatch, `DryRun` supported); envelope encryption, incl. asymmetric data key pairs (`KeyPairSpec` adds RSA_3072); alias resolution; key rotation; key policies; tags; enable/disable/schedule deletion; full Terraform `aws_kms_key` compatible; `cryptography` package included in Docker image || **CloudFront** | CreateDistribution, GetDistribution, GetDistributionConfig, ListDistributions, UpdateDistribution, DeleteDistribution, CreateInvalidation, ListInvalidations, GetInvalidation, CreateOriginAccessControl, GetOriginAccessControl, GetOriginAccessControlConfig, ListOriginAccessControls, UpdateOriginAccessControl, DeleteOriginAccessControl, CreateFunction, DeleteFunction, DescribeFunction, GetFunction, ListFunctions, PublishFunction, UpdateFunction, **KeyValueStore (mgmt)**: CreateKeyValueStore, DescribeKeyValueStore, ListKeyValueStores, UpdateKeyValueStore, DeleteKeyValueStore, **Policies**: CreateCachePolicy, GetCachePolicy, GetCachePolicyConfig, UpdateCachePolicy, DeleteCachePolicy, ListDistributionsByCachePolicyId, CreateOriginRequestPolicy, GetOriginRequestPolicy, GetOriginRequestPolicyConfig, UpdateOriginRequestPolicy, DeleteOriginRequestPolicy, ListDistributionsByOriginRequestPolicyId, CreateResponseHeadersPolicy, GetResponseHeadersPolicy, GetResponseHeadersPolicyConfig, UpdateResponseHeadersPolicy, DeleteResponseHeadersPolicy, ListDistributionsByResponseHeadersPolicyId, TagResource, UntagResource, ListTagsForResource | REST/XML API; ETag-based optimistic concurrency; Origin config round-trip; cache / origin request / response headers policies round-trip their full config with `ETag` / `If-Match` optimistic concurrency; Origin Access Control (OAC) with SigV4 signing for S3, MediaStore, Lambda, MediaPackageV2 origins; **CloudFront Functions** are API stubs (in-memory code + DEVELOPMENT/LIVE ETags for Terraform `aws_cloudfront_function`) with `KeyValueStoreAssociations` round-tripped — no `TestFunction`, no viewer-request JS execution at the edge; `UpdateFunction` clears the emulated LIVE stage until `PublishFunction` runs again |@@ -561,7 +561,7 @@ MiniStack expands AWS SAM transforms (`Transform: AWS::Serverless-2016-10-31`) i| Service | Operations | Notes ||---------|-----------|-------|| **ECS** | CreateCluster, DeleteCluster, DescribeClusters, ListClusters, UpdateCluster, UpdateClusterSettings, PutClusterCapacityProviders, RegisterTaskDefinition, DeregisterTaskDefinition, DescribeTaskDefinition, ListTaskDefinitions, ListTaskDefinitionFamilies, DeleteTaskDefinitions, CreateService, DeleteService, DescribeServices, UpdateService, ListServices, ListServicesByNamespace, RunTask, StopTask, DescribeTasks, ListTasks, ExecuteCommand, UpdateTaskProtection, GetTaskProtection, CreateCapacityProvider, UpdateCapacityProvider, DeleteCapacityProvider, DescribeCapacityProviders, TagResource, UntagResource, ListTagsForResource, ListAccountSettings, PutAccountSetting, PutAccountSettingDefault, DeleteAccountSetting, PutAttributes, DeleteAttributes, ListAttributes, DescribeServiceDeployments, ListServiceDeployments, DescribeServiceRevisions, SubmitTaskStateChange, SubmitContainerStateChange, SubmitAttachmentStateChanges, DiscoverPollEndpoint | 47 actions; `RunTask` starts real Docker containers via Docker socket; full Terraform ECS coverage |-| **RDS** | CreateDBInstance, DeleteDBInstance, DescribeDBInstances, ModifyDBInstance, StartDBInstance, StopDBInstance, RebootDBInstance, CreateDBInstanceReadReplica, RestoreDBInstanceFromDBSnapshot, CreateDBCluster, DeleteDBCluster, DescribeDBClusters, ModifyDBCluster, StartDBCluster, StopDBCluster, CreateDBSnapshot, DeleteDBSnapshot, DescribeDBSnapshots, CreateDBClusterSnapshot, DescribeDBClusterSnapshots, DeleteDBClusterSnapshot, CreateDBSubnetGroup, DeleteDBSubnetGroup, DescribeDBSubnetGroups, ModifyDBSubnetGroup, CreateDBParameterGroup, DeleteDBParameterGroup, DescribeDBParameterGroups, DescribeDBParameters, ModifyDBParameterGroup, CreateDBClusterParameterGroup, DescribeDBClusterParameterGroups, DeleteDBClusterParameterGroup, DescribeDBClusterParameters, ModifyDBClusterParameterGroup, CreateOptionGroup, DeleteOptionGroup, DescribeOptionGroups, DescribeOptionGroupOptions, ListTagsForResource, AddTagsToResource, RemoveTagsFromResource, DescribeDBEngineVersions, DescribeOrderableDBInstanceOptions, CreateGlobalCluster, DescribeGlobalClusters, DeleteGlobalCluster, RemoveFromGlobalCluster, ModifyGlobalCluster | `CreateDBInstance` spins up real Postgres/MySQL Docker container, returns actual `host:port` endpoint |+| **RDS** | CreateDBInstance, DeleteDBInstance, DescribeDBInstances, ModifyDBInstance, StartDBInstance, StopDBInstance, RebootDBInstance, CreateDBInstanceReadReplica, RestoreDBInstanceFromDBSnapshot, CreateDBCluster, DeleteDBCluster, DescribeDBClusters, ModifyDBCluster, StartDBCluster, StopDBCluster, CreateDBSnapshot, DeleteDBSnapshot, DescribeDBSnapshots, CreateDBClusterSnapshot, DescribeDBClusterSnapshots, DeleteDBClusterSnapshot, CreateDBSubnetGroup, DeleteDBSubnetGroup, DescribeDBSubnetGroups, ModifyDBSubnetGroup, CreateDBParameterGroup, DeleteDBParameterGroup, DescribeDBParameterGroups, DescribeDBParameters, ModifyDBParameterGroup, CreateDBClusterParameterGroup, DescribeDBClusterParameterGroups, DeleteDBClusterParameterGroup, DescribeDBClusterParameters, ModifyDBClusterParameterGroup, CreateOptionGroup, DeleteOptionGroup, DescribeOptionGroups, DescribeOptionGroupOptions, ListTagsForResource, AddTagsToResource, RemoveTagsFromResource, DescribeDBEngineVersions, DescribeOrderableDBInstanceOptions, CreateGlobalCluster, DescribeGlobalClusters, DeleteGlobalCluster, RemoveFromGlobalCluster, ModifyGlobalCluster | `CreateDBInstance` spins up real Postgres/MySQL Docker container, returns actual `host:port` endpoint; Aurora MySQL 8.0/8.4 compatibility objects (`AWSAuthenticationPlugin`, RDS/Aurora stored procedures, predefined S3 roles) install automatically for supported MySQL images so Aurora provisioning workflows run — the plugin rejects authentication (non-enforcing); disable with `MINISTACK_MYSQL_IAM_AUTH=off` || **Aurora DSQL** | CreateCluster, GetCluster, UpdateCluster, DeleteCluster, ListClusters, PutClusterPolicy, GetClusterPolicy, DeleteClusterPolicy, TagResource, UntagResource, ListTagsForResource | `CreateCluster` spins up a real `postgres:16-alpine` Docker container fronted by a validating PG wire-protocol proxy that **fails like real DSQL** — rejects unsupported SQL (`serial`, foreign keys, extensions, ...), accepts `CREATE INDEX ASYNC` + `sys.jobs`; endpoint is `localhost:<port>`; any password accepted || **ElastiCache** | CreateCacheCluster, DeleteCacheCluster, DescribeCacheClusters, ModifyCacheCluster, RebootCacheCluster, CreateReplicationGroup, DeleteReplicationGroup, DescribeReplicationGroups, ModifyReplicationGroup, IncreaseReplicaCount, DecreaseReplicaCount, CreateCacheSubnetGroup, DescribeCacheSubnetGroups, ModifyCacheSubnetGroup, DeleteCacheSubnetGroup, CreateCacheParameterGroup, DescribeCacheParameterGroups, ModifyCacheParameterGroup, ResetCacheParameterGroup, DeleteCacheParameterGroup, DescribeCacheParameters, DescribeCacheEngineVersions, CreateUser, DescribeUsers, DeleteUser, ModifyUser, CreateUserGroup, DescribeUserGroups, DeleteUserGroup, ModifyUserGroup, ListTagsForResource, AddTagsToResource, RemoveTagsFromResource, CreateSnapshot, DeleteSnapshot, DescribeSnapshots, DescribeEvents | `CreateCacheCluster` spins up a real Redis, Valkey, or Memcached Docker container (`Engine=redis`/`valkey`/`memcached`) || **Glue** | CreateDatabase, DeleteDatabase, GetDatabase, GetDatabases, UpdateDatabase, CreateTable, DeleteTable, GetTable, GetTables, UpdateTable, BatchDeleteTable, CreatePartition, DeletePartition, GetPartition, GetPartitions, BatchCreatePartition, BatchGetPartition, CreatePartitionIndex, GetPartitionIndexes, GetColumnStatisticsForTable, UpdateColumnStatisticsForTable, DeleteColumnStatisticsForTable, GetColumnStatisticsForPartition, UpdateColumnStatisticsForPartition, DeleteColumnStatisticsForPartition, CreateConnection, DeleteConnection, GetConnection, GetConnections, CreateCrawler, DeleteCrawler, GetCrawler, GetCrawlers, UpdateCrawler, StartCrawler, StopCrawler, GetCrawlerMetrics, CreateJob, DeleteJob, GetJob, GetJobs, UpdateJob, StartJobRun, GetJobRun, GetJobRuns, BatchStopJobRun, CreateTrigger, GetTrigger, DeleteTrigger, UpdateTrigger, StartTrigger, StopTrigger, ListTriggers, BatchGetTriggers, GetTriggers, CreateWorkflow, GetWorkflow, DeleteWorkflow, UpdateWorkflow, StartWorkflowRun, CreateUserDefinedFunction, UpdateUserDefinedFunction, DeleteUserDefinedFunction, GetUserDefinedFunction, GetUserDefinedFunctions, CreateSecurityConfiguration, DeleteSecurityConfiguration, GetSecurityConfiguration, GetSecurityConfigurations, CreateClassifier, GetClassifier, GetClassifiers, DeleteClassifier, TagResource, UntagResource, GetTags | Python shell jobs actually execute via subprocess; Spark jobs run on the official `amazon/aws-glue-libs` PySpark image (`GlueVersion: 4.0` / `3.0`) on MiniStack's Docker network; Glue-backed Iceberg REST catalog at `/iceberg` (signed with the `glue` credential scope, prefix `catalogs/{catalog}`) — read path for tables whose `metadata_location` parameter points at a metadata.json on MiniStack S3, e.g. DuckDB `ATTACH ... (TYPE iceberg, ENDPOINT 'localhost:4566/iceberg', AUTHORIZATION_TYPE 'sigv4')` with `USE_SSL=1` |@@ -583,7 +583,7 @@ MiniStack expands AWS SAM transforms (`Transform: AWS::Serverless-2016-10-31`) i| **CodeBuild** | CreateProject, BatchGetProjects, ListProjects, UpdateProject, DeleteProject, StartBuild, BatchGetBuilds, StopBuild, ListBuilds, ListBuildsForProject, BatchDeleteBuilds | 11 actions; project and build metadata stored in-memory; builds complete immediately with SUCCEEDED status by default. Set `MINISTACK_CODEBUILD_EXECUTE=1` and mount the Docker socket to **really run them**: the project's inline buildspec goes to the official AWS CodeBuild local agent, which runs the phases in `environment.image`, and `BatchGetBuilds` reports live `phases` with a real `SUCCEEDED`/`FAILED` outcome. Execution needs the workspace shared with the host at the **same path** (`-v /tmp/ministack-codebuild:/tmp/ministack-codebuild`), because the agent bind-mounts it into the build container; a build gets `AWS_ENDPOINT_URL` pointing back at MiniStack, honours `timeoutInMinutes`, and is stopped by `StopBuild`. An executed build streams the agent output into its `logs.groupName` / `logs.streamName`, so `aws logs tail` reads the build log back || **AppConfig** | CreateApplication, GetApplication, ListApplications, UpdateApplication, DeleteApplication, CreateEnvironment, GetEnvironment, ListEnvironments, UpdateEnvironment, DeleteEnvironment, CreateConfigurationProfile, GetConfigurationProfile, ListConfigurationProfiles, UpdateConfigurationProfile, DeleteConfigurationProfile, CreateHostedConfigurationVersion, GetHostedConfigurationVersion, ListHostedConfigurationVersions, DeleteHostedConfigurationVersion, CreateDeploymentStrategy, GetDeploymentStrategy, ListDeploymentStrategies, UpdateDeploymentStrategy, DeleteDeploymentStrategy, StartDeployment, GetDeployment, ListDeployments, StopDeployment, TagResource, UntagResource, ListTagsForResource, StartConfigurationSession, GetLatestConfiguration | 33 operations; control plane + data plane; hosted configuration versions; deployments complete immediately; session-based configuration retrieval with token rotation || **Transfer Family** | CreateServer, DescribeServer, DeleteServer, ListServers, StartServer, StopServer, CreateUser, DescribeUser, DeleteUser, ListUsers, ImportSshPublicKey, DeleteSshPublicKey | 12 operations; **real SFTP listener** on `:2222` (override with `SFTP_PORT`) backed by S3 — `ls`, `put`, `get`, `mkdir`, `rename` work end-to-end against the local S3 emulator; `SFTP_PORT_PER_SERVER=1` allocates one port per `CreateServer` from `SFTP_BASE_PORT` (default 2300); SSH key auth scans every user across every server and account; `LOGICAL` and `PATH` home-directory mappings; host key persists across restarts when `PERSIST_STATE=1` |-| **IoT Core** | CreateThing, DescribeThing, ListThings, UpdateThing, DeleteThing, CreateThingType, CreateThingGroup, AddThingToThingGroup, ListThingsInThingGroup, CreateKeysAndCertificate, RegisterCertificate, UpdateCertificate, DeleteCertificate, AttachThingPrincipal, DetachThingPrincipal, ListThingPrincipals, ListPrincipalThings, CreatePolicy, CreatePolicyVersion, AttachPolicy, DetachPolicy, ListAttachedPolicies, ListTargetsForPolicy, UpdateIndexingConfiguration, GetIndexingConfiguration, DescribeIndex, ListIndices, SearchIndex, DescribeEndpoint, Publish (HTTP), MQTT-over-WebSocket pub/sub | 29 operations + **real MQTT 3.1.1 over WebSocket** on the gateway port — clients use the address returned by `DescribeEndpoint`; local CA signs `CreateKeysAndCertificate` certificates (CA persists across restarts when `PERSIST_STATE=1`); multi-tenancy via transparent topic prefixing (same pattern as Transfer Family's shared SFTP listener); no plain TCP 1883 (real AWS IoT requires TLS or SigV4 on every connection); local CA cert available at `GET /_ministack/iot/ca.pem` for SDK trust configuration; IoT policies are stored but **not enforced** on the data plane; **fleet indexing** works the way it does on AWS — `UpdateIndexingConfiguration` turns the `AWS_Things` index on (Terraform `aws_iot_indexing_configuration`), and searching while `thingIndexingMode` is `OFF` answers `ResourceNotFoundException`; `SearchIndex` then queries the live registry + classic shadows with `AND`-separated `thingName` / `thingTypeName` / `thingGroupNames` / `attributes.*` / `shadow.reported.*` / `shadow.desired.*` terms (`*` / `?` wildcards, `maxResults` / `nextToken` paging) — there is no projection to build, so hits are always current |+| **IoT Core** | CreateThing, DescribeThing, ListThings, UpdateThing, DeleteThing, CreateThingType, CreateThingGroup, AddThingToThingGroup, ListThingsInThingGroup, CreateKeysAndCertificate, RegisterCertificate, RegisterCertificateWithoutCA, UpdateCertificate, DeleteCertificate, AttachThingPrincipal, DetachThingPrincipal, ListThingPrincipals, ListPrincipalThings, CreatePolicy, CreatePolicyVersion, AttachPolicy, DetachPolicy, ListAttachedPolicies, ListTargetsForPolicy, AttachPrincipalPolicy, DetachPrincipalPolicy, ListPrincipalPolicies, ListPolicyPrincipals, CreateTopicRule, GetTopicRule, ReplaceTopicRule, DeleteTopicRule, ListTopicRules, UpdateIndexingConfiguration, GetIndexingConfiguration, DescribeIndex, ListIndices, SearchIndex, DescribeEndpoint, Publish (HTTP), MQTT-over-WebSocket pub/sub | 39 operations + **real MQTT 3.1.1 over WebSocket** on the gateway port — clients use the address returned by `DescribeEndpoint`; local CA signs `CreateKeysAndCertificate` certificates (CA persists across restarts when `PERSIST_STATE=1`); multi-tenancy via transparent topic prefixing (same pattern as Transfer Family's shared SFTP listener); no plain TCP 1883 (real AWS IoT requires TLS or SigV4 on every connection); local CA cert available at `GET /_ministack/iot/ca.pem` for SDK trust configuration; IoT policies are stored but **not enforced** on the data plane; **fleet indexing** works the way it does on AWS — `UpdateIndexingConfiguration` turns the `AWS_Things` index on (Terraform `aws_iot_indexing_configuration`), and searching while `thingIndexingMode` is `OFF` answers `ResourceNotFoundException`; `SearchIndex` then queries the live registry + classic shadows with `AND`-separated `thingName` / `thingTypeName` / `thingGroupNames` / `attributes.*` / `shadow.reported.*` / `shadow.desired.*` terms (`*` / `?` wildcards, `maxResults` / `nextToken` paging) — there is no projection to build, so hits are always current; the deprecated principal-policy family (`AttachPrincipalPolicy` / `DetachPrincipalPolicy` / `ListPrincipalPolicies` / `ListPolicyPrincipals`) maps 1:1 onto the modern policy-target store; **topic rules fire on matching publishes** (incl. Basic Ingest `$aws/rules/<name>`) with SQL SELECT projection (`topic()`, `timestamp()`, `encode()`, `newuuid()`, `replace()`, `clientid()`, `isUndefined()`), **WHERE-clause evaluation** (comparisons, `IN`, `LIKE`, `BETWEEN`, `IS NULL`, `regexp_matches`, bare boolean attributes, composed with `AND` / `OR` and parenthesised grouping; missing attributes fail closed as on AWS; unparseable SQL → `SqlParseException`), and `lambda` / `republish` / `dynamoDBv2` / `sns` actions dispatched in-process with the rule's `errorAction` on failure || **EventBridge Scheduler** | CreateSchedule, GetSchedule, UpdateSchedule, DeleteSchedule, ListSchedules, CreateScheduleGroup, GetScheduleGroup, DeleteScheduleGroup, ListScheduleGroups, TagResource, UntagResource, ListTagsForResource | 12 actions; schedules **fire their targets** — a background sweep invokes each enabled schedule's target (Lambda, SQS, SNS, Step Functions) when due, honoring `State`, `StartDate`/`EndDate`, and `ActionAfterCompletion: DELETE`; schedule groups with cascading deletes; `rate()`, `cron()`, `at()` expressions; group/prefix/state filters on list; default group auto-created; CFN `AWS::Scheduler::Schedule` and `AWS::Scheduler::ScheduleGroup` supported || **EKS** | CreateCluster, DescribeCluster, ListClusters, DeleteCluster, CreateNodegroup, DescribeNodegroup, ListNodegroups, DeleteNodegroup, CreateAddon, DescribeAddon, ListAddons, UpdateAddon, DeleteAddon, AssociateEncryptionConfig, CreateAccessEntry, DescribeAccessEntry, ListAccessEntries, UpdateAccessEntry, DeleteAccessEntry, AssociateAccessPolicy, DisassociateAccessPolicy, ListAssociatedAccessPolicies, AssociateIdentityProviderConfig, DescribeIdentityProviderConfig, DisassociateIdentityProviderConfig, ListIdentityProviderConfigs, TagResource, UntagResource, ListTagsForResource | `CreateCluster` spawns a real **k3s** container (75 MB) with a full Kubernetes API server; `kubectl`, Helm, and any K8s tooling work out of the box; cascading delete removes nodegroups and k3s container; addon CRUD (e.g. `vpc-cni`, `coredns`, `kube-proxy`, `aws-ebs-csi-driver`) at `/clusters/{name}/addons` flips status to `ACTIVE` on create / update; `AssociateEncryptionConfig` at `/clusters/{name}/encryption-config/associate` records KMS encryption config (rejects re-association, AWS-shape `update` envelope); **Access Entries** (modern post-1.29 IAM bindings — replaces aws-auth ConfigMap) at `/clusters/{name}/access-entries[/{principalArn}[/access-policies[/{policyArn}]]]` for Crossplane / Terraform `aws_eks_access_entry` + `aws_eks_access_policy_association`; OIDC discovery + JWKS served at the cluster's `identity.oidc.issuer` URL so Terraform's `aws_iam_openid_connect_provider` (IRSA) works against ministack; **OIDC Identity Provider Config** (`AssociateIdentityProviderConfig` / `DescribeIdentityProviderConfig` / `DisassociateIdentityProviderConfig` / `ListIdentityProviderConfigs`) at `/clusters/{name}/identity-provider-configs[/{verb}]` — one OIDC IdP per cluster, issuer + clientId + claims forwarded to the k3s API server via `--kube-apiserver-arg=oidc-*` flags, tags reachable via `ListTagsForResource`; CFN `AWS::EKS::Cluster` and `AWS::EKS::Nodegroup` supported || **OpenSearch Service** | CreateDomain, DescribeDomain, DescribeDomains, DeleteDomain, ListDomainNames, UpdateDomainConfig, DescribeDomainConfig, DescribeDomainChangeProgress, ListVersions, GetCompatibleVersions, AddTags, ListTags, RemoveTags | Management plane on `/2021-01-01/*` (`boto3.client("opensearch")`, SigV4 scope `es`). Default data plane is a stub endpoint (`<domain>.ministack.local:9200`) — set `OPENSEARCH_DATAPLANE=1` to spawn one real `opensearchproject/opensearch` container per `CreateDomain` (same pattern as ElastiCache/RDS); `DescribeDomain.Endpoint` then points at that container and `_cluster/health`/`/_search` work end-to-end. Add `OPENSEARCH_DASHBOARDS=1` (with dataplane on) to also spawn a per-domain `opensearch-dashboards` sidecar; `DescribeDomain.DashboardEndpoint` is populated. ARNs follow `arn:aws:es:<region>:<account>:domain/<name>`; Terraform `aws_opensearch_domain` resource compatible. |diff --git a/ministack/services/apigateway_v1.py b/ministack/services/apigateway_v1.pyindex 5387e3ad..85e8fb76 100644--- a/ministack/services/apigateway_v1.py+++ b/ministack/services/apigateway_v1.py@@ -1876,8 +1876,11 @@ async def _invoke_lambda_custom_v1(happens to return a ``statusCode`` key therefore ships that key to the clientinside the body instead of having it promoted to the HTTP status.- A function error answers 502 ``{"message": "Internal server error"}`` —- the error payload is never surfaced to the caller.+ A standard Lambda error (the function ran and threw) is returned through the+ default integration response: 200 with the raw ``{errorMessage, errorType,+ stackTrace}`` as the body, as AWS does when no ``selectionPattern`` is+ configured (the only shape modeled here). A backend that cannot be invoked,+ or a Lambda concurrency throttle, is an integration failure and answers 504."""lambda_ref = _extract_lambda_ref_from_integration_uri(integration.get("uri", ""))@@ -1894,17 +1897,18 @@ async def _invoke_lambda_custom_v1(account_id=owner_account_id,region=owner_region,)- if err:- return 502, {"Content-Type": "application/json"}, json.dumps({"message": err}).encode()-resp_headers = {"Content-Type": "application/json"}- if result.get("throttle"):- throttle_body = result.get("body") or {}- payload = throttle_body if isinstance(throttle_body, dict) else {"message": str(throttle_body)}- return 429, resp_headers, json.dumps(payload).encode()- if result.get("error"):- return 502, resp_headers, json.dumps({"message": "Internal server error"}).encode()-+ # A backend that cannot be invoked, or a Lambda concurrency throttle, is an+ # integration failure — API Gateway answers 504 (INTEGRATION_FAILURE). Never+ # 429: THROTTLED/429 is API Gateway's own usage-plan/stage/account throttling,+ # not the function's.+ if err or result.get("throttle"):+ return 504, resp_headers, json.dumps({"message": "Internal server error"}).encode()++ # A standard Lambda error (the function ran and threw) is NOT mapped to a 5xx+ # here: with no integration-response selectionPattern configured — the only+ # shape modeled — API Gateway returns it through the default (200) response+ # with the raw {errorMessage, errorType, stackTrace} as the body.payload = result.get("body")if payload is None:resp_body = b""diff --git a/pyproject.toml b/pyproject.tomlindex a8691863..cc959459 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"[project]name = "ministack"-version = "1.4.17"+version = "1.4.18"description = "Free, open-source local AWS emulator — drop-in LocalStack replacement"readme = "README.md"license = { file = "LICENSE" }diff --git a/tests/test_apigatewayv1.py b/tests/test_apigatewayv1.pyindex 35424d34..41bed876 100644--- a/tests/test_apigatewayv1.py+++ b/tests/test_apigatewayv1.py@@ -1501,10 +1501,14 @@ def test_apigwv1_execute_lambda_custom_returns_raw_output(apigw_v1, lam):lam.delete_function(FunctionName=fname)-def test_apigwv1_execute_lambda_custom_function_error_is_502(apigw_v1, lam):- """A function error on a non-proxy integration is a 502 with the generic- gateway body — AWS never leaks the error payload to the caller."""- import urllib.error as _urlerr+def test_apigwv1_execute_lambda_custom_function_error_passes_through_200(apigw_v1, lam):+ """A standard Lambda error on a non-proxy integration is returned through the+ default (200) integration response with the raw error document as the body.++ AWS only maps a Lambda error to a 5xx when an integration-response+ selectionPattern matches it; with none configured — the only shape modeled —+ the error is "returned as 200 OK by default"+ (https://docs.aws.amazon.com/apigateway/latest/developerguide/handle-errors-in-lambda-integration.html)."""import urllib.request as _urlreqimport uuid as _uuid@@ -1517,12 +1521,13 @@ def test_apigwv1_execute_lambda_custom_function_error_is_502(apigw_v1, lam):try:req = _urlreq.Request(url, method="GET")req.add_header("Host", f"{api_id}.execute-api.localhost:{_EXECUTE_PORT}")- with pytest.raises(_urlerr.HTTPError) as exc:- _urlreq.urlopen(req)- assert exc.value.code == 502- body = json.loads(exc.value.read())- assert body == {"message": "Internal server error"}- assert "kaboom" not in json.dumps(body)+ resp = _urlreq.urlopen(req)+ assert resp.status == 200+ body = json.loads(resp.read())+ # The standard Lambda error document is passed through as the body,+ # rather than being hidden behind a generic gateway message.+ assert body.get("errorMessage") == "kaboom"+ assert "errorType" in bodyfinally:apigw_v1.delete_rest_api(restApiId=api_id)lam.delete_function(FunctionName=fname)