DEV Community: Jaymitkumar Bhoraniya

🌐 Cloud Skills Are Now Essential for Developers: Boost Your Career with FREE AWS Courses 🚀

Jaymitkumar Bhoraniya — Tue, 17 Dec 2024 05:25:38 +0000

In today’s fast-paced tech industry, cloud computing is no longer an option—it’s a necessity. Whether you're a budding developer or an experienced professional, mastering cloud technologies can significantly enhance your career.

Among the many cloud platforms, Amazon Web Services (AWS) stands out as a leader, offering a wide range of tools and services to build scalable, secure, and cost-effective applications.

To help you on your cloud journey, here’s a list of 30 FREE AWS courses that cater to all levels, from beginners to advanced developers. 🎓

🏆 30 Free AWS Courses to Level Up Your Cloud Skills

AWS Cloud Practitioner Essentials
📚 Course Link
Learn the fundamental concepts of AWS cloud infrastructure, core services, and pricing models. Ideal for beginners looking to understand AWS basics and start their cloud journey.
AWS Overview Crash Course
📚 Course Link
A high-level overview of AWS services and their integrations. This quick course helps you understand how AWS powers cloud applications across industries.
AWS Cloud Technical Essentials
📚 Course Link
Explore the technical foundations of AWS, including compute, storage, and networking. Perfect for developers aiming to build a strong AWS foundation.
AWS Certified Cloud Practitioner Course
📚 Course Link
Prepare for the AWS Certified Cloud Practitioner exam with this comprehensive course, covering all the essential topics to help you pass the certification.
AWS For Beginners
📚 Course Link
A beginner-friendly course that covers AWS basics, from creating an account to deploying your first application.
AWS Certified Solutions Architect Essentials
📚 Course Link
Learn how to design scalable, secure, and cost-effective architectures on AWS. This course is a must for aspiring solutions architects.
AWS Developer Associate Training
📚 Course Link
Master the skills needed to build, deploy, and manage applications on AWS with hands-on exercises and practical examples.
Serverless Computing in AWS
📚 Course Link
Learn how to build serverless applications using AWS Lambda, API Gateway, and DynamoDB. A must for developers looking to reduce infrastructure management.
Build and Deploy a LAMP Server on AWS
📚 Course Link
A practical guide to setting up and deploying a LAMP (Linux, Apache, MySQL, PHP) server on AWS.
Developing Serverless Solutions on AWS
📚 Course Link
Get hands-on experience in building scalable, serverless applications with AWS services.
Introduction to AWS Cloud Computing
📚 Course Link
A beginner-level course introducing cloud computing concepts and how AWS services fit into the cloud ecosystem.
Automate Your AWS Cloud Infrastructure
📚 Course Link
Learn to automate your infrastructure using AWS CloudFormation and other automation tools.
AWS Machine Learning Foundations
📚 Course Link
An introductory course on machine learning concepts and how to implement them using AWS services.
Introduction to Building with AWS Databases
📚 Course Link
Explore various AWS database services and learn how to choose the right one for your application.
AWS VPC Transit Gateway
📚 Course Link
Understand how to design and implement a scalable network architecture using AWS VPC Transit Gateway.
AWS Data Engineering Labs
📚 Course Link
Hands-on labs to help you build data pipelines and manage data workflows on AWS.
Learn Terraform and AWS
📚 Course Link
Master Infrastructure as Code (IaC) using Terraform to automate AWS deployments.
Low-Code Machine Learning on AWS
📚 Course Link
Discover how to build machine learning models with minimal coding using AWS services like SageMaker Canvas.
AWS for Games: Cloud Game Development
📚 Course Link
Learn how to build and deploy games on AWS, leveraging the cloud for multiplayer and real-time experiences.
AWS DevOps Engineer Course
📚 Course Link
A comprehensive course for DevOps professionals looking to automate and manage AWS infrastructure efficiently.
Generative AI for Executives
📚 Course Link
An executive-level course covering generative AI concepts and their applications on AWS.
AWS: CloudFormation
📚 Course Link
Learn how to create, manage, and deploy AWS infrastructure using CloudFormation templates.
AWS - Zero to Hero
📚 Course Link
A complete guide for beginners to go from zero to hero in AWS cloud development.
AWS Data Analytics Fundamentals
📚 Course Link
Explore the core concepts of data analytics and how to implement them using AWS services.
Building Generative AI Applications Using Amazon Bedrock
📚 Course Link
Learn how to build generative AI applications using Amazon Bedrock.
Standard Exam Prep Plan: AWS Certified AI Practitioner (AIF-C01)
📚 Course Link
Prepare for the AWS AI Practitioner exam with this structured study plan.
Standard Exam Prep Plan: AWS Certified Machine Learning - Associate (MLA-C01)
📚 Course Link
A detailed course to help you ace the AWS Machine Learning Associate certification.
Building LLMs on AWS
📚 Course Link
Learn how to build and deploy large language models on AWS.
Generative AI Learning Plan for Developers
📚 Course Link
A step-by-step guide for developers to learn generative AI on AWS.
Foundations of Prompt Engineering
📚 Course Link
Understand the fundamentals of prompt engineering and how to optimize AI prompts on AWS.

