DEV Community: Rajan Prasad

Creating APIs with NodeJS, DynamoDB and AWS Lambda: A better workflow with dynamoose

Rajan Prasad — Fri, 22 Jan 2021 05:40:46 +0000

In this article, we'll create CRUD APIs with AWS Lambda and NodeJS and we'll be using
Dynamoose to get better understanding of our DB model and to have a better workflow since Dynamoose takes away the pain of writing CloudFormation code for the DynamoDB table and other hassles.

Prerequisite

I assume you've AWS account

You also should've node, npm and serverless installed. If you don't have serverless installed, you can install it through npm using npm i -g serverless

Since we'll be using Serverless Framework for deploying our stack, you've set-up the credentials with AWS. If not, Head towards the Serverless Documentation do the quick set-up.

Here's the file structure we'll be using:

Getting Started

We need to generate a simple template serverless CLI. In order to do so:

sls create -t aws-nodejs

Now, Navigate into the directory and delete the handler.js file since we'll be creating our own handler.

Folder structure set-up

First create 3 new directories namely functions, helper, and Model
Inside the the functions directory, create another directory namely users
Inside the helper directory, create two files, error.js and success.js
Inside Model directory, create a new file called UserModel.js

APIs List

We'll be creating following 5 APIs related to users.

createUser
getAllUsers
getUserById
updateUser
deleteUser

Installing required packages:

We need some npm packages in order to get our code working. so run the following command

npm i dynamoose uuid
npm i aws-sdk -D

Setting up CloudFormation code:

Open the Serverless.yml file and paste the following code:

service: dynamo-tut

provider:
  name: aws
  runtime: nodejs12.x
  region: us-east-1
  profile: personal #Replace it with your own profile name


  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:DescribeTable
        - dynamodb:Query
        - dynamodb:Scan
        - dynamodb:GetItem
        - dynamodb:PutItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
        - dynamodb:CreateTable
      Resource: '*'

functions:
  writeToDB:
    handler: functions/users/createUser.main
    events:
      - http:
          path: addUser
          method: post
          cors: true

  getAllUsers:
    handler: functions/users/getAllUsers.main
    events:
      - http:
          path: getAll
          method: get
          cors: true

  getUserById:
    handler: functions/users/getUserById.main
    events:
      - http:
          path: getOne
          method: get
          cors: true

  updateUser:
    handler: functions/users/updateUser.main
    events:
      - http:
          path: update
          method: put
          cors: true

  deleteUser:
    handler: functions/users/deleteUser.main
    events:
      - http:
          path: delete
          method: delete
          cors: true

We're doing just basic stuffs, setting up provider details, AWS IAM Permissions for our lamba functions and then defining the handler for our functions with API Gateway attached.

Now, paste the following code in error.js and success.js inside helper directory

// success.js
const getSuccessResponse = (info) => {
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Credentials': true,
    },
    body: JSON.stringify({
      message: 'Request approved for performing operation',
      data: info,
      success: true,
    }),
  };
};

module.exports = { getSuccessResponse };

// error.js
const getErrorResponse = (info) => {
  console.log(info);
  return {
    statusCode: info.statusCode || 500,
    headers: {
      'Content-Type': 'text/plain',
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Credentials': true,
    },
    body: JSON.stringify(info),
  };
};

module.exports = { getErrorResponse };

These functions ensures that our functions contains the response headers and cors policy so that our front-end will not have any issues. We'll use these helper functions to throw out responses.

Now, we need to define the Model which will be then used by Dynamoose to create DDB tables under the hood.

Create a file Models/UserModel.js and paste the following code:

const dynamoose = require('dynamoose');

const schema = new dynamoose.Schema(
  {
    id: {
      type: String,
      hashKey: true,
    },
    name: String,
    age: Number,
  },
  {
    timestamps: true,
  }
);

const UsersModel = dynamoose.model('userstable', schema, {
  create: true,
  throughput: {
    read: 5,
    write: 5,
  },
});
module.exports = { UsersModel };

Now, for the handler part, create 5 files inside functions/users and paste the following code:

// createUser.js

'use strict';

const { getSuccessResponse } = require('../../helper/success');
const { getErrorResponse } = require('../../helper/error');

const { v4: uuidv4 } = require('uuid');
const { UsersModel } = require('../../Models/UserModel');

module.exports.main = async (event) => {
  try {
    const request = JSON.parse(event.body);
    const { name, email } = request;

    const result = await UsersModel.create({
      id: uuidv4(),
      name,
      email,
    });

    return getSuccessResponse(result);
  } catch (error) {
    console.log(error);
    return getErrorResponse(error);
  }
};

// getAllUsers.js

'use strict';

const { getSuccessResponse } = require('../../helper/success');
const { getErrorResponse } = require('../../helper/error');

const { UsersModel } = require('../../Models/UserModel');

module.exports.main = async (event) => {
  try {
    const result = await UsersModel.scan().exec();
    return getSuccessResponse(result);
  } catch (error) {
    return getErrorResponse(error);
  }
};

// getUserById.js

'use strict';
const { getSuccessResponse } = require('../../helper/success');
const { getErrorResponse } = require('../../helper/error');

const { UsersModel } = require('../../Models/UserModel');

module.exports.main = async (event) => {
  try {
    const queryStringParameters = event.queryStringParameters;
    const { id } = queryStringParameters;

    const result = await UsersModel.get({ id });
    return getSuccessResponse(result);
  } catch (error) {
    return getErrorResponse(error);
  }
};

// updateUser.js

'use strict';

const { getSuccessResponse } = require('../../helper/success');
const { getErrorResponse } = require('../../helper/error');

const { UsersModel } = require('../../Models/UserModel');

module.exports.main = async (event) => {
  try {
    const request = JSON.parse(event.body);
    const { id, ...data } = request;

    const result = await UsersModel.update({ id }, { ...data });
    return getSuccessResponse(result);
  } catch (error) {
    return getErrorResponse(error);
  }
};

// deleteUser.js

'use strict';

const { getSuccessResponse } = require('../../helper/success');
const { getErrorResponse } = require('../../helper/error');

const { UsersModel } = require('../../Models/UserModel');

module.exports.main = async (event) => {
  try {
    const request = JSON.parse(event.body);
    const { id } = request;

    const result = await UsersModel.delete({ id });
    return getSuccessResponse(result);
  } catch (error) {
    return getErrorResponse(error);
  }
};

Deployment

For deployment, the following command will deploy the stack on AWS and return the endpoints for all the functions:

sls deploy -v

Testing

Once the deployment is complete, you'll find the endpoints in the output section of your terminal. Copy and paste those endpoints on Postman and hit with appropriate params and payload. If you've followed everything correctly, it will return you with results.

Here's the Repo with complete code written and tested.

Subscribe

If you like reading what i write, consider subscribing to the newsletter so you won't miss any stories.

Publishing private NPM package for free

Rajan Prasad — Sun, 27 Dec 2020 05:26:56 +0000

