LocalStack

https://docs.localstack.cloud
Admin
LocalStack is a local cloud emulator that allows developers to build and test cloud applications,...
Tokens:502,479
Snippets:6,129
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone AWS SDK examples

Source: https://docs.localstack.cloud/aws/developer-tools/lambda-tools/hot-reloading

Initial setup to retrieve example Lambda functions.

```bash
cd /tmp
git clone git@github.com:awsdocs/aws-doc-sdk-examples.git
```

--------------------------------

### Start LocalStack with custom image

Source: https://docs.localstack.cloud/aws/developer-tools/security-testing/custom-tls-certificates

Configuration examples for starting LocalStack using the custom image via CLI, Docker, or Docker Compose.

```bash
IMAGE_NAME=<image name> localstack start
```

```bash
docker run <docker arguments> <image name>
```

```yaml
services:
  localstack:
    image: <image name>
    # the rest of your configuration
```

--------------------------------

### LocalStack startup output

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/localstack-cli

Example output displayed when starting LocalStack.

```text
   __                     _______ __             __
  / /   ____  _________ _/ / ___// /_____ ______/ /__
 / /   / __ \/ ___/ __ `/ /\** \/ **/ ** `/ _**/ //_/
/ /**_/ /_/ / /**/ /_/ / /**_/ / /_/ /_/ / /**/ ,<
/**_**/\_**_/\_**/\**,_/_//__**/\_**/\_**,_/\___/_/|_|


- LocalStack CLI 2026.7.0
- Profile: default
- App: https://app.localstack.cloud


[12:47:13] starting LocalStack in Docker mode 🐳 localstack.py:494
preparing environment bootstrap.py:1240
configuring container bootstrap.py:1248
starting container bootstrap.py:1258
[12:47:15] detaching bootstrap.py:1262
```

--------------------------------

### AppConfig Deployment Start Response

Source: https://docs.localstack.cloud/aws/services/appconfig

Example JSON response after starting an AppConfig deployment.

```json
{
    "ApplicationId": "400c285",
    "EnvironmentId": "3695ea3",
    "DeploymentStrategyId": "f2f2225",
    "ConfigurationProfileId": "7d748f9",
    "DeploymentNumber": 1,
    "ConfigurationName": "my-app-config",
    "ConfigurationLocationUri": "hosted",
    "ConfigurationVersion": "1",
    "Description": "My application deployment",
    "DeploymentDurationInMinutes": 0,
    "GrowthFactor": 1.0,
    "State": "BAKING",
    "EventLog": [
        {
            "EventType": "DEPLOYMENT_STARTED",
            "TriggeredBy": "USER",
            "Description": "Deployment started",
            "OccurredAt": "2023-08-28T11:18:43.273250Z"
        }
    ],
    "PercentageComplete": 0.0,
    "StartedAt": "2023-08-28T11:18:43.273250Z",
    "AppliedExtensions": []
}
```

--------------------------------

### Setup Development Environment on Apple Silicon

Source: https://docs.localstack.cloud/aws/customization/advanced/arm64-support

Commands to install dependencies for running LocalStack in host mode on ARM64 machines.

```bash
# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"


# Install java11 and follow instructions
brew install java11


# Install jenv and follow instructions
brew install jenv


# Add Java11 to jenv and use it globally
jenv add /Library/Java/JavaVirtualMachines/openjdk-11.jdk/Contents/Home/
jenv global 11


# Install pyenv and follow instructions
brew install pyenv


# Install python and enable it globally (check localstack/.python-version)
pyenv install 3.11.9
pyenv global 3.11.9
```

--------------------------------

### Start AppConfig Deployment

Source: https://docs.localstack.cloud/aws/services/appconfig

Starts a deployment of a configuration to an environment using a specified deployment strategy.

```bash
awslocal appconfig start-deployment \
    --application-id 400c285 \
    --environment-id 3695ea3 \
    --deployment-strategy-id f2f2225 \
    --configuration-profile-id 7d748f9 \
    --configuration-version 1 \
    --description "My application deployment"
```

--------------------------------

### Project-local configuration examples

Source: https://docs.localstack.cloud/azure/developer-tools/lstk

Examples of project-specific configurations using .lstk/config.toml for different emulator types and environments.

```toml

[[containers]]
type = "snowflake"
port = "4566"

```

```toml

[[containers]]
type = "aws"
tag  = "2026.4"
port = "4566"
env  = ["dev"]


[env.dev]
DEBUG = "1"
PERSISTENCE = "1"

```

--------------------------------

### Install Dependencies and Build

Source: https://docs.localstack.cloud/aws/developer-tools/lambda-tools/hot-reloading

Commands to install project dependencies and trigger the build process.

```bash
yarn install
```

```bash
yarn run build
```

--------------------------------

### Install QEMU/KVM on Debian/Ubuntu

Source: https://docs.localstack.cloud/aws/services/ec2

Install the necessary packages for KVM-accelerated virtualization on Debian or Ubuntu hosts.

```bash
sudo apt install -y qemu-kvm libvirt-daemon-system
```

--------------------------------

### Install a LocalStack extension

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/localstack-cli

Install an extension using a name or file path.

```bash
Usage: localstack extensions install [OPTIONS] NAME


  Install a LocalStack extension.


  This command installs a LocalStack extension, where the name can be any
  valid pip dependency identifier. Additionally, we support the installation
  of distribution files from disk, which you can indicate by a ``file://``
  prefix in the name


  Example invocations:
      localstack extensions install localstack-extension-stripe
      localstack extensions install "git+https://github.com/localstack/localstack-stripe.git#egg=localstack-stripe"
      localstack extensions install file://./dist/localstack-extension-hello-world-0.1.0.tar.gz
      localstack extensions install file://.  # assumes the current directory is a source distribution


Options:
  -h, --help  Show this message and exit.
```

