re:Invent 2023 - The Pragmatic Serverless Python Developer

The pragmatic serverless Python
developer
Heitor Lessa
O P N 3 0 5 - R 1
(he/him)
Chief Architect, Powertools for AWS
AWS
Ran Isenberg
(he/him)
Principal Software Architect
CyberArk

Pragmatism Use case Product API Stream processor Wrap-up
Readiness

Pragmatism: Analysis paralysis
Infra as code framework
decisions & trade-offs
situational awareness is key
Project structure
Domain-driven design?
Micro or mono functions?
Open source tools?
Sync or async?
Asynchronous testing?
App integrations
Observability? Leading practices?
Metrics? Alarms?
Documentation?

Pragmatism: Open source tools
mkdocs-material pytest Pydantic Powertools for AWS Lambda
pre-commit YAPF Tuna Radon Xenon AWS CDK
mkdocstrings isort flake8 poetry cdk-monitoring-constructs
codecov actionlint gitleaks GitPython typing-extensions
`
mypy-boto3 cdk-nag cachetools aws-lambda-env-modeler
mypy pytest-socket markdownlint dependabot Semantic PR

Pragmatism: Leading practices (CI)
Project setup pre-commit check
Merge conflicts
Valid Python code
JSON/YAML/TOML
Secrets linting
Code linting
pre-pull request
+pre-commit checks
Test (unit/contract)
AppSec baseline
Complexity baseline
Docs linting
Pull request checks
Governance checks
Test (integ/E2E)
SAST
+pre-PR checks
Dependency CVE
code checkout
virtual env
dependencies
pre-commit hooks

Use case: Simple yet practical
Product API Product database Product events

Use case: Product API
Product database Product events
Route handlers
CREATE Product
LIST Products
GET Product
DELETE Product
Amazon API Gateway

Use case: Product database
Route handlers
CREATE Product
LIST Products
GET Product
DELETE Product
Amazon DynamoDB
Amazon API Gateway
Product events

Use case: Product events
AWS Lambda
stream poller
AWS Lambda
Stream processor
Amazon
EventBridge
Route handlers
CREATE Product
LIST Products
GET Product
DELETE Product
Amazon DynamoDB
Amazon API Gateway

Use case: Synchronous path
AWS Lambda
stream poller
AWS Lambda
Stream processor
Amazon
EventBridge
Route handlers
CREATE Product
LIST Products
GET Product
DELETE Product
Amazon DynamoDB
Amazon API Gateway
Synchronous

Use case: Asynchronous path
AWS Lambda
stream poller
AWS Lambda
Stream processor
Amazon
EventBridge
Route handlers
CREATE Product
LIST Products
GET Product
DELETE Product
Amazon DynamoDB
Amazon API Gateway
Synchronous Asynchronous

Product API: Practices
Practices
Project structure, infra as code
Lambda handler practices
Business domain
Integration logic, AWS services, and more
Unit, integration, end-to-end testing
Amazon DynamoDB
Route handlers
GET /products
GET /{product}
PUT /{product}
DELETE /{product}
Amazon API Gateway

Synergy of elements
DevOps culture
DEV -> Production
Faster development
IaC
Domain
code
Tests
Readiness
Project structure
Project: Overview

Project repository structure reflects elements:
• Business domain: Lambda handlers code, business
logic, and integrations code
• Tests: unit, integration, end to end
• Production readiness: spread across all folders
• pyproject.toml: one file to rule them all
• IaC: CDK, AWS SAM, Terraform, and more
Project: Folder structure

• We chose AWS CDK as IaC framework
• One CDK app and one stack
• Domain-driven approach:
• One construct for product REST API
• One constructs builds:
• API GW
• Lambda functions
• DynamoDB table
• All roles
Project: Infrastructure as code

• Start with one Lambda function
• All business domain code and logic
• What is the ”best” way to write a
Lambda function?
Amazon DynamoDB
Route handlers
PUT /{product}
Amazon API Gateway
Handler: Overview

• Start with a handler that does it all
• Single file
• Gets input
Handler: Event source parsing

• Single file
• Gets input
• Domain logic/DB access
Handler: Integration

• Single file
• Gets input
• Returns response
Handler: Response

• Single file
• Gets input
• Returns response
• Context matters
• Cron job handler vs. REST API with logic
Handler: One handler to rule them all?

• As the service expands:
• Code duplication
• Testing becomes harder
• Code readability issues – 300+ lines
• This does not scale!
• We need a better way to develop
complex services
Amazon DynamoDB
Route handlers
GET /products
GET /{product}
PUT /{product}
DELETE /{product}
Amazon API Gateway
Handler: Will my service evolve?

Business logic only
May be shared by N handlers
Isolated tests
Handler: Architectural layers
Handler
No domain code
Concise responsibilities
Domain

Handler: Responsibilities
Configuration Env. vars Validation Serialize output
Call domain

access
Amazon DynamoDB
Amazon API Gateway
Handler Domain
invoke handle
output
serialize
Handler: High-level event flow

• Zero domain code
• Short and concise
• Clear responsibilities
Handler: Event source parsing (after)

Handler: Integration (after)

Handler: Response (after)

Handler: Refactored

• Functional or OOP
• Interface:
• Create product
• Get product
• List products
• Delete product
Domain: Product

• Functional or OOP
• Interface:
• Create product
• Get product
• List products
• Delete product
• Access DynamoDB
• Return output
Domain: Integration

• Integration practice relates to:
• Code that accesses DynamoDB
• And in general:
• Code that accesses API
• Integration with AWS resources
• Integration with external APIs
Amazon DynamoDB
Route handlers
GET /products
GET /{product}
PUT /{product}
DELETE /{product}
Amazon API Gateway
Integration: Overview

• Domain code contains
integration code
• When can it backfire?
Integration: Should domain integrate directly?

• DB requirements change and evolve
• New queries are too slow
• What if we replace DynamoDB?
• Harder refactors
• No isolated testing
• Can we do better?
Route handlers
GET /products
GET /{product}
PUT /{product}
DELETE /{product}
Amazon API Gateway
Integration: Testing and refactoring challenges
Amazon Aurora
Amazon DynamoDB

Adapter pattern
Contains API/DB code
Business logic only
May be shared by N handlers
Isolated tests
Integration: A new architecture layer
Handler
No domain code
Concise responsibilities
Domain
Integration

invoke handle
serialize output
Amazon DynamoDB
Amazon API Gateway
Handler Domain
Integration: High-level overview
Integration
call access
output

Integration: Agreeing on an interface
• Abstract interface
• Interface includes:
• Create product
• List products
• Get product
• Delete product

Integration: Implementation example
• Implements adapter pattern
• The only class that has
DynamoDB code
• Isolated tests
• Aurora handler inherits
interface

Integration: Refactoring domain
• Getter for concrete
implementation
• Domain is not aware of the
underlying DB
• Easy to switch to a different
database
• Output conversion

DevX
Never leave IDE
Real cloud resources
Local debug
Amazon DynamoDB
Route handlers
GET /products
GET /{product}
PUT /{product}
DELETE /{product}
Amazon API Gateway
Testing: Overview

Unit
No deployment Run Locally
Testing: Pyramid

call
Test runner
(pytest)
Isolated unit Assertion
Test data
verify
prepare
Testing: Unit test overview

• Test schema validations (Pydantic)
• Test isolated integration classes
• No deployment required
• Fast & repeatable
Testing: Model validation

Integration
Unit
Requires deployment
No deployment
Run locally & on AWS
Run locally
Testing: Integration tests

call
Test runner
(pytest)
Lambda
handler
Assertion
Test data
verify
prepare
resources
Testing: Integration test overview

• Build repeatable and consistent tests
• Event details:
• Print real events in CloudWatch Logs
• Powertools for AWS Lambda test JSON events
• AWS service documentation
Testing: Event generation

• Test-driven development (TDD)
• Breakpoints in IDE
• Work against cloud resources
Testing: Local code, cloud resources

• Assert side effects and response
Testing: Asserting responses

Testing: Asserting side effects

Testing: Integration test complete

• Simulate failures
• Mock DynamoDB exceptions
• Assert handler response
• Why not write as a unit test?
Testing: Injecting SDK failures

E2E
Integration
Unit
Require deployment
Require deployment
No deployment
Run on AWS
Run locally & on AWS
Run locally
Testing: End-to-end (E2E) tests

call
Test runner
(pytest)
Product API Assertion
Test data
verify
prepare
Endpoint Lambda function
invoke
Testing: E2E test overview

• Simulate real user usage
• Runs 100% on AWS
Testing: Black box testing

• Simulate real user usage
• Runs 100% on AWS
• Assert response
Testing: Asserting product creation

• Simulate bad input
• API security tests:
• Invalid authorization
• Invalid authentication
Testing: Unhappy paths

Amazon
DynamoDB
Stream processor: Intro
Amazon
EventBridge
AWS Lambda
Stream processor
Practices
Project scaffolding, infra as code
Lambda handler practices
Business domain
Integration logic, AWS services, and more
Unit, integration, end-to-end testing

Practices
Same structure as CRUD API
Project: Folder structure

Practices
Extend your handler with defaults
Handler: Extend the signature

Practices
Build domain input from event
Handler: Prepare and validate domain input

Practices
Build domain input from event
Inject integrations
Handler: Create and inject event emitter

Practices
Dependency injection to the rescue
Domain: Use dependency and issue receipt

Amazon
EventBridge
Integration layer
Domain

Amazon
EventBridge
Event Handler
Domain

Amazon
EventBridge
Event Handler
Domain
Model to Event
Standardize Event
Inject metadata

Amazon
EventBridge
Event Handler
Domain
Model to Event
Event Provider
Standardize Event
Inject metadata
send

Amazon
EventBridge
Event Handler
Domain
Model to Event
Event Provider
Standardize Event
Inject metadata
send PutEvents

Amazon
EventBridge
Event Handler
Domain
Model to Event
Event Provider
Standardize Event
Inject metadata
Build request
Error Handling
Issue Receipt
send PutEvents

Integration: Model to standard Event

Integration: Model to standard Event
Model  Event

Integration: Model to provider request
Model  Event  EventBridge

Integration
Domain
Handler
AWS Lambda
Amazon
EventBridge
Testing: Isolated tests, thanks to layering
Amazon
DynamoDB

Testing: Quick recap on our handler

Integration
Domain
Amazon
EventBridge
Amazon
DynamoDB
Testing: Unit testing Lambda handler
AWS Lambda
Handler
Event source
Domain input
EventHandler

Testing: Preventing side effects
Practices
Fail tests for unexpected connections

Testing: FakeEventHandler
Practices
Use in-memory Fakes

Testing: Unit testing benefits
Practices
Use in-memory Fakes
Test in isolation, and as a whole unit

Amazon
DynamoDB
Integration
Amazon
EventBridge
Domain
Testing: Unit testing domain
AWS Lambda
Handler
Event source
Domain input
EventHandler
Business rule
Use integ.

Testing: Unit testing domain logic
Practices
Use in-memory Fakes
Test in isolation, and as a whole unit

Amazon
DynamoDB
Amazon
EventBridge
Integration
Domain
Testing: Unit testing integration
AWS Lambda
Handler
Event source
Domain input
EventHandler
Business rule
Use integ.

Testing: Contract testing
Practices
Use in-memory Fakes
Test model -> event -> provider request

Practices
Use in-memory Fakes
Test model  event  provider request
Testing: Contract testing (event)

Testing: Contract testing (provider)
Practices
Use in-memory Fakes

Testing: Asserting contract
Practices
Use in-memory Fakes
AWS SDK stubber for deeper validation

Amazon
DynamoDB
Amazon
EventBridge
Integration
Domain
Testing: Asserting asynchronous behavior
AWS Lambda
Handler
Event source
Domain input
EventHandler
Business rule
Use integ.
Init provider
Build event
Send event

Amazon
EventBridge
Testing: Listening to events
AWS Lambda
Amazon
DynamoDB

Amazon
EventBridge
Testing: Creating new side effects
AWS Lambda AWS Step Functions
Amazon
DynamoDB
Amazon
DynamoDB
Intercept Event Testing Construct

Amazon
EventBridge
Testing: Querying intercepted events
AWS Lambda AWS Step Functions
Amazon
DynamoDB
Amazon
DynamoDB
Intercept Event Testing Construct
pk sk data metadata receipt_id
test_eventbridge_provider_send
b30a7..#SAMPLE_NOTIFICATION
#2023-10-08T20:17:02…
{…} {…} b30a7…

Testing: Using test name as event source
Practices
Use in-memory Fakes
Validate input with AWS SDK stubber
Make it easier to trace test events

Testing: Asserting intercepted events
Practices
Use in-memory Fakes
Validate input with AWS SDK stubber
Make it easier to trace test events
Consider eventual consistency

Powertools for AWS Lambda: Toolkit
Batch processing
REST/GraphQL API
Input/output validation
Config management
Secrets handling
Idempotency
Observability
BYO middleware
Self-documented schemas Feature flags
Data extraction
Caching
best practices, for everyone
Streaming
*feature set may vary across languages
Python | TypeScript | Java | .NET

Tuna: Visualizing import time (cold start)

Py-spy: Visualizing most freq. code path

Pyinstrument: Visualizing select code areas

Recap: Open source repository
opinionated reference
and fully documented

Summary: Takeaways
Resources and template

Thank you!
Please complete the session
survey in the mobile app
Thank you!
Please complete the session
survey in the mobile app
Heitor Lessa
@heitor_lessa
lessa@amazon.com
Ran Isenberg
@IsenbergRan
Ran.Isenberg@ranthebuilder.cloud
www.ranthebuilder.cloud

re:Invent 2023 - The Pragmatic Serverless Python Developer

More Related Content

More from Heitor Lessa (9)

Recently uploaded (20)

re:Invent 2023 - The Pragmatic Serverless Python Developer