Working with Microservices in Go (Golang)

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: About me

Lecture 3: Installing Go

Lecture 4: Installing Visual Studio Code

Lecture 5: Installing Make

Lecture 6: Installing Docker

Lecture 7: Asking for help

Lecture 8: Mistakes. We all make them.

Chapter 2: Building a simple front end and one Microservice

Lecture 1: What we'll cover in this section

Lecture 2: Setting up the front end

Lecture 3: Reviewing the front end code

Lecture 4: Our first service: the Broker

Lecture 5: Building a docker image for the Broker service

Lecture 6: Adding a button and JavaScript to the front end

Lecture 7: Creating some helper functions to deal with JSON and such

Lecture 8: Simplifying things with a Makefile (Mac & Linux)

Lecture 9: Simplifying things with a Makefile (Windows)

Chapter 3: Building an Authentication Service

Lecture 1: What we'll cover in this section

Lecture 2: Setting up a stub Authentication service

Lecture 3: Creating and connecting to Postgres from the Authentication service

Lecture 4: A note about PostgreSQL

Lecture 5: Updating our docker-compose.yml for Postgres and the Authentication service

Lecture 6: Populating the Postgres database

Lecture 7: Adding a route and handler to accept JSON

Lecture 8: Update the Broker for a standard JSON format, and conect to our Auth service

Lecture 9: Updating the front end to authenticate thorough the Broker and trying things out

Chapter 4: Building a Logger Service

Lecture 1: What we'll cover in this section

Lecture 2: Getting started with the Logger service

Lecture 3: Setting up the Logger data models

Lecture 4: Finishing up the Logger data models

Lecture 5: Setting up routes, handlers, helpers, and a web server in our logger-service

Lecture 6: Adding MongoDB to our docker-compose.yml file

Lecture 7: Add the logger-service to docker-compose.yml and the Makefile

Lecture 8: Adding a route and handler on the Broker to communicate with the logger service

Lecture 9: Update the front end to post to the logger, via the broker

Lecture 10: Add basic logging to the Authentication service

Lecture 11: Trying things out

Chapter 5: Building a Mail Service

Lecture 1: What we'll cover in this section

Lecture 2: Adding Mailhog to our docker-compose.yml

Lecture 3: Setting up a stub Mail microservice

Lecture 4: Building the logic to send email

Lecture 5: Building the routes, handlers, and email templates

Lecture 6: Challenge: Adding the Mail service to docker-compose.yml and the Makefile

Lecture 7: Solution to challenge

Lecture 8: Modifying the Broker service to handle mail

Lecture 9: Updating the front end to send mail

Lecture 10: A note about mail and security

Chapter 6: Building a Listener service: AMQP with RabbitMQ

Lecture 1: What we'll cover in this section

Lecture 2: Creating a stub Listener service

Lecture 3: Adding RabbitMQ to our docker-compose.yml

Lecture 4: Connecting to RabbitMQ

Lecture 5: Writing functions to interact with RabbitMQ

Lecture 6: Adding a logEvent function to our Listener microservice

Lecture 7: Updating main.go to start the Listener function

Lecture 8: Change the RabbitMQ server URL to the Docker address

Lecture 9: Creating a Docker image and updating the Makefile

Lecture 10: Updating the broker to interact with RabbitMQ

Lecture 11: Writing logic to Emit events to RabbitMQ

Lecture 12: Adding a new function in the Broker to log items via RabbitMQ

Lecture 13: Trying things out

Chapter 7: Communicating between services using Remote Procedure Calls (RPC)

Lecture 1: What we'll cover in this section

Lecture 2: Setting up an RPC server in the Logger microservice

Lecture 3: Listening for RPC calls in the Logger microservice

Lecture 4: Calling the Logger from the Broker using RPC

Lecture 5: Trying things out

Chapter 8: Speeding things up (potentially) with gRPC

Lecture 1: What we'll cover in this section

Lecture 2: Installing the necessary tools for gRPC

Lecture 3: Defining a Protocol for gRPC: the .proto file

Lecture 4: Generating the gRPC code from the command line

Lecture 5: Getting started with the gRPC server

Lecture 6: Listening for gRPC connections in the Logger microservice

Lecture 7: Writing the client code

Lecture 8: Updating the front end code

Lecture 9: Trying things out

Chapter 9: Deploying our Distributed App using Docker Swarm

Lecture 1: What we'll cover in this section

Lecture 2: Building images for our microservices

Lecture 3: Creating a Docker swarm deployment file

Lecture 4: Initializing and starting Docker Swarm

Lecture 5: Starting the front end and hitting our swarm

Lecture 6: Scaling services

Lecture 7: Updating services

Lecture 8: Stopping Docker swarm

Lecture 9: Updating the Broker service, and creating a Dockerfile for the front end

Lecture 10: Solution to the Challenge

Lecture 11: Adding the Front end to our swarm.yml deployment file

Lecture 12: Adding Caddy to the mix as a Proxy to our front end and the broker

Lecture 13: Modifying our hosts file to add a "backend" entry and bringing up our swarm

Lecture 14: Challenge: correcting the URL to the broker service in the front end

Lecture 15: Solution to challenge

Lecture 16: Updating Postgres to 14.2 – why monitoring is important!

Lecture 17: Spinning up two new servers on Linode