--------------------------------

### Start LocalStack

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/serverless-framework

Run this command to start the LocalStack environment before deploying your Serverless service.

```bash
localstack start
```

--------------------------------

### Install an extension from a local file

Source: https://docs.localstack.cloud/aws/customization/integrations/extensions/managing-extensions

Installs a local Python wheel or source distribution file.

```bash
pip install file://./my-extensions/dist/my-extension-0.0.1.dev0.tar.gz
```

--------------------------------

### Install localstack-utils

Source: https://docs.localstack.cloud/aws/customization/integrations/localstack-sdks/testing-utils

Use pip to install the testing utilities package.

```bash
pip install localstack-utils
```

--------------------------------

### Clone and Navigate to Project

Source: https://docs.localstack.cloud/aws/tutorials/rds-database-initialization

Initial steps to retrieve the sample repository and enter the project directory.

```bash
git clone https://github.com/localstack-samples/sample-cdk-rds-database-initialization.git
cd sample-cdk-rds-database-initialization
```

--------------------------------

### Configure Travis CI job for LocalStack

Source: https://docs.localstack.cloud/aws/ci-pipelines/travis-ci

Example .travis.yaml configuration to install LocalStack, start the container in detached mode, and execute AWS commands.

```yaml
language: python


services:
    - docker


python:
  - "3.8"


before_install:
  # Install the LocalStack CLI and awslocal
  - python -m pip install localstack awscli-local[ver1]
  # Make sure to pull the latest version of the image
  - docker pull localstack/localstack
  # Start LocalStack in the background
  - localstack start -d
  # Wait 30 seconds for the LocalStack container to become ready before timing out
  - echo "Waiting for LocalStack startup..."
  - localstack wait -t 30
  - echo "Startup complete"


script:
  # Test LocalStack by creating a new S3 bucket (and verify that it has been created by listing all buckets)
  - awslocal s3 mb s3://test
  - awslocal s3 ls
  - echo "Execute your tests here :)"
```

--------------------------------

### Start LocalStack with Snapshot Options

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/lstk

Override or disable snapshot loading during the start command.

```bash
# Start and load a different snapshot for this run only
lstk start --snapshot pod:other-baseline


# Start without loading the configured snapshot
lstk start --no-snapshot
```

--------------------------------

### Start and restart server

Source: https://docs.localstack.cloud/azure/services/dbfor-postgresql

Commands to start the server or restart it to apply pending configuration changes.

```bash
az postgres flexible-server start \
  --resource-group rg-postgres-demo \
  --name postgres-demo


az postgres flexible-server restart \
  --resource-group rg-postgres-demo \
  --name postgres-demo
```

--------------------------------

### Deploy and Run DMS Sample

Source: https://docs.localstack.cloud/aws/services/dms

Use the provided Makefile commands to install dependencies, deploy the CDK stack, and execute the replication tasks.

```bash
# install dependencies
make install
# deploys cdk stack with all required resources (replication instances, tasks, endpoints)
make deploy
# starts the tasks
make run
```

--------------------------------

### Install Cross-Platform Emulation

Source: https://docs.localstack.cloud/aws/customization/advanced/arm64-support

Install the binfmt emulator to support running containers for different architectures.

```bash
docker run --privileged --rm tonistiigi/binfmt --install amd64
```

--------------------------------

### Deploy Application Preview with LocalStack Startup Action

Source: https://docs.localstack.cloud/aws/tutorials/ephemeral-application-previews

This step utilizes the 'LocalStack/setup-localstack/ephemeral/startup' action to deploy the application preview on an ephemeral LocalStack instance. It requires GitHub and LocalStack API keys and defines the commands to build and deploy the application, including frontend assets and CloudFront distribution.

```yaml
- name: Deploy Preview
  uses: LocalStack/setup-localstack/ephemeral/startup@v0.2.2
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    localstack-api-key: ${{ secrets.LOCALSTACK_API_KEY }}
    preview-cmd: |
        npm install -g aws-cdk-local aws-cdk
        pip install awscli-local[ver1]
        make build
        make bootstrap
        make deploy
        make prepare-frontend-local
        make build-frontend
        make bootstrap-frontend
        make deploy-frontend
        distributionId=$(awslocal cloudfront list-distributions | jq -r '.DistributionList.Items[0].Id')
        echo LS_PREVIEW_URL=$AWS_ENDPOINT_URL/cloudfront/$distributionId/ >> $GITHUB_ENV
```

--------------------------------

### Start LocalStack in CircleCI

Source: https://docs.localstack.cloud/aws/ci-pipelines/circleci

Configures a CircleCI job to install the LocalStack CLI, start the service, and run tests.

```yaml
version: '2.1'
orbs:
  python: circleci/python@4.0.0
jobs:
  localstack-test:
    machine:
      image: ubuntu-2204:current
    steps:
      - checkout
      - run:
          name: Install LocalStack CLI and awslocal
          command: |
            python3 -m pip install --user --upgrade pip
            python3 -m pip install --user localstack awscli-local[ver1]
            echo 'export PATH=$HOME/.local/bin:$PATH' >> "$BASH_ENV"
      - run:
          name: Start LocalStack
          command: |
            source "$BASH_ENV"
            docker pull localstack/localstack:latest
            localstack start -d
            localstack wait -t 60
      - run:
          name: Test LocalStack
          command: |
            awslocal s3 mb s3://test-bucket
            awslocal s3 ls
workflows:
  localstack-test:
    jobs:
      - localstack-test
```

