Build Go Apps That Scale on AWS

Table of Contents

• 

  Introduction

  00:00:00 - 00:14:27 View Transcript

  Melkey discusses the prerequisites and architecture of the application built throughout the course. The Go application is a simple API server with user authentication. Users can log in or create accounts. When a user is authenticated, a JWT is issued. The application will be deployed as a Lambda on AWS.
• 

  Why Use Go?

  00:14:28 - 00:24:14 View Transcript

  Melkey shares a brief history of Go, a statically typed, compiled language. Go is beginner-friendly and versatile, making it an attractive choice for start-ups and large organizations.
• 

  Go Community Adoption

  00:24:15 - 00:31:28 View Transcript

  Melkey describes why developers moved from Rust, Python, or other Fullstack frameworks to Go. The reasons include Go's ease of use, robust standard library, and strong type system.

• 

  Setup Your First Go Program

  00:31:29 - 00:47:08 View Transcript

  Melkey creates a Go program using the "go run init" command. A go.mod file is generated. The entry point to any Go program is main.go. Variables are introduced, and string, bool, and int types are demonstrated.
• 

  Arrays & Slices std library

  00:47:09 - 00:53:33 View Transcript

  Melkey demonstrates the differences between Arrays and Slices. Arrays have a fixed length assigned when they are declared. Slices are more flexible because their length can change dynamically. This flexibility does require more memory.
• 

  Structs & Receivers

  00:53:34 - 01:12:17 View Transcript

  Melkey introduces structs, which are class-like data types in Go. Functions can be added to structs by providing a receiver data type, allowing developers to create more complicated data types through composition. Passing structs as copies versus references is also demonstrated in this lesson.
• 

  Pointers & References

  01:12:18 - 01:22:58 View Transcript

  Melkey dives deeper into variable references and demonstrates pointers. The ampersand symbol refers to a variable's memory address and allows a pointer to be created. If the pointer is dereferencing, it is also explained, and a demonstration of using a pointer to update the original variable's value is provided.
• 

  Go Modules & Imports

  01:22:59 - 01:31:56 View Transcript

  Melkey demonstrates how Go modules can be divided into separate folders or packages and imported based on their package name. Capitalization of property names within a module will tell the compiler if the property is public or private.
• 

  Basic Struct Exercise

  01:31:57 - 01:38:27 View Transcript

  Students are instructed to create a Circle struct with a single field radius of type float64, define a circumference method, and, as a bonus, add a method for calculating the area. The exercise solution can be found on the live_workshop branch linked below.

• 

  AWS & CDK Setup

  01:38:28 - 01:52:15 View Transcript

  Melkey introduces AWS and the Could Development Kit (CDK). AWS will host the application, and the CDK will allow the AWS infrastructure to be set up with code rather than through the AWS interface. Installation instructions are reviewed. The AWS CLI and CDK setup instructions are in the course repo README.
• 

  CDK Init

  01:52:16 - 02:00:19 View Transcript

  Melkey discusses how the AWS CDK enables infrastructure as code within a project. The CDK will create and deploy the stack and provide utilities for comparing different states between the current and deployed stack. An initial project is created with the `cdk init` command.
• 

  CDK Constructs & Stacks

  02:00:20 - 02:08:26 View Transcript

  Melkey explains the difference between CDK constructs and stacks. A stack contains one or more resources. This application will include a Lambda, DynamoDB, and API Gateway. There can be one or more stacks in an application construct.
• 

  Understanding Lambdas

  02:08:27 - 02:14:09 View Transcript

  Melkey introduces Lambdas, serverless functions that can execute code in the cloud and be invoked by events. An advantage of serverless Lambdas is scalability. When there's an increase in traffic to an application, the underlying infrastructure is already prepared to scale.
• 

  Creating a Serverless Function

  02:14:10 - 02:21:59 View Transcript

  Melkey creates a serverless function in the lambda package in the application. It receives an event and returns either a string or an error depending on whether a username exists on the event.
• 

  Bundling the Lambda

  02:22:00 - 02:35:09 View Transcript

  Melkey uses the awslambda package in the CDK to build out the lambda function. The runtime, code payload, and the handler function to invoke are specified.
• 

  Deploying the Lambda

  02:35:10 - 02:41:39 View Transcript

  Melkey deploys the lambda to AWS using the CDK CLI. The function and environment are bootstrapped, and the code is packaged in a zip file. The `cdk diff` command can compare the current environment with what's being deployed.
• 

  Testing the Deployment

  02:41:40 - 02:45:23 View Transcript

  Melkey demonstrates how to view the lambda through the AWS CloudFormation console. A sample JSON payload is configured, and the lambda is tested.

• 

  Database & API Handlers

  02:45:24 - 02:58:27 View Transcript

  Melkey refactors the application to have a better project structure. Packages are created for the app, api, database, and types. The new DynamoDB client service is implemented. The chapter_0 branch can be used as a starting reference for this lesson.
