Tutoriel Meteor : Créer des applications Web en temps réel avec Meteor

Publié: 2022-03-11

Meteor est un framework JavaScript complet pour les applications Web et mobiles. Il existe depuis 2011 et a acquis une solide réputation parmi les développeurs de Meteor comme étant une solution idéale et facile à utiliser pour le prototypage rapide. Cependant, ces derniers temps, les développeurs ont réalisé que Meteor n'était plus seulement destiné au prototypage : il était prêt à être utilisé pour le développement commercial. Avec l'arsenal de packages qu'il fournit, la base solide mongoDB/node.js sur laquelle il s'appuie et la flexibilité de codage qu'il offre ; Meteor facilite la création d'applications Web en temps réel robustes et sécurisées, gérant tout, de l'application de navigateur au serveur ou à la base de données.

Ce didacticiel Meteor vous guidera dans la création d'une application Web de base dans Meteor - un catalogue simple qui permet aux utilisateurs de se connecter et de gérer une liste de livres.

Pourquoi utiliser Météor ? La réponse courte est "parce que Meteor est amusant". Il simplifie le développement d'applications Web. Il est facile à apprendre et vous permet de vous concentrer davantage sur les fonctionnalités de votre application que sur les bases de la synchronisation des données et du service des pages.

Il intègre également de nombreux comportements. Meteor effectue automatiquement des mises à jour en direct, de sorte que les modifications de données s'affichent immédiatement dans la fenêtre de votre navigateur, et même les modifications de code apportées à l'application elle-même sont transmises à tous les navigateurs et appareils en « temps réel ». Meteor a une compensation de latence intégrée, est facile à déployer et propose des « packages » faciles à installer qui gèrent toutes sortes de fonctionnalités.

Même s'il s'agit d'un cadre relativement nouveau, de nombreuses startups créent déjà des applications Meteor, y compris des services à relativement grande échelle comme Respondly et Telescope.

Installation de météores et échafaudages

L'installation de Meteor sur les systèmes *nix est une ligne :

 curl https://install.meteor.com/ | sh

Bien qu'il n'y ait toujours pas de support officiel, leur aperçu pour Windows se déroule bien. Selon les rumeurs, le support Windows sera livré avec la version 1.1, prévue pour avril ou mai 2015. Comme vous pouvez vous y attendre d'un framework intelligent comme Meteor, le démarrage d'une application nécessite l'appel d'une seule ligne de commande :

 meteor create book-list

Cela créera un répertoire nommé "book-list" et le remplira avec du code passe-partout et dépendant. Pour exécuter l'application, entrez dans le répertoire nouvellement créé et exécutez :

 meteor

Ouvrez http://localhost:3000 dans votre navigateur Web et vous verrez ce qui suit :

Vous pouvez également consulter la "version 0" de notre application sur MeteorPad, un site du genre JSFiddle pour Meteor : Liste des livres : App par défaut

Meteor stocke ses vues dans des fichiers HTML. Si nous ouvrons « book-list.html », nous verrons :

 <head> <title>book-list</title> </head> <body> <h1>Welcome to Meteor!</h1> {{> hello}} </body> <template name="hello"> <button>Click Me</button> <p>You've pressed the button {{counter}} times.</p> </template>

