DEV Community: Akil Mahmod Tipu

How I Passed the AWS Certified Cloud Practitioner in 4 Days

Akil Mahmod Tipu — Wed, 26 Jul 2023 04:48:26 +0000

I passed the AWS Certified Cloud Practitioner exam in 4 days, with prior cloud experience.

Here are the steps I followed:

Took a practice test and scored 58%. (from 6 Practice Exams Course by Stephane Maarek on Udemy)
Watched Stephane Maarek's Practitioner Course(Udemy) on 2x speed, taking no notes.
Read the course slides and took handwritten notes (almost 300 pages).
Took another practice test and scored 81%.
Reviewed my own handwritten notes.
Took 4 more practice tests, reviewed incorrect and correct questions each time, and took handwritten notes.
On exam day, I didn't study and passed the exam.

Tips:

Don't study any dumps. Instead, take paid practice tests.
Review your incorrect and correct questions after each practice test.
Don't over study. The exam is designed to be passed with 70% correct answers.

I hope this helps!

Build an End-to-End Web Application with AWS: Step-by-Step Guide

Akil Mahmod Tipu — Wed, 12 Jul 2023 08:34:18 +0000

In this blog post, we will walk through the steps involved in building an end-to-end web application using AWS services.

Overview of the services and application we'll be building:

The application we will build is a simple calculator. Users will be able to enter two numbers and the application will calculate the result. The result will be stored in a DynamoDB table and the user will be able to view it again later.

Architect the web application from scratch:

The first step is to architect the web application. We need to decide how the different services will interact with each other.

The user will interact with the application through a web page. The web page will be hosted on Amplify. When the user clicks the "Calculate" button, the web page will send a request to the Lambda function. The Lambda function will perform the calculation and store the result in the DynamoDB table. The web page will then retrieve the result from the DynamoDB table and display it to the user.

We will use five AWS services:

AWS Amplify: Amplify is a service that makes it easy to build and deploy web applications.
AWS Lambda: To perform math calculations. Lambda is a service that lets you run code without provisioning or managing servers.
Amazon DynamoDB: To store the results of the math calculations. DynamoDB is a service that provides a NoSQL database.
Amazon API Gateway: To expose the math functionality to users. API Gateway is a service that helps you create, publish, and manage APIs.
IAM: To manage permissions.

Prerequisites:
Before you follow along with this tutorial, you will need the following:

An AWS account.
A basic understanding of AWS services.
A text editor.

Step 1: Create a Web Page with Amplify

We will use Amplify to create and host a simple web page. The web page will simply display the name of our application.
Before getting started with Amplify create an index.html file with the following code:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>To the Power of Math!</title>
</head>

<body>
    To the Power of Math!
</body>
</html>

Or you can copy the index.html this Gist

and zip this file name index.zip. Now,

Go to the Amplify Console: https://console.aws.amazon.com/amplify/home.
Select Amplify Hosting, Click Continue
Select Deploy without Git provider for manual deployment.
Enter a name for your project and an environment name.

Drag and drop the index.zip file from your local machine into the Method field.
Click Save and Deploy.

Once the deployment is complete, you will see a Deployment a successfully completed message and link to your web page. Open the link in your browser to view the web page.

And your live website should look like this:

Step 2: Create a Lambda Function to Perform Math Calculations

We will use a Lambda function to perform the math calculations that our users will need. The Lambda function will take two numbers as input and return the calculation result.

Go to the Lambda Console: https://console.aws.amazon.com/lambda/home.

Click Create a function.
Select the Author from scratch.
Enter a name for your Lambda function.
Select the latest Python 3.10 runtime (Architecture: x86_64).
You can leave everything else the same.
Click Create function.

The Lambda function code will be pre-populated with some sample code. Replace the sample code with the following code:

# import the JSON utility package
import json
# import the Python math library
import math

# define the handler function that the Lambda service will use an entry point
def lambda_handler(event, context):

# extract the two numbers from the Lambda service's event object
    mathResult = math.pow(int(event['base']), int(event['exponent']))

    # return a properly formatted JSON object
    return {
    'statusCode': 200,
    'body': json.dumps('Your result is ' + str(mathResult))
    }

