• Deploy any Docker image as a web service on AWS.
• Perfect for self-hosting tools like Uptime Kuma, Plausible, Metabase, n8n, or your own Docker containers.
• Includes optional PostgreSQL database — uncomment to enable.
• This project includes a pre-configured stacktape.yml configuration. The configured infrastructure is described in the stack description section

1. AWS account. If you don't have one, create new account here.

2. Stacktape account. If you don't have one, create new account here.

3. Stacktape installed.

iwr https://installs.stacktape.com/windows.ps1 -useb | iex

curl -L https://installs.stacktape.com/linux.sh | sh

curl -L https://installs.stacktape.com/macos.sh | sh

curl -L https://installs.stacktape.com/macos-arm.sh | sh

To initialize the project, use

stacktape init --starterId docker

The deployment will take ~5-15 minutes. Subsequent deploys will be significantly faster.

stacktape deploy --projectName <<project-name>> --stage <<stage>> --region <<region>>

stacktape codebuild:deploy --stage <<stage>> --region <<region>> --projectName <<project-name>>

After a successful deployment, some information about the stack will be printed to the terminal (URLs of the deployed services, links to logs, metrics, etc.).

• Open the Web Service URL printed to the terminal after deploy.
• To self-host a different app, change the image in stacktape.yml and adjust environment variables as needed.

To run the service in the development mode (locally on your machine), you can use the dev command.

stacktape dev --region <<your-region>> --stage <<stage>> --resourceName app

Stacktape runs the container as closely to the deployed version as possible:

• Maps container ports to the host machine.
• Injects parameters referenced in the environment variables by $ResourceParam and $Secret directives to the running container.
• Injects credentials of the assumed role to the container. This means that your locally running container will have the exact same IAM permissions as the deployed version.
• Pretty-prints logs (stdout/stderr) produced by the container to the terminal.

The container is rebuilt and restarted, when you either:

• type rs + enter to the terminal
• use the --watch option and one of your source code files changes

• Stacktape deployments use AWS CloudFormation under the hood. It brings a lot of guarantees and convenience, but can be slow for certain use-cases.

• To speed up the deployment, you can use the --hotSwap flag which avoids using Cloudformation.

• Hotswap deployments work only for source code changes (for lambda function, containers and batch jobs) and for content uploads to buckets.

• If the update deployment is not hot-swappable, Stacktape will automatically fall back to using a Cloudformation deployment.

stacktape deploy --hotSwap --stage <<stage>> --region <<region>> --projectName <<project-name>>

• If you no longer want to use your stack, you can delete it.
• Stacktape will automatically delete every infrastructure resource and deployment artifact associated with your stack.

stacktape delete --stage <<stage>> --region <<region>>

Stacktape uses a simple stacktape.yml configuration file to describe infrastructure resources, packaging, deployment pipeline and other aspects of your project.

You can deploy your project to multiple environments (stages) - for example production, staging or dev-john. A stack is a running instance of an project. It consists of your application code (if any) and the infrastructure resources required to run it.

The configuration for this project is described below.

• Every resource must have an arbitrary, alphanumeric name (A-z0-9).
• Stacktape resources consist of multiple underlying AWS or 3rd party resources.

The app resource runs any public Docker image as a managed web service using the prebuilt-image packaging type — no Dockerfile needed.

To self-host a different tool, swap the image property:

resources:
  app:
    type: web-service
    properties:
      packaging:
        type: prebuilt-image
        properties:
          # Change this to any Docker image:
          #   plausible/analytics:v2.1
          #   metabase/metabase:latest
          #   n8nio/n8n:latest
          image: louislam/uptime-kuma:1

Resource allocation is configured with resources. Increase these values for heavier workloads:

resources:
  cpu: 0.5
  memory: 1024

Pass runtime configuration to your container using environment. Adjust these to match the image you are deploying:

environment:
  - name: UPTIME_KUMA_PORT
    value: "3000"

A relational database section is included but commented out. Uncomment it to provision a managed PostgreSQL instance and connect it to the web service using connectTo:

# database:
#   type: relational-database
#   properties:
#     credentials:
#       masterUserPassword: $Secret('db-password', 'my_secret_password')
#     engine:
#       type: postgres
#       properties:
#         version: '16.6'
#         primaryInstance:
#           instanceSize: db.t3.micro

When uncommented, also uncomment the connectTo section on the web service so it can reach the database. Connection details (host, port, credentials) are automatically injected as environment variables.