reklama - zainteresowany?

Cloud Native Go - Helion

Cloud Native Go
ebook
Autor: Matthew A. Titmus
ISBN: 9781492076285
stron: 436, Format: ebook
Data wydania: 2021-04-20
Księgarnia: Helion

Cena książki: 169,15 zł (poprzednio: 196,69 zł)
Oszczędzasz: 14% (-27,54 zł)

Dodaj do koszyka Cloud Native Go

What do Docker, Kubernetes, and Prometheus have in common? All of these cloud native technologies are written in the Go programming language. This practical book shows you how to use Go's strengths to develop cloud native services that are scalable and resilient, even in an unpredictable environment. You'll explore the composition and construction of these applications, from lower-level features of Go to mid-level design patterns to high-level architectural considerations.

Each chapter builds on the lessons of the last, walking intermediate to advanced developers through Go to construct a simple but fully featured distributed key-value store. You'll learn best practices for adopting Go as your development language for solving cloud native management and deployment issues.

  • Learn how cloud native applications differ from other software architectures
  • Understand how Go can solve the challenges of designing scalable distributed services
  • Leverage Go's lower-level features, such as channels and goroutines, to implement a reliable cloud native service
  • Explore what "service reliability" is and what it has to do with cloud native
  • Apply a variety of patterns, abstractions, and tooling to build and manage complex distributed systems

Dodaj do koszyka Cloud Native Go

 

Osoby które kupowały "Cloud Native Go", wybierały także:

  • Windows Media Center. Domowe centrum rozrywki

Dodaj do koszyka Cloud Native Go

Spis treści

