Skip to main content
INS // Insights

AWS Security Lake Architecture for Audit Evidence

Updated October 2026 · 7 min read

An AWS Security Lake architecture is the delegated security account, the three sources we turn on, and the query a reviewer can rerun when an auditor asks for a sample. The pain is the week before fieldwork. Someone exports CloudTrail from the log archive, someone else screenshots Security Hub, and a cluster admin pastes kubectl output into a ticket. The three files cover different clocks, different accounts, and different filters. The sample the auditor picks is the one file that does not contain the event. The lake is one place those three sources already land, in the same schema, for the window the audit covers.

Amazon Security Lake collects from native AWS sources and from custom sources, converts the native sources to the Open Cybersecurity Schema Framework, and writes Parquet to a bucket it manages. Subscribers read through Lake Formation. We use it as the evidence store for trail events, findings, and cluster audit logs. We leave the high-volume sources off until a named question requires them. The lake is a queryable record. It is not a detection program, and it does not replace the trail the organization already runs.

What this AWS Security Lake architecture collects

Three sources match the evidence the mid-market review actually asks for.

CloudTrail management events are the API history: who called which action, from which account, against which resource. Security Lake collects them only when a multi-Region organization trail is already logging read and write management events. Organization CloudTrail is that trail. Security Lake reads an independent stream. It does not replace the trail, and it does not change the bucket the trail already writes. S3 data events and Lambda data events are separate sources. We leave them off in the first build. They multiply volume, and the management-event sample is the one the access and change questions need.

Security Hub CSPM findings are the second source. The finding the auditor asks about is already in Security Hub: the control, the account, the resource, the workflow state. In the lake, that finding is an OCSF record next to the API call that preceded it. We do not build a second findings database. We subscribe the lake to the findings Security Hub already has, and we store the workflow state we observed when the sample was pulled.

EKS audit logs are the third source. They are the Kubernetes API record for clusters in the accounts we name. EKS control plane logging is the CloudWatch side of the same clusters, including authenticator logs the lake source does not replace. For the lake, we enable the EKS audit source on the clusters in scope. The result is a query that can return "this IAM principal, this verb, this namespace" beside the CloudTrail event for the AWS API around it.

Route 53 resolver logs, VPC flow logs, and WAF logs are native sources too. They answer network questions. They also dominate the bill and the partition count. The architecture we leave running is the three sources above. A later source is a row in the same ledger: source name, regions, date enabled, and the person who asked for it. Adding a source is a change. It is not a default.

Where the lake lives

The delegated administrator is a security account in the organization, not a workload account and not the management account. The data lake buckets, the Glue catalog, and the Lake Formation grants sit there. Rollup regions are explicit. We record which Regions collect and which Region holds the rollup. A Region that is enabled in the organization and absent from the lake config is an open row, the same way a missing trail Region is an open row.

Subscribers are how anyone reads the data. A subscriber gets a Lake Formation grant on the tables it needs, for the accounts in scope. The auditor's sample does not require a human with AdministratorAccess in the security account. It requires a role that can run the saved query. We create that role in the security account, scoped to the evidence workgroup. The query output lands in a prefix that access logs and that the workload accounts cannot delete. The GRC platform receives the sample file. The lake remains the system of record underneath the file.

Retention is a setting on the lake, and we store the value we set. A sample pulled for a window the lake has already expired is a gap, even when CloudTrail's own archive still has the event. The evidence row records both clocks: lake retention, and the trail archive retention. When they differ, the sample procedure says which store answers which question. API history that must survive the lake window still comes from the trail archive. The lake is the joined view for the window it holds.

delegated_admin_account: security
sources: cloudtrail_management, security_hub_findings, eks_audit
rollup_region: named
subscriber_role: evidence-query
lake_retention_days: policy
sample_query_id: q-14
sample_row_count: 42

A query we save is small. It filters to the account, the day, and the source. It returns a bounded sample, not an export of the Region. The evidence file stores the query text, the time it ran, the row count, and a hash of the result. Rerunning it is the test that the source is still on. A query that returns zero rows for an account that had production traffic is a source gap, and the row reopens.

What we do not ask the lake to decide

The lake holds records. It does not close an access review, and it does not declare an incident handled. A finding in the lake still needs the workflow state from Security Hub and the owner on the resource. An API call in the lake still needs the access-review decision if the question is whether that principal should have been able to call it. We link the sample to those systems by account id, principal, and time. We do not paste the sample into a ticket and call the control complete.

Custom sources are available for systems Security Lake does not natively collect. The first build does not depend on one. A homegrown application log can be a custom source later, with its own mapping into OCSF. Until that mapping exists, the application's evidence stays on its own pipeline. Pretending the lake already contains it produces a sample that is quietly missing the system the auditor named.

Cost sits in the source list. Management events for a mid-market organization are a tractable volume. Turning on every native source because the console offers them is how the security account's bill becomes the surprise. The ledger's source list is the control. AWS cloud infrastructure is where we build the delegated admin, the trail prerequisite, the subscriber role, and the saved queries.

Rutagon delivers that account boundary, the three sources, the subscriber, and the sample file. The organization trail keeps doing its job. Security Hub keeps the finding workflow. The lake is the place those records can be queried together for the audit window.

Frequently Asked Questions

Does Security Lake replace the organization CloudTrail trail?

The lake consumes CloudTrail management events through its own stream, and only after a multi-Region organization trail is logging read and write management events. The trail's bucket, retention, and integrity settings stay on the trail. A sample that has to outlive the lake retention still comes from that archive.

Why leave VPC flow logs out of the first build?

Flow logs, resolver logs, and WAF logs are native sources, and they dwarf management events in volume. The evidence questions this architecture answers are API history, findings, and Kubernetes audit. A network source is added as its own ledger row when a reviewer names the question it answers.

Who can query the lake?

A subscriber role in the security account, granted through Lake Formation on the tables in scope. Workload accounts do not get write access to the lake buckets. The sample file copied for the GRC platform is an output of a saved query, with the query text and the row count stored beside it.

What proves a source is still collecting?

The saved query for that source, account, and day returns rows, and the evidence file records the query id, the run time, and the count. A zero-row result for an account that should have traffic reopens the source row. The console toggle, by itself, is not the recheck.

Ask for an AWS infrastructure diagnostic that shows whether trail events, findings, and cluster audit logs can be sampled from one lake. Contact Rutagon at https://rutagon.com/contact, 907-841-8407, or contact@rutagon.com.