```yaml
version: '2.1'
orbs:
  python: circleci/python@4.0.0
jobs:
  localstack-test:
    machine:
      image: ubuntu-2204:current
    steps:
      - checkout
      - run:
          name: Install LocalStack CLI and awslocal
          command: |
            python3 -m pip install --user --upgrade pip
            python3 -m pip install --user localstack awscli-local[ver1]
            echo 'export PATH=$HOME/.local/bin:$PATH' >> "$BASH_ENV"
      - run:
          name: Start LocalStack in background
          command: |
            source "$BASH_ENV"
            docker pull localstack/localstack:latest
            localstack start -d
      - run:
          name: Execute setup and tests
          command: |
            source "$BASH_ENV"
            localstack wait -t 60
            awslocal sqs create-queue --queue-name test-queue
            awslocal sqs list-queues
workflows:
  localstack-test:
    jobs:
      - localstack-test
```

--------------------------------

### Create App Service Plan and Web App

Source: https://docs.localstack.cloud/azure/services/managed-identity

Initializes the infrastructure required for hosting the web application.

```bash
az appservice plan create \
  --name asp-doc77 \
  --resource-group rg-managedidentity-demo \
  --location westeurope \
  --sku F1


az webapp create \
  --name ls-app-doc77 \
  --resource-group rg-managedidentity-demo \
  --plan asp-doc77 \
  --runtime "PYTHON:3.11"
```

--------------------------------

### View initialization logs

Source: https://docs.localstack.cloud/snowflake/capabilities/init-hooks

Example log output showing the execution of SQL queries from the initialization hook.

```text
DEBUG --- [et.reactor-0] s.analytics.handler        : REQ: POST /queries/v1/query-request {"sqlText": "CREATE DATABASE foobar123", ...
DEBUG --- [et.reactor-0] s.analytics.handler        : REQ: POST /queries/v1/query-request {"sqlText": "CREATE DATABASE test123", ...
DEBUG --- [et.reactor-0] s.analytics.handler        : REQ: POST /queries/v1/query-request {"sqlText": "SHOW DATABASES", ...
```

--------------------------------

### Execute setup script

Source: https://docs.localstack.cloud/snowflake/tutorials/s3-tables-iceberg-integration

Command to run the Python script and the expected output.

```bash
python setup_s3_tables.py
```

```text
Created table: my_namespace.customer_orders
Inserted sample data into table
Tables in namespace: [('my_namespace', 'customer_orders')]
```

--------------------------------

### Configure LocalStack in Travis CI

Source: https://docs.localstack.cloud/aws/getting-started/ci-cd

Installs LocalStack and starts it in the background during the before_install phase.

```yaml
language: python


services:
  - docker


python:
  - "3.8"


before_install:
  - python -m pip install localstack awscli-local[ver1]
  - docker pull localstack/localstack
  - localstack start -d
  - localstack wait -t 30
```

--------------------------------

### Replication job output format

Source: https://docs.localstack.cloud/aws/developer-tools/aws-replicator

Example JSON response returned after starting a replication job.

```json
1
{
2
  "job_id": "50005865-1589-4f6d-a720-c86f5a5dd021",
3
  "state": "TESTING_CONNECTION",
4
  "resources": {"succeeded": [], "failed": [], "skipped": []},
5
  "error_message": null,
6
  "type": "SINGLE_RESOURCE",
7
  "explore_strategy": "SIMPLE"
8
}
```

--------------------------------

### Configure LocalStack in CircleCI

Source: https://docs.localstack.cloud/aws/getting-started/ci-cd

Requires manual installation of localstack and awscli-local via pip before starting the service.

```yaml
version: '2.1'
orbs:
  python: circleci/python@4.0.0
jobs:
  localstack-test:
    machine:
      image: ubuntu-2204:current
    steps:
      - checkout
      - run:
          name: Install lstk and awslocal
          command: |
            python3 -m pip install --user --upgrade pip
            python3 -m pip install --user localstack awscli-local[ver1]
            echo 'export PATH=$HOME/.local/bin:$PATH' >> "$BASH_ENV"
      - run:
          name: Start LocalStack
          command: |
            source "$BASH_ENV"
            docker pull localstack/localstack:latest
            localstack start -d
            localstack wait -t 60
```

--------------------------------

### Configure and start with LocalStack CLI

Source: https://docs.localstack.cloud/aws/getting-started/auth-token

Sets the authentication token in the local configuration before starting the LocalStack service.

```bash
localstack auth set-token <YOUR_AUTH_TOKEN>
localstack start
```

--------------------------------

### Start React Frontend

Source: https://docs.localstack.cloud/aws/tutorials/terraform-shipment-app-guide

Navigate to the frontend directory and start the React development server. Access the UI at http://localhost:3000.

```bash
cd shipment-list-frontend
npm start
```

--------------------------------

### License activation error message

Source: https://docs.localstack.cloud/snowflake/getting-started/auth-token

Example of the error output when the emulator fails to start due to invalid credentials.

```text
===============================================
License activation failed!


Reason: The credentials defined in your environment are invalid. Please make sure to set the LOCALSTACK_AUTH_TOKEN variable to a valid auth token. You can find your Auth Token in the LocalStack web app https://app.localstack.cloud.


Due to this error, LocalStack has quit. The Snowflake emulator can only be used with a valid license.
```

