DEV Community: Marcos Ferrero

Hosting a static website on AWS and implementing CI/CD

Marcos Ferrero — Wed, 24 May 2023 02:36:21 +0000

A static website is a website that does not require any server-side processing. This means that the website's content is stored in files and served directly to the user without any need for a web server to process the files. Static website hosting: S3 provides a simple and easy way to host static websites. You can simply upload your website's files to an S3 bucket and configure S3 to serve your website.

For this project, I want to show the benefits of using the following services: Github, AWS Code Pipeline, AWS S3, and Cloudfront to speed the process to set up a website and allow different developers to provide modification to the features.

Github: is a popular code hosting platform that offers a number of benefits for developers, including version control, collaboration, documentation and security.

Create a new GitHub repo for this project.

AWs S3 offers a number of features that make it ideal for hosting static websites, such as: is a fully managed object storage service that provides a durable and scalable storage solution for static websites. Scalability: S3 is a highly scalable service that can easily handle large volumes of traffic.
Durability: S3 is a durable service that provides 99.9999999999% durability for objects stored in S3.

Create a Bucket add a name and keep all the other default options.

Once the Bucket is created, go to the properties tab of that bucket and below click where the option is to edit Static website hosting. Enable it and add the index file name containing the HTML code.

Since the bucket can be access from the public, it does not mean your object is also accessible. At the object level, it should also be accessible else it will throw an error in S3 URL. So here we will define the policies at the object level as shown below.

Please, on the Resource field, add your Bucket name.

Now upload your files to your bucket as shown and after uploading your files, click on the S3 URL.

AWS CloudFront is a content delivery network (CDN) that can be used to improve the performance and security of static websites. CloudFront caches your website's content in edge locations around the world, which can significantly improve the loading time of your website for users in different regions. CloudFront also provides a number of security features, such as:

SSL/TLS encryption: CloudFront can encrypt all traffic between users and your website, which helps to protect user data.
DDoS protection: CloudFront can help to protect your website from distributed denial-of-service (DDoS) attacks.

By using AWS S3 and CloudFront together, you can easily create a highly scalable, durable, and secure static website. Below are some of the benefits of using AWS S3 and CloudFront to host a static website:

Scalability: S3 and CloudFront are both highly scalable services, so you can easily add more capacity as your website grows.

Durability: S3 and CloudFront are both highly durable services, so your website will be up and running even if there is an outage at your web host.

Security: S3 and CloudFront both offer a number of security features, so you can be confident that your website is safe from attack.

Cost-effectiveness: S3 and CloudFront are both very cost-effective services, so you can save money on hosting your website.
If you are looking for a reliable and affordable way to host a static website, then AWS S3 and CloudFront are a great option.

Now, Go the CloudFront and create a distribution and for the origin, it will automatically pop out the S3 URL when you drop down. Unmark the Block all public access and check the Acknowledge box.

CloudFront uses cache content it might delay in displaying your changed content. Therefore, I will be disabling caching as shown above.

After this is created, you will get the Distribution domain name. Open your browser and check if your website is up and running.

AWS CodePipeline is a continuous delivery service that helps you automate your release pipelines for fast and reliable application and infrastructure updates. It provides a visual pipeline editor that makes it easy to model your software release process.

Now, I will create a pipeline to automate release process of the code or any developer can add new features.

In the Source section, you can choose your repository. For me, I have uploaded it on GitHub so I will be linking my Github repo here.

Click on Next, Review the configs and click to create your pipeline. You make some changes to your source code and push it to repo. CodePipeline will automatically detect it and trigger the pipeline.

After creating the pipeline, I added some file to the GitHub repository and went to check out the new release on the pipeline where successfully added the new updates to the pipeline.

Thank you for reading this blog.

Serverless API CRUD with lambda and DynamoDB

Marcos Ferrero — Wed, 26 Apr 2023 01:54:46 +0000

In this blog post, I will show you how to build a serverless CRUD API with AWS Lambda and Amazon DynamoDB using the AWS Console. This is a great way to build APIs quickly and easily without having to worry about managing servers or infrastructure.

