Go + Terraform + AWS Lambda + API gateway 튜토리얼

$ mkdir go-note-api && cd $_
$ go mod init github.com/your-git-account/go-note-api

# Makefile
# Go parameters
GOCMD=go
GOBUILD=$(GOCMD) build
GOCLEAN=$(GOCMD) clean
GOTEST=$(GOCMD) test
GOGET=$(GOCMD) get
BINARY_NAME=main

all: test build
build:
	$(GOBUILD) -o $(BINARY_NAME) -v
test:
	$(GOTEST) -v ./...
clean:
	$(GOCLEAN)
	rm -f $(BINARY_NAME)

// main.go
package main

import "fmt"

func main() {
	fmt.Println("go-note-api")
}

$ go run .
go-note-api

$ make build
$ ./main
go-note-api

$ mkdir terraform && cd $_
$ touch data.tf providers.tf terraform.tf

$ aws s3 mb s3://go-note-api

// terraform.tf
terraform {
  required_version = ">= 0.12"
}

terraform {
  backend "s3" {
    bucket         = "go-note-api"
    key            = "terraform.tfstate"
    region         = "ap-northeast-2"
    encrypt        = true
    acl            = "private"
  }
}

// data.tf
data "aws_caller_identity" "current" {}

data "aws_s3_bucket" "go-note-api" {
  bucket = "simple-lambda-go"
}

output "account_id" {
  value = data.aws_caller_identity.current.account_id
}

output "s3_bucket" {
  value = data.aws_s3_bucket.simple-lambda-go.bucket
}

// providers.tf
provider "aws" {
  version = "~> 2.7"
  region  = "ap-northeast-2"
}

$ terraform init
Initializing the backend...

Successfully configured the backend "s3"! Terraform will automatically
use this backend unless the backend configuration changes.

Initializing provider plugins...
...

$ terraform refresh
...
Outputs:

account_id = Some-digits
s3_bucket = go-note-api

# Makefile
...
deps:
	$(GOGET) github.com/aws/aws-sdk-go
	$(GOGET) github.com/labstack/echo
	$(GOGET) github.com/aws/aws-lambda-go
	$(GOGET) github.com/awslabs/aws-lambda-go-api-proxy

# Cross compilation
build-linux:
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(BINARY_NAME) -v

# Package
package: build-linux
	zip lambda.zip main

$ make deps

// main.go
package main

import (
	"context"

	"github.com/aws/aws-lambda-go/lambda"
)

func HandleRequest(ctx context.Context) (string, error) {
	return "Hello World!", nil
}

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

$ make build-linux
$ zip lambda.zip ./main

// terraform/lambda.tf
resource "aws_iam_role" "go-note-api" {
  name = "LambdaRole_GoNoteAPI"  # 고유한 이름이어야 한다.

  assume_role_policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {"Service": "lambda.amazonaws.com"},
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF
}

