¿Porque escoger Go para crear una API? 🤔
Go es un lenguaje fantástico creado por Google, fuertemente tipado, fácil de leer y con multi-hilo y asincronismo por defecto.
En este post vamos a crear una API CRUD de lista de Videojuegos (Porque el típico TO DO es muy aburrido 😘) con Go Fiber y GORM con una base de datos PostgreSQL, el proyecto se llamara gamelist.
Requisitos Previos 🛑
Como punto de partido tendremos un proyecto de Go usando Go Modules, tener una instancia de GORM con PostgreSQL y un servidor básico con Fiber. Si no sabes como, en posts anteriores cubro estos temas, combínalos y sigue el tutorial.
La Estructura del Proyecto
Si has seguido los tutoriales previos, tendras dentro de tu proyecto un archivo main.go con un servidor de Fiber y una carpeta con el archivo /storage/connectDB.go con la conexión a la base de datos. Creamos 3 carpetas mas:
- handlers: Aquí crearemos las funciones HTTP.
- models: Nuestros modelos para la bases de datos.
- utils: Y aquí nuestras funciones y herramientas para nuestro proyecto.
¿Que son las variables de Entorno? Y porque tienes que usarlas 🤗
Las Variables de Entorno (O ENV por "Environment variables") son variables de valor dinámico que afectan el funcionamiento de la App. En proyectos de programación es información importante que afecta su funcionamiento y que debería estar oculto al publicarlo (Por ejemplo al subirlo al GitHub), en estos archivos deben estar cosas como los datos de conexión a la base datos.
Para continuar con el proyecto vamos a usar ENV.
Usar ENV en nuestro proyecto 🤫
Para usar ENV agregamos en la ruta base de nuestro proyecto un archivo .env, la sintaxis de los ENV es key=value. Vamos a tomar los datos de nuestra Base de datos, y ponerla en nuestro ENV:
DB_HOST=localhost
DB_USER=postgres
DB_PORT=5432
DB_PASSWORD=password
DB_NAME=db
Los nombres de las variables suelen estar en mayúsculas y separados por "_".
Para acceder a nuestras variables utilizares el paquete os y su función Getenv os.Getenv(key) esta función buscara la variable que le pasemos y si existe retornara el valor.
¡Alto! Importante Esto por si solo no nos servira a nosotros ¿Por que? Porque esto busca en las ENV por defecto de Go, solo con agregar el archivo .env el programa no sabra que existe y no cargara nuestras variables.
Para que nuestra aplicación carga las variables y podamos usarlas, usaremos el paquete GoDotEnv que cargara nuestro archivo .env permitiendo usarlas. lo agregamos con el comando go get:
go get github.com/joho/godotenv
Para usarlo agregamos en el archivo donde usemos las ENV, en los import el paquete GoDotEnv:
import (
//Autoload the env
_ "github.com/joho/godotenv/autoload"
)
```
Al importar el `autoload` como su nombre indica solo al importarlo cargara nuestro archivo `.env`. Otra forma de hacerlo, pero que puede darle problemas en el deploy, es:
````go
import (
"github.com/joho/godotenv"
"log"
"os"
)
func main() {
err := godotenv.Load()
if err != nil {
log.Fatal("Error loading .env file")
}
val:= os.Getenv("key")
}
```
{% endraw %}
### Implementar ENV y mejores practicas 🤓
Ahora con el paquete [GoDotEnv](https://github.com/joho/godotenv), **podemos usar ENV en todo el proyecto** pero hay ciertas cosas en tener en cuenta.
* Orden de uso: Esto es algo importante, como dije podemos usar GoDotEnv en todo el proyecto, pero el orden es importante, deberías usar este paquete cargar el {% raw %}`.env`{% endraw %} en una etapa temprana del programa, porque puede que intente cargar una variable importante y no lo encuentra.
* Rendimiento: Acceder al ENV es un poco lento, ten esto en cuenta y no abuses de esto.
Para evitar esto, me gusta crear en mis proyecto la utilidad {% raw %}`accessENV.go`{% endraw %} el cual se encargara de acceder a todas nuestras variables y las guardara en una cache para que cuando se necesite otra vez podrá accederse rápidamente.
Creamos el archivo {% raw %}`accessENV.go`{% endraw %} dentro de la carpeta {% raw %}`utils`{% endraw %}, importamos los paquetes {% raw %}`os`{% endraw %} {% raw %}`sync`{% endraw %} y {% raw %}`GoDotEnv`{% endraw %} crearemos una función con el mismo nombre {% raw %}`accessENV`{% endraw %} y fuera de la función crearemos nuestra "cache" que sera un {% raw %}`map`{% endraw %} de Go con un {% raw %}`RWMutex`{% endraw %} del paquete {% raw %}`sync`{% endraw %}, este sera el resultado de la función:
{% raw %}
```go
package utils
import (
"os"
"sync"
//Autoload the env
_ "github.com/joho/godotenv/autoload"
)
var (
environment = map[string]string{}
environmentMutex = sync.RWMutex{}
)
//AccessENV Return the ENV if exits
func AccessENV(key string) string {
//Obtiene el valor del map, si existe regresa el valor
environmentMutex.RLock()
val := environment[key]
environmentMutex.RUnlock()
if environment[key] != "" {
return val
}
//Si el valor no existe, lo obtiene de ENV
val := os.Getenv(key)
if val == "" || len(val) <= 0 {
return ""
}
//Si existe en ENV, lo asigna al map
environmentMutex.Lock()
environment[key] = val
environmentMutex.Unlock()
return val
}
```
{% endraw %}
#### ¿Que es el {% raw %}`RWMutex`{% endraw %} y porque no uso solo el {% raw %}`map`{% endraw %}?
> RWMutex is a reader/writer mutual exclusion lock
Esto quiere decir que bloquea la lectura y escritura de los {% raw %}`map`{% endraw %}, el cual **es necesario si se trabaja con gorutines**, porque puede dar un {% raw %}`fatal error`{% endraw %} debido que si no se bloquea, dos gorutines pueden intentar leer o escribir al mismo tiempo, corrompiendo los datos y deteniendo la aplicación.
La forma es que como funciona es que:
* {% raw %}`Lock`{% endraw %} {% raw %}`Unlock`{% endraw %} para bloquear y desbloquear la **escritura**
* {% raw %}`RLock`{% endraw %} {% raw %}`RUnlock`{% endraw %} para bloquear y desbloquear la **lectura**
El uso de maps es seguro dentro de las funciones y no dará ningún error.
Ahora en podemos usar esto y acceder a nuestras variables de manera segura y rápida. Con nuestra función vamos a cambiar la función de {% raw %}`ConnectDB()`{% endraw %} para acceder a los datos de la base de datos desde el archivo {% raw %}`.env`{% endraw %}, cambiamos el codigo de esta manera:
{% raw %}
```go
package storage
import (
"fmt"
"log"
"strconv"
"github.com/jinzhu/gorm"
//Postgres Driver imported
_ "github.com/lib/pq"
"gamelist/utils"
)
func ConnectDB() *gorm.DB {
var (
host = utils.AccessENV("DB_HOST")
user = utils.AccessENV("DB_USER")
port = utils.AccessENV("DB_PORT")
password = utils.AccessENV("DB_PASSWORD")
name = utils.AccessENV("DB_NAME")
)
if host == "" {
log.Fatalln("Error loading ENV")
return nil
}
portInt, err := strconv.Atoi(port)
if err != nil {
log.Fatalln("Error en convertir el port : " + err.Error())
return nil
}
}
```
{% endraw %}
El resto del código es igual, ahora comprobamos si las variables están vacías, en cuyo caso ocurrió un **error al obtener los valores de ENV**. Luego se convierte el port de {% raw %}`string`{% endraw %} a {% raw %}`int`{% endraw %}, **formato que la función necesita**.
## Crear el modelo de {% raw %}`Juego`{% endraw %}
Para poder trabajar con [GORM](http://gorm.io/) necesitas crear un modelo. Dentro de la carpeta {% raw %}`models` creamos el archivo `juego.go`, para este proyecto solo usaremos un modelo, el cual sera `Juego` que tendra `Nombre`, `Desarrollador` y `precio`, usaremos el `Model` de GORM que nos provee con **todo lo necesario para manipular la información**:
{% raw %}
```go
package models
import (
"time"
"github.com/jinzhu/gorm"
)
//Juego estructura
type Juego struct {
gorm.Model
Nombre string `gorm:"not null" json:"nombre"`
Desarrollador string `gorm:"not null" json:"desarrollador"`
Precio int `gorm:"not null" json:"precio"`
}
```
{% endraw %}
El {% raw %}`gorm.Model`{% endraw %} nos agrega esto a nuestro {% raw %}`Juego`{% endraw %}:
{% raw %}
```go
// gorm.Model definition
type Model struct {
ID uint `gorm:"primaryKey"`
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt gorm.DeletedAt `gorm:"index"`
}
```
{% endraw %}
Ahorrándonos de agregarlos nosotros, por ultimo agregamos un {% raw %}`Hook`{% endraw %} que nos permite GORM. Este se llamara {% raw %}`AfterUpdate`{% endraw %} que se ejecuta cada que actualizamos algo y la usaremos para actualizar el dato {% raw %}`UpdatedAt`{% endraw %} automáticamente, este es el código:
{% raw %}
```go
// Updating data in same transaction
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
u.UpdatedAt = time.Now()
return
}
```
{% endraw %}
Por ultimo para poder usarlo, tenemos que hacer la migración en la base de datos. Dentro del {% raw %}`ConnectDB()`{% endraw %} antes del {% raw %}`return`{% endraw %} agregamos {% raw %}`DB.AutoMigrate(&models.User{})`{% endraw %} esto hara la migración en la base de datos si no existe, y si existe simplemente la ignorara evitando cualquier tipo de problemas.
## Ya cree el modelo ¿Ahora como lo uso? Creando el CRUD de la DB 👨💻
Esto constara de 5 funciones que interactuarán con nuestra base de datos y sera la base de nuestro CRUD. Dentro de la carpeta storage creamos {% raw %}`juegos.go`{% endraw %} donde crearemos nuestro CRUD.
importaremos estos paquetes:
{% raw %}
```go
import (
"log"
"time"
"github.com/jinzhu/gorm"
"gamelist/models"
)
```
{% endraw %}
Existe diferentes maneras de trabajar con la instancia de la base de datos, en este tutorial crearemos una estructura con la base de datos y agregaremos los métodos de nuestro CRUD.
{% raw %}
```go
//JuegoDB struct
type JuegoDB struct {
db *gorm.DB
}
```
{% endraw %}
esto creara una estructura con una instancia de GORM como parámetro, podremos crear tantas como queramos, importante que nombre de la instancia de GORM este en minuscula y asi no se exporte. Para poder usarlo tenemos que crear una nueva con una instancia de GORM conectada a nuestra base de datos, para ellos crearemos una función que la cree:
{% raw %}
```go
//NuevoJuegoDB Create a new storage user service
func NuevoJuegoDB () JuegoDB {
nuevaDB := ConnectDB()
nuevoServicio := JuegoDB{db: nuevaDB}
return nuevoServicio
}
```
{% endraw %}
Esto creara una nueva instancia y sera lo que usemos después en nuestros handlers. Como estamos en la misma carpeta que la función {% raw %}`ConnectDB()`{% endraw %} podremos usarla sin necesidad de ninguna importación.
### Crear los métodos del CRUD
Ahora que podemos crear una nueva instancia {% raw %}`JuegoDB`{% endraw %} necesitamos agregar los métodos a nuestra estructura, esto hara que al crear una nueva instancia en {% raw %}`NuevoJuegoDB()`{% endraw %} venga con funciones que podremos usar, para agregarlo como metodo tenemos que crear una función normal pero con {% raw %}`(j *JuegoDB)`{% endraw %} antes del nombre, así que vamos a hacerlo.
* **Obtener un juego**:
{% raw %}
```go
//ObtenerJuego del juego con el ID
func (j *JuegoDB) ObtenerJuego(id int) *models.Juego, error {
var juego *models.Juego = new(models.Juego)
// SELECT * FROM juegos WHERE id = 10;
if err := j.db.First(&juego, id).Error; err != nil {
return nil, err
}
return juego, nil
}
```
{% endraw %}
Esta función da por hecho que el {% raw %}`id`{% endraw %} existe y no esta vacío, comprobaremos el id en los handlers. Esta función crea una variable vacia, que se usara en la DB, GORM buscara automaticamente en función del modelo de la variable y le pasaremos el {% raw %}`id`{% endraw %} como parametro. En caso de error regresara un {% raw %}`nil`{% endraw %} y el error, si todo salio bien, regresara el {% raw %}`juego`{% endraw %} y un error {% raw %}`nil`{% endraw %}.
* **Obtener todos los Juegos**:
{% raw %}
```go
//ObtenerJuegos Obtener todos los Juegos
func (j *JuegoDB) ObtenerJuegos () []*models.Juego, error {
var juego []*models.Juego = []*models.Juego{new(models.Juego)
// SELECT * FROM juegos;
if err := j.db.Find(&juego).Error; err != nil {
return nil, err
}
return juego, nil
}
```
{% endraw %}
* **Crear un Juego**:
{% raw %}
```go
//CrearJuego crea un Juego
func (j *JuegoDB) CrearJuego(nuevoJuego *models.Juego) *models.Juego, bool, error {
if err := j.db.Create(&nuevoJuego).Error; err != nil {
return nil, false, err
}
return *nuevoJuego, true, nil
}
```
{% endraw %}
* **Modificar un Juego**:
{% raw %}
```go
//ModificarJuego Modifica el Juego
func (j *JuegoDB) ModificarJuego(nuevoJuego *models.Juego) bool, error {
if err := j.db.Model(&juego).Updates(&nuevoJuego).Error; err != nil {
return false, err
}
return true, nil
}
```
{% endraw %}
En esta función se utiliza {% raw %}`Updates`{% endraw %} que actualiza todos los campos que no estén vacíos. GORM, encadena las funciones, al agregar {% raw %}`Model()`{% endraw %} le decimos donde buscar, luego la función {% raw %}`Updates`{% endraw %} buscara con el {% raw %}`id`{% endraw %} del objeto y actualizara en la base de datos.
* **Eliminar un Juego**:
{% raw %}
```go
//EliminarJuego Elimina un Juego
func (j *JuegoDB) EliminarJuego(id int) bool, error {
if err := j.db.Delete(&nuevoJuego, id).Error; err != nil {
return false, err
}
return true, nil
}
```
{% endraw %}
Estas son todas las funciones de nuestro CRUD, **Podremos acceder a los juegos, crearlo, modificarlo y eliminarlo**.
## Ahora con las funciones de la DB, Los Handlers 😎
Como ya dije, usaremos [Go Fiber](https://gofiber.io/) para nuestros Handlers y administrar las peticiones HTTP. Usaremos la misma estructura que las funciones de la Base de datos. Crearemos una estructura y le agregaremos las funciones de nuestro handler.
{% raw %}
```go
import (
"strconv"
"strings"
"time"
"github.com/go-redis/redis/v8"
"github.com/gofiber/fiber/v2"
"github.com/jinzhu/gorm"
"gamelist/storage"
"gamelist/models"
)
type juegosHandler struct {
BaseDatos storage.JuegoDB
}
```
{% endraw %}
Y crearemos la función para crear un nuevo handler:
{% raw %}
```go
//NuevoJuegosHandler Crear un nuevo handler
func NuevoJuegosHandler() *juegosHandler {
//Regresa nuevo Handler
return &juegosHandler{
BaseDatos: storage.NuevoJuegoDB(),
}
}
```
{% endraw %}
Ahora crearemos nuestros handlers usando [Go Fiber](https://gofiber.io/), la forma de un handler de Fiber es: `func Nombre(c *fiber.Ctx) error {...}`, son todas las mismas, toma como metodo el `Context` o contexto de Fiber y regresa un `error` si todo sale bien sera `nil`. Ahora vamos a crear nuestras funciones:
* **Obtener un Juego por ID**:
{% raw %}
```go
//ObtenerJuego Obtener un Juego por ID
func (j *juegosHandler) ObtenerJuego(c *fiber.Ctx) error {
//Obtener el ID desde los parametros, es uno de los metodos de Fiber
ID := c.Params("id")
//Si el ID esta vacio, no se envio asi que regresa un error
if len(ID) < 0 {
//Esta es la forma de regresar errores en fiber
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Review your input"})
}
...
}
```
{% endraw %}
Para enviar errores en Fiber tienes que enviar un numero de {% raw %}`Status`{% endraw %} o Estatus, que indique que ha pasado con la petición, Fiber viene con codigos por defecto que son los estandares en la Web. Y opcionalmente **puedes mandar información en formato JSON** con la información del servidor, en este caso el error. Ahora convertiremos el ID, que es un {% raw %}`string`{% endraw %} a un {% raw %}`int`{% endraw %} para ser usado en la Base de datos:
{% raw %}
```go
//ObtenerJuego Obtener un Juego por ID
func (j *juegosHandler) ObtenerJuego(c *fiber.Ctx) error {
...
//Convertir ID a int
IntID, err := strconv.Atoi(ID)
if err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error converting in Integer", "data": err.Error()})
}
//Obtener datos del Juego
juego, err := j.BaseDatos.ObtenerJuego(ID)
if err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
}
//Regresar los datos del juego, Go lo convertira en JSON
return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}
* **Obtener todos los juegos**: Esta es mas simple que el anterior, no tenemos que hacer ninguna comprobación por parte del usuario, solo asegurarnos de obtener la lista de Juegos.
{% raw %}
```go
//ObtenerTodosJuegos Obtener Todos los Juegos
func (j *juegosHandler) ObtenerTodosJuegos(c *fiber.Ctx) error {
//Obtener datos del Juego
juego, err := j.BaseDatos.ObtenerJuego(ID)
if err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
}
//Regresar los datos del juego, Go lo convertira en JSON
return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}
Al igual que con el anterior, Go lo convertira en JSON automáticamente, no importa si es un array.
* **Crear un Juego**:
{% raw %}
```go
//CrearJuego Crea un nuevo Juego
func (j *juegosHandler) CrearJuego(c *fiber.Ctx) error {
//Crear el nuevo juego
var nuevoJuego *models.Juego
//Obtener los datos del body
if err := c.BodyParser(&nuevoJuego); err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Revisa tu Body", "data": err.Error()})
}
//Comprobar los datos del juego
//Nombre
if len(strings.TrimSpace(nuevoJuego.Nombre)) <= 0 || strings.TrimSpace(nuevoJuego.Nombre) == "" {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El Nombre del juego es obligatorio")
}
//Desarrollador
if len(strings.TrimSpace(nuevoJuego.Desarrollador)) <= 0 || strings.TrimSpace(nuevoJuego.Desarrollador) == "" {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El Desarrolladordel juego es obligatorio")
}
//Precio
if len(nuevoJuego.Precio) < 0 {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El precio no puede ser negativo")
}
//Crear el Juego
juego, exitoso, err := j.BaseDatos.CrearJuego(nuevoJuego)
if err != nil || !exitoso {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
}
//Regresar los datos del juego, Go lo convertira en JSON
return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}
En esta función obtendremos los datos del nuevo juego del {% raw %}`body`{% endraw %} con los datos que el usuario deberia enviar, tendra que enviar un {% raw %}`JSON`{% endraw %} como este:
{% raw %}
```json
{
"nobmre": "Dark Souls",
"desarrollador": "From Software",
"precio": 20
}
```
{% endraw %}
* **Modificar un Juego**: Esta sera muy similar al anterior pero verificaremos los valores y si no lo envia lo tendra vacio y asi GORM lo ignorara:
{% raw %}
```go
//ModificarJuego Modificia un Juego
func (j *juegosHandler) ModificarJuego (c *fiber.Ctx) error {
//Crear el nuevo juego
var body *models.Juego
//Obtener los datos del body
if err := c.BodyParser(&body); err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Revisa tu Body", "data": err.Error()})
}
//Crear el nuevo juego
var nuevoJuego *models.Juego
//Comprobar los datos del juego
//Nombre
if len(strings.TrimSpace(body.Nombre)) <= 0 || strings.TrimSpace(body.Nombre) == "" {
nuevoJuego.Nombre = body.Nombre
}
//Desarrollador
if len(strings.TrimSpace(body.Desarrollador)) <= 0 || strings.TrimSpace(body.Desarrollador) == "" {
nuevoJuego.Desarrollador= body.Desarrollador
}
//Precio
if len(body.Precio) < 0 {
nuevoJuego.Precio= body.Precio
}
//Modificar el Juego
exitoso, err := j.BaseDatos.ModificarJuego(nuevoJuego)
if err != nil || !exitoso {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
}
//Esto regresara el numero de estatus de que todo salio bien
return c.SendStatus(fiber.StatusAccepted)
}
```
{% endraw %}
* **Eliminar un Juego**:
{% raw %}
```go
//EliminarJuego Elimina un Juego por ID
func (j *juegosHandler) EliminarJuego(c *fiber.Ctx) error {
//Obtener el ID desde los parametros, es uno de los metodos de Fiber
ID := c.Params("id")
//Si el ID esta vacio, no se envio asi que regresa un error
if len(ID) < 0 {
//Esta es la forma de regresar errores en fiber
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Review your input"})
}
//Convertir ID a int
IntID, err := strconv.Atoi(ID)
if err != nil {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error converting in Integer", "data": err.Error()})
}
//Obtener datos del Juego
exitoso, err := j.BaseDatos.EliminarJuego(ID)
if err != nil || !exitoso {
return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
}
//Regresar Estatus de aceptado, todo salio bien.
return c.SendStatus(fiber.StatusAccepted)
}
```
{% endraw %}
Con esto terminamos con el handler de nuestro CRUD, Lo unico que falta es configurar el servidor con los metodos necesarios.
## Configurar el Servidor Fiber
En nuestro {% raw %}`main.go`{% endraw %} deberiamos tener algo como esto:
{% raw %}
```go
func main() {
//Crear nuestra aplicación de Fiber
app := fiber.New()
app.Get("/", func(c *fiber.Ctx) error {
return c.SendString("Hello, World 👋!")
})
log.Fatal(app.Listen(":3000"))
}
```
{% endraw %}
Para poder configurar con nuestros handlers, tendremos que agregar esto a nuestros {% raw %}`import`{% endraw %}
{% raw %}
```go
import (
"log"
"github.com/gofiber/fiber/v2"
"gamelist/handlers"
)
```
{% endraw %}
Ahora crearemos un nuevo {% raw %}`Handler`{% endraw %} y agregaremos las rutas de nuestro CRUD:
{% raw %}
```go
func main() {
//Crear nuestra aplicación de Fiber
app := fiber.New()
nuevoHandler := handlers.NuevoJuegosHandler()
app.Get("/:id", nuevoHandler.ObtenerJuego)
app.Get("/", nuevoHandler.ObtenerTodosJuegos)
app.Post("/", nuevoHandler.CrearJuego)
app.Put("/", nuevoHandler.ModificarJuego)
app.Delete("/:id", nuevoHandler.EliminarJuego)
log.Fatal(app.Listen(":3000"))
}
```
{% endraw %}
### ¡Listo! ¡Terminamos nuestro Proyecto! 🤩
Eso es todo en este tutorial, Los siguientes pasos serian agregar {% raw %}`middlewares`{% endraw %} a nuestro proyecto y seguridad con {% raw %}`JWT`{% endraw %}.
Gracias por leer, cualquier cosa no dudes en preguntar.
Top comments (0)