Forem: ckmonish2000

Terraform 101

ckmonish2000 — Tue, 06 Dec 2022 14:47:20 +0000

Infrastructure as code makes our lives easy by allowing us to deploy our servers by describing the configurations for our infrastructure as code.

When you're setting up your servers you go through a 3-step process i.e

Provision your servers: You create your EC2 instances, S3 buckets etc...
Configure your servers: You install docker or some other software that will help you during the application setup.
Application setup: You setup your app in production or test mode.

All the above steps are time consuming processes hence we can automate each of the above step by:

Provisioning our infrastructure using tools like terraform or cloud formation.
Managing Configurations using ansible or puppet
Finally containerizing your application to make sure it runs the same everywhere with docker or vagrant

In this post we'll learn about basics of provisioning tool called terraform.

Terraform is an infrastructure provisioning tool similar to AWS's cloud formation or the serverless framework which allow you to manage resources via code.

Install Terraform

You can setup terraform by downloading a binary file and adding it to your system PATH from here.

Basic Concepts

Terraform has its own language called HCL (Hashicorp configuration language) through which you have describe your infrastructure.

you define all your configs in files that have a .tf extension.

Terraform supports various cloud providers like AWS, GCP and much more in order to manage infrastructure on these platforms terraform has plugins.

plugins are of 3-types:

Official - These are plugins created and maintained by Hashicorp eg: AWS, Azure, GCP and etc....
Verified - These are plugins created and maintained by Hashicorp's partners like Linode, Digital Ocean and etc....
Community - These are plugins built and maintained by the community.

you can learn more about plugins from here

Basic commands

Once you define your config you can create your resources using 3 basic commands in a sequence:

terraform init: This command looks at your config and downloads all the plugins that's required to create and manage your resources.
terraform plan: Before actually creating your resources, you can review the changes that will be made to your infrastructure using this command.
terraform apply: finally running the apply command will create your resources

Creating your first resource with terraform

The first resource we'll be creating will be a file.

So, first create a file with a .tf extension and add the code down below.

In terraform everything is defined as a block and the above image we are using something called a resource block the resource block takes 2 arguments first is the resource type and second is a logical name for your resource.

In the resource type argument the keyword before the _ indicates the provider we are using in this case it's an official provider from hashicorp called local and the keyword after the _ indicates the resource provided by the provider.

another example can be aws_s3_bucket where aws is the provider and s3_bucket symbolizes the S3 feature provided by aws.

Each block expects you to enter a few key value pairs to function,
Here the resource block's key value pair will change depending on the provider and resources being used.

In the above image the local_file provider expects us to pass the filename key which will create a file in the provided path and the content key specifies what content will be added to the newly created file.

No if you run terraform init, plan, apply you'll see a new file created with the name pet.txt with the content hello pets

Using variables

Terraform allows us to define variables and use them in our config file.

you can learn about the variable types supported by terraform here

you can create a variable by starting the block with the variable keyword,

Each keyword block expects you to enter a default value and if required you can enter a variable type.

if you do not enter a default value terraform will require you to enter a default value when you run the apply command.

you can also set a default value by passing the value while running the apply command using the -var flag or you can initialize your variables using a .tfvar file.

You can also export the value for variables as an environment variable.

you can use the variable in your config like this var.test

here's a more complex variable for your reference

let's access the name of the dog and print it in the console.

You can print values from terraform using the output block and the output block expects you to provide it a value to print.

now when you run the terraform apply command you will see the output in your console.

Resource Dependency

There are times where we might want to supply the output of one resource as an input to another resource or we might want a resource B to be created after the creation of resource A we can achieve this with resource dependency.

There are 2 types implicit and explicit

Implicit Resource Dependency

We can use the output of one resource to be the input of another by referencing the resource using the resource type followed by the resource's logical name and one of the property that's being returned by the resource.

here in our case, we are using the random provider and resource pet that returns and id.

Now run apply the changes and see what happens.

Explicit Resource Dependency

using references will make your resource implicitly dependent but if you want to explicitly make a resource dependent, we can use the depends_on key in the resource block like in the image below

Now if you have a look at the console the resource time is created first following the petz resource.

Terraform Lifecycle

Generally, in terraform most of the time when you make a change the resource block the resource is completely destroyed and recreated.

For example, say that you change the name of the file the file will first be deleted then a new copy will be created but there are times where you might want the old file to be deleted only when the new one is up and running you can achieve that using the lifecycle block.

