Cloud Native Go

Table of contents

1. Preface
   1. Who Should Read This Book
   2. Why I Wrote This Book
   3. Conventions Used in This Book
   4. Using Code Examples
   5. O’Reilly Online Learning
   6. How to Contact Us
   7. Acknowledgments
2. I. Going Cloud Native
3. 1. What Is a “Cloud Native” Application?
   1. The Story So Far
   2. What Is Cloud Native?
      1. Scalability
      2. Loose Coupling
      3. Resilience
      4. Manageability
      5. Observability
   3. Why Is Cloud Native a Thing?
   4. Summary
4. 2. Why Go Rules the Cloud Native World
   1. The Motivation Behind Go
   2. Features for a Cloud Native World
      1. Composition and Structural Typing
      2. Comprehensibility
      3. CSP-Style Concurrency
      4. Fast Builds
      5. Linguistic Stability
      6. Memory Safety
      7. Performance
      8. Static Linking
      9. Static Typing
   3. Summary
5. II. Cloud Native Go Constructs
6. 3. Go Language Foundations
   1. Basic Data Types
      1. Booleans
      2. Simple Numbers
      3. Complex Numbers
      4. Strings
   2. Variables
      1. Short Variable Declarations
      2. Zero Values
      3. The Blank Identifier
      4. Constants
   3. Container Types: Arrays, Slices, and Maps
      1. Arrays
      2. Slices
      3. Maps
   4. Pointers
   5. Control Structures
      1. Fun with for
      2. The if Statement
      3. The switch Statement
   6. Error Handling
      1. Creating an Error
   7. Putting the Fun in Functions: Variadics and Closures
      1. Functions
      2. Variadic Functions
      3. Anonymous Functions and Closures
   8. Structs, Methods, and Interfaces
      1. Structs
      2. Methods
      3. Interfaces
      4. Composition with Type Embedding
   9. The Good Stuff: Concurrency
      1. Goroutines
      2. Channels
      3. Select
   10. Summary
7. 4. Cloud Native Patterns
   1. The Context Package
      1. What Context Can Do for You
      2. Creating Context
      3. Defining Context Deadlines and Timeouts
      4. Defining Request-Scoped Values
      5. Using a Context
   2. Layout of this Chapter
   3. Stability Patterns
      1. Circuit Breaker
      2. Debounce
      3. Retry
      4. Throttle
      5. Timeout
   4. Concurrency Patterns
      1. Fan-In
      2. Fan-Out
      3. Future
      4. Sharding
   5. Summary
8. 5. Building a Cloud Native Service
   1. Let’s Build a Service!
      1. What’s a Key-Value Store?
   2. Requirements
      1. What Is Idempotence and Why Does It Matter?
      2. The Eventual Goal
   3. Generation 0: The Core Functionality
      1. Your Super Simple API
   4. Generation 1: The Monolith
      1. Building an HTTP Server with net/http
      2. Building an HTTP Server with gorilla/mux
      3. Building a RESTful Service
      4. Making Your Data Structure Concurrency-Safe
   5. Generation 2: Persisting Resource State
      1. What’s a Transaction Log?
      2. Storing State in a Transaction Log File
      3. Storing State in an External Database
   6. Generation 3: Implementing Transport Layer Security
      1. Transport Layer Security
      2. Private Key and Certificate Files
      3. Securing Your Web Service with HTTPS
      4. Transport Layer Summary
   7. Containerizing Your Key-Value Store
      1. Docker (Absolute) Basics
      2. Building Your Key-Value Store Container
      3. Externalizing Container Data
   8. Summary
9. III. The Cloud Native Attributes
10. 6. It’s All About Dependability
    1. What’s the Point of Cloud Native?
    2. It’s All About Dependability
    3. What Is Dependability and Why Is It So Important?
       1. Dependability: It’s Not Just for Ops Anymore
    4. Achieving Dependability
       1. Fault Prevention
       2. Fault Tolerance
       3. Fault Removal
       4. Fault Forecasting
    5. The Continuing Relevance of the Twelve-Factor App
       1. I. Codebase
       2. II. Dependencies
       3. III. Configuration
       4. IV. Backing Services
       5. V. Build, Release, Run
       6. VI. Processes
       7. VII. Data Isolation
       8. VIII. Scalability
       9. IX. Disposability
       10. X. Development/Production Parity
       11. XI. Logs
       12. XII. Administrative Processes
    6. Summary
11. 7. Scalability
    1. What Is Scalability?
       1. Different Forms of Scaling
    2. The Four Common Bottlenecks
    3. State and Statelessness
       1. Application State Versus Resource State
       2. Advantages of Statelessness
    4. Scaling Postponed: Efficiency
       1. Efficient Caching Using an LRU Cache
       2. Efficient Synchronization
       3. Memory Leaks Can…fatal error: runtime: out of memory
       4. On Efficiency
    5. Service Architectures
       1. The Monolith System Architecture
       2. The Microservices System Architecture
       3. Serverless Architectures
    6. Summary
12. 8. Loose Coupling
    1. Tight Coupling
       1. Tight Coupling Takes Many Forms
    2. Communications Between Services
    3. Request-Response Messaging
       1. Common Request-Response Implementations
       2. Issuing HTTP Requests with net/http
       3. Remote Procedure Calls with gRPC
    4. Loose Coupling Local Resources with Plug-ins
       1. In-Process Plug-ins with the plugin Package
       2. HashiCorp’s Go Plug-in System over RPC
    5. Hexagonal Architecture
       1. The Architecture
       2. Implementing a Hexagonal Service
    6. Summary
13. 9. Resilience
    1. Keeping on Ticking: Why Resilience Matters
    2. What Does It Mean for a System to Fail?
       1. Building for Resilience
    3. Cascading Failures
       1. Preventing Overload
    4. Play It Again: Retrying Requests
       1. Backoff Algorithms
       2. Circuit Breaking
       3. Timeouts
       4. Idempotence
    5. Service Redundancy
       1. Designing for Redundancy
       2. Autoscaling
    6. Healthy Health Checks
       1. What Does It Mean for an Instance to Be “Healthy”?
       2. The Three Types of Health Checks
       3. Failing Open
    7. Summary
14. 10. Manageability
    1. What Is Manageability and Why Should I Care?
    2. Configuring Your Application
       1. Configuration Good Practice
       2. Configuring with Environment Variables
       3. Configuring with Command-Line Arguments
       4. Configuring with Files
       5. Viper: The Swiss Army Knife of Configuration Packages
    3. Feature Management with Feature Flags
       1. The Evolution of a Feature Flag
       2. Generation 0: The Initial Implementation
       3. Generation 1: The Hard-Coded Feature Flag
       4. Generation 2: The Configurable Flag
       5. Generation 3: Dynamic Feature Flags
    4. Summary
15. 11. Observability
    1. What Is Observability?
       1. Why Do We Need Observability?
       2. How Is Observability Different from “Traditional” Monitoring?
    2. The “Three Pillars of Observability”
    3. OpenTelemetry
       1. The OpenTelemetry Components
    4. Tracing
       1. Tracing Concepts
       2. Tracing with OpenTelemetry
       3. Putting It All Together: Tracing
    5. Metrics
       1. Push Versus Pull Metric Collection
       2. Metrics with OpenTelemetry
       3. Putting It All Together: Metrics
    6. Logging
       1. Better Logging Practices
       2. Logging with Go’s Standard log Package
       3. The Zap Logging Package
    7. Summary
16. Index
17. About the Author