--------------------------------

### Configure BitBucket Pipeline for LocalStack

Source: https://docs.localstack.cloud/aws/ci-pipelines/bitbucket

Example configuration for bitbucket-pipelines.yaml to start LocalStack and run AWS CLI commands.

```yaml
image: python:3.9


definitions:
  services:
    docker:
      memory: 2048


pipelines:
  default:
    - step:
        name: Test Localstack
        services:
          - docker
        script:
          - export PYTHONPATH=$PYTHONPATH:$(pwd)
          - export DOCKER_SOCK=$DOCKER_HOST
          - export AWS_ENDPOINT_URL="http://localhost.localstack.cloud:4566"
          - env
          - echo "${BITBUCKET_DOCKER_HOST_INTERNAL} localhost.localstack.cloud " >> /etc/hosts
          - pip install localstack awscli-local
          - |
            curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
            unzip awscliv2.zip
            ./aws/install
          - docker run -d --rm -p 4566:4566 -p 4510-4559:4510-4559 -e DOCKER_SOCK=tcp://${BITBUCKET_DOCKER_HOST_INTERNAL}:2375 -e DOCKER_HOST=tcp://${BITBUCKET_DOCKER_HOST_INTERNAL}:2375 --name localstack-main localstack/localstack
          - localstack wait -t 60
          - awslocal s3 mb s3://test-bucket
          - awslocal s3 ls
```

--------------------------------

### Start LocalStack

Source: https://docs.localstack.cloud/aws/tutorials/lambda-ecr-container-images

Initialize LocalStack with ECR emulation enabled. Replace <your-auth-token> with your valid token.

```bash
LOCALSTACK_AUTH_TOKEN=<your-auth-token> ECR_ENDPOINT_STRATEGY=off DEBUG=1 localstack start -d
```

--------------------------------

### Start the Azure emulator

Source: https://docs.localstack.cloud/azure/getting-started/quickstart

Initializes the local Azure emulator environment.

```bash
$ lstk start
```

--------------------------------

### Verify LocalStack Auth Token Setup

Source: https://docs.localstack.cloud/aws/ci-pipelines/circleci

Example configuration for verifying that the LOCALSTACK_AUTH_TOKEN is correctly picked up by the LocalStack container.

```yaml
version: '2.1'
orbs:
  python: circleci/python@4.0.0
jobs:
  localstack-test:
    machine:
      image: ubuntu-2204:current
    steps:
      - checkout
      - run:
          name: Install LocalStack CLI and awslocal
          command: |
            python3 -m pip install --user --upgrade pip
            python3 -m pip install --user localstack awscli-local[ver1]
            echo 'export PATH=$HOME/.local/bin:$PATH' >> "$BASH_ENV"
      - run:
          name: Start LocalStack
          command: |
            source "$BASH_ENV"
            docker pull localstack/localstack:latest
            localstack start -d
            localstack wait -t 60
      - run:
          name: Verify LocalStack setup
          command: localstack logs | rg "activated|auth token|ready"
workflows:
  localstack-test:
    jobs:
      - localstack-test
```

--------------------------------

### Start Workflow Execution Output

Source: https://docs.localstack.cloud/aws/services/swf

Example output from the StartWorkflowExecution API, containing the unique run ID for the new execution.

```json
{
    "runId": "0602601afc71403abb934d8094c51668"
}
```

--------------------------------

### Create and Inspect a SQL Server

Source: https://docs.localstack.cloud/azure/services/sql

Commands to provision a logical SQL server and retrieve its configuration details.

```bash
az sql server create \
  --name sqlsrvdoc85 \
  --resource-group rg-sql-demo \
  --location westeurope \
  --admin-user lsadmin \
  --admin-password "LocalstackSqlPassw0rd"
```

```json
{
  "administratorLogin": "lsadmin",
  ...
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-sql-demo/providers/Microsoft.Sql/servers/sqlsrvdoc85",
  ...
  "location": "westeurope",
  ...
  "name": "sqlsrvdoc85",
 ...
  "type": "Microsoft.Sql/servers",
 ...
}
```

```bash
az sql server show --name sqlsrvdoc85 --resource-group rg-sql-demo
```

```json
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-sql-demo/providers/Microsoft.Sql/servers/sqlsrvdoc85",
  "name": "sqlsrvdoc85",
  "location": "westeurope",
  "state": "Ready",
  "publicNetworkAccess": "Enabled",
  "type": "Microsoft.Sql/servers",
  ...
}
```

--------------------------------

### Set Up Python Virtual Environment and Install Dependencies

Source: https://docs.localstack.cloud/aws/tutorials/serverless-quiz-app

Create a Python virtual environment and install the necessary development dependencies for the project. This ensures a consistent development environment.

```bash
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install -r tests/requirements-dev.txt
```

--------------------------------

### S3 Bucket Resource Description

Source: https://docs.localstack.cloud/aws/services/cloudcontrol

Example output when listing or getting an S3 bucket resource using the Cloud Control API.

```json
{
    "ResourceDescriptions": [
        {
            "Identifier": "my-bucket",
            "Properties": "{\"BucketName\":\"my-bucket\"}"
        }
    ],
    "TypeName": "AWS::S3::Bucket"
}
```

--------------------------------

### Install Serverless Framework Globally

Source: https://docs.localstack.cloud/aws/tutorials/elb-load-balancing

Installs the Serverless framework globally using npm. This is the first step to using the framework.