If you're avid JS developer then You must be using npm daily to daily basis. NPM has become a home for millions of packages. In today's article, we're going to publish a private NPM package to GitHub. If we were to publish private package to NPM directly, we'll have to upgrade to one of the Paid Plans of NPM but GitHub allows us to do the same thing for free.

Prerequisite

I assume you have basic working knowledge of Git and NodeJS and a GitHub Account Of course.

Getting Started

We'll start by creating a folder for our package and initializing npm in the directory. To do so:

mkdir gh-package
cd gh-package
npm init -y
touch index.js

You can rename the directory anything you want, in my case it's a github package so i'm naming it gh-package. Now, you should go to package.json file and edit it as follow:

{
  "name": "@userName/gh-package",
  "version": "1.0.0",
  "description": "Package for trying out GITHUB Package Registry",
  "main": "index.js",
  "publishConfig": {
    "registry": "https://npm.pkg.github.com/@userName"
  },
  "scripts": {
    "start": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

You can customize it in anyway you like but make sure to replace the userName with your valid github username. If i've my github username dmr i'll edit it as:

...
"name": "@dmr/gh-package"
...

Also, instead of gh-package, it should be same as your package name.

Writing Sample package code

Now, let's write some code. In order to keep things simple, i'm going to write a very simple function which will take a string as parameter and will return Hello *String*

Replace the index.js with the following code:

const sayHello = (name) => {
  console.log('Hello ' + name + '!');
};

module.exports = {
  sayHello,
};

Creating repo & Setting up GitHub Access Token

Now in order to publish our package we'll need a github repo and have to run GitHub Actions. So head to the GitHub and create a repo and name it as the same name you want to name your package. You can make it public however I suggest to make it private. Now once repo is created you should be able to commit the current code and push it to the repo. I'm not going to guide you through that part.

Now as I already mentioned, we need to run github actions and in order to do so, we need to create Access Token. In order to do so, head over to your github page go to Settings -> Developer Settings -> Personal Access Tokens -> Generate new token

You should tick the following permissions:

workflow
write: packages
delete: packages

Once done, it will provide you with a token. You need to keep the token safe as we will need that token in order to install the package as well since it's going to be private package.

Adding Secret to GitHub Repo

Now, the generated token should be considered as critical entity and should be kept safe. Hence we need to create a secret to our repository. Repository Secrets allows us to use variables without exposing it to the code, just like environment variables in Heroku. So head over to the repo created for this project -> Settings -> Secrets -> New repository secret.

You can name the secret anything but make sure to use it the same name as in our workflow. In my case i'll be naming it MY_GITHUB_TOKEN

Creating GH Actions workflow

We're almost done, the last thing we need to do is add github actions workflow to our repo. In order to do so, we need to create a folder called .github in our root folder and inside that another folder called workflows and lastly a file called action.yml

mkdir .github
mkdir .github/workflows
touch .github/workflows/action.yml

Now add the following code to action.yml file

name: Build and Deploy

on:
  push:
    branches:
      - main

jobs:
  publish-gpr:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v1
        with:
          node-version: 12
          registry-url: https://npm.pkg.github.com/
          scope: '@userName'
      - run: npm install
      - run: npm publish
        env:
          NODE_AUTH_TOKEN: ${{secrets.MY_GITHUB_TOKEN}}

Replace the userName in scope with your own github userName and *MY_GITHUB_TOKEN with the secret you named while adding secret to the repo

Pushing and Publising the package

Now the final step is to commit all the changes and push it to the github. Once we do so, you can go to the package repo -> Actions and see the build process kicking off. Once the build is completed you'll be able to see your package by going to your Profile -> Packages.

Testing the published package

Now we need to see our published package in action, i mean that's the whole point of publishing an package. In order to do so, You have to create a folder let's call it package-test and navigate into that folder and init npm. Now we need to create a file called .npmrc and paste the following code:

@YOUR_USERNAME:registry=https://npm.pkg.github.com/
//npm.pkg.github.com/:_authToken=YOUR_TOKEN

Replace the YOUR_USERNAME and YOUR_TOKEN with your github username and the generated token. Now you can install the package by running:

npm i @YOUR_USERNAME/PACKAGENAME

now create a file called index.js and replace it with following code:

let demoPackage = require('@username/gh-package');

demoPackage.sayHello('World');

And run it, and the package will return Hello World
The package code can be found on my Github Repo

Thanks for Reading.

Setting up Redux store in Your React application

Rajan Prasad — Sat, 14 Nov 2020 11:04:32 +0000

State management is one of the most important portion of any Front end development framework. Almost every FE framework offers one or many state management libraries. For example, Redux & Recoil for React, Vuex for VueJS and NgRx for Angular. In this article, we're going to create a very simple Reading List application which will have a redux store set up and we will be using FakerAPI for the mock response.

You can checkout the demo application Here .
Also, the source-code can be found Here on my GitHub. It is very basic application which fetches books from FakerAPI and you'll also be able to add Books.

Prerequisite

I assume that you already have a good understanding of React Components, Props & states(in general).

Getting Started

So we start simple by creating a React application using CRA and installing required dependencies afterwards.

create-react-app reading-list

This will generate the react application. Now, navigate into the newly created application and install the dependencies using

cd reading-list
npm install redux react-redux redux-thunk redux-devtools-extension axios

Now, few things to note here, redux alone is independent of any frameworks. react-redux is what let us use redux for react application. Also, we need some kind of middleware, redux-thunk in our case for basic Redux side effects logic, including complex synchronous logic that needs access to the store, and simple async logic like AJAX requests since With a plain basic Redux store, you can only do simple synchronous updates by dispatching an action. Middleware extends the store's abilities, and lets you write async logic that interacts with the store.

Also, redux-devtools-extension makes it easy to integrate Redux DevTools which speeds up our app debugging process. Axios works great for fetching data from the apis.

Folder Structure

Now, let's take a look at our folder structure

We'll create 3 folders actions , components & reducers inside our src folder. Inside the components folder, we'll create 3 components, BookList for looping through the List of Books, BookForm for adding a new Book & BookDetail for displaying each book's Detail.

Inside reducers folder, we'll have 2 files, index.js which will be our rootReducer & bookReducer.

Setting up the store

In order to set up the store, replace the src/index.js file with

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';

// Imports for Redux
import { createStore, applyMiddleware } from 'redux';
import { Provider } from 'react-redux';
import thunk from 'redux-thunk';
import { composeWithDevTools } from 'redux-devtools-extension';

// root reducer import
import rootReducer from './reducers';

const store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(thunk))
);

ReactDOM.render(
  <Provider store={store}>
    <App />
  </Provider>,
  document.getElementById('root')
);

Creating components

Since the store has been set up, we can start writing our components. Add the following code to build up our components:

// src/components/BookDetail.js
import React from 'react';

const BookDetails = ({ book }) => {
  return (
    <li>
      <div className="title">{book.title}</div>
      <div className="author">{book.author}</div>
    </li>
  );
};

export default BookDetails;

