TOC

Comment installer et utiliser ArangoDB sur Ubuntu 14.04

introduction

ArangoDB est une base de données NoSQL. Elle a été créée en 2011, alors que de nombreuses bases de données NoSQL existaient déjà, dans le but de constituer une solution de base de données complète pouvant couvrir une variété de cas d’utilisation.

À sa base, ArangoDB est un document store, mais ce n’est que le début. Vous pouvez interroger des données avec un langage de requête à part entière (nommé AQL), ​​effectuer des transactions ACID, ajouter des points de terminaison HTTP personnalisés sous la forme d’applications JavaScript avec ses https: //developers.google.com/v8/[embedded V8], et plus encore.

Comme ArangoDB a beaucoup de fonctionnalités, cela pourrait être intimidant au début, mais après un deuxième regard, ce n’est pas du tout compliqué. Cet article vous aidera à installer ArangoDB et vous expliquera brièvement comment utiliser certaines de ses fonctionnalités principales.

Après avoir terminé ce tutoriel, vous devriez être capable de:

  • Installer ArangoDB sur Ubuntu 14.04

  • Configurer ArangoDB pour une utilisation de base

  • Insérer, modifier et rechercher des données

Concepts de base

Tout au long de l’article, nous allons utiliser certains concepts de base. Vous voudrez probablement vous familiariser avec eux avant de construire un projet sur ArangoDB:

  • Document Store: ArangoDB stocke les données dans des documents, contrairement à la manière dont les bases de données relationnelles stockent les données. Les documents sont des structures de données arbitraires composées de key-value pairs. Le key est une chaîne qui nomme le value (comme une colonne dans une base de données relationnelle). La value peut être n’importe quel type de données, même un autre document. Les documents ne sont liés à aucun schéma.

  • Query Language: interagissez avec vos données à l’aide d’une API ou d’un langage de requête. Alors que le premier laisse beaucoup de détails à l’utilisateur de l’API, un langage de requête transmet les détails à la base de données. Dans une base de données relationnelle, SQL est un exemple de langage de requête.

  • ACID: Les quatre propriétés A tomicity, C onsistency, I solation, et D urability décrivent les garanties des transactions de base de données. ArangoDB prend en charge les transactions conformes à ACID.

  • V8: le moteur JavaScript de Google, qui fait fonctionner Chrome, peut également être facilement intégré à d’autres logiciels. Son utilisation dans ArangoDB permet d’utiliser JavaScript dans la base de données. La plupart des fonctionnalités internes d’ArangoDB sont construites avec JavaScript.

  • HTTP API: ArangoDB fournit une API HTTP permettant aux clients d’interagir avec la base de données. L’API est resource oriented et peut être étendue avec JavaScript.

Conditions préalables

Avant de commencer, assurez-vous que votre Droplet est correctement configuré:

  • Créer un droplet avec Ubuntu 14.04 x64

  • Ajoutez un utilisateur sudo

Maintenant, vous devez vous connecter à votre serveur en utilisant le nouvel utilisateur créé. Tous les exemples du didacticiel peuvent être réalisés à partir du répertoire de base de l’utilisateur:

cd ~

Étape 1 - Installer ArangoDB

ArangoDB est livré pré-construit pour de nombreux systèmes d’exploitation et distributions. La chance est grande que vous n’avez pas besoin de le construire à partir de la source. Pour plus de détails, veuillez vous reporter à la documentation d’ArangoDB. Pour ce tutoriel, nous utiliserons Ubuntu 14.04 x64.

Depuis qu’ArangoDB utilise le service buildbuild d’OpenSUSE, la première chose à faire est de télécharger la clé publique de ses référentiels:

wget https://www.arangodb.com/repositories/arangodb2/xUbuntu_14.04/Release.key

Vous avez besoin de + sudo + pour installer la clé:

sudo apt-key add Release.key

Ensuite, ajoutez le référentiel apt et mettez à jour l’index:

sudo apt-add-repository 'deb https://www.arangodb.com/repositories/arangodb2/xUbuntu_14.04/ /'
sudo apt-get update