```bash
npm install -g serverless
```

--------------------------------

### CloudWatch Get Log Events Response

Source: https://docs.localstack.cloud/aws/services/cloudwatch

Example JSON response from the `get-log-events` command, displaying the log messages and associated metadata.

```json
{
    "events": [
        {
            "timestamp": 1683009968920,
            "message": "START RequestId: 71712856-9f41-4d22-827c-e3883f799f25 Version: $LATEST",
            "ingestionTime": 1683009968979
        },
        {
            "timestamp": 1683009968932,
            "message": "END RequestId: 71712856-9f41-4d22-827c-e3883f799f25",
            "ingestionTime": 1683009968979
        },
        {
            "timestamp": 1683009968945,
            "message": "REPORT RequestId: 71712856-9f41-4d22-827c-e3883f799f25\tDuration: 1.27 ms\tBilled Duration: 2 ms\tMemory Size: 1024 MB\tMax Memory Used: 1024 MB\t",
            "ingestionTime": 1683009968979
        }
    ],
    "nextForwardToken": "f/00000000000000000000000000000000000000000000000000000002",
    "nextBackwardToken": "b/00000000000000000000000000000000000000000000000000000000"
}
```

--------------------------------

### Configure devcontainer.json for LocalStack

Source: https://docs.localstack.cloud/aws/customization/other-installations/devcontainers

Example configuration for a LocalStack DinD setup, including environment variables, required features, and volume mounts.

```json
{
 "name": "LocalStack DinD setup",
 "image": "mcr.microsoft.com/devcontainers/base:bullseye",


 "remoteEnv": {
  // Activate LocalStack for AWS: https://docs.localstack.cloud/getting-started/auth-token/
  "LOCALSTACK_AUTH_TOKEN": "${localEnv:LOCALSTACK_AUTH_TOKEN}",  // required for Pro, not processed via template due to security reasons
  "LOCALSTACK_API_KEY": "${localEnv:LOCALSTACK_API_KEY}",
  // LocalStack configuration: https://docs.localstack.cloud/references/configuration/
  "DEBUG": true,
  "LS_LOG": "debug",
  "PERSISTENCE": false,
  "AWS_ENDPOINT_URL": "http://localhost.localstack.cloud:4566",
  "AUTO_LOAD_POD": " ",
  "ENFORCE_IAM": false,
  "AWS_REGION": "us-east-1",
  "AWS_DEFAULT_REGION": "us-east-1",
  "IMAGE_NAME": "localstack/localstack-pro:latest",
  "LOCALSTACK_VOLUME_DIR": "/data"
 },


 // 👇 Features to add to the Dev Container.
 // More info: https://containers.dev/implementors/features.
 "features": {
  "ghcr.io/devcontainers/features/docker-in-docker:2": {},
  "ghcr.io/localstack/devcontainer-feature/localstack-cli:latest": {
   "version": "latest",
   "awslocal": true,  // if true, add in features manually: ghcr.io/devcontainers/features/aws-cli
   "cdklocal": false,  // if true, add in features manually: ghcr.io/devcontainers-contrib/features/aws-cdk
   "pulumilocal": false,  // if true, add in features manually: ghcr.io/devcontainers-contrib/features/pulumi
   "samlocal": false,  // if true, add in features manually: ghcr.io/customink/codespaces-features/sam-cli
   "tflocal": false  // if true, add in features manually: ghcr.io/devcontainers-contrib/features/terraform-asdf
  },
  "ghcr.io/devcontainers/features/aws-cli:1": {}
 },


 // 👇 Use 'postCreateCommand' to run commands after the container is created.
 "postCreateCommand": "type localstack; true && localstack start -d || true",
 "mounts": [
  {
   // to persist build data and images
   "source": "dind-var-lib-docker",
   "target": "/var/lib/docker",
   "type": "volume"
  },
  {
   "source": "./.volume",
   "target": "/data",
   "type": "bind",
   "consistency": "cached"
  }
 ]
}
```

--------------------------------

### Initialize Node.js Project

Source: https://docs.localstack.cloud/aws/developer-tools/lambda-tools/hot-reloading

Create a new Node.js project using npm.

```bash
npm init -y
```

--------------------------------

### API Gateway v2 Get APIs Response

Source: https://docs.localstack.cloud/aws/services/apigateway

Example response from the `awslocal apigatewayv2 get-apis` command, showing WebSocket API details.

```json
{
    "Items": [{
        "ApiEndpoint": "ws://localhost:4510",
        "ApiId": "129ca37e",
        ...
    }]
}

```

--------------------------------

### Get Cost Anomaly Monitors

Source: https://docs.localstack.cloud/aws/services/ce

Retrieves a list of all created cost anomaly monitors. Use this to view, manage, or verify your anomaly detection setup.

```bash
awslocal ce get-anomaly-monitors
```

```json
{
    "AnomalyMonitors": [
        {
            "MonitorArn": "arn:aws:ce::000000000000:anomalymonitor/22570ff3",
            "MonitorName": "mon5463",
            "MonitorType": "DIMENSIONAL"
        }
    ]
}
```

--------------------------------

### Create, Bootstrap, and Deploy Sample CDK App

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/aws-cdk

Generates a sample CDK application, bootstraps the LocalStack environment, and deploys the application. Requires LocalStack to be running.

```bash
# create sample app
mkdir /tmp/test; cd /tmp/test
cdklocal init sample-app --language=javascript


# bootstrap localstack environment
cdklocal bootstrap


# deploy the sample app
cdklocal deploy
> Do you wish to deploy these changes (y/n)? y
```