there are 3 types create_before_destroy, prevent_destroy and ignore_changes

create_before_destroy: when set to true will first create the new resource and then delete the old one.

resource "azurerm_resource_group" "example" {
  # ...

  lifecycle {
    create_before_destroy = true
  }
}

prevent_destroy: when set to true will cause Terraform to reject with an error any plan that would destroy the infrastructure.

ignore_changes: Accepts a list of attributes it should ignore when changed.

resource "aws_instance" "example" {
  lifecycle {
    ignore_changes = [
      tags,
    ]
  }
}

These are the basic concepts of terraform which will help you provision and manage your resources.

If you are looking for resources on how to use terraform with cloud providers stay tuned will soon publish how to setup your linode and digital ocean instances using terraform.

Also checkout Getting Started With Terraform on AWS.

Thanks for the read.

Build a Todo list with AWS Lambda and DynamoDB

ckmonish2000 — Tue, 29 Nov 2022 09:40:12 +0000

In this post we will be building simple CRUD API to manage tasks and in the upcoming posts we will use this project as a base to explore other AWS services.

But in order to follow along with this post you need to have a basic understanding of DynamoDB and how to setup your lambda function and DynamoDB database using the serverless framework.

So, let's begin

Project structure

The code is structured using a service-oriented approach where we basically follow a 3-layer architecture.

The main advantage of using the 3-layer-architecture is that it creates a level of abstraction and allows you to manage your code base more efficiently.

So, create a folder called src and create 3 files:

functions.js - which basically is your controller
io.js - which will be your service layer
model.js - which will be your data access layer

Tips

Before we start just want to drop in few serverless commands that will speed up your deployment and debugging process.

serverless deploy function --function functionName
serverless logs -f functionName -t

The first command allows you to only deploy a single function rather than your entire infrastructure.

The second command allows you to view the logs for a given function.

Database operations

Now in the model.js file we will define all the operations we will be performing on the todo table.

In the code below I'm creating a class called Todo which will contain the respective methods fetchAll fetchById put deleteById.

You can follow the DynamoDB 101 post to understand how it works

const aws = require('aws-sdk');

class Todo {
  client = new aws.DynamoDB.DocumentClient();
  TableName = "todoTable"

  async put(Item) {
    const params = {
      TableName: this.TableName,
      Item
    }
    const result = await this.client.put(params).promise()

    return true
  }


  async fetchById(key) {
    const params = {
      TableName: this.TableName,
      Key: {
        userId: key
      }
    }
    const result = await this.client.get(params).promise()
    return result.Item
  }

  async fetchAll(key) {
    const params = {
      TableName: this.TableName,
    }
    const result = await this.client.scan(params).promise()
    return result.Items
  }

  async deleteById(key) {
    const params = {
      TableName: this.TableName,
      Key: {
        userId: key
      }
    }
    const result = await this.client.delete(params).promise()
    return true
  }
}

module.exports = new Todo();

Service layer

This layer will basically encapsulate your business logic since this is a basic todo app we'll just extract the body and rout parameter from the request and return it.

module.exports = {
  input: (event) => JSON.parse(event.body),
  params: (event) => event.pathParameters
}

Controller

This section of the project will contain all your function logic that we'll link in the serverless.yml file in a sec.

if you're not sure how to write your functions checkout the post on serverless functions for dummies

'use strict';
const io = require('./io')
const Todo = require('./model')

const getAllTasks = async (event) => {
  const data = await Todo.fetchAll();
  return data
};


const taskById = async (event) => {
  const { id } = io.params(event)
  const data = await Todo.fetchById(id);
  return data
}

const createTask = async (event) => {
  const body = io.input(event);
  const data = await Todo.put(body)
  return JSON.stringify({ message: "created task" })
}

const updateTask = async (event) => {
  const body = io.input(event);
  const data = await Todo.put(body)

  return JSON.stringify({ message: "updated task" })
}

const deleteTask = async (event) => {
  const { id } = io.params(event)
  const data = await Todo.deleteById(id);
  return JSON.stringify({ message: "deleted task with id = " + id })
}


module.exports = {
  getAllTasks,
  taskById,
  createTask,
  updateTask,
  deleteTask
}

Serverless config

Try to setup the serverless configs on your own, the below code is just for your reference.

'use strict';
const io = require('./io')
const Todo = require('./model')

const getAllTasks = async (event) => {
  const data = await Todo.fetchAll();
  return data
};