// src/components/BookForm.js
import React, { useState } from 'react';
import { connect } from 'react-redux';
import { addBook } from '../actions/bookActions';

const BookForm = ({ dispatch }) => {
  const [title, setTitle] = useState('');
  const [author, setAuthor] = useState('');

  const handleSubmit = (e) => {
    e.preventDefault();
    const newBook = {
      title,
      author,
      id: 5,
    };
    dispatch(addBook(newBook));
    setTitle('');
    setAuthor('');
  };
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="text"
        placeholder="book title"
        value={title}
        onChange={(e) => setTitle(e.target.value)}
        required
      />
      <input
        type="text"
        placeholder="author"
        value={author}
        onChange={(e) => setAuthor(e.target.value)}
        required
      />

      <input type="submit" value="add book" />
    </form>
  );
};

export default connect(null)(BookForm);

// src/components/BookList.js

import React, { useEffect } from 'react';
import { connect } from 'react-redux';
import BookDetails from './BookDetails';

import { fetchBooks } from '../actions/bookActions';

const BookList = ({ dispatch, books }) => {
  useEffect(() => {
    dispatch(fetchBooks());
  }, [dispatch]);
  return books.length ? (
    <div className="book-list">
      <ul>
        {books.map((book) => {
          return <BookDetails book={book} key={book.id} />;
        })}
      </ul>
    </div>
  ) : (
    <div className="empty">No books to read</div>
  );
};

const mapStateToProps = (state) => ({
  books: state.books.books,
});

export default connect(mapStateToProps)(BookList);

Setting up Reducers

Reducers are what responsible for mutating states. It reads the dispatched action type and mutates the state accordingly. There is one main reducer generally called rootReducer which keeps track of all the other reducers. If you look at src/index.js, in createStore method, we only passed on Reducer which is root Reducer. The rootReducer contains all the other reducers.

Add the following code in src/reducers/index.js

import { combineReducers } from 'redux';

import booksReducer from './booksReducer';

const rootReducer = combineReducers({
  books: booksReducer,
});

export default rootReducer;

We see that it is calling combineReducers method from redux and taking all the other reducers.

Add the following code to src/reducers/bookReducer.js

import { GET_BOOKS, ADD_BOOK } from '../actions/bookActions';

export const initialState = {
  books: [],
};

export default function bookReducer(state = initialState, action) {
  switch (action.type) {
    case GET_BOOKS:
      return {
        ...state,
        books: action.payload,
      };

    case ADD_BOOK:
      return {
        ...state,
        books: [...state.books, action.payload],
      };

    default:
      return state;
  }
}

Setting up actions

Add the following code to src/actions/bookActions.js

import Axios from 'axios';
export const GET_BOOKS = 'GET_BOOKS';
export const ADD_BOOK = 'ADD_BOOk';

export const fetchBooks = () => async (dispatch) => {
  const data = await fetchData();
  dispatch({
    type: GET_BOOKS,
    payload: data,
  });
};

export const addBook = (newBook) => async (dispatch) => {
  dispatch({
    type: ADD_BOOK,
    payload: newBook,
  });
};

// fetch data from the API
const fetchData = async () => {
  try {
    const res = await Axios.get(
      'https://fakerapi.it/api/v1/custom?_quantity=5&author=name&id=counter&title=city'
    );

    return res.data.data;
  } catch (error) {
    console.log(error);
  }
};

Styling

Since we're mainly focused on setting up redux, it doesn't mean our application has to look ugly. That's why i've already written some basic styling which will make our app look decent.

Replace all the codes in src/index.css with following

body {
  margin: 0;
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
    sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  background: #553055;
}
.App {
  background: #4c2a4c;
  margin: 20px auto;
  width: 90%;
  max-width: 700px;
  color: #eee;
}
.navbar {
  padding: 10px 20px;
  text-align: center;
  background: #6d3d6d;
}
.navbar h1 {
  margin: 10px 0;
}

.book-list {
  margin: 20px;
}
.book-list ul {
  padding: 0;
  list-style-type: none;
}
.book-list li {
  background: #6d3d6d;
  border-radius: 4px;
  padding: 10px;
  cursor: pointer;
  margin: 10px 0;
}
.book-list li:hover {
  opacity: 0.7;
  text-decoration: line-through;
}
.book-list .title {
  font-weight: bold;
  color: #fff;
  font-size: 1.2em;
}
.book-list .author {
  font-size: 0.9em;
  color: #ddd;
}
.empty {
  margin: 20px;
  text-align: center;
}

form {
  padding: 20px;
}
input[type='text'] {
  width: 100%;
  padding: 10px;
  box-sizing: border-box;
  margin: 6px 0;
  background: #3c1f3c;
  color: #fff;
  border: 0;
}
input[type='submit'] {
  margin: 10px auto;
  background: #eee;
  border: 0;
  padding: 6px 20px;
  display: block;
}

Now, finally, let's add our components to src/App.js . Replace all the codes in src/App.js with following

import BookForm from './components/BookForm';
import BookList from './components/BookList';

function App() {
  return (
    <div className="App">
      <BookList />
      <BookForm />
    </div>
  );
}

export default App;

Now, if you've followed everything accordingly, once you start the server, you can see the application running. Also if you look at Redux DevTools you'll be able to see how the states changed, what actions were launched.

If you run in any problem, you can always use the code from Here as a reference.

Intelligence Explosion: possibility that future of computing holds

Rajan Prasad — Sat, 24 Oct 2020 10:10:36 +0000

Comparing most powerful computers from 1956 to that of 2015, there's 1 trillion-fold increase in processing power.Although the technological progress has been accelerating, the human brain has not changed significantly in millenia and so some great minds have speculated that machines will surpass human levels of intelligence and ability at some point of time.

Machines have become really intelligent, fast, accurate and unbeatable for performing some task like playing chess, or DOTA2(the Open AI), doing complex calculations, weather forecasting and more. But the one thing that makes human special is their Natural Intelligence. But what if humans were able to design such intelligent system which in turn designs a new system more intelligent than itself and this cycle repeats ?

This will result in such an intelligence called "UltraIntelligence". There would then unquestionably be an ‘intelligence explosion’, and the intelligence of men would be left far behind. Thus the first ultraintelligent machine is the last invention that man need ever make.

But to be clear, nobody knows when is it going to happen, might be never or around 2500 or maybe around 2100. Maybe those prognosticators are right, and it will happen in the next thirty to eighty years.

Get yourself ready

There are another speculations however on How far along the intelligence explosion go.
Some believe that it will stop at the point that it reaches the full equivalent of human intelligence.

Why so? Because it is asserted that perhaps mankind exhibits the highest possible intelligence, and therefore there isn’t anything beyond it. In contrast, another viewpoint is that the AI intelligence explosion is going to zip right past human intelligence and land somewhere around so-called super-intelligence, also referred to as ultra-intelligence.

How high is up? Can’t say. Don’t know.

