Úvod

Meteor je dobře známý pro své plnohodnotné řešení pro rychlé vytváření JavaScriptových aplikací s mnoha variantami (SPA, PWA, Mobile native, Desktop web a další).

Pokud jste v Meteoru úplným nováčkem nebo jej znáte "ze starých časů" pak vám tento článek může poskytnout nové informace o tom, co je dnes Meteor a co není:

Meteor přichází s velmi podrobným a propracovaným průvodcem pro vývojáře. Provede vás všemi architektonickými aspekty a poskytuje návrhy osvědčených postupů pro rozhodování o architektuře a designu.

Neučí vás však o tom, jak vytvořit mikroslužby s Meteorem. Je to proto, že Meteor jako framework je velmi flexibilní a pokrytí každého potenciálního architektonického rozhodnutí by přesahovalo rámec tohoto průvodce.

To je důvod, proč je zde tento příspěvek, aby vás provedl nejdůležitějšími aspekty mikroslužeb s Meteorem.

Pokrytá témata

Abychom dostali všechny na palubu, projdeme si nejdůležitější aspekty, abychom získali fungující a použitelný příklad Microservice:

• Proč Microservices with Meteor
• Jak vytvořit "bezhlavou" nanoslužbu s Meteorem
• Jak vytvořit fullstack Microservice s Meteorem
• Propojte aplikace a služby mezi sebou (HTTP / DDP)
• Bezpečnostní aspekty
• Nasazení

Veškerý kód je také umístěn v repozitáři, na který odkazuji na konci článku.

Co není zahrnuto

Oblast mikroslužeb je velmi široká. Proto chci ponechat tento článek zaměřený a pouze poškrábat povrch architektonických omezení nebo věci, které hrají roli při komunikaci mezi službami.

Pokud jste v Microservices noví a máte zájem se o nich dozvědět, můžete začít s nějakou dobrou standardní literaturou:

• Martin Fowler o mikroslužbách
• Chris Richardson o mikroslužbách

Jazyk a symboly

Často přepínám mezi Já/já , vy nebo používáme a použitím těchto slov odkazuji na různé kontexty:

• Já/já - Odrážet mé volby, záměry nebo zkušenosti
• vy/vaše - Vyvolání vás k zamyšlení nad určitým aspektem článku nebo tématu
• my/nás - Praktická situace nebo praktický úkol, kde byste nás měli považovat za malý tým, který aktuálně spolupracuje
• 🤓 - Tyto odstavce přidávají podrobnosti o pozadí pro ty, kteří chtějí přesně vědět, co se děje a proč. Pokud je informací příliš mnoho, můžete je prozatím přeskočit a přečíst si je později.

Kontext

Aby to bylo mnohem dostupnější, měli bychom uvažovat o konkrétním případu použití takové služby. Řekněme, že chceme implementovat internetový obchod, který má nějaké napojení na sklad.
Zároveň by měl existovat katalog produktů, kam může osoba (správce katalogu) vkládat a aktualizovat nové položky produktů.
Nakonec by měla být aktualizována dostupnost produktu na základě fyzické dostupnosti ve skladu.

Na základě toho můžeme naši aplikaci a služby rozdělit na následující:

• nakupovat (aplikaci)
• katalogová služba (Microservice)
• služba-stav-skladu (Nanoservice)

Architektura může vypadat takto:

Proč Microservices with Meteor

Toto by měla být vždy úplně první otázka:proč používat určitou technologii nebo zásobník k řešení konkrétního problému. Pokud na tuto otázku nemůžete odpovědět, můžete své rozhodnutí přehodnotit. Zde je několik příkladů, proč jsem si vybral Meteor:

Dobře zavedený zásobník

Meteor nabízí plný zásobník po vybalení. Přináší sdružování, správu balíčků (balíčky NPM/Meteor), transport (server/klient) a nulovou potřebnou konfiguraci. Navíc plně podporuje TypeScript, stejně jako nejpopulárnější frontendy jako React, Angular, Vue a Svelte (plus vlastní klientský engine "Blaze").

