Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20
, ,

Cloud Native

Using Containers, Functions, and Data to Build Next-Generation Applications

Paperback Engels 2019 9781492053828
Verkooppositie 5407
Verwachte levertijd ongeveer 8 werkdagen


Developers often struggle when first encountering the cloud. Learning about distributed systems, becoming familiar with technologies such as containers and functions, and knowing how to put everything together can be daunting. With this practical guide, you’ll get up to speed on patterns for building cloud native applications and best practices for common tasks such as messaging, eventing, and DevOps.

Authors Boris Scholl, Trent Swanson, and Peter Jausovec describe the architectural building blocks for a modern cloud native application. You’ll learn how to use microservices, containers, serverless computing, storage types, portability, and functions. You’ll also explore the fundamentals of cloud native applications, including how to design, develop, and operate them.

- Explore the technologies you need to design a cloud native application
- Distinguish between containers and functions, and learn when to use them
- Architect applications for data-related requirements
- Learn DevOps fundamentals and practices for developing, testing, and operating your applications
- Use tips, techniques, and best practices for building and managing cloud native applications
- Understand the costs and trade-offs necessary to make an application portable


Aantal pagina's:300
Hoofdrubriek:IT-management / ICT


Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht


Conventions Used in This Book
O’Reilly Online Learning
How to Contact Us

1. Introduction to Cloud Native
Distributed Systems
Fallacies of Distributed Systems
CAP Theorem
The Twelve-Factor App
Availability and Service-Level Agreements

2. Fundamentals
Container Isolation Levels
Container Orchestration
Kubernetes Overview
Kubernetes and Containers
Serverless Computing
From VMs to Cloud Native
Application Modernization
Application Optimization
Benefits of a Microservices Architecture
Challenges with a Microservices Architecture

3. Designing Cloud Native Applications
Fundamentals of Cloud Native Applications
Operational Excellence
Reliability and Availability
Scalability and Cost
Cloud Native versus Traditional Architectures
Functions versus Services
Function Scenarios
Considerations for Using Functions
Composite of Functions and Services
API Design and Versioning
API Backward and Forward Compatibility
Semantic Versioning
Service Communication
Messaging Protocols
Serialization Considerations
Choosing Between Pub/Sub and Request Response
Synchronous versus Asynchronous
Implementing Gateways
Service Mesh
Example Architecture

4. Working with Data
Data Storage Systems
Objects, Files, and Disks
Streams and Queues
Selecting a Datastore
Data in Multiple Datastores
Change Data Capture
Write Changes as an Event to a Change Log
Transaction Supervisor
Compensating Transactions
Extract, Transform, and Load
Microservices and Data Lakes
Client Access to Data
Restricted Client Tokens (Valet-Key)
Database Services with Fine-Grained Access Control
GraphQL Data Service
Fast Scalable Data
Sharding Data
Caching Data
Content Delivery Networks
Analyzing Data
Data Lakes on Object Storage
Data Lakes and Data Warehouses
Distributed Query Engines
Databases on Kubernetes
Storage Volumes

5. DevOps
What Is DevOps?
Lean Principles and Processes
Test Doubles
Test Automation Pyramid
When to Run Which Types of Tests
Testing Cadence
Testing in Production
Development Environments and Tools
Development Tools
Development Environments
Local Development Environments
Local Development with a Remote Cluster
Skaffold Development Workflow
Remote Cluster Routed to Local Development
Cloud Development Environments
Source Code Control
Build Stage (CI)
Test Stage (CI)
Deploy Stage (CD)
Release Stage (CD)
Post-Release Stage
Collecting Metrics
Observable Services
Configuration Management
Single-Environment Variable
Multiple-Environment Variables
Adding ConfigMap Data to a Volume
Storing Secrets
Deployment Configuration
Sample CI/CD Flows

6. Best Practices
Moving to Cloud Native
Breaking Up the Monolith for the Right Reasons
Decouple Simple Services First
Learn to Operate on a Small Scale
Use an Anticorruption Layer Pattern
Use a Strangler Pattern
Come Up with a Data Migration Strategy
Rewrite Any Boilerplate Code
Reconsider Frameworks, Languages, Data Structures, and Datastores
Retire Code
Ensuring Resiliency
Handle Transient Failures with Retries
Use a Finite Number of Retries
Use Circuit Breakers for Nontransient Failures
Graceful Degradation
Use a Bulkhead Pattern
Implement Health Checks and Readiness Checks
Define CPU and Memory Limits for Your Containers
Implement Rate Limiting and Throttling
Ensuring Security
Treat Security Requirements the Same as Any Other Requirements
Incorporate Security in Your Designs
Grant Least-Privileged Access
Use Separate Accounts/Subscriptions/Tenants
Securely Store All Secrets
Obfuscate Data
Encrypt Data in Transit
Use Federated Identity Management
Use Role-Based Access Control
Isolate Kubernetes Pods
Working with Data
Use Managed Databases and Analytics Services
Use a Datastore That Best Fits Data Requirements
Keep Data in Multiple Regions or Zones
Use Data Partitioning and Replication for Scale
Avoid Overfetching and Chatty I/O
Don’t Put Business Logic in the Database
Test with Production-like Data
Handle Transient Failures
Performance and Scalability
Design Stateless Services That Scale Out
Use Platform Autoscaling Features
Use Caching
Use Partitioning to Scale Beyond Service Limits
Write Single-Purpose Functions
Don’t Chain Functions
Keep Functions Light and Simple
Make Functions Stateless
Separate Function Entry Point from the Function Logic
Avoid Long-Running Functions
Use Queues for Cross-Function Communication
Deployments and Releases Are Separate Activities
Keep Deployments Small
CI/CD Definition Lives with the Component
Consistent Application Deployment
Use Zero-Downtime Releases
Don’t Modify Deployed Infrastructure
Use Containerized Build
Describe Infrastructure Using Code
Use Namespaces to Organize Services in Kubernetes
Isolate the Environments
Separate Function Source Code
Correlate Deployments with Commits
Logging, Monitoring, and Alerting
Use a Unified Logging System
Use Correlation IDs
Include Context with Log Entries
Common and Structured Logging Format
Tag Your Metrics Appropriately
Avoid Alert Fatigue
Define and Alert on Key Performance Indicators
Continuous Testing in Production
Start with Basic Metrics
Service Communication
Design for Backward and Forward Compatibility
Define Service Contracts That Do Not Leak Internal Details
Prefer Asynchronous Communication
Use Efficient Serialization Techniques
Use Queues or Streams to Handle Heavy Loads and Traffic Spikes
Batch Requests for Efficiency
Split Up Large Messages
Store Images in a Trusted Registry
Utilize the Docker Build Cache
Don’t Run Containers in Privileged Mode
Use Explicit Container Image Tags
Keep Container Images Small
Run One Application per Container
Use Verified Images from Trusted Repositories
Use Vulnerability Scanning Tools on Images
Don’t Store Data in Containers
Never Store Secrets or Configuration Inside an Image

7. Portability
Why Make Applications Portable?
The Costs of Portability
Data Gravity and Portability
When and How to Implement Portability
Standardized Interfaces
Common Services and Features
Abstractions and Layers
Managed Services from Other Vendors
Portability Tooling
Kubernetes as a Portability Layer


Alle 100 bestsellers


Populaire producten



        Cloud Native