Top 5 youtube channels to learn developing microservices with GO

• The webpage provides a free course, Building Microservices with Go, from YouTube that is designed to teach students to build microservices using the Go programming language.
• The course is aimed at individuals who have a basic understanding of Go and RESTful services.
• Each lesson in the course focuses on specific concepts in building microservices and is designed to progressively build on what was learned in the previous lesson.
• The course is divided into 19 lessons, and the topics covered include an introduction to microservices and RESTful services, version control with Gorilla framework, JSON validation, documenting REST APIs with Swagger, Cross-Origin Resource Sharing, handling files with Go standard library, HTTP multi-part requests, Gzip compression, introduction to gRPC and protocols, refactoring, and gRPC bi-directional streaming.
• The course is designed to teach students to build microservices more effectively and efficiently, and at the end of the course, students should be able to build microservices using Go programming language.
• The instructor of the course is Nic Raboy, who is a software developer, author, and speaker having more than a decade of software development experience. He is known for his blog, The Polyglot Developer, where he writes about software development, architecture, and other related topics. He has authored several books, including API Driven Development with Swift.
• The course also has supplementary resources like exercises, quizzes, and an eBook that help students practice what they have learned in the lessons.
• The course is hosted on the YouTube channel, The Polyglot Developer, and it has over 46 videos and runs for approximately 12 hours and 31 minutes.
• The webpage also presents Class Central that is learner supported. When you buy through links on their site, they may earn an affiliate commission.
• Class Central also provides personalized course recommendations, tracks subjects and courses with reminders, and helps learners never stop learning.
• The webpage also includes a review on “Never Stop Learning’’ that recommends the course to everyone who wants to build Microservices.

• Original post is by a redditor who is an experienced software developer but mostly worked with monolithic architecture.
• They are asking for a resource (video or blog post) that teaches the core fundamentals and concepts of microservices.
• One redditor comments that it can’t be learned in a week and mentions reading through the design patterns on microservices.io and learning the basic principles of DDD.
• Another redditor suggests that an experienced developer should already know the concepts, but microservices are context-dependent and require knowledge of REST, HTTP, authentication, and containerizing applications (docker, kubernetes).
• There are no magic solutions and it’s more about having experience, understanding the domain, and good software development practices.
• Another redditor recommends checking out Sam Newman’s books “Building Microservices” and “Monolith to Microservices”.
• One person suggests the 12-factor app as a starting point before slowly learning more.
• Some resources mentioned are:
  • Microsoft documention
  • YouTube videos to describe and use related software patterns. Like the “claims check pattern” you could implement.
  • Several courses on LinkedIn learning for micro services.
• None of the resources suggested are specific to developing microservices with GO.
• The original post is from 2 years ago.

Not used in article

Not used in article

Not used in article

Not used in article

Not used in article

Not used in article

• Microservices are a software architecture pattern where complex applications are decomposed into smaller, independent services.
• Microservices offer several benefits over traditional monolithic architectures, including scalability, resilience, agility, iteration, and technology diversity.
• Go, also known as Golang, has gained significant popularity in recent years due to its simplicity, performance, and excellent support for building concurrent systems.
• Go’s features make it an excellent choice for developing microservices, including being lightweight and fast, having built-in concurrency primitives, strong typing and error handling, and excellent support for HTTP-based APIs and message queues.
• When designing microservices in Go, several considerations should be taken into account to ensure scalability and resilience, including service decoupling and communication, service discovery and load balancing, data storage and persistence, and fault tolerance and resilience.
• Go provides various database drivers and libraries for interacting with different databases, such as MySQL, PostgreSQL, or MongoDB.
• Techniques like circuit breakers, retries, and timeouts can be employed to ensure resilience in microservices built with Go.
• To expose the microservice’s functionality over HTTP, we can utilize Go’s net/http package.
• Writing unit tests to ensure the correctness of your service’s business logic and integration tests to verify the behavior of the entire microservice is an integral part of building reliable microservices.
• Containerization and orchestration tools have become the de facto standards for deploying microservices. Docker provides a lightweight and portable containerization platform that simplifies the deployment of microservices.
• By packaging Go microservice into a Docker container, we can ensure consistency across different environments and streamline the deployment process.
• In Go, Go kit is a framework for developing microservices using best practices that focus on observability, maintainability, and scalability.
• The Go open-source community is active and supportive, providing numerous helpful libraries and examples on the internet to aid in the development of microservices using Go.
• Go has several YouTube channels where users can learn to develop microservices using Go, including:
  • Just For Func (1.8k karma)
  • GopherCon (5.8k karma)
  • Brian Scott (14.5k karma)
  • Changelog (1.6k karma)
  • Udemy (not given)