--------------------------------

### Retrieve Product via API Gateway

Source: https://docs.localstack.cloud/aws/tutorials/cloud-pods-collaborative-debugging

Attempts to retrieve a specific product using a GET request, which triggers an internal server error in the example scenario.

```bash
curl --location "http://$rest_api_id.execute-api.localhost.localstack.cloud:4566/dev/productApi?id=34534"
```

--------------------------------

### Verify Initialization Script Logs

Source: https://docs.localstack.cloud/aws/customization/advanced/initialization-hooks

Example log output showing discovered and running initialization scripts when DEBUG=1 is enabled.

```text
... 
Init scripts discovered: {BOOT: [], START: [], READY: [Script(path='/etc/localstack/init/ready.d/setup.sh', stage=READY, state=UNKNOWN)], SHUTDOWN: []} 
... 
Running READY script /etc/localstack/init/ready.d/setup.sh 
...
```

--------------------------------

### Start LocalStack with Terraform Init Hook

Source: https://docs.localstack.cloud/aws/tutorials/using-terraform-with-testcontainers-and-localstack

Starts LocalStack, automatically installs the Terraform init extension, and mounts a Terraform configuration file to be used as an initialization hook. This command ensures Terraform and tflocal are available within the container and enables the init hook runners to detect Terraform files.

```bash
export LOCALSTACK_AUTH_TOKEN=<your_auth_token>
localstack start -e EXTENSION_AUTO_INSTALL=localstack-extension-terraform-init \
    -v ./terraform/main.tf:/etc/localstack/init/
```

--------------------------------

### Get Document Text Detection Job Status and Results

Source: https://docs.localstack.cloud/aws/services/textract

Retrieve the status and results of an asynchronous document text detection job using the GetDocumentTextDetection API. Requires the JobId obtained from the start command.

```bash
awslocal textract get-document-text-detection \
    --job-id "501d7251-1249-41e0-a0b3-898064bfc506"
```

```json
{
    "DocumentMetadata": {
        "Pages": {
            "Pages": 389
        }
    },
    "JobStatus": "SUCCEEDED",
    "Blocks": [],
    "DetectDocumentTextModelVersion": "1.0"
}
```

--------------------------------

### Create a Table

Source: https://docs.localstack.cloud/snowflake/features/data-metric-functions

Creates a sample 'customers' table with 'id', 'name', and 'email' columns. This table will be used to demonstrate Data Metric Functions.

```sql
CREATE TABLE customers (
    id NUMBER,
    name STRING,
    email STRING
);
```

--------------------------------

### Create S3 Bucket and Configure for Website Hosting

Source: https://docs.localstack.cloud/aws/services/route53

Sets up an S3 bucket for static website hosting, including creating the bucket, uploading files, configuring website settings, and setting a public read access policy using LocalStack.

```bash
DOMAIN="example.com"
BUCKET_NAME="$DOMAIN"


# Create the bucket
awslocal s3api create-bucket --bucket "$BUCKET_NAME"


# Upload your website files
awslocal s3 cp index.html s3://$BUCKET_NAME/
awslocal s3 cp error.html s3://$BUCKET_NAME/


# Configure the bucket for website hosting
awslocal s3 website s3://"$BUCKET_NAME"/ \
    --index-document index.html \
    --error-document error.html


# Set bucket policy to allow public read access
awslocal s3api put-bucket-policy \
    --bucket $BUCKET_NAME \
    --policy '{ 
        "Version": "2012-10-17",
        "Statement": [{
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::'$BUCKET_NAME'/*"
        }]
    }'
```

--------------------------------

### Install and Verify pulumilocal

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/pulumi

Install the wrapper script via pip and verify the installation.

```bash
pip install pulumi-local
```

```bash
pulumilocal --help
```

```text
Pulumi - Modern Infrastructure as Code
...
```

--------------------------------

### lstk start

Source: https://docs.localstack.cloud/azure/developer-tools/lstk

Starts the LocalStack emulator. Running 'lstk' without arguments is equivalent to 'lstk start'.

```APIDOC
## lstk start

### Description
Starts the LocalStack emulator. Launches the TUI in interactive terminals and prints plain output otherwise.

### Parameters
- **--persist** (flag) - Optional - Persist emulator state across restarts.
- **--type, -t** (string) - Optional - Select the emulator to start (aws, snowflake, or azure).
- **--snapshot** (string) - Optional - Auto-load a specific snapshot after the emulator starts (AWS only).
- **--no-snapshot** (flag) - Optional - Skip auto-loading the configured snapshot.
- **--timeout** (string) - Optional - Maximum time to wait for the emulator to become ready (e.g., 90s, 2m).
- **--non-interactive** (flag) - Optional - Disable the interactive TUI and use plain output.
```

--------------------------------

### Create project files

Source: https://docs.localstack.cloud/aws/tutorials/lambda-ecr-container-images

Initialize the handler and Dockerfile within the project directory.

```bash
touch handler.py Dockerfile
```

--------------------------------

### Initialize Podman on Windows

Source: https://docs.localstack.cloud/aws/customization/other-installations/podman

Commands to initialize and start the Podman machine on Windows via WSLv2.

```bash
podman machine init
podman machine start
```

--------------------------------

### Install Go Snowflake Driver

Source: https://docs.localstack.cloud/snowflake/integrations/snowflake-drivers

Use this command to install the Go Snowflake driver. Ensure you have Go installed and configured.