Meteor utilise "Blaze", un moteur de template, pour rendre les réponses à partir de ces fichiers HTML. Les doubles accolades devraient être familières à tous ceux qui ont utilisé Handlebars.js (ou d'autres moteurs de modèles similaires), et elles remplissent ici une fonction similaire. Blaze examine les expressions à l'intérieur de chaque paire d'accolades doubles et remplace chacune par la valeur que ces expressions produisent.

Ce programme d'exemple simple n'a que deux expressions entre accolades :

Le premier, "{{> hello}}", indique à Blaze d'inclure un modèle appelé "hello". Ce modèle est défini au bas du fichier, dans la section <template name="hello">.
Le second, "{{counter}}", est un peu plus compliqué. Pour voir d'où vient cette valeur de "compteur", nous devons ouvrir "book-list.js":

 if (Meteor.isClient) { // counter starts at 0 Session.setDefault('counter', 0); Template.hello.helpers({ counter: function () { return Session.get('counter'); } }); Template.hello.events({ 'click button': function () { // increment the counter when button is clicked Session.set('counter', Session.get('counter') + 1); } }); } if (Meteor.isServer) { Meteor.startup(function () { // code to run on server at startup }); }

Certaines choses méritent d'être expliquées ici. Tout d'abord, la division en "if (Meteor.isClient)" et "if (Meteor.isServer)". Rappelez-vous que meteor est un framework full-stack, donc le code que vous écrivez est exécuté à la fois sur le serveur et sur le client. Ces conditions nous permettent de limiter cela : le premier bloc ne s'exécute que sur le client, et le second ne s'exécute que sur le serveur.

Deuxièmement, il y a l'appel "Session.setDefault" - cela initialise une variable de session appelée "counter" dans le navigateur. Les variables de session agissent un peu comme des globales dans Meteor (pour le meilleur et pour le pire). Cependant, cette variable de session n'apparaît pas directement dans "{{counter}}". Au lieu de cela, cette expression "counter" est un "helper", celui qui est défini dans la section "Template.hello.helpers". Cet assistant saisit simplement la valeur de la variable de session et la renvoie.

Notez que l'assistant est "réactif". Cela signifie qu'à chaque fois que la variable de session change, Meteor réexécute automatiquement cette fonction d'assistance qui y fait référence, et Blaze met automatiquement à jour le navigateur avec le nouveau contenu.

Le code client surveille également les événements, via "Template.hello.events". Nous identifions l'événement par type d'événement et sélecteur (dans ce cas, "cliquez sur le bouton"), puis indiquons à Meteor ce que cet événement doit faire. Dans ce cas, la variable de session est incrémentée, ce qui réexécute la fonction d'assistance et restitue à son tour le contenu.

Affichage des données statiques

Tout cela est bien beau, mais ce n'est pas l'application Meteor que nous souhaitons pour ce tutoriel.

Commençons à peaufiner cette application - nous afficherons une liste de livres statique et codée en dur. Pour l'instant, nous allons stocker la liste des livres dans une variable de session. Dans le code « isClient », nous utiliserons « Template.hello.rendered » pour définir la variable de session dès que le modèle bookList sera rendu :

 Template.hello.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); };

Ensuite, nous renvoyons cette variable de session avec un nouvel assistant dans le modèle "hello":

 Template.hello.helpers({ books: function () { return Session.get('books'); } });

Et affichez-le à l'écran via une interpolation variable dans le modèle "hello":

 <template name="hello"> <h3>Here are your books:</h3> {{ books }} </template>

Vous pouvez consulter ce code en action sur Meteorpad : Liste de livres : Afficher la variable de session

La première chose à remarquer est que le serveur Meteor a automatiquement détecté les modifications apportées à notre base de code, a envoyé le nouveau code aux clients et a invité le client à recharger. Même après avoir déployé une application, nous pouvons déployer des modifications et mettre à jour automatiquement nos clients via des pushs de code à chaud.

déployer les modifications automatiquement

Pour l'instant, voici ce que nous obtenons :

Oups, nous affichons les données de manière incorrecte. Blaze obtient des points pour la précision ici (pourquoi oui, c'est un tableau d'objets), mais nous allons devoir être un peu plus intelligents si nous voulons afficher notre liste de livres de manière utile. Heureusement, Blaze permet de travailler très facilement avec des tableaux de données en utilisant la directive "#each":

 <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL>

Dans Blaze, "#each" fonctionne un peu comme la directive "ng-repeat" d'Angular : elle parcourt la structure du tableau, définissant le contexte actuel sur l'objet actuel du tableau et affichant à plusieurs reprises le code HTML à l'intérieur du "{{#each …}}". Voici à quoi ressemble notre liste de livres maintenant :

Sur MeteorPad : afficher correctement la variable de session

Un peu de nettoyage

Avant d'aller plus loin, nettoyons un peu notre code.

Meteor laisse une marge de manœuvre considérable dans la façon dont vous organisez votre base de code. Comme vous le verrez, il n'y a que quelques règles strictes : où que vous mettiez votre code HTML et JavaScript, Meteor le trouvera. Cette flexibilité est agréable, mais cela signifie qu'il vous incombe davantage d'organiser votre code d'une manière qui a du sens, de sorte que vous n'êtes pas coincé à maintenir un gâchis désordonné géant.

Tout d'abord, renommons ce modèle "hello" en quelque chose de significatif, comme "bookList", et remplaçons le HTML standard par ceci :

 <head> <title>book-list</title> </head> <body> {{> bookList}} </body> <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>

