code/ ├── lambda/ # Shared: the same code runs locally and on real AWS │ ├── fetch_status/ │ │ └── app.py │ └── notify_slack/ │ └── app.py ├── mock-api/ # Local only: mock server standing in for the external API │ ├── Dockerfile │ └── server.py ├── scripts/ │ ├── put-parameters-aws.sh # AWS only: registers parameters in the real SSM │ └── put-parameters.sh # Local only: registers parameters in MiniStack's SSM ├── terraform/ │ ├── environments/ │ │ ├── aws/ # For real AWS: points at real AWS │ │ │ ├── main.tf │ │ │ ├── outputs.tf │ │ │ ├── providers.tf │ │ │ ├── terraform.tfvars │ │ │ ├── terraform.tfvars.example │ │ │ └── variables.tf │ │ └── local/ # For local: points at MiniStack │ │ ├── main.tf │ │ ├── outputs.tf │ │ ├── providers.tf │ │ ├── terraform.tfvars │ │ ├── terraform.tfvars.example │ │ └── variables.tf │ └── modules/ │ └── notify/ # Shared: Lambda, SNS, Scheduler, IAM, and more │ ├── main.tf │ ├── outputs.tf │ ├── variables.tf │ └── versions.tf └── docker-compose.yml # Local only: starts MiniStack, StackPort, and mock-api 

services: ministack: image: ministackorg/ministack:latest ports: - "4566:4566" environment: - MINISTACK_REGION=ap-northeast-1 healthcheck: test: [ "CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:4566/_ministack/health')", ] interval: 5s timeout: 3s retries: 5 stackport: image: davireis/stackport:latest ports: - "8080:8080" environment: - AWS_ENDPOINT_URL=http://ministack:4566 - AWS_REGION=ap-northeast-1 - AWS_ACCESS_KEY_ID=test - AWS_SECRET_ACCESS_KEY=test healthcheck: test: [ "CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/api/health')", ] interval: 10s timeout: 3s retries: 3 restart: unless-stopped depends_on: ministack: condition: service_healthy # Mock server standing in for the external API mock-api: build: ./mock-api ports: - "8000:8000" environment: - EXPECTED_API_KEY=local-dummy-api-key 

 def do_GET(self): if self.path == "/v1/status": if self.headers.get("x-api-key") != EXPECTED_API_KEY: return self._send(403, {"message": "Forbidden"}) return self._send(200, {"status": "ok"}) return self._send(404, {"message": "not found"}) 

cd code docker compose up -d --build 

#!/usr/bin/env bash set -euo pipefail : "${SLACK_WEBHOOK_URL:?Set SLACK_WEBHOOK_URL}" export AWS_ACCESS_KEY_ID=test export AWS_SECRET_ACCESS_KEY=test export AWS_DEFAULT_REGION=ap-northeast-1 ENDPOINT=http://localhost:4566 aws --endpoint-url="$ENDPOINT" ssm put-parameter \ --name /notify-demo/api-key \ --type SecureString \ --value local-dummy-api-key \ --overwrite aws --endpoint-url="$ENDPOINT" ssm put-parameter \ --name /notify-demo/slack-webhook-url \ --type SecureString \ --value "$SLACK_WEBHOOK_URL" \ --overwrite 

SLACK_WEBHOOK_URL=<Webhook URL of the local channel> ./scripts/put-parameters.sh 

import json import os import urllib.request import boto3 ssm = boto3.client("ssm") sns = boto3.client("sns") API_BASE_URL = os.environ["API_BASE_URL"] API_KEY_PARAM = os.environ["API_KEY_PARAM"] RESULT_TOPIC_ARN = os.environ["RESULT_TOPIC_ARN"] _api_key = None def get_api_key(): # Fetch from SSM only on a cold start; use the cache afterwards  global _api_key if _api_key is None: res = ssm.get_parameter(Name=API_KEY_PARAM, WithDecryption=True) _api_key = res["Parameter"]["Value"] return _api_key def handler(event, context): req = urllib.request.Request( f"{API_BASE_URL}/v1/status", headers={"x-api-key": get_api_key()}, ) # 4xx/5xx raise HTTPError, which makes the Lambda invocation fail  with urllib.request.urlopen(req, timeout=10) as res: result = json.loads(res.read()) print(f"API status: {result['status']}") sns.publish( TopicArn=RESULT_TOPIC_ARN, Subject="API status check", Message=json.dumps(result, ensure_ascii=False), ) return result 

