Web console and dashboard for AWS Emulator, MiniStack, Floci, LocalStack, Moto and real AWS
50K+
An open-source web console for local AWS emulators and real AWS.
Browse, inspect, and manage what's running in AWS Emulator, MiniStack, Floci, LocalStack, Moto, or any AWS-compatible endpoint: a live dashboard and resource browser for 51 AWS services, an API Explorer for every operation, and guided lessons that teach AWS hands-on.
Local emulators give you AWS on your laptop. StackPort gives you a console to look at it with: a web UI and dashboard that works the same way whichever emulator you run. It's open source, runs locally with one command, and needs no AWS account. It can point at a real AWS account too, with a single setting to make it read-only.
| Emulator | Default endpoint | How StackPort connects | Quick start |
|---|---|---|---|
| AWS Emulator | https://127.0.0.1:9297 | HTTPS. Finds the keys and certificate the emulator writes to ~/.aws/emulator/<port>/ by itself, and the new ones after a restart | AWS Emulator |
| MiniStack | http://localhost:4566 | HTTP, any access key (test) | MiniStack |
| Floci | http://localhost:4566 | HTTP, any access key (test) | Floci |
| LocalStack | http://localhost:4566 | HTTP, any access key (test) | LocalStack |
| Moto | http://localhost:5000 | HTTP, any access key (test) | Moto |
| Any AWS-compatible endpoint, such as MinIO for S3 | Its URL | The keys it accepts | Other endpoints |
| Real AWS | AWS itself | Your credential chain or a profile (SSO, AssumeRole), optionally read-only | Real AWS |
MiniStack is StackPort's partner project: StackPort started as a web UI pull request to MiniStack, and the two projects work closely together. Otherwise StackPort is an independent open-source project, not affiliated with or endorsed by AWS or the other emulator projects, and it talks to every emulator the same way, through the standard AWS API.
STACKPORT_ALLOW_WRITES=falsestatus, list, describe, and export? to see them)pip install. Works with AWS Emulator, MiniStack, Floci, LocalStack, Moto, or any AWS-compatible endpoint![]() Dashboard: every service with live resource counts | ![]() Light mode: light, dark, or follow the system |
![]() S3: folders, upload, download, bucket settings | ![]() Lambda: config, aliases, versions, invoke |
![]() DynamoDB: scan, query, and edit items | ![]() Step Functions: state machine graph and execution timeline |
![]() SQS: send, receive, purge, dead-letter queues | ![]() KMS: keys, policies, grants, aliases |
![]() API Explorer: any operation boto3 knows, with a form, the response, and the same call as AWS CLI or boto3 | ![]() Guided lessons: hands-on steps checked against your live resources |
Install StackPort with pip install stackport or use the davireis/stackport Docker image, point AWS_ENDPOINT_URL at your emulator, and open http://localhost:8080. StackPort signs its requests like any AWS SDK. It finds AWS Emulator's own keys by itself, and MiniStack, Floci, LocalStack and Moto accept any keys, so their commands below pass test.
AWS Emulator, MiniStack and Floci also have a Docker Compose example that runs the emulator, StackPort, and a one-shot seed container. The seed creates a few resources (S3, SQS, SNS, DynamoDB, Secrets Manager, IAM, Logs, Step Functions) so the dashboard has something to show on first load. For another emulator, replace the emulator service and update AWS_ENDPOINT_URL.
AWS Emulator serves HTTPS on 127.0.0.1:9297 and, by default, only accepts requests signed with keys it creates. Its certificate and keys are new on every start, and it writes them to ~/.aws/emulator/<port>/. StackPort reads them from there, so there are no keys or certificate settings to pass, and it keeps working after the emulator restarts.
Start the emulator as in AWS's guide, on Linux or with Docker (which shares ~/.aws/emulator with your machine), then:
pip install stackport
AWS_ENDPOINT_URL=https://127.0.0.1:9297 stackport
# Open http://localhost:8080
To run both in Docker, use examples/docker-compose.aws-emulator.yml:
curl -O https://raw.githubusercontent.com/DaviReisVieira/stackport/main/examples/docker-compose.aws-emulator.yml
docker compose -f docker-compose.aws-emulator.yml up -d
# Open http://localhost:8080
# If the dashboard is empty: docker compose -f docker-compose.aws-emulator.yml logs seed
There is no prebuilt emulator image, so the first up builds one from the Dockerfile in AWS's guide. StackPort shares the emulator's network, because the certificate only covers localhost and loopback addresses, and reads the keys and certificate from a shared volume. The emulator keeps everything in memory, so a restart starts from an empty account. Embedded mode, where the emulator runs inside your tests, has no endpoint for StackPort to connect to.
MiniStack is StackPort's partner project (see Origin).
docker run -d -p 4566:4566 ministackorg/ministack # or: pip install ministack && ministack
pip install stackport
AWS_ENDPOINT_URL=http://localhost:4566 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test stackport
# Open http://localhost:8080
With Docker Compose, using examples/docker-compose.yml:
curl -O https://raw.githubusercontent.com/DaviReisVieira/stackport/main/examples/docker-compose.yml
docker compose up -d
# Open http://localhost:8080
# If the dashboard is empty: docker compose logs seed
MiniStack derives the URLs it returns (SQS queue URLs, pre-signed URLs) from the request Host, so they resolve from other containers and from the host without extra configuration.
docker run -d -p 4566:4566 floci/floci
pip install stackport
AWS_ENDPOINT_URL=http://localhost:4566 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test stackport
# Open http://localhost:8080
With Docker Compose, using examples/docker-compose.floci.yml:
curl -O https://raw.githubusercontent.com/DaviReisVieira/stackport/main/examples/docker-compose.floci.yml
docker compose -f docker-compose.floci.yml up -d
# Open http://localhost:8080
# If the dashboard is empty: docker compose -f docker-compose.floci.yml logs seed
Floci takes the hostname for the URLs it returns from FLOCI_HOSTNAME, which the example sets to floci so they resolve from other containers. From the host, reach the same resources through http://localhost:4566.
Floci can also start StackPort for you as its web console, at http://localhost:4566/_floci/ui: see Running a different console in Floci's README.
docker run -d -p 4566:4566 -e LOCALSTACK_AUTH_TOKEN=<your-token> localstack/localstack
pip install stackport
AWS_ENDPOINT_URL=http://localhost:4566 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test stackport
# Open http://localhost:8080
Recent LocalStack images ask for an auth token from your LocalStack account. If you start LocalStack with localstack start instead, the StackPort command is the same.
docker run -d -p 5000:5000 motoserver/moto # or: pip install "moto[server]" && moto_server
pip install stackport
AWS_ENDPOINT_URL=http://localhost:5000 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test stackport
# Open http://localhost:8080
Moto listens on port 5000. On macOS, AirPlay Receiver can hold that port: publish Moto on another one (-p 5001:5000) and use it in AWS_ENDPOINT_URL.
StackPort works with any endpoint that speaks the AWS API. Set AWS_ENDPOINT_URL and keys the endpoint accepts:
# MinIO (S3 only), with a MinIO access key
AWS_ENDPOINT_URL=http://localhost:9000 AWS_ACCESS_KEY_ID=<access-key> AWS_SECRET_ACCESS_KEY=<secret-key> stackport
# Any custom endpoint
AWS_ENDPOINT_URL=http://my-emulator:4566 AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test stackport
docker run -p 127.0.0.1:8080:8080 \
-e AWS_ENDPOINT_URL=http://host.docker.internal:4566 \
-e AWS_ACCESS_KEY_ID=test -e AWS_SECRET_ACCESS_KEY=test \
davireis/stackport
host.docker.internal is how a container reaches an emulator published on your machine under Docker Desktop. For AWS Emulator, use its Compose example instead: StackPort has to share the emulator's network and see its keys and certificate.
Leave AWS_ENDPOINT_URL unset and StackPort uses the standard AWS credential chain:
# Using an AWS profile
AWS_PROFILE=my-profile stackport
# Using explicit credentials
AWS_ACCESS_KEY_ID=AKIA... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-west-2 stackport
# Read-only: block every write from the UI and API
STACKPORT_ALLOW_WRITES=false AWS_PROFILE=my-profile stackport
An endpoint without a URL sends every request to AWS itself. Endpoint URLs set up for other AWS tools, in AWS_ENDPOINT_URL_<SERVICE> variables (like AWS_ENDPOINT_URL_S3) or in a profile's endpoint_url and services settings in ~/.aws/config, don't apply to StackPort. A profile still provides the credentials.
When connected to real AWS, StackPort shows a warning banner on every page. Writes stay enabled unless you set STACKPORT_ALLOW_WRITES=false, so use that whenever you only want to look. In read-only mode a lock appears in the top bar, and the only POST calls still allowed are the ones that read: DynamoDB queries, CloudWatch metric queries, Lambda invokes and Try it requests (both run your code, so keep that in mind on a live account), Bedrock playground prompts (billed per token on real AWS), and API Explorer operations that read.
Switch between endpoints from the UI. Configure named endpoints with STACKPORT_ENDPOINTS, or add them later from Settings:
# A local emulator and a real AWS account (empty URL = real AWS)
STACKPORT_ENDPOINTS="local=http://localhost:4566,nprod=" \
AWS_PROFILE=nprod AWS_REGION=us-west-1 stackport
Docker Compose (local + real AWS):
curl -O https://raw.githubusercontent.com/DaviReisVieira/stackport/main/examples/docker-compose.multi-endpoint.yml
docker compose -f docker-compose.multi-endpoint.yml up -d
# Open http://localhost:8080
See examples/docker-compose.multi-endpoint.yml for a full example with MiniStack + real AWS via profile.
The endpoint menu sits in the top navigation bar. Each endpoint is health-checked independently, and all API requests, caches, and WebSocket subscriptions are scoped to the active endpoint.
Each endpoint can use its own AWS authentication method, configured from the Settings page:
| Auth Type | Description | Use Case |
|---|---|---|
| Default | Uses AWS Emulator's own keys for an AWS Emulator endpoint, otherwise AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY env vars or instance role | Local emulators, EC2/ECS deployments |
| AWS Profile | Uses a named profile from ~/.aws/config | SSO, AssumeRole, multiple accounts |
| Static Credentials | Per-endpoint access key and secret | Service accounts, cross-account access |
Profile auth supports SSO, AssumeRole, and credential_process (anything boto3.Session(profile_name=...) handles). If your SSO token expires, StackPort returns a 401 with instructions to run aws sso login --profile <name>.
Docker users: mount your AWS config to use profiles inside the container:
services:
stackport:
image: davireis/stackport
volumes:
- ~/.aws:/root/.aws
HTTPS endpoints can also have their own certificate settings: a CA bundle to trust (a PEM file on the machine that runs StackPort), or certificate checks turned off. They are set per endpoint because AWS_CA_BUNDLE replaces the system certificates, so setting it for the whole process would break a real AWS endpoint configured next to an emulator. AWS Emulator needs neither when StackPort reaches it on 127.0.0.1 (on the same machine, or sharing its network as in the Compose example): StackPort trusts the certificate the emulator wrote to ~/.aws/emulator/<port>/ and, with the Default auth type, signs with the keys it wrote there.
You can test a connection before saving it with the "Test Connection" button in the add/edit endpoint dialog.
Settings shows what StackPort knows about the emulator behind the endpoint you're browsing: a link to its documentation, limits worth knowing before you run into them, and a reset when the emulator offers one. The connection test shows the same documentation link and limits.
| Emulator | Reset from Settings | Known limits |
|---|---|---|
| AWS Emulator | No: it keeps everything in memory, and restarting it starts empty | Requests up to 16 MiB; S3 holds at most 64 MiB and 1,000 objects per bucket, 128 MiB and 10,000 objects in all; Lambda runs Python and Node.js functions only |
| MiniStack | Yes, with POST /_ministack/reset | None known |
| Floci | Yes, with POST /_floci/state/reset | None known |
| LocalStack | No: the open-source image has no reset route | None known |
| Moto | Yes, with POST /moto-api/reset | None known |
To reset, type the endpoint's name to confirm. StackPort sends the emulator's own reset request to that endpoint's URL and clears its cached counts, so the dashboard reflects the reset straight away. Reset is never offered for real AWS, and read-only mode (STACKPORT_ALLOW_WRITES=false) refuses it. The S3 and Lambda limits also appear next to the S3 object list and the Lambda invoke and runtime settings.
| Service | Browse | Write operations |
|---|---|---|
| S3 | Buckets, objects, folder navigation, search | Create buckets and folders, upload, download, delete, batch delete; edit versioning, lifecycle, notifications, CORS, tags |
| DynamoDB | Tables, schema, items, scan and query, live item count | Create tables, add, edit and delete items, batch write |
| Lambda | Functions, config, aliases, versions, event sources | Invoke with a JSON payload, edit configuration, download code |
| SQS | Queues, messages, attributes | Create and delete queues, send (single or batch), receive, delete messages, purge, edit attributes and redrive policy |
| SNS | Topics, subscriptions | Create and delete topics, subscribe, unsubscribe, publish |
| EC2 | Instances, Auto Scaling groups, VPCs and subnets, security group rules, key pairs | Start, stop, reboot, terminate instances |
| CloudWatch Logs | Log groups, streams, events with time and pattern filters, live tail | Create and delete log groups, delete streams, set retention |
| Secrets Manager | Secrets with value reveal, rotation status | Create, update value and metadata, delete, restore |
| Step Functions | State machines with an ASL graph, executions, execution timeline | Start and stop executions |
| IAM | Users, roles, groups, policies, trust policies | Read-only |
| RDS | Instances, clusters, snapshots, parameter groups | Read-only |
| CloudWatch | Dashboards, alarms, metric charts | Read-only |
| KMS | Keys, key policies, grants, aliases | Read-only |
| Bedrock | Text foundation models, custom models | Playground: send a prompt to a model through Converse, with a system prompt, max tokens, temperature and top P. On real AWS it runs on your account and is billed per token |
Every other service uses a searchable resource table with a JSON detail view, tag editing where supported, pagination, and export to JSON or CSV.
The service views cover what StackPort knows about, and emulators implement much more. Open API Explorer in the sidebar (or press g e) to call any operation of any service boto3 knows against the selected endpoint, including services StackPort has no view for.
--endpoint-url (AWS Emulator's keys and certificate), the tabs show the shell setup to run first, the same as Learn does./explorer?service=sqs&operation=ListQueues open an operation directly, and the History menu keeps your last requests in this browser (values the API marks as sensitive, such as secret strings, are left out).Bytes that aren't text travel as {"$base64": "..."}, both in responses and in the parameters you send. Streamed responses (an S3 object, a Lambda invoke) show their first 1 MB, responses over 5 MB of JSON aren't shown, and operations that stream events can only be copied, not run.
In read-only mode the explorer only runs operations that read (Describe, Get, List and similar). Operations named like reads that create something or hand out credentials, tokens or passwords (sts GetSessionToken, ecr GetAuthorizationToken) count as writes; reading a stored value, such as a secret's value, stays a read, as it is in the console's views. The others stay visible so you can still build the request and copy it. On real AWS, and while StackPort can't yet tell whether the endpoint is AWS, operations that write ask for confirmation before they run.
Open Activity in the sidebar to see the API calls CloudTrail recorded (LookupEvents), newest first: the event name and source, who made the call, the resources it named, whether it only read, and the error code when it failed. Click an event to see its whole CloudTrail record, copy it or export it.
Content type
Image
Digest
sha256:f88e7f0ab…
Size
38.7 MB
Last updated
about 10 hours ago
docker pull davireis/stackport