DEV Community: Dhruv

Writing my first AWS Lambda Function

Dhruv — Mon, 08 Apr 2019 14:23:35 +0000

First things first, Lambda functions are incredible!

The best part about Lambda is that you only pay for the time the function is running which saves you a lot of money compared to running a 24x7 AWS EC2 instance.

To get a Lambda function working we need three things in place — A working code, a trigger, and a monitoring tool.

Trigger, as the word suggests is used to invoke the function. Currently, AWS has 12 ways to trigger any Lambda Function.

API Gateway
AWS IoT
Application Load Balancer
CloudWatch Events
CloudWatch Logs
CodeCommit
Cognito Sync Trigger
DynamoDB
Kinesis
S3
SNS
SQS

Here I will discuss 3 of these which I have used until now.

Creating a Lambda Function

Login to your AWS Console. Within the console, you can find AWS Lambda under Services which takes you to the Lambda console.

Lambda Console Page

This is what you’ll see if this is your first Lambda. Click on the Create a function button to start with your first function.

You’ll be taken to the setup page where you configure the function (name, runtime, role). You can create a Lambda from Blueprints or Serverless Application Repos. I used the *Author from scratch * option.

Create a Lambda Function Configuration

After deciding on what to call my function I can choose my runtime, AWS has a lot of supported languages and versions (.Net, Go, Java, Node.js, Python, Ruby). I use Node.js 8.10 for most of my projects. You’ll have to create a new role if you don’t already have one.

Writing My Lambda Function Code

AWS gives me 3 options to write my code

Using the inline code editor (Recommended if your code is short and uses only amazon dependencies like S3)
Uploading a zip folder (Recommended if you are using non-amazon dependencies)
Uploading a file from S3 (Recommended if your zip > 10MB)

After writing the code you can alter the configuration if you want. I had to increase the default timeout of 3s for my use case.

Hit the Save button and boom your lambda function is ready!

Taking a TDD approach you can always test your code. You can also configure your test events!

Test your Amazon AWS Lambda Function

Creating a trigger

I have used API gateway and CloudWatch Events for all my projects until now. You can add a trigger by selecting your favorite option from the list when you open your function.

Adding a trigger for Lambda Function

Configure API Gateway

You can select an existing API or you can configure a new. If this is your first time you can find AWS API Gateway under Services which takes you to the API Gateway console.

Amazon API Gateway Configuration

Hit that Get Started button and it will take you to the configuration page. Choose the protocol, enter the name, description, etc and create your new API

Create a new method as per your use case and integrate it your lambda function. After saving you will get an endpoint for your REST API. Requesting this endpoint will trigger your lambda function.

Creating a method in Amazon API Gateway

Configure CloudWatch Events

You can select an existing role or you can create one. Creating a new rule requires you to enter a name, description, rule type, etc. In scheduled expressions, you can set up a Cron. All Cron expressions are in UTC.

cron(0 17 ? * MON-FRI *)

this triggers your lambda function at 17:00:00 GMT Monday to Friday.

Monitoring

Another good thing about Lambda (AWS in general) we can monitor various events like invocations, time durations, errors, etc.

Monitoring in AWS Lambda

CloudWatch Logs gives you insights about execution start, execution end, request length, memory used for every execution.

If you’ve reached this far I hope you have fun exploring the serverless architecture :)

This post was originally published on medium

Writing ES6 in your Node.js Applications

Dhruv — Mon, 27 Aug 2018 09:53:26 +0000

ES6 (ECMAScript 2015) is the latest stable version of JavaScript. It includes new language syntaxes and implementations for the language. Three years later implementation of these new features in JavaScript engines is still ongoing but you'd still like to write your code in ES6 because who wants to stay behind in this industry.
We'd be using Babel here to convert our ES6 code that can be understood by the existing Javascript engines. Babel is a compiler that allows us to write ES6 features in JavaScript and run it in the older/existing engines.
How to set up Babel with your Node.js App

You should have the latest node.js installed and running on your machine.
Create a new project or run and move to this directory

$ mkdir new_project $ cd new_project
Create a file app.js and write some ES6 code in there

import request from 'requests'; let helloWorld = 'Hello World!`; console.log(`${helloWorld} this is some ES6 JavaScript code`);
Create a package.json file by running npm init . Enter the required details or press return for fields you do not recognise. At this point your package.json should look like this

