Aurora Dsql · aws/agent-toolkit-for-aws

Aurora Dsql · aws/agent-toolkit-for-aws · Skills Docs

Limit	Default	Verify query
Max rows mutated per transaction	3,000	`aurora dsql transaction limits`
Max data modified per write transaction	10 MiB	`aurora dsql transaction limits`
Max transaction duration	5 minutes	`aurora dsql transaction limits`
Max connections per cluster	10,000	`aurora dsql connection limits`
IAM auth token expiry	15 minutes	`aurora dsql authentication token`
Max connection duration	60 minutes	`aurora dsql connection limits`
Max indexes per table	24	`aurora dsql index limits`
Max columns per index	8	`aurora dsql index limits`
IDENTITY/SEQUENCE CACHE values	1 or >= 65536	`aurora dsql sequence cache`

Task	Script	Example
Create cluster with tags	`scripts/create-cluster.sh` (opens in a new tab)	`./scripts/create-cluster.sh --created-by <model-id> --tags Environment=eval,Project=dsql-skill-eval`
List clusters	`scripts/list-clusters.sh` (opens in a new tab)	`./scripts/list-clusters.sh --region us-east-1`
Inspect cluster	`scripts/cluster-info.sh` (opens in a new tab)	`./scripts/cluster-info.sh <cluster-id>`
Connect via psql	`scripts/psql-connect.sh` (opens in a new tab)	`./scripts/psql-connect.sh --cluster <id> --command "SELECT 1"`

./scripts/psql-connect.sh --cluster <id> --command "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'"
./scripts/psql-connect.sh --cluster <id> --command "SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '<table>' ORDER BY ordinal_position"

Use psql-connect.sh (or the language connector in app code) for SELECT queries
Always include tenant_id in WHERE clause for multi-tenant apps
MUST build SQL with safe_query.build() — see references/input-validation.md

Use ./scripts/psql-connect.sh --admin (or the language connector with the IAM admin auth token) for DDL
Follow one-DDL-per-transaction rule
Always use CREATE INDEX ASYNC in a separate statement
ALTER COLUMN TYPE, DROP COLUMN, DROP CONSTRAINT → Table Recreation Pattern (Workflow 6)

{"service": "dsql", "operation": "CreateCluster",
 "parameters": {"tags": {"created_by": "<model-id>", "Environment": "eval", "Project": "dsql-skill-eval"}, "deletionProtectionEnabled": true}}

Value kind	Validator	Emits
Known set (tenant ID, status enum)	`allow(v, SET)`	`'value'`
Known set used as SQL keyword (ASC/DESC)	`keyword(v, SET)`	`value` (unquoted)
Strict format (UUID, slug, ISO date)	`regex(v, PATTERN)`	`'value'`
Table or column name	`ident(name)`	`"value"`
Integer	`integer(v)`	`value`
Free text (description, comment, user name)	`literal(v)`	`$dq_xxx$value$dq_xxx$`

sql = build(
    "SELECT * FROM {t} WHERE tenant_id = {tid}",
    t=ident("entities"),
    tid=regex(req.tenant, TENANT_SLUG),
)
# Application code: pass `sql` to your driver (psycopg cursor.execute, pgx Query, etc.).
# Bash one-off: pipe `sql` into psql via the patterns in input-validation.md.

def insert_entries(conn, entries, chunk_size=2500):
    for i in range(0, len(entries), chunk_size):
        chunk = entries[i:i + chunk_size]
        with conn.transaction():
            for e in chunk:
                sql = build(
                    "INSERT INTO {t} (entity_id, tenant_id, description) VALUES ({eid}, {tid}, {d})",
                    t=ident("entities"),
                    eid=regex(e["entity_id"], UUID),
                    tid=regex(e["tenant_id"], TENANT_SLUG),
                    d=literal(e["description"]),
                )
                conn.execute(sql)