One belief is that this super-intelligence will undoubtedly be beyond our level of intelligence, and yet it will itself also have a boundary or final edge to it. It won’t be some amorphous intelligence that is all-consuming. Meanwhile, there are those though that suggest the AI intelligence explosion might be a never-ending chain reaction. AI intelligence might keep going and going, getting smarter and smarter, doing so for the rest of eternity.

What would it mean for mankind if the AI intelligence explosion was something that once started was ever-expanding?

This could be really good or ...really...really...bad

A machine superintelligence, if programmed with the right motivations, could potentially solve all the problems that humans are trying to solve but haven’t had the ingenuity or processing speed to solve yet. A superintelligence might cure disabilities and diseases, achieve world peace, give humans vastly longer and healthier lives, eliminate food and energy shortages, boost scientific discovery and space exploration, and so on.

Furthermore, humanity faces several existential risks in the 21st century, including global nuclear war, bioweapons, superviruses, and more.[56] A superintelligent machine would be more capable of solving those problems than humans are.

Sounds really cool so far right ? Now let's look at the downside

If programmed with the wrong motivations, a machine could be malevolent toward humans, and intentionally exterminate our species. More likely, it could be designed with motivations that initially appeared safe (and easy to program) to its designers, but that turn out to be best fulfilled (given sufficient power) by reallocating resources from sustaining human life to other projects.
“the AI does not hate you, nor does it love you, but you are made out of atoms which it can use for something else.”, No strings attached.

Can we add friendliness to any artificial intelligence design?

Many AI designs that would generate an intelligence explosion would not have a ‘slot’ in which a goal (such as ‘be friendly to human interests’) could be placed. For example, if AI is made via whole brain emulation, or evolutionary algorithms, or neural nets, or reinforcement learning, the AI will end up with some goal as it self-improves, but that stable eventual goal may be very difficult to predict in advance.

Thus, in order to design a friendly AI, it is not sufficient to determine what ‘friendliness’ is (and to specify it clearly enough that even a superintelligence will interpret it the way we want it to). We must also figure out how to build a general intelligence that satisfies a goal at all, and that stably retains that goal as it edits its own code to make itself smarter. This task is perhaps the primary difficulty in designing friendly AI.

Can we teach a superintelligence a moral code with machine learning?

Some have proposed that we teach machines a moral code with case-based machine learning. The basic idea is this: Human judges would rate thousands of actions, character traits, desires, laws, or institutions as having varying degrees of moral acceptability. The machine would then find the connections between these cases and learn the principles behind morality, such that it could apply those principles to determine the morality of new cases not encountered during its training. This kind of machine learning has already been used to design machines that can, for example, detect underwater mines after feeding the machine hundreds of cases of mines and not-mines.

There are several reasons machine learning does not present an easy solution for Friendly AI. The first is that, of course, humans themselves hold deep disagreements about what is moral and immoral. But even if humans could be made to agree on all the training cases, at least two problems remain.

The first problem is that training on cases from our present reality may not result in a machine that will make correct ethical decisions in a world radically reshaped by superintelligence.

The second problem is that a superintelligence may generalize the wrong principles due to coincidental patterns in the training data.Consider the parable of the machine trained to recognize camouflaged tanks in a forest. Researchers take 100 photos of camouflaged tanks and 100 photos of trees. They then train the machine on 50 photos of each, so that it learns to distinguish camouflaged tanks from trees. As a test, they show the machine the remaining 50 photos of each, and it classifies each one correctly. Success! However, later tests show that the machine classifies additional photos of camouflaged tanks and trees poorly. The problem turns out to be that the researchers’ photos of camouflaged tanks had been taken on cloudy days, while their photos of trees had been taken on sunny days. The machine had learned to distinguish cloudy days from sunny days, not camouflaged tanks from trees.

Thus, it seems that trustworthy Friendly AI design must involve detailed models of the underlying processes generating human moral judgments, not only surface similarities of cases.

Setting up Routing in Svelte

Rajan Prasad — Thu, 15 Oct 2020 16:31:36 +0000

In this article, i'll provide a quick overview of Svelte then we'll create a very basic Svelte app and add routing to it. Now for those who don't know what svelte app is, Svelte is Front-end JavaScript UI Library. It is not actually a framework, instead Svelte is a compiler that generates minimal and highly optimized JavaScript code.

Introduction

Svelte is a new approach to building UIs. Instead of using Virtual DOM, it compiles the code and ships framework-less vanilla JavaScript which makes it faster and lighter than other frameworks or Libraries like React or Vue. It is gaining very much popularity due to its easy learning curve and a very easy state management.

Setting Up

Now, in order to create an svelte app, we just basically have to clone the template from github. In order to do so, navigate into the directory in which you want to create the project and run

npx degit sveltejs/template my-svelte-project

You can change 'my-svelte-project' to any name you want. Now, next you have to navigate into the recently created template folder and run the package installations

cd my-svelte-project
npm install

This will install all the required dependencies and then we can run the project by using the command

npm run dev

This will fire-up the server and the project will be running on port 5000 by default. Visit http://localhost:5000/ in your browser and you will see our app running.

Creating components

Now, the next step is to create components. We'll create component folder inside src and place all our components there. Also we'll be needing a folder called routes to place our router file. So let's create all the Files and folders necessary. You can use GUI or simply enter the following commands

mkdir src/component
mkdir src/routes
touch src/component/About.svelte src/component/Home.svelte src/component/Blog.svelte

touch src/routes/index.svelte

This will create all the files and folders required. We also need a package called svelte-routing in order to implement routing. In order to install the package, run

npm install svelte-routing

Now since all our files and folders are set up and svelte-routing has been installed, we can head towards configuring routes/index.svelte

Configuring Routing

Add the following code in routes/index.svelte file

<script>
  import { Router, Route } from 'svelte-routing';
  import Home from '../components/Home.svelte';
  import About from '../components/About.svelte';
  import Blog from '../components/Blog.svelte';

  export let url = '';
</script>

<Router {url}>
  <div>
    <Route path="blog" component={Blog} />
    <Route path="about" component={About} />
    <Route path="/" component={Home} />
  </div>
</Router>

What we're doing here is, We're importing all our created components and also the bringing in Router and Route from svelte-routing which are necessary classes in order to configure routing. Then we're setting up path for each component and pointing to load the respective component in their respective path.

Now, it's time configure the Components.

Configuring Components

First we've to configure the App.svelte since it's the root component. Replace all the code of App.svelte with

<script>
  import Router from './routes/index.svelte';
</script>

<style>
  main {
    text-align: center;
    padding: 1em;
    max-width: 240px;
    margin: 0 auto;
  }
</style>

<main>
  <Router />
</main>

Basically, we're just bringing in the router we created and loading Router as root component. Now, let's configure other components.

Almost all the components will be of same structure since its just a demo application. So let's configure our Home.svelte. Add the following codes to this file

<script>
  import { Link } from 'svelte-routing';
</script>

<div>
  <h3>This is HomePage</h3>
  <Link to="blog">Blog</Link><br />
  <Link to="about">About</Link>
