DEV Community: Gordon_Gao

How I setup layer on serverless.yml

Gordon_Gao — Fri, 31 Jan 2020 01:15:47 +0000

provider:
  name: aws
  runtime: nodejs12.x
  stage: dev
  region: ap-southeast-2
  iamRoleStatements:
    - Effect: 'Allow'
      Action:
        - 'lambda:InvokeFunction'
        - 'lambda:InvokeAsync'
      Resource: '*'
environment:
  variable1: value1
layers:
  axios:
    path: deps
    name: axios
    description: axios module
package:
  exclude:
    - .prettierrc
    - .eslintrc
    - ./node_modules/**
    - ./package.json
    - ./package-lock.json

functions:
  hello:
    handler: handler.hello
    layers:
      - Ref: AxiosLambdaLayer

Upload layers

layers:
  axios:
    path: deps
    name: axios
    description: axios module

In the Layers property, you should point out which folder in the project directory you are going to upload to AWS Lambda as layers.

The key point I am going to illustrate here is,

do not use `nodejs`as folder's name (I use `deps` here) and there must be a folder which is named with `nodejs` in this folder (`deps`).

As the Serverless Framework will zip the folder automatically when you run serverless deploy and upload the zip file to AWS, when the lambda handler.js require module, lambda will navigate it to /opt/nodejs/ to find out the module.

In the nodejs folder, there is package.json file, and run npm install --save for download all modules locally. Then there are package.json, package-lock.json and node_modules under nodejs.

Ref the layer

functions:
  hello:
    handler: handler.hello
    layers:
      - Ref: AxiosLambdaLayer

In the field of function, the function which need layers created above should config with layers property. use Ref and the value should be layer name with capitalized initial letter plug string of LambdaLayer(eg.AxiosLambdaLayer).

If you are going to use existed layer, you can use ARN

excluded files

package:
  exclude:
    - .prettierrc
    - .eslintrc
    - ./node_modules/**
    - ./package.json
    - ./package-lock.json

Using ./ for just excluding node_modules and package.json from root directory, do not use node_modules/** and package.json, it will exclude node_modules and package.json from deps/nodejs/ folder.

useful link

How to set up backend API mocks in JavaScript.

Gordon_Gao — Mon, 25 Nov 2019 01:09:58 +0000

Why mock an API?

There are many benefits of API Mocks:

Developing frontend components that normally depend upon the services, when the services are not available;
Testing frontend components (frontend unit tests generally use mocks for more reliability); and
If backend and frontend development are happening in parallel, providing a contract/dummy response to work with whilst the backend is in development. ## How to mock In the following example, I will be using mountebank. There are other solutions out there, but we'll be using this one for the purposes of this article.
Install mountebank globally: npm install -g mountebank
Install the mountebank helper in your project: npm install mountebank-helper

Create a file nameed mbSetting.js and write:

const mbHelper = require("mountebank-helper");
// create a imposter, and assign a port number to it
const imposter = new mbHelper.Imposter({ imposterPort: 3430 });
// define an object as HTTP response
const mockResponse = {
  uri: "/structure",
  verb: "GET",
  res: {
    statusCode: 200,
    responseHeaders: { "Content-Type": "application/json" },
    responseBody: JSON.stringify({
      Contents: [{ Key: "content1" }, { Key: "content2" }]
    })
  }
};
// bind the response object to a route
imposter.addRoute(mockResponse);
// start mb server with routes set before
mbHelper.startMbServer(2525).then(function() {
  imposter.postToMountebank().then(() => {
    console.log("Imposter Posted, domain is http://localhost:3430");
  });
});

Start the mountebank server: mb --nologfile
Run the Node.js file you just created: node mbSetting.js
Send an HTTP request to http://localhost:3430/structure, and the response from this endpoint should be:
```
 [{ Key: "content1" }, { Key: "content2" }]
```

Collapse

Inheritance in JavaScript and understanding the prototype chain

Gordon_Gao — Fri, 22 Nov 2019 04:42:53 +0000

Javascript has an interesting inheritance model, which happens to be completely different from most OOP languages. While it is object-oriented, an object doesn't have a class that it gets its methods from. Instead, it has a prototype.

This is called prototype-based inheritance (as contrasted with class-based inheritance)

It is important to understand the differences between these two as they are not equivalent, and lead to much confusion down the line.

Even though JavaScript has since introduced class keyword for supporting OOP, this is simply syntactic sugar for its prototype-based inheritance model - nothing has fundamentally changed.

Defining a class with the `function` keyword

Let's have a look at a "class", defined using the function keyword:

function Animal(name, energy) {
  // _secret is a private property, which cannot be accessed with a dot-notation
  const _secret = 100;
  // name and energy are public properties, can be accessed with a dot-notation
  this.name = name;
  this.energy = energy;
  // this function is public, and returns the value of the private _secret property (but prevents it from being modified)
  this.getSecret = () => _secret;
}

// all properties under prototype are shared methods across all instances of a function.
Animal.prototype.sleep = function(energyReplenished) {
  console.log(`${this.name} is sleeping.`);
  this.energy += energyReplenished;
};
Animal.prototype.play = function(energyLost) {
  console.log(`${this.name} is playing.`);
  this.energy -= energyLost;
};

Note: _secret is a private property not because of the _ prefix on its variable name, but because we did not define it specifically as a property on this.

Prototype-based Inheritance

Now let's have a look at inheritance:

function Dog(name, energy, breed) {
  // every instance of Dog will now have a name and energy property.
  Animal.call(this, name, energy); // look at the Animal function above - notice how it takes in `name` and `energy` as the two parameters
  // in addition to the properties created by the Animal function, Dog also has its own properties now as well
  this.breed = breed;
}

// Dog has the same prototypes that are definded in Animal,
Dog.prototype = Object.create(Animal.prototype);

// but also some of its own as well:
Dog.prototype.bark = function () {
  console.log('Woof Woof!');
  this.energy -= 0.1;
}

// Let Dog's constructor point to itself, not Animal
Dog.prototype.constructor = Dog;

Thanks for reading, and I hope you've enjoyed!
Collapse

Why you should be using async/await

Gordon_Gao — Thu, 21 Nov 2019 05:39:30 +0000

Promises are an incredibly important part of JavaScript. It allows us to hook into the completion of asynchronous calls, making chained asynchronous operations simple.

But there is a (not so) tiny downside - Promises are not the best solution in terms of prettiest syntax.

The async and await keywords are syntactic sugar for Promises. They aid in presenting the asynchronous code in a synchronous way. They introduce no new concepts, but they change the way that Promise-based code is written.

Before/after async/await

Here is some code that uses plain Promises:

const doAsynchronousStuff = ...; // function that returns a Promise

doAsynchronousStuff().then(result1 => {
  return doAsynchronousStuff(result1);
}).then(result2 => {
  return doAsynchronousStuff(result2);
}).then(result3 => {
  return doAsynchronousStuff(result3);
}).catch(e => {
  // handle the error
});

Notice the use of callback functions. However, with async/await this becomes:

try {
  const result1 = await doAsynchronousStuff();
  const result2 = await doAsynchronousStuff(result1);
  const result3 = await doAsynchronousStuff(result2);
} catch (e) {
  // handle the error
}

Notice how it looks just like regular, synchronous, non-Promise-based code, except it supports waiting for the Promise to be resolved!
Collapse

How I use PM2 to run Node.js applications to production.

Gordon_Gao — Wed, 20 Nov 2019 13:07:08 +0000

PM2 is a process manager for Node.js applications. It helps to monitor applications, their memory and CPU uses. Also, provides easy commands line to manipulate apps. In this article, I will explain to you how to deploy a Node.js application on a server using the pm2 tool.

Install PM2

PM2 depends on Node.js and python-software-properties, so we need to install them first:

sudo apt-get install python-software-properties
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
sudo apt-get install nodejs

Then, we can install pm2 globally:

sudo npm i -g pm2

Create the config file

PM2 provides a command line for users to generate a config file. The config file will be generated in the YAML format under the project folder.

pm2 ecosystem # generates a config file

After generation, there is a file like:

apps:
  - script   : ./api.js
    name     : 'api-app'
    instances: 4
    exec_mode: cluster
    watch  : true
    env    :
      NODE_ENV: development
    env_production:
      NODE_ENV: production

Configuring PM2

Here are what some of the configuration options are for:

script: how to start the application. PM2 also supports starting Python applications.
instance: the number of instances you are going to create.
exec_mode: cluster/fork.
watch: if true, the application will auto-restart if any crash happened.
max_memory_restart: if true, PM2 will restart the application if the application exceeds the amount of memory.
env: all the env variables settings should be placed here.
error_file: a path string for forwarding stderr
out_file: a path string for forwarding stdout

Start!

Now use the following command to start the application. PM2 will read the configuration file, start applications and assign a unique id to the process.

pm2 start config.yml

PM2 provides a list function for showing all applications under PM2:

pm2 list

If you need to get more detailed info about one specific app, we can use the command:

pm2 show [app_id]

Thanks for reading, and I hope you guys learned something!