An Amazon API Gateway is a collection of resources and methods. For this tutorial, you create one resource (DynamoDBManager) and define one method (POST) on it. The method is backed by a Lambda function (LambdaFunctionOverHttps). That is, when you call the API through an HTTPS endpoint, Amazon API Gateway invokes the Lambda function.

The POST method on the DynamoDBManager resource supports the following DynamoDB operations:

Create, update, and delete an item.
Read an item.
Scan an item.
Other operations (echo, ping), not related to DynamoDB, that you can use for testing.

Prerequisites
An AWS account
The AWS Console

Step 1: Create Lambda IAM Role
Create the execution role that gives your function permission to access AWS resources.

To create an execution role : Open the roles page in the IAM console, Choose Create role. Create a role with the following properties. Trusted entity – Lambda. Role name –lambda-apigateway-role.
Create a Permissions – Custom policy with permission to DynamoDB and CloudWatch Logs. This custom policy has the permissions that the function needs to write data to DynamoDB and upload logs.

{
"Version": "2012-10-17",
"Statement": [
{
  "Sid": "Stmt1428341300017",
  "Action": [
    "dynamodb:DeleteItem",
    "dynamodb:GetItem",
    "dynamodb:PutItem",
    "dynamodb:Query",
    "dynamodb:Scan",
    "dynamodb:UpdateItem"
  ],
  "Effect": "Allow",
  "Resource": "*"
},
{
  "Sid": "",
  "Resource": "*",
  "Action": [
    "logs:CreateLogGroup",
    "logs:CreateLogStream",
    "logs:PutLogEvents"
  ],
  "Effect": "Allow"
}
]
}

Step 2: Create a DynamoDB table
First, we need to create a DynamoDB table to store our data. We can do this using the AWS Console:

Go to the DynamoDB console. To create a DynamoDB table
Open the DynamoDB console.
Choose Create table.
Create a table with the following settings.
Table name – lambda-apigateway
Primary key – id (string)
Click on "Create".

Step 3: Create a Lambda function
Next, we need to create a Lambda function to handle our API requests. We can do this using the AWS Console:

Go to the Lambda console.
Click on "Create Function".
In the "Function name" field, enter a name for your function.
In the "Runtime" drop-down, select "Phyton 3.7".
Add the script with python code.

from __future__ import print_function

import boto3
import json

print('Loading function')


def lambda_handler(event, context):
    '''Provide an event that contains the following keys:

      - operation: one of the operations in the operations dict below
      - tableName: required for operations that interact with DynamoDB
      - payload: a parameter to pass to the operation being performed
    '''
    #print("Received event: " + json.dumps(event, indent=2))

    operation = event['operation']

    if 'tableName' in event:
        dynamo = boto3.resource('dynamodb').Table(event['tableName'])

    operations = {
        'create': lambda x: dynamo.put_item(**x),
        'read': lambda x: dynamo.get_item(**x),
        'update': lambda x: dynamo.update_item(**x),
        'delete': lambda x: dynamo.delete_item(**x),
        'list': lambda x: dynamo.scan(**x),
        'echo': lambda x: x,
        'ping': lambda x: 'pong'
    }

    if operation in operations:
        return operations[operation](event.get('payload'))
    else:
        raise ValueError('Unrecognized operation "{}"'.format(operation))

Add the existing script ambda-apigateway-role wich allow to create, update and delete objects in the DynamoDB table.
Click on "Create".

Test Lambda Function
Let's test our newly created function. We haven't created DynamoDB and the API yet, so we'll do a sample echo operation. The function should output whatever input we pass.

Paste the following JSON into the event. The field "operation" dictates what the lambda function will perform. In this case, it'd simply return the payload from input event as output. Click "Create" to save.

{
    "operation": "echo",
    "payload": {
        "somekey1": "somevalue1",
        "somekey2": "somevalue2"
    }
}

Step 4: Create an API Gateway API
Finally, we need to create an API Gateway API to expose our Lambda function to the internet. We can do this using the AWS Console:

Go to the API Gateway console.
Click on "Create API".
In the "API Name" field, enter a name for your API.
In the "API Type" drop-down, select "REST API".
Click on "Create".
Step 4: Create a method
Now that we have created an API, we need to create a method to handle our API requests. We can do this using the AWS Console:

