Cómo usar Go con MongoDB en Mac
MongoDB es una base de datos NoSQL orientada a documentos. Si quieres usarla en tus proyectos con Golang, ¡buenas noticias! MongoDB sí es compatible con Golang. Sigue este tutorial para conectar Go y MongoDB y desarrollar proyectos que involucren ambos.
En el artículo a continuación, describimos exactamente cómo configurar tu MongoDB como fuente de datos en Go. Además, mostramos cómo ejecutar algunas de las operaciones básicas de CRUD en la base de datos.
Para seguir los pasos de este tutorial de Golang — MongoDB, necesitarás tener Go instalado en tu Mac, así que asegúrate de instalarlo antes de empezar.
Instalando el controlador de Go para MongoDB
Para usar MongoDB con Go, necesitas un controlador específico. Afortunadamente, MongoDB proporciona documentación oficial para el proceso. Vamos a repasar todos los pasos juntos.
Nota: En este post, solo cubrimos el controlador de Go. Para otros controladores de MongoDB, consulta la documentación oficial.
Para comenzar a usar MongoDB en Go, inicializa tu proyecto con go mod en un nuevo directorio. Aquí están los comandos de terminal para eso:
mkdir go-quickstart cd go-quickstart go mod init go-quickstart
A continuación, añade la dependencia de MongoDB con el comando go get:
go get go.mongodb.org/mongo-driver/mongo
Ahora estás listo para crear un clúster de base de datos en tu cuenta de MongoDB. Para hacerlo, necesitarás unirte a MongoDB Atlas. Es una excelente solución para empezar a trabajar con MongoDB en Golang, ya que tiene un nivel gratuito y está alojado en la nube.
Lo que necesitas hacer para conectar tu controlador MongoDB Golang es crear una cuenta en Atlas (puedes iniciar sesión con tu cuenta de Google), desplegar un clúster gratuito, añadir tu dirección IP a la lista de conexiones permitidas, crear un usuario de base de datos para el clúster que has desplegado, conectarte al clúster y comenzar a trabajar con tus datos.
Sigue estos pasos comenzando con el registro en https\://account.mongodb.com/account/register. Si encuentras algún problema, aquí tienes una guía oficial para cada uno de los pasos.
Ninguno de estos pasos requiere código, y deberías poder completar las acciones en la interfaz de Atlas. Una vez que completes este paso, podemos continuar con nuestra configuración para conectarte a tu clúster de base de datos MongoDB utilizando el controlador MongoDB Go.
Ten en cuenta que, al conectarte a tu clúster, necesitas seleccionar Connect to your application, y luego, en la página siguiente, copiar la cadena de conexión para agregarla a tu código de aplicación:
Copia tu fragmento de código para usarlo más tarde en tu editor de código. Nos gusta guardar nuestras partes de código en SnippetsLab, una aplicación dedicada a alojar una biblioteca de fragmentos de código.
Recuerda reemplazar y en el fragmento con la contraseña de la base de datos que creaste al registrarte en Atlas. Recomendamos guardar tus credenciales de inicio de sesión en un lugar seguro.
Usamos la aplicación Secrets 4 para guardar las credenciales de inicio de sesión de nuestro clúster de MongoDB:
Ahora, crea y guarda el archivo que contiene tu aplicación en tu carpeta go-quickstart (puedes usar un nombre diferente para tu carpeta de proyecto, pero asegúrate de realizar los cambios respectivos en el código que proporcionamos en los pasos anteriores).
Estamos desarrollando este proyecto en CodeRunner, una aplicación que te permite guardar, editar y ejecutar tu código en más de 25 lenguajes, incluido Go. Para escribir nuestro programa, creamos el archivo main.go en CodeRunner usando el código de ejemplo de MongoDB de este tutorial oficial y colocamos el archivo en la carpeta raíz de nuestro proyecto /go-quickstart.
Aquí está el código que usamos:
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"github.com/joho/godotenv"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
if err := godotenv.Load(); err != nil {
log.Println("No .env file found")
}
uri := os.Getenv("MONGODB_URI")
if uri == "" {
log.Fatal("You must set your 'MONGODB_URI' environmental variable. Seent https://docs.mongodb.com/drivers/go/current/usage-examples/#environment-variable")
}
client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
if err != nil {
panic(err)
}
defer func() {
if err := client.Disconnect(context.TODO()); err != nil {
panic(err)
}
}()
coll := client.Database("sample_mflix").Collection("movies")
title := "Back to the Future"
var result bson.M
err = coll.FindOne(context.TODO(), bson.D{{"title", title}}).Decode(&result)
if err == mongo.ErrNoDocuments {
fmt.Printf("No document was found with the title %sn", title)
return
}
if err != nil {
panic(err)
}
jsonData, err := json.MarshalIndent(result, "", " ")
if err != nil {
panic(err)
}
fmt.Printf("%sn", jsonData)
}
Para ejecutar este código con éxito, también necesitarás un archivo .env en la carpeta raíz de tu aplicación (en nuestro ejemplo, /go-quickstart).
Para crear un archivo .env vacío, usamos este comando de Terminal:
touch .env
A continuación, agregamos nuestra cadena de conexión en el archivo .env con una serie de comandos en la Terminal:
- Ejecuta vim .env en la Terminal.
- Establece el valor para MONGODB_URI con:
MONGODB_URI="mongodb+srv://<username>:<password>@cluster0.icb48.mongodb.net/myFirstDatabase?retryWrites=true&w=majority</password></username>
- Ejecuta el comando: wq!
- Ejecuta cat .env en el Terminal para comprobar que los cambios se han guardado correctamente. El archivo .env debe decir:
MONGODB_URI="mongodb+srv://<username>:<password>@cluster0.icb48.mongodb.net/myFirstDatabase?retryWrites=true&w=majority</password></username>
Ahora estás listo para hacer el ping a tu base de datos MongoDB con el comando:
go run main.go
Si cargó su base de datos de muestra según las instrucciones en los pasos de configuración de su cuenta de Atlas, debería obtener una respuesta que contenga información de esa base de datos de muestra.
En nuestro ejemplo, obtuvimos información de nuestra biblioteca de MongoDB sobre una película de Hollywood:
Operaciones CRUD de MongoDB
Para realizar operaciones CRUD en MongoDB, debe importar el paquete BSON. Dado que su importación está incluida en el código que hemos utilizado para nuestro ejemplo de programa Go anterior (del tutorial oficial de MongoDB), no tiene que hacerlo manualmente.
Pero si está escribiendo su propia aplicación, la línea para importar es:
"go.mongodb.org/mongo-driver/bson"
Ahora, leamos algunos datos en su base de datos de muestra de MongoBD.
Leer un documento en MongoDB
Aquí está el código que debe agregar a main.go para solicitar información sobre la película The Room:
coll := client.Database("sample_mflix").Collection("movies")
var result bson.M
err = coll.FindOne(context.TODO(), bson.D{{"title", "The Room"}}).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
// This error means your query did not match any documents.
return
}
panic(err)
}
También puedes copiar el código completo para tu archivo sample main.go en el tutorial oficial de MongoDB aquí.
A continuación, vamos a trabajar en las operaciones de escritura.
Crear un documento en MongoDB
Añade un documento a tu colección con este código:
coll := client.Database("insertDB").Collection("movies")
doc := bson.D{{"title", "Sunny Days and Nights in 1672"}, {"text", "This is just a test"}}
result, err := coll.InsertOne(context.TODO(), doc)
if err != nil {
panic(err)
}
El código de muestra completo está disponible en el tutorial oficial de MongoDB en esta página.
Ejecuta tu código y obtén una confirmación de que tu documento ha sido insertado:
Para verificar, ejecuta la consulta de búsqueda. Deberías obtener la información de tu muestra de vuelta:
Lee también:
- Usa Go con MySQL
- Usa Redis como base de datos
- Las mejores herramientas de desarrollo para Mac
- Cliente Git para Mac
Actualizar un documento en MongoDB
Ahora, puedes introducir cambios en el registro de tu base de datos. Para hacer eso, usa la herramienta de actualización.
Aquí tienes un código de muestra para eso:
coll := client.Database("insertDB").Collection("movies")
id, _ := primitive.ObjectIDFromHex("6205210bc9748a7cee6af8cb")
filter := bson.D{{"_id", id}}
update := bson.D{{"$set", bson.D{{"average_rtng", 4.5}}}}
result, err := coll.UpdateOne(context.TODO(), filter, update)
if err != nil {
panic(err)
}
El resultado después de ejecutar el código del programa actualizado debe ser: Documentos actualizados: 1
Ejecuta una consulta de búsqueda para probarlo. Así es como pueden verse tus resultados (ten en cuenta que ejecutamos bastantes actualizaciones para volver a verificar el código, por lo que nuestros resultados contienen un poco más de información que con la actualización anterior):
Eliminar un documento en MongoDB
Y finalmente, veamos cómo podemos eliminar documentos de nuestra base de datos MongoDB.
Este código eliminará el primer título coincidente en tu colección:
coll := client.Database("insertDB").Collection("movies")
filter := bson.D{{"title", "Your Newly Updated Title"}}
result, err := coll.DeleteOne(context.TODO(), filter)
if err != nil {
panic(err)
}
Conclusión
Como puedes ver, configurar tu base de datos MongoDB para trabajar con Golang solo requiere unas pocas líneas de código. Esperamos que este tutorial haya sido útil en tu camino hacia el dominio de Golang y las bases de datos MongoDB. Golang y MongoDB funcionan muy bien juntos y pueden ser tus aliados en numerosos proyectos, así que esperamos que hayas podido aprender a usar MongoDB con la ayuda de esta guía.
Ten en cuenta que MongoDB Atlas solo te permite crear un clúster gratuito, y deberás pagar por cualquier clúster adicional