const taskById = async (event) => {
  const { id } = io.params(event)
  const data = await Todo.fetchById(id);
  return data
}

const createTask = async (event) => {
  const body = io.input(event);
  const data = await Todo.put(body)
  return JSON.stringify({ message: "created task" })
}

const updateTask = async (event) => {
  const body = io.input(event);
  const data = await Todo.put(body)

  return JSON.stringify({ message: "updated task" })
}

const deleteTask = async (event) => {
  const { id } = io.params(event)
  const data = await Todo.deleteById(id);
  return JSON.stringify({ message: "deleted task with id = " + id })
}


module.exports = {
  getAllTasks,
  taskById,
  createTask,
  updateTask,
  deleteTask
}

now run serverless deploy and try out your apis using postman.

How to setup DynamoDB with serverless framework for dummies

ckmonish2000 — Thu, 24 Nov 2022 18:23:16 +0000

In this post you will learn how to setup a DynamoDB table with infrastructure as code using the serverless framework which will act as a base for the future posts.

let's begin

Project set up

first checkout to your project directory and run the below command create a serverless project.

serverless create -t aws-nodejs

now you should have a simple boilerplate with a serverless.yml and handler which allows us to setup everything from the API gateway to DynamoDB by ourselves.

Adding an API Gateway to your handler

Under the handler property add another key called events which accepts an array of events you can learn more about events here
we are going to use the http api event to trigger the function so add httpApi as the first event and under httpApi add 2 more properties one called method and another called path where method is the request method Type and path specifies your endpoint.

now if you run sls deploy -v a lambda function with an api gateway must be created.

Setting up DynamoDB

There is something called AWS cloudformation which is an IAC solution provided by AWS which allows you to setup and manage your AWS services,

The serverless framework follows the cloudformation template to create and manage services and that's the reason you won't find a detailed docs for setting up AWS resources on the serverless's website.

So, let's begin by creating out DynamoDB table:

At the end of your serverless.yml file add the properties down below, this is where you will define all the AWS resources you are going to use in your serverless project.

resources:
  Resources:

Now under Resources define a new property give this property a name of your choice (This is like a service name for your resources)

resources:
  Resources:
    TodoTable:

Now just remember the key value pair data below this property will change depending on the AWS resource you are using, but all your services will have one property in common called Type where you will have to tell serverless which service from AWS you want to create here we are creating a DynamoDB table

resources:
  Resources:
    TodoTable:
      Type: AWS::DynamoDB::Table

if you have followed my previous post you would know that we have to define the primary key for every table and that's we are doing under AttributeDefinitions and KeySchema

AttributeDefinitions is used to define the column by giving it a name and datatype here we are giving it a name of userId and type of string
KeySchema is used to tell which column we are going to use as a primary key and define the type as hash or range

resources:
  Resources:
    TodoTable:
      Type: AWS::DynamoDB::Table
      Properties:
        AttributeDefinitions:
          - AttributeName: userId
            AttributeType: S
        KeySchema:
          - AttributeName: userId
            KeyType: HASH

Finally, we are going to add las 2 properties called TableName and BillingMode where both are self-explanatory.

resources:
  Resources:
    TodoTable:
      Type: AWS::DynamoDB::Table
      Properties:
        AttributeDefinitions:
          - AttributeName: userId
            AttributeType: S
        KeySchema:
          - AttributeName: userId
            KeyType: HASH
        BillingMode: PAY_PER_REQUEST
        TableName: ${self:custom.TableName}

now if you run the deploy script it will create you an DynamoDB table.

Adding IAM role

If you remember from a previous post in the series your functions don't have permission to access DynamoDB, so we need to create a IAM role and assign it to your function, we also automate that task using the serverless framework.

We need to add all the IAM related properties under the provider block of your serverless.yml file
Add the following line under the provider block, and under statements you are going to define all the permissions your IAM user is going to have.

iam:
    role:
      statements:

Add a new property under statements called Effects it's an array element you can have multiple effects and under effects define a new key called actions which accepts an array here you will define all the actions your IAM user can perform.

iam:
    role:
      statements:
        - Effect: 'Allow'
          Action:        
            - dynamodb:Query
            - dynamodb:Scan
            - dynamodb:GetItem
            - dynamodb:PutItem
            - dynamodb:UpdateItem
            - dynamodb:DeleteItem

Finally, you have to specify which resource will your function have access to under the Resource property

Here you have 2 options

Directly copy paste you table ARN here

