Estructura de carpetas para API Rest en Go

Tiempo de lectura: 3 minutos

Go es un lenguaje de programación eficiente y rápido para construir APIs y microservicios.

Aquí te propongo una estructura de carpetas en Go para tu proyecto.

Estructura para Go

project/
├── config/        # Configuración 
├── controllers/   # Controladores 
├── models/        # Modelos de datos 
├── routes/        # Rutas de la API 
├── schemas/       # Esquemas o validaciones de datos 
├── utils/         # Utilidades y funciones auxiliares 
└── main.go        # Punto de entrada de la aplicación

Desglose y Función de Cada Carpeta

1. config/: Aquí puedes definir las configuraciones de la aplicación, como variables de entorno, configuraciones de la base de datos, etc. Puedes crear un archivo como config.go que maneje estas configuraciones, cargándolas de un archivo .env o de variables de entorno.
2. controllers/: Este directorio sería el equivalente a crud/, ya que en Go es común separar la lógica de negocio en «controladores» o «servicios». Aquí defines las funciones CRUD que interactúan con la base de datos o con otros servicios, que luego son utilizadas en las rutas.
3. models/: Aquí defines los modelos de datos, que en Go suelen representarse con structs. Puedes usar estos modelos junto con GORM o con otra ORM para interactuar con la base de datos.
4. routes/: En Go, puedes definir las rutas de la API en esta carpeta. Crea un archivo routes.go donde registras los endpoints y asocias cada ruta a sus controladores correspondientes. Puedes usar un enrutador como mux para facilitar el enrutamiento de las rutas.
5. schemas/: En Go, los esquemas de validación suelen ser más limitados que en Python debido a la naturaleza del lenguaje. Sin embargo, puedes usar esta carpeta para definir «data transfer objects» (DTOs) o cualquier otra estructura de datos de entrada/salida que desees validar. Las bibliotecas como go-playground/validator pueden ayudarte a realizar validaciones.
6. utils/: Aquí puedes almacenar utilidades o funciones auxiliares, como generadores de JWT, funciones de hashing, o cualquier lógica que no encaje en los controladores ni en los modelos.
7. main.go: Este archivo es el punto de entrada de la aplicación, donde se inicializa la configuración, se registran las rutas y se inicia el servidor.

Ejemplo Básico de Código

main.go

package main

import (
    "log"
    "net/http"
    "project/config"
    "project/routes"
)

func main() {
    // Cargar configuración
    config.LoadConfig()

    // Configurar rutas
    r := routes.SetupRouter()

    // Iniciar servidor
    port := ":8080"
    log.Println("Servidor escuchando en el puerto", port)
    log.Fatal(http.ListenAndServe(port, r))
}

config/config.go

package config

import (
    "log"
    "os"
)

var DB_URL string

func LoadConfig() {
    // Ejemplo de cargar una variable de entorno
    DB_URL = os.Getenv("DB_URL")
    if DB_URL == "" {
        log.Fatal("DB_URL no definido")
    }
}

models/item.go

package models

type Item struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Price float64 `json:"price"`
}

controllers/item_controller.go

package controllers

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

var items = []models.Item{
    {ID: 1, Name: "Item 1", Price: 10.5},
    {ID: 2, Name: "Item 2", Price: 20.0},
}

func GetItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

routes/routes.go

package routes

import (
    "net/http"
    "github.com/gorilla/mux"
    "project/controllers"
)

func SetupRouter() *mux.Router {
    r := mux.NewRouter()

    // Definir rutas
    r.HandleFunc("/items", controllers.GetItems).Methods("GET")

    return r
}

Inicializar el proyecto en Go

Para comenzar el proyecto, puedes iniciar un nuevo módulo de Go en la carpeta project con el siguiente comando:

go mod init project

Luego, puedes instalar dependencias (como el enrutador mux) usando:

go get -u github.com/gorilla/mux

Ejecución

Para ejecutar la aplicación, usa:

go run main.go

Esta estructura te permitirá organizar mejor tu código y crear una API en Go con una estructura modular, similar a lo que estás acostumbrado en FastAPI.