Ejercicio: API en GoLang con DocumentDB Multi-región ​

// internal/database/models/user.go
package models

import (
    "time"
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID        primitive.ObjectID `bson:"_id,omitempty" json:"id"`
    Name      string            `bson:"name" json:"name"`
    Email     string            `bson:"email" json:"email"`
    CreatedAt time.Time         `bson:"created_at" json:"created_at"`
    UpdatedAt time.Time         `bson:"updated_at" json:"updated_at"`
    Region    string            `bson:"region" json:"region"`
    Version   int              `bson:"version" json:"version"`
}

type UserRepository interface {
    Create(*User) error
    Update(*User) error
    Delete(primitive.ObjectID) error
    FindByID(primitive.ObjectID) (*User, error)
    FindAll() ([]*User, error)
}

// pkg/utils/mongodb/connection.go
package mongodb

import (
    "context"
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

type Config struct {
    Username   string
    Password   string
    Host       string
    Port       string
    Database   string
    CAFile     string
    ReplicaSet string
}

func NewConnection(cfg *Config) (*mongo.Client, error) {
    // Leer certificado CA
    ca, err := ioutil.ReadFile(cfg.CAFile)
    if err != nil {
        return nil, fmt.Errorf("error reading CA file: %v", err)
    }

    // Configurar TLS
    tlsConfig := &tls.Config{
        RootCAs: x509.NewCertPool(),
    }
    if !tlsConfig.RootCAs.AppendCertsFromPEM(ca) {
        return nil, fmt.Errorf("failed to append CA certificates")
    }

    // Construir URI
    uri := fmt.Sprintf(
        "mongodb://%s:%s@%s:%s/%s?tls=true&replicaSet=%s&retryWrites=false",
        cfg.Username,
        cfg.Password,
        cfg.Host,
        cfg.Port,
        cfg.Database,
        cfg.ReplicaSet,
    )

    // Opciones de cliente
    clientOptions := options.Client().
        ApplyURI(uri).
        SetTLSConfig(tlsConfig).
        SetConnectTimeout(10 * time.Second).
        SetServerSelectionTimeout(5 * time.Second).
        SetMaxPoolSize(100)

    // Conectar
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        return nil, fmt.Errorf("error connecting to database: %v", err)
    }

    // Verificar conexión
    err = client.Ping(ctx, nil)
    if err != nil {
        return nil, fmt.Errorf("error pinging database: %v", err)
    }

    return client, nil
}

// internal/handlers/health.go
package handlers

import (
    "encoding/json"
    "net/http"
    "time"
    
    "github.com/your-org/your-app/internal/database"
)

type HealthStatus struct {
    Status      string            `json:"status"`
    Database    DatabaseStatus    `json:"database"`
    LastChecked time.Time        `json:"last_checked"`
    Region      string           `json:"region"`
}

type DatabaseStatus struct {
    Connected bool    `json:"connected"`
    Latency   int64  `json:"latency_ms"`
}

func HealthCheckHandler(db *database.DocumentDB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        status := HealthStatus{
            Status:      "healthy",
            LastChecked: time.Now(),
            Region:     os.Getenv("AWS_REGION"),
        }

        // Verificar conexión a DB
        start := time.Now()
        err := db.Ping()
        latency := time.Since(start).Milliseconds()

        status.Database = DatabaseStatus{
            Connected: err == nil,
            Latency:   latency,
        }

        if err != nil {
            status.Status = "unhealthy"
            w.WriteHeader(http.StatusServiceUnavailable)
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(status)
    }
}

// internal/config/config.go
package config

import (
    "context"
    "fmt"
    "github.com/aws/aws-sdk-go-v2/service/ssm"
)

type Config struct {
    Environment    string
    DocDB         DocDBConfig
    App           AppConfig
    AWS           AWSConfig
}

type DocDBConfig struct {
    Username    string
    Password    string
    Host        string
    Port        string
    Database    string
    ReplicaSet  string
}

type AppConfig struct {
    Port        string
    LogLevel    string
    Region      string
}

type AWSConfig struct {
    Region      string
    Profile     string
}

func LoadConfig(ctx context.Context, environment string) (*Config, error) {
    ssmClient := ssm.New(ssm.Options{
        Region: os.Getenv("AWS_REGION"),
    })

    // Cargar parámetros por path
    params, err := getParametersByPath(ctx, ssmClient, fmt.Sprintf("/%s/", environment))
    if err != nil {
        return nil, err
    }

    config := &Config{
        Environment: environment,
        DocDB: DocDBConfig{
            Username:    params["/docdb/username"],
            Password:    params["/docdb/password"],
            Host:        params["/docdb/host"],
            Port:        params["/docdb/port"],
            Database:    params["/docdb/database"],
            ReplicaSet:  params["/docdb/replica_set"],
        },
        App: AppConfig{
            Port:     params["/app/port"],
            LogLevel: params["/app/log_level"],
            Region:   params["/app/region"],
        },
        AWS: AWSConfig{
            Region:  params["/aws/region"],
            Profile: params["/aws/profile"],
        },
    }

    return config, nil
}