Or you can follow the method mentioned below where you will pass the Table Service name you have created under resources as the first element in the array and serverless framework will automatically fetch the ARN for your specified resource.

provider:
  name: aws
  runtime: nodejs12.x
  region: us-east-1
  iam:
    role:
      statements:
        - Effect: 'Allow'
          Action:        
            - dynamodb:Query
            - dynamodb:Scan
            - dynamodb:GetItem
            - dynamodb:PutItem
            - dynamodb:UpdateItem
            - dynamodb:DeleteItem
          Resource:
            - Fn::GetAtt: [ TodoTable, Arn]

Now if you run the deploy command, you'll see a new IAM user has been created and now your function will be able to access the DynamoDB table created.

Stay tuned in the next post we will build our first CRUD app and use it's as a base to explore other AWS services.

Intro to Infrastructure as code (Serverless framework)

ckmonish2000 — Fri, 18 Nov 2022 14:16:05 +0000

If you have followed the previous posts about creating lambda functions, you would have realized that it's a pain in the ass to configure the infrastructure manually using the AWS console, you always wonder if there's an easy way of setting up your infrastructure and honestly there is, and it's called infrastructure as code.

What is infrastructure as code?

Let me give you an example to understand infrastructure as code

If you have used an ORM (like prisma, typeORM or DjangoORM) in your project to connect to your database, you know that it generally is a twostep process

where you first describe how your tables are going to look and then you run a migration which converts your code into SQL tables.

Similarly in infrastructure as code you describe your infrastructure in something called a YAML file (similar to JSON) and then you run a migration script which will setup your infrastructure according to the description provided.

In this post we are going to use a framework called serverless which specifically is used for you guessed it serverless infrastructure setup on various platforms like AWS, Cloudflare and etc...

But if you're interested in diving deep checkout Terraform or Ansible.

So, let's start

Install AWS CLI

Serverless framework uses the aws cli to perform migrations so follow the below steps to setup AWS-CLI on windows.

First, download and install the AWS-CLI
Now check if the AWS-CLI was installed properly by running the following command in your terminal aws and you should get a output like the image below.

Add new IAM user

This is the only manual step to start with, The serverless framework is going to use the aws cli to execute tasks on your aws account so you need to provision your aws-cli with the creds to access your aws account

Search for IAM in the search bar and select users.

Select add users

give the user a name and provide programmatic access as we will be creating resources through code and hit next.

For the purpose of this post provide the user administrative access but do not do it in a live project and hit next and create the user.

Now you must see access code and secret key which we will just use in a second and make sure you don't share this with anyone.

Now in the terminal run the command below and it will ask for your access key enter that followed by the secret key and hit enter until the process exits.

aws configure

Setup serverless framework

First, we have to install the serverless framework globally by running

npm install -g serverless

now that you have installed the serverless framework checkout to the location of your choice.

Setup your lambda function with code

Run serverless in the terminal you'll see that it gives you a variety of options to choose from choose AWS - Node.js - HTTP API and hit enter and select a project name and hit enter.

select no for all the following options and continue.
now cd into your serverless project directory and you should see the following:

There are 2 main files which needs to be explained

The handler.js file.
The serverless.yml file.

if you first open the handler.js file you'll notice that it's the code for your lambda function.

and the serverless.yml file is where you describe your infrastructure let me explain the instructions line by line.

YAML file store key value pair data just like JSON.

In the service key we pass in the service name that will be displayed on your aws lambda console like in the image below. (FYI the naming in the console has 3 properties service name, stage name and the function name all separated by "-".)

The frameworkVersion specifies which version of serverless framework we are using.
The provider key is used to configure your cloud provider
- name here specifies which cloud provider you're using.
- runtime specifies which programming language you're using.

(FYI: the provider block might look different for other cloud providers you look it up here)

Under the functions block you are telling serverless framework where to find your functions and you're linking an API gateway to your function.
- handler tells you where to find your function
- events accepts an array of values where you can specify how you want to trigger the function call, here we are using the httpApi (API Gateway) to trigger the function which in turn asks you to specify the API path and method to invoke the function.

Let's deploy the function

In order to deploy this function all, you have to do is run the command down below.

serverless deploy

now if you go to your lambda console you should see that your function 's deployed.

Will share how to create a DynamoDB and S3 instance in the next post.

Thanks for your time.

DynamoDB 101

ckmonish2000 — Tue, 15 Nov 2022 17:04:03 +0000