Or Copy the code from this Gist

We have a simple code that imports the JSON utility package and the Python math library. The lambda handler is where most of the work is done. The user passes in two numbers, the base number, and the exponent, which are extracted from the event object. We use math.pow function to calculate the result. Finally, we return the result in a JSON object.

Now make sure to save the code by Ctrl + S and very importantly Deploy the code.

Testing our Lambda function:
To test our Lambda function, set up a new test event by clicking the dropdown arrow next to the "test" option.

Create an event named "PowerOfMathTestEvent" and leave it private. We only need two values: the base and the exponent. You can choose any values you want. For example, I'll use 2 as the base and 3 as the exponent, which should give us 8. Scroll down and save.

We've finished configuring the test event, and now it's time to run the test. Simply click the Test button. If everything is working correctly, you should receive a status code of 200 and the result should be 8. This confirms that our Lambda function is functioning properly.

So far, we have a basic HTML page hosted on Amplify and a Lambda function for performing simple math operations. Now, our next step is to find a way to invoke the Lambda function without users having to access the AWS console. We need a public endpoint or URL that can trigger the function to run. To achieve this, we'll utilize API Gateway, a core AWS service for building APIs (HTTP, REST, or WebSocket). API Gateway is the ideal method to invoke our Lambda function. Let's proceed with setting it up.

STEP 3: Creating a REST API for our Lambda function using API Gateway

We're now going to create a REST API for our Lambda function using API Gateway. Go to the Lambda Console: https://console.aws.amazon.com/apigateway/home
Click Create API button and from REST API select Build. Select "REST API" and click on the "New API" button to begin.

Leave the default options and give it a name, such as "PowerOfMathAPI" and endpoint type Regional click on "Create API" to proceed.

Currently, our API is empty, so let's add a method. In the left panel, select "Resources," then select the backslash ("/"). From the actions menu, choose "Create Method." Select "POST" as the method type since we'll be receiving data from the user. Save the method.

For the integration type, choose "Lambda Function." Enter the name of the Lambda function, such as "PowerOfMathFunction." Save your changes.

Next, we need to enable Cross-Origin Resource Sharing (CORS). To do this, ensure that "POST" is selected in the API Gateway console. Then, from the actions menu, choose "Enable CORS." This allows a web application on one domain to access resources on a different domain. Since our web application is hosted on Amplify and our Lambda function will run on another domain, we need to enable CORS for them to work together. Simply click on "Enable CORS" and confirm your selection.

Now, let's deploy the API to test it out. In the API Gateway console, click on the actions menu and choose "Deploy API." We'll set up a new stage, which we'll name "dev" for this example. Click on "Deploy."

To validate our setup, go to the left panel, click on "Resources," and select "POST." Here, you'll see the flow of the request from the method to the integration with Lambda and back to the client. To test it, click on the blue lightning bolt icon.

You can send test data in a simple format, such as {"base”: 2, “exponent”: 4} Click on "Test," and you should receive a result of 16. Great!

This progress means we can now trigger our math function in Lambda with an API call.

Now, we can trigger our math function in Lambda with an API call. However, we still need to connect it to our index.html page and Amplify, but we'll address that soon.

Next, let's explore how to incorporate a database into our setup. We want to store the math results and also return them to the user. While it's not necessary to store the results, most real-world applications use databases. We'll use DynamoDB, a lightweight NoSQL database that doesn't require upfront schema and relationship setup like relational databases.

Additionally, we need to handle permissions between different parts of the application. In this case, we need to grant our Lambda function permission to write to the database. Let's proceed with configuring this aspect.

Step 4: Create a DynamoDB Table to Store the Results

To store our math results, let's create a new DynamoDB table. Go to the DynamoDB Console: https://console.aws.amazon.com/dynamodb/home

Click on "Create table" and provide a table name, such as "PowerOfMathDatabase." For the partition key, let's use "id." Leave the remaining settings as default and create the table.

Now, it's important to save the Amazon Resource Name (ARN) for this table. Go to the table details, specifically the "General information" and "Additional info" sections. Copy the ARN and keep it anywhere that will be needed later.

Let's grant our Lambda function permission to write to the DynamoDB table. Go back to the Lambda function "PowerOfMathFunction" (or locate it in the Lambda console). Access the configuration tab and navigate to the "Permissions" section. Click on the role name, which will open in a new tab.

To add additional permissions for DynamoDB, click on "Add permissions" on the right side. Then, choose "Create inline policy" and select the JSON tab.

Copy JSON code below or from this Gist and replace the existing code.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "dynamodb:PutItem",
                "dynamodb:DeleteItem",
                "dynamodb:GetItem",
                "dynamodb:Scan",
                "dynamodb:Query",
                "dynamodb:UpdateItem"
            ],
            "Resource": "YOUR-TABLE-ARN"
        }
    ]
}