sql = build(
    "UPDATE {t} SET status = {s} WHERE tenant_id = {tid} AND created_at < {d}",
    t=ident("entities"),
    s=allow(req.status, {"active", "archived", "deleted"}),
    tid=regex(req.tenant, TENANT_SLUG),
    d=regex(req.date, ISO_DATE),
)
conn.execute(sql)

ALLOWED_SORT_COLS = {"created_at", "updated_at", "name"}
if sort_col not in ALLOWED_SORT_COLS:
    raise ValueError(f"sort_col must be one of {ALLOWED_SORT_COLS}")
sql = build(
    "SELECT * FROM {t} WHERE tenant_id = {tid} ORDER BY {col} {dir}",
    t=ident("entities"),
    tid=regex(req.tenant, TENANT_SLUG),
    col=ident(sort_col),
    dir=keyword(req.sort_dir, {"ASC", "DESC"}),
)

# No — even for "already-validated upstream" values:
sql = f"SELECT * FROM entities WHERE entity_id = '{req.entity_id}'"   # BAD

# Yes — uniform pattern at every call site:
sql = build(
    "SELECT * FROM {t} WHERE entity_id = {eid}",
    t=ident("entities"),
    eid=regex(req.entity_id, UUID),
)

IAM auth token expiry: IAM auth tokens expire after 15 minutes. Always generate fresh tokens per connection or implement periodic refresh. Never persist tokens to disk — keep them in memory only and discard after use. See authentication-guide.md (opens in a new tab).
Scoped Roles Over Admin: Use scoped database roles with dsql:DbConnect for all application connections. Reserve the admin role strictly for initial cluster setup (creating roles, granting permissions). Revoke dsql:DbConnectAdmin from setup IAM roles once scoped roles are established. See access-control.md (opens in a new tab).
Encryption in Transit: SSL/TLS is enforced server-side. Use sslmode=verify-full (default in DSQL connectors and psql-connect.sh) to validate the server certificate against DSQL’s CA, preventing MITM attacks. Only downgrade to require when the client lacks access to a trusted CA bundle.
Encryption at Rest: Aurora DSQL encrypts all data at rest using AWS-managed keys by default. No additional configuration is required; verify encryption status in cluster properties when compliance frameworks require attestation.
Audit Logging via CloudTrail: Enable CloudTrail logging for DSQL API calls to monitor token generation patterns, cluster configuration changes, and failed authentication attempts. Configure CloudWatch alarms for suspicious activity. Enable encryption on CloudWatch Log Groups used for DSQL monitoring using a KMS key to protect potentially sensitive query metadata. See authentication-guide.md (opens in a new tab).
Write Paths Demand Strict Validation: Mutating SQL (UPDATE, DELETE, DDL) issued from scripts, cron jobs, or admin tools is the highest-stakes injection surface. Every write path MUST route through safe_query.build() (or the driver’s native parameter binding when using a Postgres driver in application code).
Input Validation Is the Primary Defense: safe_query.build() is the primary defense against SQL injection on raw-SQL paths. Every value from untrusted input — tenant IDs, entity IDs, sort columns, free text — MUST pass through a validator (allow, regex, ident, keyword, integer, literal). Do not use f-strings, .format(), or concatenation. See input-validation.md (opens in a new tab).
Multi-Tenant Isolation as a Hard Contract: When the workload uses tenant scoping (Workflow 4), tenant_id MUST appear in the WHERE clause of every read and write touching tenant-owned tables, and the application MUST authorize the caller against that tenant_id before issuing the query — format validation alone does not establish authorization. Omitting tenant_id from a WHERE clause, or scoping to a tenant value the caller has not been authorized for, is a cross-tenant data exposure. This boundary is enforced by the skill, not by DSQL — verify every data-access path scopes to the authenticated tenant before deployment. See access-control.md (opens in a new tab) and Workflow 4.

Appendix 63.1–63.49

ReferencesMarkdown · 42 files

Scripts7 files

About this skill

Trigger

Colophon

platforms/ (opens in a new tab) — per-assistant install notes

Appendix 63.1–63.49

ReferencesMarkdown · 42 files

Scripts7 files