DEV Community

Julián Duque
Julián Duque

Posted on

Deploying Node.js microservices to ZEIT Now

ZEIT Now is a cloud platform to deploy serverless applications, one of the things I like the most about Now is their DX (Developer Experience), it makes it very pleasant to deploy microservices to the cloud.

In this article we are going to learn how to install Now and start deploying with one single command, now.

Prerequisites

  • Node.js 10 LTS Installed
  • A terminal
  • Code editor of your choice
  • A ZEIT Now account, you can signup for free here

Installation

First, let's install now CLI from npm by running the following command:

$ npm install -g now
Enter fullscreen mode Exit fullscreen mode

Login

Next, we need to identify ourselves in the platform, now CLI offers an easy way to do this by running:

$ now login
Enter fullscreen mode Exit fullscreen mode

This will ask for your email and will send you a Verification email, just by clicking on Verify will log you in the platform, it's like magic 🔮!

Verifying Email

Verifying email

Successful login from Terminal

Successful login from Terminal

Create your first Microservice

We are ready to start creating our first microservice (or serverless application, you name it).

Now provides a list of examples, for our exercise we are going to use Node.js ⬢, but hey!, Now supports other languages and platforms too, just give it a try with the one you like the most 😉

To start witht he Node.js template let's run the following command:

$ now init nodejs microservice
Enter fullscreen mode Exit fullscreen mode

This will create a folder called microservice with the Node.js template.

Now is time to deploy our example to the cloud, let's go to that folder and execute now to see what happens!

$ cd microservice
$ now
Enter fullscreen mode Exit fullscreen mode

Deploying to Now

Deploying to Now and running our microservice

It's magic

Before continuing with our next trick, let's explore the files we are deploying:

index.js

It contains a simple function with the request and response objects from Node.js, this will be executed on every request made to our microservice.

module.exports = (req, res) => {
  res.end(`Hello from Node.js on Now 2.0!`);
};
Enter fullscreen mode Exit fullscreen mode
index.js

now.json

It's the deployment configuration file, used to specify the name of our project, the type of builders we are going to use, routes, etc. More information can be found in their documentation.

{
    "version": 2,
    "name": "nodejs",
    "builds": [
        { "src": "*.js", "use": "@now/node" }
    ]
}
Enter fullscreen mode Exit fullscreen mode
now.json

Monorepo

What we have seen so far seems simple, but, here comes the real power of now, we can mix and match different microservices in a monorepo to create a full serverless project.

For our next trick, we will create a Nuxt.js static application that will be doing API requests to a Node.js microservice, both are going to be deployed to now using the monorepo approach.

Let's create a monorepo folder and then run create-nuxt-app, this will create a basic Nuxt.js application for you, just make sure to select Axios support in the features section, we will use it later 😉.

$ mkdir monorepo
$ cd monorepo
$ npx create-nuxt-app www
Enter fullscreen mode Exit fullscreen mode

create-nuxt-app

create-nuxt-app

We have our frontend application almost ready, we will need to add an API to our monorepo project, let's create an api folder and add a Node.js microservice in there (no need to create the now.json, we will take care of that later).

Let's create a bands microservice:

$ mkdir api
$ touch api/bands.js
Enter fullscreen mode Exit fullscreen mode

api/bands.js

module.exports = (req, res) => {
  const bands = [
    {
      name: 'Dio',
      genre: 'Heavy Metal'
    },
    {
      name: 'Anthrax',
      genre: 'Trash Metal'
    },
    {
      name: 'Tenebrarum',
      genre: 'Gothic Metal'
    }
  ]
  res.end(JSON.stringify(bands))
}
Enter fullscreen mode Exit fullscreen mode

yes, I like Metal 🤘

Let's create a Deployment Configuration file to wire up our two project in the monorepo.

now.json

{
  "version": 2,
  "name": "monorepo",
  "builds": [
    { "src": "www/package.json", "use": "@now/static-build" },
    { "src": "api/*.js", "use": "@now/node" }
  ],
  "routes": [
    { "src": "/api/(.*)", "dest": "/api/$1" },
    { "src": "/(.*)", "dest": "/www/$1" }
  ]
}
Enter fullscreen mode Exit fullscreen mode

More information about how routes work in their documentation.

Here we are creating both the API and the Web project in one single repo using two different serverless applications, one served by @now/node and the other built by @now/static-build.

Before deploying let's add the following to our www project:

  • Add a now-build script to the package.json file as following:
"now-build": "API_URL=https://monorepo.julianduque.now.sh npm run generate"
Enter fullscreen mode Exit fullscreen mode

This will setup Axios to discover our API endpoint in the proper URL (make sure to use your alias here), and will tell now how to generate a static site for Nuxt.

  • Let's update our pages/index.vue page to execute the Bands microservice we implemented with Node.js
export default {
  components: {
    Logo
  },
  data: function () {
    return {
      bands: []
    }
  },
  methods: {
    async loadBands () {
      try {
        this.bands = await this.$axios.$get('/api/bands.js')
      } catch (err) {
        console.error(err)
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode
  • Add a Button to the <template> and render the items with Vue.js
<a v-on:click="loadBands">Load Bands</a>
<ul v-bind:key="band.name" v-for="band in bands">
  <li>{{ band.name }} - {{ band.genre }}</li>
</ul>
Enter fullscreen mode Exit fullscreen mode

And voila! We have connected our two serverless applications in one monorepo with Now!

Mind Blown

I hope you liked this tutorial and if you speak Spanish let me invite you to my semi-weekly Node.js show on Twitch - Node.js ¡En Vivo! 💜

Top comments (4)

Collapse
 
lcarbonaro profile image
Les Carbonaro • Edited

Not sure I understand how the Nuxt application hooks up to the microservices api from the first section. As far as I can tell, the front-end is getting the bands info from the hard-coded list in api/bands.js, unless I'm missing something.

Collapse
 
julianduque profile image
Julián Duque

Hello Les,

The first section was an example on how to deploy a single microservice, the 2nd section Monorepo consist of two microservices:

  • api/bands.js - Node.js microservice
  • www - Static website generated by Nuxt

api/bands.js is deployed as a microservice in now and doesn't run inside the client code, in the now.json file you can see the configuration and routes for both.

Collapse
 
lcarbonaro profile image
Les Carbonaro

I see. Thanks for clarifying that, Julian, and for taking the time to write about this interesting topic.

Collapse
 
kumareth profile image
Kumar Abhirup

Hi, I have a question. Is this thing Zeit Now specific? Can I deploy the same code on some other service?