Pokud dokážeme ovládat celý zásobník téměř bez úsilí o integraci, můžeme snadno vytvořit novou mikroslužbu v několika krocích.

Jeden jazyk, který vládne všem

Navíc, protože Meteor používá jeden jazyk (JavaScript) pro celý tento zásobník, můžeme snadno začlenit nováčky do projektu a přiřadit jim jednu službu. To maximalizuje zaměření, protože je potřeba pokrýt jeden jazyk, jeden rámec a jednu mikroslužbu.

DB-Integrace

Jak již bylo zmíněno, Meteor přichází s těsnou integrací pro MongoDB. I když je to často kritizováno za to, že je méně flexibilní, ve skutečnosti nám to umožňuje snadno implementovat „vlastnictví dat“, kdy služby mají svou vlastní databázi:i když máme jednoho poskytovatele MongoDB, můžeme každé službě přiřadit databázi jednoduše vložením 02 na proměnné prostředí aplikace s příslušným názvem databáze. To nám umožňuje udržovat služby oddělené nejen z hlediska kódu, ale také z hlediska dat.

Čas uvedení na trh

Krok od vývoje k nasazení je velmi rychlý, protože není potřeba konfigurovat žádný bundler, minifikátor, babel a podobně. Všechno už tam je, takže stačí nasadit v jednom kroku na Galaxy (hosting optimalizovaný pro meteority od oficiálních vývojářů) nebo použít Meteor-Up k nasazení u jakéhokoli jiného poskytovatele služeb, kterého si dokážete představit.

To vše vede k velmi krátké době uvedení na trh a umožňuje vám rychle přidávat nové mikroslužby do vaší infrastruktury nebo je aktualizovat, aniž byste se museli potýkat se složitými konfiguracemi.

Pro další kroky si vezmeme náš praktický Meteor a za přibližně 15 minut vytvoříme vlastní příklad mikroslužby.

Nainstalujte Meteor

Pokud jste si Meteor na svůj počítač nenainstalovali, postupujte podle kroků z oficiálního instalačního webu:

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

nebo ve Windows:

npm install -g meteor

Existuje také další příspěvek, který vám může pomoci rozhodnout, který frontendový rámec byste mohli použít pro své další aplikace Meteor:

Jak vytvořit "bezhlavou" nanoslužbu s Meteorem

Krok 1 – Vytvořte co nejmenší aplikaci Meteor

Pro náš sklad vytvoříme co nejmenší aplikaci Meteor. Chcete-li tak učinit, vytvořte holý projekt:

$ meteor create --bare warehouse
$ cd warehouse
$ meteor npm install

Toto 12 služba nyní neobsahuje žádný kód a pouze velmi minimální seznam balíčků Meteor (viz 26 v 30 projekt):

[email protected]             # Packages every Meteor app needs to have
[email protected]       # Packages for a great mobile UX
[email protected]                   # The database Meteor supports right now
static-html             # Define static page content in .html files
[email protected]            # Reactive variable for tracker
[email protected]                 # Meteor's client-side reactive programming library

[email protected]   # CSS minifier run for production mode
[email protected]    # JS minifier run for production mode
[email protected]                # ECMAScript 5 compatibility for older browsers
[email protected]              # Enable ECMAScript2015+ syntax in app code
[email protected]              # Enable TypeScript syntax in .ts and .tsx modules
[email protected]            # Server-side component of the `meteor shell` command

No, můžeme to posunout ještě dál! Tato služba je „bezhlavá“ (neobsahuje žádný kód na straně klienta), takže zde můžeme odstranit několik nepotřebných balíčků:

$ meteor remove mobile-experience static-html reactive-var tracker standard-minifier-css es5-shim shell-server

Toto je nejmenší možná sada balíčků pro naši bezhlavou nano-službu:

