Go言語（Golang）でAWS DynamoDB（NoSQL）の使い方｜Docker環境構築＋CRUD APIサンプル

$ mkdir go-dynamodb && cd go-dynamodb
$ touch compose.yml

services:
  dynamodb:
    image: amazon/dynamodb-local:latest
    container_name: dynamodb-local
    command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
    user: root # volumeがroot所有のため書き込み対応
    ports:
      - "8000:8000"
    volumes:
      - dynamodb_data:/home/dynamodblocal/data
volumes:
  dynamodb_data:

$ docker compose up -d

$ docker compose ps

"entity_type": "MESSAGE",
"room_id": "xxxx-xxxx-0001",
"message_id": "yyyy-yyyy-0001",
"sender_id": "xxxx-yyyy-zzzz-0001",
"type": "text",
"text": "こんにちは！",
"created_at": "2026-03-25T10:00:00.123Z",
"updated_at": "2026-03-25T10:00:00.123Z",
"GSI1PK": "USER#xxxx-yyyy-zzzz-0001",
"GSI1SK": "MESSAGE#2026-03-25T10:00:00.123Z"

$ brew install awscli

$ aws --version

$ aws dynamodb create-table \
    --table-name ChatTable \
    --attribute-definitions \
      AttributeName=PK,AttributeType=S \
      AttributeName=SK,AttributeType=S \
      AttributeName=GSI1PK,AttributeType=S \
      AttributeName=GSI1SK,AttributeType=S \
    --key-schema \
      AttributeName=PK,KeyType=HASH \
      AttributeName=SK,KeyType=RANGE \
    --global-secondary-indexes '[
      {
        "IndexName": "GSI1",
        "KeySchema": [
          {"AttributeName": "GSI1PK", "KeyType": "HASH"},
          {"AttributeName": "GSI1SK", "KeyType": "RANGE"}
        ],
        "Projection": {
          "ProjectionType": "ALL"
        }
      }
    ]' \
    --billing-mode PAY_PER_REQUEST \
    --endpoint-url http://localhost:8000 \
    --region ap-northeast-1

$ docker compose down

$ mkdir -p docker/local/go && touch docker/local/go/Dockerfile
$ mkdir src && touch src/main.go
$ touch .env

FROM golang:1.26.1-alpine3.23

WORKDIR /go/src

COPY ./src .

# go.modがあれば依存関係をインストール
RUN if [ -f ./go.mod ]; then \
      go install; \
    fi

# 開発用のライブラリをインストール
RUN go install github.com/air-verse/air@v1.64.5
RUN go install honnef.co/go/tools/cmd/staticcheck@latest

EXPOSE 8080

package main

