Skip to Content
Cloud Engineering Academy
1. Cloud Computing & AWS Fundamentals

The Shared Responsibility Model

Draw the line between what AWS secures and what Harbourline Bank still owns, for EC2, RDS, Fargate, Lambda and S3, and collect evidence for your side of the line.

beginner⏱ 1 h 15 min🟢 FreeCLF-C02SAA-C03SCS-C03

Assumes: .NET 10 LTS · AWS SDK for .NET v4 (AWSSDK.S3 4.1.1) · AWS CLI v2 · Region us-east-1. Verified against official sources on 2026-11-17.

Learning objectives

By the end of this lesson you can:

  • Explain the difference between security of the cloud (AWS's job) and security in the cloud (your job) in two sentences.
  • Show how the line moves between Amazon EC2, Amazon RDS, AWS Fargate, AWS Lambda and Amazon S3, and say who patches what.
  • Classify a control as inherited, shared or customer-specific.
  • List what a bank still owns after moving to AWS: data, identity, keys, logging, incident response, third-party risk management and regulatory accountability.
  • Download AWS's own audit reports from AWS Artifact and produce evidence for your side of the line with the CLI and C#.

Prerequisites

Why this matters in banking

Picture a Monday-morning call. A fictional fintech partner of Harbourline Bank has exposed 40,000 statement PDFs from an S3 bucket. The partner's first message says "but S3 is secure, AWS is certified". Both statements are true and irrelevant. AWS kept its data centres, disks and S3 service secure. The partner switched off Block Public Access and wrote a bucket policy with "Principal": "*". That configuration sits entirely on the customer's side of the line.

Regulators see it the same way. Under UK GDPR the bank is the controller of its customers' personal data; AWS is a processor. Under the PRA's outsourcing rules and the EU's Digital Operational Resilience Act (DORA), the bank stays accountable for the service even when a cloud provider runs part of it. "Our provider is certified" is never an answer to an auditor. You need to know exactly which controls you inherit, which you share, and which are yours alone, and you need evidence for each.

The idea in plain language

AWS runs the building, the power, the network cables, the servers, the hypervisor and the software behind each managed service. That is security of the cloud. Everything you put into AWS and every setting you choose is security in the cloud: your data, who can access it, how it is encrypted, how your network is opened, what code you run and how you watch it.

The line is not fixed. It moves depending on how much of the stack the service manages for you:

  • With EC2 (a virtual machine) you get a bare server. You patch the operating system, harden it, install the runtime, configure the firewall (security groups) and back it up.
  • With Lambda (functions as a service) AWS patches the operating system and the managed .NET runtime. You own your code, its dependencies, its IAM role and its configuration.
  • With S3 (object storage) there is no server to see at all. You still own the data, the bucket policy, Block Public Access, encryption choices and access logging.

Analogy: Renting a safe-deposit box. The bank (AWS) builds the vault, guards the door, runs the CCTV and checks ID at the entrance. You (the customer) decide what goes in the box, who gets a copy of your key, and whether you leave the box open on the counter. If you hand your key to a stranger, the vault's guards did nothing wrong.

A second analogy fits the moving line: renting a home. An unfurnished flat (EC2) means you fit the locks on the internal doors and maintain the boiler. A serviced apartment (Lambda) means the landlord maintains the building and appliances, but you still decide who gets a key and what you leave lying around.

What problem the Shared Responsibility Model solves

The model is not a service; it is a contract of expectations. It solves three problems:

  1. Clarity. It tells engineers and auditors which controls they must design, operate and evidence themselves.
  2. Inheritance. It lets you reuse AWS's independently audited controls (for example physical security) instead of re-auditing data centres you cannot visit.
  3. Scale. Because AWS handles the undifferentiated lower layers, your team can spend its effort on the layers that are specific to your bank.

AWS groups controls into three types (checked against the official Shared Responsibility Model page on 2026-11-17):

Control typeWhoExamples AWS givesHarbourline example
InheritedAWS fullyPhysical and environmental controlsData-centre access logs, fire suppression, hardware disposal
SharedBoth, each in its own layerPatch management, configuration management, awareness and trainingAWS patches the Lambda runtime; Harbourline patches the NuGet packages inside the function
Customer-specificCustomer onlyService and communications protection or zone securityRouting card-processing traffic only through private subnets and VPC endpoints

Limitations and sharp edges:

  • The model is a principle, not a per-service checklist. Each service's "Security" chapter in the AWS documentation spells out the details. Read it before you approve a new service.
  • "AWS manages it" does not mean "AWS configures it the way your bank needs". RDS patches the database engine, but you choose whether automatic minor version upgrades are on and when the maintenance window runs.
  • Compliance reports describe AWS's controls. They do not cover your configuration, your code or your people.

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure shared responsibility (IaaS/PaaS/SaaS columns)AWS Shared Responsibility ModelSame idea. AWS describes it per service rather than in one grid, and uses inherited/shared/customer-specific control types
Azure VM: you patch the guest OSEC2: you patch the guest OS (AWS Systems Manager Patch Manager can automate it)Identical split
Azure App Service / Functions: Microsoft patches the platformLambda / Fargate: AWS patches the host and, for Lambda managed runtimes, the runtimeContainer images on Fargate are still yours to patch
Azure SQL DatabaseAmazon RDS / AuroraYou still own users, network exposure, encryption choice, backup retention and the maintenance window
Service Trust Portal (SOC, ISO reports)AWS ArtifactFree, in the console and through the aws artifact CLI
Microsoft Products and Services Data Protection AddendumAWS Customer Agreement + AWS GDPR Data Processing Addendum (part of the AWS Service Terms)Legal and procurement review it, not engineers
Azure Key Vault Managed HSM / customer-managed keysAWS KMS customer managed keys, CloudHSM-backed custom key stores, external key storesMore options for "who physically holds the key"

Architecture

The diagram shows where the line sits for five services. Everything above the dashed line in each column is Harbourline's job.

Where the line sits, service by service

TaskEC2RDSFargate (ECS)Lambda (managed .NET runtime)S3
Physical security, hardware, hypervisorAWSAWSAWSAWSAWS
Host / guest OS patchingYouAWSAWS (host)AWSAWS
Runtime or engine patchingYou (.NET, IIS, SQL Server you install)AWS applies; you choose window and upgrade policyYou (base image and .NET inside the container)AWS (managed runtime); you for container-image functionsNot applicable
Application code and librariesYouYou (schema, stored procedures, users)YouYouYou (object content)
Network exposureYou: security groups, NACLs, public IPsYou: subnet group, security group, public accessibility flagYou: subnets, security groupsYou: VPC attachment, function URL auth, resource policyYou: Block Public Access, bucket policy, VPC endpoint policy
Encryption at restYou enable EBS encryption and pick the keyYou enable it at creation (cannot be switched on later in place)You for attached volumes and secretsAWS encrypts environment variables by default; you may pick a customer managed keyOn by default (SSE-S3) for new objects since 2023; you choose SSE-KMS if you need key control
IAM permissionsYou (instance profile)You (IAM auth, DB users)You (task role, execution role)You (execution role)You (IAM and bucket policies)
BackupsYou (snapshots, AWS Backup)Shared: AWS takes automated backups; you set retention and test restoresYou (data lives elsewhere)You (code in Git, data elsewhere)You: versioning, replication, Object Lock
LoggingYou enable and retainYou enable log exportsYou configure log driverYou set log retentionYou enable server access logs or CloudTrail data events

Notice the bottom half of the table. No matter how managed the service is, IAM, network exposure, encryption choices, logging and data stay with you. That is the part a bank can never outsource.

Step-by-step implementation

You cannot "turn on" a responsibility model, but you can make your side of it visible. The steps below build a one-page responsibility record for one workload: the statement bucket from the module exercise.

Describe the workload in one sentence

"Harbourline statement store: an S3 bucket in the sandbox account in us-east-1 holding fictional monthly PDF statements, read by a .NET console app through an IAM Identity Center role."

List the components and their service model

S3 bucket (abstracted service), IAM Identity Center permission set (identity), the .NET app on your laptop (your code), the learn-sandbox SSO profile (your credential path).

For each layer, write who owns it

Use the table above. For S3, AWS owns storage hardware, durability and the service software. Harbourline owns: Block Public Access, object ownership, default encryption choice, TLS-only bucket policy, IAM permissions, tags, logging and lifecycle.

Collect evidence for your side

Run the CLI commands below, or the C# checker in the Complete code section, and save the output with the date. Evidence that is not dated and stored is not evidence.

Collect evidence for AWS's side

Download the current SOC 2 Type II report from AWS Artifact (steps below). File it next to your own evidence. Note its period end date: auditors care about coverage gaps.

Record the gaps

Anything nobody owns is a finding. Typical first-time gaps: no one owns log retention, no one tests restores, nobody reviews IAM access quarterly.

AWS Console instructions

Get AWS's audit reports (AWS Artifact):

  1. Sign in through the access portal to the sandbox account with SandboxAdmin.
  2. Console → search "Artifact" → AWS Artifact → Reports.
  3. Search for SOC 2. Select the report and choose Download report. You must accept the terms (confidentiality conditions) before downloading. Read them: AWS reports are usually confidential and may only be shared under the conditions stated.
  4. Repeat for PCI DSS Attestation of Compliance and ISO/IEC 27001 if you want to see what they look like.

Check your side on a bucket:

  1. Console → S3 → Buckets → select your bucket → Permissions.
  2. Block public access (bucket settings): all four settings should show On.
  3. Object Ownership: should show Bucket owner enforced (ACLs disabled).
  4. Bucket policy: look for a statement that denies requests where aws:SecureTransport is false.
  5. Properties → Default encryption: shows SSE-S3 or SSE-KMS.

Check what AWS says it covers: the AWS Services in Scope by Compliance Program page lists which services each programme (SOC, PCI, ISO and others) covers. If a service is not in scope for PCI DSS, it should not touch cardholder data at Harbourline.

AWS CLI

# 1. Encryption at rest on a bucket (your choice, AWS runs the service).
aws s3api get-bucket-encryption --bucket hl-m01-statements-111122223333-a1b2c3 --profile learn-sandbox

# 2. Block Public Access settings on the bucket (all four should be true).
aws s3api get-public-access-block --bucket hl-m01-statements-111122223333-a1b2c3 --profile learn-sandbox

# 3. Account-level Block Public Access (a safety net for every bucket in the account).
aws s3control get-public-access-block --account-id 111122223333 --profile learn-sandbox

# 4. Is the bucket policy considered public by S3's own policy analysis?
aws s3api get-bucket-policy-status --bucket hl-m01-statements-111122223333-a1b2c3 --profile learn-sandbox

# 5. Object ownership: BucketOwnerEnforced means ACLs are disabled.
aws s3api get-bucket-ownership-controls --bucket hl-m01-statements-111122223333-a1b2c3 --profile learn-sandbox

# 6. AWS's side: list AWS compliance reports available in AWS Artifact (id, name, period).
aws artifact list-reports --profile learn-sandbox --region us-east-1 \
  --query "reports[?contains(name, 'SOC')].[id, name, periodEnd]" --output table

# 7. To download one: first get the terms token for that report, then the report URL.
aws artifact get-term-for-report --report-id report-abcdEFGH12345678 --profile learn-sandbox --region us-east-1
aws artifact get-report --report-id report-abcdEFGH12345678 --term-token "<token from previous call>" --profile learn-sandbox --region us-east-1
  • Commands 1 to 5 are read-only and cost nothing (S3 control-plane requests like these are not billed as storage requests ⚠ VERIFY; at worst they are fractions of a cent).
  • get-public-access-block returns NoSuchPublicAccessBlockConfiguration if the bucket has none. That is a finding, not an error in your command.
  • The artifact commands exist in AWS CLI v2 (list-reports, get-term-for-report, get-report, list-customer-agreements and others). Run them in us-east-1 ⚠ VERIFY the Regions where the Artifact API is available. The report ID above is a fictional placeholder in the documented report- + 16 characters format.
  • In PowerShell, replace the \ line continuation with a backtick or write the command on one line.

Infrastructure as Code

Your side of the line is configuration, so it belongs in code where it can be reviewed and re-applied. Both versions create a bucket where every customer-owned S3 control is explicit. The Terraform file assumes a provider "aws" block with region = "us-east-1" and profile = "learn-sandbox" (the pattern from Secure your AWS account, with AWS provider ~> 6.x); the CDK stack needs a CDK app and cdk bootstrap in the sandbox account.

statement-bucket.tf
resource "aws_s3_bucket" "statements" {
  bucket_prefix = "hl-m01-statements-"
  tags = {
    Project     = "cea-lab"
    Lab         = "m01-hello-aws"
    Environment = "learn"
    Owner       = "alex"
  }
}

# Customer-owned control: no public access, ever.
resource "aws_s3_bucket_public_access_block" "statements" {
  bucket                  = aws_s3_bucket.statements.id
  block_public_acls       = true
  ignore_public_acls      = true
  block_public_policy     = true
  restrict_public_buckets = true
}

# Customer-owned control: ACLs disabled, access only through IAM and bucket policy.
resource "aws_s3_bucket_ownership_controls" "statements" {
  bucket = aws_s3_bucket.statements.id
  rule {
    object_ownership = "BucketOwnerEnforced"
  }
}

# Customer-owned choice: which encryption. SSE-S3 here; SSE-KMS with your own key in production.
resource "aws_s3_bucket_server_side_encryption_configuration" "statements" {
  bucket = aws_s3_bucket.statements.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

# Customer-owned control: refuse any request that is not over TLS.
data "aws_iam_policy_document" "tls_only" {
  statement {
    sid     = "DenyInsecureTransport"
    effect  = "Deny"
    actions = ["s3:*"]
    principals {
      type        = "*"
      identifiers = ["*"]
    }
    resources = [aws_s3_bucket.statements.arn, "${aws_s3_bucket.statements.arn}/*"]
    condition {
      test     = "Bool"
      variable = "aws:SecureTransport"
      values   = ["false"]
    }
  }
}

resource "aws_s3_bucket_policy" "statements" {
  bucket     = aws_s3_bucket.statements.id
  policy     = data.aws_iam_policy_document.tls_only.json
  depends_on = [aws_s3_bucket_public_access_block.statements]
}

The module exercise app (lab-hello-aws) applies the same settings with the SDK, so you can compare three ways of owning the same controls.

Complete code

A read-only C# checker that turns "our side of the line" into a pass/fail report for one bucket. It uses the default credential chain, so set AWS_PROFILE first.

Harbourline.ResponsibilityCheck.csproj
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <RootNamespace>Harbourline.ResponsibilityCheck</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="AWSSDK.S3" Version="4.1.1" />
    <!-- Needed at runtime so IAM Identity Center (SSO) profiles resolve. -->
    <PackageReference Include="AWSSDK.SSO" Version="4.1.0.2" />
    <PackageReference Include="AWSSDK.SSOOIDC" Version="4.1.0.2" />
  </ItemGroup>
</Project>
Program.cs
// Harbourline.ResponsibilityCheck: prints evidence that "your side" of the
// Shared Responsibility Model is configured on one S3 bucket. Read-only.
// Usage: dotnet run -- <bucket-name>   (with AWS_PROFILE=learn-sandbox and a valid SSO session)
using Amazon.S3;
using Amazon.S3.Model;

if (args.Length != 1)
{
    Console.Error.WriteLine("Usage: dotnet run -- <bucket-name>");
    return 2;
}

var bucket = args[0];
using var s3 = new AmazonS3Client(); // default credential chain + Region from AWS_PROFILE / AWS_REGION
var findings = new List<(string Control, bool Ok, string Detail)>();

// 1. Encryption at rest (customer chooses the key type; AWS runs the encryption service).
var enc = await s3.GetBucketEncryptionAsync(new GetBucketEncryptionRequest { BucketName = bucket });
var rule = enc.ServerSideEncryptionConfiguration?.ServerSideEncryptionRules?.FirstOrDefault();
var algorithm = rule?.ServerSideEncryptionByDefault?.ServerSideEncryptionAlgorithm?.Value ?? "none";
findings.Add(("Default encryption", algorithm is "AES256" or "aws:kms" or "aws:kms:dsse", algorithm));

// 2. Block Public Access (customer configuration; AWS enforces it).
try
{
    var pab = await s3.GetPublicAccessBlockAsync(new GetPublicAccessBlockRequest { BucketName = bucket });
    var c = pab.PublicAccessBlockConfiguration;
    var allOn = c is not null && c.BlockPublicAcls == true && c.IgnorePublicAcls == true
                && c.BlockPublicPolicy == true && c.RestrictPublicBuckets == true;
    findings.Add(("Block Public Access (all four)", allOn, allOn ? "on" : "at least one setting is off"));
}
catch (AmazonS3Exception ex) when (ex.ErrorCode == "NoSuchPublicAccessBlockConfiguration")
{
    findings.Add(("Block Public Access (all four)", false, "not configured on the bucket"));
}

// 3. Object ownership: ACLs disabled means only IAM and bucket policies grant access.
try
{
    var own = await s3.GetBucketOwnershipControlsAsync(new GetBucketOwnershipControlsRequest { BucketName = bucket });
    var mode = own.OwnershipControls?.Rules?.FirstOrDefault()?.ObjectOwnership?.Value ?? "unknown";
    findings.Add(("ACLs disabled (BucketOwnerEnforced)", mode == "BucketOwnerEnforced", mode));
}
catch (AmazonS3Exception ex) when (ex.ErrorCode == "OwnershipControlsNotFoundError")
{
    findings.Add(("ACLs disabled (BucketOwnerEnforced)", false, "no ownership controls"));
}

// 4. Is the bucket policy public? (AWS evaluates the policy for you.)
try
{
    var status = await s3.GetBucketPolicyStatusAsync(new GetBucketPolicyStatusRequest { BucketName = bucket });
    var isPublic = status.PolicyStatus?.IsPublic == true;
    findings.Add(("Bucket policy not public", !isPublic, isPublic ? "PUBLIC" : "not public"));
}
catch (AmazonS3Exception ex) when (ex.ErrorCode == "NoSuchBucketPolicy")
{
    findings.Add(("Bucket policy not public", true, "no bucket policy (TLS-only policy recommended)"));
}

foreach (var (control, ok, detail) in findings)
{
    Console.WriteLine($"{(ok ? "PASS" : "FAIL"),-5} {control,-38} {detail}");
}

return findings.All(f => f.Ok) ? 0 : 1;

Run it:

aws sso login --profile learn-sandbox
$env:AWS_PROFILE = "learn-sandbox"
dotnet run -- hl-m01-statements-111122223333-a1b2c3

Expected output for a bucket created by the module exercise:

PASS  Default encryption                     AES256
PASS  Block Public Access (all four)         on
PASS  ACLs disabled (BucketOwnerEnforced)    BucketOwnerEnforced
PASS  Bucket policy not public               not public

This code compiled cleanly with .NET 10 and the package versions shown on 2026-11-17 (warnings as errors). Running it needs your AWS account.

Code explained line by line

  1. using Amazon.S3; using Amazon.S3.Model; bring in the S3 client and its request/response types from the AWSSDK.S3 package.
  2. The args.Length check returns exit code 2 for wrong usage, so scripts can tell "bad input" from "control failed" (exit code 1).
  3. new AmazonS3Client() with no arguments uses the SDK's default credential provider chain and Region resolution. With AWS_PROFILE=learn-sandbox it uses your SSO session. See SDK first contact.
  4. findings is a list of tuples: control name, pass or fail, and the detail to print. It keeps the report logic separate from the AWS calls.
  5. GetBucketEncryptionAsync reads the bucket's default encryption rule. Since January 2023 every bucket has at least SSE-S3, so a "none" result is very unlikely; the check still documents which option you chose.
  6. ServerSideEncryptionAlgorithm?.Value is an SDK "constant class", not a C# enum. .Value gives the wire string such as AES256 or aws:kms.
  7. GetPublicAccessBlockAsync returns the four Block Public Access flags. In SDK v4 these properties are nullable bool?, so the code compares with == true rather than assuming a default.
  8. The catch ... when (ex.ErrorCode == "NoSuchPublicAccessBlockConfiguration") turns "nothing configured" into a FAIL finding instead of a crash. Exception filters keep other errors (such as AccessDenied) propagating so you notice them.
  9. GetBucketOwnershipControlsAsync returns the object ownership mode. BucketOwnerEnforced disables ACLs entirely, which removes a whole class of accidental public grants.
  10. GetBucketPolicyStatusAsync asks S3 itself whether the policy is public. This is better than parsing JSON yourself: S3 applies its own rules for what "public" means.
  11. NoSuchBucketPolicy is treated as a pass with advice, because no policy is not public, but a TLS-only policy is recommended.
  12. The foreach prints aligned columns (-5, -38 are left-aligned widths) so the output can be pasted into an evidence record.
  13. The final return gives exit code 0 only if every control passed, so a CI pipeline can fail on drift.

Security considerations

  • Least privilege for the checker: it needs only s3:GetEncryptionConfiguration, s3:GetBucketPublicAccessBlock, s3:GetBucketOwnershipControls and s3:GetBucketPolicyStatus on the bucket ARN. Give an evidence-collection role exactly those, not AdministratorAccess.
  • Evidence integrity: store evidence in a separate account and bucket with versioning and Object Lock, so the team being audited cannot edit it. Module 5 and Module 15 build this.
  • Artifact reports are confidential. Do not paste them into chat tools, tickets visible to suppliers, or public repositories. Respect the terms you accepted.
  • Customer managed keys move work to you. With SSE-KMS and your own key, you own the key policy, rotation settings and the risk of locking yourself out. Choose it because you need it (separation of duties, crypto-shredding, audit of every decrypt), not by default.

⚠ Learning shortcut — not for production

The lab bucket uses SSE-S3 (keys fully managed by AWS) and you check it by hand from your laptop with an administrator role. In a bank, statement buckets typically use SSE-KMS with a customer managed key whose key policy separates key administrators from key users. The checks run continuously through AWS Config rules and Security Hub CSPM controls in a central security account, and findings route to a ticketing system. Module 5 builds that version.

⚠ Learning shortcut — not for production

In this course one person accepts the Artifact terms, configures the bucket and reviews the evidence. A bank separates these roles: procurement and legal accept agreements, engineering configures, a second line risk function reviews, and internal audit tests independently.

Banking use case

Harbourline Bank is moving its monthly statement generation from an on-premises Windows service to AWS: a .NET 10 Lambda function writes PDFs to S3, and customers download them through the mobile app. The architecture review board asks the team for a responsibility matrix before go-live. The team's matrix, simplified, reads:

AreaAWSHarbourline (engineering)Harbourline (risk, legal, compliance)
Data-centre, hardware, Lambda and S3 service securityOperates; evidence in SOC 2 / ISO 27001 reports via ArtifactDownloads and files current reportsReviews report scope, period and exceptions
Lambda runtime patchingPatches the managed dotnet10 runtimeKeeps NuGet dependencies patched; redeploysSets patch SLAs
Data classificationNoneTags bucket DataClassification=confidentialOwns the classification scheme
Personal data (UK GDPR)Processor under the AWS GDPR DPAImplements retention (S3 Lifecycle), access controls, encryptionController duties: lawful basis, DPIA, data-subject rights, breach notification within 72 hours to the ICO where required
KeysRuns KMS (FIPS-validated HSMs ⚠ VERIFY current validation level)Creates customer managed key, key policy, rotationApproves key-management standard: KMS, CloudHSM custom key store or external key store
Identity and accessRuns IAM and Identity CenterLeast-privilege roles; no human access to the bucket in productionQuarterly access reviews
Logging and detectionDelivers CloudTrail and service logsOrganisation trail, retention, alertsDefines retention periods for regulatory record-keeping
Incident responseNotifies customers of AWS-side events (AWS Health)Runbooks, on-call, forensics in the accountRegulatory incident reporting (PRA/FCA, and DORA for the EU subsidiary)
Third-party riskProvides assurance reports, contractual commitmentsExit plan technical feasibility, data export testedOutsourcing register, materiality assessment, contract review, concentration risk

What the bank still owns, in plain words

  • Data. Harbourline decides what data goes to AWS, classifies it, minimises it and deletes it on schedule. AWS does not look inside your objects or tell you that a bucket holds personal data unless you run a service such as Amazon Macie.
  • Identity. Every IAM policy, role trust, Identity Center assignment and SCP is the bank's. Most cloud breaches are identity breaches.
  • Keys. The bank chooses the key model:
    • AWS KMS with customer managed keys ($1 per key per month, plus requests): key material lives in AWS-operated HSMs; you control the key policy and usage.
    • KMS custom key store backed by AWS CloudHSM: keys in single-tenant HSMs that you manage in your VPC. CloudHSM is billed per HSM per hour, and a resilient cluster needs at least two HSMs in different AZs, so this costs well over USD 1,000 per month ⚠ VERIFY current hourly price on the CloudHSM pricing page.
    • KMS external key store (XKS): key material stays in a key manager outside AWS that you operate. Strongest "hold your own key" story, but your key manager's availability becomes part of every encrypt and decrypt call.
  • Logging and evidence. AWS records API calls in CloudTrail; the bank decides to keep them, for how long, where, and who can read them.
  • Incident response. AWS will not investigate a compromised IAM role in your account. Your security team does.
  • Third-party and outsourcing risk. In the UK, the PRA's supervisory statement SS2/21 sets expectations for outsourcing and third-party risk management, including materiality assessments, contractual rights, data security and exit plans. For the EU subsidiary, the EBA Guidelines on outsourcing arrangements and DORA (applying since 17 January 2025) require ICT third-party risk management and a register of ICT contractual arrangements. On 18 November 2025 the European Supervisory Authorities designated AWS (as Amazon Web Services EMEA SARL) one of the critical ICT third-party providers under DORA, which means direct oversight of AWS by EU authorities. This oversight does not move the bank's own obligations to AWS. The bank remains responsible for its operational resilience. How these rules apply to a specific workload is a question for the bank's risk, compliance and legal teams, not for an architecture diagram.
  • Contracts. The AWS Customer Agreement, the AWS Service Terms (which include the GDPR Data Processing Addendum) and any negotiated enterprise or financial-services addendum are reviewed by legal and procurement. AWS Artifact Agreements shows which agreements your account or organisation has accepted.

Common mistakes

  • "AWS is PCI compliant, so our app is." → AWS's Attestation of Compliance covers AWS's controls for in-scope services → your cardholder-data environment still needs its own assessment. Use AWS's AoC as one input to yours.
  • Assuming managed means configured. → RDS is "managed" → people leave PubliclyAccessible=true or skip encryption at creation. Encryption must be chosen when the instance is created.
  • Forgetting container images on Fargate. → "Fargate is serverless" → AWS patches the host, not your image. Rebuild images on a schedule and scan them (Amazon ECR scanning, Module 9).
  • Treating Lambda as patch-free. → AWS patches the managed runtime → outdated NuGet packages in your deployment package are still yours.
  • No owner for logs. → CloudTrail is on by default for 90 days of management events in Event history → but that is not a retained, tamper-resistant trail. Create a trail to S3 with a retention policy.
  • Downloading Artifact reports once. → They have audit periods → a two-year-old SOC report does not cover today. Refresh at least annually and note the bridge letter if a period gap exists.

Troubleshooting

SymptomLikely causeFix
NoSuchPublicAccessBlockConfiguration from get-public-access-blockNo bucket-level Block Public Access settingsApply all four settings (put-public-access-block) and recheck; also check the account-level setting
AccessDenied on Artifact Download reportMissing artifact:GetReport / artifact:GetTermForReport permissions, or terms not acceptedUse SandboxAdmin, accept the terms, or add the Artifact read permissions to a dedicated evidence role
aws artifact list-reports returns an endpoint errorRegion where the Artifact API is not offeredAdd --region us-east-1
ServerSideEncryptionConfigurationNotFoundErrorVery old bucket or a non-AWS S3-compatible endpointUnlikely on AWS since 2023; set default encryption explicitly
The C# checker throws AmazonS3Exception: AccessDenied for one call onlyThe role can read some bucket settings but not othersAdd the specific s3:Get... permission listed under Security considerations
Checker says Bucket policy not public but you expected a TLS policyNo policy existsAdd the TLS-only deny statement shown in the IaC section

Cost and cleanup

Cost: $0. AWS Artifact is free. The CLI and SDK reads above are configuration requests on a bucket and cost nothing noticeable. The IaC examples create an S3 bucket that holds no data: storage cost is zero until you upload objects.

If you deployed the IaC example, remove it:

# Terraform version
terraform destroy

# CDK version (AutoDeleteObjects empties the bucket first)
cdk destroy

# Confirm nothing tagged for this lab remains
aws resourcegroupstaggingapi get-resources --tag-filters Key=Lab,Values=m01-hello-aws --profile learn-sandbox --query "ResourceTagMappingList[].ResourceARN"

The tagging API can show recently deleted resources for a short while. If an ARN still appears, check it with the service's own describe/head call.

Exercises

  • 🟢 Guided: Run the six CLI commands against a bucket configured like the module-exercise bucket. The module exercise deletes its bucket at the end, so either check its README for an option to keep the bucket, or create one with the Terraform above and destroy it afterwards. Download the latest AWS SOC 2 Type II report from Artifact and write down its period end date.
  • 🟡 Challenge: Fill in the "where the line sits" table for Amazon DynamoDB and Amazon ECS on EC2 (not Fargate) using each service's security documentation. Where does the line differ from Fargate?
  • 🔴 Live problem: A product owner writes: "Legal says we can put customer statements in S3 because AWS is ISO 27001 certified. Can you just create the bucket today?" Write the reply you would send, covering what ISO 27001 does and does not tell you, which customer-owned controls you will apply, and which internal teams must sign off.

Assignment

Create docs/responsibility-matrix.md in your learning-journal repository for the module-exercise workload. Include: the workload sentence, the per-layer ownership table, the dated output of the C# checker, the name and period of the AWS report you downloaded (not the report itself), and a "gaps and owners" list.

Solutions

Knowledge check

Interview questions

  • "Explain the Shared Responsibility Model to a non-technical risk manager." — AWS secures the facilities, hardware and the managed software it runs; we secure everything we configure and store: data, access, encryption choices, network exposure, logging and our code. How much of the middle layer AWS takes on depends on the service: very little for a VM, a lot for serverless.
  • "We use Lambda. What security work is left for us?" — Least-privilege execution role, dependency patching and scanning, secrets in Secrets Manager rather than environment variables, input validation, resource policies on function URLs or API Gateway, log retention and alerting, and the data the function touches.
  • "How do you evidence AWS's controls to an auditor?" — Download the relevant reports (SOC 2 Type II, ISO certificates, PCI AoC) from AWS Artifact, check that the services we use are in scope, note the period and any exceptions, and pair them with our own evidence for customer-side controls.
  • "What would make you choose CloudHSM or an external key store over standard KMS?" — A regulatory or internal policy requirement for single-tenant HSMs or for key material to stay outside AWS, balanced against higher cost, operational burden and availability risk.

Certification practice

Completion checklist

  • I can explain security of vs in the cloud in two sentences
  • I can fill the "where the line sits" table for EC2, RDS, Fargate, Lambda and S3 from memory
  • I ran the CLI evidence commands or the C# checker against a bucket I own
  • I downloaded an AWS SOC 2 report from Artifact and noted its period
  • I can list seven things a bank still owns after moving to AWS
  • I destroyed any IaC bucket I created and confirmed with the tagging API

Key takeaways

  • AWS secures the cloud; you secure what you put in it and how you configure it.
  • The line moves with the service: EC2 leaves you the OS, Lambda leaves you code and configuration, S3 leaves you data and access settings.
  • Identity, data, network exposure, encryption choices, logging and incident response never move to AWS.
  • AWS's certifications are evidence for AWS's controls only; collect your own evidence for yours.
  • Regulators hold the bank accountable for outsourced services, including AWS, even under DORA's direct oversight of AWS.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page