Muutke küpsiste eelistusi

E-raamat: Cloud Native Go: Building Web Applications and Microservices for the Cloud with Go and React

3.00/5 (31 hinnangut Goodreads-ist)
,
  • Formaat: 256 pages
  • Sari: Developer's Library
  • Ilmumisaeg: 05-Dec-2016
  • Kirjastus: Addison-Wesley Educational Publishers Inc
  • Keel: eng
  • ISBN-13: 9780134505756
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 19,49 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Cloud Native Go: Building Web Applications and Microservices for the Cloud with Go and ReactSuurem pilt
  • Formaat: 256 pages
  • Sari: Developer's Library
  • Ilmumisaeg: 05-Dec-2016
  • Kirjastus: Addison-Wesley Educational Publishers Inc
  • Keel: eng
  • ISBN-13: 9780134505756
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Today, companies and their developers need to respond to their market at breakneck speeds. Organizations that aren't built on highly-available, rapidly-evolving software are going the way of the dinosaurs.Cloud Native Go brings together all the knowledge developers need to build huge-scale cloud applications that meet the insatiable demands of today's customers and markets.

 

Kevin Hoffman starts with a primer on Go, a programming language that's rapidly gaining traction due to its exceptional suitability for cloud development. Next, he describes the modern cloud-native application in detail, illuminating the 12 Factors associated with successful cloud-native development.

 

Hoffman then guides you through building the skills you need to create microservices in Go, helping you master key techniques such as TDD in Go. Once you're comfortable building microservices, Hoffman shows how to add front-end web components using AngularJS and server-side templates. He walks through Go-based, cloud-native techniques for routing, RESTful service creation, JSON serialization, securing RESTful services, OAuth2 authentication, and more.

 

You'll find practical techniques for working with web sockets, developing responsive/mobile-friendly UIs, making the most of concurrency, and integrating database access. At each appropriate stopping point, Hoffman shows you how to push your work in progress to cloud like Cloud Foundry/Pivotal Web Services, watch it run there, and assess its ability to dynamically scale, and to support failover, fault tolerance, and monitoring.

 

With cloud-native development rapidly accelerating in importance, these are skills you need now - and no other book brings them together like this. By the time you're finished, you'll be ready to build cloud-native apps that dynamically scale to handle virtually any volume of data, traffic, or users.