• 

  Creating the App struct

  02:58:28 - 03:03:02 View Transcript

  Melkey creates the App struct, initializing a new DynamoDB client and API handler. The App is initialized in the top-level main.go file. The project structure is now completely bootstrapped.
• 

  DynamoDB

  03:03:03 - 03:07:04 View Transcript

  Melkey spends a few minutes discussing DynamoDB. It's a fully managed NoSQL database server that uses key-value stores. It's a fast, scalable database solution for serverless functions. A question about testing locally is also discussed in this lesson.
• 

  Check For Existing User

  03:07:05 - 03:19:53 View Transcript

  Melkey implements two functions to interact with the DynamoDB service. The first function checks for the existence of the user. The second performs the insert operation, adding a record with the username and a plain-text password. Later in the course, the password will be replaced with a hashed version.
• 

  Register User API Handler

  03:19:54 - 03:30:19 View Transcript

  Melkey adds the RegisterUserHandler function to the application's API. This function ensures the username and password are provided and uses the database functions to check for the user's existence and insert the user into the database. The AWS CDK logic is updated to create the necessary table in DynamoDB and the stack is updated.
• 

  Deploying Database and Lambda Changes

  03:30:20 - 03:36:03 View Transcript

  Melkey runs `cdk diff` to compare the changes with the current environment. The changes show an updated lambda deployment and the addition of DynamoDB. The changes are deployed and tested in Cloud Formation on AWS.

• 

  Using Interfaces to Decouple the DB

  03:36:04 - 03:45:11 View Transcript

  Melkey creates an interface for the database to decouple the database platform from the application. An interface is a collection of function signatures that act as a contract for the application. This allows the underlying database to be changed without affecting application logic. The chapter_1 branch can be used as a starting reference for this lesson.
• 

  Hashing Passwords

  03:45:12 - 03:53:44 View Transcript

  Melkey adds password hashing to the application. The bcrypt package is added to the project to both hash the plain text password and compare a plain text password with a hashed version.
• 

  AWS API Gateway

  03:53:45 - 03:57:24 View Transcript

  Melkey introduces the AWS API Gateway. It's a fully managed service that makes it easy to create, publish, maintain, monitor, and secure APIs at scale. A gateway is like a front door for an application to access backend services.
• 

  Defining the API Gateway Routes

  03:57:25 - 04:09:30 View Transcript

  Melkey defines the routes for the API gateway. Each route has a resource name, the URL path, and the necessary methods like GET or POST. The route resources are added to the gateway with a new lambda integration.
• 

  Logging In Users

  04:09:31 - 04:14:54 View Transcript

  Melkey begins adding the ability to log in users to the applications. First, a GetUser function is created to return a user from the database.
• 

  Refactor RegisterUserHandler

  04:14:55 - 04:27:57 View Transcript

  Melkey refactors the RegisterUserHandler function to accept an APIGatewayProxRequest object and return an APIGatewayProxyResponse object. The user data is unmarshaled from the request body, and the error-checking logic is updated.
• 

  Handling Login Requests

  04:27:58 - 04:34:46 View Transcript

  Melkey implements the LoginUser function, which receives an APIGatewayProxyRequest object and populates a LoginRequest struct from the request body. Error checking is added and a "StatusOK" is returned if the login is successful.The changes are then deployed with CDK
• 

  Testing with cURL

  04:34:47 - 04:41:26 View Transcript

  Melkey tests the API from the command line using cURL commands. A username and password are sent to the API using a POST method. If CloudWatch Logging errors appear when deploying the application, the `LoggingLevel` property in the go_cdk.go file can be removed, or the instructions mentioned in the lesson can be followed.

• 

  Creating a JWT

  04:41:27 - 04:48:58 View Transcript

  Melkey introduces JSON Web Tokens (JWTs), which are a URL-safe way of representing secure token-based authentication information between two parties. A CreateToken function generates the JWT and returns it as a string. The chapter_2 branch can be used as a starting reference for this lesson.
• 

  Middleware Package

  04:48:59 - 05:03:43 View Transcript

  Melkey creates a middleware to act as a wrapper around requests coming to routes only available to logged-in users. When a user requests a protected route, the middleware will extract the JWT from the Authorization headers and ensure the JWT is valid. Once the JWT is validated, the request is passed to the protected route's handler function.
• 

  Protected Routes

  05:03:44 - 05:13:22 View Transcript

  Melkey adds the protected route to the application and wraps the route's handler function with the middleware. The route details are added to the CDK infrastructure code, and the changes are deployed and tested.

• 

  Wrapping Up

  05:13:23 - 05:21:58 View Transcript

  Melkey wraps up the course by sharing some Go resources. The final code can be found on the live_workshop branch. The `cdk destroy` command can be run to remove the AWS infrastructure from your account.