This post is written considering you're a fresher to DynamoDB and it only explains the basic concepts that's required to perform CRUD operations.

The language used in this post in node.js but the underlying concepts are same no matter which language you choose.

What is DynamoDB?

DynamoDB is a fully managed No-SQL database as a service provided by AWS.
DynamoDB is super-fast where you get responses in single digit seconds.
It's infinitely scaleable on demand
The data values in DynamoDB are stored on an SSD which makes it fast, reliable and extremely secure.

How is the Data Stored?

The items in DynamoDB are stored in tables.
Each item in the table contains 2 things a key (which is again of 2 type) and a value which are in the document format.
A table can store infinite number of items, but each item must not exceed the size of 400kb.
Your tables have 2 types of keys a primary key which is mandatory (Think of it like the primary key in SQL) and then we have a sort key which is optional (think of it as the foreign key in SQL).
If you have a primary key alone then each value must be unique but if you're pairing it with a sort key the combination of your primary and sort key must be unique (this helps you filter values efficiently).

Setup DynamoDB

Please follow the previous post to setup IAM user with the required.

Search for DynamoDB in your AWS console and click on create table.

To follow along create a table name Todo with the Partition key called ID and hit create table

Server Setup

Now let's setup our node environment:

first create a package.json by running yarn init -y
add "type": "module" in package.json

now install the dependencies

yarn add express dotenv aws-sdk nodemon

now add the scripts section in package.json

"scripts": {
    "start": "nodemon index"
  }

create 3 files in your project directory index.js,Database.js and .env.
In .env add the your IAM user secret, access key and your AWS account region.

Now setup your express server

Go into the Database.js file and let setup our DynamoDB client which allows us to interact with our tables.

the aws.config.update is used to authorize the aws-sdk to access your tables in DynamoDB.

the const client = new aws.DynamoDB.DocumentClient(); is used to initialize the DynamoDB client.

finally, the constant Table_Names is used to define the DynamoDB table name we just created.

now create a variable called DB and export it.

let DB = {};

export default DB;

CRUD Operations

Before we start coding let's understand few methods provided by the DynamoDB client.

put this method is used to create a new entry in the DB or edit and existing entry.
scan this method is used to all the entries of a given table.
get this method is used to get an element by their partition key or a combination partition and sort key.
delete this method deletes a given element.

All the above methods use a callback in order to convert it into a promise we chain a method called promise.

In all the above methods accept an object as an argument where we have to pass in the TableName attributes.

const params = {
      TableName: Table_Names,
    }

Add item to table

addItem: async (item) => {
    const params = {
      TableName: Table_Names,
      Item: item,
    }
    try {
      return await client.put(params).promise()
    } catch (err) {
      return (err)
    }
  },

In the above code the item parameter can be any JSON object of your choice.

Get all items from the table

getAllItems: async () => {
    const params = {
      TableName: Table_Names,
    }

    try {
      return await client.scan(params).promise()
    } catch (err) {
      return (err)
    }
  }

Get item by id

getMemberByID: async (id) => {
    const params = {
      TableName: Table_Names,
      Key: {
        ID: id,
      }
    }
    try {
      return await client.get(params).promise()
    } catch (err) {
      return (err)
    }
  },

In the above function the parameter id is a string which needs to be the ID of the item you want to fetch.
We use the Key attribute to match the Partition key ID with the parameter id (if you have a sort key that also goes here).

Delete item by id

deleteItem: async (id) => {
    const params = {
      TableName: Table_Names,
      Key: {
        ID: id
      }
    }
    try {
      return await client.delete(params).promise()
    } catch (err) {
      return (err)
    }
  }

finally you database.js should look like this:

import aws from "aws-sdk";

aws.config.update({
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  region: process.env.AWS_REGION
})

const client = new aws.DynamoDB.DocumentClient();
const Table_Names = "Todo"

const DB = {
  addItem: async (item) => {
    const params = {
      TableName: Table_Names,
      Item: item,
    }
    try {
      return await client.put(params).promise()
    } catch (err) {
      return (err)
    }
  },
  getMemberByID: async (id) => {
    const params = {
      TableName: Table_Names,
      Key: {
        ID: id,
      }
    }
    try {
      return await client.get(params).promise()
    } catch (err) {
      return (err)
    }
  },
  deleteItem: async (id) => {
    const params = {
      TableName: Table_Names,
      Key: {
        ID: id
      }
    }
    try {
      return await client.delete(params).promise()
    } catch (err) {
      return (err)
    }
  },
  getAllItems: async () => {
    const params = {
      TableName: Table_Names,
    }

    try {
      return await client.scan(params).promise()
    } catch (err) {
      return (err)
    }
  }
}