[email protected]             # Packages every Meteor app needs to have
[email protected]                   # The database Meteor supports right now

[email protected]    # JS minifier run for production mode
[email protected]              # Enable ECMAScript2015+ syntax in app code
[email protected]              # Enable TypeScript syntax in .ts and .tsx modules

Vzhledem k tomu, že naše skladová služba odešle některé požadavky HTTP na katalogovou službu (pro aktualizaci dostupnosti některých produktů), přidáváme zde ještě jeden balíček:

$ meteor add http

🤓 Proč 45 a ne 58

Poznámka:místo toho bychom mohli použít 67 package, což je v podstatě obal pro 79 ale líbí se mi snadné použití 80 , proto jsem si to vybral zde.

Krok 2 – Implementace skladové služby

Nejprve vytvoříme nový soubor hlavního serveru:

$ mkdir -p server
$ touch ./server/main.js

Poté přidáme následující kód:

import { Meteor } from 'meteor/meteor'
import { HTTP } from 'meteor/http'

// fake data for some products
const productIds = [
  '012345',
  'abcdef',
  'foobar'
]

const randomProductId = () => productIds[Math.floor(Math.random() * 3)]
const randomAvailable = () => Math.random() <= 0.5

Meteor.startup(() => {
  Meteor.setInterval(() => {
    const params = {
      productId: randomProductId(),
      available: randomAvailable()
    }

    const response = HTTP.post('http://localhost:3000/warehouse/update', { params })

    if (response.ok) {
      console.debug(response.statusCode, 'updated product', params)
    } else {
      console.error(response.statusCode, 'update product failed', params)
    }
  }, 5000) // change this value to get faster or slower updates
})

Co se tady děje?

Po dokončení spuštění aplikace (92 ) chceme bezpečně provést interval (107 ), kde náš vzdálený koncový bod nazýváme 117 s nějakými 129 a 131 parametry.

To je ono.

🤓 Více pozadí

ID produktů jsou náhodná z pevné sady hypotetických ID – předpokládáme, že tato ID existují. Ve skutečném nastavení služby můžete buď chtít synchronizovat data mezi skladem a katalogem, nebo – jako v tomto příkladu – použít implicitní připojení na základě 140 , což vyžaduje zadání produktového manažera při aktualizaci katalogu.

Prvním příkladem zajistíte vysokou integritu dat a zároveň zavedete jemný krok směrem k propojení služeb. Druhá možnost je bez jakékoli vazby, ale vyžaduje, aby katalog obsahoval produkty, než je sklad může aktualizovat.

Krok 3 – Spusťte službu

Nakonec spusťte 155 na portu 4000:

$ meteor --port=4000

Chybové zprávy můžeme zatím ignorovat, protože naše katalogová služba ještě není zřízena. To bude předmětem zaměření v další části.

Jak vytvořit fullstack Microservice s Meteorem

Krok 1 – Vytvořte normální aplikaci Meteor

Normální aplikace? Ano, mikroslužba může být aplikace, která pokrývá celou sadu! Rozsah není architektonický, ale řízený doménou.

Proto se vraťme do kořenového adresáře našeho projektu a vytvořte novou aplikaci Meteor:

$ cd .. # you should be outside of warehouse now
$ meteor create --blaze catalog-service
$ cd catalog-service
$ meteor npm install --save bcrypt body-parser jquery mini.css simpl-schema
$ meteor add reactive-dict accounts-password accounts-ui aldeed:autoform communitypackages:autoform-plain leaonline:webapp [email protected]!

🤓 K čemu jsou tyto balíčky?

Krok 2 – Vytvořte backend

Pro náš backend většinou potřebujeme novou kolekci Mongo, která ukládá naše produkty a některé koncové body, abychom je mohli načíst (pro obchod) a aktualizovat jejich stav (pro sklad).

Krok 2.1 – Vytvořte produkty

Nejprve vytvoříme novou kolekci produktů, kterou použijeme isomopriním způsobem na serveru a klientovi:

$ mkdir -p imports
$ touch ./imports/Products.js

320 soubor obsahuje následující

import { Mongo } from 'meteor/mongo'

export const Products = new Mongo.Collection('products')

// used to automagically generate forms via AutoForm and SimpleSchema
// use with aldeed:collection2 to validate document inserts and updates
Products.schema = {
  productId: String,
  name: String,
  description: String,
  category: String,
  price: Number,
  available: Boolean
}

Pokud jste příliš líní zadávat produkty sami (jako já), můžete tento soubor rozšířit o následující kód a přidat některé výchozí hodnoty:

const fixedDocs = [
  {
    productId: 'foobar',
    name: 'Dev Keyboard',
    description: 'makes you pro dev',
    category: 'electronics',
    price: 1000,
    available: true
  },
  {
    productId: '012345',
    name: 'Pro Gamepad',
    description: 'makes you pro gamer',
    category: 'electronics',
    price: 300,
    available: true
  },
  {
    productId: 'abcdef',
    name: 'Pro Headset',
    description: 'makes you pro musician',
    category: 'electronics',
    price: 800,
    available: true
  }
]

// to make the start easier for you, we add some default docs here
Meteor.startup(() => {
  if (Products.find().count() === 0) {
    fixedDocs.forEach(doc => Products.insert(doc))
  }
})

Krok 2.2 – Vytvoření koncového bodu HTTP pro sklad

Nyní importujeme produkty v našem 333 a poskytněte koncový bod HTTP POST, který bude později volán 344 nanoservis. Proto odstraňujeme standardní kód z 355 a přidejte naši implementaci koncového bodu zde:

import { Meteor } from 'meteor/meteor'
import { WebApp } from 'meteor/webapp'
import bodyParser from 'body-parser'
import { Products } from '../imports/Products'

const http = WebApp.connectHandlers

// proper post body encoding
http.urlEncoded(bodyParser)
http.json(bodyParser)

// connect to your logger, if desired
const log = (...args) => console.log(...args)

// this is an open HTTP POST route, where the
// warehouse service can update product availability
http.use('/warehouse/update', function (req, res, next) {
  const { productId, available } = req.body
  log('/warehouse/update', { productId, available })

  if (Products.find({ productId }).count() > 0) {
    const transform = {
      productId: productId,
      available: available === 'true' // http requests wrap Boolean to String :(
    }

    // if not updated we respond with an error code to the service
    const updated = Products.update({ productId }, { $set: transform })
    if (!updated) {
      log('/warehouse/update not updated')
      res.writeHead(500)
      res.end()
      return
    }
  }

  res.writeHead(200)
  res.end()
})

🤓 Více pozadí

Pro ty z vás, kteří hledají 363 route - Meteor je již dodáván s 378 , což je zásobník middlewaru na nižší úrovni. Je expresně kompatibilní, ale funguje perfektně sám o sobě.
Kromě toho náš koncový bod přeskočí veškeré aktualizace produktů, které nebyly nalezeny. Ve skutečnosti můžeme vrátit nějakou odpověď 404, ale to bude záležet na vašem návrhu služby.
Všimněte si, že i s 381 stále potřebujeme analyzovat booleovské hodnoty, které byly analyzovány na řetězce během požadavku (399 a 406 místo 413 a 423 ).x

Krok 2.3 – Vytvořte koncové body DDP pro obchod

Abychom mohli poskytovat výkonnější službu s menším úsilím při kódování, chceme mít také některá data dostupná způsobem Meteor.
Náš obchod pak bude schopen přepsat data a „automaticky“ převést odpověď do Mongo Collection na straně klienta.

Rozšiřte 437 soubor podle následujícího kódu:

// We can provide a publication, so the shop can subscribe to products
Meteor.publish('getAvailableProducts', function ({ category } = {}) {
  log('[publications.getAvailableProducts]:', { category })
  const query = { available: true }

  if (category) {
    query.category = category
  }

  return Products.find(query)
})