resource "aws_iam_role_policy_attachment" "go-note-api" {
  role       = aws_iam_role.go-note-api.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

resource "aws_lambda_function" "go-note-api" {
  function_name = "go-note-api"
  role          = aws_iam_role.go-note-api.arn
  filename      = "../lambda.zip"  # 우선 로컬에 있는 파일을 직접 업로드한다.
  handler       = "main"
  runtime       = "go1.x"
  memory_size   = 1024
  timeout       = 300

  environment {
    variables = {
      APP_ENV = "production"
    }
  }
}

resource "aws_cloudwatch_log_group" "go-note-api" {
  name = "/aws/lambda/go-note-api"
}

$ terraform apply
data.aws_caller_identity.current: Refreshing state...
data.aws_s3_bucket.go-note-api: Refreshing state...

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # aws_cloudwatch_log_group.go-note-api will be created
  + resource "aws_cloudwatch_log_group" "go-note-api" {
      + arn               = (known after apply)
      + id                = (known after apply)
...

$ aws lambda invoke --function-name go-note-api /dev/stdout
"Hello World!"

# Makefile
...
S3_BUCKET=go-note-api
LAMBDA_NAME=go-note-api

...

# Package
package:
	zip lambda.zip main

# Upload compiled
deploy: package
	aws s3 cp ./lambda.zip s3://${S3_BUCKET}/${LAMBDA_NAME}/
	aws lambda update-function-code \
		--region ap-northeast-2 \
		--function-name ${LAMBDA_NAME} \
		--s3-bucket ${S3_BUCKET} \
		--s3-key ${LAMBDA_NAME}/lambda.zip --publish

$ make build && make deploy
$ aws lambda invoke --function-name go-note-api /dev/stdout
"Hello overthecode!"

// server.go
package main

import (
	"net/http"

	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
)

func createServer() *echo.Echo {
	e := echo.New()
	e.Use(middleware.CORS())  // 추후에 웹 페이지에서 요청을 날릴 수 있도록 CORS 헤더 추가
	e.GET("/note", func(c echo.Context) error {
		return c.NoContent(http.StatusOK)
	})

	return e
}

package main

import (
	"context"
	"os"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
	echoadapter "github.com/awslabs/aws-lambda-go-api-proxy/echo"
	"github.com/labstack/echo"
)

func getHandler(server *echo.Echo) func(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	echoLambda := echoadapter.New(server)
	return func(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
		// If no name is provided in the HTTP request body, throw an error
		return echoLambda.Proxy(req)
	}
}

func main() {
	server := createServer()

	env := os.Getenv("APP_ENV")
	if env == "production" {
		lambda.Start(getHandler(server))
	} else {
		server.Logger.Fatal(server.Start(":3201"))
	}
}

$ curl -I -X GET http://localhost:3201/note
HTTP/1.1 200 OK
Access-Control-Allow-Origin: *
Vary: Origin
Date: Wed, 20 May 2020 01:50:12 GMT
Content-Length: 0

// api-gateway-api.tf
resource "aws_api_gateway_rest_api" "go-note-api" {
  name        = "go-note-api"
}

// api-gateway-method.tf
resource "aws_api_gateway_resource" "note" {
  rest_api_id = aws_api_gateway_rest_api.go-note-api.id
  parent_id   = aws_api_gateway_rest_api.go-note-api.root_resource_id
  path_part   = "note"
}

resource "aws_api_gateway_method" "note" {
  rest_api_id   = aws_api_gateway_rest_api.go-note-api.id
  resource_id   = aws_api_gateway_resource.note.id
  http_method   = "ANY"
  authorization = "NONE"
}

resource "aws_api_gateway_integration" "note" {
  rest_api_id             = aws_api_gateway_rest_api.go-note-api.id
  resource_id             = aws_api_gateway_resource.note.id
  http_method             = aws_api_gateway_method.note.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = "arn:aws:apigateway:ap-northeast-2:lambda:path/2015-03-31/functions/${aws_lambda_function.go-note-api.arn}/invocations"
}

resource "aws_api_gateway_resource" "note-proxy" {
  rest_api_id = aws_api_gateway_rest_api.go-note-api.id
  parent_id   = aws_api_gateway_resource.note.id
  path_part   = "{proxy+}"
}

resource "aws_api_gateway_method" "note-proxy" {
  rest_api_id   = aws_api_gateway_rest_api.go-note-api.id
  resource_id   = aws_api_gateway_resource.note-proxy.id
  http_method   = "ANY"
  authorization = "NONE"
}

resource "aws_api_gateway_integration" "note-proxy" {
  rest_api_id             = aws_api_gateway_rest_api.go-note-api.id
  resource_id             = aws_api_gateway_resource.note-proxy.id
  http_method             = aws_api_gateway_method.note-proxy.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = "arn:aws:apigateway:ap-northeast-2:lambda:path/2015-03-31/functions/${aws_lambda_function.go-note-api.arn}/invocations"
}

// lambda.tf
...
resource "aws_lambda_permission" "go-note-api" {
  statement_id  = "AllowExecutionFromAPIGateway"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.go-note-api.arn
  principal     = "apigateway.amazonaws.com"
  source_arn    = "arn:aws:execute-api:ap-northeast-2:${data.aws_caller_identity.current.account_id}:${aws_api_gateway_rest_api.go-note-api.id}/*/*"
}

// dynamodb.tf
resource "aws_dynamodb_table" "go-note-api" {
  name           = "go-note-api"
  billing_mode   = "PAY_PER_REQUEST"

  hash_key       = "user"
  range_key      = "id"

  attribute {
    name = "user"
    type = "S"
  }

  attribute {
    name = "id"
    type = "S"
  }
}

// table.go
package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/dynamodb"
	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
)

type Table struct {
	name string
	db   *dynamodb.DynamoDB
}

// Create session.
func (t *Table) Init(name string) {
	db := dynamodb.New(session.New(), &aws.Config{Region: aws.String("ap-northeast-2")})
	t.name = name
	t.db = db
}

// Put item into dynamodb table
func (t *Table) PutItem(item interface{}) error {

	av, err := dynamodbattribute.MarshalMap(item)
	if err != nil {
		fmt.Println("Got error marshalling attribute item:")
		fmt.Println(err.Error())
		return err
	}

	input := &dynamodb.PutItemInput{
		Item:      av,
		TableName: aws.String(t.name),
	}

	_, err = t.db.PutItem(input)
	if err != nil {
		fmt.Println("Got error PutItem:")
		fmt.Println(err.Error())
		return err
	}
	return nil
}

// note.go
package main

import (
	"strconv"
	"time"
)

var noteTable *Table

func init() {
	noteTable = &Table{}
	noteTable.Init("go-note-api")  // 앞서 만들어준 table이름을 넣어준다.
}

type note struct {
	User      string    `json:"user"`
	Id        string    `json:"id"`
	Title     string    `json:"title"`
	Content   string    `json:"content"`
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

type NoteKey struct {
	Id   string `json:"id"`
	User string `json:"user"`
}

func createNote(user string, m note) (*note, error) {

	_m := note{
		User:      user,
		Content:   m.Content,
		Id:        strconv.FormatInt(time.Now().UTC().UnixNano()/1000, 10),
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
		Title:     m.Title,
	}

	err := noteTable.PutItem(_m)
	if err != nil {
		return nil, err
	}
	return &_m, nil
}

// server.go
...
func createServer() *echo.Echo {

  ...

	e.POST("/note/:user", func(c echo.Context) error {
		user := c.Param("user")
		body := &note{}
		if err := c.Bind(body); err != nil {
			return err
		}

		note, err := createNote(user, *body)
		if err != nil {
			c.Error(err)
		}

		return c.JSON(http.StatusCreated, note)
	})

	return e
}

$ curl -X POST -H "Content-Type: application/json" -d \
  '{ "title": "untitled", "content": "cat is awesome" }' \
  http://localhost:3201/note/user1

// lambda.tf
...
resource "aws_iam_policy" "go-note-api-dynamodb" {
  name = "LambdaPolicy_GoNoteAPI"

  policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:PutItem",
        "dynamodb:DeleteItem",
        "dynamodb:Scan",
        "dynamodb:Query",
        "dynamodb:UpdateItem",
        "dynamodb:ListTable",
        "dynamodb:DescribeTable",
        "dynamodb:GetItem",
        "dynamodb:DescribeLimits",
        "dynamodb:GetRecords"
      ],
      "Resource": "arn:aws:dynamodb:ap-northeast-2:${data.aws_caller_identity.current.account_id}:table/go-note-api"
    }
  ]
}
EOF
}