export default DB;

Create routes

go to your index.js file and create routes like down below

import express from "express";
import env from "dotenv";
import DB from "./Database.js"

env.config();
const app = express();

app.use(express.json())

app.get("/", async (req, res) => {
  const data = await DB.getAllItems();
  res.json(data)
})

app.post("/", async (req, res) => {
  const data = await DB.addItem(req.body)
  res.json(data)
})

app.get("/:id", async (req, res) => {
  const data = await DB.getMemberByID(req.params.id)
  res.json(data)
})

app.delete("/:id", async (req, res) => {
  const data = await DB.deleteItem(req.params.id)
  res.json(data)
})

app.listen(3000, () => {
  console.log("listening on 3000")
})

Now you can test the apis using Postman and they should workfine.

I will try to cover more topics related to DynamoDB while building projects with lambda and DynamoDB.

Thanks for time.

Lambda functions with DynamoDB & Node

ckmonish2000 — Sat, 12 Nov 2022 15:51:13 +0000

In this post let's use the API we previously created and create and fetch data from a database provided by AWS called DynamoDB.

DynamoDB is a fully managed proprietary NoSQL database service that supports key–value and document data structures.

So, to being with create another API with request type POST called createStudent and you can use the body property to extract request body from the event parameter in the lambda function.

Creating a DynamoDB table

Search for DynamoDB in the search bar and click on create table.

Now enter the table name and enter the name of your primary key column [Note: If you enter a name for the sortkey then the combination of primary and sortkey will have to be unique].

Select default settings under table settings and hit the create table button.

Now you should see that the table is created, and you can feed in some data.

fetching data from DynamoDB in our function

Let's replace the code from the previous code like this

const aws = require("aws-sdk")
const dynamo = new aws.DynamoDB.DocumentClient()

exports.handler = async (event) => {

    const studentID = event.pathParameters.studentID

    const data = await dynamo.get({
        TableName:"school",
        Key:{
            ID:studentID
        }
    }).promise()

    const response = {
        statusCode: 200,
        body: JSON.stringify(data),
    };
    return response;
};

let's review the code
By default the aws-sdk is installed in the instance running our function so we can use the DynamoDB client from there.
the get method on the document client takes an object as it's parameter where you specify the tablename and the key value to filter the data.
The get method requires a call back we are converting the call back into a promise by invoking the .promise() method.
if you deploy the code and try calling the api you'll get a internal server error to resolve it we have provide your function permission to access dynamodb.
So go to the configurations section in lambda and click on edit under the execution role card.

Click on the view role name and it will take you the aws iam console.

There you'll notice your iam user only has the permission for lambda now we can add a new permission by either attaching a new policy or creating an inline policy.

under services choose DynamoDB

under actions choose what all can this user do with a table

For the sake of the post under resources select all resources but do not do this a production level project and click on review policy and then hit the create button.

Now try calling the api and it'll work

Creating students

Now before you continue to the code provide DynamoDB write access to this function.
The below code allows us to create new entries in DynamoDB.

const aws = require("aws-sdk")
const dynamo = new aws.DynamoDB.DocumentClient()

exports.handler = async (event) => {
    const body = JSON.parse(event.body)
    console.log(body)

    const data = await dynamo.put({
        TableName:"school",
        Item:{
            ...body,
            ID: Math.floor(Math.random()*10000000).toString()
        }
    }).promise()


    const response = {
        statusCode: 200,
        body: JSON.stringify("Added new student welcome to the X-MEN"),
    };
    return response;
};

So here instead of get we are using the put method and we are extracting the data from the body of the request using event.body.
Now let's call the API using postman

Now if you go to the DynamoDB explore section you'll see that the new student has been added.

Thanks for your time.

Create your first API with AWS lambda and Node

ckmonish2000 — Sat, 12 Nov 2022 09:23:06 +0000

In the previous post we saw how to create a serverless lambda function with netlify now let create a function directly on AWS.

we are going to use 2 AWS services namely lambda serverless function service from AWS and API gateway a service which it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale.

Setup AWS API Gateway

You have various options like HTTP, Rest and sockets but for the purpose of this post select HTTP API.

You will be redirected to a page to create your API, so give a name to your API endpoint and click next also click next on the route's registration page as we will configure the later.

