gui4aws 0.0.1__py3-none-any.whl

gui4aws/__about__.py

@@ -0,0 +1,25 @@
+"""Metadata for gui4aws."""
+
+__all__ = [
+    "__credits__",
+    "__dependencies__",
+    "__description__",
+    "__keywords__",
+    "__license__",
+    "__readme__",
+    "__requires_python__",
+    "__status__",
+    "__title__",
+    "__version__",
+]
+
+__title__ = "gui4aws"
+__version__ = "0.0.1"
+__description__ = "Tkinter GUI for AWS"
+__readme__ = "README.md"
+__credits__ = [{"name": "Matthew Martin", "email": "matthewdeanmartin@gmail.com"}]
+__keywords__ = ["gui4aws", "aws", "tkinter", "gui"]
+__license__ = "MIT"
+__requires_python__ = ">=3.10"
+__status__ = "3 - Alpha"
+__dependencies__ = ["boto3>=1.35.0", "keyring>=25.0.0", "tomli>=2.4.1 ; python_full_version < '3.11'"]

gui4aws/__init__.py

@@ -0,0 +1,11 @@
+"""gui4aws: A thoughtful Tkinter GUI for AWS.
+
+This package provides a desktop application for browsing and managing AWS resources
+with a focus on safety, transparency, and developer productivity. It supports
+both boto3 and AWS CLI execution modes, and includes built-in support for
+local emulation via Moto and Robotocore.
+"""
+
+from gui4aws.__about__ import __version__
+
+__all__ = ["__version__"]

gui4aws/__main__.py

@@ -0,0 +1,6 @@
+"""Main entry point for gui4aws when run via `python -m gui4aws`."""
+
+from gui4aws.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gui4aws/app.py

