GuideBeginner
Aws Serverless And Containers
This guide continues directly from the AWS Core Services Guide, using the same Andes Cargo case and the same LocalStack lab, to teach the two real ways compute gets designed in production AWS: serverless in depth and containers. The Lambda function that processed shipment manifests becomes a production-grade function with layers, concurrency, and secrets; it gets wrapped in a Step Functions workflow with explicit retries and error handling; the direct S3 trigger gets decoupled with an EventBridge event bus, complete with its own dead-letter queue; and a REST API Gateway unifies HTTP access to everything Andes Cargo exposes. On that same thread, the guide builds `andes-cargo-status-api`, an always-on service (unlike a function that only runs on events), packaged in Docker, pushed to a registry, and run with ECS's cluster/task-definition/service model on Fargate. The guide is upfront about a real limitation: LocalStack's free plan doesn't include ECR or ECS, so those two modules execute the real mechanics with plain Docker and a local registry, and show verified command syntax and output as reference, leaving LocalStack's paid plan as an optional, never-required path. The capstone runs the event-driven flow end to end and documents the container path, closing with the "when Lambda, when a container" criterion installed since the first module.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Apply a decision framework (latency, duration, statefulness, cost) between a Lambda function and a containerized service
- Take a Lambda function to production grade: layers for shared code, reserved concurrency, environment variables with Secrets Manager, versions, and aliases
- Design a Step Functions state machine with Task/Choice states, parallel branches, retries (`Retry`), and error handling (`Catch`)
- Decouple producers from consumers with EventBridge: custom buses, rules, custom event patterns, scheduled events, and dead-letter queues
- Expose a unified REST API with API Gateway: Lambda proxy integration, deployment stages, request validation, and usage plans
- Build a Docker image for an AWS-ready service and apply the mechanics of pushing/pulling images with a container registry
- Explain the ECS model (cluster, task definition, task, service) and the difference between the Fargate and EC2 launch types
- Distinguish an ECS task's execution role from the task role itself, and apply least privilege to each
- Recognize when Fargate costs more than EC2 and which container services have no free tier in real AWS
- Chain together a full event-driven architecture (S3 → EventBridge → Step Functions → DynamoDB) and an API that routes to both Lambda and a container
Before you start
What you need to bring
It's for you if...
- Devs who already completed the AWS Core Services Guide and need to move from "one function with a trigger" to production-grade serverless architectures
- Devs with Docker experience who want to apply that knowledge to the AWS-specific context (ECR, ECS, Fargate)
- Teams deciding whether a flow should be orchestrated with Step Functions or decoupled with EventBridge
- Anyone who needs the real market criterion for choosing between serverless and containers before committing to an architecture
Requirements and materials
- AWS Core Services Guide completed (single-account IAM, S3, basic VPC/EC2, Lambda with a simple trigger, DynamoDB) with the LocalStack lab already running
- Docker Essentials Guide completed (or equivalent: Dockerfile, layers, `docker build`/`run`, multi-stage builds)
- Docker installed and running locally
- Free LocalStack account with an auth token (the paid Base plan is optional, only needed to run ECR/ECS literally)
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Guide introduction: from core services to real architectures
- 2. Serverless vs. containers: a judgment call, not a religion
- 3. Recap: Andes Cargo's cloud foundation
- 4. Hands-on: reconnecting to your LocalStack lab
- 5. This guide's honesty: the Hobby plan's ceiling
- 6. The IAM roles this guide is going to need
- 7. Hands-on: verifying inherited resources
- 8. Project: Andes Cargo's roadmap for this guide
- 1. Introduction: what one lone function doesn't tell you
- 2. The Lambda execution model: cold starts and memory
- 3. Lambda Layers: sharing code across functions
- 4. Concurrency: reserved vs. provisioned
- 5. Environment variables and Secrets Manager
- 6. Versions and aliases: deploying without breaking production
- 7. Hands-on: upgrading process-shipment-manifest
- 8. Project: Andes Cargo's production-grade function
- 1. Introduction: when one function isn't enough anymore
- 2. What a state machine is: orchestration vs. glue code
- 3. States: Task, Choice, and parallel branches
- 4. Error handling: Retry and Catch
- 5. Standard vs. Express workflows
- 6. Hands-on: your first state machine
- 7. Hands-on: the shipment manifest workflow
- 8. Project: ShipmentManifestWorkflow end to end
- 1. Introduction: decoupling who produces from who reacts
- 2. What event-driven architecture is
- 3. Buses, rules, and targets
- 4. Custom events and event patterns
- 5. Scheduled events with EventBridge Scheduler
- 6. Reliability: dead-letter queues and idempotency
- 7. Hands-on: wiring Andes Cargo's bus
- 8. Project: Andes Cargo's event-driven notifications
- 1. Introduction: one door, not one service per client
- 2. What an API Gateway is and why you need one
- 3. REST API: resources, methods, and integrations
- 4. Lambda proxy integration vs. custom integration
- 5. Stages, deployments, and request validation
- 6. Throttling, usage plans, and API keys
- 7. Hands-on: building `andes-cargo-api`
- 8. Project: Andes Cargo's public shipment API
- 1. Introduction: from a function to an always-on service
- 2. From code to container: what changes for AWS
- 3. What a container registry is and why ECR
- 4. The LocalStack Base line: being honest about ECR
- 5. Hands-on: building the status-api image
- 6. Hands-on: pushing and pulling with a local registry
- 7. ECR in the real world: policies and scanning
- 8. Project: Andes Cargo's status-api image
- 1. Introduction: who keeps your container running
- 2. The ECS model: clusters, tasks, and services
- 3. Launch types: Fargate vs. EC2
- 4. Anatomy of a task definition
- 5. Networking and load balancing for ECS services
- 6. Scaling, and when Fargate costs more than EC2
- 7. Hands-on: deploying status-api to ECS
- 8. Project: Andes Cargo's status-api service
- 1. Capstone introduction
- 2. Architecture review: the full Andes Cargo system
- 3. End-to-end walkthrough: the event-driven path
- 4. End-to-end walkthrough: the container path
- 5. Tagging, cost, and cleanup checklist
- 6. What this guide did NOT cover
- 7. From serverless and containers to production AWS
- 8. Final project: Andes Cargo's 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!