Atjaunināt sīkdatņu piekrišanu

Practical Go: Building Scalable Network and Non-Network Applications [Mīkstie vāki]

4.75/5 (6 ratings by Goodreads)
  • Formāts: Paperback / softback, 416 pages, height x width x depth: 234x185x23 mm, weight: 726 g
  • Izdošanas datums: 03-Mar-2022
  • Izdevniecība: John Wiley & Sons Inc
  • ISBN-10: 1119773814
  • ISBN-13: 9781119773818
Citas grāmatas par šo tēmu:
  • Mīkstie vāki
  • Cena: 36,55 €*
  • * ši ir gala cena, t.i., netiek piemērotas nekādas papildus atlaides
  • Standarta cena: 43,00 €
  • Ietaupiet 15%
  • Grāmatu piegādes laiks ir 3-4 nedēļas, ja grāmata ir uz vietas izdevniecības noliktavā. Ja izdevējam nepieciešams publicēt jaunu tirāžu, grāmatas piegāde var aizkavēties.
  • Daudzums:
  • Ielikt grozā
  • Piegādes laiks - 4-6 nedēļas
  • Pievienot vēlmju sarakstam
Practical Go: Building Scalable Network and Non-Network ApplicationsPalielināt
  • Formāts: Paperback / softback, 416 pages, height x width x depth: 234x185x23 mm, weight: 726 g
  • Izdošanas datums: 03-Mar-2022
  • Izdevniecība: John Wiley & Sons Inc
  • ISBN-10: 1119773814
  • ISBN-13: 9781119773818
Citas grāmatas par šo tēmu:
Permanent link: https://www.kriso.lv/db/9781119773818.html
Keywords:
YOUR PRACTICAL, HANDS-ON GUIDE TO WRITING APPLICATIONS USING GO

Google announced the Go programming language to the public in 2009, with the version 1.0 release announced in 2012. Since its announcement to the community, and the compatibility promise of the 1.0 release, the Go language has been used to write scalable and high-impact software programs ranging from command-line applications and critical infrastructure tools to large-scale distributed systems. Its speed, simplicity, and reliability make it a perfect choice for developers working in various domains.

In Practical Go - Building Scalable Network + Non-Network Applications, you will learn to use the Go programming language to build robust, production-ready software applications. You will learn just enough to building command line tools and applications communicating over HTTP and gRPC.

This practical guide will cover:





Writing command line applications Writing a HTTP services and clients Writing RPC services and clients using gRPC Writing middleware for network clients and servers Storing data in cloud object stores and SQL databases Testing your applications using idiomatic techniques Adding observability to your applications Managing configuration data from your applications

