Building Serverless Applications with Google Cloud Run

Spis treści książki

• Foreword
• Preface
  • Why I Wrote This Book
  • Who This Book Is For
  • Why Use the Go Language?
  • Navigating This Book
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Introduction
  • Serverless Applications
    • A Simple Developer Experience
    • Autoscalable Out of the Box
    • A Different Cost Model
    • Serverless Is Not Functions as a Service
  • Google Cloud
  • Serverless on Google Cloud
  • Cloud Run
    • Service
    • Container Image
    • Scalability and Self-Healing
    • HTTPS Serving
    • Microservices Support
    • Identity, Authentication, and Access Management
    • Monitoring and Logging
    • Transparent Deployments
    • Pay-Per-Use
  • Concerns About Serverless
    • Unpredictable Costs
    • Hyper-Scalability
    • When Things Go Really Wrong
    • Separation of Compute and Storage
    • Open Source Compatibility
  • Summary
• 2. Understanding Cloud Run
  • Getting Started with Google Cloud
    • Costs
    • Interacting with Google Cloud
    • Google Cloud Projects
    • Installing and Authenticating the SDK
    • Installing Beta Components
  • Deploying Your First Service
    • Deploying the Sample Container
    • Region
    • Structure of the HTTPS Endpoint
    • Viewing Your Service in the Web Console
    • Deploying a New Version
    • Revision
  • Understanding Cloud Run
    • Container Life Cycle
    • CPU Throttling
    • Task Scheduling and Throttling
    • Load Balancer and Autoscaler
    • Concurrent Request Limit
    • Autoscaler
    • Tuning the Concurrency Setting
    • 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
      • Source-based versus container-based
      • Request- versus instance-oriented runtime
    • 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
      • Adding a policy binding to a project
      • Adding a policy binding to a resource
    • Service Accounts
      • Avoiding the default service account
      • A gripping demo
    • 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
      • Provider
      • Variables are parameters
      • Adding the first resource declaration
      • Terraform configuration language
      • Preparing to deploy the service: Creating a plan
      • Saving input variables
      • Deploying the service: Apply the plan
      • Terraform state
  • 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

pokaż cały spis treści

ukryj recenzje