</div>

So in order to go to another Route, we need something called Link then we points to which component it should redirect. That's all we're basically doing here.

Blog and About component also will have similar structure.

// Blog.svelte
<script>
  import { Link } from 'svelte-routing';
</script>

<div>
  <h3>This is Blog Page</h3>
  <Link to="/">Home</Link><br />
  <Link to="about">About</Link>
</div>

// About.svelte

<script>
  import { Link } from 'svelte-routing';
</script>

<div>
  <h3>This is About Page.</h3>
  <Link to="/">Home</Link><br />
  <Link to="blog">Blog</Link>
</div>

Now, we're all set. save all the files and test it. All the links should be working and you should be able to switch between apps. You can demo the project Here.

Here's the source code for the project

5 Pillars of Well-Architected Framework

Rajan Prasad — Mon, 05 Oct 2020 13:24:03 +0000

Creating a software system is a lot like constructing a building. If the foundation is not solid, structural problems can undermine the integrity and function of the building.
In this article, we're going to talk about the design principles we can follow to build a future proof large scale software. The concepts are from *AWS Well-Architected framework * whitepaper. This whitepaper inspires to learn architectural best practices for designing and operating reliable, secure, efficient, and cost-effective systems in the cloud. It provides a way to consistently measure your architectures against best practices and identify areas for improvement. I'll be trying to summarize the Whitepaper

So let's first quickly sum up the Guiding Design Principles:

Stop guessing capacity needs: Scale up & Down as required
Automate everything: Automated systems ensure consistency & reliability
Test at scale: Test an accurate replica of production on-demand
Adapt & Evolve: Adapt the architecture as needed to meet new challenges

The framework is based on 5 pillars:

1). Operational Excellence
2). Cost optimization
3). Reliability
4). Performance Efficiency
5). Security

Operational Excellence

The main emphasis of this pillar is: Does your architecture work ? Will it continue to ?
Let's look at this pillar specific principles:

All operations are code
Document is updated automatically
Make smaller changes you can roll back
Iterate...a lot
Expect things to go sideways

Cost Optimization

Emphasis: Spend only what you have to
Pillar specific principles:

Consumption based pricing
Measure efficiency constantly

Reliability:

Emphasis: ** Will this system work consistently & recover quickly ?**
Pillar specific principles:

Recover from issues automatically
Scale horizontally first for resilience
Reduce idle resources
Manage change through automation

Performance Efficiency

Emphasis: Remove bottlenecks, reduce waste
Pillar specific principles:

Reduce latency
Serverless

Security

Emphasis: *Does this system work only as intended? *
Pillar specific principles:

Automate security tasks
Encrypt data in transit and at rest
Know who did what when
Identities have the least privileges required

Operational Excellence In Depth

Operational excellence is the ability to run systems and gain insights into their operations in order to deliver business value, and to continuously improve supporting processes and procedures. The 3 Phases of Operational Excellence

Prepare-Prioritize: Prioritize to align with business priorities

What is the business goal ?
What are the critical pieces need to meet that goal ?
Any compliance restrictions/requirements ?
Dependencies between services ?

Design your architecture to support business Priorities

Is the design observable ?
Are your logs & observations actionable ?

Is your workload ready to go live ?

Are your processes consistent ?
Is operational code properly managed ?
Are tests in place ?
Anticipate failure ?
Ensure your workload is actually working

Shit happens. Be ready.

Anticipate planned & unplanned events
Respond in code
Connect observations with 3rd party tools as needed

Evolve

Learn from success & failure
Post-event, have runbooks changed ?
Test assumptions
Experiment early and often find better solutions

Cost

Use the appropriate resources & configurations
Provision to current needs with an eye to future
Right size to lowest resource that meets needs
Use data to choose purchase options
Optimize by geography
Optimize data transfer
Know how much you're spending and where
Continuously work to maximize value delivered
Align utilization with requirements
Report and validate findings
Evaluate new services for value

** Awareness of spend is key to maximizing value **

Reliability

Reliability is the ability of a system to recover from infrastructure or service disruptions, dynamically acquire computing resources to meet demand, and mitigate disruptions.

Scale horizontally first for resilience
Reduce idle resources
Manage change through automation

Limit: Understand default & requested resources limit
Networking: Understand topology, bandwidth & latency
Availability: Ensure your application is ready for business use

Ensure your application is ready for business use

Can users access your application
Deploy without issue
Can you push issue to planned downtime
Can your application withstand portal outages ?

Performance Efficiency

Selection:

Is this the optimal solution for this workload ?
What type of compute best suits ?
Which data store is ideal for this workload ?
Does your network design complement compute & data store choices ?

Review:

Continuously ensure choices work for your workload
Is infrastructure stored as code ?
Are deployments simple & automated ?
Can benchmarks be taken automatically ?

Monitoring:

Use active & passive monitoring where appropriate
Understand the five phases of monitoring (Generation, Aggregation, Real-time Processing, Storage, Analysis)
Create actionable metrics

Trade of -> You can't have it all

NodeJS CRUD API with MongoDB

Rajan Prasad — Sun, 04 Oct 2020 06:13:51 +0000

If you've been in the web development world, the chances are: you already have heard about NodeJS and MongoDB. The NodeJS official page defines it as Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine. Also, MongoDB is one of the most popular NoSQL database. In this article we're going to perform CRUD operation on MongoDB using NodeJS along with tools express & mongoose.

Prerequisite

If you're to get started i assume you already have set-up a MongoDB cluster and have the connection URI. If not so then you can find how to set it up in my previous article , it will guide you step-by-step on setting up Free MongoDB cluster. I also assume you've some working knowledge with NodeJS and express.

Setting Up

In order to get started, first thing we'll do is create the file structure. I suggest you to create a root folder and then inside the root folder, create the following sub-folders:

Installing Dependencies

Now, to get started, we first need to create a file server.js and then install few required dependencies. In order to do so,

npm init -y


touch server.js
touch .env
mkdir controllers
mkdir models
mkdir routes

npm install express mongoose dotenv cors body-parser

This will complete our folder structure and dependencies installation. Now the next step will be to get our mongoDB connection URI and place it in a .env file. In order to do so, open your .env file and edit it as:

DB = "YOUR_CONNECTION_STRING_HERE"

Setting up Server and Routes

Now, let's edit our server.js file in order to set up the routes. Copy and paste the following code in your server.js file:

const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");
const mongoose = require("mongoose");

require("dotenv").config();

const app = express();

const routes = require("./app/routes");

var corsOptions = {
  origin: "http://localhost:8081",
};

app.use(cors(corsOptions));

app.use(bodyParser.json());

app.use(bodyParser.urlencoded({ extended: true }));

let DB = process.env.DB;

mongoose
  .connect(DB, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log("mongoDB connected Successfully"))
  .catch((err) => console.log(err));

app.use("/api/notes", routes);

const PORT = process.env.PORT || 8080;

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

So basically what we're doing here is