• A user on Reddit posted a thread two years ago asking for recommendations for open source projects to learn medium/large microservices projects implemented in Go, which utilize technologies such as gRPC, Redis, Kubernetes, message brokers, etc., and also have some documentation on the project.
• One user recommended https://github.com/ThreeDotsLabs/wild-workouts-go-ddd-example, a project created to show advanced techniques in DDD, CQRS, Clean Architecture. It includes blog posts describing it in depth, as well as a REST API using OpenAPI, gRPC, and deployment on Google Cloud Run. There’s also a more basic example on GitHub using Watermill - https://github.com/ThreeDotsLabs/nats-example, and https://github.com/ThreeDotsLabs/event-driven-example.
• Another user recommended https://github.com/MarioCarrion/todo-api-microservice-example, a repository that describes the user’s organization of code for big and complex services that leverage concepts coming from Domain Driven Design and Hexagonal Architecture. Links to more detailed blog posts and videos are also included.
• The same user recommended https://github.com/dotnet-architecture/eShopOnContainers as an example in dotnet of a large project.
• Another user posted a link to https://github.com/quii/mockingjay-server, a customizable, configurable mock server used to develop and test microservices before services you depend on are available. This may be helpful to users learning to develop microservices and needing to test dependencies that are not yet available.
• Another user recommended https://github.com/microservices-demo, a text-based workshop that guides users through building and deploying microservices using AMQP, Docker, Kubernetes, Elasticsearch, and more.
• One user recommended https://github.com/bohdanlisovskyi/telegram-golang-cqrs-es-cqrs-es-bot-tutorial as a Go-based project that uses CQRS and event sourcing in a chatbot app. The user provides a tutorial as well.
• The same user recommended https://github.com/IQ-tech/namespace-handler, which is a Kubernetes Namespaces Handler. The user provides insight into how this project may be helpful to users developing microservices in Kubernetes.
• Another user recommended https://github.com/dgraph-io/dgraph, a fast, distributed graph database that provides horizontal scaling and consistency guarantees with low latency. This may be helpful to users when building and deploying microservices.
• There is a discussion among users in the comments section

Not used in article

Not used in article

Sure, here are some relevant bullet points to remember later when answering your query on the top 5 YouTube channels to learn developing microservices with GO:

• Microservices are an architectural style for building distributed applications with small, independent, and loosely coupled services.
• Go is a programming language that was designed with concurrency, simplicity, and performance in mind.
• Go is compiled and produces native binaries that run fast and consume less memory. It has a built-in concurrency model based on goroutines and channels, which allows for writing scalable and responsive services that can handle a large number of requests in parallel.
• Go has a simple and expressive syntax that is easy to read and write. It also has a minimalistic and consistent standard library that covers most of the common functionalities needed for microservices, such as networking, encoding, testing, logging, etc. Go also enforces good practices such as code formatting, documentation, and error handling.
• Go supports cross-compilation, which makes it easy to compile code for different platforms and architectures. This feature enables deployment of services to different environments, such as cloud, containers, or edge devices.
• Go supports multiple communication protocols and formats, such as HTTP, gRPC, JSON, Protobuf, etc. This allows interacting with other services written in different languages and technologies. It also has excellent support for generating and consuming RESTful APIs, which are widely used for microservices.
• There is a growing community of Go developers and many online resources for learning Go and microservices, such as websites, forums, courses, books, and videos.
• Some popular tools and frameworks for building microservices with Go are Go kit, gRPC, Gin, Gorilla, HashiCorp’s Consul, and Kubernetes.
• Go kit is a toolkit for building microservices in Go, designed to help developers solve common problems such as service discovery, load balancing, circuit breaking, and telemetry.
• gRPC is a high-performance, open-source framework for building distributed systems that allows for defining and generating client/server code in multiple languages and platforms from a single source of truth.
• Gin is a web framework for building APIs and microservices with Go, designed for high-speed with low memory consumption.
• Gorilla is a set of packages for building web applications and services with a focus on providing flexible and well-documented APIs.
• HashiCorp’s Consul is a service mesh platform for discovering, managing, and securing services across any runtime platform and cloud.
• Kubernetes is an open-source container orchestration platform that automates the