Now name your stage and make sure the auto-deploy switch is active and hit next [FYI: a stage is just a logical reference to a lifecycle state of your API (for example, dev, prod, beta, or v2).]

Now Review your changes and create the API

Creating an API route

Now we have an API endpoint setup in gateway now we have to configure routes like get student by id.

Click on routes in the sidebar

Click on create

Now choose the Request type from the dropdown and add the route name and hit create [NOTE: the /{studentID} in the route indicates a route parameter which we will extract in the function]

Now you have created an api endpoint the next step is to create a lambda function and link it to the route we just created.

Creating an Lamda function from the console

Now search for lambda in the search bar select it and click on create function.

Select author from scratch

Give your function a name while keeping the default config and hit create function.
Now you should see a view like this where you can setup various triggers to run your function and we are going to use API gateway's HTTP endpoint to trigger the function.

And if you come down you should be able to view the function code and edit it.
Here we are extracting the studentID from the route and returning the student if their ID is present in the array.

Hit Deploy and your function must be live.

Linking the endpoint to your lambda function

Go Back to the routes section of the API gateway and click on attach integration

Then click on create and attach integration

From the drop down choose Lambda function as integration type

Then in the Integration details section select the lambda function we just created and make sure the invoke permission switch is active and then hit the create button.

Now if you come down to configurations under lambda function you should see the endpoint to trigger the function.

Now if you call the URL from the browser or postman you'll see the response.

Thankyou,

for following this post in the next post I'll try to cover using Dynamo DB and how you can setup your serverless infrastructure using code with a framework called serverless

Serverless functions for dummies⚡

ckmonish2000 — Mon, 07 Nov 2022 15:45:26 +0000

Intro

If you're thinking that you'll be building applications without a server your wrong,

serverless means rather than you managing your servers it would be handled by cloud providers

now you must be thinking then what's the difference between services like Heroku (you don't know what it's because they canceled their free tire a while back),

well with services like Heroku you can choose how you want to structure your app and also note that your app will keep running even if no one is using it.

But with serverless you have to split your logic into individual functions and the code only starts running when you make a request.

There are various options for serverless functions, but the most popular ones are:

AWS Lambda
Cloudflare Workers
Firebase Cloud Functions

In this blog post we will be using AWS Lambda,

With netlify functions under the hood it uses AWS lambda, but it removes the complexity of setting up your environment.

FYI, I would suggest using netlify only for small projects.

Setup

initialize package.json

yarn init -y

Add the dependency to run netlify-functions

yarn add netlify-lambda

Add the following code under the scripts section of package.json

"scripts": {
    "server": "netlify-lambda serve functions",
    "build": "netlify-lambda build functions"
  }

Create a file named netlify.toml and add the following in it

[build]
  functions = "lambda"

Now create a folder in the root directory called functions.
Create a JS file with a name of your choice (Note: Name of the file will be the API endpoint)

Your first function

Let's create a simple function that greets you when you request for it.

exports.handler = async (event, context) => {
  const { name } = JSON.parse(event.body)

  return {
    statusCode: 200,
    body: `hello ${name}`
  };
}

Let me explain the code above:

We are exporting an async function that takes in 2 arguments events and context.

FYI: [event gives you access to the headers, body and other properties of the request and the context parameter provides methods and properties that gives you info about the function invocation.]

Then you return a object with status code and body of your choice.

Run your serverless app locally

Run the following command in your terminal and it should start your application of port 9000

yarn server

and now you can use postman or your app to query the API you just built.

Fetch live data from an API

Here's another example, which fetches users list from github and returns data only on a GET request.

const axios = require('axios').default;

exports.handler = async (event, context) => {
  let data = await axios.get("https://api.github.com/users")

  if (event.httpMethod === "GET") {
    if (data) {
      return {
        statusCode: 200,
        body: JSON.stringify(data.data)
      }
    } 
  } else {
    return {
      statusCode: 404
    }
  }
}

you can also deploy the function to netlify Here's a link to the docs.

Hope this blog was helpful thanks for your time.

Express GraphQL

ckmonish2000 — Wed, 20 Jul 2022 08:56:00 +0000

So this post is not gonna tell you what GraphQL is and how it's better over restful API's rather this is a gist to act as a tool to revise the basic concepts on GQL like how to define a query or mutation or how to write a resolver using a GraphQL server called Express GraphQl.

Dependencies & initial setup

First and foremost we have to install the dependencies for the project , I'm assuming you have your bare bones node project already setup.