In the "Methods" tab, click on "Create Method".
In the "Method Type" drop-down, select "POST".
In the "Path" field, enter the path for your method.
Click on "Create".

Step 5: Integrate the method with Lambda
Now that we have created a method, we need to integrate it with our Lambda function. We can do this using the AWS Console:

In the "Integrations" tab, click on "Create Integration".
In the "Integration Type" drop-down, select "Lambda Function".
In the "Lambda Function" field, select the name of your Lambda function.
Click on "Create".

Step 6: Deploy the API
Now that we have configured our API, we need to deploy it. We can do this using the AWS Console:

In the "Actions" menu, click on "Deploy API".
In the "Deployment stage" drop-down, select a stage.
Click on "Deploy".

Testing the API
Running our solution
The Lambda function supports using the create operation to create an item in your DynamoDB table. To request this operation, use the following JSON:

{
    "operation": "create",
    "tableName": "lambda-apigateway",
    "payload": {
        "Item": {
            "id": "1234ABCD",
            "number": 5
        }
    }
}

T o test the solution I used a VS Code extension call Thunder client, is a lightweight Rest API Client Extension for Visual Studio Code, hand-crafted by Ranga Vadhineni with simple and clean design.

Or also can use the Code snippet
curl -X GET https://{API_GATEWAY_ENDPOINT}/{PATH}
Use code with caution.
This will return the response from our Lambda function.

To validate that the item is indeed inserted into DynamoDB table, go to Dynamo console, select "lambda-apigateway" table, select "Items" tab, and the newly inserted item should be displayed.

Cleanup
Let's clean up the resources we have created for this lab.

Cleaning up DynamoDB
To delete the table, from DynamoDB console, select the table "lambda-apigateway", and click "Delete table"

To delete the Lambda, from the Lambda console, select lambda "LambdaFunctionOverHttps", click "Actions", then click Delete

To delete the API we created, in API gateway console, under APIs, select "DynamoDBOperations" API, click "Actions", then "Delete"

Conclusion
In this blog post, we showed you how to build a serverless CRUD API with AWS Lambda and Amazon DynamoDB using the AWS Console. This is a great way to build APIs quickly and easily without having to worry about managing servers or infrastructure.

AWS Internship 2022

Marcos Ferrero — Tue, 29 Nov 2022 03:29:46 +0000

Summer of 2022, I completed an internship with AWS in Herndon, VA. I was assigned to a Data Lake Accelerator project for one of the government agencies which was very exciting and a great experience.

During my internship, I learned AWS processes, different recoding practices, cloud architecture, and how to code better. In addition, I experienced the corporate culture and engaged with the knowledgeable developers that work for AWS.

My role responsibilities consisted of deploying data lake infrastructure, automatically build, test, and deploy new or changed versions of the application from the version control system. I utilized AWS CodeCommit and CodePipeline to set up a CI/CD to help automate multiple steps to automate builds, push code to a repository and then deploy to your updated code to AWS. This helps minimize potential mistakes as opposed to running multiple manual steps Automate deployment to different stages (dev, staging, and production).

I learned AWS CDK and used it to deploy pipelines. The AWS Cloud Development Kit (AWS CDK) is an open-source software development framework to define cloud infrastructure in familiar programming languages and provision it through AWS CloudFormation. The AWS CDK consists of three major components: The core framework for modeling reusable infrastructure components, A CLI for deploying CDK applications, the AWS Construct Library, a set of high-level components that abstract cloud resources and encapsulate proven defaults. The CDK makes it easy to deploy an application to the AWS Cloud from your workstation by simply running CDK deploy. This is good when you’re doing initial development and testing, but you should deploy production workloads through more reliable, automated pipelines.

At some point of the project, I was instructed to test Glue ETL process and querying data information using Athena. AWS Glue is a serverless data integration service that makes it easy for analytics users to discover, prepare, move, and integrate data from multiple sources. You can use it for analytics, machine learning, and application development. It also includes additional productivity and data ops tooling for authoring, running jobs, and implementing business workflows.