// We can provide a Method, so the shop can fetch products
Meteor.methods({
  getAvailableProducts: function ({ category } = {}) {
    log('[methods.getAvailableProducts]:', { category })
    const query = { available: true }

    if (category) {
      query.category = category
    }

    return Products.find(query).fetch() // don't forget .fetch() in methods!
  }
})

To je pro náš backend nyní vše. Nebudeme implementovat žádné autentizační mechanismy, protože to zcela zničí rozsah tohoto článku.

V dalším kroku vytvoříme minimální frontend pro správce katalogu, včetně přihlášení a formuláře pro vkládání nových produktů.

Krok 3 – Vytvořte rozhraní

Krok 3.1 – Přidání šablon HTML

Kód frontendu se nachází v 443 složku. Nejprve odeberme kód Boierplate z 453 a nahradit jej vlastním:

<head>
    <title>catalog-service</title>
</head>

<body>
<h1>Catalog service</h1>

{{#unless currentUser}}
    {{> loginButtons}}
{{else}}
    {{> products}}
{{/unless}}
</body>

<template name="products">
    <ul>
    {{#each product in allProducts}}
        <li>
            <div>
                {{product.productId}} - {{product.name}}
                {{#if product.available}})(available){{else}}(not available){{/if}}
            </div>
            <div>{{product.description}}</div>
        </li>
    {{else}}
        <li>No products yet!</li>
    {{/each}}
    </ul>

    <button class="addProduct">Add product</button>

    {{#if addProduct}}
        {{> quickForm id="addProductForm" schema=productSchema type="normal"}}
    {{/if}}
</template>

🤓 Co se tady děje?

Tato šablona vykresluje všechny naše produkty v seznamu (466 ) a také zobrazuje jejich aktuální stav. Pokud je uživatel přihlášen. V opačném případě se zobrazí přihlašovací obrazovka. Pokud uživatel klikne na tlačítko "Přidat produkt", může pomocí 478 aktuálně zadat nové produkty. generované z 482 který předává 495 Pomocník šablony.

Krok 3.2 – Přidání logiky šablony

Výše uvedený kód šablony se opírá o některé pomocníky a události, které implementujeme v 502 :

/* global AutoForm */
import { Template } from 'meteor/templating'
import { Tracker } from 'meteor/tracker'
import { ReactiveDict } from 'meteor/reactive-dict'
import { Products } from '../imports/Products'
import SimpleSchema from 'simpl-schema'
import { AutoFormPlainTheme } from 'meteor/communitypackages:autoform-plain/static'
import 'meteor/aldeed:autoform/static'
import 'mini.css/dist/mini-dark.css'
import './main.html'

// init schema, forms and theming
AutoFormPlainTheme.load()
AutoForm.setDefaultTemplate('plain')
SimpleSchema.extendOptions(['autoform'])

// schema for inserting products,
// Tracker option for reactive validation messages
const productSchema = new SimpleSchema(Products.schema, { tracker: Tracker })

Template.products.onCreated(function () {
  const instance = this
  instance.state = new ReactiveDict()
})

Template.products.helpers({
  allProducts () {
    return Products.find()
  },
  productSchema () {
    return productSchema
  },
  addProduct () {
    return Template.instance().state.get('addProduct')
  }
})

Template.products.events({
  'click .addProduct' (event, templateInstance) {
    event.preventDefault()
    templateInstance.state.set('addProduct', true)
  },
  'submit #addProductForm' (event, templateInstance) {
    event.preventDefault()

    const productDoc = AutoForm.getFormValues('addProductForm').insertDoc
    Products.insert(productDoc)

    templateInstance.state.set('addProduct', false)
  }
})

🤓 Co se tady děje?

Nejprve inicializujeme 510 který vykreslí HTML formulář založený na 525 .

Poté vytvoříme novou stavovou proměnnou v 539 zpětné volání. Tento stav pouze sleduje, zda je formulář aktivní nebo ne.

549 jsou reaktivní, protože jsou připojeny k reaktivním zdrojům dat (554 a 561 ).

574 stačí kliknout na naše tlačítka a přepnout stav nebo vložit nový produkt do kolekce.

Krok 4 – Spusťte službu

Nyní jsme pomocí těchto několika kroků vytvořili plně funkční mikroslužbu. Spusťte to na 581 (ve skladu jsme se dohodli na použití tohoto portu, použijte 592 pro snadnou dynamickou konfiguraci).

$ meteor

Poté otevřete prohlížeč na 607 a zaregistrovat nového uživatele / přihlásit se s uživatelem a pomocí skladové služby aktualizovat stav dostupnosti našich produktů. 🎉

Vytvořte aplikaci obchodu

Nyní poslední částí našich praktických zkušeností je vytvoření minimálního obchodu, který využívá DDP připojení Meteoru k odběru všech dostupných produktů ŽIVĚ!

Samotný obchod neobsahuje žádný backendový kód, takže jeho spuštění nezabere mnoho času:

$ cd .. # you should be outside catalog-service now
$ meteor create --blaze shop
$ cd shop
$ meteor npm install --save jquery mini.css

Poté, stejně jako u katalogové služby, nahraďte 612 s naším vlastním kódem šablony:

<head>
    <title>shop</title>
</head>

<body>
<h1>Welcome to our Shop!</h1>

{{> products}}
</body>

<template name="products">

    <h2>Subscribed products (live)</h2>
    <ul>
        {{#each product in subscribedProducts}}
            <li>{{product.name}}</li>
        {{else}}
            <li>Currently no products available</li>
        {{/each}}
    </ul>

    <h2>Fetched products (not live)</h2>
    <ul>
        {{#each product in fetchedProducts}}
            <li>{{product.name}}</li>
        {{else}}
            <li>Currently no products available</li>
        {{/each}}
    </ul>
</template>

Udělejte totéž s 624 :

import { Template } from 'meteor/templating'
import { Mongo } from 'meteor/mongo'
import { ReactiveVar } from 'meteor/reactive-var'
import { DDP } from 'meteor/ddp-client'
import 'mini.css/dist/mini-dark.css'
import './main.html'

// at very first we establish a connection to our catalog-service
// in a real app we would read the remote url from Meteor.settings
// see: https://docs.meteor.com/api/core.html#Meteor-settings
const remote = 'http://localhost:3000'
const serviceConnection = DDP.connect(remote)

// we need to pass the connection as option to the Mongo.Collection
// constructor; otherwise the subscription mechanism doesn't "know"
// where the subscribed documents will be stored
export const Products = new Mongo.Collection('products', {
  connection: serviceConnection
})

Template.products.onCreated(function () {
  // we create some reactive variable to store our fetch result
  const instance = this
  instance.fetchedProducts = new ReactiveVar()

  // we can't get our data immediately, since we don't know the connection
  // status yet, so we wrap it into a function to be called on "connected"
  const getData = () => {
    const params = { category: 'electronics' }

    // option 1 - fetch using method call via remote connection
    serviceConnection.call('getAvailableProducts', params, (err, products) => {
      if (err) return console.error(err)

      // insert the fetched products into our reactive data store
      instance.fetchedProducts.set(products)
    })

    // options 2 - subscribe via remote connection, documents will be
    // added / updated / removed to our Products collection automagically
    serviceConnection.subscribe('getAvailableProducts', params, {
      onStop: error => console.error(error),
      onReady: () => console.debug('getAvailableProducts sub ready')
    })
  }

  // we reactively wait for the connected status and then stop the Tracker
  instance.autorun(computation => {
    const status = serviceConnection.status()
    console.debug(remote, { status: status.status })

    if (status.connected) {
      setTimeout(() => getData(), 500)
      computation.stop()
    }
  })
})

Template.products.helpers({
  subscribedProducts () {
    return Products.find({ available: true })
  },
  fetchedProducts () {
    return Template.instance().fetchedProducts.get()
  }
})

Nyní spusťte aplikaci na jiném portu než 3000 nebo 4000 a uvidíte, jak se dostupné produkty magicky objevují a nedostupné mizí:

$ meteor --port=5000

Dokončili jsme náš ukázkový projekt 🎉

🤓 Co se tady děje?

Obchod používá DDP připojení k běžícímu 633 a přihlásíte se k odběru publikace, kterou jsme vytvořili v kroku 2.3. Vzhledem k tomu, že toto připojení přidáme ke klientovi Mongo Collection, Meteor ví, že přijaté dokumenty musí být umístěny do této kolekce. Vzhledem k tomu, že dotazy na klienta jsou reaktivní, náš Template engine detekuje změny těchto aktualizací a znovu je vykresluje na základě nových dat.

Aspekty zabezpečení

Vytvořili jsme některé služby, které spolu komunikují danými koncovými body. Tyto služby však neověřují integritu dat ani neověřují zdroj požadavků. Toto je pokročilé téma a může být zahrnuto v budoucích článcích.

Všimněte si také, že 647 obsahuje 656 balíček, který automaticky vrátí všechna data kterémukoli klientovi a 661 balíček, který umožňuje synchronizaci vložek na straně klienta s kolekcí serveru.
Tyto balíčky jsou skvělé pro zesměšňování nových prototypů projektů, ale měli byste je odstranit a implementovat postupy ověřování a ověřování .

Mnohá ​​z těchto témat jsou popsána v části zabezpečení průvodce Meteorem.

Nasazení

Nasazení těchto aplikací je téma samo o sobě. S přibývajícími službami přidanými do infrastruktury se zvyšuje i složitost nasazení.

Obecně se můžete spolehnout na řešení Galaxy od Meteor Software, které vám umožní nasadit vaše aplikace a služby v jednom kroku. Nasazuje je také na konfiguraci AWS optimalizovanou pro meteorologii a přináší nástroje APM ihned po vybalení.

Pokud provozujete vlastní infrastrukturu nebo chcete používat jiného poskytovatele, můžete vyzkoušet Meteor-up, který vám umožní nasazení na jakýkoli server v jednom kroku s několika konfiguracemi přidanými do souboru JSON.

Obecně byste si měli přečíst průvodce nasazením, který pokrývá jak řešení, tak mnoho dalších témat, jako jsou soubory nastavení, CDN nebo SEO.

Shrnutí a výhled

Tento článek byl krátkým úvodem do Microservices with Meteor a měl by poskytnout dostatek informací, abyste mohli něco spustit.

Odtud můžete příklad rozšířit nebo vytvořit vlastní. Všimněte si, že bezpečnostní opatření nebyla součástí tohoto článku, a proto je třeba je brát vážně, než dostanete své služby do přírody.

Další zdroje

Veškerý kód praktického cvičení se nachází v tomto úložišti:

Mikroslužby s Meteorem

Příklad nastavení ukazuje, jak používat Microservices s Meteorem.

Přečtěte si článek na:https://dev.to/jankapunkt/microservices-with-meteor-40la

Další mé články o Meteoru:

Začátečníci

• Proč si pro svůj další projekt vybrat Meteor (nebo ne)? c
• Změňte jakoukoli aplikaci Meteor na PWA
• Zavedení účtu správce v Meteoru

Pokročilé

• Meteor a standardní vlákna
• Architektura pluginů s Meteor
• Balík Meteor browser a Node-Stubs – pozor na to, co importujete

Můžete mě také najít (a kontaktovat) na GitHubu, Twitteru a LinkedIn.

Sledujte nejnovější vývoj na Meteoru tím, že navštívíte jejich blog, a pokud jste do Meteoru stejní jako já a chcete to ukázat světu, měli byste se podívat do obchodu Meteor s merch.