Deuxièmement, divisons les parties "client" et "serveur" en fichiers séparés. Dans notre répertoire d'application, nous allons configurer un sous-répertoire "client" et un sous-répertoire "serveur" - Meteor saura automatiquement exécuter les fichiers "/client/" sur le client, et exécuter les fichiers "/server/" sur le serveur. C'est une bonne convention de mettre le code du modèle dans un fichier JavaScript nommé d'après le modèle, alors mettons notre code client dans « client/bookList.js ». Nous pouvons mettre notre code de démarrage de serveur actuellement vide dans "server/startup.js". Enfin, sortons le "

Notez que même après tous ces changements, Meteor trouvera toujours automatiquement tous nos fichiers HTML et JavaScript. Tant qu'un fichier se trouve quelque part dans "/client/", Meteor saura l'exécuter sur le client. Tant qu'un fichier se trouve quelque part dans "/server/", meteor saura l'exécuter sur le serveur. Encore une fois, c'est au développeur de garder les choses organisées.

Alors maintenant, notre code devrait ressembler à ceci :

liste-de-livres.html :

 <head> <title>book-list</title> </head> <body> {{> bookList}} </body>

client/bookList.html :

 <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>

client/bookList.js :

 Template.bookList.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); }; Template.bookList.helpers({ books: function () { return Session.get('books'); } });