Bringing in required dependencies
Bringing in Routes(which we haven't created yet but will shortly)
Connecting to mongoDB

Creating Models

Since we're using MongoDB and Mongoose, we must have to have models. In this app, we'll have only one model NotesModel which will contain the fields for our notes.
So let's create a file NotesModel.js file inside models folder and paste the following code:

const mongoose = require("mongoose");

const NotesSchema = new mongoose.Schema(
  {
    title: String,
    description: String,
  },
  { timestamps: true }
);

const Note = mongoose.model("Note", NotesSchema);
module.exports = Note;

So essentially, we just have 2 fields title and description of string types to keep things simple. Also the timestamps has been set to true which will record the creation and modification date.

Creating Router and Controller

Now, the server.js is all setup, we can start setting up our controller and Router.
Inside controller folder, create a file index.js and paste the following code:

const NotesModel = require("../models/NotesModel");

exports.findAll = async (req, res) => {
  try {
    const notes = await NotesModel.find({});
    res.send(notes);
  } catch (error) {
    res.status(500).send({
      message: error.message || "Some error occured while retrieving Notes",
    });
  }
};

exports.create = async (req, res) => {
  const Note = req.body;

  try {
    let NoteDoc = new NotesModel(Note);
    await NoteDoc.save();
    res.send(Note);
  } catch (error) {
    res.status(500).send(error);
  }
};

exports.findOne = async (req, res) => {
  const id = req.params.id;

  try {
    let Note = await NotesModel.findById(id);
    res.send(Note);
  } catch (error) {
    res.status(500).send(error);
  }
};

exports.update = async (req, res) => {
  let { ...data } = req.body;
  const result = await NotesModel.findOneAndUpdate(
    { _id: req.params.id },
    data,
    {
      new: true,
    }
  );

  res.send(result);
};

exports.delete = async (req, res) => {
  try {
    let id = req.params.id;

    await NotesModel.findByIdAndDelete(req.params.id);

    res.status(200).send();
  } catch (error) {
    res.status(500).send(error);
  }
};

This part contains the logic for Creating, Reading, Updating and Deleting data from/to our database. Now in order for it to work, we've to bring it in routes file and map it to proper methods/paths. In order to do so, create a file called index.js inside routes folder and paste the following code:

// Bring in the express server
const express = require("express");

// Bring in the Express Router
const router = express.Router();

// Import the Controller
const controller = require("../controllers");

// Create a new Note
router.post("/", controller.create);

// Get all Notes
router.get("/", controller.findAll);

// Get Note by Id
router.get("/:id", controller.findOne);

// Modify existing Note
router.put("/:id", controller.update);

// Delete Note by Id
router.delete("/:id", controller.delete);

module.exports = router;

Now that all has been set-up, you can just run:

node server.js

The server will start and will listen to port:8080. You can use postman to test the APIs.

The complete project can be found on my Github

Adding authentication to React App using AWS Amplify and Cognito

Rajan Prasad — Tue, 01 Sep 2020 14:13:59 +0000

AWS Amplify enables front-end developers to build secure, scalable full stack applications, powered by AWS while Amazon Cognito lets you add user sign-up, sign-in, and access control to your web and mobile apps quickly and easily. In this article, we will be using AWS amplify to add authentication to our React application.

Prerequisite

In order to follow along, you must have

npm installed
AWS Account
AWS profile set up If you don't have any of these i suggest you to set it up since i will not be going to talk about any of those in this article.

Creating React application

Now, to get started, we first have to create a React Application. we'll use CRA to make things easier. If you've CRA installed you can simply use

create-react-app my-auth-app

If you don't have CRA installed and don't want to do so then simply use

npx create-react-app my-auth-app

Installing and initializing Amplify

Now, we need to install aws-amplify. We also be installing pre-built React UI for authentication so that we don't have to code the SignIn/SignUp UI by ourselves. Once installed, we can then initialize amplify.

cd my-auth-app
npm i aws-amplify @aws-amplify/ui-react
amplify init

So, we just navigated into our directory and hit install command for aws-amplify and ui-react. Then, we initialized Amplify. Once initialized, you'll be prompted with few questions:

Enter the name for the project (my-auth-app)
Enter name for the environment
Choose your default editor
Choose the type of app you're building
What javascript framework are you using
Source directory Path (src)
Distribution directory Path (build)
Build Command
Start Command
Do you want to use an aws-profile (Y/n)

You can just hit enter for all other questions except 2 and 10. For the environment name, you can enter either 'test' or 'dev'. i prefer 'dev'.
For question 10, once hit enter, your aws-profiles will be prompted, you have to select the profile on which you want to deploy the cognito user-pool.

Adding authentication

It's time we finally add authentication to our project. To do so, use

amplify add auth

Now, again you'll be prompted with set of questions.

Do you want to use the default authentication and security configuration?
How do you want users to be able to sign in?
Do you want to configure advanced settings?

Default options are good enough for our simple app, so just hit enter for all the above questions. Authentication has been. Now, to set-up cognito userpool in the cloud, we just have to push it. To do so use

amplify push

You'll be prompted with "Are You sure" question, hit enter as we DO want to deploy the userpool in the cloud. It will start the deployment process and deploy the cloudformation stack. Might take 4-5 minutes. Once done, we can set up our react application to use Cognito and add Authentication UI from react-ui package.
Now, we need to configure our react application. To do so, open the project in any code-editor. I'll be using vs-code in my case however feel free to use any text editor, whichever suits you best.
Edit Your src/index.js file to

import React from "react";
import ReactDOM from "react-dom";
import "./index.css";
import App from "./App";
import * as serviceWorker from "./serviceWorker";

import config from "./aws-exports";
import Amplify from "aws-amplify";
Amplify.configure(config);

ReactDOM.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>,
  document.getElementById("root")
);

// If you want your app to work offline and load faster, you can change
// unregister() to register() below. Note this comes with some pitfalls.
// Learn more about service workers: https://bit.ly/CRA-PWA
serviceWorker.unregister();

Now, edit your src/App.js file to

import React from "react";
import { withAuthenticator, AmplifySignOut } from "@aws-amplify/ui-react";

const App = () => (
  <div>
    <AmplifySignOut />
    My App
  </div>
);

export default withAuthenticator(App);

Save the project and run te app using

npm start

If there's not any issue, You'll see the following screen

You can try out by creating a user. When creating a new user, you'll be provided with a verification code to the email you enter in order to complete the verification process. Once verified you can Sign In by providing the credentials.

Thanks for reading. You can find the complete project on GitHub

Discord Servers to join as a Developer

Rajan Prasad — Tue, 01 Sep 2020 03:21:01 +0000

Whether You're new to development or an experienced developer seeking to connect with like minded people then this article is for you. Discord is a platform which allows to connect with other people and there are dedicated servers only for developers.

Here's a list of recommended Dev Servers to join as a developer:

Did i miss any ?? Feel free to comment i'll be happy to checkout.

DynamoDB CRUD with NodeJS and Lambda

Rajan Prasad — Sun, 30 Aug 2020 11:54:25 +0000