You will learn to implement best practices using hands-on examples written with modern practices in mind. With its focus on using the standard library packages as far as possible, Practical Go will give you a solid foundation for developing large applications using Go leveraging the best of the languages ecosystem.
Introduction xvii
Getting Started xxi
Chapter 1 Writing Command-Line Applications
1(32)
Your First Application
1(7)
Writing Unit Tests
8(6)
Using the Flag Package
14(6)
Testing the Parsing Logic
20(2)
Improving the User Interface
22(1)
Removing Duplicate Error Messages
23(1)
Customizing Usage Message
24(1)
Accept Name via a Positional Argument
25(3)
Updating the Unit Tests
28(4)
Summary
32(1)
Chapter 2 Advanced Command-Line Applications
33(24)
Implementing Sub-commands
33(4)
An Architecture for Sub-command-Driven Applications
37(6)
Testing the Main Package
43(2)
Testing the Cmd Package
45(2)
Making Your Applications Robust
47(1)
User Input with Deadlines
48(4)
Handling User Signals
52(4)
Summary
56(1)
Chapter 3 Writing HTTP Clients
57(24)
Downloading Data
57(2)
Testing the Data Downloader
59(2)
Deserializing Received Data
61(5)
Sending Data
66(6)
Working with Binary Data
72(8)
Summary
80(1)
Chapter 4 Advanced HTTP Clients
81(24)
Using a Custom HTTP Client
81(1)
Downloading from an Overloaded Server
81(4)
Testing the Time-Out Behavior
85(3)
Configuring the Redirect Behavior
88(3)
Customizing Your Requests
91(1)
Implementing Client Middleware
92(1)
Understanding the Round Tripper Interface
93(1)
A Logging Middleware
94(2)
Add a Header to All Requests
96(3)
Connection Pooling
99(4)
Configuring the Connection Pool
103(1)
Summary
104(1)
Chapter 5 Building HTTP Servers
105(28)
Your First HTTP Server
105(3)
Setting Up Request Handlers
108(1)
Handler Functions
109(3)
Testing Your Server
112(2)
The Request Struct
114(1)
Method
115(1)
URL
115(1)
Proto, ProtoMajor, and ProtoMinor
116(1)
Header
116(1)
Host
116(1)
Body
116(1)
Form, PostForm
116(1)
Multipart Form
117(1)
Attaching Metadata to a Request
118(3)
Processing Streaming Requests
121(5)
Streaming Data as Responses
126(6)
Summary
132(1)
Chapter 6 Advanced HTTP Server Applications
133(28)
The Handler Type
133(1)
Sharing Data across Handler Functions
134(5)
Writing Server Middleware
139(1)
Custom HTTP Handler Technique
139(1)
The Handler Func Technique
140(2)
Chaining Middleware
142(5)
Writing Tests for Complex Server Applications
147(1)
Code Organization
147(6)
Testing the Handler Functions
153(2)
Testing the Middleware
155(2)
Testing the Server Startup
157(2)
Summary
159(2)
Chapter 7 Production-Ready HTTP Servers
161(32)
Aborting Request Handling
161(4)
Strategies to Abort Request Processing
165(4)
Handling Client Disconnects
169(4)
Server-Wide Time-Outs
173(1)
Implement a Time-Out for All Handler Functions
173(1)
Implementing Server Time-Out
174(5)
Implementing Graceful Shutdown
179(5)
Securing Communication with TLS
184(1)
Configuring TLS and HTTP/2
184(4)
Testing TLS Servers
188(4)
Summary
192(1)
Chapter 8 Building RPC Applications with gRPC
193(36)
gRPC and Protocol Buffers
193(4)
Writing Your First Service
197(1)
Writing the Server
198(5)
Writing a Client
203(4)
Testing the Server
207(4)
Testing the Client
211(3)
A Detour into Protobuf Messages
214(1)
Marshalling and Unmarshalling
214(5)
Forward and Backward Compatibility
219(1)
Multiple Services
220(6)
Error Handling
226(2)
Summary
228(1)
Chapter 9 Advanced gRPC Applications
229(46)
Streaming Communication
229(1)
Server-Side Streaming
230(7)
Client-Side Streaming
237(2)
Bidirectional Streaming
239(8)
Receiving and Sending Arbitrary Bytes
247(9)
Implementing Middleware Using Interceptors
256(1)
Client-Side Interceptors
257(6)
Server-Side Interceptors
263(6)
Wrapping Streams
269(2)
Chaining Interceptors
271(1)
Summary
272(3)
Chapter 10 Production-Ready gRPC Applications
275(36)
Securing Communication with TLS
275(3)
Robustness in Servers
278(1)
Implementing Health Checks
278(8)
Handling Runtime Errors
286(3)
Aborting Request Processing
289(8)
Robustness in Clients
297(1)
Improving Connection Setup
298(2)
Handling Transient Failures
300(5)
Setting lime-Outs for Method Calls
305(1)
Connection Management
306(3)
Summary
309(2)
Chapter 11 Working with Data Stores
311(38)
Working with Object Stores
312(1)
Integration with Package Server
313(10)
Testing Package Uploads
323(2)
Accessing Underlying Driver Types
325(2)
Working with Relational Databases
327(1)
Integration with Package Server
328(11)
Testing Data Storage
339(4)
Data Type Conversions
343(3)
Using Database Transactions
346(2)
Summary
348(1)
Appendix A Making Your Applications Observable
349(18)
Logs, Metrics, and Traces
349(3)
Emitting Telemetry Data
352(1)
Command-Line Applications
352(8)
HTTP Applications
360(4)
gRPC Applications
364(2)
Summary
366(1)
Appendix B Deploying Applications
367(6)
Managing Configuration
367(3)
Distributing Your Application
370(2)
Deploying Server Applications
372(1)
Summary 373(2)
Index 375
Amit Saha is a software engineer at Atlassian, located in Sydney, Australia. He has written Doing Math with Python: Use Programming to Explore Algebra, Statistics, Calculus, and More! (No Starch Press, 2015) and Write Your First Program (PHI Learning, 2013). His other writings have been published in technical magazines, conference proceedings, and research journals. He can be found online at https://echorand.me