🌟 Why Master AWS?
In-Demand Skills: Cloud skills are among the top requirements in tech jobs.
Flexible Learning: Learn at your own pace with free, high-quality resources.
Career Growth: AWS certifications can enhance your resume and open doors to better job opportunities.
🌍 Share & Connect
Found this list helpful? Share it with your developer community and help others grow their cloud skills.

Happy Learning! 🎓

AWS Serverless Security: Preventing HTTP Flood DDoS Attack

Jaymitkumar Bhoraniya — Sun, 15 Dec 2024 18:50:54 +0000

Introduction

In this article, we will talk about how to make your serverless application security stronger. Nowadays many different types of Distributed Denial of Service (DDoS) attacks are happening on applications, one of them is the HTTP Flood DDoS Attack. This article will explain how to Prevent HTTP Flood DDOS attacks for serverless applications to make your serverless security stronger.

What is a DDoS Attack?

A distributed denial-of-service (DDoS) attack is a malicious attempt to disrupt the normal traffic of a targeted server, service, or network by overwhelming the target or its surrounding infrastructure with a flood of Internet traffic.
The attacker does floods of fake requests on target, and due to that, the target goes slow or down completely and it is not able to serve the requests of valid users.

Few General DDoS Attacks Type

HTTP Flood DDoS Attack
SYN Flood DDoS Attack
DNS Amplification DDoS Attack

What is HTTP Flood DDoS Attack?

HTTP Flood DDoS Attack is a kind of attack that loads web applications again and again on many different systems at once (sometimes referred to as a botnet), due to the huge number of HTTP requests flooding on servers consuming more resources, and in the end, web applications are not available to real users & denial-of-service (DDoS) occurs. In short, each HTTP request does an expensive database query (and other logical operations on the server) so when lots of HTTP requests hit the server at the same time then it will go down due to the heavy resource consumption; which then creates a DDoS.

Preventing HTTP Flood DDoS Attack in Serverless Applications with AWS WAF

What is AWS WAF?

AWS WAF is a web application firewall that helps protect your web applications / APIs against common web exploits and bots. Attacks may affect availability, compromise security, or consume excessive resources. AWS WAF gives you control over how traffic reaches your applications by enabling you to create security rules that control bot traffic and block common attack patterns.

AWS WAF is possible to deploy on:

Amazon CloudFront
Application Load Balancer
Amazon API Gateway
AWS AppSync

AWS WAF Security Automations use AWS CloudFormation to quickly configure AWS WAF rules that help block these common types of attacks:

HTTP floods
SQL injection
Cross-site scripting
Scanners and probes
Known attacker origins (IP reputation lists)
Bots and scrapers

In the diagram below, we can see where the AWS WAF sits in our serverless architecture. Basically, it’s our shield in front of all requests coming into our system. But, don’t confuse this service with AWS Shield (lol, AWS has everything).

Preventing HTTP Flood DDoS Attack on API Gateway using AWS WAF with Rate-based rule

Follow the below steps to create a web ACL in AWS WAF:

Open the AWS WAF console.
Choose to Create web ACL.
For Web ACL Name, enter ApiGateway-HTTP-Flood-Prevent.
For Region, choose US East (N. Virginia).
Choose Next and you will see Add rules and rule groups step.
Choose Add rule, Further, Choose to Add my own rules and rule groups

Rule type: Rule builder
Rule builder - Rule Name: HTTP-Flood-Prevent
Rule builder - Rule Type: Rate-based rule
Rate limit: 2000
choose Add Rule.

For Default action, choose ’Allow’ for Default web ACL action for requests that don't match any rules

Do Next till you see Review and create web ACL Step
Do select create web ACL

That’s it!! You are done with creating an AWS WAF Web ACL along with a rate-based rule to prevent HTTP Flood attacks 🔥🔥

Now, We need to enable WAF web ACL on existing APIs in API Gateway to make it more secure:

Go to the Amazon API Gateway console.
Select Stages, prod.
Under Web Application Firewall (WAF), select ApiGateway-HTTP-Flood-Prevent which we already created
Choose Save Changes.

Test your WAF Web ACL Enabled Secure APIs

Do a normal call to your API Gateway APIs endpoint and it should give success response

WAF Allows:

{"statusCode":200,"body":"\"Hello from Lambda!\""}

Use Artillery to send a large number of requests in a short period to trigger your rate limit rule:

$artillery quick -n 2000 --count 10 
https://XXXXXXXXXX.execute-api.us-east-1.amazonaws.com/prod/gettodos

Using this command, Artillery sends 2000 requests to your API from 10 concurrent users. By doing this, you trigger the rate limit rule in less than the 5-minute threshold. Once Artillery finishes its execution, re-running the API and API response will be:

WAF Blocked:

{"message":"Forbidden"}

You can see the API response is Forbidden, as the request was blocked by AWS WAF. Your IP address will remove from the blocked list after it falls below the request limit rate.

Same as AWS API Gateway, you are also able to associate AWS WAF Web ACL with regional resources like Amazon Application Load Balancer, AWS AppSync, and Global resources like CloudFront Distributions.

For the CloudFront Distributions case you need to create AWS WAF Web ACL of Global type instead of the regional resource type.

Conclusion

Using the AWS WAF service as part of your Serverless Application Architecture helps to prevent HTTP Flood DDoS Attacks while also making the Serverless Application more secure through its many other security features provided.

In this article we:

Gave a high level of DDoS and HTTP Flood DDoS Attacks
Showed how to use AWS WAF to prevent this attack vector
Demonstrated how we can load test our serverless application and see the requests be blocked past a specific threshold

Thank you for reading :)

Sources
[1] https://www.cloudflare.com/learning/ddos/what-is-a-ddos-attack/
[2] https://aws.amazon.com/waf/
[3] https://docs.aws.amazon.com/solutions/latest/aws-waf3-security-automations/overview.html

AWS CI/CD Pipeline to Deploy a Serverless Framework Project

Jaymitkumar Bhoraniya — Mon, 25 Dec 2023 04:49:45 +0000

Introduction

In this article, we will set up an AWS CI/CD Pipeline to Deploy a Serverless Framework project using AWS CodeCommit, AWS CodeBuild, and AWS CodePipeline.

We will automate the release process so once developers commit code and push changes to a branch it will auto-trigger the AWS CI/CD pipeline which will then build & deploy the project changes to a specific stage.

While using AWS CI/CD services you don’t need to worry about creating custom build servers manually, that of course saves your engineering team time and money. There is no maintenance cost as you only pay when it’s running. Furthermore, there is no need to worry about scaling as it is easily configurable, secure, and highly available.

AWS Architecture:

Above is an AWS CI/CD Architecture Diagram showing how AWS CodePipeline, AWS CodeCommit, and AWS CodeBuild are leveraged to deploy Serverless Framework project code changes automatically when they are committed.

What is a CI/CD?

CI/CD is the combined practice of continuous integration (CI) and continuous delivery (CD). [1]

CI/CD bridges the gaps between development and operation activities by enforcing automation in the building, testing, and deployment of applications. The aim is to increase early defect detection, increase productivity, and faster release cycles.

AWS provides a range of Developer Tools Services. AWS CodePipeline, AWS CodeCommit, AWS CodeBuild, and AWS CodeDeploy services are used to build a full CI/CD flow.

AWS CodePipeline

AWS CodePipeline is a fully managed continuous delivery service that helps you automate your release pipelines for fast and reliable application and infrastructure updates. CodePipeline automates the build, test, and deploy phases of your release process every time there is a code change, based on the release model you define. [2]

AWS CodeCommit

AWS CodeCommit is a secure, highly scalable, managed source control service that hosts private Git repositories. CodeCommit eliminates the need for you to manage your own source control system or worry about scaling its infrastructure. It supports the standard functionality of Git, so it works seamlessly with your existing Git-based tools. [3]

AWS CodeBuild

AWS CodeBuild is a fully managed continuous integration service that compiles source code, runs tests, and produces software packages that are ready to deploy. With CodeBuild, you don’t need to provision, manage, and scale your own build servers. CodeBuild scales continuously and processes multiple builds concurrently, so your builds are not left waiting in a queue. [4]

AWS CodeDeploy

AWS CodeDeploy is a fully managed deployment service that automates software deployments to a variety of computing services such as Amazon EC2, AWS Fargate, AWS Lambda, and your on-premises servers. AWS CodeDeploy makes it easier for you to rapidly release new features, helps you avoid downtime during application deployment, and handles the complexity of updating your applications. [5]

Implement Basic Serverless Framework Project with Git initialized in local

serverless.yml

handler.js

.gitignore

Generate - package.json by running npm init

buildspec.yml
This buildspec.yml will be used in the AWS CodeBuild step for installing Serverless Framework, relevant dependencies, and deploying the Serverless Framework Project.

Deploy Serverless Framework Project Manually without CI/CD

Create AWS CodeCommit Repository

Developer Tools → CodeCommit → Repositories → Create Repository

Create IAM User and Generate Git Credentials for AWS CodeCommit

IAM → Users → Create User
Create IAM User with attached existing AWS IAM policy: AWSCodeCommitPowerUser‍
IAM → User Details → Secret Credentials → HTTPS Git credentials for AWS CodeCommit

In local git repository add remote origin of AWS CodeCommit Repository

Verify pushed code in AWS CodeCommit Repository

Developer Tools → CodeCommit → Repositories → sls-aws-cicd

Create AWS CodeBuild Project