The JSON code grants various DynamoDB actions to the Lambda function. However, make sure to update the table ARN in the code. Retrieve the ARN you previously saved and replace it accordingly.

Review the policy, give it a name (e.g., "PowerOfMathDynamoPolicy"), and click on "Create policy."

With the permissions in place, we have completed this step.

Updating the Lambda function code to write to the DynamoDB table

Now, let's update the Lambda function to interact with the database. Go back to the Lambda function "PowerOfMathFunction" and access the code. Replace the existing code with the updated code provided below or copy from this Gist.

# import the JSON utility package
import json
# import the Python math library
import math

# import the AWS SDK (for Python the package name is boto3)
import boto3
# import two packages to help us with dates and date formatting
from time import gmtime, strftime

# create a DynamoDB object using the AWS SDK
dynamodb = boto3.resource('dynamodb')
# use the DynamoDB object to select our table
table = dynamodb.Table('PowerOfMathDatabase')
# store the current time in a human readable format in a variable
now = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())

# define the handler function that the Lambda service will use an entry point
def lambda_handler(event, context):

# extract the two numbers from the Lambda service's event object
    mathResult = math.pow(int(event['base']), int(event['exponent']))

# write result and time to the DynamoDB table using the object we instantiated and save response in a variable
    response = table.put_item(
        Item={
            'id': str(mathResult),
            'LatestGreetingTime':now
            })

# return a properly formatted JSON object
    return {
    'statusCode': 200,
    'body': json.dumps('Your result is ' + str(mathResult))
    }

Ensure that you modify the table name if necessary.

The updated code includes new imports for the AWS SDK (boto3) and packages for date and time formatting. It retrieves the DynamoDB table resource, gets the current time, and inserts the math result along with the timestamp into the table using the table.put_item function.

After pasting the updated code, save the changes and deploy the function to apply the updates. Then, test the function using the same test case. Verify that the result is still correct. Additionally, check the DynamoDB table and explore the table items button to see the stored result.

With the Lambda function now writing data to the DynamoDB table and having the proper permissions, we're making progress.

We're almost there! However, you might have noticed that we're missing a connection between Amplify and API Gateway. To address this, we need to update the index.html page.

Open the index.html file and replace its contents with the provided code from this PowerOfMath_index_updated.html Gist

The updated code includes some styling enhancements and a form where users can input their numbers. The magic happens with the "callApi" function, which connects to the API Gateway endpoint. Make sure to update the endpoint URL with your own APIGateway Invoke URL.

Save the changes to the index.html file. Create a zip file containing the updated file, and delete the previous zip file if necessary. Drag and drop the new zip file into Amplify, and it will automatically redeploy.

Once the deployment is successful, refresh the page. You will now see the updated web application with the new styling and functionality.

Let's go through what happens when we use the web application. We enter our numbers, for example, 3 to the power of 5. When we click the calculate button, the script on the HTML page calls API Gateway. This triggers the Lambda function, which performs the calculation and writes the result to the database. Finally, we receive a message in the browser through API Gateway. Let's try it out. Calculate... and the result is 243.

That's it! Our application is complete. Well done! Feel free to share the link with your friends if you'd like.