resource "aws_iam_role_policy_attachment" "go-note-api-dynamodb" {
  role       = aws_iam_role.go-note-api.name
  policy_arn = aws_iam_policy.go-note-api-dynamodb.arn
}

// data.tf
...
- output "account_id" {
-   value = data.aws_caller_identity.current.account_id
- }

- output "s3_bucket" {
-   value = data.aws_s3_bucket.go-note-api.bucket
- }

data "aws_route53_zone" "go-note-api" {
  name = "overthecode.io."  // 본 서비스에 적용할 루트 도메인.
}

data "aws_acm_certificate" "go-note-api" {
  domain      = "overthecode.io"
  types       = ["AMAZON_ISSUED"]
  most_recent = true
}

// api-gateway-api.tf
...
resource "aws_api_gateway_deployment" "go-note-api" {
  rest_api_id = aws_api_gateway_rest_api.go-note-api.id
  stage_name  = ""
}

resource "aws_api_gateway_stage" "go-note-api" {
  depends_on = [aws_api_gateway_deployment.go-note-api]

  stage_name           = "v1"
  rest_api_id          = aws_api_gateway_rest_api.go-note-api.id
  deployment_id        = aws_api_gateway_deployment.go-note-api.id
}

// api-gateway-domain.tf
resource "aws_api_gateway_domain_name" "go-note-api" {
  domain_name              = "api.overthecode.io"  // api 엔드포인트로 사용할 서브도메인
  regional_certificate_arn = data.aws_acm_certificate.go-note-api.arn

  endpoint_configuration {
    types = ["REGIONAL"]
  }
}

