GuideIntermediate
Cloud Security And Guardrails
This guide takes the Andes Cargo Terraform project and pipeline left working by the three previous guides and teaches that a green pipeline is not a secure pipeline. It starts with threat modeling using the STRIDE framework applied to Andes Cargo's real infrastructure inventory, producing a threat model document that governs the rest of the guide. It builds real federated OIDC identity infrastructure (the identity provider, a least-privilege trust policy) against LocalStack, honest about the exact limit of what a free lab can validate for a real token, and tightens Andes Cargo's existing IAM roles to least privilege. It migrates secrets from a plain-text file to SSM Parameter Store and Secrets Manager, and scans the repository for leaked credentials. The guide's executed core is preventive policy-as-code: writing Rego policies with `conftest`/OPA that evaluate a Terraform `plan` before it can even be applied, replacing the handmade guardrail built in the CI/CD guide. It adds static IaC scanning with Trivy and Checkov, and real software supply chain work: generating an SBOM and signing/verifying a deployment artifact with `cosign`, fully offline, demonstrating that verification actually catches tampering. It closes by distinguishing preventive from detective guardrails and chaining `conftest` → Trivy → `cosign` into a real security gate inside the inherited pipeline, tested with a change that passes and one that gets stopped before applying.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Apply the STRIDE framework to model threats against real infrastructure and produce a threat model document
- Build federated OIDC identity infrastructure (identity provider, trust policy) and understand the exact limit of what a $0 lab can validate for a real token
- Tighten existing IAM roles to least privilege, trimming broad permissions down to the exact verbs the code actually uses
- Migrate secrets from a plain-text file to SSM Parameter Store and Secrets Manager, and decide when to use each
- Scan a repository for leaked credentials using community tools
- Write Rego policies with `conftest`/OPA that evaluate a `terraform plan` before applying it, preventively blocking dangerous changes
- Run static IaC scanning with Trivy and Checkov, and decide between fixing, suppressing, or accepting a finding
- Generate an SBOM (CycloneDX) for a deployment artifact and explain what questions it answers that a dependency file doesn't
- Sign and verify a deployment artifact with `cosign` offline, and demonstrate that verification catches tampering after signing
- Distinguish preventive from detective guardrails, and place each real AWS mechanism correctly (SCPs, permission boundaries, CloudTrail, GuardDuty, Config)
- Chain policy-as-code, scanning, and artifact verification into a security gate inside an existing CI/CD pipeline
Before you start
What you need to bring
It's for you if...
- Devs who already completed the CI/CD and GitOps on AWS Guide and need to harden a pipeline that already works
- Teams still storing long-lived AWS credentials in a repository who want to replace them with OIDC
- Devs who need to implement preventive policy-as-code instead of manually reviewing every infrastructure change
- Anyone who needs to cover the software supply chain gap (SBOM, artifact signing) that almost no market curriculum teaches
Requirements and materials
- Terraform and IaC Guide completed (the `andes-cargo-infra/` project, the `init`/`plan`/`apply`/`destroy` cycle)
- CI/CD and GitOps on AWS Guide completed (`act`, the `ci.yml`/`apply.yml`/`drift.yml` workflows running against LocalStack)
- Docker installed and running locally
- Free LocalStack account with an auth token, no credit card needed
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Guide introduction: from "it works" to "it's secure"
- 2. Green is not a synonym for secure
- 3. What threat modeling and the STRIDE framework are
- 4. Hands-on: mapping Andes Cargo's real attack surface
- 5. Applying STRIDE to Andes Cargo
- 6. The blast radius, revisited: what would have stopped it?
- 7. Hands-on: writing the threat model document
- 8. Project: Andes Cargo's risk map
- 1. Introduction: what was named is now built
- 2. The long-lived credential antipattern, revisited in depth
- 3. How OIDC federation works, step by step
- 4. Hands-on: creating the IAM OIDC Identity Provider
- 5. Hands-on: a least-privilege trust policy
- 6. Hands-on: what LocalStack validates, and what not, live
- 7. Hands-on: tightening Andes Cargo's existing roles
- 8. Project: Andes Cargo's federated identity
- 1. Introduction: who you are (Module 2) versus what you know (Module 3)
- 2. The antipattern: secrets in the repository
- 3. SSM Parameter Store vs. Secrets Manager: when to use each
- 4. Hands-on: SSM Parameter Store with LocalStack
- 5. Hands-on: Secrets Manager with LocalStack
- 6. Secret rotation: the real mechanism, named
- 7. Hands-on: scanning the repository for leaked secrets
- 8. Project: Andes Cargo's secrets inventory
- 1. Introduction: from human review of the `plan` to automatic policy
- 2. What Open Policy Agent and Rego are
- 3. Hands-on: installing `conftest`
- 4. Hands-on: your first Rego policy
- 5. From HCL to JSON: the `terraform plan` as `conftest`'s input
- 6. Hands-on: the "never destroy `Shipments`" policy
- 7. Hands-on: least privilege and public bucket policies
- 8. Project: Andes Cargo's policy library
- 1. Introduction: your own rules (M4) vs. community rules (M5)
- 2. The scanner landscape: Trivy, Checkov, and `tfsec`, with market honesty
- 3. Hands-on: installing Trivy
- 4. Hands-on: scanning `andes-cargo-infra/` with Trivy
- 5. Hands-on: installing and running Checkov
- 6. Reading a finding: fix, suppress, or accept the risk
- 7. Hands-on: adding scanning to the inherited pipeline
- 8. Project: Andes Cargo's security posture report
- 1. Introduction: the supply chain nobody teaches
- 2. What an SBOM is and why it matters
- 3. Hands-on: generating Andes Cargo's SBOM
- 4. What Sigstore solves: keyless vs. keypair
- 5. Hands-on: installing `cosign` and a local keypair
- 6. Hands-on: signing and verifying the deployment artifact
- 7. Hands-on: breaking the chain on purpose
- 8. Project: Andes Cargo's supply chain package
- 1. Introduction: the handrail vs. the security camera
- 2. Preventive guardrails: SCPs and permission boundaries
- 3. Hands-on: a permission boundary for `AppServerRole`
- 4. Detective guardrails: CloudTrail, Config, and GuardDuty, named
- 5. Hands-on: CloudTrail, as far as LocalStack goes
- 6. SCPs and multi-account, named
- 7. Hands-on: an alarm on a sensitive IAM event
- 8. Project: Andes Cargo's guardrails map
- 1. Capstone introduction
- 2. Architecture review: the full security gate
- 3. Hands-on: chaining the gate into `ci.yml`
- 4. End-to-end walkthrough: a change that passes the complete gate
- 5. End-to-end walkthrough: a change the gate stops
- 6. What this guide left representative, final honesty
- 7. What Andes Cargo still needs
- 8. Final project: Andes Cargo's security gate as a deliverable
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!