Cloud Native Go eBook -- spis treści

  • Preface
    • Who Should Read This Book
    • Why I Wrote This Book
    • Conventions Used in This Book
    • Using Code Examples
    • OReilly Online Learning
    • How to Contact Us
    • Acknowledgments
  • I. Going Cloud Native
  • 1. What Is a Cloud Native Application?
    • The Story So Far
    • What Is Cloud Native?
      • Scalability
      • Loose Coupling
      • Resilience
      • Manageability
      • Observability
    • Why Is Cloud Native a Thing?
    • Summary
  • 2. Why Go Rules the Cloud Native World
    • The Motivation Behind Go
    • Features for a Cloud Native World
      • Composition and Structural Typing
      • Comprehensibility
      • CSP-Style Concurrency
      • Fast Builds
      • Linguistic Stability
      • Memory Safety
      • Performance
      • Static Linking
      • Static Typing
    • Summary
  • II. Cloud Native Go Constructs
  • 3. Go Language Foundations
    • Basic Data Types
      • Booleans
      • Simple Numbers
      • Complex Numbers
      • Strings
    • Variables
      • Short Variable Declarations
      • Zero Values
      • The Blank Identifier
      • Constants
    • Container Types: Arrays, Slices, and Maps
      • Arrays
      • Slices
        • Working with slices
        • The slice operator
        • Strings as slices
      • Maps
        • Map membership testing
    • Pointers
    • Control Structures
      • Fun with for
        • The general for statement
        • Looping over arrays and slices
        • Looping over maps
      • The if Statement
      • The switch Statement
    • Error Handling
      • Creating an Error
    • Putting the Fun in Functions: Variadics and Closures
      • Functions
        • Multiple return values
        • Recursion
        • Defer
        • Pointers as parameters
      • Variadic Functions
        • Passing slices as variadic values
      • Anonymous Functions and Closures
    • Structs, Methods, and Interfaces
      • Structs
      • Methods
      • Interfaces
        • Type assertions
        • The empty interface
      • Composition with Type Embedding
        • Interface embedding
        • Struct embedding
        • Promotion
        • Directly accessing embedded fields
    • The Good Stuff: Concurrency
      • Goroutines
      • Channels
        • Channel blocking
        • Channel buffering
        • Closing channels
        • Looping over channels
      • Select
        • Implementing channel timeouts
    • Summary
  • 4. Cloud Native Patterns
    • The Context Package
      • What Context Can Do for You
      • Creating Context
      • Defining Context Deadlines and Timeouts
      • Defining Request-Scoped Values
      • Using a Context
    • Layout of this Chapter
    • Stability Patterns
      • Circuit Breaker
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Debounce
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Retry
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Throttle
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Timeout
        • Applicability
        • Participants
        • Implementation
        • Sample code
    • Concurrency Patterns
      • Fan-In
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Fan-Out
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Future
        • Applicability
        • Participants
        • Implementation
        • Sample code
      • Sharding
        • Applicability
        • Participants
        • Implementation
        • Sample code
    • Summary
  • 5. Building a Cloud Native Service
    • Lets Build a Service!
      • Whats a Key-Value Store?
    • Requirements
      • What Is Idempotence and Why Does It Matter?
      • The Eventual Goal
    • Generation 0: The Core Functionality
      • Your Super Simple API
    • Generation 1: The Monolith
      • Building an HTTP Server with net/http
      • Building an HTTP Server with gorilla/mux
        • Creating a minimal service
        • Initializing your project with Go modules
        • Variables in URI paths
        • So many matchers
      • Building a RESTful Service
        • Your RESTful methods
        • Implementing the create function
        • Implementing the read function
      • Making Your Data Structure Concurrency-Safe
        • Integrating a read-write mutex into your application
    • Generation 2: Persisting Resource State
      • Whats a Transaction Log?
        • Your transaction log format
        • Your transaction logger interface
      • Storing State in a Transaction Log File
        • Prototyping your transaction logger
        • Defining the event type
        • Implementing your FileTransactionLogger
        • Creating a new FileTransactionLogger
        • Appending entries to the transaction log
        • Using a bufio.Scanner to play back file transaction logs
        • Your transaction logger interface (redux)
        • Initializing the FileTransactionLogger in your web service
        • Integrating FileTransactionLogger with your web service
        • Future improvements
      • Storing State in an External Database
        • Working with databases in Go
        • Importing a database driver
        • Implementing your PostgresTransactionLogger
        • Creating a new PostgresTransactionLogger
        • Using db.Exec to execute a SQL INSERT
        • Using db.Query to play back postgres transaction logs
        • Initializing the PostgresTransactionLogger in your web service
        • Future improvements
    • Generation 3: Implementing Transport Layer Security
      • Transport Layer Security
        • Certificates, certificate authorities, and trust
      • Private Key and Certificate Files
        • Privacy enhanced mail (PEM) file format
      • Securing Your Web Service with HTTPS
      • Transport Layer Summary
    • Containerizing Your Key-Value Store
      • Docker (Absolute) Basics
        • The Dockerfile
        • Building your container image
        • Running your container image
        • Running your container image
        • Issuing a request to a published container port
        • Running multiple containers
        • Stopping and deleting your containers
      • Building Your Key-Value Store Container
        • Iteration 1: adding your binary to a FROM scratch image
        • Iteration 2: using a multi-stage build
      • Externalizing Container Data
    • Summary
  • III. The Cloud Native Attributes
  • 6. Its All About Dependability
    • Whats the Point of Cloud Native?
    • Its All About Dependability
    • What Is Dependability and Why Is It So Important?
      • Dependability: Its Not Just for Ops Anymore
    • Achieving Dependability
      • Fault Prevention
        • Good programming practices
        • Language features
        • Scalability
        • Loose coupling
      • Fault Tolerance
      • Fault Removal
        • Verification and testing
        • Manageability
      • Fault Forecasting
    • The Continuing Relevance of the Twelve-Factor App
      • I. Codebase
      • II. Dependencies
      • III. Configuration
      • IV. Backing Services
      • V. Build, Release, Run
      • VI. Processes
      • VII. Data Isolation
      • VIII. Scalability
      • IX. Disposability
      • X. Development/Production Parity
      • XI. Logs
      • XII. Administrative Processes
    • Summary
  • 7. Scalability
    • What Is Scalability?
      • Different Forms of Scaling
    • The Four Common Bottlenecks
    • State and Statelessness
      • Application State Versus Resource State
      • Advantages of Statelessness
    • Scaling Postponed: Efficiency
      • Efficient Caching Using an LRU Cache
      • Efficient Synchronization
        • Share memory by communicating
        • Reduce blocking with buffered channels
        • Minimizing locking with sharding
      • Memory Leaks Canfatal error: runtime: out of memory
        • Leaking goroutines
        • Forever ticking tickers
      • On Efficiency
    • Service Architectures
      • The Monolith System Architecture
      • The Microservices System Architecture
      • Serverless Architectures
        • The pros and cons of serverlessness
        • Serverless services
    • Summary
  • 8. Loose Coupling
    • Tight Coupling
      • Tight Coupling Takes Many Forms
        • Fragile exchange protocols
        • Shared dependencies
        • Shared point-in-time
        • Fixed addresses
    • Communications Between Services
    • Request-Response Messaging
      • Common Request-Response Implementations
      • Issuing HTTP Requests with net/http
      • Remote Procedure Calls with gRPC
        • Interface definition with protocol buffers
        • Installing the protocol compiler
        • The message definition structure
        • The key-value message structure
        • Defining our service methods
        • Compiling your protocol buffers
        • Implementing the gRPC service
        • Implementing the gRPC client
    • Loose Coupling Local Resources with Plug-ins
      • In-Process Plug-ins with the plugin Package
        • Plug-in vocabulary
        • A toy plug-in example
        • The Sayer interface
        • The Go plugin code
        • Building the plug-ins
        • Using our go plug-ins
          • Import the plugin package
          • Find our plug-in
          • Open our plug-in
          • Look up your symbol
          • Assert and use your symbol
        • Executing our example
      • HashiCorps Go Plug-in System over RPC
        • Another toy plug-in example
        • Common code
          • The Sayer interface
          • The SayerPlugin struct
          • The SayerRPC client implementation
          • The handshake configuration
          • The SayerRPCServer server implementation
        • Our plug-in implementation
        • Our host process
          • Import the hashicorp/go-plugin and commons packages
          • Find our plug-in
          • Create our plug-in client
          • Connect to our plug-in and dispense our Sayer
    • Hexagonal Architecture
      • The Architecture
      • Implementing a Hexagonal Service
        • Our refactored components
        • Our first plug
        • Our core application
        • Our TransactionLogger adapters
        • Our FrontEnd port
        • Putting it all together
    • Summary
  • 9. Resilience
    • Keeping on Ticking: Why Resilience Matters
    • What Does It Mean for a System to Fail?
      • Building for Resilience
    • Cascading Failures
      • Preventing Overload
        • Throttling
        • Load shedding
        • Graceful service degradation
    • Play It Again: Retrying Requests
      • Backoff Algorithms
      • Circuit Breaking
      • Timeouts
        • Using Context for service-side timeouts
        • Timing out HTTP/REST client calls
        • Timing out gRPC client calls
      • Idempotence
        • How do I make my service idempotent?
        • What about scalar operations?
    • Service Redundancy
      • Designing for Redundancy
      • Autoscaling
    • Healthy Health Checks
      • What Does It Mean for an Instance to Be Healthy?
      • The Three Types of Health Checks
        • Liveness checks
        • Shallow health checks
        • Deep health checks
      • Failing Open
    • Summary
  • 10. Manageability
    • What Is Manageability and Why Should I Care?
    • Configuring Your Application
      • Configuration Good Practice
      • Configuring with Environment Variables
      • Configuring with Command-Line Arguments
        • The standard flag package
        • The Cobra command-line parser
      • Configuring with Files
        • Our configuration data structure
        • Working with JSON
          • Encoding JSON
          • Decoding JSON
          • Field formatting with struct field tags
        • Working with YAML
          • Encoding YAML
          • Decoding YAML
          • Struct field tags for YAML
        • Watching for configuration file changes
          • Making your configuration reloadable
          • Polling for configuration changes
          • Watching OS filesystem notifications
      • Viper: The Swiss Army Knife of Configuration Packages
        • Explicitly setting values in Viper
        • Working with command-line flags in Viper
        • Working with environment variables in Viper
        • Working with configuration files in Viper
          • Reading configuration files
          • Watching and rereading configuration files in Viper
        • Using remote key/value stores with Viper
        • Setting defaults in Viper
    • Feature Management with Feature Flags
      • The Evolution of a Feature Flag
      • Generation 0: The Initial Implementation
      • Generation 1: The Hard-Coded Feature Flag
      • Generation 2: The Configurable Flag
      • Generation 3: Dynamic Feature Flags
        • Dynamic flags as functions
        • Implementing a dynamic flag function
        • The flag function lookup
        • The router function
    • Summary
  • 11. Observability
    • What Is Observability?
      • Why Do We Need Observability?
      • How Is Observability Different from Traditional Monitoring?
    • The Three Pillars of Observability
    • OpenTelemetry
      • The OpenTelemetry Components
    • Tracing
      • Tracing Concepts
      • Tracing with OpenTelemetry
        • Creating the tracing exporters
          • The Console Exporter
          • The Jaeger Exporter
        • Creating a tracer provider
        • Setting the global tracer provider
        • Obtaining a tracer
        • Starting and ending spans
        • Setting span metadata
          • Attributes
          • Events
        • Autoinstrumentation
          • Autoinstrumenting net/http and gorilla/mux
          • Autoinstrumenting gRPC
          • Getting the current span from context
      • Putting It All Together: Tracing
        • The Fibonacci service API
        • The Fibonacci service handler
        • The service Main function
        • Starting your services
        • Console exporter output
        • Viewing your results in Jaeger
    • Metrics
      • Push Versus Pull Metric Collection
        • Push-based metric collection
        • Pull-based metric collection
        • But which is better?
      • Metrics with OpenTelemetry
        • Creating the metric exporters
        • Setting the global meter provider
        • Exposing the metrics endpoint
        • Obtaining a meter
        • Metric instruments
          • Synchronous instruments
          • Asynchronous instruments
      • Putting It All Together: Metrics
        • Starting your services
        • Metric endpoint output
        • Viewing your results in Prometheus
    • Logging
      • Better Logging Practices
        • Treat logs as streams of events
        • Structure events for parsing
        • Less is (way) more
        • Dynamic sampling
      • Logging with Gos Standard log Package
        • The special logging functions
        • Logging to a custom writer
        • Log flags
      • The Zap Logging Package
        • Creating a Zap logger
        • Writing logs with Zap
        • Using dynamic sampling in Zap
    • Summary
  • Index

Dodaj do koszyka Cloud Native Go

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2021 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.