Sign inSign up
stackport logo

davireis/stackport

By davireis

•Updated about 10 hours ago

Web console and dashboard for AWS Emulator, MiniStack, Floci, LocalStack, Moto and real AWS

Image
Developer tools
Web servers
1

50K+

davireis/stackport repository overview

StackPort logo

⁠StackPort

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.

CI PyPI Version Docker Pulls Docker Image Size License Python versions GitHub stars

StackPort demo: dashboard, S3 browser, and a guided lesson

⁠Why StackPort

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.

⁠Works with

EmulatorDefault endpointHow StackPort connectsQuick start
AWS Emulator⁠https://127.0.0.1:9297HTTPS. Finds the keys and certificate the emulator writes to ~/.aws/emulator/<port>/ by itself, and the new ones after a restartAWS Emulator⁠
MiniStack⁠http://localhost:4566HTTP, any access key (test)MiniStack⁠
Floci⁠http://localhost:4566HTTP, any access key (test)Floci⁠
LocalStack⁠http://localhost:4566HTTP, any access key (test)LocalStack⁠
Moto⁠http://localhost:5000HTTP, any access key (test)Moto⁠
Any AWS-compatible endpoint, such as MinIO for S3Its URLThe keys it acceptsOther endpoints⁠
Real AWSAWS itselfYour credential chain or a profile (SSO, AssumeRole), optionally read-onlyReal 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.

⁠Features

  • 51 AWS services discovered and counted on a live dashboard (WebSocket updates, pinned favorites, light and dark themes)
  • 14 dedicated service views: S3, DynamoDB, Lambda, SQS, SNS, IAM, EC2, RDS, CloudWatch Logs, CloudWatch metrics and alarms, Secrets Manager, KMS, Step Functions, and Bedrock with a model playground. Every other service gets a searchable resource table
  • Write operations in 9 of those views, from S3 uploads and DynamoDB item edits to SQS messages, Lambda invokes, EC2 start/stop, and Step Functions executions
  • API Explorer to call any operation of any service boto3 knows, with a form built from the API's own model and the same request ready to copy as an AWS CLI command or boto3 code
  • Activity: recent API calls from CloudTrail's event history, with who made them, what they touched and how they went
  • Try it for API Gateway stages and Lambda function URLs: send an HTTP request from the console and see the status, headers, body and timing
  • Connection details for databases, caches, search domains, Kafka brokers and queues: the address to use from your machine and a command to copy
  • Guided lessons that run inside the console and check your real resource state as you go
  • Real AWS and multiple endpoints, each with its own auth (default chain, AWS profile with SSO/AssumeRole, or static keys)
  • Read-only mode with STACKPORT_ALLOW_WRITES=false
  • Tags viewed and edited across 24 resource types
  • Export resource lists to JSON or CSV, and a CLI for status, list, describe, and export
  • Keyboard shortcuts for navigation (press ? to see them)
  • Single Docker image or pip install. Works with AWS Emulator⁠, MiniStack⁠, Floci⁠, LocalStack⁠, Moto⁠, or any AWS-compatible endpoint

⁠Screenshots

Dashboard in dark mode with service counts
Dashboard: every service with live resource counts
Dashboard in light mode
Light mode: light, dark, or follow the system
S3 file browser
S3: folders, upload, download, bucket settings
Lambda function view
Lambda: config, aliases, versions, invoke
DynamoDB items view
DynamoDB: scan, query, and edit items
Step Functions state machine graph
Step Functions: state machine graph and execution timeline
SQS queue view
SQS: send, receive, purge, dead-letter queues
KMS key view
KMS: keys, policies, grants, aliases
API Explorer running an SQS operation against AWS Emulator
API Explorer: any operation boto3 knows, with a form, the response, and the same call as AWS CLI or boto3
A guided lesson running inside the console
Guided lessons: hands-on steps checked against your live resources

⁠Quick Start

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

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

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.

⁠Floci
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.

⁠LocalStack
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.

