Muutke küpsiste eelistusi

Cloud Native: Using containers, functions, and data to build next-generation applications [Pehme köide]

4.05/5 (102 hinnangut Goodreads-ist)
, ,
  • Formaat: Paperback / softback, 300 pages, kõrgus x laius: 233x178 mm
  • Ilmumisaeg: 30-Sep-2019
  • Kirjastus: O'Reilly Media
  • ISBN-10: 1492053821
  • ISBN-13: 9781492053828
Teised raamatud teemal:
  • Pehme köide
  • Hind: 63,19 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Tavahind: 74,34 €
  • Säästad 15%
  • Raamatu kohalejõudmiseks kirjastusest kulub orienteeruvalt 2-4 nädalat
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Tellimisaeg 2-4 nädalat
  • Lisa soovinimekirja
Cloud Native: Using containers, functions, and data to build next-generation applicationsSuurem pilt
  • Formaat: Paperback / softback, 300 pages, kõrgus x laius: 233x178 mm
  • Ilmumisaeg: 30-Sep-2019
  • Kirjastus: O'Reilly Media
  • ISBN-10: 1492053821
  • ISBN-13: 9781492053828
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781492053828.html
Märksõnad:
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, youll 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. Youll learn how to use microservices, containers, serverless computing, storage types, portability, and functions. Youll 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
Preface xi
1 Introduction to Cloud Native 1(8)
Distributed Systems
1(3)
Fallacies of Distributed Systems
1(2)
CAP Theorem
3(1)
The Twelve-Factor App
4(2)
Availability and Service-Level Agreements
6(1)
Summary
7(2)
2 Fundamentals 9(20)
Containers
9(8)
Container Isolation Levels
11(2)
Container Orchestration
13(1)
Kubernetes Overview
13(3)
Kubernetes and Containers
16(1)
Serverless Computing
17(1)
Functions
18(1)
From VMs to Cloud Native
19(3)
Lift-and-Shift
19(1)
Application Modernization
20(2)
Application Optimization
22(1)
Microservices
22(5)
Benefits of a Microservices Architecture
23(2)
Challenges with a Microservices Architecture
25(2)
Summary
27(2)
3 Designing Cloud Native Applications 29(44)
Fundamentals of Cloud Native Applications
29(5)
Operational Excellence
29(2)
Security
31(2)
Reliability and Availability
33(1)
Scalability and Cost
34(1)
Cloud Native versus Traditional Architectures
34(5)
Functions versus Services
39(3)
Function Scenarios
39(1)
Considerations for Using Functions
39(1)
Composite of Functions and Services
40(2)
API Design and Versioning
42(3)
API Backward and Forward Compatibility
44(1)
Semantic Versioning
45(1)
Service Communication
45(10)
Protocols
46(1)
Messaging Protocols
47(1)
Serialization Considerations
48(1)
Idempotency
49(1)
Request/Response
49(2)
Publisher/Subscriber
51(2)
Choosing Between Pub/Sub and Request Response
53(1)
Synchronous versus Asynchronous
54(1)
Gateways
55(3)
Routing
55(1)
Aggregation
56(1)
Offloading
57(1)
Implementing Gateways
58(1)
Egress
58(1)
Service Mesh
59(9)
Example Architecture
68(4)
Summary
72(1)
4 Working with Data 73(36)
Data Storage Systems
75(7)
Objects, Files, and Disks
75(1)
Databases
76(3)
Streams and Queues
79(1)
Blockchain
79(1)
Selecting a Datastore
80(2)
Data in Multiple Datastores
82(10)
Change Data Capture
83(3)
Write Changes as an Event to a Change Log
86(1)
Transaction Supervisor
86(2)
Compensating Transactions
88(1)
Extract, Transform, and Load
89(1)
Microservices and Data Lakes
89(3)
Client Access to Data
92(4)
Restricted Client Tokens (Valet-Key)
93(1)
Database Services with Fine-Grained Access Control
94(1)
GraphQL Data Service
95(1)
Fast Scalable Data
96(4)
Sharding Data
97(1)
Caching Data
97(1)
Content Delivery Networks
98(2)
Analyzing Data
100(3)
Streams
100(1)
Batch
100(1)
Data Lakes on Object Storage
101(1)
Data Lakes and Data Warehouses
101(1)
Distributed Query Engines
102(1)
Databases on Kubernetes
103(4)
Storage Volumes
104(1)
StatefulSets
105(1)
DaemonSets
106(1)
Summary
107(2)
5 DevOps 109(50)
What Is DevOps?
109(3)
Collaboration
109(1)
Automation
110(1)
Lean Principles and Processes
110(1)
Measurement
111(1)
Sharing
111(1)
Testing
112(11)
Test Doubles
113(1)
Test Automation Pyramid
113(5)
When to Run Which Types of Tests
118(1)
Testing Cadence
119(1)
Testing in Production
120(3)
Development Environments and Tools
123(7)
Development Tools
124(2)
Development Environments
126(1)
Local Development Environments
126(1)
Local Development with a Remote Cluster
127(1)
Skaffold Development Workflow
128(1)
Remote Cluster Routed to Local Development
129(1)
Cloud Development Environments
130(1)
CI/CD
130(8)
Source Code Control
131(2)
Build Stage (CI)
133(1)
Test Stage (CI)
133(1)
Deploy Stage (CD)
134(2)
Release Stage (CD)
136(1)
Post-Release Stage
137(1)
Monitoring
138(11)
Collecting Metrics
139(5)
Observable Services
144(5)
Configuration Management
149(6)
Single-Environment Variable
151(1)
Multiple-Environment Variables
151(1)
Adding ConfigMap Data to a Volume
151(1)
Storing Secrets
152(1)
Deployment Configuration
153(2)
Sample CI/CD Flows
155(3)
Summary
158(1)
6 Best Practices 159(24)
Moving to Cloud Native
159(4)
Breaking Up the Monolith for the Right Reasons
159(1)
Decouple Simple Services First
160(1)
Learn to Operate on a Small Scale
160(1)
Use an Anticorruption Layer Pattern
160(1)
Use a Strangler Pattern
161(1)
Come Up with a Data Migration Strategy
162(1)
Rewrite Any Boilerplate Code
162(1)
Reconsider Frameworks, Languages, Data Structures, and Datastores
163(1)
Retire Code
163(1)
Ensuring Resiliency
163(2)
Handle Transient Failures with Retries
163(1)
Use a Finite Number of Retries
164(1)
Use Circuit Breakers for Nontransient Failures
164(1)
Graceful Degradation
164(1)
Use a Bulkhead Pattern
164(1)
Implement Health Checks and Readiness Checks
165(1)
Define CPU and Memory Limits for Your Containers
165(1)
Implement Rate Limiting and Throttling
165(1)
Ensuring Security
165(2)
Treat Security Requirements the Same as Any Other Requirements
165(1)
Incorporate Security in Your Designs
166(1)
Grant Least-Privileged Access
166(1)
Use Separate Accounts/Subscriptions/Tenants
166(1)
Securely Store All Secrets
166(1)
Obfuscate Data
166(1)
Encrypt Data in Transit
167(1)
Use Federated Identity Management
167(1)
Use Role-Based Access Control
167(1)
Isolate Kubernetes Pods
167(1)
Working with Data
167(2)
Use Managed Databases and Analytics Services
168(1)
Use a Datastore That Best Fits Data Requirements
168(1)
Keep Data in Multiple Regions or Zones
168(1)
Use Data Partitioning and Replication for Scale
168(1)
Avoid Overfetching and Chatty I/O
169(1)
Don't Put Business Logic in the Database
169(1)
Test with Production-like Data
169(1)
Handle Transient Failures
169(1)
Performance and Scalability
169(2)
Design Stateless Services That Scale Out
170(1)
Use Platform Autoscaling Features
170(1)
Use Caching
170(1)
Use Partitioning to Scale Beyond Service Limits
170(1)
Functions
171(1)
Write Single-Purpose Functions
171(1)
Don't Chain Functions
171(1)
Keep Functions Light and Simple
171(1)
Make Functions Stateless
171(1)
Separate Function Entry Point from the Function Logic
171(1)
Avoid Long-Running Functions
172(1)
Use Queues for Cross-Function Communication
172(1)
Operations
172(2)
Deployments and Releases Are Separate Activities
172(1)
Keep Deployments Small
172(1)
CI/CD Definition Lives with the Component
172(1)
Consistent Application Deployment
173(1)
Use Zero-Downtime Releases
173(1)
Don't Modify Deployed Infrastructure
173(1)
Use Containerized Build
173(1)
Describe Infrastructure Using Code
173(1)
Use Namespaces to Organize Services in Kubernetes
173(1)
Isolate the Environments
173(1)
Separate Function Source Code
173(1)
Correlate Deployments with Commits
174(1)
Logging, Monitoring, and Alerting
174(2)
Use a Unified Logging System
174(1)
Use Correlation IDs
174(1)
Include Context with Log Entries
174(1)
Common and Structured Logging Format
174(1)
Tag Your Metrics Appropriately
175(1)
Avoid Alert Fatigue
175(1)
Define and Alert on Key Performance Indicators
175(1)
Continuous Testing in Production
175(1)
Start with Basic Metrics
176(1)
Service Communication
176(2)
Design for Backward and Forward Compatibility
176(1)
Define Service Contracts That Do Not Leak Internal Details
177(1)
Prefer Asynchronous Communication
177(1)
Use Efficient Serialization Techniques
177(1)
Use Queues or Streams to Handle Heavy Loads and Traffic Spikes
178(1)
Batch Requests for Efficiency
178(1)
Split Up Large Messages
178(1)
Containers
178(3)
Store Images in a Trusted Registry
179(1)
Utilize the Docker Build Cache
179(1)
Don't Run Containers in Privileged Mode
179(1)
Use Explicit Container Image Tags
179(1)
Keep Container Images Small
179(1)
Run One Application per Container
180(1)
Use Verified Images from Trusted Repositories
180(1)
Use Vulnerability Scanning Tools on Images
180(1)
Don't Store Data in Containers
181(1)
Never Store Secrets or Configuration Inside an Image
181(1)
Summary
181(2)
7 Portability 183(14)
Why Make Applications Portable?
183(1)
The Costs of Portability
184(1)
Data Gravity and Portability
185(1)
When and How to Implement Portability
185(10)
Standardized Interfaces
186(1)
Common Services and Features
187(1)
Abstractions and Layers
187(2)
Managed Services from Other Vendors
189(1)
Portability Tooling
190(3)
Kubernetes as a Portability Layer
193(2)
Summary
195(2)
Index 197
Boris is a Product Architect with the Azure Compute team focusing on the next generation of distributed systems platforms and application models. He has been working on Azure Developer tools and platforms in various product engineering roles since 2011. Boris re-joined the Azure Compute team in 2018 after having spent the 18 months outside Microsoft leading an engineering team to work on a microservices platform based on Kubernetes and Service Meshes. His work on distributed systems platforms has resulted in several patents about cloud computing and distributed systems. Boris is a frequent speaker at industry events, a contributor to many blogs, instructor for distributed computing topics and the lead author of one of the first books about microservices and Docker on Azure (Microservices with Docker on Azure).

As a co-founder and consultant with Full Scale 180, he worked with some of Microsoft's largest customers, helping them migrate and build applications on the Microsoft Azure platform. He has been involved in building some of the largest applications running on Microsoft Azure today, many of which are now utilizing Docker, serverless technologies, and a microservices architecture. Trent often works with the Microsoft Patterns and Practices team developing guidance and best practices for cloud applications where he also co-authored a book on cloud design patterns. As a co-founder of Krillan and Threadsoft he has built applications based on a microservices architectural style using Docker, Node.js, Go, and Mesos. As a co-founder of B & S Enterprises, he dabbles with various IoT technologies for commercial building management.

Peter Jausovec is a software engineer with more than 10 years of experience in the field of software development and tech. During his career, he spent time in various roles, starting with QA then moving to software engineering and leading tech teams. His early career was mostly focused on developer and cloud tooling for Azure while working for Microsoft. In recent years, he has been focusing more on developing distributed systems, working with cloud-native solutions and microservices platform developed on Kubernetes and service mesh.