Forem: Abhishek Rajendra Wagh

AWS Community Builders on a Holiday

Abhishek Rajendra Wagh — Tue, 20 Dec 2022 08:00:00 +0000

Hello 👋, this is Abhishek and I am community builder for 3 consecutive years. Here are my few cents on the community builders program!

What surprises you most about the Community Builders Program?

The sheer amount of helpful content produced by the community builders helping a lot of folks out there without expecting anything in return is commendable and to be praised for always.

What’s your background and your experience with AWS?

I am a platform engineer by profession and also a backend engineer. Since I started working I only used AWS as my go to cloud provider because of the amount of services and solutions it provides and the community support for the same.

What’s the biggest benefit you see from the program?

The biggest benefit I see is this program brings the community builders around the globe under one roof and it gives everyone huge opportunity to network with like minded people and the solutions they are building on AWS.

What’s the next swag item that you would like to get?

I would like to add a builders hoodie or the tumbler which was given out at re:invent to my swag collection. Although Jason and team always surprise with the new items, so open for surprises.

What are you eating for dinner today? Share the recipe!

I am eating butter chicken today for dinner! For the recipe head over to - Butter Chicken

Do you have anything else to say about the community builders programme in 2022?

I can't thank enough Jason and team to bring this program to us. Because of this program I am able to grow and reach out to fellow community builders and learn a lot from them. Whenever I feel low on motivation, I go back to Community Builders Slack channel and see what everyone's doing and get my motivation high.

How to build Serverless GraphQL API using AWS AppSync

Abhishek Rajendra Wagh — Sun, 25 Sep 2022 12:00:06 +0000

What is GraphQL?

GraphQL is a query language for APIs which provides a complete and understandable description of the data in the API. GraphQL APIs give the exact data that the client wants, nothing more or less.

GraphQL is fast and flexible to use as compared to REST. GraphQL allows clients to decide what data to be returned unlike servers in REST. GraphQL reduces the number of HTTP requests since it can get you all the data required by your app in a single request. According to official documentation, apps using GraphQL can be quick even on slow mobile network connections.

GraphQL Operations

Query - Used to fetch the data from the GraphQL API, same as GET request
Mutation - Used to manipulate the data, same as CREATE, UPDATE, DELETE
Subscription - Used to listen or subscribe to the changes to the data

What is AppSync?

AWS AppSync is a fully managed, serverless GraphQL API service offered by Amazon Web Services. AppSync allows developers to build GraphQL APIs without much hassle; it takes care of the parsing and resolution of requests.

It also natively supports integration with other AWS services like AWS Lambda, NoSQL and SQL databases, and HTTP APIs to gather backend data for the API.

What are we going to build?

We will build a GraphQL API using AWS AppSync to perform CRUD operations. For example, we will make an API that will allow us to create, read, update and delete a blog. We will use DynamoDB to store our blog data to achieve the functionality of the CRUD API we will use Lambda. To configure our resources we will use Serverless Framework.

Initialising the project

First of all, create an empty directory and we will create a new serverless project in this directory. You can use the following command to do that.

serverless create --template aws-nodejs

The above command will create a new serverless project for you from scratch and you can find the serverless.yml file in the editor. This file is the heart of the project, where we will define all our infrastructure.

This is how the serverless.yml file will look after all the resources are defined. I will explain each section of this file further.

Firstly, start defining the basics like region, stage, and global configuration variables in the provider section.



provider:
  name: aws
  runtime: nodejs12.x
  lambdaHashingVersion: 20201221
  region: ${env:REGION, 'ap-south-1'}
  stage: ${opt:stage, 'dev'}
  timeout: 30

Then, we define global-level environment variables, as defined in the image below.



  # Environment variables
  environment:
    STAGE: ${self:provider.stage}
    REGION: ${self:provider.region}
    SERVICE_NAME: ${self:service}-${self:provider.stage}
    DYNAMODB: ${self:service}-${self:provider.stage}

IAM role statements

Since we are going to use DynamoDB to store the data and it will be integrated with the lambda function, we will need to define IAM role statements to give permission to the lambda function to access our DynamoDB table.



# IAM statements
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:GetItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
        - dynamodb:PutItem
      Resource: "arn:aws:dynamodb:${opt:region, self:provider.region}:*:table/${self:provider.environment.DYNAMODB}"
    - Effect: Allow
      Action:
        - lambda:invokeFunction
      Resource: "*"

serverless-appsync-plugin

serverless-appsync-plugin allows us to deploy AppSync API without much hassle, it provides a lot of configurations to set up your API on AppSync.



plugins:
  - serverless-appsync-plugin

Lambda Functions



functions:
  createBlog:
    handler: createBlog/index.handler
    name: createBlog-${self:provider.stage}
  getBlog:
    handler: getBlog/index.handler
    name: getBlog-${self:provider.stage}
  updateBlog:
    handler: updateBlog/index.handler
    name: updateBlog-${self:provider.stage}
  deleteBlog:
    handler: deleteBlog/index.handler
    name: deleteBlog-${self:provider.stage}

Now, it's time to set up the appsync configuration provided by serverless-appsync-plugin, this plugin has a lot of configurations available, in the below code snippet you can find some of them. In the custom section of the serverless.yml file, we can define the configurations.

To know more about what each of these configuration parameters does, head over to this link.



custom:

  appSync:

    name: appsync-crud-api

    schema: schema.api.graphql

    authenticationType: API_KEY

    apiKeys:

      - apiKey

    dataSources:

      - type: AWS_LAMBDA

        name: createBlog

        description: 'Lambda'

        config:

          functionName: createBlog


      - type: AWS_LAMBDA

        name: getBlog

        description: 'Lambda'

        config:

          functionName: getBlog

      - type: AWS_LAMBDA

        name: updateBlog

        description: 'Lambda'

        config:

          functionName: updateBlog

      - type: AWS_LAMBDA

        name: deleteBlog

        description: 'Lambda'

        config:

          functionName: deleteBlog