resource "aws_route53_record" "go-note-api" {
  name    = aws_api_gateway_domain_name.go-note-api.domain_name
  type    = "A"
  zone_id = data.aws_route53_zone.go-note-api.id

  alias {
    evaluate_target_health = true
    name                   = aws_api_gateway_domain_name.go-note-api.regional_domain_name
    zone_id                = aws_api_gateway_domain_name.go-note-api.regional_zone_id
  }
}

resource "aws_api_gateway_base_path_mapping" "go-note-api" {
  api_id      = aws_api_gateway_rest_api.go-note-api.id
  stage_name  = "v1"  // stage 이름을 v1로 정했었다.
  domain_name = aws_api_gateway_domain_name.go-note-api.domain_name
}

$ curl -X POST -H "Content-Type: application/json" -d \
  '{ "title": "hello", "content": "world!" }' \
  https://api.overthecode.io/note/user1

// table.go
...

// Query table with hash key and pagination.
func (t *Table) ListItem(hkName string, hkValue string, paginated bool, from interface{}) (*dynamodb.QueryOutput, error) {
	hash := expression.Key(hkName).Equal(expression.Value(hkValue))
	expr, err := expression.NewBuilder().WithKeyCondition(hash).Build()

	if err != nil {
		fmt.Println("Got error building expression:")
		fmt.Println(err.Error())
		return nil, err
	}

	query := dynamodb.QueryInput{
		KeyConditionExpression:    expr.KeyCondition(),
		ExpressionAttributeValues: expr.Values(),
		ExpressionAttributeNames:  expr.Names(),
		TableName:                 aws.String(t.name),
		Limit:                     aws.Int64(5),  // 한번에 다섯개 까지 읽어올 수 있다.
	}                                           // 페이지네이션 테스트를 위해 값을 작게 설정했다.

	if paginated {
		exkey, err := dynamodbattribute.MarshalMap(from)

		if err != nil {
			fmt.Println("Got error building ExclusiveStartKey:")
			fmt.Println(err.Error())
			return nil, err
		} else {
			query.ExclusiveStartKey = exkey
		}
	}

	result, err := t.db.Query(&query)

	if err != nil {
		fmt.Println("Got error while query:")
		fmt.Println(err.Error())
		return nil, err
	}

	return result, nil
}

// note.go
...

type noteQueryResult struct {
	Notes            []note  `json:"notes"`
	Count            int64   `json:"count"`
	ScannedCount     int64   `json:"scannedCount"`
	LastEvaluatedKey NoteKey `json:"lastEvaluatedKey"`
}

func getNotes(user string, from string) (*noteQueryResult, error) {
	result, err := noteTable.ListItem("user", user, from != "", NoteKey{User: user, Id: from})
	if err != nil {
		return nil, err
	}

	notes := make([]note, len(result.Items))
	for i, v := range result.Items {
		dynamodbattribute.UnmarshalMap(v, &notes[i])
	}

	lastEvaluatedKey := NoteKey{}

	if result.LastEvaluatedKey != nil {
		dynamodbattribute.UnmarshalMap(result.LastEvaluatedKey, &lastEvaluatedKey)
	}

	noteQueryResult := noteQueryResult{
		Notes:            notes,
		Count:            *result.Count,
		ScannedCount:     *result.ScannedCount,
		LastEvaluatedKey: lastEvaluatedKey,
	}

	return &noteQueryResult, nil
}

// server.go
...
func createServer() *echo.Echo {
  ...
  e.GET("/note/:user", func(c echo.Context) error {
    user := c.Param("user")
	  id := c.QueryParam("from")
	  notes, err := getNotes(user, id)

    if err != nil {
		 	c.Error(err)
	  }
    return c.JSON(http.StatusOK, notes)
  })

  return e
}

$ curl -X GET http://localhost:3201/note/user1
...
$ make build-linux && make deploy
$ curl -X GET https://api.overthecode.io/note/user1
...

