Cómo crear una API CRUD con Gin y MongoDB de Golang

Golang es uno de los lenguajes de programación más demandados y mejor pagados con muchas aplicaciones. Cuando se combina con marcos como Gin, Revel y gorilla/mux, puede crear fácilmente una API con Go.

Aprenda a crear una API CRUD en Golang utilizando el marco Gin HTTP.

Configuración e instalación inicial

Comience con Golang instalándolo en su computadora si aún no lo ha hecho.

Una vez instalado, el siguiente paso es crear una carpeta raíz del proyecto en su máquina e inicializar un módulo Go en ese directorio raíz.

Para ello, abra una CLI, navegue a la carpeta raíz de su proyecto y ejecute:

ir mod init module_name

Verá el nombre de su módulo (p. ej. CRUD_API) y su versión al abrir el ir.mod expediente. Todos los paquetes personalizados provendrán de este módulo principal. Entonces, cualquier paquete personalizado importado toma la forma:

importar(paquete CRUD_API/paquete-nombre del directorio)

A continuación, instale los paquetes necesarios para crear la API CRUD. En este caso, utilice Ginebra Gónica para enrutar los puntos finales de la API:

instagram viewer

Vamos obtener github.com/gin-gonic/ginebra

Ahora instale el controlador MongoDB para almacenar datos:

Vamos obtener go.mongodb.org/mongo-driver/mongo

Cómo conectarse Ir a MongoDB

Todo lo que necesita es su URI de MongoDB para conectar Golang con la base de datos. Por lo general, se ve así si se está conectando a MongoDB Atlas localmente:

Mongo_URL = "mongodb://127.0.0.1:27017"

Ahora crea una nueva carpeta en el directorio raíz de tu proyecto y llámala bases de datos. Cree un archivo Go dentro de esta carpeta y asígnele un nombre base de datos.ir.

Este es su paquete de base de datos y comienza importando las bibliotecas requeridas:

paquete base de datosimportar (
"contexto"
"fmt"
"Iniciar sesión"
"tiempo"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
función Conectar DB() * mongo. Cliente {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	cliente, error: = mongo. Nuevo cliente (opciones. Cliente().ApplyURI(Mongo_URL))
si yerra != nil {
Iniciar sesión.Fatal(errar)
	}
ctx, cancelar := contexto. WithTimeout (contexto. Fondo(), 10 * tiempo. Segundo)
	error = cliente. Conectar (ctx)
	aplazar cancelar ()
si yerra != nil {
Iniciar sesión.Fatal(errar)
	}fmt. imprimir("Conectado a mongoDB")
devolver cliente
}

Es una buena práctica ocultar variables de entorno como la cadena de conexión de la base de datos en un .env expediente usando el paquete dotenv. Esto hace que su código sea más portátil y resulta útil cuando se utiliza un Instancia de clúster en la nube de MongoDB, por ejemplo.

los Conectar DB La función establece una conexión y devuelve un nuevo objeto MongoDB Client.

Crear colección de base de datos

MongoDB almacena datos en colecciones, que proporcionan una interfaz para los datos de la base de datos subyacente.

Para manejar la funcionalidad de obtención de colecciones, comience creando una nueva carpeta, Recopilación, en la raíz de su proyecto. Ahora cree un nuevo archivo Go, getCollection.go, que obtiene la colección de la base de datos:

paquete coleccionarimportar (
"go.mongodb.org/mongo-driver/mongo"
)funciónObtenerColección(cliente *mongo.Cliente, nombre de la coleccióncuerda) *mongo.Recopilación {
	colección := cliente. Base de datos("miGoappDB").Recopilación("Publicaciones")
devolver recopilación
}

Esta función obtiene la Colección de la base de datos MongoDB. El nombre de la base de datos, en este caso, es miGoappDB, con Publicaciones como su colección.

Crear el modelo de base de datos

Cree una nueva carpeta dentro de su directorio raíz y llámela modelo. Esta carpeta maneja su modelo de base de datos.

Cree un nuevo archivo Go dentro de esa carpeta y llámelo modelo.ir. Su modelo, en este caso, es una publicación de blog con su título:

paquete modeloimportar ( "go.mongodb.org/mongo-driver/bson/primitive" )

escribe Publicar estructura { IDENTIFICACIÓNprimitivo.IDObjeto Cadena de título Cadena de artículo }

Creación de una API CRUD con Go

El siguiente paso es la creación de la API CRUD. Para comenzar con esta sección, cree una nueva carpeta dentro del directorio raíz de su proyecto para manejar sus puntos finales. Llámalo rutas.

Cree un archivo Go separado en esta carpeta para cada acción. Por ejemplo, puedes nombrarlos crear.ir, leer.ir, actualizar.ir, y eliminar.ir. Exportará estos controladores como el rutas paquete.

Cómo crear el punto final POST en Go

Comience definiendo el punto final POST para escribir datos en la base de datos.

En el interior rutas/create.go, agrega lo siguiente:

paquete rutasimportar (
	coleccionar "CRUD_API/Colección"
	base de datos "CRUD_API/bases de datos"
	modelo "CRUD_API/modelo"
"contexto"
"Iniciar sesión"
"red/http"
"tiempo"
"github.com/gin-gonic/ginebra"
"go.mongodb.org/mongo-driver/bson/primitive"
)
función Crear publicación(c * ginebra. Contexto){
variable BD = base de datos. ConectarDB()
	var postCollection = getcolección. ObtenerColección (DB, "Publicaciones")
	ctx, cancelar := contexto. WithTimeout (contexto. Fondo(), 10*tiempo. Segundo)
	publicar := nuevo(modelo. publicaciones)
	aplazar cancelar ()
si falla := c. EnlazarJSON(&correo); err != nulo {
 C. JSON(http. EstadoBadRequest, ginebra. H{"mensaje": error})
Iniciar sesión.Fatal(errar)
devolver
	}
postPayload := modelo. Publicaciones{
Identificación: primitivo.NuevoIDObjeto(),
Título: correo.Título,
Artículo: correo.Artículo,
	}
resultado, err := postCollection. InsertOne (ctx, postPayload)
si yerra != nil {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": error})
devolver
	}C. JSON(http. Estado Creado, ginebra. H{"mensaje": "Publicado con éxito", "Datos": mapa[cadena]interfaz{}{"datos": resultado}})
}

Este código comienza importando los módulos personalizados del proyecto. A continuación, importa paquetes de terceros, incluidos Ginebra y Controlador MongoDB.

Más lejos, postColección contiene la colección de la base de datos. Notablemente, C. BindJSON("publicación") es una instancia de modelo JSONified que llama a cada campo de modelo como postcarga útil; esto va a la base de datos.

Cómo crear el punto final GET

El punto final GET, en rutas/read.go, lee un solo documento de la base de datos a través de su ID único. También comienza importando paquetes personalizados y de terceros:

paquete rutasimportar (
	coleccionar "CRUD_API/Colección"
	base de datos "CRUD_API/bases de datos"
	modelo "CRUD_API/modelo"
"contexto"
"red/http"
"tiempo"
"github.com/gin-gonic/ginebra"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
función Leer una publicación(c * ginebra. Contexto){
	ctx, cancelar := contexto. WithTimeout (contexto. Fondo(), 10*tiempo. Segundo)
variable BD = base de datos. ConectarDB()
	var postCollection = getcolección. ObtenerColección (DB, "Publicaciones")
ID de la publicación: = c. parámetro("ID del mensaje")
variable modelo de resultado. Publicaciones
aplazar cancelar ()
objId, _ := primitivo. ObjectIDFromHex (postId)
err := postColección. FindOne (ctx, bson. METRO{"identificación":objId}).Decodificar(&resultado)
res := mapa[cadena]interfaz{}{"datos": resultado}
si yerra != nil {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": error})
devolver
	}C. JSON(http. Estado Creado, ginebra. H{"mensaje": "¡éxito!", "Datos": res})
}

los ID del mensaje variable es una declaración de parámetro. Obtiene el ID de objeto de un documento como objId.

Sin embargo, resultado es una instancia del modelo de base de datos, que luego contiene el documento devuelto como resolución.

Cómo crear el punto final PUT

El controlador PUT, en rutas/update.go, es similar al controlador POST. Esta vez, actualiza una publicación existente por su ID de objeto único:

paquete rutasimportar (
	coleccionar "CRUD_API/Colección"
	base de datos "CRUD_API/bases de datos"
	modelo "CRUD_API/modelo"
"contexto"
"red/http"
"tiempo"
"github.com/gin-gonic/ginebra"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
función Actualizar publicación(c * ginebra. Contexto){
	ctx, cancelar := contexto. WithTimeout (contexto. Fondo(), 10 * tiempo. Segundo)
variable BD = base de datos. ConectarDB()
	var postCollection = getcolección. ObtenerColección (DB, "Publicaciones")
ID de la publicación: = c. parámetro("ID del mensaje")
variable modelo de publicación Publicaciones
aplazar cancelar ()
objId, _ := primitivo. ObjectIDFromHex (postId)
si falla := c. EnlazarJSON(&correo); err != nulo {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": error})
devolver
	}
editado := bson. METRO{"título": correo. Título, "artículo": correo. Artículo}
resultado, err := postCollection. UpdateOne (ctx, bson. METRO{"identificación": objId}, hijo. METRO{"$establecer": editado})
res := mapa[cadena]interfaz{}{"datos": resultado}
si yerra != nil {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": error})
devolver
	}
si resultado. MatchedCount < 1 {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": "Los datos no'no existo"})
devolver
	}C. JSON(http. Estado Creado, ginebra. H{"mensaje": "¡Datos actualizados con éxito!", "Datos": res})
}

Un formato JSON de la instancia del modelo (correo) llama a cada campo del modelo desde la base de datos. La variable de resultado utiliza MongoDB. $establecer operador para actualizar un documento requerido llamado por su ID de objeto.

los resultado. MatchedCount condición evita que el código se ejecute si no hay ningún registro en la base de datos o si el ID pasado no es válido.

Creación de un punto final DELETE

El extremo DELETE, en eliminar.ir, elimina un documento en función del ID de objeto pasado como parámetro de URL:

paquete rutasimportar (
	coleccionar "CRUD_API/Colección"
	base de datos "CRUD_API/bases de datos"
"contexto"
"red/http"
"tiempo"
"github.com/gin-gonic/ginebra"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
función Eliminar mensaje(c * ginebra. Contexto){
	ctx, cancelar := contexto. WithTimeout (contexto. Fondo(), 10*tiempo. Segundo)
variable BD = base de datos. ConectarDB()
	ID de la publicación: = c. parámetro("ID del mensaje")
var postCollection = getcolección. ObtenerColección (DB, "Publicaciones") 
	aplazar cancelar ()
	objId, _ := primitivo. ObjectIDFromHex (postId) 
	resultado, err := postCollection. DeleteOne (ctx, bson. METRO{"identificación": objID}) 
	res := mapa[cadena]interfaz{}{"datos": resultado}
si yerra != nil {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": error})
devolver
	}
si resultado. Cuenta eliminada < 1 {
 C. JSON(http. StatusInternalServerError, ginebra. H{"mensaje": "No hay datos para eliminar"})
devolver
	}C. JSON(http. Estado Creado, ginebra. H{"mensaje": "Artículo eliminado con éxito", "Datos": res})
}

Este código elimina un registro usando el Eliminar uno función. También utiliza el resultado. Cuenta eliminada propiedad para evitar que el código se ejecute si la base de datos está vacía o el ID del objeto no es válido.

Crear el archivo del ejecutor de la API

Finalmente, crea un principal.ir dentro del directorio raíz de su proyecto. La estructura final de su proyecto debería verse así:

Este archivo maneja la ejecución del enrutador para cada punto final:

paquete principalimportar (
 rutas "CRUD_API/rutas"
"github.com/gin-gonic/ginebra"
)
función principal(){
 enrutador: = ginebra.Defecto()
enrutador CORREO("/", rutas. Crear Publicación)
// llamado como localhost: 3000/getOne/{id}
 enrutador OBTENER("getOne/:postId", rutas. Leer una publicación)
// llamado como servidor local: 3000/actualizar/{identificación}
 enrutador PONER("/update/:postId", rutas. Actualizar publicación)
// llamado como servidor local: 3000/Eliminar/{identificación}
 enrutador ELIMINAR("/Eliminar/:postId", rutas. Eliminar mensaje)enrutador Correr("servidor local: 3000")
}

Este archivo es el paquete principal que ejecuta otros archivos. Comienza importando los controladores de ruta. El siguiente es el enrutador variables, un Ginebra instancia que evoca las acciones HTTP y llama a cada punto final por su nombre de función desde el rutas paquete.

Su proyecto CRUD se ejecuta en servidor local: 3000. Para ejecutar el servidor y probar la API CRUD, ejecute el siguiente comando en su directorio base:

Vamoscorrerprincipal.Vamos

Convierta su proyecto Golang CRUD en un producto utilizable

Ha creado con éxito una API CRUD con Go; ¡Felicidades! Si bien este es un proyecto menor, ha visto lo que se necesita para ejecutar solicitudes HTTP regulares en Go.

Puede ser más creativo expandiendo esto a una aplicación más práctica que brinde valor a los usuarios. Go es un lenguaje de programación adecuado para una variedad de casos de uso.

About Technology - denizatm.com