{ "name": "es6project", "version": "1.0.0", "description": "using babel with node", "main": "app.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "author": "", "license": "ISC" }

Install babel and babel preset as a dev dependency

$ npm install -D babel-cli $ npm install -D babel-preset-es2015

Babel uses different plugins to enable different features. In our case we can use the es2015 plugin. We will need to create a .babelrc configuration file.

$ touch .babelrc

and paste the following in the file

{ "presets": ["es2015"] }

Create an npm build command to compile your ES6 Javascript. Modify your package.json with

"scripts": { "test": "echo \"Error: no test specified\" && exit 1", "build": "babel --presets es2015 -d lib/ src" }

this compiles all of your ES6 code in the src directory to the lib directory.
You should see your code compiled in the lib directory and now you are good to go and run this.This code is present in the this Github repository.

This post was originally published on medium

Do you think dev.to should have an API to so that you can list your posts/activity on your websites etc. ?

Dhruv — Fri, 23 Mar 2018 09:30:19 +0000

Why you should code in vanilla too

Dhruv — Fri, 16 Mar 2018 12:20:45 +0000

In the past few years I’ve become the guy who likes vanilla everywhere, ice cream, shakes, cakes or code.

Just like almost (everyone) I started out building websites with jquery because it was comparatively easy to grasp/understand and involved less code to write. Then there was the angular boom and I started building projects on AngularJS.

Even though I used to write vanilla javascript here and then but as my projects grew bigger the bugs became difficult to understand.

Yes frameworks will help you build things faster. Yes frameworks are here to make things easier. But as your project grows there comes a time when you know there is something wrong but do not why. Frameworks are built to solve specific types of problems and hence we have different frameworks to solve different types of problems. And as your project grows you’ll have different use cases and different problems, and I guarantee you all the time you saved by using a framework will be lost to solving a bug that you have no idea about.

Now I’ll tell you why you should write more and difficult (not) code.

Lightweight Applications
Adding any dependency automatically increases your app size, more http requests and more load time.
File size (minified) for the most used JavaScript libraries/frameworks:
Vue: 58kb
Jquery : 93kb
React: 98kb
Angular 1.x: 143kb
Ember: 435kb
Angular 2: 566kb
No Dependency
You own your project completely. You know your project in and out. If there is a bug/feature request that you need then you don’t have to wait and hope for the next version of your library/framework or worse add an an extra dependency to get things done.
Learn New Things
When you do not have any abstract layer you tend to explore and learn new things. You’ll look for solutions that the language provides and you’ll get to know the hidden gems of JavaScript. Your understanding of the language becomes better and obviously you understand your project better.
Contributing to open source
All (Mostly) libraries you use are written in vanilla JS. Since now you have a better understanding of JavaScript you can quickly understand the big codebase of any library and contribute to them.
Better security
Yes you read this right. By using libraries you might be making your website more vulnerable or might be risking your user data. There is a chance some external dependency is taking your user data and sending it to their servers. For more details read this post.
Dive into server side
With better understanding of the language you can easily work node.js (built on v8) and can finally write your own backend.

This was originally published on Medium

Using nvm

Dhruv — Mon, 05 Mar 2018 13:31:23 +0000

If you work on more than one project at a time or you do a lot of open source work or you decide to go back to a project you did a year ago there is a very high chance you will have to change your node.js version. There might be a few dependencies that will work only on a specific node.js version. You can use nvm to change your node.js versions in a second.

If you already do not have nvm installed. Download and install the latest version of nvm.
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash

Check your nvm version by
nvm – version

To download and install a new version of node.js run
nvm install 8.2
Replace 8.2 with the version number you need.

To check what versions of node.js are installed on your system run
nvm ls
This will list out all the versions you have installed.

To switch to any node.js version you need run
nvm use 8.2

If you do not want any particular node.js version you can uninstall it by
nvm uninstall 8.2

You can set the default node.js version by setting an alias
nvm alias default v9.3.0

This was originally published on Medium

Essential git commands every developer should know

Dhruv — Thu, 28 Sep 2017 12:25:00 +0000

If you’re one of those developers who still don’t use any version control system, I don’t know how you’re still managing to get work done.
In this post, I’m focusing on important git commands that gets all (almost) your work done ( I know you’re a GUI person ).

1) git config

Utility : To set your user name and email in the main configuration file.
How to : To check your name and email type in git config --global user.name and git config --global user.email. And to set your new email or name git config --global user.name = “Dhruv Nenwani” and git config --global user.email = “nendhruv@gmail.com”

2) git init

Utility : To initialise a git repository for a new or existing project.
How to : git init in the root of your project directory.

3) git clone

Utility : To copy a git repository from remote source, also sets the remote to original source so that you can pull again.
How to : git clone <:clone git url:>

4) git status

Utility : To check the status of files you’ve changed in your working directory, i.e, what all has changed since your last commit.
How to : git status in your working directory. lists out all the files that have been changed.

5) git add

Utility : adds changes to stage/index in your working directory.
How to : git add .

6) git commit

Utility : commits your changes and sets it to new commit object for your remote.
How to : git commit -m”sweet little commit message”

7) git push/git pull

Utility : Push or Pull your changes to remote. If you have added and committed your changes and you want to push them. Or if your remote has updated and you want those latest changes.
How to : git pull <:remote:> <:branch:> and git push <:remote:> <:branch:>