@@ -0,0 +1,121 @@
+"""AppContext: the single source of truth for runtime selections.
+
+The GUI binds widget values to fields on AppContext and asks AppContext for the right executor.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from gui4aws.execution.action_cache import ActionCache
+from gui4aws.execution.action_history import ActionHistory
+from gui4aws.execution.aws_cli_executor import AwsCliExecutor
+from gui4aws.execution.boto3_executor import Boto3Executor
+from gui4aws.execution.endpoint_config import EndpointConfig, EndpointMode
+from gui4aws.execution.execution_mode import ExecutionMode
+from gui4aws.services.service_registry import ServiceRegistry, default_registry
+
+__all__ = ["AWS_PARTITIONS", "AppContext"]
+
+logger = logging.getLogger(__name__)
+
+# AWS partitions with their default region for region enumeration.
+# Keys are partition names; values are a (default_region, display_label) tuple.
+AWS_PARTITIONS: dict[str, tuple[str, str]] = {
+    "aws": ("us-east-1", "AWS Standard"),
+    "aws-us-gov": ("us-gov-west-1", "AWS GovCloud (US)"),
+    "aws-cn": ("cn-north-1", "AWS China"),
+    "aws-iso": ("us-iso-east-1", "AWS ISO"),
+    "aws-iso-b": ("us-isob-east-1", "AWS ISO-B"),
+}
+
+
+@dataclass
+class AppContext:
+    """Holds profile/region/mode/endpoint plus the action history and registry."""
+
+    profile_name: str | None = None
+    region_name: str = "us-east-1"
+    partition: str = "aws"
+    mode: ExecutionMode = ExecutionMode.BOTO3
+    endpoint_config: EndpointConfig = field(default_factory=EndpointConfig)
+    history: ActionHistory = field(default_factory=ActionHistory)
+    registry: ServiceRegistry = field(default_factory=default_registry)
+    action_cache: ActionCache = field(default_factory=ActionCache)
+
+    def set_mode(self, mode: ExecutionMode) -> None:
+        """Change execution mode (AWS CLI vs boto3)."""
+        logger.info("execution mode -> %s", mode)
+        self.mode = mode
+        self.action_cache.clear()
+
+    def set_region(self, region_name: str) -> None:
+        """Change region; resource lists should refresh after this."""
+        logger.info("region -> %s", region_name)
+        self.region_name = region_name
+        self.action_cache.clear()
+
+    def set_partition(self, partition: str) -> None:
+        """Change AWS partition (aws, aws-us-gov, aws-cn, aws-iso, aws-iso-b)."""
+        logger.info("partition -> %s", partition)
+        self.partition = partition
+        self.action_cache.clear()
+
+    def set_profile(self, profile_name: str | None) -> None:
+        """Change AWS profile (None means rely on environment)."""
+        logger.info("profile -> %s", profile_name)
+        self.profile_name = profile_name
+        self.action_cache.clear()
+
+    def set_endpoint(self, mode: EndpointMode, endpoint_url: str | None = None) -> None:
+        """Change endpoint mode + URL."""
+        self.endpoint_config = EndpointConfig.for_mode(mode, endpoint_url)
+        logger.info("endpoint -> %s url=%s", mode, endpoint_url)
+        self.action_cache.clear()
+
+    def boto3_executor(self) -> Boto3Executor:
+        """Build a fresh Boto3Executor that reflects current selections."""
+        return Boto3Executor(
+            profile_name=self.profile_name,
+            region_name=self.region_name,
+            endpoint_config=self.endpoint_config,
+        )
+
+    def aws_cli_executor(self) -> AwsCliExecutor:
+        """Build a fresh AwsCliExecutor that reflects current selections."""
+        return AwsCliExecutor(
+            profile_name=self.profile_name,
+            region_name=self.region_name,
+            endpoint_config=self.endpoint_config,
+        )
+
+    def execute(self, action: Any, inputs: dict[str, str]) -> Any:
+        """Dispatch to whichever executor matches the current mode."""
+        cache_key = self.action_cache.build_key(
+            action,
+            inputs,
+            mode=self.mode,
+            profile_name=self.profile_name,
+            region_name=self.region_name,
+            endpoint_config=self.endpoint_config,
+        )
+        cached = self.action_cache.get(cache_key)
+        if cached is not None:
+            return cached
+        result: Any
+        if self.mode is ExecutionMode.BOTO3:
+            result = self.boto3_executor().execute(action, inputs)
+        else:
+            result = self.aws_cli_executor().execute(action, inputs)
+        if self.action_cache.should_cache(action, result):
+            self.action_cache.put(cache_key, result)
+        return result
+
+    def invalidate_read_cache(self, service_id: str | None = None) -> None:
+        """Drop cached read-only results globally or for one service."""
+        if service_id is None:
+            self.action_cache.clear()
+            return
+        self.action_cache.invalidate_service(service_id)

gui4aws/cli.py

@@ -0,0 +1,194 @@
+"""Command-line entry point for gui4aws."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import shutil
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+import boto3
+import botocore
+
+from gui4aws.__about__ import __version__
+from gui4aws.app import AppContext
+from gui4aws.execution.endpoint_config import EndpointConfig, EndpointMode
+from gui4aws.execution.execution_mode import ExecutionMode
+from gui4aws.logging_config import configure_logging
+
+__all__ = ["build_parser", "main"]
+
+logger = logging.getLogger(__name__)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Construct the argparse parser."""
+    parser = argparse.ArgumentParser(prog="gui4aws", description="Tkinter GUI for AWS")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--log-level", default="INFO", help="DEBUG, INFO, WARNING, ERROR")
+    parser.add_argument("--log-file", type=Path, default=None, help="optional file to also log to")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    gui_parser = subparsers.add_parser("gui", help="launch the GUI")
+    add_common_runtime_options(gui_parser)
+
+    doctor_parser = subparsers.add_parser("doctor", help="environment diagnostics")
+    doctor_parser.add_argument("--check-aws-cli", action="store_true", help="report aws CLI presence")
+    doctor_parser.add_argument("--check-boto3", action="store_true", help="report boto3 version")
+    doctor_parser.add_argument("--check-docker", action="store_true", help="report docker presence")
+
+    subparsers.add_parser("list-profiles", help="list available AWS profiles")
+    list_regions_parser = subparsers.add_parser("list-regions", help="list known AWS regions")
+    from gui4aws.app import AWS_PARTITIONS
+
+    list_regions_parser.add_argument(
+        "--partition",
+        default="aws",
+        choices=list(AWS_PARTITIONS.keys()),
+        help="AWS partition to list regions for (default: aws)",
+    )
+
+    return parser
+
+
+def add_common_runtime_options(parser: argparse.ArgumentParser) -> None:
+    """Add the runtime-selection options shared by ``gui`` (and future subcommands)."""
+    from gui4aws.app import AWS_PARTITIONS
+
+    parser.add_argument("--profile", default=None, help="AWS profile name")
+    parser.add_argument("--region", default="us-east-1", help="AWS region")
+    parser.add_argument(
+        "--partition",
+        default="aws",
+        choices=list(AWS_PARTITIONS.keys()),
+        help="AWS partition (aws, aws-us-gov, aws-cn, aws-iso, aws-iso-b)",
+    )
+    parser.add_argument(
+        "--mode",
+        default=ExecutionMode.BOTO3.value,
+        choices=[m.value for m in ExecutionMode],
+        help="execution mode",
+    )
+    parser.add_argument(
+        "--endpoint-mode",
+        default=EndpointMode.AWS.value,
+        choices=[m.value for m in EndpointMode],
+        help="endpoint mode",
+    )
+    parser.add_argument("--endpoint-url", default=None, help="endpoint URL (required for --endpoint-mode custom)")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Entry point for the ``gui4aws`` command."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    configure_logging(args.log_level, args.log_file)
+
+    if args.command in (None, "gui"):
+        return run_gui(args)
+    if args.command == "doctor":
+        return run_doctor(args)
+    if args.command == "list-profiles":
+        return run_list_profiles()
+    if args.command == "list-regions":
+        return run_list_regions(args)
+    parser.error(f"unknown command: {args.command}")
+    return 2
+
+
+def run_gui(args: argparse.Namespace) -> int:
+    """Launch the GUI window."""
+    from gui4aws.config import load_config
+    from gui4aws.gui.main_window import create_main_window
+
+    saved = load_config()
+
+    # CLI args take precedence over saved config; config takes precedence over defaults.
+    cli_profile = getattr(args, "profile", None)
+    cli_region = getattr(args, "region", None)
+    cli_partition = getattr(args, "partition", None)
+
+    profile = cli_profile or (saved.default_profile or None)
+    partition = cli_partition or saved.default_partition or "aws"
+    region = cli_region or saved.default_region or "us-east-1"
+
+    context = AppContext(
+        profile_name=profile,
+        region_name=region,
+        partition=partition,
+        mode=ExecutionMode(getattr(args, "mode", saved.default_mode or ExecutionMode.BOTO3.value)),
+        endpoint_config=EndpointConfig.for_mode(
+            EndpointMode(getattr(args, "endpoint_mode", saved.default_endpoint_mode or EndpointMode.AWS.value)),
+            getattr(args, "endpoint_url", None),
+        ),
+    )
+
+    profiles = available_profiles()
+    regions = available_regions(partition=partition)
+    window = create_main_window(context, profiles=profiles, regions=regions)
+    window.run()
+    return 0
+
+
+def run_doctor(args: argparse.Namespace) -> int:
+    """Print environment diagnostics."""
+    print(f"gui4aws version: {__version__}")
+    print(f"python: {sys.version.split()[0]}")
+    if args.check_boto3 or not any([args.check_aws_cli, args.check_docker]):
+        print(f"boto3: {boto3.__version__}")
+        print(f"botocore: {botocore.__version__}")
+    if args.check_aws_cli or not any([args.check_boto3, args.check_docker]):
+        aws_path = shutil.which("aws")
+        print(f"aws CLI: {aws_path or 'not found on PATH'}")
+    if args.check_docker:
+        docker_path = shutil.which("docker")
+        print(f"docker: {docker_path or 'not found on PATH'}")
+    try:
+        import moto  # pylint: disable=unused-import  # noqa: F401
+
+        print("moto: importable")
+    except ImportError:
+        print("moto: not importable (install dev deps to use moto-backed tests)")
+    profiles = available_profiles()
+    print(f"profiles: {', '.join(profiles) if profiles else '(none configured)'}")
+    return 0
+
+
+def run_list_profiles() -> int:
+    """Print available AWS profiles, one per line."""
+    for profile in available_profiles():
+        print(profile)
+    return 0
+
+
+def run_list_regions(args: argparse.Namespace | None = None) -> int:
+    """Print known AWS regions, one per line."""
+    partition = getattr(args, "partition", "aws") if args else "aws"
+    for region in available_regions(partition=partition):
+        print(region)
+    return 0
+
+
+def available_profiles() -> list[str]:
+    """Best-effort profile list from boto3's session."""
+    try:
+        session = boto3.Session()
+        return list(session.available_profiles)
+    except Exception:  # pylint: disable=broad-exception-caught
+        return []
+
+
+def available_regions(service: str = "ec2", partition: str = "aws") -> list[str]:
+    """Known regions for ``service`` in ``partition`` (EC2 is the most-supported default)."""
+    try:
+        session = boto3.Session()
+        return sorted(session.get_available_regions(service, partition_name=partition))
+    except Exception:  # pylint: disable=broad-exception-caught
+        return []
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gui4aws/config.py