Developer Tools → CodeBuild → Build projects → Create build project

Created new build project: sls-aws-cicd-build

Source provider: AWS CodeCommit

Repository: sls-aws-cicd [Use the same repository which we created]

Environment variables Name: STAGE_NAME

Environment variables Value: staging

Build specifications

Build specifications: Use a buildspec file
Default Buildspec file name: buildspec.yml

Give needful permission to AWS CodeBuild IAM role.

Create AWS CodePipeline using already created CodeCommit & CodeBuild

Developer Tools → CodePipeline → Pipelines → Create pipeline

Created new pipeline: sls-aws-cicd-staging-pipeline

Source Stage

Source provider: AWS CodeCommit
Repository name: sls-aws-cicd
Branch name: master

Build Stage

Build provider: AWS CodeBuild
Build project name: sls-aws-cicd-build [Use the same build project which we created]

Deploy Stage

We are skipping this stage.

We are using a Serverless Framework deploy command in buildspec.yml as part of the build step for deployment.

Verify CI/CD Pipeline Flow - On git commit push auto deploy changes

Updated handler.js

Commit recent changes and git push same into the master branch

Master branch pushed changes Auto Trigger Relevant Deployment Pipeline

Verify API in Postman - Updated changes auto get reflected in API response

Conclusion

Utilizing a CI/CD increases early defect detection, increases productivity, and faster release cycles.

AWS CodePipeline, AWS CodeCommit, AWS CodeBuild helps you implement CI/CD automation for Serverless Framework Projects which helps the development team follow standard continuous integration and delivery process.

While using AWS CI/CD Services you don’t need to worry about creating custom build servers manually, which saves your engineering team time and cost because it only charges you when it’s running, you no longer need to worry about scaling, it is easily configurable, secure, and highly available.

Sources

[1] https://en.wikipedia.org/wiki/CI/CD

[2] https://aws.amazon.com/codepipeline/

[3] https://aws.amazon.com/codecommit/

[4] https://aws.amazon.com/codebuild/

[5] https://aws.amazon.com/codedeploy/

Lambda Scheduling & Event Filtering with EventBridge using Serverless Framework

Jaymitkumar Bhoraniya — Sun, 24 Dec 2023 14:30:13 +0000

Lambda Scheduling & Event Filtering with EventBridge using Serverless Framework

Application Stack:

Serverless Framework
AWS EventBridge
AWS Lambda
NodeJs

In this post, We will take a look at a use-case that allows us to schedule lambda function call and custom event pattern matching based lambda function call with EventBridge using Serverless Framework.

AWS Architecture:

Above is an AWS Serverless architecture diagram showing EventBridge calling Lambda, using scheduled rules, and filtering lambda calls using custom even pattern matching rules.

1. Install Serverless Framework



npm install -g serverless

2. Create basic NodeJs type template project using Serverless Framework



serverless create --template aws-nodejs

By default it will generate a folder structure like this:

handler.js
serverless.yml

Default serverless.yml will have below IaC code:



service: default-aws-nodejs
frameworkVersion: '2'
provider:
  name: aws
  runtime: nodejs12.x
  lambdaHashingVersion: 20201221

functions:
  hello:
    handler: handler.hello

Default handler.js will have below NodeJs code:



'use strict';

module.exports.hello = async (event) => {

  return {

    statusCode: 200,

    body: JSON.stringify(

      {

        message: 'Go Serverless v1.0! Your function executed successfully!',

        input: event,

      },

      null,

      2

    ),

  };

};

Modify serverless.yml Infrastructure as code to provision needful Lambda functions with EventBridge as Event Source




service: sls-eventbridge

frameworkVersion: '2'

provider:

  name: aws

  runtime: nodejs12.x

  lambdaHashingVersion: 20201221

  stage: dev

  region: ap-south-1

functions:

  scheduledService:

    handler: handler.scheduledService

    events:

      - schedule: rate(1 minute)

invoiceService:

    handler: handler.invoiceService

    events:

      - cloudwatchEvent:

          event:


            detail:

              operation:

                - invoice-service

rewardService:

    handler: handler.rewardService

    events:

      - cloudwatchEvent:

          event:


            detail:

              operation:

                - reward-service

Modify handler.js with below sample demo code




'use strict';

const scheduledService = async (event) => {

  console.log(event);

  return {

    statusCode: 200,

    body: JSON.stringify(

      {

        message: 'scheduledService lambda function call through EventBridge scheduling rule!',

        input: event,

      },

      null,

      2

    ),

  };

};

const invoiceService = async (event) => {

  console.log(event);

  return {

    statusCode: 200,

    body: JSON.stringify(

      {

        message: 'invoiceService lambda function call through EventBridge custom pattern matching!',

        input: event,

      },

      null,

      2

    ),

  };

};

const rewardService = async (event) => {

  console.log(event);

  return {

    statusCode: 200,

    body: JSON.stringify(

      {

        message: 'rewardService lambda function call through EventBridge custom pattern matching!',

        input: event,

      },

      null,

      2

    ),

  };

};

