Building Serverless Applications on Knative: A Guide to Designing and Writing Serverless Cloud Applications

✍ Scribed by Evan Anderson

• Publisher: O'Reilly Media
• Year: 2023
• Tongue: English
• Leaves: 252
• Edition: 1
• Category: Library

✦ Synopsis

Explore the theory and practice of designing and writing serverless applications using examples from the Knative project. With this practical guide, mid-level to senior application developers and team managers will learn when and why to target serverless platforms when developing microservices or applications. Along the way, you'll also discover warning signs that suggest cases when serverless might cause you more trouble than joy.

Drawing on author Evan Anderson's 15 years of experience developing and maintaining applications in the cloud, and more than 6 years of experience with serverless platforms at scale, this book acts as your guide into the high-velocity world of serverless application development. You'll come to appreciate why Knative is the most widely adopted open source serverless platform available.

With this book, you will:
• Learn what serverless is, how it works, and why teams are adopting it
• Understand the benefits of Knative for cloud native development teams
• Learn how to build a serverless application on Knative
• Explore the challenges serverless introduces for debugging and the tools that can help improve it
• Learn why event-driven architecture and serverless compute are complementary but distinct
• Understand when a serverless approach might not be the right system design

✦ Table of Contents

Cover
Copyright
Table of Contents
Preface
Who Is This Book For?
Background
Containers
Cloud Providers
Kubernetes and Cloud Native
Cloud-Hosted Serverless
How This Book Is Organized
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments
Part I. The Theory of Serverless
Chapter 1. What Is Serverless, Anyway?
Why Is It Called Serverless?
A Bit of Terminology
What’s a “Unit of Work”?
Connections
Requests
Events
It’s Not (Just) About the Scale
Blue and Green: Rollout, Rollback, and Day-to-Day
Creature Comforts: Undifferentiated Heavy Lifting
Creature Comforts: Managing Inputs
Creature Comforts: Managing Process Lifecycle
Summary
Chapter 2. Designing from Scratch
Setup for This Chapter
A Single-Page App
Bootstrapping a React App
A Basic Web UI
Packaging Our App
Into the Cloud on Your Laptop!
Under the Covers: How Requests Are Handled
Continuing to Build
Adding an API
API Gateways and Composing an App
Splitting an API into Components
Augmenting a Proxy
Complementary Services
Key-Value Storage
Object Storage
Timers (Cron)
Task Queues
Workflows
Summary
Chapter 3. Under the Hood: Knative
Infrastructure Assumptions
Hardware and Operating System Management
Scheduling and the Datacenter as a Computer
Serving
Control-Plane Concepts
Life of a Request
Autoscaling Control Loop
Comparison with AWS Lambda
Eventing
Control-Plane Concepts
Delivery Guarantees
Life of an Event
Ecosystem
Comparison with Amazon SNS and Other Cloud Providers
Comparison with RabbitMQ
Comparison with Apache Kafka
Eventing Summary
Functions
Summary
Chapter 4. Forces Behind Serverless
Top Speed: Reducing Drag
Continuously Delivering Value
Winning the (Business) Race
Microbilling
A Deal with the Cloud
Clouding on Your Own
What Happens When You’re Not Running
The Gravitational Force of Serverless
Implications for Languages
Implications for Sandboxing
Implications for Tooling
Implications for Security
Implications for Infrastructure
Summary
Part II. Designing with Serverless
Chapter 5. Extending the Monolith
The Monolith Next Door
Microservice Extension Points
Asynchronous Cleanup and Extension
Extract, Transform, Load
The Strangler Fig Pattern
Experiments
Dark Launch and Throwaway Work
A Serverless Monolith?
Summary
Chapter 6. More on Integration: Event-Driven Architecture
Events and Messages
Why CloudEvents
Events as an API
What Does Event-Driven Mean?
Event Distribution
Content-Based Routing Versus Channels
Internal and External Events
Building for Extension with “Inner Monologue”
Workflow Orchestration
Long-Lived Workflows, Short-Lived Compute
Workflow as Declarative Manifests
Event Broadcast
What’s So Tricky About Broadcast?
Broadcast in Fast-Moving Systems
Task Queues
Task Queue Features
Scaling in Time Instead of Instances
Summary
Chapter 7. Developing a Robust Inner Monologue
Ambient Event Publishing
The Active Storage Pattern
Is Your Database Your Monologue?
Scenarios for Inner Monologues
Key Events
Workflows
Inner Monologues Versus RPCs
Sensitive Data and Claim Checks
How to Use an Inner Monologue
Extending the Monolith: Workflow Decoration
Scatter-Gather Advice
Account Hijacking Detection
Versioned Events, Unversioned Code
Clouds Have Monologues Too
Kubernetes: Only a Monologue
Audit Log or Mono-Log?
Summary
Chapter 8. Too Much of a Good Thing Is Not a Good Thing
Different Types of Work in the Same Instance
Work Units That Don’t Signal Termination
Protocol Mismatch
Inelastic Scaling
Instance Addressability and Sharding
Summary
Part III. Living with Serverless
Chapter 9. Failing at the Speed of Light
Meltdown
Narrowest Bottleneck
Feedback Loop
Cold Start, Extra Slow
The Race to Ready
Avoiding Cold Starts
Forecasting Is Hard
Loopback
Hotspots Don’t Scale
Graphs and Focal Points
Data Size
Locking
Exactly Once Is Hard
Summary
Chapter 10. Cracking the Case: Whodunnit
Log Aggregation
Tracing
Metrics
Live Tracing and Profiling
APM Agents
Summary
Part IV. A Brief History of Serverless
Chapter 11. A Brief History of Serverless
35 Years of Serverless
inetd
CGI
Stored Procedures
Heroku
Google App Engine
Cloud Foundry
AWS Lambda
Azure and Durable Functions
Knative and Cloud Run
Cloudflare Workers and Netlify Edge Functions
Where to Next?
AI
Distributed and the Edge
Beyond Stateless
Summary
Index
About the Author
Colophon

✦ Subjects

Software Architecture; Serverless Applications; Event-Driven Architecture; Monolithic Architecture; Serverless Architecture; Knative