Next run one of the command down below based on which package manager you are using :

yarn add express express-graphql graphql

npm i --save express express-graphql graphql

after that set up the server in your index.ts file

Queries & Mutations

Once you have set up your GraphQL end point you'll have to setup your GraphQL Schema which is basically a combination of your GraphQL mutations, queries and subscriptions.

to set up a Schema you have to first import 2 things

const {GraphQLSchema, GraphQLObjectType} = require('graphql')

the GraphQLSchema object is used to create a new instance of the schema and while initializing the object it take a JSON value as a parameter, This parameter will further contain the details for the queries and mutation.

Down below I'm creating a file called test.ts which will export our schema

once you have exported you schema import it and pass it into the your index.ts file so that your graphql end point knows where to look for the queries and mutations.

app.use("/graphql", graphqlHTTP({ schema: Schema, graphiql: true, }))

So let's begin by creating a query in a file called queries.ts

here let's first take a look at the GraphQLObjectType which takes in 2 parameters:

name: indicates the name for the given return type of the resolver.
fields indicates the values that a mutation or query will return so the fields have 2 sub fields i.e the type of the field and a custom function called resolve.

In type you add the type of value a particular field is gonna return and in resolve function your basically gonna return the value of the given type.

and if you notice you can also create custom types like user in the above example it's not very different from creating a query,
The only key difference is that

a. In a custom object type you do not add the resolve function

b. you can use the custom object type as a return type for any other resolver.

and that's all we need to know in order to define a query and to define a mutation you can pretty much use the same steps but just pass the mutations in the mutations part of the schema.

Arguments

Now when you are building a mutation your gonna need to accept some parameters for that you can use the args key when defining a given query or mutation and extract them from the resolve function like shown down below.

That's all for this post follow me for more such quick guides and handbooks

Node For Dummies

ckmonish2000 — Wed, 15 Jun 2022 07:46:08 +0000

There are a million ways you can learn Node JS but the one I Prefer is hand made notes that can assist me in all my future projects.

If your something like me you would also like sicknotes and cheat sheets for your future references.

So without further ado let's get started.

WTF Is Node.js

Once upon a time JavaScript was a language that could not do anything more than manipulate DOM elements, In other words JS was confined only to your browser.

But today we can do just about anything with JS from building websites to training AI models and that's all thanks to Node.

So how exactly did node revolutionize JS ???

Basically when you write a line of code you need what's called a compiler that translates human readable code into lower level format that your computer can understand.

So browsers are shipped with something called a JS engine that acts as a compiler,

Like shown in the image above the code from your app will go through the engine to perform the required operations but there are a lot of limitations to the JS engine shipped with browsers like we can not interact with the OS or create files with JS.

To over come these limitation Ryan Dahl in 2009 introduce the world to Node.JS

which is basically uses chromes JS engine called V8 and wraps it with Libuv a library built with C which gives JS the ability to perform a lot of native operations we will be visiting over the course of this series so stay tuned for the next blog post.

WTF is WEB 5.0 ☣️

ckmonish2000 — Wed, 15 Jun 2022 07:45:08 +0000

Web 5 announced by Block is the middle ground between web 2.0 and web 3.0 i.e.

✅ WEB 2.0 + WEB 3.0 = WEB 5.0

💵 Web 5 has made bitcoin their central currency but unlike web 3,

Web 5 is not built on the blockchain so Bitcoin will only act as a currency to purchase in app assets like subscriptions, mods and stuff like that.

👨‍💻 Web 5 is open source and is aiming to build a decentralized network layer using Bitcoin's layer 2 payment protocol called lighting.

Web 5 is divided in to 3 main components:

Wallet 👛
Node 🌐
DWAS 📱

Wallets and nodes are almost similar to web 3

but the add on's for wallets is what intrigue me,

so apart storing assets and identifying a user the wallet will also have the ability to store user settings and meta data,

E.g. you are some one who loves dark mode so rather than going to each app and turning on dark mode, All you will have to do is enable dark mode on your wallet and that setting will be carried forward to all your apps (A global state management system of sorts).

And as a web 5 developers you wont develop DAPP or PWA you will develop something called DWAS that's decentralized web apps

where the app will be hosted on a node in the network rather than on a central server,

You may ask how is this any different from web 3 it's simple in web 3 all the data is decentralized but

In web 5 the organization can store data related to their platform on their own servers but as a users will be able to abstract your personal information and preferences.