AWS defines DynamoDB as "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale. It's a fully managed, multiregion, multimaster, durable database with built-in security, backup and restore, and in-memory caching for internet-scale applications". So from the definition, it is clear that DynamoDB is a serverless, fully-managed millisecond performance and highly scalable NoSQL database which was announced in Early 2012.

In this article, we'll perform basic CRUD operations using AWS Lambda and NodeJS. To kick off, we first have to define the following file structure:

we'll call our root-folder DynamoCRUD, however feel free to call it anything you like. Under our root folder, we'll create a folder called resources which will contain a file called dynamo-table.yml containing our code for creating DynamoDB table. Also since we'll be using Serverless Framework to deploy our cloudformation stack, i assume that you already have installed and set up the programmatic access to your AWS account with Serverless. If not you can refer to the Serverless Documentation .
After creating a folder called resources, we'll generate a template using serverless framework with the command:



sls create -t aws-nodejs

This will generate the serverless.yml file, handler.js file and .gitignore file and finally our file structure will be completed.

Now, lets get started with our serverless.yml file. Our serverless.yml file will look like this:



service: DynamoCRUD

provider:
  name: aws
  runtime: nodejs12.x
  profile: default
  timeout: 30

  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - "dynamodb:*"
      Resource: "*"

functions:
  addItem:
    handler: handler.addItem

  getAllItem:
    handler: handler.getAllItem

  updateItem:
    handler: handler.updateItem

  deleteItem:
    handler: handler.deleteItem

resources:
  - ${file(resources/dynamo-table.yml)}

So basically what we're doing is we're creating a dynamoDB table using resources section and creating 4 basic functions to perform the CRUD operation and giving DynamoDB permission to our Lambda functions.

Now, we'll create a DynamoDB table i.e. our dynamo-table.yml under resources folder. It will look something like :



Resources:
  myDynamoDBTable:    # Logical Id of the resource
    Type: AWS::DynamoDB::Table

    Properties:
      AttributeDefinitions:
        - 
          AttributeName: "year"
          AttributeType: "N"
        - 
          AttributeName: "title"
          AttributeType: "S"

      KeySchema:
        - AttributeName: "year"    # Partition Key
          KeyType: "HASH"
        - AttributeName: "title"    # Sort Key
          KeyType: "RANGE"

      TableName: "Movies"     

      ProvisionedThroughput:   # Optional, can be skipped
        ReadCapacityUnits: 10
        WriteCapacityUnits: 10

So basically we're creating a table with the above attribute definitions.

Now, lets write our handler.js file. This will have the code for all the CRUD operation defined on serverless.yml file.



"use strict";
const AWS = require('aws-sdk');

const docClient = new AWS.DynamoDB.DocumentClient();

// Function to Create an Item to DB
module.exports.addItem = async (event) => {
  try {

    let table = "Movies";
    let year = 2015;
    let title = "The Big New Movie";

    let params = {
      TableName: table,
      Item: {
        "year": year,
        "title": title,
        "info": {
          "plot": "Nothing happens at all",
          "rating": 0
        }
      }
    }

    let result = await docClient.put(params).promise();
    if (result) {
      console.log(">>>>>>>>>", result);
    }

    console.log("hello world")
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Go Serverless v1.0! Your function executed successfully!",
        data: result
      }),
    };
  } catch (error) {
    console.log(error);
    return error;
  }
};

// Function to getAllItems from DB
module.exports.getAllItem = async () => {
  let table = "Movies";
  let year = 2015;

  let title = "The Big New Movie";

  let params = {
    TableName: table,
    Key: {
      "year": year,
      "title": title
    }
  }

  try {
    let result = await docClient.get(params).promise();

    console.log(result);

    return {
      body: JSON.stringify({
        message: "Executed succesfully",
        data: result
      })
    }
  } catch (error) {
    console.log(error);
  }
}

// Function to update an Item in DB
module.exports.updateItem = async () => {
  let table = "Movies";
  let year = 2015;

  let title = "The Big New Movie";

  let params = {
    TableName: table,
    Key: {
      "year": year,
      "title": title
    },
    UpdateExpression: "set info.rating = info.rating + :val",
    ExpressionAttributeValues: {
      ":val": 1
    },
    ReturnValues: "UPDATED_NEW"
  };

  try {
    let result = await docClient.update(params).promise();
    return {
      body: JSON.stringify({
        message: "updated succesfully",
        data: result
      })
    }
  } catch (error) {
    console.log(error);
  }
}

// Function to Delete an item
module.exports.deleteItem = async () => {

  let table = "Movies";
  let year = 2015;

  let title = "The Big New Movie";

  let params = {
    TableName: table,
    Key: {
      "year": year,
      "title": title
    }
  }

  let result = await docClient.delete(params).promise();

  return {
    body: JSON.stringify({
      message: "deleted succesfully",
      data: result
    })
  }

}

One thing to note here, I'm hard-coding the Data to be created in DB for the sake of simplicity. Feel free to change the AddItem method into POST and parse the body from event.body, you can totally do that. Same goes for update and delete method. I'm just trying to keep the things as simple as possible.

Now, the last thing to do is deploy our stack to AWS and we'll be ready to test our functions worked or not. To deploy the stack simply just enter the following command:



sls deploy -v

This will return all the functions end-point. You can use POSTMAN to to hit the end-points and check the responses.

Thanks for Reading

Node.js Rest CRUD API with Postgres

Rajan Prasad — Sat, 29 Aug 2020 06:10:28 +0000

PostgreSQL is a powerful, open source object-relational database system that has earned it a strong reputation for reliability, feature robustness, and performance. In this article, We will build Rest Apis that can create, retrieve, update and delete Notes.

First we will start setting up express server and routes with express router. Next we add configuration for PostgreSQL database and create Note Model with sequelize. Our File structure at the end will be

To create express server and install required dependencies, in your terminal type

mkdir postgres-crud
cd postgres-crud
npm init -y
touch server.js
mkdir app
npm i express cors body-parser pg pg-hstore sequelize@5.21.13

This will create a folder called postgres-crud, initialize a node project and install the required dependencies. Now, we need to set-up our express server code and configure the route. To set up the server, Edit the server.js file as

// Bring in required Modules
const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");

const app = express();

// Bring in the route
const routes = require("./app/routes");

var corsOptions = {
  origin: "http://localhost:8081",
};

app.use(cors(corsOptions));

app.use(bodyParser.json());

app.use(bodyParser.urlencoded({ extended: true }));

const db = require("./app/models");
db.sequelize.sync();

app.use("/api/notes", routes);

// Define PORT
const PORT = process.env.PORT || 8080;

// Listen to the defined PORT
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Now, to set up the routes, we will create a folder called routes in our app folder and under routes folder, we will create a file called index.js. You can do these all through the editor or type the following command in your terminal

mkdir app/routes
touch app/routes/index.js

Now, edit the app/routes/index.js file as

// Bring in the express server
const express = require("express");