Installez ArangoDB:

sudo apt-get install arangodb

Nous pouvons vérifier si tout s’est bien passé en interrogeant l’API HTTP:

curl http://localhost:8529/_api/version

La sortie suivante indique que ArangoDB est opérationnel:

Output{"server":"arango","version":"2.5.5"}

Étape 2 - Accéder à la ligne de commande avec arangosh

ArangoDB est livré avec + arangosh +, un client en ligne de commande qui vous donne un accès complet à la base de données via son environnement d’exécution JavaScript. Vous pouvez l’utiliser pour exécuter des tâches administratives ou des scripts en production.

Il est également bien adapté à la mise en route d’ArangoDB et de ses fonctionnalités principales. Pour suivre, démarrez une session + arangosh + comme ceci:

arangosh

Le résultat est essentiellement un shell JavaScript dans lequel vous pouvez exécuter du code JavaScript arbitraire. Par exemple, ajoutez deux nombres:

23 + 19

Vous obtiendrez ce résultat:

Output42

Si vous souhaitez approfondir ce sujet, tapez + tutorial + dans le shell.

Étape 3 - Ajout d’un utilisateur de base de données

Pour des raisons de sécurité, il est uniquement possible d’ajouter des utilisateurs à partir de l’interface de ligne de commande + arangosh +. Vous devriez toujours être dans le shell + arangosh + de l’étape précédente.

Ajoutons maintenant un nouvel utilisateur, * sammy *. Cet utilisateur aura accès à la base de données complète. C’est OK pour le moment, mais vous souhaiterez peut-être créer des utilisateurs plus limités dans un environnement de production. Utilisez un ++ sécurisé.

require("org/arangodb/users").save("", "");

Maintenant, quittez le shell + arangosh +:

exit

Étape 4 - Configuration de l’interface Web

ArangoDB est livré avec une interface Web très puissante. Il offre des fonctionnalités de surveillance, une navigation dans les données, une documentation interactive sur les API, un puissant éditeur de requêtes et même un logiciel + arangosh + intégré. Nous nous concentrerons sur l’utilisation de l’interface Web pour le rappel de ce tutoriel.

Pour rendre l’interface Web facilement accessible, nous devons procéder à des préparatifs:

  1. Activer l’authentification

  2. Lier ArangoDB à l’interface de réseau public

Activer l’authentification

ArangoDB, comme beaucoup d’autres bases de données NoSQL, est livré avec l’authentification désactivée. Il est * hautement recommandé d’activer l’authentification * si vous exécutez ArangoDB dans un environnement partagé et / ou souhaitez utiliser l’interface Web. Pour plus de détails sur ce sujet, veuillez vous reporter à la ArangoDB documentation.

Activez l’authentification dans le fichier + / etc / arangodb / arangod.conf +. Vous pouvez exécuter cette commande pour créer un fichier de sauvegarde et définir le paramètre + disable-authentication sur` + no + `:

sudo sed -i.bak 's/disable-authentication = yes/disable-authentication = no/g' /etc/arangodb/arangod.conf

Vous pouvez également utiliser un éditeur de texte pour définir le paramètre + disable-authentication + sur + no +.

Redémarrez la base de données:

sudo service arangodb restart

Lier ArangoDB à l’interface de réseau public

Configurez ArangoDB pour écouter sur l’interface réseau publique. Commencez par ouvrir le fichier + / etc / arangodb / arangodb.conf pour le modifier:

sudo nano /etc/arangodb/arangod.conf

Localisez la ligne active + endpoint +, qui devrait se trouver à la fin du bloc + [serveur] + sous une section d’exemples. Mettez à jour le paramètre comme indiqué ci-dessous, en utilisant l’adresse IP de votre propre serveur et le port + 8529 +.

/etc/arangodb/arangod.conf

. . .

endpoint = tcp://:8529

Etant donné que + arangosh + utilise sa propre configuration par défaut, nous devons également modifier le noeud final dans le fichier + / etc / arangodb / arangosh.conf +:

sudo nano /etc/arangodb/arangosh.conf