• The Reddit post was made 2 years ago and has 6 karma points.
• The post’s title is “Best way to learn Golang from scratch to microservices.”
• The user who made the post has experience in TypeScript, C#, and Java. They want to make Go their main language and seek advice on the best way to learn it.
• One user recommends throwing the notion of OOP out the window when facing Go. It provides some OOP notions, but cramming OOP into Go will result in writing JGO instead of Go.
• Another user suggests reading the spec and Effective Go. They also recommend doing the Go tour and say good books and resources can be found on the Go wiki.
• There is a discussion on whether design patterns and OOP principles are useful in Go. One user suggests that Go loves simplicity and recommends not overdesigning and never overthinking. They say to write something that works, then move on.
• Another user disagrees that design patterns and OOP principles are not useful in Go. They say that Go can apply design patterns, but they are not implemented with classes. The user adds that knowing design patterns is still a useful abstraction skill.
• One user recommends watching Nic Jackson’s Building Microservices with Go series on YouTube. Another user also recommends this resource and has 5 karma points. They are currently reading Microservices with Go and suggest the Exercism.io Go track.
• Other recommended resources for learning Go include the Go Bootcamp and Todd McLeod’s How to Code: Google’s Go on Udemy.
• There is a discussion on how people should approach Go based on their professional experience and mindset. Some users mention overengineering as a prevalent problem and suggest Go is a more advanced language best leveraged by people who aim to get things done without being concerned about the purity of code design.
• One user suggests watching a video with another perspective on Go and cautions against a strong fixation on design patterns. They say that most “good OOP” code is modular procedural code that uses classes as a module system.

• A Reddit user asked for GitHub repos to learn microservices in Go and received recommendations from other users.
• One user recommended starting with a monolith and having loose coupling between different parts of the app to make it easier to break apart into microservices later on. They also mentioned Martin Fowler’s article about monoliths and microservices. (19 karma)
• Another user recommended looking into gRPC and buf to implement inter-process communication (IPC) techniques and patterns they had learned. (2 karma)
• A user shared a GitHub repo with a sample coffee shop application in Go that can be used to learn about microservices. (9 karma)
• Another user shared a GitHub repo with a sample Dockerized RESTful API application that includes a CRUD and can be used to learn about microservices in Go. (5 karma)
• A user recommended looking at Gokit for Go idiomatic and best practices, but later found that it added more abstraction than necessary. They also suggested looking into when to use messaging or a queue system. (5 karma)
• Another user shared a GitHub repo for a sample project called “Wild Workouts”, which uses domain-driven design (DDD) and can be used to learn about microservices in Go. (3 karma)

Overall, the users recommended starting with a well-architected monolith and using techniques like gRPC and DDD to break apart the app into microservices. They also suggested looking into messaging or queue systems and when to use them. These GitHub repos can be used to learn more about implementing microservices in Go and are a great starting point for those who want to get hands-on experience with microservices.

Not used in article

Not used in article

💭  Looking into

Go's suitability for developing microservices

💭  Looking into

List of top 5 youtube channels with tutorials, code reviews, and other resources for developing microservices with Go