Add AWS Community Day workshop: Order Processing Pipeline

Moves previous EuroPython workshop content to old/, and introduces a new
3-hour workshop built around a single serverless order processing app
(API GW → Lambda → DynamoDB + SQS → Lambda → S3 + DLQ), covering:
- Module 00: environment setup with dynamic auth token fetch
- Module 01: awslocal CLI basics + full Terraform deployment
- Module 02: pytest end-to-end integration tests
- Module 03: Lambda live debugging via VS Code AWS Toolkit
- Module 04: chaos engineering with DDB fault injection and DLQ replay
- Module 05: App Inspector topology and request tracing
- Module 06: AI integration via LocalStack MCP server and Claude Code skills

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: whummer

.devcontainer/Dockerfile.github

@@ -1,24 +1,21 @@
 FROM mcr.microsoft.com/devcontainers/universal
 
-RUN sudo apt update
+RUN sudo apt-get update && sudo apt-get install -y curl jq
 
-# install LocalStack CLI, awslocal, samlocal, tflocal
-# FIXME remove once https://github.com/yaml/pyyaml/issues/601 is fixed
-RUN pip install "setuptools" "wheel"
-RUN pip install --no-build-isolation "Cython<3.0" "pyyaml<5.5"
-RUN pip install localstack awscli-local[ver1] aws-sam-cli-local terraform-local
-RUN pip install --pre --upgrade localstack localstack-ext
-
-# install CDK utils
-RUN npm install -g aws-cdk-local aws-cdk
+# Install LocalStack CLI and AWS/Terraform local wrappers
+RUN pip install localstack awscli-local terraform-local pytest requests
 
 # default environment variables
 ENV DEBUG=1
 ENV OVERRIDE_IN_DOCKER=0
 ENV EXTRA_CORS_ALLOWED_ORIGINS='*'
 ENV DISABLE_CUSTOM_CORS_APIGATEWAY=1
-ENV PORTS_CHECK_DOCKER_IMAGE=localstack/localstack-pro
 
-# set test environment variables
+# Workshop token URL — set by organizer before each event.
+# The setup script fetches the actual token from this endpoint.
+ENV WORKSHOP_TOKEN_URL=""
+
+# Standard LocalStack test credentials
 ENV AWS_ACCESS_KEY_ID=test
 ENV AWS_SECRET_ACCESS_KEY=test
+ENV AWS_DEFAULT_REGION=us-east-1

.devcontainer/devcontainer.json

@@ -3,10 +3,17 @@
     "dockerfile": "Dockerfile.github"
   },
   "customizations": {
+    "vscode": {
+      "extensions": [
+        "amazonwebservices.aws-toolkit-vscode",
+        "hashicorp.terraform"
+      ]
+    },
     "codespaces": {
       "openFiles": [
         "README.md"
       ]
     }
-  }
+  },
+  "postStartCommand": "echo 'Run ./00-setup/setup.sh to configure your auth token and start LocalStack.'"
 }

.gitignore

@@ -1,5 +1,16 @@
 .idea/
 node_modules/
 .venv/
-
 .DS_Store
