2017 - Tapsoft Tech Labs Pvt. Ltd.

December 19, 2017

Posted by shrikant_tapkeer

Comments Off

Writing Your First Dockerfile

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. Once you have a Docker file ready you can “build” this file into an image and then spawn a container based on this image. In this article we will create a simple Dockerfile to build an image with Ubuntu, Node.js, Express.js and a sample app installed into it.

Getting Started

A Dockerfile is nothing but a simple text file. Just create a plain text file in any of your favorite text editor and name it Dockerfile. This file should be in the project folder since we will be using the

Generally the convention is that you should name this file Dockerfile and keep this in your project folder.

The Dockerfile that we will be using will be as follows

FROM ubuntu:latest
WORKDIR /tmp
RUN apt-get update
RUN apt-get install -y --no-install-recommends apt-utils \
curl \
build-essential \
libssl-dev \
ca-certificates
RUN curl -sL https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh -o install_nv.sh
RUN bash install_nv.sh
RUN . "/root/.nvm/nvm.sh" && nvm install stable && nvm use stable
RUN apt-get install -y npm
RUN npm install express-generator -g
WORKDIR /srv
RUN ln -s /usr/bin/nodejs /usr/bin/node
RUN express -e
RUN npm install
EXPOSE 3000
ENTRYPOINT ["node", "bin/www"]

Once you have the Dockerfile in your project folder you can then use the following command to build the Docker image

$ docker build -t <image_tag> /path/to/docker_folder

Docker Build

Once the build starts you will notice the progress that happens with each line of instruction.

Step 1/15 : FROM ubuntu:latest – This step states that the Docker container will be based on the latest version of Ubuntu Docker image. So, our container will have Ubuntu as its operating system.

Step 2/15 : WORKDIR /tmp – This step is to change the directory. This is something like the cd command which is used in most Linux or UNIX based operating systems.

Step 3/15 : RUN apt-get update – This creates a list of packages for updates

Step 4/15 : RUN apt-get install -y –no-install-recommends apt-utils curl build-essential libssl-dev ca-certificates – In this step we start installing some required packages for Ubuntu which are used later. The -yswitch makes this an unattended installed.

Step 5/15 : RUN curl -sL https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh -o install_nv.sh – Here we are downloading Node Version Manager (NVM)

Step 6/15 : RUN bash install_nv.sh – This will install NVM in the container.

Step 7/15 : RUN . “/root/.nvm/nvm.sh” && nvm install stable && nvm use stable – This step installed the latest stable version of Node.js via NVM and sets it as the default version to be used in the container

Step 8/15 : RUN apt-get install -y npm – This step is going to install Node Package Manager (NPM)

Step 9/15 : RUN npm install express-generator -g – This step is going to install the Express app generator

Step 10/15 : WORKDIR /srv – We are now changing our directory to /srv where our app files will reside

Step 11/15 : RUN ln -s /usr/bin/nodejs /usr/bin/node – This step creates a “symlink” for the nodejs package so that the command node can work as expected

Step 12/15 : RUN express -e – This will create a barebones Express app in the /srv directory with the application folder structure

Step 13/15 : RUN npm install – This command will install all Node.js dependencies from the express apps package.json file

Step 14/15 : EXPOSE 3000 – This step exposes port 3000 to the host machine. This is the port where Express runs by default

Step 15/15 : ENTRYPOINT nodejs bin/www – This step says that when the container is started run the node bin/www command so that the Express app starts.

Start the Container

Once the image is built successfully you now have to run the container using this image. You can first use the following command to check if your image has been created

$ docker images

You should notice on your screen the image with the tag name that you may have given at build time if the build was successful

To run the container you can use the following command

$ docker run -p 3000:3000 -tid --name=<container_name> <image_tag>

You can use the following command to check if your container is running

$ docker ps -a

If your container has started without any errors then you can go to http://localhost:3000/ on your browser, where you should be able to see the Express’ default Welcome Page.

That’s it! Go ahead and create your own Dockerfile. A good place to look at various Dockerfiles to understand how all the other statements work will be http://hub.docker.com/

Level: Advanced

Technologies: Docker, Linux / Unix

post via Codincafe

December 7, 2017

Posted by shrikant_tapkeer

Comments Off

Test Drive Sails.js

We have been using Express.js for all our projects so far and there are have been no regrets. But it was time that we developed a Bolierplate template that consists of all the dependencies and repeated stuff like Session management, CSRF, File Uploads etc. that are often needed for every project. So we started working on it, but stumbled upon Sails.js. It’s true that Sails.js has been out there from a long time and we should have looked at it earlier, but we are glad that we worked on Express.js first, since Sails.js is built tightly on top of Express.js which makes it easier to understand the inner workings of Sails.js

One of the features that we thought was very cool is a very neat and tidy Models & ORM which works out of box with most of the SQL and No-SQL database. Sails.js makes use of Waterline adapter as its default ORM which can be used for data storage and retrieval for Node.js with support for MySQL, MongoDB, PostgreSQL, Redis, and more.

So, with all the nice features and bells and whistles ready to be used lets get started. This tutorial shows how to install and start your first app.

Installing Sails.js

Assuming you have Node.js and NPM installed you can install Sails.js with the following command

$ npm install sails -g

Once sails is install you can create your sails app with

$ sails new my-app

*Note: You can change my-app to the name of your project. A new project directory with the name supplied will be created

Starting your app

Once your project has been created you can start your app with the following command

$ sails lift

Once the app has started you will see the output as below in your terminal.

Your app will now started on the frameworks default port 1337

The main file where the app is spawned is app.js. So you can run the app with node, forever or any other way in situations where Sails CLI is not relevant or useful. We like to work with nodemon as it gives a nice way to watch file changes and restart the app automatically to speed up the development.