IMPORTANT!! Delete your resources (I'll show you how)

Before we conclude, it's essential to delete all the resources we created to avoid unexpected charges. Follow these simple steps to delete everything:

Close any tabs related to the application.
In the Amplify console, click on "Actions" in the top right corner and select "Delete app." Confirm the deletion.
Move to DynamoDB and click on "Tables." Locate the "PowerOfMathDatabase" table and choose "Delete." Confirm the deletion.
Delete the Lambda function by selecting "PowerOfMathFunction" and clicking on "Actions" and "Delete."
Lastly, go to API Gateway, click on "APIs," and select the appropriate API. Choose "Actions" and "Delete" to delete it.

And that's it! By following these steps, you have successfully removed all the resources we created. If you found this helpful, consider liking and follow me for more content. Thank you!

Provision a server on AWS: a step-by-step guide for the absolute beginner.

Akil Mahmod Tipu — Sun, 02 Jul 2023 17:05:26 +0000

Amazon Elastic Compute Cloud (EC2) is a service that provides virtual servers on the AWS cloud. Without further ado, we will provision an EC2 server following these step-by-step instructions.

Launch an EC2 instance from AWS Management Console.

Log in to your AWS management console using your root or IAM account. Using IAM with administrator access is recommended for this tutorial.
After logging in to the console from the top search bar search EC2 then click EC2 like the image below.

Now you are in the ec2 console like the below image.

From the left sidebar select Security Group.

A Security Group in AWS is a virtual firewall that controls inbound and outbound traffic for instances. It acts as a filter for network traffic, allowing only specified connections while blocking others.

Now we are gonna create a custom security group for our server allowing SSH, HTTP, and HTTPS Ports: First, give a Security Group Name. In this case: MyNodejsSG

To allow SSH access, create a new inbound rule and specify the Type SSH and Source Type Anywhere-IPv4. Similarly create HTTP and HTTPs rules.

Now go to the Security Group dashboard and rename the Security Group name as below for better recognition.

Key Pair:

Key pairs in AWS are used for secure SSH (Secure Shell) access to EC2 instances. They consist of a public key that is stored on the instance and a private key that is kept securely by the user, allowing for secure authentication and data encryption.

Create a key pair like this image and save this on your local machine for later use.

Launch EC2 instance:

Instances in AWS are virtual servers that can be launched and terminated on demand. They provide scalable computing resources and can be configured with various operating systems and applications. Now we are going to create a Ubuntu 22.04 server.

Click the Launch Instance button from your EC2 dashboard. Then give a name of your instance. I named it MyNodejsWebServer.

From Application and OS Images usually called AMI(Amazon Machine Image) select Ubuntu Server 22.04 which one is Free tier eligible.

Instance type: t2.micro (free tier eligible)
Key pair (login): Select my_node_js_server_key from the dropdown menu that we created earlier.
Configure storage: keep it default 8 GiB gp3 root volume.

And keep everything default for now then click the Launch Instance Button from the bottom.

In a minute your instance will be running.

After successfully running your instances click on the instance id (you can find your instance id from ec2 dashboard > instances)

Log in to the server:

By clicking the instance id you find details about your instance. From here copy your public IPv4 DNS id or Public IPv4 address for later use.
Below your instances summary click CONNECT button then go to the SSH Client tab. You will find instructions like this.

Following this instruction you will able to log in to your server from your local machine.

XPath Cheat Sheet for Web Scraping

Akil Mahmod Tipu — Thu, 23 Jun 2022 09:18:21 +0000

About this Cheat Sheet

👉 This Cheat Sheet covers all the examples I included in my Web
Scraping course with Python using Requests, LXML and Splash.
👉 This Cheat Sheet covers only the basics of how to use XPath to
locate elements from the HTML markup.
👉 All the XPath expressions I’m gonna cover on this Cheat Sheet will
be applied on the HTML.

HTML web page

<!DOCTYPE html>
<html lang="en">
   <head>
      <title>XPath and CSS Selectors</title>
   </head>
   <body>
      <h1>XPath expressions simplified</h1>
      <div class="intro">
         <p>
            I'm paragraph within a div with a class set to
            intro
            <span id="location">I'm a span with ID set to
            location and i'm within a paragraph</span>
         </p>
         <p id="outside">I'm a paragraph with ID set to
            outside and i'm within a div with a class set to intro
         </p>
      </div>
      <p>Hi i'm placed immediately after a div with a class
         set to intro
      </p>
      <span class='intro'>Div with a class attribute set to
      intro
      </span>
      <ul id="items">
         <li data-identifier="7">Item 1</li>
         <li>Item 2</li>
         <li>Item 3</li>
         <li>Item 4</li>
      </ul>
      <a href="https://www.google.com">Google</a>
      <a href="http://www.google.fr">Google France</a>
      <p class='bold italic'>Hi, I have two classes</p>
      <p class='bold'>Hi i'm bold</p>
   </body>
</html>

BASICS

An element is a tag in the HTML markup.

Example:

The ‘p’ tag aka paragragh is called an element.
To select any element from HTML web pages we simply use the
following syntax

Example:

To select all p elements we can use the following XPath selector

//p

Although this approach works perfectly fine, it’s not recommended to use it, because if for example we want only to select the “p” elements that are inside the first div with a class attribute equals to “intro” this approach won’t be the best solution, this is why we always prefer to target elements either by their class attribute, id or
by position so we can limit the scope of the XPath expression.

CLASS & ID

So to select any element by its class attribute value we use the following syntax:

//elementName[@attributeName=’value’]

Example:

Let’s say we want to select the “p” elements that inside the “div” with a class attribute equals to “intro” in this case we use the following XPath expression:

//div[@class=’intro’]/p
If we want to select the “p” element with “id” equals to “outside” we can use the following XPath expression:

//p[@id=’outside’]/p

REMEBER:

_Please note, the same exact class attribute value can be assigned to more than one element however, and id can be assigned to only and only one element. _

Sometimes we want also to select elements based on a foreign attribute which doesn’t belong to HTML markup standard. For example to select the “li” element with the attribute “data-identifier” equals to 7 in this case we use the following XPath expression:

//li[@data-identifier=”7”]

Sometimes the element we want to select does have two classes, for example, to select the “p” element with a class attribute equals to “bold” and “italic” in this case we use the following XPath expression:

//p[@class=’bold italic’]

OR:

Although the element does have two classes we can for example search for a substring within the class attribute value by using the contains function.

//p[contains(@class, ‘italic’)]

REMEBER:

The contains function takes two arguments:

The first one is where to search, whether on the class
attribute value, id or anything else.The second argument is the value you’re looking for. The value you search for is also case sensitive, so be careful!

Value lookup

Let’s say you want to select all the “a” elements in which the “href” attribute value starts with “https” and not “http”, in this case we can use the following XPath expression:

//a[starts-with(@class, ‘https’)]

So search for the text at the beginning we use the caret sign “starts-with” function which takes the same arguments as the contains function.

Now if you want to search for a value at the end we use the “ends-with” function, however, this function is not supported on XPath version 1.0 which is the version used by the majority of the browsers and LXML.

Finally if we want to search for a particular value in between we use the contains function as explained before.

If you want to get the text of a particular element you can use the text function, for example, to get the text element of the “p” element with id equals to “outside” we use the following XPath expression:

//p[@id=”outside”]/text()

The position

Okay, let’s say you want to get the second “li” element from the “ul” element with “id” equals to “outside”, in this case you can use the following XPath expression:

//ul[@id=”items”]/li[2]

However, if you want to select the second list item but you also want to make that its text element is “Item 2”, in this case you can use the following XPath expression:

//ul[@id=”items”]/li[position() = 2 and text() = “Item 2”]
Notice in this case I did use the position() function, the text() function plus the “and” logical operator.

In contrast to the “and” logical operator we also have the “or” logical operator.

REMEBER:

In XPath everything we write within [] is known as a
predicate.

XPath axes

In XPath an axis is used to search for an element based on its relationship with another element, we have some axes which we can use to navigate up and down in the HTML markup.

All axes in XPath use the follwing syntax:

ElementName::axis

XPath axes (GOING UP)

The parent
The parent axis is used to get the parent of a specific
element, for example the get the parent of the “p” element with id equals to “outside” we use the following
XPath expression:

//p[@id="outside"]/parent::node()

The node() function in XPath is used to get the “element” no matter what its type is.

The ancestor

The ancestor axis can be used to all the ancestors of a
specific element, for example to get the ancestors(parent, grand parent, ...) of the “p” element with id equals to “outside“ we use the following XPath expression:

//p[@id="outside"]/ancestor::node()

The preceding

In XPath the preceding axis will get all the elements that do precede an element excluding its ancestors.

Preceding sibling

In XPath the preceding-sibling axis will get the sibling that do precede an element, in other words it will return the brother that is on the top of a specific element.

XPath axes (GOING DOWN)

To go down on the HTML markup we also have 4 axis which are:

The child axis which will get the children of a specific element

The following axis which will return all the elements that are after the closing tag of a specific element.

The following-sibling axis which will return all the
elements that are after the closing tag of an element but these elements should share the same parent.

The descendant axis which will get the descendants of a particular element.

Promotional Alert!

I do web scraping/data mining as a freelance service. If you need to do some scraping project don't hesitate to DM me. You can visit my Upwork profile or Fiverr profile. Also you direct order from Upwork verified python web scraping project catalog or Fiverr Python Web Scraping Gig 1 or Gig 2.

Thank you. 😍

Algorithm: Selection sort, how it works and implementation in python

Akil Mahmod Tipu — Thu, 16 Jul 2020 15:36:02 +0000

In this blog, I will talk about how selection sort works. I will implement examples in python3.

Selection sort is an algorithm that selects the smallest element from an unsorted list in each iteration and placed that element at the beginning of the unsorted list.

How does Selection sort work?

The word ‘select’ means carefully chosen from a group of things as being the best or most valuable. If I have a list of numbers and, I pick a random number without any thinking this should not be select. Rather, If I thoughtfully pick the best one or the appropriate one it should be selected.

In the selection sort, every time we pick the appropriate elements from an array then put it on an appropriate position. Then applying this technique on the rest of the elements of the list, we will get our sorted array.

Let, we have five numbers 10, 5, 2, 8, 7 and we need to sort those numbers in ascending order. To do that use the selection sort algorithm. (fig-1)

Step-1: First we need to find the smallest number from the list of numbers. In this case, the number is 2. Now bringing 2 in the first position of the list. Then exchange 2’s old position with 10 (10 was in the first position). After this step, our list looks like this. (fig-2)

Step-2: Now we have the smallest number at the beginning of the list. So, now we find out the smallest number from the rest of the four numbers. That is 5. Here 5 is it’s the correct position. That’s why no need to swapping. (fig-3)

Step-3: In this step, we find out the smallest number among 10, 8, 7. Here 7 is the smallest. Now bringing 7 in the first among these three numbers. And swapping position with 10. Now our list looks like- 2, 5, 7, 8, 10, and we know that the first three numbers in the correct position. (fig-4)

Step-4: Now find the smallest between 8 and 10. Here 8 is the smallest one and it is in the correct position. So, there is no need to exchange positions. (fig-5)

Within 5 numbers 4 of those are sorted. So, the last one is naturally in the right position. Finally, our list is fully sorted. (fig-6)

Selection sort algorithm in detail:

Input: A list L has n number of elements.

Step-1: Let i = 0

Step-2: If i is greater or equal to (n-1); go to step 11.

Step-3: Let, the index of the smallest elements of the list is, index_min = i

Step-4: Let, j = i+1

Step-5: If j is greater or equal to n then go to step 9

Step-6: If L[j] < L[index_min] go to next step else go to step 8.

Step-7: index_min = j

Step-8: increment j by 1 then go to step 5.

Step-9: If i and index_min is not equal then swap the value of L[i] and L[index_min]

Step-10: Increment i by 1

Step-11: List is now sorted by ascending order.

Implementation in Python 3

def selection_sort(L):
    n = len(L)

    for i in range(0, n-1):
        index_min = i

        for j in range(i+1, n):
            if L[j] < L[index_min]:
                index_min = j

        if index_min != i:
            L[i], L[index_min] = L[index_min], L[i]


if __name__ == "__main__":
    L = [10, 5, 2, 8, 7]
    print("Before sort:", L)
    selection_sort(L)
    print("After sort:", L)

This blog previously published on medium.com