def handler(event, context): for record in event["Records"]: result = json.loads(record["Sns"]["Message"]) now = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M:%S %Z") text = f":white_check_mark: API status: {result['status']} ({now})" req = urllib.request.Request( get_webhook_url(), data=json.dumps({"text": text}).encode(), headers={"Content-Type": "application/json"}, method="POST", ) with urllib.request.urlopen(req, timeout=10): pass print(text) 

resource "aws_lambda_function" "fetch_status" { function_name = local.fetch_name role = aws_iam_role.fetch_status.arn runtime = "python3.14" handler = "app.handler" filename = data.archive_file.fetch_status.output_path source_code_hash = data.archive_file.fetch_status.output_base64sha256 timeout = 30 environment { variables = { API_BASE_URL = var.api_base_url API_KEY_PARAM = local.api_key_param RESULT_TOPIC_ARN = aws_sns_topic.result.arn } } depends_on = [aws_cloudwatch_log_group.fetch_status] } 

provider "aws" { access_key = "test" secret_key = "test" region = "ap-northeast-1" skip_credentials_validation = true skip_metadata_api_check = true skip_requesting_account_id = true endpoints { iam = "http://localhost:4566" lambda = "http://localhost:4566" logs = "http://localhost:4566" scheduler = "http://localhost:4566" sns = "http://localhost:4566" ssm = "http://localhost:4566" sts = "http://localhost:4566" } } 

module "notify" { source = "../../modules/notify" region = "ap-northeast-1" api_base_url = var.api_base_url } 

api_base_url = "http://mock-api:8000" 

cd terraform/environments/local cp terraform.tfvars.example terraform.tfvars # Rewrite <API ID> in terraform.tfvars terraform init terraform apply 

$ terraform apply module.notify.data.archive_file.notify_slack: Reading... module.notify.data.archive_file.fetch_status: Reading... module.notify.data.archive_file.notify_slack: Read complete after 0s [id=68fb7c506afbeeab169fb65494efc63dd8acba90] module.notify.data.archive_file.fetch_status: Read complete after 0s [id=013b111cb8285884b651e501fd6f84ad373f787a] module.notify.data.aws_iam_policy_document.lambda_assume: Reading... module.notify.data.aws_caller_identity.current: Reading... module.notify.data.aws_iam_policy_document.lambda_assume: Read complete after 0s [id=2690255455] module.notify.data.aws_caller_identity.current: Read complete after 0s [id=000000000000] module.notify.data.aws_iam_policy_document.scheduler_assume: Reading... module.notify.data.aws_iam_policy_document.notify_slack: Reading... module.notify.data.aws_iam_policy_document.scheduler_assume: Read complete after 0s [id=644537899] module.notify.data.aws_iam_policy_document.notify_slack: Read complete after 0s [id=2364181876] Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols: + create <= read (data resources) Terraform will perform the following actions: # module.notify.data.aws_iam_policy_document.fetch_status will be read during apply # (config refers to values not yet known) <= data "aws_iam_policy_document" "fetch_status" { + id = (known after apply) + json = (known after apply) + minified_json = (known after apply) + statement { + actions = [ + "ssm:GetParameter", ] + resources = [ + "arn:aws:ssm:ap-northeast-1:000000000000:parameter/notify-demo/api-key", ] } + statement { + actions = [ + "sns:Publish", Source：https://dev.to/aws-builders/trying-ministack-and-stackport-110i
My favorites