1 The Way of the Cloud
1(10)
The Virtues of the Way of the Cloud
2(6)
Favor Simplicity
2(1)
Test First, Test Everything
3(2)
Release Early, Release Often
5(1)
Automate Everything
6(1)
Build Service Ecosystems
7(1)
Why Use Go?
8(1)
Simplicity
8(1)
Open Source
8(1)
Easy Automation and IDE Freedom
9(1)
Summary
9(2)
2 Getting Started
11(6)
The Right Tools for the Job
11(1)
Setting Up Git
12(2)
Installing Homebrew
12(1)
Installing the Git Client
13(1)
Installing Mercurial and Bazaar
13(1)
Creating a GitHub Account
13(1)
Setting Up Go
14(1)
Configuring your Go Workspace
14(1)
Testing Your Environment
15(1)
Summary
16(1)
3 Go Primer
17(18)
Building Hello Cloud
18(1)
Using Basic Functions
19(3)
Working with Structs
22(3)
Introducing Go Interfaces
25(1)
Adding Methods to Structs
25(3)
Exploiting Dynamic Typing in Go with Interfaces
26(2)
Working with Third-Party Packages
28(2)
Creating Your Own Packages
30(4)
Exporting Functions and Data
31(1)
Creating a Package
31(3)
Summary
34(1)
4 Delivering Continuously
35(18)
Introducing Docker
36(3)
Why use Docker?
36(1)
Installing Docker
36(2)
Running Docker Images
38(1)
Continuous Integration with Wercker
39(11)
Continuous Integration Best Practices
39(1)
Why use Wercker?
40(1)
Creating a Wercker Application
41(1)
Installing the Wercker CLI
42(1)
Creating a Wercker Configuration File
43(4)
Running a Wercker Build
47(2)
Deploying to DockerHub
49(1)
Reader Exercise: Create a Full Development Pipeline
50(2)
Advanced Challenge: Integrate Third-Party Library
52(1)
Summary
52(1)
5 Building Microservices in Go
53(18)
Designing Services API First
54(3)
Designing the Matches API
54(1)
Creating an API Blueprint
54(2)
Testing and Publishing Documentation with Apiary
56(1)
Scaffolding a Microservice
57(3)
Building Services Test First
60(8)
Creating a First, Failing Test
61(3)
Testing the Location Header
64(1)
Epic Montage---Test Iterations
65(3)
Deploying and Running in the Cloud
68(2)
Creating a PWS Account
68(1)
Setting up PCF Dev
68(1)
Pushing to Cloud Foundry
69(1)
Summary
70(1)
6 Using Backing Services
71(24)
Designing Service Ecosystems
72(1)
Building Dependent Services Test-First
73(11)
Creating the Fulfillment Service
74(3)
Creating the Catalog Service
77(7)
Sharing Structured Data Among Services
84(2)
Client Imports Server Package
84(1)
Client Duplicates Server Structure
84(1)
Client And Server Import Shared Package
85(1)
Using Service Bindings to Externalize URLs and Metadata
86(3)
Discovering Services
89(3)
Dynamic Service Discovery
90(1)
Service Discovery with Netflix's Eureka
90(2)
Reader Exercise
92(1)
Bonus Activity
93(1)
Summary
93(2)
7 Creating a Data Service
95(18)
Creating a MongoDB Match Repository
96(7)
Why MongoDB?
96(1)
Updating the Repository Pattern
96(1)
Communicating with MongoDB in Go
97(1)
Writing a MongoDB Repository Test-First
98(5)
Integration Testing a Mongo-Backed Service
103(7)
Integrating with a Transient MongoDB Database
103(3)
Writing an Integration Test
106(4)
Running in the Cloud
110(2)
Configuring a Backing Service
110(2)
Summary
112(1)
8 Event Sourcing and CQRS
113(24)
Reality is Event Sourced
114(3)
Idempotent
115(1)
Isolated
115(1)
Testable
116(1)
Replayable and Recoverable
116(1)
Big Data
117(1)
Embracing Eventual Consistency
117(1)
Introducing Command Query Responsibility Segregation
118(2)
Event Sourcing Use Cases
120(1)
Weather Monitoring
120(1)
Connected Cars
121(1)
Social Media Feed Processing
121(1)
Code Sample: Managing a Drone Army
121(1)
Creating a Command Handler Service
122(6)
Introduction to RabbitMQ
122(4)
Building the Command Handler Service
126(2)
Building the Event Processor
128(5)
Integration Testing the Event Processor
133(1)
Creating the Query Handler Service
133(2)
Summary
135(2)
9 Building a Web Application with Go
137(14)
Serving Static Files and Assets
138(1)
Supporting JavaScript Clients
139(3)
Using Server-Side Templates
142(3)
Processing Forms
145(1)
Working with Cookies and Session State
145(2)
Writing Cookies
146(1)
Reading Cookies
147(1)
Build and Deploy with Wercker
147(2)
Summary
149(2)
10 Security in the Cloud
151(16)
Securing a Web Application
151(9)
Web Application Security Options
152(1)
Setting up an AuthO Account
153(1)
Building an OAuth-Secured Web App
154(4)
Running the SecureWeb Application
158(2)
Securing Microservices
160(3)
Overview of the Client Credentials Pattern
160(1)
Securing a Microservice with Client Credentials
161(2)
A Note on SSL
163(1)
A Word on Privacy and Data Security
163(2)
Hackers Can't Get What You Don't Have
164(1)
Reader Exercise
165(1)
Summary
166(1)
11 Working with WebSockets
167(10)
Demystifying WebSockets
168(2)
How WebSockets Work
168(1)
WebSockets vs. Server-Sent Events
169(1)
Designing a WebSocket Server
169(1)
On WebSockets and Cloud Nativity
170(2)
Building a WebSocket App with a Messaging Provider
172(4)
A Note on JavaScript Frameworks
175(1)
Running the WebSockets Sample
175(1)
Summary
176(1)
12 Building Web Views with React
177(18)
JavaScript State of the Union
178(1)
Why React?
178(3)
The Virtual DOM
179(1)
Component Composition
180(1)
Reactive Data Flow
180(1)
Narrow Focus
180(1)
Ease* of Use
181(1)
Anatomy of a React Application
181(3)
The package.json File
181(1)
Webpack.config.js
182(1)
The .babelrc File
183(1)
Understanding JSX and Webpack
183(1)
React Components
184(1)
Building a Simple React Application
184(8)
What We Didn't Like
191(1)
Testing React Applications
192(1)
Further Reading
192(1)
React Websites
192(1)
React Books
193(1)
Other Materials
193(1)
Summary
193(2)
13 Creating UIs that Scale with Flux
195(14)
Introducing Flux
195(3)
Dispatcher
196(1)
Store
196(1)
View
197(1)
Action
197(1)
Source
197(1)
Complexity in Flux
197(1)
Building a Flux Application
198(9)
Summary
207(2)
14 Creating a Full Application---World of FluxCraft
209(14)
Introducing World of FluxCraft
210(1)
Architectural Overview
211(3)
Independent Scaling, Versioning, and Deployment
213(1)
Databases are not the Integration Tier
213(1)
One-Way Immutable Data Flow
213(1)
The Flux GUI
214(3)
The Go UI Host Service
215(1)
Sample Player Move Sequence
216(1)
Processing Commands
217(1)
Processing Events
218(1)
Maintaining Reality
219(1)
Map Management
219(1)
Automating Acceptance Tests
220(2)
Summary
222(1)
15 Conclusion
223(4)
What we Learned
223(2)
Go Isn't Just a Niche Language
223(1)
How Micro Should a Microservice Be?
224(1)
Continuous Delivery and Deployment
224(1)
Test Everything
224(1)
Release Early, Release Often
224(1)
Event Sourcing, CQRS, and More Acronyms
225(1)
Next Steps
225(2)
A Troubleshooting Cloud Applications 227(4)
Index 231
Kevin Hoffman helps enterprises bring their legacy applications onto the cloud through modernization and building cloud native services in many different languages. He started programming when he was 10 years old, teaching himself BASIC on a rebuilt Commodore VIC-20. Since then, he has been addicted to the art of building software, and has spent as much time as he can learning languages, frameworks, and patterns. He has built everything from software that remotely controls photography drones to biometric security, ultra-low-latency financial applications, mobile applications, and everything between. He fell in love with the Go language while building custom components for use with Pivotal Cloud Foundry.

Kevin is the author of a popular series of fantasy books ( The Sigilord Chronicles, http://amzn. to/2fc8iES ) and is eagerly awaiting the day when he will finally be able to combine his love for building software with his love for building fictional worlds.

Dan Nemeth has spent the last two decades building web and cloud systems for industries ranging from finance to pharmaceutical. He currently works at Pivotal enabling customer success with Pivotal Cloud Foundry. He now specializes in Go.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97801345057562e.html