func getParametersByPath(ctx context.Context, client *ssm.Client, path string) (map[string]string, error) {
    params := make(map[string]string)
    
    input := &ssm.GetParametersByPathInput{
        Path:           &path,
        Recursive:      aws.Bool(true),
        WithDecryption: aws.Bool(true),
    }

    paginator := ssm.NewGetParametersByPathPaginator(client, input)
    for paginator.HasMorePages() {
        output, err := paginator.NextPage(ctx)
        if err != nil {
            return nil, fmt.Errorf("error getting parameters: %v", err)
        }

        for _, param := range output.Parameters {
            // Remover el prefijo del path para tener nombres más limpios
            name := strings.TrimPrefix(*param.Name, path)
            params[name] = *param.Value
        }
    }

    return params, nil
}

// cmd/api/main.go
package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/your-org/your-app/internal/config"
    "github.com/your-org/your-app/internal/database"
    "github.com/your-org/your-app/internal/handlers"
    "github.com/your-org/your-app/internal/middleware"
    "github.com/gorilla/mux"
    "go.uber.org/zap"
)

func main() {
    // Inicializar logger
    logger, _ := zap.NewProduction()
    defer logger.Sync()

    // Cargar configuración
    cfg, err := config.LoadConfig(context.Background(), os.Getenv("ENVIRONMENT"))
    if err != nil {
        logger.Fatal("Failed to load configuration", zap.Error(err))
    }

    // Inicializar base de datos
    db, err := database.NewDocumentDB(cfg.DocDB)
    if err != nil {
        logger.Fatal("Failed to connect to database", zap.Error(err))
    }
    defer db.Close()

    // Configurar router
    router := mux.NewRouter()
    
    // Middleware
    router.Use(middleware.RequestID)
    router.Use(middleware.Logging(logger))
    router.Use(middleware.Metrics())
    router.Use(middleware.Recovery(logger))

    // Rutas
    api := router.PathPrefix("/api/v1").Subrouter()
    api.Handle("/health", handlers.HealthCheckHandler(db)).Methods("GET")
    api.Handle("/users", handlers.CreateUserHandler(db)).Methods("POST")
    api.Handle("/users/{id}", handlers.GetUserHandler(db)).Methods("GET")
    api.Handle("/users/{id}", handlers.UpdateUserHandler(db)).Methods("PUT")
    api.Handle("/users/{id}", handlers.DeleteUserHandler(db)).Methods("DELETE")

    // Servidor HTTP
    srv := &http.Server{
        Addr:         ":" + cfg.App.Port,
        Handler:      router,
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    // Iniciar servidor en goroutine
    go func() {
        logger.Info("Starting server", zap.String("port", cfg.App.Port))
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            logger.Fatal("Server failed", zap.Error(err))
        }
    }()

    // Graceful shutdown
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    logger.Info("Shutting down server...")
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        logger.Fatal("Server forced to shutdown", zap.Error(err))
    }

    logger.Info("Server exiting")
}

// internal/handlers/users.go
package handlers

import (
    "encoding/json"
    "net/http"
    "github.com/gorilla/mux"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "github.com/your-org/your-app/internal/database"
    "github.com/your-org/your-app/internal/models"
)

type UserHandler struct {
    db *database.DocumentDB
}

type CreateUserRequest struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

func CreateUserHandler(db *database.DocumentDB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        var req CreateUserRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            http.Error(w, "Invalid request body", http.StatusBadRequest)
            return
        }

        user := &models.User{
            Name:      req.Name,
            Email:     req.Email,
            CreatedAt: time.Now(),
            UpdatedAt: time.Now(),
            Region:    os.Getenv("AWS_REGION"),
            Version:   1,
        }

        if err := db.CreateUser(r.Context(), user); err != nil {
            http.Error(w, "Failed to create user", http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(user)
    }
}