$ curl -X POST -H "Content-Type: application/json" -d \
  '{ "title": "hello2", "content": "world2" }' \
  https://api.overthecode.io/note/user1
$ curl -X POST -H "Content-Type: application/json" -d \
  '{ "title": "hello3", "content": "world3" }' \
  https://api.overthecode.io/note/user1
...

$ curl -X GET https://api.overthecode.io/note/user1\?from\=1590012352455034

// table.go
...
// Update item in dynamodb table
func (t *Table) UpdateItem(key interface{}, expr expression.Expression) (*dynamodb.UpdateItemOutput, error) {

	k, err := dynamodbattribute.MarshalMap(key)
	if err != nil {
		fmt.Println("Got error marshalling key item:")
		fmt.Println(err.Error())
		return nil, err
	}

	input := &dynamodb.UpdateItemInput{
		Key:                       k,
		ExpressionAttributeNames:  expr.Names(),
		ExpressionAttributeValues: expr.Values(),
		TableName:                 aws.String(t.name),
		ReturnValues:              aws.String("ALL_NEW"),
		UpdateExpression:          expr.Update(),
	}

	result, err := t.db.UpdateItem(input)
	if err != nil {
		fmt.Println("Got error UpdateItem:")
		fmt.Println(err.Error())
		return nil, err
	}

	return result, nil
}

// Delete item in dynamodb table
func (t *Table) DeleteItem(key interface{}) error {  // 에러가 없으면 잘 삭제된 것이다.

	k, err := dynamodbattribute.MarshalMap(key)
	if err != nil {
		fmt.Println("Got error marshalling key item:")
		fmt.Println(err.Error())
		return err
	}

	input := &dynamodb.DeleteItemInput{
		Key:       k,
		TableName: aws.String(t.name),
	}

	_, err = t.db.DeleteItem(input)
	if err != nil {
		fmt.Println("Got error DeleteItem:")
		fmt.Println(err.Error())
		return err
	}

	return nil
}

// note.go
...
func updateNote(user string, id string, m note) (*note, error) {

	update := expression.UpdateBuilder{}
	update = update.Set(expression.Name("updatedAt"), expression.Value(time.Now()))
	if m.Title != "" {
		update = update.Set(expression.Name("title"), expression.Value(m.Title))
	}
	if m.Content != "" {
		update = update.Set(expression.Name("content"), expression.Value(m.Content))
	}

	expr, err := expression.NewBuilder().WithUpdate(update).Build()

	if err != nil {
		fmt.Println("Got error building expression:")
		fmt.Println(err.Error())
		return nil, err
	}

	result, err := noteTable.UpdateItem(NoteKey{Id: id, User: user}, expr)

	if err != nil {
		return nil, err
	}

	updatedNote := note{}
	dynamodbattribute.UnmarshalMap(result.Attributes, &updatedNote)

	return &updatedNote, nil
}

func deleteNote(user string, id string) error {
	if err := noteTable.DeleteItem(NoteKey{Id: id, User: user}); err != nil {
		return err
	}
	return nil
}

// server.go
...
func createServer() *echo.Echo {
  ...
	e.PUT("/note/:user/:id", func(c echo.Context) error {
		user := c.Param("user")
		id := c.Param("id")
		body := &note{}
		if err := c.Bind(body); err != nil {
			return err
		}

		note, err := updateNote(user, id, *body)
		if err != nil {
			c.Error(err)
		}

		return c.JSON(http.StatusCreated, note)
	})

	e.DELETE("/note/:user/:id", func(c echo.Context) error {
		user := c.Param("user")
		id := c.Param("id")
		if err := deleteNote(user, id); err != nil {
			c.Error(err)
		}
		return c.NoContent(http.StatusAccepted)
	})

	return e
}

# 노트를 수정한다.
$ curl -X PUT -H "Content-Type: application/json" -d \
  '{ "title": "this is", "content": "updated" }' \
  http://localhost:3201/note/user1/1590012463321602

# 노트를 삭제한다.
$ curl -X DELETE https://api.overthecode.io/note/user1/1590012463321602

fetch('https://api.overthecode.io/note/user1')
  .then(response => response.json())
  .then(data => console.log(data));