CF

How to develop a productive HTTP client in Golang (Go)

9h 44m 29s
English
Paid

How to develop a productive HTTP client in Golang (Go) is a 45-lesson 9 hours 44 minutes self-paced course by Udemy. Have you ever called a REST API from your Go program?

Course facts

Lessons
45
Duration
9 hours 44 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

Have you ever called a REST API from your Go program? Did you implemented your own HTTP client or did you ended up using some of the thousand libraries out there? Do you know what your HTTP client is doing in the background? In this course we're starting from scratch! We're going to remember how a basic HTTP call looks like by digging into the request & response objects. We're going to write a basic HTTP client to perform HTTP requests and then use it in productive applications.

 What issues do we have? Can we scale our applications by following this approach? Of course not! 

That's why we're creating an HTTP client library that provides:

  • Fast, reliable and friction-free HTTP connections.

  • Support for all HTTP methods: GET, POST, PUT, DELETE, PATCH and more!

  • A Concurrency-Safe HTTP client that you can use without worrying about performance.

  • Content type management and optimization.

  • Mocking features out of the box.

  • A clean interface in case you want to unit test your code without relying on integration testing features.

  • A robust implementation so you won't need any external dependency whatsoever.

  • Completely customizable interface: timeouts, transport layer, custom HTTP client and lots of useful features.

  • A library that is PRODUCTION-READY!

If you're looking to integrate a 3rd party REST APIs in your code, you'll need to perform an HTTP call to it. Make sure you take a look at this course before even considering alternatives out there that will force you to use different dependencies for running, testing and extending your code! As Robert Pike says: "A little copying is much better than a little dependency". In this course we're not only getting rid of the dependencies but we're also getting rid of the copying. We're not using anything more than the Go's standard library to design & develop our own HTTP client.

This client will the baseline for all of the applications we're going to build later, making our business scale and grow as fast as we can Go.

Who teaches How to develop a productive HTTP client in Golang (Go)? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in How to develop a productive HTTP client in Golang (Go)?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 45 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (45)
#Lesson TitleDurationAccess
1
Introduction Demo
01:35
2
Welcome!
02:51
3
The reason for this course
08:43
4
What we're going to build
03:15
5
How an HTTP call looks like
13:23
6
Connections and timeouts
08:32
7
Implementing a basic HTTP GET
06:20
8
Default problems
21:33
9
The reason for a new library
25:36
10
Introduction to Go modules
20:18
11
Go basics: Structs, functions, interfaces and methods.
16:05
12
Adding basic behavior
13:24
13
Defining custom & common headers
17:41
14
Dealing with the request body
13:22
15
Testing, testing and testing!
18:09
16
Be careful with code coverage
18:38
17
Dealing with timeouts
16:07
18
Allow timeout customization
16:28
19
Allow timeout disabling
09:05
20
Builder pattern applied
15:47
21
Refactoring our builder implementation
06:11
22
Making the client concurrent-safe
09:04
23
Using our custom response implementation
18:11
24
Creating our examples
13:16
25
Should we provide mocking features?
12:24
26
Defining the Mock struct
14:12
27
Adding the mock server
17:35
28
Responding from the mock server
13:03
29
Adding a default mock
17:20
30
How to flush every active mock
09:01
31
Improving mock body and keys
07:57
32
How to publish a Go module
08:02
33
How to use our Go module
09:27
34
Easily testing API calls with our library
18:43
35
Allowing custom HTTP client
09:31
36
Clean our public interface
14:02
37
Adding documentation to our code
08:40
38
Adding more examples
21:08
39
Allow user agent definition
07:56
40
Defining common constants
06:29
41
Releasing the first stable version!
07:44
42
Cleaning our mocking interface
19:05
43
Changing how we mock requests
23:19
44
Cleaning our mock server
07:15
45
What we have done
18:02
Unlock unlimited learning

Get instant access to all 44 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to How to develop a productive HTTP client in Golang (Go)?

More courses by Udemy

Frequently asked questions

What prerequisites should I have before taking this course?
Before enrolling in this course, you should have a basic understanding of the Go programming language, as the course involves writing Go code extensively. Familiarity with fundamental Go concepts such as structs, functions, interfaces, and methods is essential, as these are covered in lesson 11. Basic knowledge of HTTP and RESTful APIs will also be beneficial, although the course begins with an introduction to how an HTTP call looks like.
What projects or applications will I build during the course?
Throughout the course, you will work on building a productive HTTP client from scratch. This involves implementing a basic HTTP GET request, making the client concurrent-safe, and using custom response implementations. You will also create examples and mock servers to test the functionality of your client under different conditions. By the end of the course, you'll have a stable Go module ready for use in productive applications.
Who is the target audience for this course?
This course is aimed at Go developers who are interested in understanding and developing HTTP clients in Go. It is suitable for those who have basic knowledge of Go and want to deepen their understanding of HTTP interactions in Go applications. Developers who wish to learn about timeouts, custom headers, client testing, and mocking in Go will find this course particularly useful.
How does the depth of this course compare to other similar courses?
This course offers a focused exploration on building HTTP clients in Go, starting from basic HTTP requests to advanced topics like making the client concurrent-safe and implementing custom responses. Unlike broader Go courses, it delves into specific aspects such as timeouts, mock servers, and Go module publishing, providing detailed insights into HTTP client development in Go.
What specific tools or platforms will be used in this course?
The course focuses on using the Go programming language itself, leveraging Go modules for package management and distribution. It covers essential Go features such as structs, functions, and interfaces, and also delves into Go-specific tools for testing and mocking HTTP requests. The course does not rely on external HTTP client libraries, emphasizing custom implementation instead.
What topics are not covered in this course?
The course does not cover other aspects of Go programming outside HTTP client development, such as web server implementation, database interactions, or Go's concurrency model in detail. It also does not delve into advanced network protocols beyond HTTP or explore using third-party libraries for HTTP clients, focusing instead on building a custom solution.
What is the expected time commitment for completing this course?
The course consists of 45 lessons, but the total runtime is not specified. Considering the depth of topics such as HTTP request implementation, timeout handling, and module publishing, students should expect to spend a considerable amount of time practicing coding, setting up their own projects, and testing their implementations alongside the instructional content.