Encore une fois, assurez-vous que la ligne + endpoint + est définie sur + tcp: //: 8529 +.

/etc/arangodb/arangosh.conf

pretty-print = true

[server]
endpoint = tcp://:8529
disable-authentication = true

. . .

Maintenant redémarrez ArangoDB une fois de plus:

sudo service arangodb restart

Étape 5 - Accès à l’interface Web ArangoDB

Vous devriez maintenant pouvoir accéder à l’interface Web dans votre navigateur:

http://:8529

Veuillez vous connecter avec le nom d’utilisateur et le mot de passe que vous avez créés pour la base de données à l’étape 3.

Le premier écran que vous devriez voir est le tableau de bord avec les métriques de base sur le serveur de base de données:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/iKDjIgx.png [Le tableau de bord de l’interface Web ArangoDB]

Au centre de la barre de navigation supérieure, vous verrez * DB: _system *. Cela indique la base de données actuellement sélectionnée. La valeur par défaut est la base de données + _system +. Certaines tâches administratives ne peuvent être effectuées que dans la base de données + _system +.

Pour les sections suivantes, nous allons créer une base de données avec laquelle travailler. Survolez l’élément de menu * DB: _system * et cliquez sur le lien * Gérer les DB *.

Sur la page suivante, cliquez sur le bouton * Ajouter une base de données *. Remplissez le formulaire pour créer une base de données nommée + music_library +. Vous devez entrer les mêmes nom d’utilisateur et mot de passe que précédemment dans cette boîte de dialogue, sinon vous ne pourrez pas accéder à la nouvelle base de données plus tard:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/DA8kRTO.png [Créer une nouvelle base de données dans l’interface Web]

Nous sommes maintenant prêts à commencer à faire quelque chose avec ArangoDB.

Étape 6 - Effectuer des opérations CRUD avec arangosh

Nous allons quitter l’interface Web pour l’instant et revenir à l’interface de ligne de commande + arangosh + pour couvrir les opérations de base CRUD dans ArangoDB. Nous reviendrons plus loin sur les mêmes opérations dans l’interface Web, mais le faire dans le shell nous aide à mieux comprendre le fonctionnement des choses.

Pour suivre, retournez à la ligne de commande de votre serveur. Connectez-vous à la nouvelle base de données + music_library + en utilisant votre utilisateur et votre mot de passe:

arangosh --server.database music_library --server.username  --server.password

Créer une collection de documents

Si vous venez d’un arrière-plan de base de données relationnelle, une collection est l’équivalent ArangoDB d’une table dans une base de données SQL. Nous allons créer une collection pour stocker des chansons dans notre bibliothèque musicale:

db._createDocumentCollection('songs')

ArangoDB fournit une série de méthodes de gestion des collections. La plupart d’entre eux ne présentent aucun intérêt pour le moment, mais jetez-y un coup d’œil au fur et à mesure que vous avancez dans ArangoDB. Pour le moment, nous allons nous concentrer sur les opérations CRUD (créer, lire, mettre à jour et supprimer), c’est-à-dire comment obtenir des données réelles dans et hors de la base de données.

Création de documents

Si vous avez des lignes dans une base de données SQL, ArangoDB contient Documents. Les documents dans ArangoDB sont des objets JSON. Chaque document est associé à une collection et possède trois attributs principaux: + _id +, + _rev + et + _key +.

Un document est identifié de manière unique dans une base de données par son descripteur document composé du nom de la collection et du signe + _key +, séparés par un + / +. Le descripteur de document est stocké dans le champ + _id + d’un document. + _Key + et + _id + sont similaires à la clé primaire d’une base de données relationnelle.

Ajoutons votre premier document à la collection + songs:

db.songs.save(
{ title: "Immigrant Song", album: "Led Zeppelin III", artist: "Led Zeppelin", year: 1970, length: 143, _key: "immigrant_song" }
)
Output{
 "error" : false,
 "_id" : "songs/immigrant_song",
 "_rev" : "11295857653",
 "_key" : "immigrant_song"
}