// Bring in the Express Router
const router = express.Router();

// Import the Controller
const controller = require("../controllers");


// Create a new Note
router.post("/", controller.create);

// Get all Notes
router.get("/", controller.findAll);

// Get Note by Id
router.get("/:id", controller.findOne);

// Modify existing Note
router.put("/:id", controller.update);

// Delete Note by Id
router.delete("/:id", controller.delete);

module.exports = router;

Now, the next step is to configure the Database. In order to do so, we create config folder inside our app folder then create a file db.config.js file under the config folder. To do these through command line

mkdir app/config
touch app/config/db.config.js

Now, edit the db.config.js file as below. You have to replace the HOST, USER, PASSWORD values with your own db values.

module.exports = {
  HOST: "localhost", // Replace it with your own host address
  USER: "user123", // Replace with your own username
  PASSWORD: "12345", // Replace with your own password
  DB: "testdb",
  dialect: "postgres",
  pool: {
    max: 5,
    min: 0,
    acquire: 30000,
    idle: 10000,
  },
};

Now, the setting up db configuration part is done. Next is to define the db model. To do so, create a folder called models inside app folder and initialize two files namely index.js and notes.model.js. Now, edit the index.js file as

const dbConfig = require("../config/db.config");

const Sequelize = require("sequelize");
const sequelize = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
  host: dbConfig.HOST,
  dialect: dbConfig.dialect,
  operatorAliases: 0,

  pool: {
    max: dbConfig.pool.max,
    min: dbConfig.pool.min,
    acquire: dbConfig.pool.acquire,
    idle: dbConfig.pool.idle,
  },
});

const db = {};
db.Sequelize = Sequelize;
db.sequelize = sequelize;

db.notes = require("./notes.model.js")(sequelize, Sequelize);
module.exports = db;

Also, edit the notes.model.js file as

const { sequelize, Sequelize } = require(".");

module.exports = (sequelize, Sequelize) => {
  const Note = sequelize.define("note", {
    title: {
      type: Sequelize.STRING,
    },
    description: {
      type: Sequelize.STRING,
    },
    published: {
      type: Sequelize.BOOLEAN,
    },
  });
  return Note;
};

Now, the model is all set. Last thing remaining to do is defining controller. To do so, create a folder called controllers inside app folder and initialize a file namely index.js inside controllers folder. Edit the index.js file as

const db = require("../models");
const Notes = db.notes;
const Op = db.Sequelize.Op;

exports.create = (req, res) => {
  if (!req.body.title) {
    res.status(400).send({
      message: "Content can not be empty !",
    });
    return;
  }

  const note = {
    title: req.body.title,
    description: req.body.description,
    published: req.body.published ? req.body.published : false,
  };

  Notes.create(note)
    .then((data) => {
      res.send(data);
    })
    .catch((err) => {
      res.status(500).send({
        message: err.message || "Some error occurred while create the Notes",
      });
    });
};

exports.findAll = (req, res) => {
  const title = req.query.title;

  Notes.findAll()
    .then((data) => {
      res.send(data);
    })
    .catch((err) => {
      res.status(500).send({
        message: err.message || "Some error occured while retrieving Notes",
      });
    });
};

exports.findOne = (req, res) => {
  const id = req.params.id;
  Notes.findByPk(id)
    .then((data) => {
      res.send(data);
    })
    .catch((err) => {
      res.status(500).send({
        message: "Error retrieving Notes with id=" + id,
      });
    });
};

exports.update = (req, res) => {
  const id = req.params.id;

  Notes.update(req.body, {
    where: { id: id },
  }).then((data) => {
    if (data) {
      res.send({
        message: "Note was updated successfully",
      });
    } else {
      res.send({
        message: `Cannot update Note with id=${id}`,
      });
    }
  });
};

exports.delete = (req, res) => {
  const id = req.params.id;

  Notes.destroy({
    where: { id: id },
  }).then((data) => {
    if (data) {
      res.send({
        message: "Note was delete successfully!",
      });
    } else {
      res.send({
        message: `Cannot delete Note with id=${id}`,
      });
    }
  });
};

Now, we can finally run the application. To do so run

node server.js

If you've provided valid credentials for db and followed the steps correctly, you'll see the message Server is running on port 8080 and we'll be able to test the endpoints on Postman. The test result will be similar to mine for create and getAll methods

Thanks for reading. You can find the code for the tutorial on Github

Managing Secrets with AWS SSM

Rajan Prasad — Wed, 26 Aug 2020 02:26:34 +0000

One of the most burning question i've come across while working in Serverless Architecture is "What's the right way to manage secrets in serverless applications?". The question might have many answers like hard-coding into the application, storing them as .env variables or using dedicated secret files.

But all of them requires you to write the secrets in the file you're working with, the files you might unknowingly push to GitHub. So is there no any better way ? The answer is: There is !! Using Parameter Store provided under AWS SSM. We will be using aws-cli/aws-console, aws-sdk with NodeJS to store and retrieve a MongoDB connection String.

Parameter store allows us to create different type of secrets like String type Key-Value Pair, StringList type Key-value pair. We will be using simple String type in our case as mongoDB connection string is just a normal String in the below format so just a simple key-value pair will do the trick.

mongodb+srv://user:password@mycluster-nqdzq.mongodb.net/dbname

Now, its to time create our Secret. In order to create the Secret, we will be using AWS Console. So Go to AWS Console, and search for SSM,
There will be a pop-up with Systems Manager , click on that and you'll be forwarded to SSM main page. Now on the left side, you'll find the Parameter Store. After clicking on that, there will be an option called Create parameter if you don't have any Secrets stored YET, if you already have any Secretes created, you'll be presented with the list along with Create Parameter Option, click on Create Parameter.

After clicking on Create Parameter, you'll be presented with a screen similar to :

Now, its time to fill up the values. Give it a suitable name, in my case i'll write NOTEAPP_CONN_STRING. Descriptions are optional, you can leave that blank, Choose Standard Tier and String in Type and paste the Mongo Connection String. You can also give it some tags which is totally optional, so you can just hit Create Parameter.

Now, its time to Access it through our Lamda Function. In order to access the Parameter Store, we first have to provide some IAM permissions.
Inside you .yml file under Provider Section in iamRoleStatements Section, copy/paste the following policies:

iamRoleStatements:
    - Effect: Allow
      Action:
        - "ssm:GetParameter*"
      Resource: "*"

Now, inside our handler function, what we will do is, we will simple console log the secret however you can do anything you want once you have the access. So our handler file will look something like this :

const AWS = require("aws-sdk");
const ssm = new AWS.SSM();

let param = {
  Name: "NOTEAPP_CONN_STRING", // Our Secret Name
  WithDecryption: true,
};

module.exports.handler = async (event) => {
    let request = await ssm.getParameter(param).promise();
    let conn_string = request.Parameter.Value;

   console.log(conn_string);
}

So we see that there is no trace of our Secret in our Code but it is stored in AWS. This is how you manage the secrets in Serverless applications