8) git branch

Utility : Lists out all the branches.
How to : git branch or git branch -a to list all the remote branches as well.

9) git checkout

Utility : Switch to different branches
How to : git checkout <:branch:> or **_git checkout -b <:branch:> if you want to create and switch to a new branch.

10) git stash

Utility : Save changes that you don’t want to commit immediately.
How to : git stash in your working directory. git stash apply if you want to bring your saved changes back.

11) git merge

Utility : Merge two branches you were working on.
How to : Switch to branch you want to merge everything in. git merge <:branch_you_want_to_merge:>

12) git reset

Utility : You know when you commit changes that are not complete, this sets your index to the latest commit that you want to work on with.
How to : git reset <:mode:> <:COMMIT:>

13) git remote

Utility : To check what remote/source you have or add a new remote.
How to : git remote to check and list. And git remote add <:remote_url:>

These are the commands that I feel are essential and get things done, at least for me. Comment here if you think I’ve missed something important or if something can be done differently.

This was originally published on Medium

Writing your own npm module

Dhruv — Wed, 16 Aug 2017 12:32:28 +0000

What is npm?

npm stands for node package manager. npm makes it easy for developers to share code. Like every other package npm packages also have a manifesto file called package.json.

Installing node.js and npm

Best way of downloading node.js is to use the node installers from the node.js website. It is also good to have nvm(node version manager) to switch between different versions of node. Node.js comes with npm but it is best to update your npm. Run the following command to update your npm.

npm install npm@latest -g

Creating a package.json file

package.json has

the list of dependencies your package depend on.
specify the versions of the packages you’re using
makes it easy to reuse your package to make a package.json file run

npm init

it will ask for some details like

name : name of your package
version : version of your package
description : what your package does
main : file that will have your main code (ideally should be index.js)
scripts : any scripts you want to run after , like tests or bower
author : who the package belongs to
licence : licence
you can also manually edit this file and add your dependencies. In the end your package.json will look something

{
  "name": "my_package",
  "description": "",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/username/my_package.git"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/username/my_package/issues"
  },
  "homepage": "https://github.com/username/my_package"
  "dependencies": {
    "my_dep": "^1.0.0"
  }
}

Writing your package

You write your script in the index.js you mentioned in the package.json. As mentioned you can use already published packages in your package.

var request = require('request');
exports.printMessage = function(){
  console.log("This is my npm package. Wohoo !");
}

Here I’m using request module to make an HTTP call.
To make your functions to be used , you need to export them. Here I export my printMessage function.
When people use your package they will npm install myNewPackage

var myPackage = require('myNewPackage');
myPackage.printMessage() // This is my npm package. Wohoo !

Publishing your npm package

To publish your package you must have an account on npm registry. Either make an account on the website or run

npm adduser

If you already have an account run

npm login

To check if you’re logged in run

npm whoami

It should prompt your username.
When you are done with all of this just hit

npm publish

and boom you’ve your npm package published.

Updating your npm package

When you’re done updating your package just change the version in your package.json and hit npm publish, your npm package will be updated.

Originally published on medium.

Deploying your Node.js , mongoDB app on Google Cloud for free

Dhruv — Thu, 01 Jun 2017 14:10:38 +0000

This post focuses on how to deploy your node.js application on Google cloud. Yes it is free, well not technically but you get free $300 credits for a year on a new sign up (yay!).
You’ll need to sign in to your Google Cloud from an existing google account and enter into your console.
Start with creating a new project. Now we can either create a new App Engine instance or a new Compute Engine instance. I’ll be creating a Compute Engine instance.
From the navigation on the left, go to compute engine → VM instances. Create a new VM instance. Fill in the details as per your needs. Although you can only use 3 machine types if you want your whole year to be free.
1) [shared] micro CPU, 0.6GB memory
2) [shared] small CPU, 1.7GB memory
3) CPU, 3.75GB memory
Third option won’t last for whole year though.

Now you have a machine where you have to deploy your code. SSH your way through.

Things you’ll have to do on your VM now

Installing node.js

Install the latest node.js version or any particular version you want. You can follow this guide to install node.js.

Installing mongoDB

Install the latest mongoDB version or any particular version you want. You can follow this guide to install mongoDB.

Putting code in place

Put your code wherever and however you want to. It’s always better to use git for your projects, shall talk about git and it’s importance in sometime in some other post.

Once you are done with all these things you can run your application. But hold on you still can’t access it from any external source(like your browser). You need to open a port your application is running on.

Opening any port from Google Cloud Console

From the navigation on the left, go to Networking → Firewall Rules.
Create a new firewall rule, fill in the required details and bam you’re up!

Source filter for IP range is to specify from which all IPs you want it to be accessible, in case of any write 0.0.0.0/0.
Congrats you’ve successfully deployed your application on Google Cloud.

Originally published on medium.