module.exports = {

  scheduledService,

  invoiceService,

  rewardService

};

Create AWS IAM user with programmatic access and give needful permission that allows Serverless Framework to provision resources

The Serverless Framework needs access to your cloud provider account so that it can create and manage resources on your behalf.

During Creating AWS IAM user copy API Key & Secret.

6. Configure AWS Credentials for Serverless Framework Deployment



serverless config credentials --provider aws --key xxxxx --secret xxxxx

Deploy using Serverless Framework




serverless deploy



> serverless deploy

Serverless: Packaging service...

Serverless: Excluding development dependencies...

Serverless: Service files not changed. Skipping deployment...

Service Information

service: sls-eventbridge

stage: dev

region: ap-south-1

stack: sls-eventbridge-dev

resources: 18

api keys:

  None

endpoints:

  None

functions:

  scheduledService: sls-eventbridge-dev-scheduledService

  invoiceService: sls-eventbridge-dev-invoiceService

  rewardService: sls-eventbridge-dev-rewardService

layers:

  None

Amazon EventBridge and AWS Lambda Screenshots

AWS Lambda Functions List

AWS Lambda Functions Event Source Configuration

Amazon EventBridge Default Bus Scheduling Rules

Amazon EventBridge Default Bus Custom Event Pattern Rule

9. Remove already provisioned resources



serverless remove

Relevant Resources Link

Serverless Framework: https://www.serverless.com/
AWS EventBridge: https://aws.amazon.com/eventbridge/
AWS Lambda: https://aws.amazon.com/lambda/
NodeJs: https://nodejs.org/

AWS re:invent 2021 - AWS CEO Adam Selipsky's Keynotes Announcement Summary

Jaymitkumar Bhoraniya — Fri, 03 Dec 2021 03:48:38 +0000

AWS re:invent 2021 - AWS CEO Adam Selipsky's Keynotes Announcement Summary

Please Welcome CEO of AWS, Adam Selipsky...

WOW!!! Hello Everyone Welcome to AWS reinvent...

Thank you so much for joining us, it is great to be back here with all of you on 10th anniversary of reinvent and 15th anniversary of aws.

You still needed more..., so, I am really pleased to announce....

Graviton3

C7g Insurance for EC2

Trn1 insurance for EC2

AWS mainframe modernization

AWS Private 5G

Row and cell-level security for Lake Formation
Transaction for governed tables in Lake Formation

Serverless and on-demand analytics

Amazon SageMaker Canvas

AWS Training Programs

Amazon FinSpace

Goldman Sachs Financial Cloud for data

AWS IoT TwinMaker

AWS IoT FleetWise

It was a great presentation with real case study examples from a few AWSome partner customers along with new exciting announcements.

Thank you so much to Adam Selipsky and his team for great presentation with lots of exciting things. Thank you so much to AWS and AWS re:invent team for such great event.

AWS CEO Adam Selipsky's Keynotes See full video here: https://www.youtube.com/watch?v=WGA2P_oH5Xc

AWS AppSync ToDo APIs with AWS Lambda Resolvers using Serverless Framework

Jaymitkumar Bhoraniya — Sun, 26 Sep 2021 14:20:30 +0000

Implement basic ToDo APIs using AWS AppSync with AWS Lambda Resolvers by using Serverless Framework

Application Stack:

Serverless Framework
AWS AppSync
AWS Lambda
AWS DynamoDB
AWS IAM
NodeJs
GraphQL

Install NodeJs as per instruction given here

1. Install Serverless Framework



npm install -g serverless

2. Create basic NodeJs type template project using Serverless Framework



serverless create --template aws-nodejs

By default it will generate a folder structure like this:

handler.js
serverless.yml

Default serverless.yml will have below IaC code:



service: default-aws-nodejs
frameworkVersion: '2'
provider:
  name: aws
  runtime: nodejs12.x
  lambdaHashingVersion: 20201221

functions:
  hello:
    handler: handler.hello

Default handler.js will have below NodeJs code:



'use strict';

module.exports.hello = async (event) => {

  return {

    statusCode: 200,

    body: JSON.stringify(

      {

        message: 'Go Serverless v1.0! Your function executed successfully!',

        input: event,

      },

      null,

      2

    ),

  };

};

Install required Serverless Framework Plugins

npm install serverless-appsync-plugin
npm install serverless-pseudo-parameters

4. Modify serverless.yml Infrastructure as code to provision needful AppSync, DynamoDb, Lambda resources, and relevant configuration



service: appsync-todo-apis-demo

frameworkVersion: "2"

plugins:


serverless-appsync-plugin
serverless-pseudo-parameters