serveur/startup.js :

 Meteor.startup(function () { // code to run on server at startup }); ~~~ Check it out on MeteorPad: [Initial Code Cleanup](http://meteorpad.com/pad/MwvMcsBAzfbWwEXp3/Book-List:%20Initial%20Code%20Cleanup) Verify that everything's running correctly by checking the browser window and then we're good to move on to the next step. ## Using the Database in Meteor The Meteor server runs on top of a MongoDB database. In this section of our tutorial, we will move the static list of books out of the session variable and into that database. First, delete the Template.bookList.rendered code, so that we're no longer putting stuff into that session variable. Next, we should add that list of books to the database as fixture data when the server initializes. As you'd expect for MongoDB, Meteor stores data in "collections". So, we'll create a new collection for our books. To keep things simple we will name it "books". It turns out that both the client and the server will want to know about this collection, so we'll put this code in a new subfolder: "/lib/". Meteor knows automatically that files in "/lib/" run on the client and the server. We'll create a file called "lib/collections/books.js", and give it just one line of code: ~~~ js Books = new Meteor.Collection("books");

Dans la fenêtre du navigateur pointée sur http://localhost:3000, accédez à la console développeur et vérifiez la valeur de "Livres". Il devrait maintenant s'agir d'une collection Mongo ! Essayez d'exécuter "Books.find().fetch()", et vous obtiendrez un tableau vide - ce qui est logique, puisque nous n'y avons pas encore ajouté de livres. Nous pouvons essayer d'y ajouter des éléments dans la console :

 Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"})

Ajouter des choses dans la console est assez fastidieux. Au lieu de cela, nous allons configurer les choses de sorte que lorsque le serveur démarre, nous insérons automatiquement les données des projecteurs dans la base de données. Revenons donc à "server/startup.js", et ajoutons ceci :

 Meteor.startup(function () { if (!Books.findOne()) { Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"}); Books.insert({title: "1984", author: "George Orwell"}); Books.insert({title: "The Lord of the Rings", author: "JRR Tolkien"}); Books.insert({title: "The Catcher in the Rye", author: "JD Salinger"}); Books.insert({title: "The Great Gatsby", author: "F. Scott Fitzgerald"}); } });

Maintenant, lorsque le serveur démarre, s'il n'y a pas de données présentes, nous ajouterons les données du projecteur. Nous pouvons le vérifier en retournant sur notre terminal, en arrêtant le serveur météore et en exécutant cette commande :

 meteor reset

Remarque : vous aurez rarement besoin de cette commande, car elle réinitialise - c'est-à-dire efface - la base de données utilisée par Meteor. Si votre application Meteor contient des données utilisateur dans la base de données, vous ne devez pas exécuter cette commande. Mais dans ce cas, nous allons simplement effacer toutes les données de test dont nous disposons.

Maintenant, nous allons redémarrer le serveur :

 meteor

Au démarrage, Meteor exécutera la routine de démarrage, vérifiera que la base de données est vide et ajoutera les données du projecteur. À ce stade, si nous allons sur la console et tapons "Books.find().fetch()", nous obtenons les cinq livres que nous avions auparavant.

Il ne reste plus pour cette étape que l'affichage des livres à l'écran. Heureusement, c'est aussi simple que de remplacer "return Session.get('books');" avec ce qui suit dans l'assistant "livres":

 return Books.find();

Et nous reprenons nos activités ! L'application affiche désormais les données d'un curseur de base de données, au lieu de celles de la variable de session.

Découvrez-le sur MeteorPad : Passer à la base de données

Problèmes de sécurité

Je vais commencer par dire : « ne fais pas ça ».

Selon vous, que se passerait-il si quelqu'un lançait cette application dans son navigateur, se rendait sur la console et tapait "Books.remove({})" ?

La réponse est : ils anéantiraient la collection.

C'est donc un problème de sécurité assez important - nos utilisateurs ont trop accès à notre base de données. N'importe quel client peut accéder à l'ensemble de la base de données. De plus, n'importe quel client peut apporter n'importe quelle modification à l'ensemble de la base de données, y compris l'effacement des données ".remove({})".

Ce n'est pas bon, alors corrigeons-le.

Meteor utilise ce qu'on appelle des "packages" pour ajouter des fonctionnalités. Ce que les modules sont pour Node.js et les gemmes pour Ruby, les packages sont un ensemble de fonctionnalités pour Meteor. Il existe des forfaits pour toutes sortes de choses. Pour parcourir ce qui est disponible, consultez atmosphere.js.

L'application météore par défaut que nous avons créée avec "meteor create" comprend deux packages appelés "autopublish" et "insecure". Le premier package permet aux clients d'avoir un accès automatique à l'ensemble de la base de données, et le second permet aux utilisateurs d'effectuer n'importe quelle action sur cette base de données.

Supprimons ceux-ci. Nous pouvons le faire en exécutant ce qui suit à partir du répertoire de l'application :

 meteor remove autopublish insecure

Lorsque cela est fait, vous verrez les données de la liste de livres disparaître de l'écran (puisque vous n'y avez plus accès), et si vous essayez un appel "Books.insert", vous obtiendrez l'erreur : "insert failed : Accès refusé". Sur MeteorPad : sécurité excessive

Si vous ne prenez rien d'autre de ce didacticiel Meteor, souvenez-vous de ceci : lorsque vous déployez une application Meteor, assurez-vous de supprimer les packages de publication automatique et non sécurisés. Meteor a de nombreuses bonnes précautions de sécurité, mais toutes ne servent à rien si vous laissez ces deux packages installés.

Alors, pourquoi Meteor inclut-il automatiquement ces packages, s'ils présentent un tel danger pour la sécurité ? La raison en est que, en particulier pour les débutants, ces deux packages facilitent le démarrage - vous pouvez facilement déboguer et modifier la base de données à partir de la console d'un navigateur. Mais c'est une bonne pratique d'abandonner la publication automatique et l'insécurité dès que possible.

Publier et s'abonner

Nous avons donc corrigé cette faille de sécurité béante, mais nous avons introduit deux problèmes. Premièrement, nous n'avons plus accès à la base de données. Deuxièmement, nous n'avons aucun moyen d'interagir avec la base de données.

Abordons ici le premier problème. Meteor fournit un accès sécurisé à une base de données en demandant au serveur de « publier » un sous-ensemble de la base de données et en demandant au client de « s'abonner » à cette publication.

Commençons par créer "/server/publications.js":

 Meteor.publish('books', function() { return Books.find({}); });

Et nous allons créer "/client/subscriptions.js":

 Meteor.subscribe('books');

Découvrez-le sur MeteorPad : Publiez et abonnez-vous

Le serveur « publie » un curseur qui a accès à toutes les données, et le client « s'y abonne » à l'autre bout. Le client utilise cet abonnement pour remplir une copie miroir de la base de données avec toutes les données du curseur. Lorsque nous accédons à "Books.find().fetch()", nous voyons les cinq objets et nous les voyons affichés à l'écran comme auparavant.

La différence maintenant est qu'il est vraiment facile de limiter ce à quoi les clients peuvent accéder. Essayez de remplacer la publication "find()" par un sous-ensemble de données :

 Meteor.publish('books', function() { return Books.find({}, {limit:3}); });

Maintenant, le client ne voit que trois des cinq livres, et il n'y a aucun moyen d'accéder au reste. Non seulement c'est une aubaine pour la sécurité (je ne vois pas les comptes bancaires de tout le monde), mais vous pouvez l'utiliser pour répartir les données et éviter de surcharger un client.

Ajout de nouveaux livres

Nous avons vu comment donner aux clients un accès en lecture à la base de données de manière limitée et sécurisée. Maintenant, regardons le deuxième problème : comment laisser les utilisateurs modifier la base de données sans leur permettre de faire ce qu'ils veulent ? En se débarrassant du paquet non sécurisé, les clients n'ont aucun accès - essayons à nouveau d'autoriser l'ajout de livres. Dans Meteor, nous faisons cela en ajoutant une "méthode" au serveur. Ajoutons une méthode, qui ajoute un nouveau livre, à "/lib/collections/books.js":

 Meteor.methods({ addBook: function(bookData) { var bookID = Books.insert(bookData); return bookID; } });

Comme vous pouvez le voir, cela prend "bookData" - dans ce cas, c'est un objet avec des champs "title" et "author" - et l'ajoute à la base de données. Une fois votre client rechargé, nous pouvons alors appeler cette méthode depuis le client. Vous pouvez aller sur la console et entrer quelque chose comme ceci :

 Meteor.call('addBook', {title: "A Tale of Two Cities", author: "Charles Dickens"})

Et hop ! Vous obtenez un autre livre sur la liste des livres. L'utilisation de la console est intolérablement maladroite, alors allons-y et ajoutons un formulaire simple à la fin du modèle "bookList" qui nous permettra d'ajouter de nouveaux livres :

 <form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form>

Et nous pouvons connecter cela à JavaScript en utilisant un cas d'événement, comme nous l'avions dans l'application de test d'origine :

 Template.bookList.events({ "submit .add-book": function(event) { event.preventDefault(); // this prevents built-in form submission Meteor.call('addBook', {title: event.target.title.value, author: event.target.author.value}) } });

Vous pouvez voir cela en action sur MeteorPad : Méthodes

Lorsque nous avions mis en place une publication non sécurisée et automatique, les clients pouvaient accéder à l'ensemble de la base de données et la modifier. Maintenant que l'insécurité et la publication automatique ont disparu, mais avec les publications, les abonnements et les méthodes, les clients peuvent accéder à la base de données et interagir avec elle de manière contrôlée.

En passant : vous pouvez également résoudre les problèmes de sécurité dans Meteor en utilisant les « règles d'autorisation et de refus ». Vous pouvez en savoir plus sur ceux-ci et sur certaines raisons pour lesquelles je préfère l'approche ci-dessus à la place sur Discovermeteor.com.

Authentification d'utilisateur

Il peut sembler que nous venons de revenir à notre point de départ, mais il y a une différence importante : il est maintenant très facile pour nous de limiter l'accès à la base de données. Pour voir comment cela fonctionne, essayons d'ajouter des utilisateurs à cette application. Nous ajouterons un système de connexion à notre application, puis au lieu que tous les clients travaillent avec une seule liste de livres à l'échelle du système, nous ferons en sorte que chaque utilisateur ne puisse ajouter ou lire que sa propre liste de livres.

Accédez au répertoire de l'application et installez deux packages :

 meteor add accounts-ui accounts-password

Là. Vous venez d'ajouter un système de connexion à l'application. Il ne nous reste plus qu'à ajouter l'interface utilisateur de connexion à book-list.html. Mettez cette ligne unique en haut du corps :

 {{> loginButtons}}

Vous devriez voir une invite de connexion en haut de l'écran :

Notez que si vous cliquez sur le lien de connexion, il vous demandera une adresse e-mail et un mot de passe. Nous pouvons passer à un simple système de connexion par nom d'utilisateur/mot de passe en créant "/client/config.js" avec les éléments suivants :

 Accounts.ui.config({ passwordSignupFields: "USERNAME_ONLY" });

À ce stade, vous pouvez taper "Meteor.userId()" dans la console, et il renverra "null". Vous pouvez essayer de cliquer sur le lien pour créer un compte. L'appel de "Meteor.userId()" devrait maintenant renvoyer une chaîne d'identification. Le serveur a accès à cette même information (comme "this.userId"), il est donc trivial de faire en sorte que la méthode "add books" force l'utilisateur à se connecter et inclue un champ userID :

 Meteor.methods({ addBook: function(bookData) { if (this.userId) { bookData.userID = this.userId; var bookID = Books.insert(bookData); return bookID; } } });

Il ne reste plus qu'à limiter le client, en n'affichant que les livres que cet utilisateur a ajoutés. Nous utilisons la capacité de la publication à restreindre ce à quoi le client a accès :

 Meteor.publish('books', function() { return Books.find({userID: this.userId}); });

Désormais, la publication ne trouve que les livres de cet utilisateur particulier. Nous pouvons même accéder à l'ID utilisateur à partir des expressions Blaze en tant que "{{currentUser}}" ; et nous pouvons l'utiliser, avec une directive "{{#if}}" (qui fait exactement ce que vous pensez qu'elle fait), pour afficher uniquement les données lorsque l'utilisateur est connecté :

 <template name="bookList"> {{#if currentUser}} <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> <form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form> {{else}} <h3>Please log in to see your books</h3> {{/if}} </template>

Découvrez le résultat final sur MeteorPad : Utilisateurs

Déploiement

Nous pouvons maintenant déployer cette application Meteor sur Internet. Pour ce faire, nous allons dans le répertoire de l'application sur un terminal et exécutons :

 meteor deploy <your app's name>.meteor.com

Assurez-vous de remplacer "<nom de votre application>" par un nom réel et court pour l'instance d'application. L'exécution de cette commande vous invitera à créer un compte avec Meteor, puis elle mettra votre nouvelle application sur les serveurs de test de Meteor afin que vous puissiez l'essayer sur Internet.

Pour une démonstration rapide, cette solution meteor.com est tout ce dont vous avez besoin. L'équipe Meteor n'a annoncé aucune limite explicite de stockage ou de bande passante sur ses serveurs. La seule limitation notable est que si votre application reste inutilisée pendant une longue période, le site met quelques secondes à démarrer pour l'utilisateur suivant.

Cela dit, meteor.com n'est pas destiné à un usage commercial. Mais lorsque vous passez à la production, il existe des sociétés de plate-forme en tant que service comme Modulus et Digital Ocean qui facilitent le déploiement des applications Meteor. Si vous souhaitez déployer une application météore sur votre propre serveur, "meteor up" simplifie également ce processus.

Prochaines étapes

Toutes nos félicitations! Dans votre quête pour apprendre Meteor, vous avez maintenant créé et déployé une application Web Meteor en temps réel très simple. Évidemment, ce n'est qu'un petit premier pas dans tout un univers de fonctionnalités et de fonctionnalités. Si vous aimez ce que vous avez vu jusqu'à présent, je recommande fortement Your First Meteor Application de David Turnbull, qui guide les lecteurs dans la création d'une application plus compliquée, avec plus d'informations sur les caractéristiques des météores en cours de route. Il est disponible sous forme de livre Kindle pour un petit prix et sous forme de PDF gratuit sur le site Web de Turnbull.

Vous voudrez également explorer les packages disponibles pour Meteor. Neuf fois sur dix, la réponse à "comment puis-je faire <x> dans Meteor ?" est "il y a un paquet pour ça". "Comment puis-je ajouter un routage à mon application ?" Vous utilisez Iron Router. "Comment puis-je fournir une API RESTful ?" Vous utilisez RESTivus. « Comment inclure les tests unitaires ? » Vous utilisez Velocity. « Comment ajouter des validations de schéma ? » Vous utilisez Collection2. Vous pouvez facilement vous perdre sur Atmosphere.js en regardant tous les packages disponibles.

Pourquoi ne pas utiliser Météor ?

Comme vous pouvez le voir dans ce tutoriel, Meteor est simple et amusant pour écrire des applications, mais je m'en voudrais de ne pas mentionner les inconvénients.

Meteor est encore relativement immature. Il a atteint 1,0 en octobre dernier, ce qui pose quelques problèmes. Si vous cherchez à faire quelque chose d'obscur, il est possible que personne n'ait encore écrit de package pour cette fonctionnalité. Les paquets qui existent sont plus susceptibles d'avoir des bogues, simplement parce qu'ils n'existent pas depuis assez longtemps pour résoudre tous les problèmes.

La mise à l'échelle peut également être quelque peu inconnue avec Meteor. Il existe de nombreux sites Meteor qui s'adaptent à un nombre raisonnable d'utilisateurs, mais peu de très grands sites - rien de l'ordre de Facebook ou LinkedIn, avec des dizaines ou des centaines de millions d'utilisateurs.

Cependant, pour la plupart des applications, Meteor est un choix parfait, car c'est une chance de réduire le temps de développement et de participer au démarrage de quelque chose de grand.