Nahuel Nucera

Posted on Mar 28

LocalStack Is Dead. MiniStack Runs Real Databases for Free.

#programming #cloud #terraform #testing

LocalStack archived its repo on March 23. Pipelines are breaking everywhere. Here's a drop-in replacement that actually spins up real Postgres, Redis, and Docker containers — no account, no API key, MIT licensed.

If you woke up this week to broken pipelines, you're not alone.

LocalStack archived its public GitHub repository and moved every image behind mandatory authentication. No warning in your docker-compose.yml. No deprecation period for CI. Just — gone.

The usual suspects have appeared: Moto, Floci, individual service emulators. But one project stands out for a reason nobody else is doing — it runs real infrastructure instead of faking it.

MiniStack: The One That Doesn't Fake It

docker run -p 4566:4566 nahuelnucera/ministack

No account. No API key. No telemetry. No BSL license. MIT, forever.

Existing --endpoint-url configs, boto3 clients, Terraform providers, and CDK stacks work without code changes.

aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket
aws --endpoint-url=http://localhost:4566 sqs create-queue --queue-name my-queue
aws --endpoint-url=http://localhost:4566 dynamodb list-tables

The Killer Feature: Real Infrastructure

Most AWS emulators fake everything in memory. MiniStack doesn't — not where it matters.

RDS creates actual database containers:

import boto3
import psycopg2

rds = boto3.client("rds",
    endpoint_url="http://localhost:4566",
    aws_access_key_id="test",
    aws_secret_access_key="test",
    region_name="us-east-1"
)

resp = rds.create_db_instance(
    DBInstanceIdentifier="mydb",
    DBInstanceClass="db.t3.micro",
    Engine="postgres",
    MasterUsername="admin",
    MasterUserPassword="password",
    DBName="appdb",
    AllocatedStorage=20,
)

endpoint = resp["DBInstance"]["Endpoint"]

# This is a REAL Postgres instance
conn = psycopg2.connect(
    host=endpoint["Address"],
    port=endpoint["Port"],
    user="admin",
    password="password",
    dbname="appdb",
)

That conn is talking to a real Postgres process. Not a mock. Not an in-memory fake. A real database you can inspect with psql.

Same story for:

ElastiCache → spins up a real Redis container
ECS → runs real Docker containers
Athena → executes real SQL via DuckDB
Lambda → real Python execution with warm starts between invocations

Why This Matters

If a test says "insert a row into RDS and read it back," the question is: is it testing application code or testing someone's mock of Postgres?

Moto is excellent for unit tests. But when integration confidence is what matters — when SQL migrations need to actually run, connection pooling needs to actually work, Redis TTLs need to actually expire — real infrastructure beats mocks. Locally.

That's the gap MiniStack fills.

23 Services, One Port

Service	Real Infra?	Notes
S3	In-memory + persistence	Full API including presigned URLs
SQS	In-memory	FIFO, dead-letter, visibility timeout
SNS	In-memory	Subscriptions, filtering
DynamoDB	In-memory	Streams, GSI, LSI
Lambda	✅ Real Python execution	Warm starts between invocations
RDS	✅ Real Postgres/MySQL	Actual Docker containers
ElastiCache	✅ Real Redis	With IAM auth support
ECS	✅ Real Docker	Actual container execution
Athena	✅ Real SQL (DuckDB)	Optional
IAM / STS	In-memory	Policies, roles, assume-role
Secrets Manager	In-memory	Full CRUD + rotation
SSM Parameter Store	In-memory	String, SecureString, StringList
EventBridge	In-memory	Rules, targets, patterns
Kinesis	In-memory	Shards, iterators
CloudWatch Logs	In-memory	Log groups, streams, events
CloudWatch Metrics	In-memory	Put/Get metric data
SES	In-memory	Send email (logged, not delivered)
Step Functions	In-memory	State machine execution
Glue	In-memory	Catalog, crawlers

How It Compares

	MiniStack	Floci	Moto	LocalStack (was)
License	MIT	MIT	Apache 2.0	BSL (was Apache)
Account required	No	No	No	Yes (now)
Real databases	✅	❌	❌	Pro only
Real containers (ECS)	✅	❌	❌	Pro only
Image size	~150 MB	~90 MB	N/A (library)	~1 GB
RAM at idle	~30 MB	~13 MB	N/A	~500 MB
Approach	Docker service	Docker service	In-process mock	Docker service
Best for	Integration tests, real infra	Quick emulation, CI	Python unit tests	—

5-Minute Migration from LocalStack

Step 1: Swap the image

# docker-compose.yml
services:
  # OLD
  # localstack:
  #   image: localstack/localstack

  # NEW
  ministack:
    image: nahuelnucera/ministack
    ports:
      - "4566:4566"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - REDIS_HOST=redis

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

Step 2: There is no step 2.

Same port. Same endpoint format. Same AWS API. boto3 clients, Terraform configs, and CDK stacks don't change.

GitHub Actions

- name: Start MiniStack
  run: |
    docker run -d -p 4566:4566 nahuelnucera/ministack
    sleep 2
    curl http://localhost:4566/_localstack/health

- name: Run tests
  env:
    AWS_ENDPOINT_URL: http://localhost:4566
    AWS_ACCESS_KEY_ID: test
    AWS_SECRET_ACCESS_KEY: test
    AWS_DEFAULT_REGION: us-east-1
  run: pytest

The Footprint Difference

LocalStack's image was over 1 GB and consumed ~500 MB at idle. That's a real cost in CI — especially on GitHub Actions free tier or when running parallel jobs.

MiniStack is ~150 MB and idles at ~30 MB. CI spins up faster, laptop fans stay quiet, and there's headroom for actual test workloads.

FAQ

Is this production-ready?
It's a local dev and CI tool. Don't expose it to the internet — it has no authentication by design. That's the whole point.

What about Moto?
Moto is the right choice for Python unit tests where in-process speed matters and Docker isn't wanted. MiniStack is the right choice when real infrastructure is needed — actual database connections, real Redis commands, real container execution.

What about Floci?
Floci is a solid project with faster startup and smaller footprint. MiniStack's differentiator is real infrastructure — actual Postgres/Redis containers out of the box, not in-memory fakes.

Will this stay free?
MIT is MIT. Fork it, embed it, sell it. No "community vs pro" split. No feature gates. No bait-and-switch.

DEV Community