DynamoDB Table

To store the blog data we are using the dynamodb table which can be configured like the below:



resources:

  Resources:

    BlogsTable:

      Type: 'AWS::DynamoDB::Table'

      Properties:

        AttributeDefinitions:

          - AttributeName: id

            AttributeType: S

        KeySchema:

          - AttributeName: id

            KeyType: HASH

        ProvisionedThroughput:

          ReadCapacityUnits: 1

          WriteCapacityUnits: 1

        TableName: ${self:provider.environment.DYNAMODB}

GraphQL Schema

Every graphql API needs a schema where we define all the operations(query, mutation, subscription). We will need to create a file named schema.api.graphql. This same file we have referred to in the appsync plugin configuration is in the custom section. The file should look something like this:



schema {

    query: Query

    mutation: Mutation

}

type Query {

    # Query for blog details

    getBlog(id: ID!): Blog

}

type Mutation {

    # Create blog

    createBlog(input: CreateBlogInput!): AWSJSON

# Update blog
updateBlog(input: UpdateBlogInput!): AWSJSON

# delete blog
deleteBlog(id: ID!): AWSJSON



}

input UpdateBlogInput {

    id: ID!

    title: String

    blogUrl: String

    author: String

    publicationDate: AWSDate

}

input CreateBlogInput {

    title: String!

    blogUrl: String!

    author: String!

    publicationDate: AWSDate!

}

type Blog {

    id: ID

    title: String

    blogUrl: String

    author: String

    publicationDate: AWSDate

}

Lambda Function Code

Now it's time to move towards lambda functions, which will act as a resolver for the API. Hence the name, "Lambda Resolvers". As you can see in the image below, I have created a folder for each of the lambda functions which we defined in the functions section in the serverless.yml file.

All four lambdas just perform very simple dynamodb CRUD operations using dynamodb DocumentClient() from aws-sdk. I won't explain the lambda code since it's really straightforward. You can head over to this repository and find the code.

If you have followed until now, then it's time to deploy our service 🚀.

Use serverless deploy to deploy all of your defined resources to the aws cloud. This will give you the deployed API URL and API_KEY in the console which can be used by the client application.

Testing the GraphQL API

Once your deployment is successful, you'll see something like this in the AppSync console. You'll see a tile with the name you have given to your API.

Click on the tile and you'll see another interface, then in the left nav click on Queries. You should see the following interface where you will find all the CRUD operations we have defined in our schema.api.graphql file.

In the mutations section, you'll find createBlog, updateBlog, and deleteBlog, and in the queries section, you'll find getBlog.

You can then test the createBlog mutation by entering some data and hitting the play button on the top should give you the success response by returning the created blog's data in the rightmost window.

By doing the same steps, you can test the other operations as well.

Aaaand 🥁, we are done with the whole backend side of things. We just created an API for a simple blog application.

That's all for this blog, if you liked it do not forget to react to the blog. Thanks for reading and following along, Peace ☮✌️.

Feel free to reach out to me:

GitHub - https://github.com/iabhishek07
Twitter - https://twitter.com/abhishekrwagh
LinkedIn - https://www.linkedin.com/in/iamabhishek21/
Email - waghabhi21@gmail.com

How to deploy your websites with AWS Amplify?

Abhishek Rajendra Wagh — Fri, 14 Aug 2020 17:55:37 +0000

What is AWS Amplify

AWS Amplify helps mobile developers and web developers to build highly scalable and secure full-stack applications powered by AWS. Amplify enables developers to easily create custom onboarding flows, develop voice-enabled experiences, and many more.

We are going to use AWS Amplify Console to deploy our static website built using HTML and SASS.

AWS Amplify Console allows users to host static websites along with the accelerated release cycle by providing a simple CI/CD workflow for the deployment.

Initial Requirements

AWS Account (free tier works!)
GitHub repository of the project
A Domain (in case you want a custom domain)

Now head over to aws.amazon.com/amplify and create a free tier account. It's simple you just need to click on 'create an AWS account' and follow the procedure.

How it works: Deploy

Now there are just three simple steps to deploy your static web application with Amplify.

Step 1: Connecting your GitHub Repository
You can upload your project to a repository on GitHub, Bit Bucket, GitLab, or CodeCommit.

I uploaded my website to GitHub, so I am going to select the GitHub option to connect source code.

Click 'Continue' to proceed and now after authentication with GitHub, you have to select a particular branch from the repository, in my case name of the repository is 'Natours' and the branch is 'master'.

Now, click on next and you will be directed to the next step!

Step 2: Configure Build Settings

In this step, you will be asked to pick a name for your application and to review your build and test settings, which are auto-detected by the console itself. In advance settings, you can also add custom build image and environment variables.

After that, you have to click next and review your 'Repository details' and 'App settings'. If everything is alright, you can click on "Save and Deploy".

Step 3: Deploy your App

When you click on save and deploy, the continuous deployment starts, you can see the following steps on the console:

After all the four steps turn into green checkmarks, you can see the following screen, and you can click the website preview on the left side to open your live website!

Here is the link to the website I just deployed!

Thanks for reading and following along, Peace ☮✌️.

Feel free to reach out to me:

GitHub - https://github.com/iabhishek07
Twitter - https://twitter.com/I_AM_Abhishek07
LinkedIn - https://www.linkedin.com/in/abhishek-wagh-674283141/
EMail - waghabhi21@gmail.com