GuideAdvanced
Genai On Aws Production
Adds Andes Cargo's first generative AI workload: an extractor that kicks in when the inherited deterministic manifest parser can't read free-text input, invoking an Amazon Bedrock model as an escalation path, never as the default. This is the only guide in the ecosystem where no real model invocation runs inside the lab — Bedrock requires a paid account and is only available on LocalStack's Ultimate plan — so it declares the entire infrastructure as real code (`terraform validate`/`plan` genuinely verified, with no LocalStack or AWS account needed), builds Bedrock Guardrails' six policies as HCL, and complements them with its own defense-in-depth layer (a PII scrubber and an output schema validator, both deterministic and tested with `pytest`). It extends the security gate and cost gate the sibling guides already built (least-privilege IAM for `bedrock:InvokeModel`, a new cost policy) and computes per-token cost with its own calculator, since Infracost can't price a volume assumption nobody declared. It applies SLI/SLO vocabulary to AI metrics (escalation rate, guardrail block rate, latency) and closes with a capstone that runs the cheap path end to end and documents, with exact honesty, where the executable stops and the representative begins. It doesn't teach prompt engineering, RAG, agents, or semantic evaluation — that's AI Engineering territory; this guide teaches how to operate, not build, the AI system.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Tell a notebook prototype apart from a generative AI workload in production, and understand the core architecture decision: the cheap, deterministic path stays the default, the LLM is only the escalation path
- Understand how Bedrock is actually billed (on-demand, Provisioned Throughput, Batch, Flex, Priority) and what invocation-per-minute quotas are
- Declare an AI workload's infrastructure as real Terraform code — `aws_bedrock_guardrail`, a least-privilege IAM role for `bedrock:InvokeModel` — with `validate`/`plan` genuinely verified, with no dependency on LocalStack or an AWS account
- Declare Bedrock Guardrails' six policies (content filters, PII, denied topics, contextual grounding, word filters) as code, and build your own deterministic defense-in-depth layer (PII scrubber, output schema validator) that never depends on the model existing in the lab
- Extend the already-built security gate (`conftest`/Trivy/`cosign`) to this guide's new Terraform and artifact, with a least-privilege policy specific to the model
- Extend the already-built cost gate with a per-token cost model: your own deterministic calculator, a budget policy, and cost-allocation tagging for the AI workload
- Apply SLI/SLO vocabulary to AI-specific metrics: escalation rate from the deterministic path to the LLM (computable without invoking the model), your own guardrail's block rate, and inference latency (representative, with its technical reason stated)
- Run a capstone that genuinely executes the deterministic path end to end and documents, with an explicit honesty ledger, exactly where the system stops being executable and becomes representative
Before you start
What you need to bring
It's for you if...
- Cloud, backend, or DevOps engineers who completed the seven prior AWS Cloud ecosystem guides and want to add their first generative AI workload to that same infrastructure
- AI Engineering graduates who already know how to build with an LLM (prompting, function calling, structured outputs) but never learned to operate one in production: IAM, guardrails as code, per-token cost, observability
- Teams evaluating adding Bedrock to a real system who want to understand the infrastructure, security, and cost discipline before invoking a single token
- Not for anyone looking to learn prompt engineering, RAG, agents, or building an AI application from scratch — that boundary with AI Engineering is respected without exception in this guide
Requirements and materials
- The seven prior AWS Cloud ecosystem guides completed (or equivalent): `andes-cargo-infra/` with the pipeline, security gate, and cost gate already working
- AI Engineering ecosystem completed (or equivalent): knowing how to build with an LLM — prompting, function calling, structured outputs — since this guide doesn't re-teach it
- Terraform and an AWS account with Bedrock enabled, if you want to run a real invocation on your own (the guide teaches everything around it, not the invocation itself)
- Basic Python and `pytest`, for the custom guardrail checks
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Guide introduction: the eighth piece of the ecosystem
- 2. A notebook and a production system are not the same problem
- 3. Andes Cargo's AI workload: when the deterministic parser isn't enough
- 4. The boundary with AI Engineering, said out loud
- 5. Hands-on: inventory of what already exists
- 6. Bedrock, 2026 landscape: models, families, and why the cheap path stays the default
- 7. Hands-on: the honest attempt against Bedrock on LocalStack
- 8. Project: Andes Cargo's AI workload map
- 1. Introduction: price per token, not per hour
- 2. How Bedrock is billed: on-demand, Provisioned Throughput, Batch, Flex, Priority
- 3. Bedrock quotas: the limit no bill shows
- 4. Hands-on: Infracost, inherited
- 5. Hands-on: the honest attempt of `infracost scan` on `bedrock.tf`
- 6. Why Infracost can't solve this alone, and what can
- 7. Hands-on: the cost-per-token calculator
- 8. Project: Andes Cargo's `GENAI-COST-PROFILE.md`
- 1. Introduction: what Terraform knows how to declare without needing to invoke anything
- 2. What Terraform resources exist for Bedrock
- 3. Hands-on: the `modules/bedrock-guardrail/` module
- 4. Hands-on: `BedrockManifestExtractorRole`, least privilege
- 5. Hands-on: `terraform plan` of the complete AI infrastructure
- 6. The exact limit: why `apply` doesn't run against LocalStack Hobby
- 7. Hands-on: verifying what can actually be applied
- 8. Project: Andes Cargo's AI infrastructure, declared
- 1. Introduction: the managed guardrail and the custom one
- 2. Bedrock Guardrails' six policies, explained
- 3. Hands-on: declaring the complete guardrail in HCL
- 4. Why a managed guardrail isn't enough alone
- 5. Hands-on: the custom, deterministic PII scrubber
- 6. Hands-on: the output schema validator
- 7. The exact limit: why Bedrock Guardrails' real blocking can't be tested here
- 8. Project: Andes Cargo's guardrails layer
- 1. Introduction: the gate already exists, this workload enters it
- 2. Least privilege for a model, not a service
- 3. Hands-on: `bedrock-least-privilege.rego`, added to `policy/`
- 4. Why Bedrock doesn't need an API key
- 5. Hands-on: Trivy on the new Terraform
- 6. Hands-on: signing the extractor's artifact with `cosign`
- 7. STRIDE, revisited: the threats specific to an AI workload
- 8. Project: Andes Cargo's security gate, extended
- 1. Module introduction: the cost gate already exists, tokens are what's new
- 2. Why a token is the ecosystem's most extreme *usage-based* resource
- 3. Hands-on: `bedrock-budget.rego`, added to `cost-policy/`
- 4. Hands-on: the per-token cost calculator, integrated into the gate
- 5. Cost allocation tagging for the AI workload
- 6. Hands-on: a volume change that triggers the budget
- 7. On-demand vs. Provisioned Throughput: when to use each, with real numbers
- 8. Project: Andes Cargo's *cost gate*, extended to tokens
- 1. Module introduction: the same vocabulary, new metrics
- 2. SLIs for an AI workload: escalation, latency, guardrail block rate
- 3. Hands-on: CloudWatch Logs and Metrics for the extractor
- 4. Hands-on: the escalation rate metric
- 5. What a production eval is, and why it isn't a unit test
- 6. Hands-on: the smoke test harness with fixed manifests
- 7. The exact limit: why real latency and quality can't be measured here
- 8. Project: Andes Cargo's AI workload observability dashboard
- 1. Capstone introduction: the complete extractor, closed
- 2. Architecture review: the full system, two paths
- 3. End-to-end walkthrough: the deterministic, cheap path, executed
- 4. End-to-end walkthrough: the AI escalation path, mixed and declared
- 5. What this guide left representative
- 6. The boundary with AI Engineering, closed
- 7. What Andes Cargo still needs
- 8. Final project: the Andes Cargo GenAI package 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!