func GetUserHandler(db *database.DocumentDB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        id, err := primitive.ObjectIDFromHex(vars["id"])
        if err != nil {
            http.Error(w, "Invalid ID", http.StatusBadRequest)
            return
        }

        user, err := db.GetUserByID(r.Context(), id)
        if err != nil {
            if err == database.ErrNotFound {
                http.Error(w, "User not found", http.StatusNotFound)
                return
            }
            http.Error(w, "Internal server error", http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(user)
    }
}

// internal/database/documentdb.go
package database

import (
    "context"
    "errors"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "github.com/your-org/your-app/internal/models"
)

var ErrNotFound = errors.New("document not found")

type DocumentDB struct {
    client *mongo.Client
    db     *mongo.Database
}

func (d *DocumentDB) CreateUser(ctx context.Context, user *models.User) error {
    collection := d.db.Collection("users")

    result, err := collection.InsertOne(ctx, user)
    if err != nil {
        return err
    }

    user.ID = result.InsertedID.(primitive.ObjectID)
    return nil
}

func (d *DocumentDB) GetUserByID(ctx context.Context, id primitive.ObjectID) (*models.User, error) {
    collection := d.db.Collection("users")

    var user models.User
    err := collection.FindOne(ctx, bson.M{"_id": id}).Decode(&user)
    if err != nil {
        if err == mongo.ErrNoDocuments {
            return nil, ErrNotFound
        }
        return nil, err
    }

    return &user, nil
}

func (d *DocumentDB) UpdateUser(ctx context.Context, user *models.User) error {
    collection := d.db.Collection("users")

    update := bson.M{
        "$set": bson.M{
            "name":       user.Name,
            "email":      user.Email,
            "updated_at": time.Now(),
            "version":    user.Version + 1,
        },
    }

    // Actualizar solo si la versión coincide
    filter := bson.M{
        "_id":     user.ID,
        "version": user.Version,
    }

    result, err := collection.UpdateOne(ctx, filter, update)
    if err != nil {
        return err
    }

    if result.MatchedCount == 0 {
        return ErrNotFound
    }

    user.Version++
    user.UpdatedAt = time.Now()
    return nil
}

// internal/middleware/logging.go
package middleware

import (
    "net/http"
    "time"
    "go.uber.org/zap"
)

func Logging(logger *zap.Logger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            
            // Wrap ResponseWriter para capturar el status code
            wrapped := wrapResponseWriter(w)
            
            // Procesar request
            next.ServeHTTP(wrapped, r)
            
            // Log request
            logger.Info("Request processed",
                zap.String("method", r.Method),
                zap.String("path", r.URL.Path),
                zap.Int("status", wrapped.status),
                zap.Duration("duration", time.Since(start)),
                zap.String("request_id", r.Context().Value("request_id").(string)),
            )
        })
    }
}

// internal/middleware/metrics.go
func Metrics() func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            wrapped := wrapResponseWriter(w)
            next.ServeHTTP(wrapped, r)
            
            // Publicar métricas
            duration := time.Since(start).Milliseconds()
            metrics.PublishRequestMetrics(r.Method, r.URL.Path, wrapped.status, duration)
        })
    }
}

// pkg/utils/response.go
package utils

import (
    "encoding/json"
    "net/http"
)

type ErrorResponse struct {
    Error   string `json:"error"`
    Code    string `json:"code,omitempty"`
    Details string `json:"details,omitempty"`
}

func JSONError(w http.ResponseWriter, message string, code int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    json.NewEncoder(w).Encode(ErrorResponse{
        Error: message,
    })
}

func JSONResponse(w http.ResponseWriter, data interface{}, code int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    json.NewEncoder(w).Encode(data)
}

// internal/handlers/users_test.go
package handlers

import (
    "bytes"
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/your-org/your-app/internal/database"
    "github.com/your-org/your-app/internal/models"
)

func TestCreateUser(t *testing.T) {
    // Mock database
    db := &database.MockDocumentDB{}
    
    // Test cases
    tests := []struct {
        name       string
        payload    CreateUserRequest
        wantStatus int
    }{
        {
            name: "Valid user",
            payload: CreateUserRequest{
                Name:  "John Doe",
                Email: "john@example.com",
            },
            wantStatus: http.StatusCreated,
        },
        {
            name: "Invalid email",
            payload: CreateUserRequest{
                Name:  "John Doe",
                Email: "invalid-email",
            },
            wantStatus: http.StatusBadRequest,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // Create request
            body, _ := json.Marshal(tt.payload)
            req := httptest.NewRequest(http.MethodPost, "/users", bytes.NewBuffer(body))
            rec := httptest.NewRecorder()

            // Handle request
            handler := CreateUserHandler(db)
            handler.ServeHTTP(rec, req)

            // Assert response
            assert.Equal(t, tt.wantStatus, rec.Code)
        })
    }
}

// tests/integration/api_test.go
package integration

import (
    "context"
    "testing"
    "time"

    "github.com/stretchr/testify/suite"
    "github.com/your-org/your-app/internal/config"
    "github.com/your-org/your-app/internal/database"
)

type APITestSuite struct {
    suite.Suite
    db  *database.DocumentDB
    cfg *config.Config
}

func (s *APITestSuite) SetupSuite() {
    // Cargar configuración de test
    cfg, err := config.LoadConfig(context.Background(), "test")
    s.Require().NoError(err)
    s.cfg = cfg

    // Conectar a base de datos
    db, err := database.NewDocumentDB(cfg.DocDB)
    s.Require().NoError(err)
    s.db = db
}