L’objet + db + contient toutes les collections en tant que propriétés. Chaque collection fournit des fonctions pour interagir avec les documents de cette collection. La fonction + save + prend n’importe quel objet JSON et le stocke en tant que document dans la collection, en renvoyant les attributs centraux susmentionnés et en indiquant si une erreur s’est produite. Le retour de chaque opération est à nouveau un objet JSON.

Pour avoir quelque chose à jouer, nous avons besoin de plus de documents. Il suffit de copier et coller le prochain extrait pour ajouter plusieurs entrées à la base de données:

db.songs.save(
{album: "Led Zeppelin III", title: "Friends", artist: "Led Zeppelin", year: 1970, length: 235, _key: "friends"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Celebration Day", artist: "Led Zeppelin", year: 1970, length: 209, _key: "celebration_day"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Since I've Been Loving You", artist: "Led Zeppelin", year: 1970, length: 445, _key: "since_i_ve_been_loving_you"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Out On the Tiles", artist: "Led Zeppelin", year: 1970, length: 244, _key: "out_on_the_tiles"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Gallows Pole", artist: "Led Zeppelin", year: 1970, length: 298, _key: "gallows_pole"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Tangerine", artist: "Led Zeppelin", year: 1970, length: 192, _key: "tangerine"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "That's the Way", artist: "Led Zeppelin", year: 1970, length: 338, _key: "that_s_the_way"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Bron-Y-Aur Stomp", artist: "Led Zeppelin", year: 1970, length: 260, _key: "bron_y_aur_stomp"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Hats Off to (Roy) Harper", artist: "Led Zeppelin", year: 1970, length: 221, _key: "hats_off_to_roy_harper"}
);

Lecture de documents

Pour récupérer un document, vous pouvez utiliser le descripteur de document ou le + _key +. L’utilisation du descripteur de document n’est requise que si vous ne parcourez pas la collection elle-même. Avec une collection, vous pouvez utiliser la fonction + document:

db.songs.document('immigrant_song');
Output{
 "year" : 1970,
 "length" : 143,
 "title" : "Immigrant Song",
 "album" : "Led Zeppelin III",
 "artist" : "Led Zeppelin",
 "_id" : "songs/immigrant_song",
 "_rev" : "11295857653",
 "_key" : "immigrant_song"
}

Maintenant que nous pouvons créer et lire des documents, nous allons voir comment les modifier:

Mise à jour des documents

Pour mettre à jour vos données, vous avez deux options: https://docs.arangodb.com/Documents/DocumentMethods.html#replace [+ replace +] et https://docs.arangodb.com/Documents/DocumentMethods. .html # update [+ update +].

La fonction + replace + remplacera le document entier par un nouveau, même si vous fournissez des attributs complètement différents.

La fonction + update +, par contre, corrigera simplement un document en le fusionnant avec les attributs donnés. Essayons d’abord une mise à jour moins destructive, dans laquelle nous mettons à jour le `genre’ de l’une de nos chansons:

db.songs.update("songs/immigrant_song",

{ genre: "Hard Rock" }

);

Jetons un coup d’œil à l’entrée de la chanson mise à jour:

db.songs.document("songs/immigrant_song");
Output{
 "year" : 1970,
 "length" : 143,
 "title" : "Immigrant Song",
 "album" : "Led Zeppelin III",
 "artist" : "Led Zeppelin",
 "genre" : "Hard Rock",
 "_id" : "songs/immigrant_song",
 "_rev" : "11421424629",
 "_key" : "immigrant_song"
}

La fonction + update + est particulièrement utile lorsque vous avez un document volumineux et que vous ne devez mettre à jour qu’un petit sous-ensemble de ses attributs.

En revanche, utiliser le même JSON avec la fonction + replace + détruira vos données.

db.songs.replace("songs/immigrant_song",

{ genre: "Hard Rock" }

);

Voir la chanson mise à jour maintenant:

db.songs.document("songs/immigrant_song")

Comme vous pouvez le constater, les données d’origine ont été supprimées du document:

Output{
 "genre" : "Hard Rock",
 "_id" : "songs/immigrant_song",
 "_rev" : "11495939061",
 "_key" : "immigrant_song"
}

Supprimer des documents

Pour supprimer un document d’une collection, appelez la fonction + remove + avec le descripteur de document:

db.songs.remove("songs/immigrant_song")

Bien que le shell + arangosh + soit un excellent outil, il est encombrant pour explorer les autres fonctionnalités d’ArangoDB. Nous examinerons ensuite l’interface Web intégrée pour approfondir ses capacités.

Étape 7 - Opérations CRUD avec l’interface Web

Nous avons vu comment gérer les documents sur le + arangosh +, et maintenant nous retournons à l’interface Web. Visitez + http: //: 8529 / _db / music_library + dans votre navigateur.

Créer une collection de documents

Cliquez sur l’onglet * Collections * dans la barre de navigation supérieure.

Vous pouvez voir la collection + songs + existante que nous avons ajoutée à partir de la ligne de commande; n’hésitez pas à cliquer dessus et à visualiser les entrées, si vous le souhaitez.

Dans la page principale * Collections *, cliquez sur le bouton * Ajouter une collection *.

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/V05LxrP.png [Ajouter une collection dans l’interface Web]

Puisque nous avons déjà + chansons +, nous ajouterons une collection + albums +. Entrez + albums + comme * Nom * dans la boîte de dialogue * Nouvelle collection * qui est apparue. Le type par défaut, * Document *, est correct.

Cliquez sur * Enregistrer * et vous devriez voir maintenant deux collections sur la page.

Cliquez sur la collection + albums +. Vous êtes présenté avec une collection vide:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/d8qIcmh.png [Vue de la collection]

Création de documents

Cliquez sur le signe * + * dans le coin supérieur droit pour ajouter un document. On vous demandera d’abord un + _key +. Entrez + led_zeppelin_III + comme clé.

Ensuite, il y a un formulaire où vous pouvez éditer le contenu d’un document. Il existe un moyen graphique d’ajouter des attributs appelés * Arbre *, mais pour l’instant, passez à la vue * Code * en le sélectionnant dans le menu déroulant * Arbre *:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/0DfPNao.png [Créer un document]

Veuillez copier et coller le JSON suivant dans la zone d’édition (assurez-vous de n’utiliser qu’un seul jeu d’accolades):

{
"name": "Led Zeppelin III",
"release_date": "1970-10-05",
"producer": "Jimmy Page",
"label": "Atlantic",
"length": 2584
}

Sachez qu’il est nécessaire de citer les clés dans ce mode. Une fois que vous avez terminé, cliquez sur le bouton * Enregistrer *. La page doit clignoter en vert pendant un moment pour indiquer que la sauvegarde a réussi.

Lecture de documents

Vous devez revenir manuellement à la page * Collections * après avoir enregistré le nouveau document.

Si vous cliquez sur la collection + albums +, vous verrez la nouvelle entrée.

Mise à jour des documents

Pour éditer le contenu d’un document, cliquez simplement sur la ligne que vous souhaitez éditer dans la vue d’ensemble du document. Vous serez présenté avec le même éditeur que lors de la création de nouveaux documents.

Supprimer des documents

La suppression de documents est aussi simple que d’appuyer sur l’icône * - * à la fin de chaque ligne de document. Confirmez la suppression lorsque vous y êtes invité.

De plus, la page de présentation * Collections * d’une collection spécifique vous permet d’exporter et d’importer des données, de gérer des index et de filtrer les documents.

Comme mentionné précédemment, l’interface Web a beaucoup à offrir. Ce didacticiel ne couvre pas toutes les fonctionnalités. Vous êtes donc invité à explorer les autres fonctionnalités par vous-même. Nous allons creuser dans une autre fonctionnalité de ce tutoriel: l’éditeur AQL.

Étape 8 - Interrogation des données avec AQL

Comme mentionné dans l’introduction, ArangoDB est fourni avec un langage de requête complet appelé AQL.

Pour interagir avec AQL dans l’interface Web, cliquez sur l’onglet * AQL Editor * dans la barre de navigation supérieure. Vous serez présenté avec un éditeur vierge.

Pour basculer entre l’éditeur et la vue des résultats, utilisez les onglets * Query * et * Result * situés dans le coin supérieur droit:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/eKTShDh.png [L’éditeur AQL]

L’éditeur a la coloration syntaxique, la fonctionnalité annuler / rétablir et l’enregistrement des requêtes. La section suivante explore certaines des fonctionnalités d’AQL. Pour une référence complète, visitez la comprehensive documentation.

Bases AQL

AQL est un langage déclaratif, ce qui signifie qu’une requête exprime quel résultat doit être obtenu mais pas comment. Il permet de rechercher des données mais également de les modifier. Les deux approches peuvent être combinées pour réaliser des tâches complexes.

La lecture et la modification de requêtes dans AQL sont entièrement compatibles ACID. Les opérations se termineront en totalité ou pas du tout. Même la lecture des données se produira sur un instantané cohérent des données.

Nous recommençons avec la création de données. Ajoutons plus de chansons à notre collection + chansons +. Il suffit de copier et coller la requête suivante:

FOR song IN [

{ album: "Led Zeppelin", title: "Good Times Bad Times", artist: "Led Zeppelin", length: 166, year: 1969, _key: "good_times_bad_times" }

,

{ album: "Led Zeppelin", title: "Dazed and Confused", artist: "Led Zeppelin", length: 388, year: 1969, _key: "dazed_and_confused" }

,

{ album: "Led Zeppelin", title: "Communication Breakdown", artist: "Led Zeppelin", length: 150, year: 1969, _key: "communication_breakdown" }

]

INSERT song IN songs

Cliquez sur le bouton * Soumettre *.

Cette requête est déjà un bon exemple du fonctionnement d’AQL: vous parcourez une liste de documents avec + FOR + et effectuez une opération sur chacun des documents. La liste peut être un tableau avec des objets JSON ou toute collection de votre base de données. Les opérations incluent le filtrage, la modification, la sélection de documents supplémentaires, la création de nouvelles structures ou (comme dans cet exemple) l’insertion de documents dans la base de données. En fait, AQL prend également en charge toutes les opérations CRUD.

Pour obtenir une vue d’ensemble de tous les morceaux de la base de données, exécutez la requête suivante. C’est l’équivalent d’un + SELECT * FROM chansons + dans une base de données basée sur SQL (puisque l’éditeur se souvient de la dernière requête, vous devez cliquer sur l’icône * poubelle * pour effacer l’éditeur):

FOR song IN songs RETURN song

Vous verrez maintenant toutes les entrées de la base de données de chansons dans le champ de texte. Retournez à l’onglet * Query * et effacez à nouveau l’éditeur.

Un autre exemple concerne le filtrage de base des chansons d’une durée supérieure à trois minutes:

FOR song IN songs

FILTER song.length > 180

RETURN song

Le résultat est présenté dans l’onglet * Résultat * de l’éditeur:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/tFZRf5R.png [Résultat de la requête]

Exemple AQL complexe

AQL est fourni avec un ensemble de fonctions https://docs.arangodb.com/Aql/Functions.html] pour tous les types de données pris en charge et permet même l’ajout https://docs.arangodb.com/AqlExtending de nouvelles fonctions] . Combiné à la possibilité d’affecter des variables à une requête, vous pouvez construire des constructions très complexes. Cela vous permet de rapprocher les opérations gourmandes en données des données elles-mêmes plutôt que de les exécuter sur le client. Pour illustrer cela, nous allons formater la durée d’une chanson en tant que + mm: ss + pour la rendre lisible pour l’utilisateur:

FOR song IN songs

FILTER song.length > 180

LET minutes = FLOOR(song.length / 60)

LET seconds = song.length % 60

RETURN

{ title: song.title, duration: CONCAT_SEPARATOR(':', minutes, seconds) }

Cette fois, nous allons simplement retourner le titre de la chanson avec la durée. + RETURN + vous permet de créer un nouvel objet JSON à renvoyer pour chaque document d’entrée.

AQL est un langage complexe avec beaucoup de fonctionnalités. Mais il y a une autre fonctionnalité qui mérite d’être mentionnée, en particulier dans le contexte des bases de données NoSQL: les jointures.

Jointure en AQL

L’utilisation d’un magasin de documents en tant que base de données a plusieurs conséquences. Vous devez modéliser vos données de manière différente de celle que vous utiliseriez avec une base de données relationnelle.

Dans un magasin de documents, vous avez la possibilité d’intégrer des données qui seraient autrement modélisées sous forme de relation, mais cette approche n’est pas toujours réalisable. Il y a des cas où une relation a beaucoup plus de sens. Sans la possibilité de laisser la base de données effectuer les jointures requises, vous finissez par joindre les données sur le client ou par dénormaliser votre modèle de données et en incorporant des sous-documents. Cela devient particulièrement problématique pour les ensembles de données complexes et volumineux.

Alors, faisons une jointure.

Pour illustrer cette fonctionnalité, nous allons remplacer l’attribut + album + des morceaux par une référence à la collection + albums +. Nous avons déjà créé l’album Led Zeppelin III en tant que document auparavant. Veuillez revenir en arrière et ré-ajouter l’album si vous l’avez supprimé lors de l’exemple précédent.

Cette requête aura pour astuce:

FOR album IN albums

FOR song IN songs

FILTER song.album == album.name

LET song_with_album_ref = MERGE(UNSET(song, 'album'),

{ album_key: album._key }

)

REPLACE song WITH song_with_album_ref IN songs

Nous parcourons d’abord tous les albums, puis toutes les chansons auxquelles cet album est associé. L’étape suivante consiste à créer un nouveau document contenant les attributs + album_key + et + UNSET + l’attribut + album +. Nous utiliserons + REPLACE et non` + UPDATE` pour mettre à jour les documents de morceau. Ceci est possible parce que nous avons créé un nouveau document de chanson auparavant.

Après cette migration de données, nous pouvons maintenant conserver le document d’album à un endroit. Lors de la récupération des données de morceau, nous pouvons utiliser une jointure pour ajouter à nouveau le nom de l’album aux documents de morceau:

FOR song IN songs

FOR album IN albums

FILTER album._key == song.album_key

RETURN MERGE(song,

{ album: album.name }

)

Nous avons à peine effleuré la surface de ce qui peut être accompli avec AQL, mais vous devriez avoir une bonne idée de ce qui est possible. Pour une référence complète sur le langage et d’autres exemples, reportez-vous à la vaste documentation.

(Facultatif) Étape 9 - Effectuer des sauvegardes

Vous devriez commencer à penser aux sauvegardes une fois que vous avez mis en production une base de données ArangoDB. C’est une bonne pratique d’établir des sauvegardes avant cela, cependant.

Utiliser la fonctionnalité Backup de DigitalOcean est un bon début. De plus, vous voudrez peut-être envisager d’utiliser https://docs.arangodb.com/Arangodump [+ arangodump +] et https://docs.arangodb.com/Arangorestore [+ arangorestore +] pour obtenir des informations plus détaillées contrôle sur ce qu’il faut sauvegarder et où stocker les sauvegardes.

(Facultatif) Étape 10 - Mise à niveau

Lorsqu’une nouvelle version d’ArangoDB est publiée, elle sera publiée via le référentiel de packages configuré. Pour installer la dernière version, vous devez d’abord mettre à jour l’index du référentiel:

sudo apt-get update

Maintenant, arrêtez la base de données:

sudo service arangodb stop

Mettez-le à jour avec la dernière version:

sudo apt-get install arangodb

Vous devrez peut-être mettre à niveau les fichiers de base de données eux-mêmes:

sudo service arangodb upgrade

Après cela, démarrez le serveur comme d’habitude:

sudo service arangodb start

Extension d’ArangoDB avec des applications Foxx

Avant de terminer, il convient de mentionner une dernière chose: étant donné qu’ArangoDB dispose d’un moteur V8 intégré pour gérer tout le JavaScript et d’un serveur HTTP intégré, nous pouvons étendre l’API HTTP existante avec des points de terminaison personnalisés. Cette fonctionnalité s’appelle Foxx.

Foxx est une structure qui permet à ArangoDB de créer des microservices personnalisés avec des données persistantes. Les applications Foxx sont écrites en JavaScript et exécutées dans le contexte ArangoDB V8. L’application dispose d’un accès direct à l’interface JavaScript native et peut donc accéder aux données sans allers-retours HTTP. Foxx fournit un cadre minimal dans le sens de Sinatra pour Ruby ou de Flask pour Python. Vous écrivez des contrôleurs pour gérer les demandes entrantes et implémenter la logique métier à l’intérieur de modèles.

Les applications Foxx peuvent être gérées via l’interface Web et peuvent être développées comme n’importe quelle autre application. Vous pouvez les placer sous contrôle de version et même les déployer directement à partir d’un référentiel Git. Comme ils ne sont que JavaScript, les tests unitaires sont simples. Pour les cas d’utilisation simples, elles ressemblent beaucoup aux procédures stockées dans un système de base de données relationnelle, mais le code Foxx est beaucoup plus facile à gérer et à tester.

L’utilisation d’applications Foxx en tant que procédures stockées n’est qu’un début. Imaginez que vous avez plusieurs applications partageant certaines logiques d’entreprise. Avec Foxx, vous pouvez rapprocher cette logique métier des données pour accélérer le traitement et réduire la complexité de la répartition de la mise en œuvre partagée entre les composants. L’exécution d’ArangoDB en tant que cluster permet même de rendre les applications Foxx disponibles sur chaque membre du cluster.

Même des applications Web entières sont possibles avec Foxx. L’utilisation de frameworks frontaux tels que Angular ou Ember vous permet d’exécuter des applications entièrement à partir de la base de données. Aucune infrastructure supplémentaire n’est nécessaire pour cela. Dans un environnement de production, vous placerez éventuellement Nginx ou un logiciel similaire devant ArangoDB. ArangoDB est livré avec certaines applications Foxx qui fournissent des fonctionnalités communes, telles que l’authentification et un magasin de sessions. Vous pouvez même utiliser des packages npm s’ils ne reposent pas sur la fonctionnalité HTTP.

Pour une bonne introduction à Foxx, veuillez vous référer à ce cookbook.

Conclusion

ArangoDB est une base de données puissante avec un large éventail de cas d’utilisation pris en charge. Il est bien entretenu et possède une très bonne documentation. Il est facile de commencer à utiliser ce logiciel car il existe des packages pour chaque système d’exploitation principal. L’interface Web réduit la charge d’exploration des fonctionnalités et, si vous venez d’un contexte relationnel, utiliser AQL n’est pas si différent de l’utilisation de SQL.

En disposant de la possibilité d’étendre la base de données avec des applications JavaScript et des fonctionnalités graphiques, ArangoDB est un package complet pour démarrer et développer une application.

Jusqu’ici, nous avons partagé la grande image d’ArangoDB.

Comme prochaines étapes, nous suggérons ce qui suit:

  • Pour toute application réelle, vous allez interagir avec l’API HTTP. Nous ne l’avons pas couvert ici, car vous ne l’utiliserez probablement pas directement, mais par l’un des nombreux pilotes de langue native.

  • L’interaction avec les données dans ArangoDB s’effectue la plupart du temps via AQL. Il est indispensable de vous y habituer si vous souhaitez utiliser ArangoDB dans un environnement de production.

  • ArangoDB n’est pas seulement un magasin de documents, mais dispose également de fonctionnalités de graphes très puissantes. Il vous permet de modéliser vos données sous forme de sommets dans un graphique dirigé. Les relations peuvent être modélisées comme des arêtes entre ces sommets au lieu d’utiliser des références + _key +. La modélisation de vos données de cette manière présente des avantages] par rapport à l’approche relationnelle utilisée dans les bases de données SQL.

Related