You can install nodemon by

$ npm install -g nodemon

The following command will start the app with nodemon

$ nodemon app.js

Once the nodemon starts the app, you will see the same app output as above and the app starts on port 1337. Now in your browser type http://localhost:1377 where you will see the default Sails.js home page. We will look where it comes from and how its handles in a little bit.

Level: Intermediate

Technologies: NodeJS

post via Codincafe

November 13, 2017

Posted by shrikant_tapkeer

Comments Off

Introduction to Google App Script

Google Apps Script is a scripting language based on JavaScript which allows a way to easily connect third party applications and build addons for Google Products.

More than 200+ million users worldwide use Google and their products. A lot of Google products are focused primarily on productivity suite. Hence there is a constant need to connect them with other third party applications and develop addons for various use cases.

Businesses use Google products such as Sheets, Docs, Slides etc. for day to day activities and collaborate in realtime. Google App Script gives a polished and easy to use wrapper for automating processes and fetching data from other channels. This helps in creating a perfect ecosystem comprising of all different systems.

In this article we will look at a quick tutorial on how to create a simple App Script for Google Sheets which will fetch data from an API and populate in the spreadsheet.

Create New Google App Script Project

To start with, lets create a new Google App Script project. To do this create a new Sheet in Google Drive and give it an appropriate name. Open the sheet and click on Tools -> Script Editor.

A script editor window will open and new Google App Script project specific to the sheet will be created. Give the project an appropriate name for identification. You will notice the script editor is like a basic IDE where we will be writing our code. We will create a basic app script and hence only a single file is sufficient.

Your First Function

Lets write your first function. This is a simple function to call a REST API and get data. We are using a REST API tester from https://jsonplaceholder.typicode.com/users to get dummy data in JSON format. Add the below function in your script editor.

var API_URL = 'https://jsonplaceholder.typicode.com/users' //Test API URL from jsonplaceholder.typicode.com

function getData() {
    var response = UrlFetchApp.fetch(API_URL); //Fetch data from a given API URL
    var json = response.getContentText(); //Get data content responded from API URL. This is returned as text
    var data = JSON.parse(json); //Parse the text data as JSON
    Logger.log(data) //This will log the JSON response from API
    return data //Return JSON object recevied from API
}

To run the script select your function from the dropdown on the top and then press the play button.

google-app-script-run-function-codincafe (1)

Google script will determine what permissions will be required from the users profile in order to execute the function and present you with the Authorization window. Click on “Review Permissions” and allow the script to access your account. Don’t worry you are authorizing your own app script to access your account and nothing else.

After the permissions are granted the script will execute. Now press Ctrl + Enter (Cmd + Enter on Mac) to open the Logger window. This widow will show you all the data that has been fetched from the API

Well done! You have now successfully fetched data from a third party API into Google App Script.

Add Data to Sheet

Now, lets look at how you can auto populate data received from the API into the sheet.

The data received from the API is an array of JSON objects. Here is one of the sample JSON object

{
    "id": 1,
    "name": "Leanne Graham",
    "username": "Bret",
    "email": "Sincere@april.biz",
    "address": {
      "street": "Kulas Light",
      "suite": "Apt. 556",
      "city": "Gwenborough",
      "zipcode": "92998-3874",
      "geo": {
        "lat": "-37.3159",
        "lng": "81.1496"
      }
    },
    "phone": "1-770-736-8031 x56442",
    "website": "hildegard.org",
    "company": {
      "name": "Romaguera-Crona",
      "catchPhrase": "Multi-layered client-server neural-net",
      "bs": "harness real-time e-markets"
    }
  }

Lets go ahead and add the name, email, phone and website properties from the object to our spreadsheet.

Paste the below function after getData and now run the populateSheet function.

function populateSheet() {
         var data = getData(); //Get JSON data from the above function
         var sheet = SpreadsheetApp.getActiveSheet();
         var lastRowCount = sheet.getLastRow(); //Get the last row
         var header = ['Name', 'Email', 'Phone', 'Website']; //These will be the column headers in the sheet
         sheet.clear(); // Clear the sheet if needed
         sheet.getRange(1, 1, 1, header.length).setValues([header]); //Add column header in first row
         /* Start adding data from API after column header */
         for (var i = 0; i < data.length; i++) {
         var row = [];
         var nextRow = sheet.getLastRow() + 1;
         row.push(data[i].name, data[i].email, data[i].phone, data[i].website) //Transpose data from JSON in an array
         sheet.getRange(nextRow, 1, 1, row.length).setValues([row]); //Set data to the
         }
  }

You will again be presented by the Authorization screen since some additional permission are required in the populateSheet function. If you get an error that this app is not authorized, then click on Proceed anyway and complete the steps and grant permissions.

Once the function is finished open the Spreadsheet from where you opened the script editor. Voila! Your data from the API has been populated in the spreadsheet.

You have successfully created a Google App Script which gets data from a third party API and populates to the sheet. Go crazy and start developing your addons. We will be posting more articles on some advanced development with app script. Stay tuned!

I am text block. Click edit button to change this text. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.

Level: Intermediate

Technologies: JavaScript

post via Codincafe

Writing Your First Dockerfile

Writing Your First Dockerfile

Writing Your First Dockerfile

Getting Started

Docker Build

Start the Container

Test Drive Sails.js

Test Drive Sails.js

Installing Sails.js

Starting your app

Introduction to Google App Script

Introduction to Google App Script

Create New Google App Script Project

Your First Function

Add Data to Sheet

I Want To Digitally Transform My Business

Head Office

EMAIL

PHONE

CONNECT

© 2022. Tapsoft

Quick Links