@@ -0,0 +1,139 @@
+"""User configuration: load/save preferences in a per-OS config dir.
+
+We hand-roll a minimal TOML writer to stay stdlib-only on the write path. Reading uses
+``tomllib`` (Python 3.11+). For Python 3.10 we fall back to JSON.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+__all__ = ["AppConfig", "config_path", "load_config", "save_config"]
+
+
+@dataclass
+class AppConfig:
+    """User-visible app config."""
+
+    default_profile: str = ""
+    default_region: str = "us-east-1"
+    default_partition: str = "aws"
+    default_mode: str = "boto3"
+    default_endpoint_mode: str = "aws"
+    window_width: int = 1400
+    window_height: int = 900
+    history_enabled: bool = True
+    history_max_entries: int = 500
+    local_endpoints: dict[str, str] = field(default_factory=dict)
+
+
+def config_path() -> Path:
+    """Return the OS-appropriate config file path."""
+    if sys.platform.startswith("win"):
+        base = Path(os.environ.get("APPDATA", str(Path.home() / "AppData" / "Roaming")))
+        return base / "gui4aws" / "config.toml"
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / "gui4aws" / "config.toml"
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".config"
+    return base / "gui4aws" / "config.toml"
+
+
+def load_config(path: Path | None = None) -> AppConfig:
+    """Load config from disk, returning defaults if no file exists."""
+    if path is None:
+        path = config_path()
+    if not path.exists():
+        return AppConfig()
+    raw = path.read_text(encoding="utf-8")
+    data: dict[str, Any]
+    if path.suffix == ".json":
+        data = json.loads(raw)
+    else:
+        try:
+            if sys.version_info >= (3, 11):
+                import tomllib
+            else:
+                import tomli as tomllib
+
+            data = tomllib.loads(raw)
+        except ImportError:  # pragma: no cover
+            # Fallback if neither is available (should not happen with our deps)
+            data = json.loads(raw)
+    return apply(data)
+
+
+def save_config(config: AppConfig, path: Path | None = None) -> None:
+    """Save config to disk in TOML."""
+    if path is None:
+        path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(render_toml(config), encoding="utf-8")
+
+
+def apply(data: dict[str, Any]) -> AppConfig:
+    """Map a raw dictionary (from TOML/JSON) onto an AppConfig instance."""
+    config = AppConfig()
+    for key in (
+        "default_profile",
+        "default_region",
+        "default_partition",
+        "default_mode",
+        "default_endpoint_mode",
+    ):
+        if key in data:
+            setattr(config, key, str(data[key]))
+    window = data.get("window", {})
+    if isinstance(window, dict):
+        if "width" in window:
+            config.window_width = int(window["width"])
+        if "height" in window:
+            config.window_height = int(window["height"])
+    history = data.get("history", {})
+    if isinstance(history, dict):
+        if "enabled" in history:
+            config.history_enabled = bool(history["enabled"])
+        if "max_entries" in history:
+            config.history_max_entries = int(history["max_entries"])
+    endpoints = data.get("local_endpoints", {})
+    if isinstance(endpoints, dict):
+        for service, value in endpoints.items():
+            if isinstance(value, dict) and "endpoint_url" in value:
+                config.local_endpoints[str(service)] = str(value["endpoint_url"])
+            elif isinstance(value, str):
+                config.local_endpoints[str(service)] = value
+    return config
+
+
+def render_toml(config: AppConfig) -> str:
+    """Serialize AppConfig to a TOML string."""
+    lines = [
+        f'default_profile = "{config.default_profile}"',
+        f'default_region = "{config.default_region}"',
+        f'default_partition = "{config.default_partition}"',
+        f'default_mode = "{config.default_mode}"',
+        f'default_endpoint_mode = "{config.default_endpoint_mode}"',
+        "",
+        "[window]",
+        f"width = {config.window_width}",
+        f"height = {config.window_height}",
+        "",
+        "[history]",
+        f"enabled = {'true' if config.history_enabled else 'false'}",
+        f"max_entries = {config.history_max_entries}",
+    ]
+    for service, url in sorted(config.local_endpoints.items()):
+        lines.extend(
+            [
+                "",
+                f"[local_endpoints.{service}]",
+                f'endpoint_url = "{url}"',
+            ]
+        )
+    lines.append("")
+    return "\n".join(lines)

gui4aws/demo_resources/__init__.py

@@ -0,0 +1,79 @@
+"""Seed demo AWS resources so the GUI has something to browse immediately.
+
+All resources are tagged with ``gui4aws:demo = true`` and given descriptive names so
+users can immediately distinguish demo data from real infrastructure.
+
+This package only writes resources; it never deletes. Call :func:`seed_demo_resources`
+with a boto3 session (or endpoint_url for moto server mode) to create the assets.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from gui4aws.demo_resources.aurora import seed_aurora
+from gui4aws.demo_resources.backup import seed_backup
+from gui4aws.demo_resources.compute import seed_lambda
+from gui4aws.demo_resources.ecs import seed_ecs
+from gui4aws.demo_resources.iam_resources import seed_iam_extras
+from gui4aws.demo_resources.kms import seed_kms
+from gui4aws.demo_resources.messaging import seed_ses, seed_sns
+from gui4aws.demo_resources.monitoring import seed_cloudformation, seed_cloudwatch
+from gui4aws.demo_resources.networking import seed_networking
+from gui4aws.demo_resources.secrets import seed_secrets, seed_ssm
+from gui4aws.demo_resources.storage import seed_s3, seed_sqs
+
+__all__ = ["seed_demo_resources"]
+
+logger = logging.getLogger(__name__)
+
+
+def seed_demo_resources(
+    *,
+    region_name: str = "us-east-1",
+    endpoint_url: str | None = None,
+    profile_name: str | None = None,
+    is_robotocore: bool = False,
+) -> dict[str, list[str]]:
+    """Create demo resources and return a report of what was created.
+
+    ``is_robotocore`` controls whether richer demo data (backup jobs, restore jobs,
+    ECS services with tasks, etc.) is seeded.  Robotocore has broader API coverage
+    than Moto for these resource types.
+
+    Returns a dict mapping resource type to list of identifiers.
+    """
+    import boto3
+
+    session: Any
+    if profile_name:
+        session = boto3.Session(profile_name=profile_name, region_name=region_name)
+    else:
+        session = boto3.Session(region_name=region_name)
+
+    def client(service: str) -> Any:
+        if endpoint_url:
+            return session.client(service, endpoint_url=endpoint_url)
+        return session.client(service)
+
+    created: dict[str, list[str]] = {}
+
+    rds_client = client("rds")
+    created.update(seed_aurora(rds_client))
+    created.update(seed_backup(client("backup"), rds_client, extended=is_robotocore))
+    created.update(seed_networking(client("ec2"), client("elbv2")))
+    created.update(seed_ecs(client("ecs"), extended=is_robotocore))
+    created.update(seed_secrets(client("secretsmanager")))
+    created.update(seed_ssm(client("ssm")))
+    created.update(seed_kms(client("kms")))
+    created.update(seed_s3(client("s3")))
+    created.update(seed_sqs(client("sqs")))
+    created.update(seed_lambda(client("lambda"), client("iam")))
+    created.update(seed_cloudwatch(client("cloudwatch"), client("logs")))
+    created.update(seed_cloudformation(client("cloudformation")))
+    created.update(seed_sns(client("sns")))
+    created.update(seed_ses(client("ses")))
+    created.update(seed_iam_extras(client("iam")))
+
+    return created