provider:

  name: aws

  runtime: nodejs12.x

  stage: dev

  region: ap-south-1

  lambdaHashingVersion: 20201221

  iam:

    role:

      statements:

        - Effect: "Allow"

          Action:


            - "dynamodb:PutItem"

            - "dynamodb:UpdateItem"

            - "dynamodb:DeleteItem"

            - "dynamodb:GetItem"

            - "dynamodb:Scan"

          Resource: "arn:aws:dynamodb:#{AWS::Region}:*:table/${self:custom.TODO_TABLE}"

custom:


  TODO_TABLE: todo-table

appSync:

    name: appsync-todo-apis-demo

    authenticationType: API_KEY

    mappingTemplates:


      - type: Mutation

        field: createTodo

        dataSource: createTodoFunction

        request: false

        response: false

      - type: Mutation

        field: updateTodo

        dataSource: updateTodoFunction

        request: false

        response: false

      - type: Mutation

        field: deleteTodo

        dataSource: deleteTodoFunction

        request: false

        response: false

      - type: Query

        field: getTodos

        dataSource: getTodosFunction

        request: false

        response: false


    dataSources:


      - type: AWS_LAMBDA

        name: createTodoFunction

        config:

          functionName: createTodo

  - type: AWS_LAMBDA
    name: updateTodoFunction
    config:
      functionName: updateTodo

  - type: AWS_LAMBDA
    name: deleteTodoFunction
    config:
      functionName: deleteTodo

  - type: AWS_LAMBDA
    name: getTodosFunction
    config:
      functionName: getTodos                     



functions: 

  getTodos:

    handler: functions/getTodos.handler

    environment:

      TODO_TABLE_NAME: !Ref TodoTable

createTodo:

    handler: functions/createTodo.handler

    environment:

      TODO_TABLE_NAME: !Ref TodoTable

updateTodo:

    handler: functions/updateTodo.handler

    environment:

      TODO_TABLE_NAME: !Ref TodoTable

deleteTodo:

    handler: functions/deleteTodo.handler

    environment:

      TODO_TABLE_NAME: !Ref TodoTable

resources:

  Resources:

    TodoTable:

      Type: "AWS::DynamoDB::Table"

      Properties:

        KeySchema:

          - AttributeName: id

            KeyType: HASH

        AttributeDefinitions:

          - AttributeName: id

            AttributeType: S

        BillingMode: PAY_PER_REQUEST

        TableName: ${self:custom.TODO_TABLE}

Create GraphQL Schema new file schema.graphql




schema {

    query: Query

    mutation: Mutation

}

type Query {

    getTodos: [Get!]!

}

type Mutation {

    createTodo(id: ID!, name: String!, description: String!): Save

    updateTodo(id: ID!, name: String!, description: String!): Update

    deleteTodo(id: ID!): Delete

}

type Get {

    id: ID!

    name: String

    description: String 

}

type Save {

    id: ID!

    name: String

    description: String 

}

type Update {

    id: ID!

    name: String

    description: String 

}

type Delete {

    id: ID! 

}

Implement AWS Lambda Resolver CRUD handlers

Create new folder 'functions' with this files:

createTodo.js
deleteTodo.js
getTodos.js
updateTodo.js

6.1 createTodo.js handler



const AWS = require('aws-sdk')

const dynamodb = new AWS.DynamoDB()

module.exports.handler = async (event) => {


    const id = event.arguments.id

    const name = event.arguments.name

    const description = event.arguments.description    

const params = {
    Item: {
        "id": {
            S: id
        },
        "name": {
            S: name
        },
        "description": {
            S: description
        }            
    },
    ReturnConsumedCapacity: "TOTAL",
    TableName: process.env.TODO_TABLE_NAME
}

return dynamodb.putItem(params).promise()
    .then(data =&gt; {            
        return {
            id,
            name,
            description
        }
    })
    .catch(err =&gt; {
        console.log(err)
    })



};

6.2 deleteTodo.js handler



const AWS = require('aws-sdk')

const dynamodb = new AWS.DynamoDB()

module.exports.handler = async (event) => {

    const id = event.arguments.id

const params = {
  Key: {
      "id": {
          S: id
      }
  },
  TableName: process.env.TODO_TABLE_NAME
}


return dynamodb.deleteItem(params).promise()
    .then(data =&gt; {            
        return {
            id
        }
    })
    .catch(err =&gt; {
      console.log(err)
    })



};

6.3 updateTodo.js handler



const AWS = require('aws-sdk')

const dynamodb = new AWS.DynamoDB()

module.exports.handler = async (event) => {

    const id = event.arguments.id

    const name = event.arguments.name

    const description = event.arguments.description

const params = {
  ExpressionAttributeNames: {
      "#n": "name",
      "#d": "description"          
  },
  ExpressionAttributeValues: {
      ":n": {
          S: name
      },
      ":d": {
          S: description
      }
  },
  Key: {
      "id": {
          S: id
      }
  },
  ReturnValues: "ALL_NEW",
  TableName: process.env.TODO_TABLE_NAME,
  UpdateExpression: "SET #n = :n, #d = :d"



}

return dynamodb.updateItem(params).promise()

      .then(data => {

          const body = data.Attributes

          return {

            id: body.id.S,

            name: body.name.S,

            description: body.description.S

          }

      })

      .catch(err => {

        console.log(err)

      })

};

