Building Serverless Applications with Google Cloud Run

Cold Starts
Disposable Containers
In-Memory Filesystem
Ready for Requests
Cloud Run Key Points
Choosing a Serverless Compute Product on Google Cloud
Cloud Functions: Glue Code
App Engine: Platform as a Service
Key Differences
What Will the Future Look Like?
Summary

3. Building Containers
Containers: A Hands-On Exploration
Running an Interactive Shell
Overriding the Default Command
Running a Server
Containers from First Principles
Inside a Container Image
The Linux Kernel
Container Isolation
Starting a Container
Building a Container with Docker
Dockerfile Instructions
Installing Additional Tooling
Smaller Is Better When Deploying to Production
Creating Small Containers with Distroless
Artifact Registry
Building and Tagging the Container Image
Authenticating and Pushing the Container Image
Building a Container Without a Dockerfile
Go Containers with ko
Java Containers with Jib
Cloud Native Buildpacks
Cloud Build
Remote Docker Build
Advanced Builds
Running Arbitrary Programs
Connecting with Version Control
Shutting Down
Summary

4. Working with a Relational Database
Introducing the Demo Application
Creating the Cloud SQL Instance
Understanding Cloud SQL Proxy
Connecting and Loading the Schema
Securing the Default User
Connecting Cloud Run to Cloud SQL
Disabling the Direct Connection
Deploying the Demo Application
Connection String
Public and Private IP
Limiting Concurrency
Transaction Concurrency
Resource Contention
Scaling Boundaries and Connection Pooling
External Connection Pool
A Real-World Example
Cloud SQL in Production
Monitoring
Automatic Storage Increase
High Availability
Making Your Application Resilient Against Short Downtime
Shutting Down
Summary

5. Working with HTTP Sessions
How HTTP Sessions Work
Storing Sessions in Memorystore: A Hands-On Exploration
Creating a Memorystore Instance
What Is a VPC Connector?
Creating a VPC Connector
Deploying the Demo App
Alternative Session Stores
Session Affinity
Use Cases
Session Affinity Is Not for Session Data
Shutting Down
Summary

6. Service Identity and Authentication
Cloud IAM Fundamentals
Roles
Policy Binding
Service Accounts
Creating and Using a New Service Account
Sending Authenticated Requests to Cloud Run
Deploying a Private Service
Using an ID Token to Send Authenticated Requests
When Is an ID Token Valid?
Programmatically Calling Private Cloud Run Services
Google Frontend Server
A Story About Inter-Service Latency
Demo Application
Embedded Read-Only SQL Database
Running Locally
Edit, Compile, Reload
Deploying to Cloud Run
Update the Frontend Configuration
Add Custom Service Accounts
Add IAM Policy Binding
Summary

7. Task Scheduling
Cloud Tasks
Hands-On Learning: A Demo Application
Building the Container Images
Creating a Cloud Tasks Queue
Creating Service Accounts
Deploying the Worker Service
Deploying the Task App Service
Connecting the Task Queue
Scheduling a Task with the Cloud Tasks Client Library
Automatic ID Token
Connecting the Worker
Test the App
Queue Configuration
Retry Configuration
Rate Limiting
Viewing and Updating Queue Configuration
Considerations
Cloud Tasks Might Deliver Your Request Twice
Local Development
Alternatives
Summary

8. Infrastructure as Code Using Terraform
What Is Infrastructure as Code?
Why Infrastructure as Code?
Serverless Infrastructure
How It Works
When Not to Use Infrastructure as Code
Terraform
Installing Terraform
Getting Started with a Minimal Example
The Terraform Workflow
Change with Terraform: Adding the Access Policy
Expressing Dependencies with References
Supplemental Resources
Summary

9. Structured Logging and Tracing
Logging on Cloud Run
Viewing Logs in the Web Console
Viewing Logs in the Terminal
Finding Invisible Logs
Plain-Text Logs Leave You Wanting More
Demo Application
Structured Logging
Client Libraries
Structured Logging in Other Languages
How to Use Log Levels
Capturing Panics
Local Development
Request Context
Trace Context
Forwarding Trace ID
Preparing All Incoming Requests with the Trace ID
Passing Request Context to Outgoing Requests
Viewing Trace Context in Cloud Logging
Additional Resources About Tracing
Log-Based Metrics with Cloud Monitoring
Summary

10. Cloud Run and Knative Serving
What Is Knative Serving?
Cloud Run Is Not Managed Knative Serving
Knative Serving on Google Cloud
Understanding Kubernetes
API Server
Kubernetes Resources
Database
Controllers
Adding Extensions to Kubernetes
Running Knative Serving Locally
Running a Local Kubernetes Cluster
Installing Minikube and kubectl
Starting Your Local Cluster
Install the Knative Operator
Starting Minikube Tunnel
Installing an HTTP Load Balancer
Configuring DNS
Deploying a Service
Deploying the Same Service to Cloud Run
Alternative API Clients
Shutting Down
Discussion
Serving
Moving from Kubernetes to Cloud Run Is Harder
Service Identity and Authentication
Proprietary Managed Services
Summary

Index