GoLang Tutorial - Serverless Web API with AWS Lambda

In this post, we're going to make an HTTP endpoint that accepts a POST request at the path /echo, logs the POST body, and echoes the body back to the client.

We may want to modify our $GOPATH/src/myservice/serverless.yml to attach an HTTP event:

service: myservice # NOTE: update this with your service name

frameworkVersion: ">=1.28.0 <2.0.0"

provider:
  name: aws
  runtime: go1.x

package:
 exclude:
   - ./**
 include:
   - ./bin/**

functions:
  hello:
    handler: bin/hello
    events:
      - http:
          path: hello
          method: post

We replaced the get with post.

We'll also need to update our function in hello/main.go:

The code main.go

Our Handler() function now takes an APIGatewayProxyRequest object and returns a APIGatewayProxyResponse object. In our code, we're printing the request body, then returning a response with the request body.

Since we modified our code, we need to compile it again, and then deploy it.

$ pwd
/Users/kihyuckhong/go/src/myservice

$ make
dep ensure -v
env GOOS=linux go build -ldflags="-s -w" -o bin/hello hello/main.go
env GOOS=linux go build -ldflags="-s -w" -o bin/world world/main.go

$ sls deploy
Serverless: Packaging service...
Serverless: Excluding development dependencies...
Serverless: Uploading CloudFormation file to S3...
Serverless: Uploading artifacts...
Serverless: Uploading service myservice.zip file to S3 (11.94 MB)...
Serverless: Validating template...
Serverless: Updating Stack...
Serverless: Checking Stack update progress...
..............................
Serverless: Stack update finished...
Service Information
service: myservice
stage: dev
region: us-east-1
stack: myservice-dev
resources: 16
api keys:
  None
endpoints:
  POST - font color="green">https://fxmlls3d76.execute-api.us-east-1.amazonaws.com/dev/hello
  POST - https://fxmlls3d76.execute-api.us-east-1.amazonaws.com/dev/world
functions:
  hello: myservice-dev-hello
  world: myservice-dev-world
layers:
  None

Now we have an endpoint for the "hello" listed in our Service Information output. We can see our deployment from AWS Lambda console:

Let's use curl to hit our endpoint and get a response:

$ curl -X POST \
https://fxmlls3d76.execute-api.us-east-1.amazonaws.com/dev/hello \
 -d "Serverless Go"
Serverless Go

Note that we used the "-d" flag to send the specified data in a POST request to the HTTP server.

Note also that the main() function which is the entrypoint to our Golang binary is NOT our Lambda handler function. In the main() function we call lambda.Start() and pass in the Handler function as the lambda handler. Under the hood, a RPC server wraps our handler function:

func main() {
	lambda.Start() (Handler)
}

Ref: Serverless Framework example for Golang and Lambda

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)