func (s *APITestSuite) TearDownSuite() {
    s.db.Close()
}

func (s *APITestSuite) TestUserLifecycle() {
    // Create user
    user := &models.User{
        Name:  "Test User",
        Email: "test@example.com",
    }

    err := s.db.CreateUser(context.Background(), user)
    s.Require().NoError(err)
    s.NotEmpty(user.ID)

    // Get user
    found, err := s.db.GetUserByID(context.Background(), user.ID)
    s.Require().NoError(err)
    s.Equal(user.Name, found.Name)

    // Update user
    user.Name = "Updated Name"
    err = s.db.UpdateUser(context.Background(), user)
    s.Require().NoError(err)

    // Verify update
    found, err = s.db.GetUserByID(context.Background(), user.ID)
    s.Require().NoError(err)
    s.Equal("Updated Name", found.Name)
}

func TestAPI(t *testing.T) {
    suite.Run(t, new(APITestSuite))
}

// internal/monitoring/metrics.go
package monitoring

import (
    "context"
    "time"
    
    "github.com/aws/aws-sdk-go-v2/service/cloudwatch"
    "github.com/aws/aws-sdk-go-v2/aws"
)

type Metrics struct {
    client      *cloudwatch.Client
    environment string
    region      string
}

func NewMetrics(client *cloudwatch.Client, environment, region string) *Metrics {
    return &Metrics{
        client:      client,
        environment: environment,
        region:      region,
    }
}

func (m *Metrics) PutMetric(name string, value float64, unit string, dimensions map[string]string) error {
    metricDimensions := []cloudwatch.Dimension{
        {
            Name:  aws.String("Environment"),
            Value: aws.String(m.environment),
        },
        {
            Name:  aws.String("Region"),
            Value: aws.String(m.region),
        },
    }

    for k, v := range dimensions {
        metricDimensions = append(metricDimensions, cloudwatch.Dimension{
            Name:  aws.String(k),
            Value: aws.String(v),
        })
    }

    _, err := m.client.PutMetricData(context.Background(), &cloudwatch.PutMetricDataInput{
        Namespace: aws.String("Application/GoAPI"),
        MetricData: []cloudwatch.MetricDatum{
            {
                MetricName: aws.String(name),
                Value:      aws.Float64(value),
                Unit:      aws.String(unit),
                Dimensions: metricDimensions,
                Timestamp: aws.Time(time.Now()),
            },
        },
    })

    return err
}

func (m *Metrics) TrackAPILatency(endpoint string, duration time.Duration) {
    m.PutMetric("APILatency", float64(duration.Milliseconds()), "Milliseconds", map[string]string{
        "Endpoint": endpoint,
    })
}

func (m *Metrics) TrackDatabaseOperations(operation string, success bool) {
    value := 0.0
    if success {
        value = 1.0
    }
    
    m.PutMetric("DatabaseOperations", value, "Count", map[string]string{
        "Operation": operation,
        "Status":    map[bool]string{true: "Success", false: "Failure"}[success],
    })
}

// internal/logging/logger.go
package logging

import (
    "github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

type Logger struct {
    *zap.Logger
    cwClient *cloudwatchlogs.Client
    logGroup string
    stream   string
}

func NewLogger(environment string) (*Logger, error) {
    // Configuración base de zap
    config := zap.NewProductionConfig()
    config.EncoderConfig.TimeKey = "timestamp"
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    
    baseLogger, err := config.Build()
    if err != nil {
        return nil, err
    }

    // Cliente CloudWatch Logs
    cwClient := cloudwatchlogs.NewFromConfig(cfg)

    return &Logger{
        Logger:   baseLogger,
        cwClient: cwClient,
        logGroup: "/application/" + environment,
        stream:   "api-" + time.Now().Format("2006-01-02"),
    }, nil
}

func (l *Logger) LogToCloudWatch(level zapcore.Level, msg string, fields ...zap.Field) {
    // Log localmente
    l.Log(level, msg, fields...)

    // Preparar entrada para CloudWatch
    logEvent := &cloudwatchlogs.PutLogEventsInput{
        LogGroupName:  &l.logGroup,
        LogStreamName: &l.stream,
        LogEvents: []cloudwatchlogs.InputLogEvent{
            {
                Message:   aws.String(formatLogMessage(msg, fields)),
                Timestamp: aws.Int64(time.Now().UnixNano() / 1000000),
            },
        },
    }

    // Enviar a CloudWatch de manera asíncrona
    go func() {
        if _, err := l.cwClient.PutLogEvents(context.Background(), logEvent); err != nil {
            l.Error("Failed to send logs to CloudWatch", zap.Error(err))
        }
    }()
}

func formatLogMessage(msg string, fields []zap.Field) string {
    // Implementar formato de log personalizado
    return fmt.Sprintf("%s %v", msg, fields)
}