```bash
go get github.com/snowflakedb/gosnowflake
```

--------------------------------

### List Support Cases

Source: https://docs.localstack.cloud/aws/services/support

Use this command to list all support cases. This example filters cases in the 'General guidance' category.

```bash
awslocal support describe-cases
```

--------------------------------

### Install Crossplane AWS SQS Provider

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/crossplane

Installs the Crossplane AWS provider for SQS. This follows the same pattern as installing the S3 provider.

```yaml
cat <<EOF | kubectl apply -f -
apiVersion: pkg.crossplane.io/v1
kind: Provider
metadata:
  name: provider-aws-sqs
spec:
  package: xpkg.upbound.io/upbound/provider-aws-sqs:v0.40.0
EOF

```

--------------------------------

### Verify Crossplane Installation

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/crossplane

Checks the installed Crossplane version. This command helps confirm that the Crossplane CLI tool has been installed correctly.

```bash
crossplane version
```

--------------------------------

### Initialize a new Gradle project

Source: https://docs.localstack.cloud/aws/customization/integrations/app-frameworks/spring-cloud-function

Run this command to initialize a new Gradle project structure.

```bash
gradle init
```

--------------------------------

### Verify Crossplane Provider Installation

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/crossplane

Checks the health and status of installed Crossplane providers. Use this command after installing providers to confirm they are healthy.

```bash
kubectl get providers

```

--------------------------------

### Deploy the application

Source: https://docs.localstack.cloud/aws/tutorials/rds-database-initialization

Commands to deploy the sample application infrastructure using CDK.

```bash
make deploy
# or manually:
cdklocal deploy
```

--------------------------------

### Emulator Instance Summary Output

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/lstk

Example output showing the status and details of a running AWS emulator.

```text
LocalStack AWS Emulator is running
• Endpoint: localhost:4566
• Persistence: Enabled
• Container: localstack-aws
• Version: 4.0.0
• Uptime: 1h 12m 4s
```

--------------------------------

### Install AWS CDK Local Globally

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/aws-cdk

Installs the `aws-cdk-local` and `aws-cdk` npm packages globally. Ensure both are installed globally for proper functioning.

```bash
# Install globally
npm install -g aws-cdk-local aws-cdk


# Verify it installed correctly
cdklocal --version
# e.g. 1.65.5
```

--------------------------------

### Start LocalStack

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/localstack-cli

Command to start the LocalStack service.

```bash
localstack start # start localstack in background with -d flag
```

--------------------------------

### List installed extensions

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/localstack-cli

List all currently installed extensions.

```bash
Usage: localstack extensions list [OPTIONS]


  List installed extension.


  The environment variable `LOCALSTACK_VOLUME_DIR` currently defaults to
  ~/.cache/localstack, where the extension environment will be installed into
  ./lib/extensions/


Options:
  -h, --help  Show this message and exit.
```

--------------------------------

### Initialize Lambda project directory

Source: https://docs.localstack.cloud/aws/tutorials/lambda-ecr-container-images

Create and navigate to a new directory for the Lambda container project.

```bash
mkdir -p lambda-container-image
cd lambda-container-image
```

--------------------------------

### Create a Launch Template

Source: https://docs.localstack.cloud/aws/services/autoscaling

Use the `CreateLaunchTemplate` API to define the configuration for instances within an Auto Scaling group. This example creates a basic launch template with a specified image ID and instance type.

```bash
awslocal ec2 create-launch-template \
    --launch-template-name my-template-for-auto-scaling \
    --version-description version1 \
    --launch-template-data '{"ImageId":"ami-ff0fea8310f3","InstanceType":"t2.micro"}'
```

```json
{
    "LaunchTemplate": {
        "LaunchTemplateId": "lt-5ccdf1a84f178ba44",
        "LaunchTemplateName": "my-template-for-auto-scaling",
        "CreateTime": "2024-07-12T07:59:08+00:00",
        "CreatedBy": "arn:aws:iam::000000000000:root",
        "DefaultVersionNumber": 1,
        "LatestVersionNumber": 1,
        "Tags": []
    }
}
```

--------------------------------

### Verify LocalStack CLI installation

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/localstack-cli

Check the installed version of the CLI.

```bash
localstack --version
2026.7.0
```

--------------------------------

### Initialize LocalStack MCP Server

Source: https://docs.localstack.cloud/aws/getting-started/ai-workflows

Command to launch the interactive setup wizard for the LocalStack MCP server.

```bash
npx -y @localstack/localstack-mcp-server init
```

--------------------------------

### FIS Start Experiment Output

Source: https://docs.localstack.cloud/aws/services/fis

The response returned after starting an experiment.

```json
{
    "experiment": {
        "id": "efee7c02-8733-4d7c-9628-1b60bbec9759",
        "experimentTemplateId": "ad16589a-4a91-4aee-88df-c33446605882",
        "roleArn": "arn:aws:iam:123456789012:role/ExperimentRole",
        "state": {
            "status": "running"
        },
        "targets": {
            "InstancesToStop": {
                "resourceType": "aws:ec2:instance",
                "resourceTags": {
                    "foo": "bar"
                },
                "selectionMode": "COUNT(1)"
            }
        },
        "actions": {
            "StopInstance": {
                "actionId": "aws:ec2:stop-instances",
                "description": "stop instances",
                "targets": {
                    "Instances": "InstancesToStop"
                }
            }
        },
        "stopConditions": [
            {
                "source": "none"
            }
        ],
        "creationTime": 1718268311.209798,
        "startTime": 1718268311.209798
    }
}
```