+
+# Terraform
+**/.terraform/
+**/.terraform.lock.hcl
+**/terraform.tfstate
+**/terraform.tfstate.backup
+01-serverless-app/terraform/.build/*.zip
+
+# Python
+__pycache__/
+*.pyc
+.pytest_cache/

.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug order-handler (LocalStack)",
+      "type": "aws-sam",
+      "request": "direct-invoke",
+      "invokeTarget": {
+        "target": "code",
+        "lambdaHandler": "handler.handler",
+        "projectRoot": "${workspaceFolder}/01-serverless-app/lambdas/order_handler"
+      },
+      "lambda": {
+        "runtime": "python3.12",
+        "payload": {
+          "json": {
+            "body": "{\"item\": \"debug-test\", \"quantity\": 1}"
+          }
+        },
+        "environmentVariables": {
+          "ORDERS_TABLE": "orders",
+          "ORDERS_QUEUE_URL": "http://localhost:4566/000000000000/orders-queue",
+          "AWS_ENDPOINT_URL": "http://localhost:4566"
+        }
+      },
+      "sam": {
+        "localArguments": ["--debug-port", "5890"]
+      }
+    }
+  ]
+}

00-setup/README.md

@@ -0,0 +1,56 @@
+# Module 00 — Setup
+
+Verify your environment and start LocalStack before proceeding to module 01.
+
+---
+
+## 1. Auth Token
+
+Run the setup script — it fetches today's workshop token automatically:
+
+```bash
+./00-setup/setup.sh
+```
+
+If you're running this outside the workshop, set your own token:
+
+```bash
+export LOCALSTACK_AUTH_TOKEN=<your-token>
+```
+
+---
+
+## 2. Start LocalStack
+
+```bash
+localstack start -d
+```
+
+Wait until you see `Ready.` in the logs (`localstack logs -f`).
+
+---
+
+## 3. Verify
+
+```bash
+awslocal s3 ls                         # should return empty list (no error)
+curl -s http://localhost:4566/_localstack/health | python3 -m json.tool
+```
+
+You should see `"running": true` and a list of available services.
+
+---
+
+## Installed Tools Checklist
+
+| Tool | Purpose | Check |
+|------|---------|-------|
+| `localstack` | Run AWS locally | `localstack --version` |
+| `awslocal` | AWS CLI → LocalStack | `awslocal --version` |
+| `tflocal` | Terraform → LocalStack | `tflocal --version` |
+| `pytest` | Integration tests | `pytest --version` |
+| Docker | LocalStack runtime | `docker info` |
+
+---
+
+Next: [Module 01 — Serverless App](../01-serverless-app/README.md)

00-setup/setup.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Workshop auth token endpoint — organizer publishes token here on event day.
+# The URL points to a time-limited S3 object; replace before each workshop.
+TOKEN_URL="${WORKSHOP_TOKEN_URL:-}"
+
+if [ -n "$TOKEN_URL" ]; then
+  echo "Fetching LocalStack auth token from workshop endpoint..."
+  TOKEN=$(curl -fsSL "$TOKEN_URL")
+  export LOCALSTACK_AUTH_TOKEN="$TOKEN"
+  echo "LOCALSTACK_AUTH_TOKEN=$TOKEN" >> "${HOME}/.bashrc"
+  echo "LOCALSTACK_AUTH_TOKEN=$TOKEN" >> "${HOME}/.zshrc" 2>/dev/null || true
+  echo "Token set."
+elif [ -z "${LOCALSTACK_AUTH_TOKEN:-}" ]; then
+  echo "No token found. Set LOCALSTACK_AUTH_TOKEN or WORKSHOP_TOKEN_URL."
+  echo "  export LOCALSTACK_AUTH_TOKEN=<your-token>"
+  exit 1
+else
+  echo "Using existing LOCALSTACK_AUTH_TOKEN."
+fi
+
+echo ""
+echo "Starting LocalStack..."
+localstack start -d
+
+echo ""
+echo "Waiting for LocalStack to be ready..."
+localstack wait -t 60
+
+echo ""
+echo "Verifying..."
+awslocal s3 ls > /dev/null && echo "OK: awslocal connected"
+curl -sf http://localhost:4566/_localstack/health | python3 -m json.tool | grep -q '"running"' && echo "OK: health check passed"
+
+echo ""
+echo "Setup complete. Proceed to module 01."

01-serverless-app/README.md

@@ -0,0 +1,104 @@
+# Module 01 — Serverless App
+
+Build intuition with the `awslocal` CLI, then deploy the full Order Processing Pipeline with Terraform.
+
+---
+
+## Part A — AWS CLI Basics with `awslocal`
+
+### S3
+
+```bash
+# Create a bucket and upload a file
+awslocal s3 mb s3://workshop-receipts
+echo "hello localstack" > /tmp/test.txt
+awslocal s3 cp /tmp/test.txt s3://workshop-receipts/test.txt
+awslocal s3 ls s3://workshop-receipts
+```
+
+### DynamoDB
+
+```bash
+# Create a table and put an item
+awslocal dynamodb create-table \
+  --table-name orders-scratch \
+  --attribute-definitions AttributeName=order_id,AttributeType=S \
+  --key-schema AttributeName=order_id,KeyType=HASH \
+  --billing-mode PAY_PER_REQUEST
+
+awslocal dynamodb put-item \
+  --table-name orders-scratch \
+  --item '{"order_id": {"S": "ord-001"}, "status": {"S": "pending"}}'
+
+awslocal dynamodb scan --table-name orders-scratch
+```
+
+### SQS
+
+```bash
+# Create a queue and send a message
+awslocal sqs create-queue --queue-name workshop-queue
+QUEUE_URL=$(awslocal sqs get-queue-url --queue-name workshop-queue --query QueueUrl --output text)
+awslocal sqs send-message --queue-url $QUEUE_URL --message-body '{"test": true}'
+awslocal sqs receive-message --queue-url $QUEUE_URL
+```
+
+### Lambda (quick smoke test)
+
+```bash
+# Invoke the order_handler directly (deployed in Part B)
+awslocal lambda invoke \
+  --function-name order-handler \
+  --payload '{"body": "{\"item\": \"book\", \"quantity\": 2}"}' \
+  /tmp/response.json
+cat /tmp/response.json
+```
+
+---
+
+## Part B — Deploy with Terraform
+
+```bash
+cd 01-serverless-app/terraform
+
+# Initialize and deploy
+tflocal init
+tflocal apply -auto-approve
+
+# Grab the API Gateway endpoint
+tflocal output api_endpoint
+```
+
+### Test the deployed API
+
+```bash
+API=$(tflocal output -raw api_endpoint)
+
+# Create an order
+curl -s -X POST "$API/orders" \
+  -H "Content-Type: application/json" \
+  -d '{"item": "LocalStack T-Shirt", "quantity": 1}' | python3 -m json.tool
+
+# Check DynamoDB
+awslocal dynamodb scan --table-name orders
+
+# Check S3 receipts
+awslocal s3 ls s3://order-receipts/
+```
+
+---
+
+## What Got Deployed
+
+```
+API Gateway  →  Lambda: order_handler  →  DynamoDB (orders table)
+                                       →  SQS (orders-queue)
+                                              └→  Lambda: order_processor
+                                                      →  DynamoDB (status update)
+                                                      →  S3 (receipt upload)
+                                              SQS DLQ ← (on processor failure)
+```
+
+---
+
+Next: [Module 02 — E2E Testing](../02-e2e-testing/README.md)

01-serverless-app/lambdas/order_handler/handler.py

@@ -0,0 +1,35 @@
+import json
+import os
+import uuid
+import boto3
+
+dynamodb = boto3.resource("dynamodb", endpoint_url=os.environ.get("AWS_ENDPOINT_URL"))
+sqs = boto3.client("sqs", endpoint_url=os.environ.get("AWS_ENDPOINT_URL"))
+
+TABLE_NAME = os.environ["ORDERS_TABLE"]
+QUEUE_URL = os.environ["ORDERS_QUEUE_URL"]
+
+
+def handler(event, context):
+    body = json.loads(event.get("body") or "{}")
+    order_id = str(uuid.uuid4())
+
+    order = {
+        "order_id": order_id,
+        "item": body.get("item", "unknown"),
+        "quantity": int(body.get("quantity", 1)),
+        "status": "pending",
+    }
+
+    table = dynamodb.Table(TABLE_NAME)
+    table.put_item(Item=order)
+
+    sqs.send_message(
+        QueueUrl=QUEUE_URL,
+        MessageBody=json.dumps({"order_id": order_id, **order}),
+    )
+
+    return {
+        "statusCode": 201,
+        "body": json.dumps({"order_id": order_id, "status": "pending"}),
+    }

01-serverless-app/lambdas/order_processor/handler.py

@@ -0,0 +1,38 @@
+import json
+import os
+import boto3
+
+dynamodb = boto3.resource("dynamodb", endpoint_url=os.environ.get("AWS_ENDPOINT_URL"))
+s3 = boto3.client("s3", endpoint_url=os.environ.get("AWS_ENDPOINT_URL"))
+
+TABLE_NAME = os.environ["ORDERS_TABLE"]
+RECEIPTS_BUCKET = os.environ["RECEIPTS_BUCKET"]
+
+
+def handler(event, context):
+    for record in event["Records"]:
+        order = json.loads(record["body"])
+        order_id = order["order_id"]
+
+        # Update order status in DynamoDB
+        table = dynamodb.Table(TABLE_NAME)
+        table.update_item(
+            Key={"order_id": order_id},
+            UpdateExpression="SET #s = :s",
+            ExpressionAttributeNames={"#s": "status"},
+            ExpressionAttributeValues={":s": "processed"},
+        )
+
+        # Store receipt in S3
+        receipt = {
+            "order_id": order_id,
+            "item": order.get("item"),
+            "quantity": order.get("quantity"),
+            "status": "processed",
+        }
+        s3.put_object(
+            Bucket=RECEIPTS_BUCKET,
+            Key=f"receipts/{order_id}.json",
+            Body=json.dumps(receipt),
+            ContentType="application/json",
+        )