gui4aws/demo_resources/_common.py

@@ -0,0 +1,11 @@
+"""Shared constants and helpers used across demo resource seeders."""
+
+from __future__ import annotations
+
+DEMO_TAG = {"Key": "gui4aws:demo", "Value": "true"}
+DEMO_DESC_TAG_KEY = "Description"
+
+
+def tags(*extra: dict[str, str]) -> list[dict[str, str]]:
+    """Return a tag list with the standard demo tag plus any extras."""
+    return [DEMO_TAG, *extra]

gui4aws/demo_resources/aurora.py

@@ -0,0 +1,89 @@
+"""Seed demo Aurora clusters, instances, and snapshots."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from gui4aws.demo_resources._common import DEMO_DESC_TAG_KEY, tags
+
+logger = logging.getLogger(__name__)
+
+
+def seed_aurora(rds: Any) -> dict[str, list[str]]:
+    """Seed demo Aurora clusters, instances, and snapshots.
+
+    Creates both MySQL and PostgreSQL clusters with associated instances and a sample
+    snapshot to demonstrate RDS resource browsing and management in the GUI.
+    """
+    created: dict[str, list[str]] = {"aurora_clusters": [], "aurora_instances": [], "aurora_snapshots": []}
+
+    clusters = [
+        {
+            "DBClusterIdentifier": "demo-aurora-mysql-prod",
+            "Engine": "aurora-mysql",
+            "MasterUsername": "admin",
+            "MasterUserPassword": "DemoPass123!",
+            "Tags": tags(
+                {"Key": "Name", "Value": "demo-aurora-mysql-prod"},
+                {"Key": DEMO_DESC_TAG_KEY, "Value": "Demo Aurora MySQL cluster (production-like)"},
+            ),
+        },
+        {
+            "DBClusterIdentifier": "demo-aurora-pg-analytics",
+            "Engine": "aurora-postgresql",
+            "MasterUsername": "postgres",
+            "MasterUserPassword": "DemoPass123!",
+            "Tags": tags(
+                {"Key": "Name", "Value": "demo-aurora-pg-analytics"},
+                {"Key": DEMO_DESC_TAG_KEY, "Value": "Demo Aurora PostgreSQL cluster (analytics)"},
+            ),
+        },
+    ]
+
+    for spec in clusters:
+        cluster_id = str(spec["DBClusterIdentifier"])
+        engine = str(spec["Engine"])
+        try:
+            rds.create_db_cluster(**spec)
+            logger.info("created Aurora cluster %s", cluster_id)
+            created["aurora_clusters"].append(cluster_id)
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            logger.warning("skipped cluster %s: %s", cluster_id, exc)
+            continue
+
+        instance_id = f"{cluster_id}-instance-1"
+        try:
+            rds.create_db_instance(
+                DBInstanceIdentifier=instance_id,
+                DBInstanceClass="db.t3.medium",
+                Engine=engine,
+                DBClusterIdentifier=cluster_id,
+                Tags=tags(
+                    {"Key": "Name", "Value": instance_id},
+                    {"Key": DEMO_DESC_TAG_KEY, "Value": f"Demo instance for {cluster_id}"},
+                ),
+            )
+            logger.info("created Aurora instance %s", instance_id)
+            created["aurora_instances"].append(instance_id)
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            logger.warning("skipped instance %s: %s", instance_id, exc)
+
+    if created["aurora_clusters"]:
+        source = created["aurora_clusters"][0]
+        snap_id = f"{source}-demo-snapshot"
+        try:
+            rds.create_db_cluster_snapshot(
+                DBClusterIdentifier=source,
+                DBClusterSnapshotIdentifier=snap_id,
+                Tags=tags(
+                    {"Key": "Name", "Value": snap_id},
+                    {"Key": DEMO_DESC_TAG_KEY, "Value": "Demo snapshot — safe to restore"},
+                ),
+            )
+            logger.info("created Aurora snapshot %s", snap_id)
+            created["aurora_snapshots"].append(snap_id)
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            logger.warning("skipped snapshot %s: %s", snap_id, exc)
+
+    return created