6.4 getTodos.js handler



const AWS = require('aws-sdk')

const dynamodb = new AWS.DynamoDB()

module.exports.handler = async (event) => {

const params = {        
    TableName: process.env.TODO_TABLE_NAME
}

return dynamodb.scan(params).promise()
    .then(data =&gt; {            
        const todoList = [];
        for (let i = 0; i &lt; data.Items.length; i++) {
            todoList.push({
                id: data.Items[i].id.S,
                name: data.Items[i].name.S,
                description: data.Items[i].description.S
            });        
        }
        return todoList;            
    })
    .catch(err =&gt; {
        console.log(err)
    })



};

Create AWS IAM user with programmatic access and give needful permission that allows Serverless Framework to provision resources

The Serverless Framework needs access to your cloud provider account so that it can create and manage resources on your behalf.

During Creating AWS IAM user copy API Key & Secret.

8. Configure AWS Credentials for Serverless Framework Deployment



serverless config credentials --provider aws --key xxxxx --secret xxxxx

Deploy using Serverless Framework




serverless deploy



> serverless deploy

AppSync Plugin: GraphQl schema valid

Serverless: Packaging service...

Serverless: Excluding development dependencies...

Serverless: Creating Stack...

Serverless: Checking Stack create progress...

........

Serverless: Stack create finished...

Serverless: Uploading CloudFormation file to S3...

Serverless: Uploading artifacts...

Serverless: Uploading service appsync-todo-apis-demo.zip file to S3 (16.98 MB)...

Serverless: Validating template...

Serverless: Updating Stack...

Serverless: Checking Stack update progress...

..........................................................................................

Serverless: Stack update finished...

Service Information

service: appsync-todo-apis-demo


stage: dev

region: ap-south-1

stack: appsync-todo-apis-demo-dev

resources: 31

api keys:

  None

appsync api keys:

  xxxxxxxxxxxxxxx

endpoints:

  None

appsync endpoints:

  https://xxxxxxxxxxxxxxx.appsync-api.ap-south-1.amazonaws.com/graphql

functions:

  getTodos: appsync-todo-apis-demo-dev-getTodos

  createTodo: appsync-todo-apis-demo-dev-createTodo

  updateTodo: appsync-todo-apis-demo-dev-updateTodo

  deleteTodo: appsync-todo-apis-demo-dev-deleteTodo

layers:

  None

AWS AppSync APIs Verification Screenshots

AppSync API Verification - getTodos

AppSync API Verification - createTodo

AppSync API Verification - deleteTodo

11. Remove already provisioned resources



serverless remove

Relevant Resources Link

Serverless Framework: https://www.serverless.com/
AWS AppSync: https://aws.amazon.com/appsync/
AWS Lambda: https://aws.amazon.com/lambda/
NodeJs: https://nodejs.org/
GraphQL: https://graphql.org/
AWS DynamoDB: https://aws.amazon.com/dynamodb/
AWS IAM: https://aws.amazon.com/iam/

Are You Front-End/Web Developer? You should not miss this: AWS re:Invent 2020 - Front-End Web & Mobile Announcements / Sessions

Jaymitkumar Bhoraniya — Sun, 13 Dec 2020 09:23:05 +0000

Are You Front-End/Web/Mobile Developer? Do you want to build/deploy your web/mobile application the fastest, the easiest way securely that scales on the AWS cloud?

Make sure you should not miss this:

In-case AWS Amplify new for you, please refer to this once: How will AWS Amplify (AWS Cloud) be going to make the Front-End Developer's life easy?

AWS re:Invent 2020 - Front-End Web & Mobile (AWS Amplify, AWS AppSync, More) - Announcements and Sessions to learn - All Together”:

Yet not registered for AWS re:Invent 2020? Click here to register

AWS Front-End Web & Mobile re:Invent 2020 Announcements:

AWS Amplify announces new Admin UI:https://aws.amazon.com/about-aws/whats-new/2020/12/aws-amplify-announces-new-admin-ui/
Amplify CLI enables serverless container deployments using AWS Fargate:https://aws.amazon.com/about-aws/whats-new/2020/12/amplify-cli-enables-serverless-container-deployments-using-aws-fargate/

AWS Front-End Web & Mobile re:Invent 2020 Sessions to learn:

Add a custom domain to your AWS Amplify-hosted web application: https://virtual.awsevents.com/media/1_833qyglx
Build a web application and query stored data using AWS Amplify:
https://virtual.awsevents.com/media/1_dqu343xe
Add image recognition to a web application build with AWS Amplify:https://virtual.awsevents.com/media/1_v8mg0yr9
Getting started building your first serverless web application:
https://virtual.awsevents.com/media/1_uf774rsf
Empower front-end web and mobile app development with AWS Amplify:https://virtual.awsevents.com/media/1_7an6cnep
Power modern serverless applications with GraphQL and AWS AppSync:https://virtual.awsevents.com/media/1_2w0fa3pk
Build iOS & Android mobile apps in record time with Flutter and AWS Amplify:https://virtual.awsevents.com/media/1_8sbjyktd
Speed up your release cycle: Build a web app from idea to MVP with AWS Amplify:https://virtual.awsevents.com/media/1_lwarkwwm
Model and access application data more efficiently with AWS Amplify:https://virtual.awsevents.com/media/1_128yktbk
Best practices to securely operate GraphQL at scale with AS AppSync:https://virtual.awsevents.com/media/1_gk92ddbw
Unify access to siloed data with AWS AppSync GraphQL resolvers:
https://virtual.awsevents.com/media/1_ov2gbvu6
Build and deploy dynamic Jamstack apps with AWS Amplify: https://virtual.awsevents.com/media/0_2677e112
Serverless, the Swift way: https://virtual.awsevents.com/media/0_bgyl7lbe
Faster application iteration with AWS Amplify CI/CD: https://virtual.awsevents.com/media/0_mqrhh5mn
API patterns and architectures: RESTful vs. GraphQL APIs: https://virtual.awsevents.com/media/0_si2jrm6e
Beyond authentication: Guide to secure Amazon Cognito applications:https://virtual.awsevents.com/media/0_grif4cw8

For relevant more details, please check this, Nader Dabit posted here officially in AWS blog:The AWS re:Invent 2020 Guide to Front-end Web and Mobile Sessions

How will AWS Amplify (AWS Cloud) be going to make the Front-End Developer's life easy?

Jaymitkumar Bhoraniya — Sat, 21 Nov 2020 20:00:24 +0000

Front-End Developers can implement application code but they have some limitations and dependency relevant to the many areas while they are just working on front-end development.

AWS Amplify (AWS Cloud) will make front-end developer's life easy as it allows the fastest, easiest way to develop mobile and web apps that scale on the AWS cloud.

AWS Amplify is a set of products and tools that enables mobile and front-end web developers to build and deploy secure, scalable full-stack applications, powered by AWS. With AWS Amplify, you can configure app backends in minutes, connect them to your app in just a few lines of code, and deploy static web apps in three steps. Get to market faster with AWS Amplify.

AWS Amplify Benefits:

Configure AWS backends fast
Easily connect to your app
Deploy web apps in a few steps
The fastest, easiest way to develop mobile and web apps that scale

AWS Amplify Features:

Amplify Framework:
Amplify Libraries - AWS Amplify offers use case-centric open source libraries in the Amplify Framework to build cloud-powered mobile and web apps. Amplify libraries are powered by AWS services and can be used with new backends created with the Amplify CLI or your existing AWS backend.

Authentication
DataStore
Analytics
API
Interactions
Predictions
PubSub
Push notifications
Storage
More...

Amplify UI components - Amplify UI Components is an open-source UI toolkit that encapsulates cloud-connected workflows inside of cross-framework UI components. AWS Amplify provides drop-in UI components with a style guide for your apps that automatically integrate with your configured cloud services.

Authentication
Storage
Interactions
More...

Amplify CLI - The Amplify Command Line Interface (CLI) is a toolchain to create and maintain serverless backends on AWS. Configure cloud functionality by following a simple, interactive workflow for specifying app capabilities, including the data model and auth requirements.

Backend configuration
Static hosting
API definition

Static Web Hosting: - AWS Amplify Console provides a CICD workflow for building and deploying full-stack serverless web applications through the AWS console. A full-stack serverless app consists of a backend built with cloud resources such as GraphQL or REST APIs, file and data storage, and a frontend built with single page application frameworks such as React, Angular, Vue, more.

Feature branch deployments
Globally available
Custom domain setup
Instant+Atomic deployments
Continuous workflows
Password protection

Amplify Framework works with many platforms or front-end framework:
Web:

JavaScript
React
Angular
Vue
Next.js

Mobile:

Android
IOS
React Native
Ionic
Flutter

How AWS Amplify works:

Develop App

Host Web App

Just a few AWS Amplify CLI command like the below make front-end developer life easy and give them the power to manage end-to-end application development & deployment that scale on AWS cloud:

Sign up for an AWS account
https://portal.aws.amazon.com/billing/signup#/start
Install and configure the Amplify CLI
npm install -g @aws-amplify/cli
amplify configure
Create a new React App
npm create-react-app react-amplified
cd react-amplified
npm start
Initialize a new backend
amplify init
Add and Deploy API
amplify add api
amplify push
Add Authentication / Storage / More
amplify add auth
amplify add storage
amplify push
Deploy and Host app
amplify add hosting
amplify publish

To get started with AWS Amplify visit: https://docs.amplify.aws/start