Introduction to industry REST microservices in Golang (Go)
4.4 (187 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
1,381 students enrolled

Introduction to industry REST microservices in Golang (Go)

Everything you need to get serious about microservices design & development in Golang: From design to production metrics
4.4 (187 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
1,381 students enrolled
Created by Federico León
Last updated 4/2020
English
English [Auto-generated]
Current price: $16.99 Original price: $24.99 Discount: 32% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 16 hours on-demand video
  • 11 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Install, configure and setup Go
  • Analysis and design of REST microservices.
  • Different architectures and patterns for implementing them in Go.
  • Test as you Go. Ensure the quality of your work.
  • Advanced concurrency patterns.
  • Parallel execution on Multi-Core VMs.
  • HTTP frameworks, comparison and appliance.
  • Consuming external APIs. Test them. Mock them. Measure them. Use them.
  • The ultimate and best way of mocking different layers of your application.
  • Debugging and completely testing your application.
  • Create native webservices.
Course content
Expand all 31 lectures 15:45:02
+ Introduction
3 lectures 45:55

After this lesson you'll have the Go programming language configured in your computer and ready to start working!

Preview 12:39

Configuring the Golang environment in your local machine.

Configuring environment
20:56

We're creating a basic webserver and testing how it works.

Testing our first websever
12:20
+ Package organization - Applying MVC
3 lectures 01:13:29

How the MVC pattern looks, why it is useful and how we can implement it in Go.

Introduction to MVC
13:16

How to organize golang source code in order to be able to scale as much as needed in business logic without affecting features already developed.

Package organization
45:52

Sending changes to Github, creating a Pull Request, review and merge.

Pushing our changes to Git and first PR
14:21
+ Testing in go
4 lectures 01:57:21

Yes, testing is here! We're covering tests from day one since this is the most important feature that we need to use from scratch as we're depending on tests to ensure the quality of what we develop.

Introduction to testing
13:21

An introduction to golang unit tests, how to write them, how to read them and how they are important to prove that what we have built actually works as expected.

Unit tests
30:12

Introducing the benchmark features to compare performance on different approaches while defining the best solution for a given problem.

Benchmarks
35:40

How to structure artifacts from day one. A clear and well defined way to structure different layers of our application to get the most valuable features of the language working without issues and scaling in business logic.

How to structure Go artifacts and mock
38:08
+ Consuming external APIs
7 lectures 04:35:13

An introduction of HTTP frameworks available. How and why to use them, how they improve both the performance and structure of our application. Most important, how to test :)

HTTP Frameworks
35:39

Domain-based microservices are one of the most powerful tools available when creating scalable architectures. In this video, we cover how to analyze and model the domain based on the target APIs that we're planning to consume.

Analyzing our target APIs.
13:39

How to organize our domain structs based on their concepts. How to scale in amount of code we have without affecting the quality of the final product.

Defining our domain structs
34:13

An introduction of the net/http package, how to use only this package to perform API calls to external services, how to structure our source code and how to develop thinking on tests.

REST Api Calls - Native HTTP client
47:39

Adding mock features to our restclient. How to mock any aspect of our API call providers to get the most valuable product while making sure everything we write works as expected.

Testing: Mocking native REST Api calls.
39:20

For small projects, some of the REST frameworks available out there. How to import them, how and when to use them.

Putting all together
48:25

Integration tests between every layer of our application. How and when to use these types of tests.

Testing: Unit & Integration tests
56:18
+ From linear to concurrent
6 lectures 03:17:25

A short introduction to concurrency and parallelism concepts.

Concurrency is NOT parallelism
19:22

implementing concurren API calls to an external API while making sure everything works as expected. How to use the concurrency features of Go to make this work.

Implementation of concurrent API calls
01:11:27

In this video we cover how to test different parts of our concurrent design. Keep focus on performance while ensuring the quality of the solution by using both Unit and Integration tests.

Testing concurrent models
46:50

In most cases we just can't create millions of goroutines in order to complete some task. In this video we're covering the basics we need in order to limit the concurrent processes we create while keeping performance above all.

How to limit concurrency
38:24

A real-life problem. How to calculate the best shipping box based on the products that it holds.

Preview 07:14

How to use mutex to achieve atomic behaviors.

How to use Mutex
14:08
+ Logging system
3 lectures 01:14:10

How to build a distributed and scalable logging system using ELK (ElasticSearch, Logstash & Kibana). We're only focusing on the logging libraries available and the architecture design, leaving database integration for the Part 2 of this course.

Preview 12:23

An introduction to the Logrus library and how to implement logs based on it.

Log library - logrus
38:41

An introduction to the Uber's ZAP library and how to implement logs based on it.

Log library - zap
23:06
+ Final chapter
4 lectures 02:37:58

How to organize and plan your infrastructure in order to scale to support as many traffic as you need.

Infrastructure design for your microservices
31:37

In this lesson we cover how to implement an OAuth authentication layer for our application, how to locate our microservice inside our general architecture and how to implement the service. No database is used in this first version since we're going to iterate this approach in Part 2 of the course.


OAuth documentation: https://oauth.net/2/

Creating an OAuth authentication microservice
01:32:29

How to use interfaces to mock an entire layer of our application. Use of native and custom implementation and presenting some libraries we can use to achieve this requirement.

Mocking entire layers of the application
26:15

Final words after finishing the course. Congratulations!

End of course - Part 1
07:37
+ Extra chapter
1 lecture 03:31

If you have any questions or comments that are not particularly about the topics treated during this course you can always use the Q&A section and I'll make sure you clear your doubts by publishing content about those topics or issues as well. If you like what you're looking and getting, take a look at my website, there is a lot more in there!

Extra class - Take a look at my website
03:31
Requirements
  • Just complete the Golang tour available at Golang's website
Description

In this course I'm doing the very same I've been doing for the past 6 years: Analysis, design and development of high-performance microservices in Go.


This is not an introduction to Go's concepts, you have free resources for that like the Go Tour (I strongly suggest you to take it!). This is real-life and industry experience revealed in 13+ hours of video and resources that you will not easily find online.


We will cover everything you need:

  • Native web server.

  • HTTP frameworks.

  • Benchmarks.

  • Package organization.

  • MVC pattern.

  • Interfaces: How to design and implement them.

  • Dealing with dates.

  • Unit, Integration and Functional testing.

  • Mocking different artifacts of your application.

  • Consuming external APIs.

  • Mocking external APIs responses

  • Different concurrency designs based on each requirement.

  • Parallelism when we have multi-core VMs.

  • Stress-test our applications

  • Metrics, logging, debugging, profiling.

  • And a lots of more... EVERYTHING you need to work with this amazing technology.

Who this course is for:
  • Software engineers.
  • Software developers.
  • Technical leaders.
  • Architects.
  • Anyone who wants to get serious about microservices in Go.