Tout comme le langage C, le langage Golang est également un langage open source qui peut être exécuté sur de nombreux outils sur les systèmes Windows et Linux/Unix pour créer des enregistrements. Comme C++ et Java, nous pouvons établir une connexion entre un système client MongoDB et le langage Go à l'aide de n'importe quel outil golang. Pour ce faire, nous effectuerons plusieurs étapes très importantes et nécessaires dans Ubuntu 22.04 en utilisant l'outil de code Visual Studio pour un programme. Avant d'établir une connexion avec la boussole MongoDB, nous avons tendance à installer MongoDB et Visual Studio Code avec 'go' et les extensions requises dans le guide pour vous aider dans le langage Go.
Installer MongoDB
Nous avons téléchargé le package 'deb' du serveur MongoDB depuis son site officiel. Le package 'Deb' peut également être exécuté dans Ubuntu à l'aide de l'outil de commande 'dpkg' sur le terminal.
Exécuté le fichier du serveur MongoDB sur le terminal avec les droits 'sudo' et fourni un mot de passe.
saeedraza@virtualbox :~$ sudo dpkg -je mongodb-org-server_6.0.3_amd64.deb
Si vous avez trouvé le service MongoDB inactif de votre côté après avoir essayé l'instruction 'systemctl' d'Ubuntu pour vérifier l'état, vous pouvez également le mettre à jour. Pour activer MongoDB, essayez l'instruction systemctl avec les mots clés 'start' et 'enable'.
saeedraza@virtualbox :~$ sudo systemctl permettre mondieu
saeedraza@virtualbox :~$ sudo statut systemctl mongod
Lancer MongoDB
Après l'installation, lancez rapidement le shell MongoDb en utilisant la requête 'mongo'. Passez à la base de données « admin » pour effectuer les étapes suivantes.
saeedraza@virtualbox :~$ MongoShell MongoDB version v5.0.14
connexion à : mongodb : // 127.0.0.1 : 27017 / ? compresseurs = désactivé & gssapiServiceName =mongodb
Session implicite : session { 'identifiant' : UUID ( '34cc8e0f-b6b0-4191-adea-676411f66cf5' ) }
Version du serveur MongoDB : 6.0.3
Nous créons un nouvel utilisateur avec des droits d'administrateur à l'aide de la fonction createUser().
est passé à l'administrateur de la base de données
> db.createUser (
... {
... utilisateur: 'Saïd' ,
... pwd : '12345' ,
... rôles: [ { rôle: 'userAdminAnyDatabase' , db : 'administrateur' } , 'readWriteAnyDatabase' ]
... } )
Utilisateur ajouté avec succès : {
'utilisateur' : 'Saïd' ,
'rôles' : [
{
'rôle' : 'userAdminAnyDatabase' ,
'db' : 'administrateur'
} ,
'readWriteAnyDatabase'
]
}
Autorisé l'utilisateur 'Saeed' en utilisant les informations d'identification dans la fonction 'auth' et affiché les bases de données actuellement détenues de MongoDB.
un
> afficher la base de données
administrateur 0,000 Go
configuration 0,000 Go
local 0,000 Go
Installer le pilote MongoDB pour Golang
Ouvrez le terminal dans Visual Studio Code et déplacez-vous dans le dossier « Golang » dans lequel vous vouliez ajouter vos fichiers de code source. Exécutez l'instruction 'go mod init' avec le nom du dossier pour créer un fichier 'go.mod'. Chargez le pilote MongoDB pour le langage Go via la requête « go get ».
saeedraza@virtualbox :~/Golang$ aller mod init Golang
Dans certains cas, il est également nécessaire de charger le pilote MongoDB au format bson pour Golang.
Assurez-vous d'ajouter les packages d'extension nécessaires tels que 'gopls' dans le code Visual Studio à l'aide du panneau Extensions sans utiliser aucune instruction.
En plus de 'gopls', le Golang peut nécessiter l'installation de l'outil 'dlv'.
Exemple de code en cours
Le fichier de code 'main.go' a été lancé avec l'importation de certains packages utiles qui seront utilisés dans l'ensemble du code pour la connexion. Un total de 7 importations ont été faites ici. Après avoir importé les packages, nous avons créé une nouvelle structure nommée MongoField avec 4 membres de données de type JSON. 2 de ces membres de données sont des chaînes et 2 d'entre eux sont des entiers.
Après cela, un type constant de variable 'uri' a été déclaré avec une adresse client ou vous devez y ajouter votre adresse localhost en fonction du nom d'utilisateur et du mot de passe. Les fonctions main() commencent par l'utilisation de la fonction connect() de Golang pour se connecter à MongoDB via un objet 'mongo'. La fonction ApplyURI() prendra la variable 'uri' comme argument à appliquer sur la fonction Client() afin qu'une connexion puisse être établie via une adresse hôte. Le package de contexte a joué le rôle principal pour appeler la fonction TODO() pour demander une connexion. Si la connexion a été établie avec succès entre le code Visual Studio et MongoDB, le signal renvoyé par le client sera ajouté à la variable « client » ; sinon, l'erreur sera stockée dans la variable 'err'.
L'instruction 'if' est là pour afficher les messages en conséquence. Si la variable 'err' a une valeur autre que 'nil', la fonction Println() du package de format 'fmt' imprimera cette erreur sur l'écran de sortie, le terminal. Le package 'os' sera utilisé pour quitter le programme si l'erreur se produit. Le package de contexte est à nouveau utilisé ici pour gérer le délai d'attente de la connexion à établir via ce programme. Pour la valeur de délai d'attente particulière 'ctx', notre programme s'exécutera. Une nouvelle collection 'Person' ainsi qu'une nouvelle base de données 'New' seront créées dans le client MongoDB via Golang. Le Println() affichera le type d'une collection 'c' en utilisant la fonction 'TypeOf' du package reflect.
Un enregistrement 'Rec' a été créé en utilisant la structure MongoField membres de données qui sont initialisés ici un par un. Le type d'enregistrement s'est affiché et l'enregistrement 'Rec' sera inséré dans le client MongoDB à l'aide de la fonction insertOne avec l'objet de collection 'c'. L'insertion réussie conduit à une variable 'résultat' contenant la valeur de succès tandis que la variable 'insertErr' contiendra la valeur d'échec. L'instruction 'if' est à nouveau utilisée pour vérifier et afficher l'erreur lors de l'insertion d'un enregistrement uniquement si la variable 'insertErr' contient une valeur autre que 'nil'. Sinon, la partie 'else' de l'instruction contiendra des instructions Println() pour afficher le type d'enregistrement à insérer, l'ID d'enregistrement et le message de réussite de la connexion et de l'insertion qui ont eu lieu. Le code Golang est maintenant terminé.
paquet principalimporter (
'le contexte'
'fmt'
'vous'
'refléter'
'temps'
'go.mongodb.org/mongo-driver/mongo'
'go.mongodb.org/mongo-driver/mongo/options'
)
taper Structure MongoField {
Chaîne de nom ` json : 'Champ Str' `
Chaîne d'e-mail ` json : 'Champ Str' `
Âge int ` json : 'Champ Int' `
Salaire int ` json : 'Champ Int' `
}
const uri = 'mongodb : // Mot de passe de l'utilisateur @ hôte local : 27017 / ? maxPoolSize = vingt & dans =majorité'
fonction principale ( ) {
client, err := mongo.Connect ( contexte.ALL ( ) ,options.Client ( ) .ApplyURI ( taper ) )
si se tromper ! = nul {
fmt.Println ( 'Erreur Mongo.connect() : ' , erreur )
os. Quitter ( un )
}
ctx, _ := contexte.AvecTimeout ( contexte. Contexte ( ) , quinze * temps.Seconde )
c := client.Base de données ( 'Nouveau' ) .Collection ( 'La personne' )
fmt.Println ( 'Type de collecte : ' , refléter.TypeOf ( c ) , ' \n ' )
Rec := MongoField {
Nom: 'EDEN' ,
E-mail: 'eden@gmail.com' ,
Âge: Quatre cinq ,
Un salaire: 50000 }
fmt.Println ( 'Type d'enregistrement : ' , refléter.TypeOf ( Rec ) , ' \n ' )
résultat, insertErr := c.InsertOne ( ctx, Rec )
si insertErr ! = nul {
fmt.Println ( 'Erreur InsertOne : ' , insérerErr )
os. Quitter ( un )
} autre {
fmt.Println ( 'Type de résultat InsertOne : ' , refléter.TypeOf ( résultat ) )
newID = result.InsertedID
fmt.Println ( « ID d'enregistrement inséré : » , nouvelID ) )
fmt.Println ( 'Enregistrements connectés et insérés avec succès !' )
} }
Enregistrez le code Golang et ouvrez le terminal dans le dossier Golang. Maintenant, utilisez l'instruction 'go' avec le mot-clé 'run' pour exécuter le fichier de code 'main.go'. Le débogage a réussi et la collection 'Person' a été générée avec succès dans MongoDB. La sortie affiche le type de collection, le type d'enregistrement, le type de résultat et l''ID' d'un enregistrement.
Type de collecte : * mongo.Collection
Type d'enregistrement : main.MongoField
Type de résultat InsertOne : * mongo.InsertOneResult
ID d'enregistrement inséré : ObjectID ( '63a8535ac97b4218230664b6' )
Enregistrements connectés et insérés avec succès.
Ouvrez la boussole 'MongoDB' de votre côté et connectez-vous à son hôte local à l'aide de l''URI'.
Après avoir déplacé dans la base de données 'Nouveau', nous avons la collection 'Personne' affichée dans la section 'Documents' avec l'enregistrement que nous avons ajouté.
Conclusion
Ce guide illustre l'utilisation du langage Go pour ajouter des enregistrements dans le client MongoDB à l'aide d'un outil Visual Studio Code dans le système Linux. Pour cela, nous avons installé le mongodb avec le pilote mongodb pour 'golang' dans le système. En utilisant un langage Golang, nous avons créé un fichier 'go' dans MongoDB et discuté de la variété de packages et de fonctions de Golang pour créer une connexion à MongoDB et insérer des enregistrements. Au final, nous avons démontré les résultats sur la boussole MongoDB qui montre que vous pouvez connecter n'importe quel outil Golang à MongoDB.