import (
    "log/slog"
    "net/http"

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

func main() {
    // echoのルーター設定
    e := echo.New()

    e.GET("/", func(c echo.Context) error {
        // レスポンス結果の設定
        res := map[string]string{
            "message": "Hello World !!",
        }

        return c.JSON(http.StatusOK, res)
    })

    // ログ出力
    slog.Info("start go-dynamodb")

    // サーバー起動
    e.Logger.Fatal(e.Start(":8080"))
}

ENV=local
AWS_REGION=ap-northeast-1

services:
  api:
    container_name: go-dynamodb-api
    build:
      context: .
      dockerfile: ./docker/local/go/Dockerfile
    command: air -c .air.toml
    volumes:
      - ./src:/go/src
    ports:
      - "8080:8080"
    env_file:
      - .env
    environment:
      - DYNAMODB_ENDPOINT=http://dynamodb:8000
      - AWS_ACCESS_KEY_ID=dummy
      - AWS_SECRET_ACCESS_KEY=dummy
    tty: true
    stdin_open: true
    depends_on:
      - dynamodb
  dynamodb:
    image: amazon/dynamodb-local:latest
    container_name: dynamodb-local
    command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
    user: root # volumeがroot所有のため書き込み対応
    ports:
      - "8000:8000"
    volumes:
      - dynamodb_data:/home/dynamodblocal/data
volumes:
  dynamodb_data:

$ docker compose build --no-cache

$ docker compose run --rm api go mod init go-dynamodb
$ docker compose run --rm api go mod tidy
$ docker compose run --rm api air init

$ docker compose build --no-cache
$ docker compose up -d

$ docker compose ps

$ mkdir -p src/internal/infrastructure/database && touch src/internal/infrastructure/database/dynamodb.go
$ mkdir -p src/internal/infrastructure/persistence/dynamodb/chat && touch src/internal/infrastructure/persistence/dynamodb/chat/chat_model.go

package database

import (
    "context"
    "os"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
)

func NewDynamoDB(ctx context.Context) (*dynamodb.Client, error) {
    region := os.Getenv("AWS_REGION")
    endpoint := os.Getenv("DYNAMODB_ENDPOINT")

    cfg, err := config.LoadDefaultConfig(
        ctx,
        config.WithRegion(region),
    )
    if err != nil {
        return nil, err
    }

    var client *dynamodb.Client

    if endpoint != "" {
        // ローカル開発環境の場合
        client = dynamodb.NewFromConfig(cfg, func(o *dynamodb.Options) {
            o.BaseEndpoint = aws.String(endpoint)
        })
    } else {
        // 本番環境の場合
        client = dynamodb.NewFromConfig(cfg)
    }

    return client, nil
}

package chat

type ChatTable struct {
    PK         string `dynamodbav:"PK"`
    SK         string `dynamodbav:"SK"`
    EntityType string `dynamodbav:"entity_type"`
    RoomID     string `dynamodbav:"room_id"`
    MessageID  string `dynamodbav:"message_id"`
    SenderID   string `dynamodbav:"sender_id"`
    Type       string `dynamodbav:"type"`
    Text       string `dynamodbav:"text"`
    CreatedAt  string `dynamodbav:"created_at"`
    UpdatedAt  string `dynamodbav:"updated_at"`
    GSI1PK     string `dynamodbav:"GSI1PK"`
    GSI1SK     string `dynamodbav:"GSI1SK"`
}

package main

import (
    "errors"
    "fmt"
    "log/slog"
    "net/http"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
    "github.com/google/uuid"
    "github.com/labstack/echo/v4"

    "go-dynamodb/internal/infrastructure/database"
    "go-dynamodb/internal/infrastructure/persistence/dynamodb/chat"
)

// チャット情報作成用リクエストボディの構造体
type CreateChatRequestBody struct {
    RoomID string `json:"room_id"`
    EntityType string `json:"entity_type"`
    SenderID string `json:"sender_id"`
    Type string `json:"type"`
    Text string `json:"text"`
}

// チャット情報のメッセージ更新用リクエストボディの構造体
type UpdateChatRequestBody struct {
    SenderID string `json:"sender_id"`
    Text string `json:"text"`
}

func main() {
    // echoのルーター設定
    e := echo.New()

    e.GET("/", func(c echo.Context) error {
        // レスポンス結果の設定
        res := map[string]string{
            "message": "Hello World !!",
        }

        return c.JSON(http.StatusOK, res)
    })

    // サンプルAPI（CRUD処理）を追加
    apiV1 := e.Group("/api/v1")

    // チャット情報作成
    apiV1.POST("/chat", func(c echo.Context) error {
        // リクエストボディの取得
        var reqBody CreateChatRequestBody
        if err := c.Bind(&reqBody); err != nil {
            return err
        }

        ctx := c.Request().Context()

        // DynamoDBの初期化
        dynamoDB, err := database.NewDynamoDB(ctx)
        if err != nil {
            errMsg := fmt.Sprintf("failed to initialize DynamoDB: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // UUIDでメッセージIDを設定
        messageID := uuid.New().String()

        // 現在日時の設定（ナノ秒まで対応）
        now := time.Now().UTC().Format(time.RFC3339Nano)

        // PK、SK、GSI1PK、GSI1SKの設定
        pk := "ROOM#" + reqBody.RoomID
        sk := "MESSAGE#" + now + "#" + messageID
        gsi1pk := "USER#" + reqBody.SenderID
        gsi1sk := "MESSAGE#" + now

        // チャット作成
        chat := chat.ChatTable{
            PK: pk,
            SK: sk,
            EntityType: reqBody.EntityType,
            RoomID: reqBody.RoomID,
            MessageID: messageID,
            SenderID: reqBody.SenderID,
            Type: reqBody.Type,
            Text: reqBody.Text,
            CreatedAt: now,
            UpdatedAt: now,
            GSI1PK: gsi1pk,
            GSI1SK: gsi1sk,
        }

        // DynamoDB形式に変換
        item, err := attributevalue.MarshalMap(chat)
        if err != nil {
            return c.JSON(http.StatusInternalServerError, err.Error())
        }

        // データ保存
        _, err = dynamoDB.PutItem(ctx, &dynamodb.PutItemInput{
            TableName: aws.String("ChatTable"),
            Item: item,
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to put item into DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

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

    // 全てのチャット情報を取得
    apiV1.GET("/chat", func(c echo.Context) error {
        ctx := c.Request().Context()

        // DynamoDBの初期化
        dynamoDB, err := database.NewDynamoDB(ctx)
        if err != nil {
            errMsg := fmt.Sprintf("failed to initialize DynamoDB: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // 対象データ取得
        out, err := dynamoDB.Scan(ctx, &dynamodb.ScanInput{
            TableName: aws.String("ChatTable"),
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to scan DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // マッピング
        var chats []chat.ChatTable
        if err := attributevalue.UnmarshalListOfMaps(out.Items, &chats); err != nil {
            errMsg := fmt.Sprintf("failed to unmarshal DynamoDB items: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        return c.JSON(http.StatusOK, chats)
    })

    // 対象ルームかつ特定のエンティティタイプの情報を全て取得
    apiV1.GET("/chat/:room_id/:entity_type", func(c echo.Context) error {
        // リクエストパラメータの取得
        roomID := c.Param("room_id")
        if roomID == "" {
            return echo.NewHTTPError(http.StatusBadRequest, "room_id is required")
        }
        entityType := c.Param("entity_type")
        if entityType == "" {
            return echo.NewHTTPError(http.StatusBadRequest, "entity_type is required")
        }

        // PKとSKの設定
        pk := "ROOM#" + roomID
        sk := entityType + "#"

        ctx := c.Request().Context()

        // DynamoDBの初期化
        dynamoDB, err := database.NewDynamoDB(ctx)
        if err != nil {
            errMsg := fmt.Sprintf("failed to initialize DynamoDB: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // 対象データ取得
        out, err := dynamoDB.Query(ctx, &dynamodb.QueryInput{
            TableName: aws.String("ChatTable"),
            KeyConditionExpression: aws.String("PK = :pk AND begins_with(SK, :sk)"),
            ExpressionAttributeValues: map[string]types.AttributeValue{
                ":pk": &types.AttributeValueMemberS{Value: pk},
                ":sk": &types.AttributeValueMemberS{Value: sk},
            },
            ScanIndexForward: aws.Bool(false), // 降順でソート
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to query DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // マッピング
        var chats []chat.ChatTable
        if err := attributevalue.UnmarshalListOfMaps(out.Items, &chats); err != nil {
            errMsg := fmt.Sprintf("failed to unmarshal DynamoDB items: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        return c.JSON(http.StatusOK, chats)
    })

    // チャット情報のメッセージを更新
    apiV1.PUT("/chat/:message_id", func(c echo.Context) error {
        // リクエストパラメータの取得
        messageID := c.Param("message_id")
        if messageID == "" {
            return echo.NewHTTPError(http.StatusBadRequest, "messageID is required")
        }

        // リクエストボディの取得
        var reqBody UpdateChatRequestBody
        if err := c.Bind(&reqBody); err != nil {
            return err
        }

        ctx := c.Request().Context()

        // DynamoDBの初期化
        dynamoDB, err := database.NewDynamoDB(ctx)
        if err != nil {
            errMsg := fmt.Sprintf("failed to initialize DynamoDB: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // GSI2を利用してmessage_idに紐づくデータを取得
        queryResult, err := dynamoDB.Query(ctx, &dynamodb.QueryInput{
            TableName: aws.String("ChatTable"),
            IndexName: aws.String("GSI2"),
            KeyConditionExpression: aws.String("message_id = :message_id"),
            ExpressionAttributeValues: map[string]types.AttributeValue{
                ":message_id": &types.AttributeValueMemberS{Value: messageID},
            },
            Limit: aws.Int32(1),
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to query DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // 対象データが存在しない場合
        if len(queryResult.Items) == 0 {
            return echo.NewHTTPError(http.StatusNotFound, "対象データは存在しませんでした。")
        }

        // 対象データのPKとSKを取得
        item := queryResult.Items[0]
        pk := item["PK"].(*types.AttributeValueMemberS).Value
        sk := item["SK"].(*types.AttributeValueMemberS).Value

        // 更新処理
        updateResult, err := dynamoDB.UpdateItem(ctx, &dynamodb.UpdateItemInput{
            TableName: aws.String("ChatTable"),
            Key: map[string]types.AttributeValue{
                "PK": &types.AttributeValueMemberS{Value: pk},
                "SK": &types.AttributeValueMemberS{Value: sk},
            },
            UpdateExpression: aws.String("SET #t = :text, updated_at = :updated_at"),
            ExpressionAttributeNames: map[string]string{
                "#t": "text", // 予約語回避
            },
            ExpressionAttributeValues: map[string]types.AttributeValue{
                ":text": &types.AttributeValueMemberS{Value: reqBody.Text},
                ":updated_at": &types.AttributeValueMemberS{
                    Value: time.Now().UTC().Format(time.RFC3339Nano),
                },
                ":sender_id": &types.AttributeValueMemberS{Value: reqBody.SenderID},
            },
            ConditionExpression: aws.String("sender_id = :sender_id"), // 処理前の条件チェック
            ReturnValues: types.ReturnValueAllNew, // 更新結果を戻り値に返す
        })
        if err != nil {
            // ConditionExpressionチェックでエラーの場合
            var cce *types.ConditionalCheckFailedException
            if errors.As(err, &cce) {
                return echo.NewHTTPError(http.StatusForbidden, "forbidden")
            }

            errMsg := fmt.Sprintf("failed to update item in DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // マッピング
        var updatedChat chat.ChatTable
        if err := attributevalue.UnmarshalMap(updateResult.Attributes, &updatedChat); err != nil {
            errMsg := fmt.Sprintf("failed to unmarshal DynamoDB attributes: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        return c.JSON(http.StatusOK, updatedChat)
    })

    // チャット情報のメッセージを削除
    apiV1.DELETE("/chat/:message_id", func(c echo.Context) error {
        // リクエストパラメータの取得
        messageID := c.Param("message_id")
        if messageID == "" {
            return echo.NewHTTPError(http.StatusBadRequest, "messageID is required")
        }

        ctx := c.Request().Context()

        // DynamoDBの初期化
        dynamoDB, err := database.NewDynamoDB(ctx)
        if err != nil {
            errMsg := fmt.Sprintf("failed to initialize DynamoDB: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // GSI2を利用してmessage_idに紐づくデータを取得
        queryResult, err := dynamoDB.Query(ctx, &dynamodb.QueryInput{
            TableName: aws.String("ChatTable"),
            IndexName: aws.String("GSI2"),
            KeyConditionExpression: aws.String("message_id = :message_id"),
            ExpressionAttributeValues: map[string]types.AttributeValue{
                ":message_id": &types.AttributeValueMemberS{Value: messageID},
            },
            Limit: aws.Int32(1),
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to query DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        // 対象データが存在しない場合
        if len(queryResult.Items) == 0 {
            return echo.NewHTTPError(http.StatusNotFound, "対象データは存在しませんでした。")
        }

        // 対象データのPKとSKを取得
        item := queryResult.Items[0]
        pk := item["PK"].(*types.AttributeValueMemberS).Value
        sk := item["SK"].(*types.AttributeValueMemberS).Value

        // 削除処理
        _, err = dynamoDB.DeleteItem(ctx, &dynamodb.DeleteItemInput{
            TableName: aws.String("ChatTable"),
            Key: map[string]types.AttributeValue{
                "PK": &types.AttributeValueMemberS{Value: pk},
                "SK": &types.AttributeValueMemberS{Value: sk},
            },
        })
        if err != nil {
            errMsg := fmt.Sprintf("failed to delete item in DynamoDB table: %v", err)
            return echo.NewHTTPError(http.StatusInternalServerError, errMsg)
        }

        return c.NoContent(http.StatusNoContent)
    })

    // ログ出力
    slog.Info("start go-dynamodb")

    // サーバー起動
    e.Logger.Fatal(e.Start(":8080"))
}

$ docker compose exec api go mod tidy
$ docker compose down
$ docker compose build --no-cache
$ docker compose up -d