book

Network Programming with Go

by Adam Woodbeck

March 2021

Intermediate to advanced

392 pages

9h 46m

English

No Starch Press

Read now

Unlock full access

Who This Book Is ForInstalling GoRecommended Development Environments What’s in This Book
Choosing a Network TopologyBandwidth vs. LatencyThe Open Systems Interconnection Reference ModelThe Hierarchal Layers of the OSI Reference ModelSending Traffic by Using Data EncapsulationThe TCP/IP ModelThe Application LayerThe Transport LayerThe Internet LayerThe Link LayerWhat You’ve Learned
The Internet ProtocolIPv4 AddressingNetwork and Host IDsSubdividing IPv4 Addresses into SubnetsPorts and Socket AddressesNetwork Address TranslationUnicasting, Multicasting, and BroadcastingResolving the MAC Address to a Physical Network ConnectionIPv6 AddressingWriting IPv6 AddressesIPv6 Address CategoriesAdvantages of IPv6 over IPv4The Internet Control Message ProtocolInternet Traffic RoutingRouting ProtocolsThe Border Gateway ProtocolName and Address ResolutionDomain Name Resource RecordsMulticast DNSPrivacy and Security Considerations of DNS QueriesWhat You’ve Learned
What Makes TCP Reliable?Working with TCP SessionsEstablishing a Session with the TCP HandshakeAcknowledging Receipt of Packets by Using Their Sequence NumbersReceive Buffers and Window SizesGracefully Terminating TCP SessionsHandling Less Graceful TerminationsEstablishing a TCP Connection by Using Go’s Standard LibraryBinding, Listening for, and Accepting ConnectionsEstablishing a Connection with a ServerImplementing DeadlinesWhat You’ve Learned
Using the net.Conn InterfaceSending and Receiving DataReading Data into a Fixed BufferDelimited Reading by Using a ScannerDynamically Allocating the Buffer SizeHandling Errors While Reading and Writing Data Creating Robust Network Applications by Using the io PackageProxying Data Between ConnectionsMonitoring a Network ConnectionPinging a Host in ICMP-Filtered EnvironmentsExploring Go’s TCPConn ObjectControlling Keepalive MessagesHandling Pending Data on CloseOverriding Default Receive and Send BuffersSolving Common Go TCP Network ProblemsZero Window ErrorsSockets Stuck in the CLOSE_WAIT StateWhat You’ve Learned
Using UDP: Simple and UnreliableSending and Receiving UDP DataUsing a UDP Echo ServerReceiving Data from the Echo ServerEvery UDP Connection Is a ListenerUsing net.Conn in UDPAvoiding FragmentationWhat You’ve Learned
Reliable File Transfers Using TFTPTFTP TypesRead RequestsData PacketsAcknowledgmentsHandling ErrorsThe TFTP ServerWriting the Server CodeHandling Read RequestsStarting the ServerDownloading Files over UDPWhat You’ve Learned

What Are Unix Domain Sockets?Binding to Unix Domain Socket FilesChanging a Socket File’s Ownership and PermissionsUnderstanding Unix Domain Socket TypesWriting a Service That Authenticates Clients Requesting Peer CredentialsWriting the ServiceTesting the Service with NetcatWhat You’ve Learned
Understanding the Basics of HTTPUniform Resource LocatorsClient Resource RequestsServer ResponsesFrom Request to Rendered PageRetrieving Web Resources in GoUsing Go’s Default HTTP ClientClosing the Response BodyImplementing Time-outs and CancellationsDisabling Persistent TCP ConnectionsPosting Data over HTTPPosting JSON to a Web ServerPosting a Multipart Form with Attached FilesWhat You’ve Learned
The Anatomy of a Go HTTP ServerClients Don’t Respect Your TimeAdding TLS SupportHandlersTest Your Handlers with httptestHow You Write the Response MattersAny Type Can Be a HandlerInjecting Dependencies into HandlersMiddlewareTiming Out Slow ClientsProtecting Sensitive FilesMultiplexersHTTP/2 Server PushesPushing Resources to the ClientDon’t Be Too PushyWhat You’ve Learned
What Is Caddy?Let’s Encrypt IntegrationHow Does Caddy Fit into the Equation?Retrieving CaddyDownloading CaddyBuilding Caddy from Source CodeRunning and Configuring CaddyModifying Caddy’s Configuration in Real TimeStoring the Configuration in a FileExtending Caddy with Modules and AdaptersWriting a Configuration AdapterWriting a Restrict Prefix Middleware ModuleInjecting Your Module into CaddyReverse-Proxying Requests to a Backend Web ServiceCreating a Simple Backend Web ServiceSetting Up Caddy’s ConfigurationAdding a Reverse-Proxy to Your ServiceServing Static FilesChecking Your WorkAdding Automatic HTTPSWhat You’ve Learned
A Closer Look at Transport Layer SecurityForward SecrecyIn Certificate Authorities We TrustHow to Compromise TLSProtecting Data in TransitClient-side TLSTLS over TCPServer-side TLSCertificate PinningMutual TLS AuthenticationGenerating Certificates for AuthenticationImplementing Mutual TLSWhat You’ve Learned
Serializing ObjectsJSONGobProtocol BuffersTransmitting Serialized ObjectsConnecting Services with gRPCCreating a TLS-Enabled gRPC ServerCreating a gRPC Client to Test the ServerWhat You’ve Learned
Event LoggingThe log PackageLeveled Log EntriesStructured LoggingScaling Up with Wide Event LoggingLog Rotation with LumberjackInstrumenting Your CodeSetupCountersGaugesHistograms and SummariesInstrumenting a Basic HTTP ServerWhat You’ve Learned
Laying Some GroundworkAWS LambdaInstalling the AWS Command Line InterfaceConfiguring the CLICreating a RoleDefining an AWS Lambda FunctionCompiling, Packaging, and Deploying Your FunctionTesting Your AWS Lambda FunctionGoogle Cloud FunctionsInstalling the Google Cloud Software Development KitInitializing the Google Cloud SDKEnable Billing and Cloud FunctionsDefining a Cloud FunctionDeploying Your Cloud FunctionTesting Your Google Cloud FunctionAzure FunctionsInstalling the Azure Command Line InterfaceConfiguring the Azure CLIInstalling Azure Functions Core ToolsCreating a Custom HandlerDefining a Custom HandlerLocally Testing the Custom HandlerDeploying the Custom HandlerTesting the Custom HandlerWhat You’ve Learned

Content preview from Network Programming with Go

5 Unreliable UDP Communication

Although most networking applications take advantage of TCP’s reliability and flow control, the less popular User Datagram Protocol (UDP) is nonetheless an important part of the TCP/IP stack. UDP is a simple protocol with minimal features. Some applications do not require TCP’s feature set and session overhead. Those applications, like domain name resolution services, opt to use UDP instead.

This chapter starts by comparing UDP to TCP, focusing on scenarios where UDP may be a better choice over TCP. Then, you’ll learn how to send and receive UDP packets in Go. Finally, you’ll learn why it’s best to limit the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial