See your cloud, before you ship your cloud.
Run AWS locally: S3, Lambda, DynamoDB, RDS, Step Functions, API Gateway, Glue and 50+ services —
with a full web console, real container-backed runtimes, and zero AWS account.
Mimir is a free, open-source local AWS environment: a bundled AWS-compatible backend (54 services on port 4566), a web console modeled on the real AWS console (27 services and counting), and real container-backed runtimes — all in a single docker run. Use it for local AWS development, AWS SDK integration testing, serverless development without an AWS account, offline demos, workshops, and CI.
No AWS account. No bill. No code changes — point your AWS CLI or SDK at http://localhost:4566 and go.
docker run -d --name mimir \
-p 8080:80 -p 4566:4566 -p 5500-5524:5500-5524 \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /tmp/mimir-glue:/tmp/mimir-glue \
-v mimir-data:/app/data \
tanujsoni027/mimir-aws:latestOpen http://localhost:8080 — that's it. Every service page has a one-click Load sample data button, so you're exploring a populated cloud in under a minute.
Step Functions with a live workflow graph — states turn blue while running and green when they succeed; Task nodes deep-link to the Lambda or Glue job they invoke:
The console — 27 AWS service consoles, and a $0.00 bill by design:
API Gateway — build REST and HTTP APIs in the console and invoke them locally:
RDS — every database instance is a real PostgreSQL, MySQL, or MariaDB container:
27 console services with real, working UIs:
| Category | Services |
|---|---|
| Storage | S3 — buckets, objects, uploads, presigned URLs |
| Databases | DynamoDB, RDS (real PostgreSQL/MySQL/MariaDB), ElastiCache (real Redis/Valkey/Memcached) |
| Compute | Lambda (real containers, invoke, logs, versions), EC2 (local instances + browser SSH terminal) |
| Containers | ECS (task definitions, services, tasks), ECR, EKS (real k3s clusters) |
| App integration | API Gateway (REST + HTTP), Step Functions (live workflow graph), EventBridge (rules, schedules, pipes), SQS, SNS |
| Analytics | Glue (real local job & notebook runtime), Athena (SQL over your S3 data), Kinesis + Firehose, OpenSearch, MSK/Kafka |
| Security & identity | IAM (roles, policies, users), Cognito, KMS, Secrets Manager |
| Management | CloudFormation (deploy real stacks), Systems Manager |
| Observability | CloudWatch Logs, CloudWatch Metrics |
The bundled backend exposes 54 AWS-compatible services on localhost:4566 for your CLI, SDKs, Terraform, and scripts — the console covers the workflows developers touch most.
Real engines, not mocks:
- Creating an RDS instance starts an actual PostgreSQL/MySQL/MariaDB container — connect with
psqlonlocalhost:5500. - ElastiCache runs real Redis/Valkey; OpenSearch runs the real OpenSearch engine; EKS boots a real k3s Kubernetes cluster.
- Lambda functions execute in real runtime containers. Glue jobs run actual PySpark. Step Functions Task states really invoke your local Lambdas.
- CloudFormation stacks actually provision the S3 buckets, queues, and topics in your template.
- Every container-backed service streams logs to its AWS-convention CloudWatch log group (
/aws/lambda/<fn>,/aws/rds/instance/<id>/error,/aws-glue/jobs/output, …).
LocalStack is a great project — Mimir takes a different shape:
| Mimir | LocalStack (free tier) | |
|---|---|---|
| Web console | Full AWS-style console for 27 services, bundled | Resource browser (limited free) |
| Price | Everything free, MIT | Core free; RDS, ECS, EKS, Cognito, Athena & more are paid |
| RDS / ElastiCache | Real Postgres/MySQL/Redis containers, free | Pro feature |
| ECS / EKS | Real containers / real k3s, free | Pro feature |
| Step Functions UI | Live workflow graph in the console | — |
| Glue | Real local Spark/PySpark job + notebook runtime | Pro feature |
| Setup | One docker run, one image |
One container + separate UI products |
| Data endpoints | Dedicated port range 5500–5550 (never clashes with local Redis/Postgres) | Ports vary |
If you need byte-exact AWS parity across hundreds of edge cases, use the real cloud for the last mile. If you want a fast, free, visual local AWS sandbox — that's Mimir.
aws --endpoint-url http://localhost:4566 s3 mb s3://hello
aws --endpoint-url http://localhost:4566 s3 ls
aws --endpoint-url http://localhost:4566 dynamodb list-tables
aws --endpoint-url http://localhost:4566 stepfunctions list-state-machinesSDKs work the same way — endpoint http://localhost:4566, region us-east-1, credentials mimir / mimir. Existing application code needs zero changes beyond the endpoint.
Data endpoints live in a dedicated 5500-5550 range so they never clash with a local Redis (6379), Postgres (5432), or Elasticsearch (9200):
| Range | Service | How it reaches your host |
|---|---|---|
| 5500–5509 | RDS databases (connect with psql/mysql) |
via -p 5500-5524 |
| 5510–5519 | ElastiCache (Redis/Valkey/Memcached) | via -p 5500-5524 |
| 5520–5524 | Neptune (Gremlin) | via -p 5500-5524 |
| 5525–5529 | OpenSearch domains | bound automatically |
| 5530–5539 | EC2 instance SSH | bound automatically |
| 5540–5544 | EKS API servers | bound automatically |
| 5545–5549 | ECR registries (docker push) |
bound automatically |
Mimir doesn't just browse the Glue catalog — it runs Glue code locally:
- ETL jobs in PySpark or Python shell, with run history, timeouts, parameters, and libraries
- Interactive notebooks with a live, stateful kernel
- Libraries from S3 — point a job at
s3://my-bucket/helpers.pyand it's fetched at run time - Real
awsglueimports —GlueContext,DynamicFrame,Job— via the official Glue runtime images - Apache Hudi support, S3 script locations, an optional Spark UI, and
.whldependency handling - stdout/stderr stream to
/aws-glue/jobs/outputand/aws-glue/jobs/errorin CloudWatch, like the real service
Walkthroughs:
- Run a Glue Spark job with Parquet on S3
- Use every Glue job option in one demo
- Use the EC2 browser terminal
- Run Lambda locally
┌─────────────────────────────────────────────────────────────┐
│ Your browser │
│ ↓ http://localhost:8080 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Mimir Web Console │ │
│ │ Services sidebar, region picker, resource tables │ │
│ │ API requests stay inside the local Mimir runtime │ │
│ └─────────────────────────────────────────────────────────┘ │
└──────────────────────────┬──────────────────────────────────┘
│
↓
┌──────────────────────┐
│ Mimir API Bridge │
│ │
│ • S3, DynamoDB, etc │ → backend :4566
│ • Glue execution │ → Docker daemon
│ • EC2 terminal bridge│ → docker exec
└──────────────────────┘
│
↓
┌──────────────────────────┐
│ Local AWS-compatible │
│ backend │
│ :4566 │
│ │
│ Real emulation of: │
│ • S3, DynamoDB, SQS, etc │
└──────────────────────────┘
One image starts everything: console, API bridge, and the AWS-compatible backend. Implementation details: Technical Architecture.
Run the Mimir Docker image and point your AWS CLI or SDK at http://localhost:4566. All 54 emulated services accept standard AWS API calls with local credentials (mimir/mimir) — no account, no sign-up, no internet after the initial pull.
Yes. Mimir is MIT-licensed and everything is free — including the services LocalStack gates behind its paid tiers (RDS, ECS, EKS, Cognito, Athena, Glue job execution) and a full web console.
Yes. Lambda functions run in real runtime containers with logs, versions, aliases, function URLs, and event source mappings (SQS, Kinesis, DynamoDB Streams). Create, invoke, and debug them from the console or the AWS CLI.
Yes — after the image (and any runtime images your services need) are pulled, everything runs on your machine with no AWS or internet access.
Yes. The image is multi-arch (linux/arm64 + linux/amd64), so it runs natively on Apple Silicon Macs, Intel/AMD machines, and Linux servers/CI.
No. Mimir is a local development and testing sandbox — build and iterate locally, then deploy to real AWS for production.
- Docker socket access is required for full functionality. Lambda, EC2, ECS, RDS, Glue and friends run as sibling containers. The console loads without it, but those runtimes cannot start.
- Glue needs Docker images. The first Glue/Spark run pulls a large runtime image — give it a minute.
- EC2 instances are local containers, named
mimir-ec2-<instance-id>. If a stale one holds a port:docker rm -f mimir-ec2-<id>. mimir-datais a named volume that persists buckets, tables, functions, jobs and all other state across restarts and upgrades.- It's a sandbox, not production. No promise of byte-for-byte AWS parity.
Mimir is an independent, open-source project. It is not affiliated with, endorsed by, or sponsored by Amazon Web Services. "AWS" and AWS service names are trademarks of Amazon.com, Inc. and appear here only to describe what Mimir emulates.
The local cloud backend is bundled in this repo, so the whole tool ships and runs as a single project.
MIT. Use it, fork it, build on it. No strings.
Building and maintaining Mimir takes time. If it's helping you test cloud infrastructure locally, consider supporting the project on Open Collective. Your support helps keep development going. ☕
See your cloud, before you ship your cloud.