Athena helps to analyze unstructured, semi-structured, and structured data stored in Amazon S3. Athena integrates with the AWS Glue Data Catalog, which offers a persistent metadata store for your data in Amazon S3. This allows you to create tables and
query data in Athena based on a central metadata store available throughout your Amazon Web Services account.

As part of my internship, I attended daily 1:1 and scheduled team meeting on Jira (project management skills software), gathered with my internship team to discuss other projects of interest. This gave me the opportunity to take in all of the feedback and put it into practice.

Coming into this internship with zero experience, I definitely feel this internship provided me with the tools I need to grow my career as a solution architect and developer.

Hands-On Approach with AWS Cloud Resume Challenge

Marcos Ferrero — Tue, 26 Apr 2022 01:54:33 +0000

At this stage in my life, I decided to switch careers to focus on the Tech world and what it had to offer. I enrolled at Miami-Dade College with basic knowledge of Cloud Computing. I knew coming into this new world, I had to take a hands-on approach if I wanted to succeed in this new career.

By attending classes, studying, and exposing myself to the unlimited resources, I became a certified AWS Cloud Practitioner (September 2021) and AWS Solution Architect (April 2022). One of my first projects that I was tasked with was the Cloud Resume Challenge by Forrest Brazeal.

Starting the Challenge -

Front end- HTML / CSS

I found a Bootstrap template I liked and modified it to showcase my projects by removing additional pages and links. I tried to keep it as simple as possible. I didn't have previous experience in HTML/CSS; therefore, online resources helped me with editing the template. The HTML page would also include a JavaScript snippet which updated and fetched the visitor count from the "back end."

Static S3 Website

Based on the knowledge I gained with the unlimited resources
and preparing for the AWS certifications, I learned how to host a static website on S3 and using CloudFront for content distribution. I purchased a domain name using AWS Route 53 and configured it to use the CloudFront distribution. Also, I made use of AWS Certification Manager (ACM) to procure an SSL certificate for the site.

Back-end

DynamoDB

I had some knowledge of DynamoDB but very little practical/hands-on experience. I created a Table with a Partition key (date) and an attribute count. Each day, the webpage has a certain amount of visitors. The code to retrieve items from a Table and to update the count, I searched it online and found the code for Python.

Lambda

The Lambda function was also challenging for me because I had no experience. After researching, I created a function with Python code to update the count in the table, and at the same time get the count number. I added the IAM role for the function to access the DynamoDB table and tested that it was working.

API Gateway

Another services was new to me but I was determined to learn it. I had to familiarize myself with the concept of an API in which I was able to understand its goal and function.
The API Gateway exposes a REST API Endpoint, which will be called by Javascript snippet embedded in the front-end html page, on every page visit/refresh - to update and fetch the visitor count from a DynamoDB table, through Lambda function. Enabling CORS (Cross-Origin Resource Sharing) on the API Gateway resource is mandatory to fetch the response back, when it is called.
After this, the backend was done. I could call the API link, this triggered the Lambda function, which increased the count by 1 and returned the value.

Tests

I had previous experience with unit tests so I wrote some tests for the Lambda function.

Infrastructure as Code

At this point, the backend infrastructure creation was fully automated with SAM and the frontend was done fully manually.

Source control

I used git from the beginning and stored my code and all my files in Github →(https://github.com/maf1978/CloudResumeChallenge.git)

CI/CD

I had never used Github Actions but I had used a similar CI/CD tool, so this step was quite fast and fun. I created my template and first ran the unit tests for the Lambda function. In the second step, I used the predefined SAM action to build and deploy the infrastructure to AWS. In the last step, I upload the static files to S3.

Conclusion

Although this was my first project, it gave me confidence because I was able to familiarize myself with new terminology, it gave me experience in the parts where I was lacking skills, gained useful skills, learn how to overcome the challenges of completing each step in the process and succeeding all with a hands-on approach in AWS.

Thanks for reading! Please visit my CV website (www.mafcloudsolutions.com) for more of my Cloud adventures!

My Github repo with the challenge:(https://github.com/maf1978/CloudResumeChallenge.git)