⁠Moto
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.

⁠Other endpoints

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 (standalone)
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.

⁠Real AWS and multiple endpoints

⁠With real AWS

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.

⁠Multiple endpoints

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.

⁠Per-endpoint authentication

Each endpoint can use its own AWS authentication method, configured from the Settings page:

Auth TypeDescriptionUse Case
DefaultUses AWS Emulator's own keys for an AWS Emulator endpoint, otherwise AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY env vars or instance roleLocal emulators, EC2/ECS deployments
AWS ProfileUses a named profile from ~/.aws/configSSO, AssumeRole, multiple accounts
Static CredentialsPer-endpoint access key and secretService 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.

⁠Emulator details and reset

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.

EmulatorReset from SettingsKnown limits
AWS EmulatorNo: it keeps everything in memory, and restarting it starts emptyRequests 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
MiniStackYes, with POST /_ministack/resetNone known
FlociYes, with POST /_floci/state/resetNone known
LocalStackNo: the open-source image has no reset routeNone known
MotoYes, with POST /moto-api/resetNone 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 views

⁠Dedicated views (14 services)
ServiceBrowseWrite operations
S3Buckets, objects, folder navigation, searchCreate buckets and folders, upload, download, delete, batch delete; edit versioning, lifecycle, notifications, CORS, tags
DynamoDBTables, schema, items, scan and query, live item countCreate tables, add, edit and delete items, batch write
LambdaFunctions, config, aliases, versions, event sourcesInvoke with a JSON payload, edit configuration, download code
SQSQueues, messages, attributesCreate and delete queues, send (single or batch), receive, delete messages, purge, edit attributes and redrive policy
SNSTopics, subscriptionsCreate and delete topics, subscribe, unsubscribe, publish
EC2Instances, Auto Scaling groups, VPCs and subnets, security group rules, key pairsStart, stop, reboot, terminate instances
CloudWatch LogsLog groups, streams, events with time and pattern filters, live tailCreate and delete log groups, delete streams, set retention
Secrets ManagerSecrets with value reveal, rotation statusCreate, update value and metadata, delete, restore
Step FunctionsState machines with an ASL graph, executions, execution timelineStart and stop executions
IAMUsers, roles, groups, policies, trust policiesRead-only
RDSInstances, clusters, snapshots, parameter groupsRead-only
CloudWatchDashboards, alarms, metric chartsRead-only
KMSKeys, key policies, grants, aliasesRead-only
BedrockText foundation models, custom modelsPlayground: 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
⁠Generic resource browser (37 services)

Every other service uses a searchable resource table with a JSON detail view, tag editing where supported, pagination, and export to JSON or CSV.

⁠API Explorer

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.

  • Pick a service and an operation. The list comes from botocore's own models, with each operation's documentation and whether it reads or writes.
  • Fill in a form built from the operation's input: required fields first, dropdowns for enums, a key and value editor for maps, and JSON for nested structures. The JSON tab holds the whole request, and edits in either place show up in the other.
  • Run it and get the response as JSON with its HTTP status, request ID and duration. Errors come back with the endpoint's own status and message.
  • Paginated operations can follow up to 50 pages in one run, and "Fetch next page" continues where a run stopped.
  • The AWS CLI and Python (boto3) tabs show the same request as a command or code to copy. When the endpoint's emulator needs more than --endpoint-url (AWS Emulator's keys and certificate), the tabs show the shell setup to run first, the same as Learn does.
  • Links like /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.

⁠Activity

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.

  • Choose a time range (the last hour to start with) and a lookup attribute: event name, event source, user name, resource name or type, access key, event ID, or read-only. CloudTrail looks up one attribute per call, so it's one choice rather than a set of filters. The text box then searches the events already loaded, records included.
  • The page starts with calls that change something (read-only is false). Choose All events

Tag summary

Content type

Image

Digest

sha256:f88e7f0ab…

Size

38.7 MB

Last updated

about 10 hours ago

docker pull davireis/stackport