--------------------------------

### Create Project Directory and WWW Subdirectory

Source: https://docs.localstack.cloud/aws/tutorials/s3-static-website-terraform

Sets up the necessary directory structure for the static website project, including a 'www' subdirectory for website content.

```bash
mkdir -p s3-static-website-localstack/www
cd s3-static-website-localstack
```

--------------------------------

### Verify lstk installation

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/lstk

Checks the currently installed version of the lstk CLI.

```bash
lstk --version
```

--------------------------------

### Configure per-service profiles

Source: https://docs.localstack.cloud/aws/customization/kubernetes/pod-configuration

Example configuration showing how to map services to specific profiles and handle architecture-based workload routing.

```json
{
  "profiles": {
    "default": {
      "nodeSelector": {
        "pool": "general"
      }
    },
    "defaultAmd64": {
      "nodeSelector": {
        "pool": "amd-nodes"
      }
    },
    "lambda-arm": {
      "nodeSelector": {
        "pool": "lambda-arm-nodes"
      },
      "resources": {
        "requests": {
          "cpu": "500m",
          "memory": "512Mi"
        },
        "limits": {
          "cpu": "2",
          "memory": "2Gi"
        }
      }
    },
    "ecs-tasks": {
      "nodeSelector": {
        "pool": "ecs-nodes"
      }
    }
  },
  "services": {
    "lambda": {
      "arm64": "lambda-arm"
    },
    "ecs": {
      "profile": "ecs-tasks"
    }
  }
}
```

--------------------------------

### Initialize Architect project directory

Source: https://docs.localstack.cloud/aws/customization/integrations/app-frameworks/architect

Create a new directory and initialize a standard Architect project structure.

```bash
mkdir architect_quickstart && cd architect_quickstart
```

```bash
arclocal init
```

--------------------------------

### Initialize Project and Install Dependencies

Source: https://docs.localstack.cloud/aws/tutorials/elb-load-balancing

Initializes a Node.js project and installs necessary Serverless plugins for LocalStack integration and deployment bucket management as development dependencies.

```bash
npm init -y
npm install -D serverless serverless-localstack serverless-deployment-bucket
```

--------------------------------

### Install Dependencies

Source: https://docs.localstack.cloud/aws/developer-tools/lambda-tools/hot-reloading

Install the necessary TypeScript and ESbuild packages as development dependencies.

```bash
npm install -D @types/aws-lambda esbuild
```

--------------------------------

### Create User Data Initialization Script

Source: https://docs.localstack.cloud/aws/services/ec2

Script to format and mount an EBS block device upon instance startup.

```bash
cat > init.sh <<EOF
#!/bin/bash


set -eo
mkdir -p /ebs-mounted
mkfs -t ext3 /ebs-dev/sda1
mount -o loop /ebs-dev/sda1 /ebs-mounted
touch /ebs-mounted/my-test-file
EOF
```

--------------------------------

### Install into a specific namespace

Source: https://docs.localstack.cloud/aws/customization/kubernetes/deploy-helm-chart

Deploys the chart to a custom namespace and verifies the installation.

```bash
helm install localstack localstack/localstack --namespace localstack --create-namespace
```

```bash
kubectl get pods -n localstack
```

--------------------------------

### Install tflocal wrapper

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/terraform

Install the tflocal command-line tool using pip.

```bash
pip install terraform-local
```

--------------------------------

### Initialize SAM project

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/aws-sam

Create a new SAM project using the samlocal CLI.

```bash
samlocal init
```

--------------------------------

### Install awslocal

Source: https://docs.localstack.cloud/aws/connecting/aws-cli

Commands to install the awslocal wrapper script via pip.

```bash
pip install awscli-local[ver1]
```

```bash
pip install awscli-local
```

--------------------------------

### Install Serverless-LocalStack Plugin

Source: https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/serverless-framework

Command to install the serverless-localstack plugin as a development dependency.

```bash
npm install -D serverless-localstack
```

--------------------------------

### Install lstk via npm

Source: https://docs.localstack.cloud/aws/developer-tools/running-localstack/lstk

Installs the lstk CLI globally using npm.

```bash
npm install -g @localstack/lstk
```

--------------------------------

### Create and manage databases

Source: https://docs.localstack.cloud/azure/services/dbfor-postgresql

Commands to create, show, and list databases within a flexible server.

```bash
az postgres flexible-server db create \
  --server-name postgres-demo \
  --resource-group rg-postgres-demo \
  --database-name sampledb \
  --charset UTF8 \
  --collation en_US.utf8
```

```json
{
  "charset": "UTF8",
  "collation": "en_US.utf8",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-postgres-demo/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgres-demo/databases/sampledb",
  "name": "sampledb",
  "resourceGroup": "rg-postgres-demo",
  "type": "Microsoft.DBforPostgreSQL/flexibleServers/databases"
}
```

```bash
az postgres flexible-server db show \
  --resource-group rg-postgres-demo \
  --server-name postgres-demo \
  --database-name sampledb


az postgres flexible-server db list \
  --resource-group rg-postgres-demo \
  --server-name postgres-demo
```

```json
{
  "name": "sampledb",
  "charset": "utf8",
  "collation": "en_US.utf8",
  ...
}
[
  {
    "name": "postgres",
    ...
  },
  {
    "name": "azure_sys",
    ...
  },
  {
    "name": "azure_maintenance",
    ...
  },
  {
    "name": "sampledb",
    ...
  }
]
```
Tokens:
Raw