Forem: Ogooluwa Akinola

Hey folks! Checkout my latest tutorial on building a serverless sentiment analytics dashboard

Ogooluwa Akinola — Tue, 25 Mar 2025 04:26:00 +0000

Building a Serverless Social Media Sentiment Analytics Dashboard on AWS

Ogooluwa Akinola ・ Mar 25

Building a Serverless Social Media Sentiment Analytics Dashboard on AWS

Ogooluwa Akinola — Tue, 25 Mar 2025 04:13:39 +0000

Hey there, fellow AWS explorers! Ever wondered how to turn the chaotic chatter of social media into actionable insights? Today, we're diving headfirst into the world of serverless architecture to build a simple analytics dashboard for social media sentiment data.

In this tutorial, we'll walk through building a complete serverless backend solution for a social media sentiment analytics dashboard. We'll be leveraging AWS Lambda, API Gateway, DynamoDB, Amazon Kinesis, and a few other services to create a scalable, cost-effective system. We will be using AWS CloudFormation templates to define and manage our infrastructure as code, which enables version control, reproducibility, and easier collaboration.

Why Serverless?

Now, you might be asking, "Why go serverless?" Great question! Here's why:

No Servers to Manage: Say goodbye to patching, scaling, and the headache of managing infrastructure.
Pay-as-you-go: Only pay for the compute time you consume.
Scalability: AWS handles scaling automatically, so your application can handle any load.
Faster Development: Focus on your code, not infrastructure.
Infrastructure as Code: Using CloudFormation, we define and manage our infrastructure in a declarative way, enabling version control, reproducibility, and easier collaboration.

Let’s get our Hands Dirty

Pre-requisite

AWS Account: If you don't have one, sign up for a free tier account.
IAM User: Create an IAM user with the necessary permissions for Lambda, API Gateway, DynamoDB, etc.
AWS CLI: Install and configure the AWS CLI for command-line access if you haven’t.
Mastodon API Credentials: In this project, we’ll use the Mastodon to source our social media data. Follow this link to obtain your access token.

Note: You can find the complete code here.

Let's get started! We'll break this down into manageable steps.

1. Creating your secrets manager

We’ll create a secrets manager to store our mastodon API credentials.

Navigate to the AWS Secrets Manager console
Click the Store new secrets button
Select Other type of secret
Add your Mastodon API credentials
- MASTODON_INSTANCE_URL
- We use https://mastodon.social for this project
- MASTODON_ACCESS_TOKEN
Save and note the Secret ARN (we will use it later 😉)

2. Creating an S3 bucket for Code storage

We’ll create an S3 bucket to store all code for our lambda functions and cloud formation. This is where we will push our compiled lambda code and cloud formation templates for this project. To do this:

Navigate to the Amazon S3 console.
Click Create a bucket
Provide a unique name for your bucket and use all default settings.
Your bucket URL is https://{YOUR-UNIQUE-BUCKET-NAME}.s3.amazonaws.com
We will use this URL throughout this project

3. Defining the DynamoDB Table with CloudFormation

We'll use DynamoDB to store our sentiment data. Here's the CloudFormation template (dynamodb-table.yaml) that defines our table:

Resources:
  SentimentDataTable:
    Type: 'AWS::DynamoDB::Table'
    Properties:
      TableName: SentimentDataTable
      AttributeDefinitions:
        - 
          AttributeName: DataId
          AttributeType: S
      KeySchema:
        - 
          AttributeName: DataId
          KeyType: HASH
      ProvisionedThroughput:
        ReadCapacityUnits: 5
        WriteCapacityUnits: 5
Outputs:
  SentimentDataTableName:
    Value: !Ref SentimentDataTable
    Description: Name of the Sentiment data table
    Export:
      Name: SentimentDataTableName
  SentimentDataTableArn:
    Value: !GetAtt SentimentDataTable.Arn
    Description: ARN of the Sentiment data table
    Export: 
      Name: SentimentDataTableArn

Explanation:
- The Resources section defines the resources we want to create. Here, we're creating a DynamoDB table named SentimentDataTable.
- Properties specify the table's configuration, including:
- TableName: The name of the table.
- AttributeDefinitions: The attributes that make up the table's schema. We define DataId as a String attribute.
- KeySchema: The primary key for the table. We use DataId as the hash key.
- ProvisionedThroughput: The read and write capacity for the table. For this tutorial, we'll use a basic configuration.
- The Outputs section defines values that are returned when you create the CloudFormation stack. Here, the table name and ARN are exported, which can be used by other stacks.
Deployment: You would deploy this template using the AWS CLI or the AWS Management Console. We will do this later (stay tuned 🙂).
After Deployment, navigate to the AWS console to view the SentimentDataTable.!

4. Building the Lambda Functions

Lambda is the heart of our serverless backend. We'll create three main Lambda functions:

data-collection-function: This function will fetch data from a social media source (Mastodon) and send it to a Kinesis stream.
sentiment-analysis-function: This function will process the data from the Kinesis stream, analyze the sentiment of the text, and store the results in DynamoDB.
api-handlers-function: This function will handle API requests from the frontend, querying the sentiment data from DynamoDB.

4.1 Data Collection Function

Here's the code for the data-collection-function:

import { KinesisClient, PutRecordCommand, PutRecordCommandInput } from "@aws-sdk/client-kinesis";
import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager";
import { Handler } from 'aws-lambda';
import { createRestAPIClient } from 'masto';

const kinesisClient = new KinesisClient({});
const secretsManagerClient = new SecretsManagerClient({});

export const handler: Handler = async (event: any): Promise<{ statusCode: number, body: string }> => {
  try {
    // 1. Retrieve API credentials from Secrets Manager
    const secretResponse = await secretsManagerClient.send(
      new GetSecretValueCommand({ SecretId: "social-media-analytics-secrets-manager" })
    );
    const secrets = JSON.parse(secretResponse.SecretString || "{}");

    const masto = createRestAPIClient({
      url: secrets.MASTODON_INSTANCE_URL || '',
      accessToken: secrets.MASTODON_ACCESS_TOKEN || '',
    });

    // 2. Fetch toots based on your criteria (e.g., keywords, hashtags)
    const toots = await masto.v2.search.list({
      q: "crypto",
      type: "statuses",
      limit: 40
    })

    // 3. Iterate through toots and send them to Kinesis
    const kinesisStreamName = "SocialMediaDataStream";
    const encoder = new TextEncoder()

    const res = await Promise.allSettled(toots.statuses?.map((toot) => {
      const text = toot.content.replace(/<[^>]+>/g, '');
      const postId = toot.id;
      const createdAt = toot.createdAt;
      const authorUsername = toot.account.username;

      const data = {
        PostId: postId,
        Text: text,
        CreatedAt: createdAt,
        AuthorUsername: authorUsername,
      }

      // Prepare data for Kinesis
      const recordParams: PutRecordCommandInput = {
        Data: encoder.encode(JSON.stringify(data)),
        PartitionKey: postId,
        StreamName: kinesisStreamName
      };

      return kinesisClient.send(new PutRecordCommand(recordParams));
    }));

    return {
      statusCode: 200,
      body: "Successfully sent toots to Kinesis",
    };
  } catch (error) {
    console.error("Error processing toots:", error);
    return {
      statusCode: 500,
      body: "Error processing toots",
    };
  }
};

Explanation:
- The function uses the SecretsManagerClient to retrieve the Mastodon API credentials. This is a best practice for security, as it avoids hardcoding sensitive information in your code.
- It then uses the Masto library to fetch "toots" (posts) from Mastodon. In this case, we are searching for “crypto” related posts.
- For each toot, it extracts the relevant data (post ID, text, creation date, author) and sends it to a Kinesis stream using the KinesisClient. The PartitionKey is set to the postId for even data distribution across Kinesis shards.
- For error handling, we log into the console and return a status 500.

4.2 Sentiment Analysis Function

Here's the code for the sentiment-analysis-function:

import { ComprehendClient, DetectSentimentCommand } from "@aws-sdk/client-comprehend";
import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
import { Handler, KinesisStreamEvent } from "aws-lambda";

const comprehendClient = new ComprehendClient({});
const dynamoDBClient = new DynamoDBClient({});

export const handler: Handler = async (event: KinesisStreamEvent) => {
    try {
      // 1. Process each record (toot)
      for (const record of event.Records || []) {
        if (!record?.kinesis?.data) continue

        const toot: {
          PostId: string,
          Text: string,
          AuthorUsername: string,
          CreatedAt: string
        } = JSON.parse(Buffer.from(record.kinesis.data, 'base64').toString())

        // 3. Detect sentiment using Comprehend
        const sentimentResponse = await comprehendClient.send(
          new DetectSentimentCommand({
            LanguageCode: "en",
            Text: toot.Text,
          })
        );

        // 4. Store toot and sentiment in DynamoDB
        const putItemParams = {
          TableName: "SentimentDataTable",
          Item: {
            DataId: { S: toot.PostId },
            Text: { S: toot.Text },
            AuthorUsername: { S: toot.AuthorUsername },
            CreatedAt: { S: toot.CreatedAt },
            Sentiment: { S: sentimentResponse.Sentiment || "UNKNOWN" },
            SentimentScore: {
              M: {
                Positive: { N: sentimentResponse.SentimentScore?.Positive?.toString() || "0" },
                Negative: { N: sentimentResponse.SentimentScore?.Negative?.toString() || "0" },
                Neutral: { N: sentimentResponse.SentimentScore?.Neutral?.toString() || "0" },
                Mixed: { N: sentimentResponse.SentimentScore?.Mixed?.toString() || "0" },
              },
            },
          },
        };
        await dynamoDBClient.send(new PutItemCommand(putItemParams));
      }
    } catch (error) {
      console.error("Error processing records:", error);
    }
};

Explanation:
- This function is triggered by new data arriving in the Kinesis stream. It uses the KinesisClient to retrieve records from the stream.
- For each record, it parses the data and extracts the toot information.
- It then uses the ComprehendClient to detect the sentiment of the toot's text.
- Finally, it stores the toot data and the sentiment analysis results in the DynamoDB table using the DynamoDBClient.

4.3 API Handlers Function

Here's the code for the api-handlers-function:

import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { DynamoDBClient, ExecuteStatementCommand } from '@aws-sdk/client-dynamodb';

const TABLE_NAME = 'SentimentDataTable';
const VALID_SENTIMENTS = ['POSITIVE', 'NEGATIVE', 'NEUTRAL', 'MIXED'];
const dynamoDBClient = new DynamoDBClient({});

export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
  const headers = {
    "Access-Control-Allow-Headers" : "Content-Type",
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "OPTIONS,POST,GET"
}

  try {
    // 1. Extract relevant data from the API Gateway event
    const { httpMethod, requestContext, queryStringParameters } = event;

    // 2. Determine the requested action based on the path or method
    if (httpMethod === 'GET' && requestContext.resourcePath === '/sentiment/{keyword}') {
        // 3. Validate keyword parameter
        const keyword = event.pathParameters?.keyword;
        if (!keyword) {
            return { statusCode: 400, body: JSON.stringify({ error: 'Missing keyword' }) };
        }

        // 4. Validate sentiment parameter
        const sentiment = (queryStringParameters?.sentiment || '').toUpperCase(); 
        if (sentiment && !VALID_SENTIMENTS.includes(sentiment)) {
          return { statusCode: 400, body: JSON.stringify({ error: `Invalid sentitment value: allowed values are ${VALID_SENTIMENTS}` }) };
        }

        // 5. Fetch data from DynamoDB based on the request
        const sentimentData = await getSentimentData(keyword, sentiment);

        // 6. Format the response
        return { statusCode: 200, headers, body: JSON.stringify(sentimentData ?? []) };
    }


    return { statusCode: 404, headers, body: JSON.stringify({ error: 'Not found' }) };
  } catch (error) {
    console.error('Error processing request:', error);
    return { statusCode: 500, headers, body: JSON.stringify({ error: 'Internal server error' }) };
  }
};

const getSentimentData = async (keyword: string, sentiment?: string) => {
    let statement = `SELECT * FROM "${TABLE_NAME}" WHERE Sentiment = '${sentiment}' AND contains(Text, '${keyword}')`

    if (!sentiment) {
        statement = `SELECT * FROM "${TABLE_NAME}" WHERE contains(Text, '${keyword}')`
    }

    // Execute the PartiQL statement
    const command = new ExecuteStatementCommand({
        Statement: statement,
    });

    const response = await dynamoDBClient.send(command);

    return response.Items;
};

Explanation:
- This function handles requests from external users and is triggered by an API Gateway request.
- It extracts the keyword and sentiment parameters from the request.
- It uses the DynamoDBClient to query the SentimentDataTable using a PartiQL SELECT statement. The query filters the data based on the provided keyword and sentiment (optional).
- It then returns the data in a JSON format.
- Note, since we are using the AWS_PROXY Method Integration type (refer to api-gateway.yaml), It is important to send the headers in the response object to prevent CORS errors.

5. Setting up API Gateway with CloudFormation

We'll use CloudFormation to define our API Gateway. Here's the api-gateway.yaml template:

Parameters:
  apiGatewayName:
    Type: String
    Default: SentimentAPI
  apiGatewayStageName:
    Type: String
    AllowedPattern: '[a-z0-9]+'
    Default: dev
  apiGatewayHTTPMethod:
    Type: String
    Default: GET

Resources:
  SentimentAPI:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: SentimentAPI
      EndpointConfiguration:
        Types:
          - REGIONAL

  SentimentAPIResource:
    Type: AWS::ApiGateway::Resource
    DependsOn:
      - SentimentAPI
    Properties:
      RestApiId: !Ref SentimentAPI
      ParentId: !GetAtt SentimentAPI.RootResourceId
      PathPart: 'sentiment'

  SentimentKeywordResource:
    Type: AWS::ApiGateway::Resource
    DependsOn:
      - SentimentAPI
    Properties:
      RestApiId: !Ref SentimentAPI
      ParentId: !Ref SentimentAPIResource
      PathPart: '{keyword}'

  SentimentAPIMethod:
    Type: AWS::ApiGateway::Method
    DependsOn:
      - SentimentAPI
      - SentimentAPIResource
    Properties:
      AuthorizationType: NONE
      ApiKeyRequired: false
      HttpMethod: !Ref apiGatewayHTTPMethod
      RequestParameters:
        method.request.path.keyword: true
      MethodResponses:
        - StatusCode: 200
          ResponseModels:
            "application/json": "Empty"
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri: !Sub 
          - arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${ApiHandlersFunctionArn}/invocations
          - ApiHandlersFunctionArn: !ImportValue ApiHandlersFunctionArn
      RestApiId: !Ref SentimentAPI
      ResourceId: !Ref SentimentKeywordResource

  SentimentAPIDeployment:
    Type: AWS::ApiGateway::Deployment
    DependsOn: SentimentAPIMethod
    Properties:
      RestApiId: !Ref SentimentAPI
      StageName: !Ref apiGatewayStageName

  SentimentAPIPermission:
    Type: AWS::Lambda::Permission
    DependsOn: SentimentAPI
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !ImportValue ApiHandlersFunctionName
      Principal: apigateway.amazonaws.com
      SourceArn: !Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${SentimentAPI.RestApiId}/*/*

Outputs:
  apiGatewayInvokeURL:
    Value: !Sub https://${SentimentAPI}.execute-api.${AWS::Region}.amazonaws.com/${apiGatewayStageName}

Explanation:
- This template defines the API Gateway and its resources.
- It creates a REST API named SentimentAPI.
- It defines a resource /sentiment/{keyword}, where {keyword} is a path parameter.
- It creates a GET method for this resource.
- The Integration property is crucial:
- Type: AWS_PROXY: This tells API Gateway to forward the entire request to the ApiHandlersFunction Lambda function.
- Uri: This specifies the ARN of the Lambda function to invoke. The !Sub syntax is used to substitute the actual function ARN, which is obtained from the output value of the api-handlers-function CloudFormation stack.
- AWS::Lambda::Permission: This resource grants API Gateway permission to invoke the Lambda function.

6. Tying it All Together with a Main Stack

To simplify deployment, we'll create a "main" CloudFormation stack (main-stack.yaml) that references the other stacks. This helps manage dependencies and ensures resources are created in the correct order.

Parameters:
  BucketName:
    Type: String
    Description: Unique name for the S3 bucket
    Default: {YOUR-UNIQUE-BUCKET-NAME}
  BucketURL:
    Type: String
    Description: S3 bucket URL
    Default: https://{YOUR-UNIQUE-BUCKET-NAME}.s3.amazonaws.com
  EnvVariablesAndCredentials:
    Type: String
    Description: Credentials
    Default: {YOUR-SECRETS-MANAGER-ARN}

Resources:
  KinesisDataStreamStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/kinesis-data-stream.yaml
        - BucketURL: !Ref BucketURL

  DataCollectionFunctionStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/data-collection-function.yaml
        - BucketURL: !Ref BucketURL
      Parameters:
        BucketName: !Ref BucketName
        EnvVariablesAndCredentials: !Ref EnvVariablesAndCredentials
    DependsOn:
      - KinesisDataStreamStack

  DynamoDBTableStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/dynamodb-table.yaml
        - BucketURL: !Ref BucketURL

  SentimentAnalysisFunctionStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/sentiment-analysis-function.yaml
        - BucketURL: !Ref BucketURL
      Parameters:
        BucketName: !Ref BucketName
    DependsOn:
      - DynamoDBTableStack
      - KinesisDataStreamStack

  ApiHandlersFunctionStack:
    Type: AWS::CloudFormation::Stack
    DependsOn:
      - DynamoDBTableStack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/api-handlers-function.yaml
        - BucketURL: !Ref BucketURL
      Parameters:
        BucketName: !Ref BucketName

  ApiGatewayStack:
    Type: AWS::CloudFormation::Stack
    DependsOn:
      - ApiHandlersFunctionStack
    Properties:
      TemplateURL: !Sub
        - ${BucketURL}/infrastructure/api-gateway.yaml
        - BucketURL: !Ref BucketURL

Explanation:
- This template defines the overall application stack.
- It uses AWS::CloudFormation::Stack resources to reference the other CloudFormation templates (for Kinesis, Data Collection, DynamoDB, Sentiment Analysis, API Handlers, and API Gateway).
- The DependsOn property is used to specify dependencies between the stacks, ensuring they are created in the correct order. For example, the SentimentAnalysisFunctionStack depends on the DynamoDBTableStack and KinesisDataStreamStack because the Sentiment Analysis function needs the DynamoDB table and Kinesis stream to be created first.
- Parameters like BucketName, BucketURL, and EnvVariablesAndCredentials are used to pass configuration values to the nested stacks.

7. Deploying to AWS

We’ll deploy our code to aws via aws-cli.

Since our lambda code is in typescript and has some external dependencies, we will build and compile our code to javascript. We will use esbuild for this, ensure to install it globally or in your project dependencies.

esbuild ./src/index.ts \--bundle \--minify \--sourcemap \--platform=node \--target=es2020 \--outfile=dist/index.js

After building the lambda functions, we’ll zip the bundled code.

cd dist && zip \-r {function-name}.zip index.js\*

Now, we’ll upload our zip files and cloud formation template to s3 Upload zipped files

  aws s3 cp ./dist/{function-name}.zip s3://{YOUR-UNIQUE-BUCKET-NAME}.}/{function-name}.zip

Upload Cloud formation templates

aws s3 cp backend/infrastructure/lib/ s3://{YOUR-UNIQUE-BUCKET-NAME}/infrastructure/ \--recursive

Finally, we will deploy our stack using aws cloud-formation

   aws cloudformation create-stack \  
      --stack-name social-sentiment-backend-stack \ 
      --template-url https://{YOUR-UNIQUE-BUCKET-NAME}.}.s3.amazonaws.com/infrastructure/main-stack.yaml \ 
      --capabilities CAPABILITY\_NAMED\_IAM CAPABILITY\_AUTO\_EXPAND

8. Connecting the Frontend

We will create a simple analytics dashboard. This dashboard will retrieve the sentiment data via the sentiment API (api-gateway) url. To connect the frontend to this API, we would use the URL provided in the CloudFormation stack's output (apiGatewayInvokeURL) or we can navigate to the api-gateway console and get the invoke URL. For example, if the URL is https://your-api-gateway-id.execute-api.us-east-1.amazonaws.com/dev, you would make a GET request to https://your-api-gateway-id.execute-api.us-east-1.amazonaws.com/dev/sentiment/keyword?sentiment=POSITIVE to get all positive sentiments for "keyword".

Note: this tutorial only supports the crypto keyword.

9. Clean up:

To avoid unnecessary and unforeseen costs, it is a good practice to clean up your aws resources. We simply just have to delete our stack by running this 👇🏿CLI command.

aws cloudformation delete-stack --stack-name social-sentiment-backend-stack

Then, navigate to your AWS console to delete your project bucket, and your secrets manager for the project.

And there you have it! We've built a serverless backend for a social media sentiment analytics dashboard using AWS Lambda, API Gateway, DynamoDB, Amazon Kinesis, Eventbridge, and CloudFormation. This is just the beginning. You can further enhance it by adding more features, visualizations, and social media integrations.

Share your thoughts and questions in the comments below.

Host a Static Website on Amazon Elastic Kubernetes Service (EKS)

Ogooluwa Akinola — Thu, 06 Feb 2025 11:08:15 +0000

In this article, we will explore how to deploy and run a static website (your resume in this case) on Amazon EKS.

Technologies & Tools

AWS Account (Free Tier)
AWS CLI
Docker Account - a version control for your code
Kubectl
Eksctl
Github Repo - a version control for your code

Pre-requsite

[Optional] Github Account & Repo

Skip this if you don't intend to save your project on github. However, you can follow these links to setup a Github Account & Repo.

Setup AWS account and IAM User

Create you AWS Free Tier account if you haven't. Then, follow these steps to create your IAM user.

Setup AWS CLI

Skip this if you already have AWS CLI setup on your machine.

Follow this AWS CLI installation guide.

Setup Docker

We need docker to create our images and run containers (locally) we also need a docker account to save our images. Sign up to Docker and follow the Docker setup guide to get docker installed on your machine.

Setup Kubernetes CLI

Kubernetes provides a command line tool for communicating with a Kubernetes cluster's control plane, using the Kubernetes API. This tool is named kubectl. Follow this installation guide to get started.

Setup EKS CLI

Eksctl is a simple CLI tool for creating and managing clusters on EKS - Amazon's managed Kubernetes service for EC2. Follow this installation guide to get started.

⚠️ PLEASE NOTE: Amazon EKS cost 10 cents per hour, although relatively cheap I wanted to let you know before we get started. We will ensure to clean up once we are done with this tutorial in order not to incur any hidden cost.

Now let's get started! 😀

Step 1

Create a folder for your project EKS-Static-Resume-Website

mkdir EKS-Static-Resume-Website

Step 2

Change directory to EKS-Static-Resume-Website and create necessary files and folders

cd EKS-Static-Resume-Website

touch index.html Dockerfile loadbalancerservice.yaml style.css

Step 3

Convert your resume to html (you can you GPT AI tools --- ChatGPT, Gemini, etc for that. Or copy my resume from my github repo) and then copy it into the index.html file, also copy the generated css into the style.css file.

Step 4

Copy this Dockerfile 👇🏿 into the Dockerfile. This is how we create the docker image for our resume website.

FROM httpd
COPY index.html /usr/local/apache2/htdocs/index.html
COPY style.css /usr/local/apache2/htdocs/style.css

Explanation

FROM httpd

We are building our image 👆🏿 from the Apache HTTP server image

COPY index.html /usr/local/apache2/htdocs/index.html
COPY style.css /usr/local/apache2/htdocs/style.css

We copy the index.html and style.css files into the /usr/local/apache2/htdocs folder respectively. The htdocs folder is our server root and where Apache will serve files from.

Step 5

We are going to build our docker image. In your project root, run

docker build --platform linux/amd64 -t {docker-account-username}/custom-httpd .

replace {docker-account-username} with your real docker account username, for me it's rovilay. The -t flag tags the built image with the name rovilay/custom-httpd. we specify the --platform linux/amd64 to build images compatible with our ec2 instances.

Your image is still on your local machine. To confirm, run

docker images

Step 5.1

you can run your docker image locally just to confirm everything is fine.

docker run -d -p 8080:80 {docker-account-username}/custom-httpd

To check if the container is running, run

docker ps

Navigate to localhost:8080 on your browser to see your resume

Now run 👇🏿 to stop the container

docker stop {container ID}

Step 5.2

We will push our image to docker hub. To do that run

docker push rovilay/custom-httpd:latest

you can visit your docker account on docker hub to view the image.

Step 6

Now we are going to setup our Kubernetes configuration a.k.a manifest file. Copy this loadbalancerservice.yaml 👇🏿 in to the loadbalancerservice.yaml. Don't feel overwhelmed I will explain the code. 😅

apiVersion: v1
kind: Service
metadata:
  name: lb-service
  labels:
    app: lb-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: frontend
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  minReadySeconds: 30
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend-container
        image: rovilay/custom-httpd

Explanation

apiVersion: v1
kind: Service
metadata:
  name: lb-service
  labels:
    app: lb-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: frontend

The first part 👆🏿 creates the loadbalancer service which is a kubernetes service that exposes the container (resume image) -- name frontend running within our pod (more on this later). I won't bore you with the extra kubernetes details.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  minReadySeconds: 30
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend-container
        image: rovilay/custom-httpd

The Deployment manages our pods and in extention our containers; basically each pod runs one container (note: a pod can run multiple containers but usually and in this case we run a container per pod). The deployment ensures that our cluster is running the right amount of pod replicas (replicas: 2).

    spec:
      containers:
      - name: frontend-container
        image: rovilay/custom-httpd

This part 👆🏿 is where we referenced our docker image rovilay/custom-httpd that our container is running.

Step 7

Create your kubernetes cluster on eks. To do this run,

eksctl create cluster --node-type t2.micro --nodes 4  --region us-east-1

I for one love the random names AWS comes up with 😅, however you can add the --name {your-cluster-name} flag if you want to name your cluster.

It takes a while for your cluster to be fully setup on EKS, so take some time, relax 🛀🏿 and sip a cup of coffee. ☕️

if your cluster runs successfully, you should see this 👇🏿 in your terminal.

Navigate to your EKS dashboard on AWS to see your cluster.

To view the EC2 instances provisioned in the cluster, run

kubectl get nodes

Step 8

Deploy your container to the kubernetes cluster

kubectl apply -f loadbalancerservice.yaml

To confirm deployment, run

kubectl get all

Step 9

Navigate to the load balancer url to view your host resume. Run,

kubectl get services

the url is in the External-IP column.

Step 10

Clean up your cluster to avoid any unforseen cost. Run

kubectl delete deployment frontend-deployment

kubectl delete service lb-service

Now delete the cluster on EKS, get the cluster name by running,

eksctl get cluster

and run,

eksctl delete cluster {cluster-name}

That's it guys!!! 🥳🎉🍾

We have successfully hosted a simple static web page on EKS.

Follow for more content like this.

A Quick Guide to Databases on AWS: Choosing the Right Tool for the Job🧰

Ogooluwa Akinola — Tue, 28 Jan 2025 04:16:32 +0000

Hey cloud explorers! Welcome back to another episode of Cloud in List of Threes (CiLoTs) ☁️3️⃣, where we break down complex cloud concepts into bite-sized pieces, seasoned with fun analogies! 🤩 Today, we're taking a trip into the world of databases. ☁️🗄️ We'll explore three popular AWS database solutions: Relational, NoSQL, and Purpose-built!

1. Relational Databases

Imagine a well-organized library with books arranged neatly on shelves. Each book represents a data record, and the shelves represent tables. You can easily find the book you need using the library's catalogue system (SQL queries). But there is more, this library is always open, fully managed, can scale as needed and can be customized to suit specific needs i.e. a library based on archaeology, and another based on science only.

Technical translation 👨🏿‍💻: Amazon RDS is a fully managed relational database service, that stores data in structured tables with rows and columns. They use SQL (Structured Query Language) to manage and query data, ensuring data integrity and consistency. It makes it easy to set up, operate, and scale popular databases. RDS offers six database engines of varying choices — Aurora, MySQL, PostgreSQL, Oracle, Microsoft SQL Server, and Maria DB. Aurora is a fully AWS-managed relational database engine that's built for the cloud and compatible with MySQL and PostgreSQL.

Three Key Benefits

- Easy to Manage:
Amazon RDS is a managed service which means you don’t have to worry about the administrative task overhead such as infrastructure maintenance, backups etc.

- Wide Compatibility and Choice:
Amazon RDS offers support for a wide range of relational database engines such as MySQL, PostgreSQL, Oracle, SQL server and Maria DB, hence, you’re not stuck with one choice.

- High Availability:
Amazon RDS offers deployment to multi-AZ regions which increases the availability of your database infrastructure. You don’t have to worry about downtime and your data is always available to use.

2. NoSQL Databases

Imagine a toolbox, but not just any toolbox. This one is special because it has compartments of all shapes and sizes. Some are perfect for holding long screwdrivers, others are ideal for small screws and nails, and some can even hold oddly shaped tools that don't fit anywhere else. And just like you can quickly grab the right tool from your toolbox when you need it, NoSQL databases allow you to easily access the specific data you're looking for.

Technical translation 👨🏿‍💻: NoSQL databases store data in flexible schemas that scale easily. AWS offers a variety of NoSQL database solutions e.g. Amazon DynamoDB and DocumentDB. Amazon DynamoDB is a fully managed key-value database that is designed to be highly partitionable and scalable horizontally. It provides very high performance in terms of latency and scalability. Amazon DocumentDB (with MongoDB compatibility) is a fully managed JSON document database that stores data as JSON objects that are flexible, semi-structured, and hierarchical in nature.

Three Key Benefits

- Scalability:
Imagine your toolbox growing as you get more tools. NoSQL databases excel at handling massive amounts of data and user traffic. This makes them ideal for applications that experience rapid growth or unpredictable spikes in usage. They can easily scale horizontally by distributing data across multiple servers, ensuring your application remains responsive even under heavy load.

- Flexibility:
Just like the toolbox with different compartments, NoSQL databases can handle various data structures. This is crucial because modern applications often deal with data that doesn't fit neatly into rows and columns e.g. social media posts, sensor data from IoT devices, or even complete documents.

- High Availability:
If one of the compartments in your toolbox breaks, you can still access the tools in the other compartments. Similarly, NoSQL databases are designed for continuous operation and fault tolerance. They often replicate data across multiple availability zones or regions, so even if one server fails, your data remains accessible. This ensures your application stays up and running, providing a seamless experience for your users.

3. Purpose-built Databases

Imagine specialized tools for specific tasks, like a high-powered drill for construction 👷🏿 or a precision screwdriver for electronics repair.🪛 These specialized tools offer more efficiency and precision.

Technical translation 👨🏿‍💻: AWS offers database service built and optimized for specific use cases. Amazon Neptune (Graph Database) is a managed database good for graph data e.g. social network data, recommendation engines, etc. Amazon Timestream (Time Series Databases) are ideal for tracking changes over time, such as stock prices, sensor readings from IoT devices, or website traffic patterns. Amazon QLDB (Ledger Databases) are perfect for situations where an accurate, auditable history is crucial, such as financial transactions, supply chain management, or voting systems.

Three Key Benefits

- Performance:
Just like the high-powered drill is specifically designed for drilling tasks, purpose-built databases are optimized for their specific data models and workloads. This means they can handle those tasks with exceptional speed and efficiency, outperforming general-purpose databases in those specific scenarios.

- Cost-Efficiency:
Purpose-built databases are designed to minimize unnecessary overhead and resource consumption. By focusing on specific workloads, they can offer cost savings compared to general-purpose databases that may require more resources to achieve the same level of performance for those particular tasks.

- Ease of Use:
Think of how a tool designed for a specific task is often easier to use than a general-purpose tool. Purpose-built databases simplify development and management for their targeted data types. They often come with specialized features, tools, and APIs that make it easier to work with those specific data models. This reduces the complexity of development and streamlines database administration.

And there you have it, folks! We've now learned how to store our data in the cloud (AWS). Whether you need to store structured, unstructured, or special-purpose data, AWS has the perfect database solution for you. Stay tuned for more cloud adventures in the next episode of Cloud in List of Threes! ☁️3️⃣

Checkout the last episode here.

Store weather data in Amazon S3

Ogooluwa Akinola — Thu, 23 Jan 2025 02:24:52 +0000

In this article, we will look at how to store JSON data in an Amazon S3 bucket.

Technologies & Tools

Python - Run time environment
AWS Account (Free Tier)
Boto3 - AWS SDK for python
python-dotenv - to load environment variables from .env files.
requests - a simple HTTPS library
Openweather API - external api that provides real time weather data
Github Repo (Optional) - a version control for your code

Pre-requisite

Setup Python

if you haven't, please setup Python on you local machine.

[Optional] Github Account & Repo

Skip this if you don't intend to save your project on github. However, you can follow these links to setup a Github Account & Repo.

Setup AWS account and IAM User

Create you AWS Free Tier account if you haven't. Then, follow these steps to create your IAM user. Ensure the IAM user is assigned the AmazonS3FullAccess policy.

Setup AWS CLI

We are going to be using the Boto3 AWS SDK to interact with AWS. Underneath, the AWS uses a AWS API KEY and secret key to authenticate with AWS. Hence we need to configure AWS credentials on our local machine. Please follow the Boto3 documentation for configuration guide. Ensure the IAM user credentials you're using is configured with the AmazonS3FullAccess policy mentioned above.

OpenWeather API

Openweather is the external api that we will use in this project to provide real time weather data. Please sign up to OpenWeather service to get your OpenWeather API key.

Now let's get started! 😀

P.S the CLI commands examples will be for MacOs/linux users. For windows users you can research the commands online.

Step 1

Create a folder called weather-dashboard-demo

mkdir weather-dashboard-demo

Step 2

Change directory to weather-dashboard-demo and create necessary files and folders

cd weather-dashboard-demo

mkdir src

touch .env requirements.txt

Step 3

Initialize git (optional)

git init

Step 4

Add the package dependencies in re requirements.txt

echo "boto3==1.26" >> requirements.txt

echo "python-dotenv==1.0.0" >> requirements.txt

echo "requests==2.28" >> requirements.txt

Step 5

Install your dependencies

pip3 install -r requirements.txt

Step 6

Add env variables to your .env file.

Get your API key from the open weather account you created above.

echo "OPENWEATHER_API_KEY=<replace-with-your-api-key>" >> .env

Add your s3 bucket name. Note your bucket name must be globally unique.

echo "AWS_BUCKET_NAME=weather-dashboard-<append-unique-value>" >> .env

Step 7

Create the necessary files in the src folder

touch src/__init__.py src/weather_dashboard.py

Step 8

Copy the full code into the weather_dashboard.py. Don't feel overwhelmed I will explain the code.

import os
import json
import boto3
import requests
from datetime import datetime
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

class WeatherDashboard:
    def __init__(self):
        self.api_key = os.getenv('OPENWEATHER_API_KEY')
        self.bucket_name = os.getenv('AWS_BUCKET_NAME')
        self.s3_client = boto3.client('s3')

    def create_bucket_if_not_exists(self):
        """Create S3 bucket if it doesn't exist"""
        try:
            self.s3_client.head_bucket(Bucket=self.bucket_name)
            print(f"Bucket {self.bucket_name} exists")
        except:
            print(f"Creating bucket {self.bucket_name}")
        try:
            # Simpler creation for us-east-1
            self.s3_client.create_bucket(Bucket=self.bucket_name)
            print(f"Successfully created bucket {self.bucket_name}")
        except Exception as e:
            print(f"Error creating bucket: {e}")

    def fetch_weather(self, city):
        """Fetch weather data from OpenWeather API"""
        base_url = "http://api.openweathermap.org/data/2.5/weather"
        params = {
            "q": city,
            "appid": self.api_key,
            "units": "imperial"
        }

        try:
            response = requests.get(base_url, params=params)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error fetching weather data: {e}")
            return None

    def save_to_s3(self, weather_data, city):
        """Save weather data to S3 bucket"""
        if not weather_data:
            return False

        timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
        file_name = f"weather-data/{city}-{timestamp}.json"

        try:
            weather_data['timestamp'] = timestamp
            self.s3_client.put_object(
                Bucket=self.bucket_name,
                Key=file_name,
                Body=json.dumps(weather_data),
                ContentType='application/json'
            )
            print(f"Successfully saved data for {city} to S3")
            return True
        except Exception as e:
            print(f"Error saving to S3: {e}")
            return False

def main():
    dashboard = WeatherDashboard()

    # Create bucket if needed
    dashboard.create_bucket_if_not_exists()

    cities = ["Philadelphia", "Seattle", "New York"]

    for city in cities:
        print(f"\nFetching weather for {city}...")
        weather_data = dashboard.fetch_weather(city)
        if weather_data:
            temp = weather_data['main']['temp']
            feels_like = weather_data['main']['feels_like']
            humidity = weather_data['main']['humidity']
            description = weather_data['weather'][0]['description']

            print(f"Temperature: {temp}°F")
            print(f"Feels like: {feels_like}°F")
            print(f"Humidity: {humidity}%")
            print(f"Conditions: {description}")

            # Save to S3
            success = dashboard.save_to_s3(weather_data, city)
            if success:
                print(f"Weather data for {city} saved to S3!")
        else:
            print(f"Failed to fetch weather data for {city}")

if __name__ == "__main__":
    main()

This part of the code imports the packages used and loads the environment variables from the .env file.

os package allows interaction with the operating system (e.g file paths)
json package allows easy parsing of json objects
boto3 package allows easy interaction with AWS resources
requests package allows making https requests
datetime package for working with date and time
dotenv package for loading the environment variables from the .env file.

import os
import json
import boto3
import requests
from datetime import datetime
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

This part of the code initializes the api_key, bucket_name, and s3_client properties of the WeatherDashboard class.

class WeatherDashboard:
    def __init__(self):
        self.api_key = os.getenv('OPENWEATHER_API_KEY')
        self.bucket_name = os.getenv('AWS_BUCKET_NAME')
        self.s3_client = boto3.client('s3')

This method checks if the bucket exists and if not it proceeds to creating the s3 bucket.

    def create_bucket_if_not_exists(self):
        """Create S3 bucket if it doesn't exist"""
        try:
            self.s3_client.head_bucket(Bucket=self.bucket_name)
            print(f"Bucket {self.bucket_name} exists")
        except:
            print(f"Creating bucket {self.bucket_name}")
        try:
            # Simpler creation for us-east-1
            self.s3_client.create_bucket(Bucket=self.bucket_name)
            print(f"Successfully created bucket {self.bucket_name}")
        except Exception as e:
            print(f"Error creating bucket: {e}")

This method fetches the weather data by for the specified city and returns the response data in json format or None (in case of error).

    def fetch_weather(self, city):
        """Fetch weather data from OpenWeather API"""
        base_url = "http://api.openweathermap.org/data/2.5/weather"
        params = {
            "q": city,
            "appid": self.api_key,
            "units": "imperial"
        }

        try:
            response = requests.get(base_url, params=params)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error fetching weather data: {e}")
            return None

This method saves the weather data to s3. It creates a unique json file ({city}-{timestamp}.json) and saves it in the weather-data folder on S3.

    def save_to_s3(self, weather_data, city):
        """Save weather data to S3 bucket"""
        if not weather_data:
            return False

        timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
        file_name = f"weather-data/{city}-{timestamp}.json"

        try:
            weather_data['timestamp'] = timestamp
            self.s3_client.put_object(
                Bucket=self.bucket_name,
                Key=file_name,
                Body=json.dumps(weather_data),
                ContentType='application/json'
            )
            print(f"Successfully saved data for {city} to S3")
            return True
        except Exception as e:
            print(f"Error saving to S3: {e}")
            return False

The main function is where we do all the magic. We initialize the dashboard instance using the WeatherDashboard class. We then create the S3 bucket if it doesn't exist. After which we iterate through our cities, fetch the weather data for each city, then extract the temparature, feel_like, humidity, and description data and print it to the console. Finally we save the weather data into s3.

def main():
    dashboard = WeatherDashboard()

    # Create bucket if needed
    dashboard.create_bucket_if_not_exists()

    cities = ["Philadelphia", "Seattle", "New York"]

    for city in cities:
        print(f"\nFetching weather for {city}...")
        weather_data = dashboard.fetch_weather(city)
        if weather_data:
            temp = weather_data['main']['temp']
            feels_like = weather_data['main']['feels_like']
            humidity = weather_data['main']['humidity']
            description = weather_data['weather'][0]['description']

            print(f"Temperature: {temp}°F")
            print(f"Feels like: {feels_like}°F")
            print(f"Humidity: {humidity}%")
            print(f"Conditions: {description}")

            # Save to S3
            success = dashboard.save_to_s3(weather_data, city)
            if success:
                print(f"Weather data for {city} saved to S3!")
        else:
            print(f"Failed to fetch weather data for {city}")

Finally, This code ensures the main function runs when the file is directly executed.

if __name__ == "__main__":
    main()

Step 9

Run the code.

python3 src/weather_dashboard.py

If everything goes right, you should see this on your terminal.

Navigate to your S3 console and check out the bucket.

Click on the weather-data bucket to see the weather data

To view the JSON data, click on any of the city data and then click open

The JSON data looks like this

Voila! we are done.

Step 10

It's good practice to clean up after you're done. So you can navigate to your S3 console, empty the bucket then proceed to delete.

Conclusion

In this project, we created an S3 bucket using the boto3 AWS SDK, we then loaded weather data into the S3 bucket. Follow me for more cloud-based projects.

Storing Your Stuff in the Cloud: A Simple Guide to S3, EBS, and EFS

Ogooluwa Akinola — Tue, 21 Jan 2025 11:38:18 +0000

Hey cloud explorers! Welcome back to another episode of Cloud in List of Threes (CiLoTs) ☁️3️⃣, where we break down complex cloud concepts into bite-sized pieces, seasoned with fun analogies! 🤩 Today, we're taking a trip into the world of cloud storage. ☁️🗄️ We'll explore three popular AWS storage solutions: S3, EBS, and EFS!

Amazon S3 (Simple Storage Service) ☁️🗄️

Imagine a massive, secure storage warehouse. 🏢 You can rent a unit (bucket) to store anything you want: photos, videos, documents, even old furniture! 📦 You can access your stuff from anywhere in the world, and you only pay for the space you use. 🌍💰

Technical translation 👨🏿‍💻: Amazon S3 is an object storage, meaning it stores data as individual objects in buckets. It's highly scalable, durable, and cost-effective. Each object has its own unique ID and metadata and is organized into containers called buckets. Buckets help manage and group objects, providing kind of like a hierarchical structure for your data. Basically, S3 allows you to store any type of data (text, blob, video, audio, etc) in a highly scalable, durable, and cost-effective manner.

Three Key Benefits:
Durability: Your data is safe and secure, with multiple copies stored across different locations. 💪
Scalability: Store as much or as little as you need, and easily adjust your storage capacity. 📈
Accessibility: Access your data from anywhere with an internet connection. 🌐

Amazon EBS (Elastic Block Storage) 💾💻

Think of EBS as an extra external hard drive you can attach to your computer (EC2 instance). It's like having more space to store your operating system, applications, and files. 💽 You can even choose different types of hard drives depending on your needs (speed, performance).

Technical translation 👨🏿‍💻: Amazon EBS offers block-level storage volumes, which function similarly to individual hard drives. These volumes can be attached to Amazon EC2 instances, providing the operating system and applications with persistent storage. EBS offers various volume types (SSD-based and HDD-based), each optimized for specific performance needs such as throughput and IOPS (input/output operations per second). This allows you to customize your storage based on the requirements of your applications.

Three Key Benefits:
Persistence: Your data remains on the volume even if you unplug the hard drive or restart your computer/EC2. 🔄
Flexibility: Choose from different volume types — SSD-based and HDD-based to optimize performance and cost. ⚙️
Integration: Seamlessly integrates with EC2 for easy management. 🤝

Amazon EFS (Elastic File System) 📁🔗

Imagine a toy box that you and your friends can all share. 🪀🗃️You can put your toys in it, and your friends can take them out to play with them. You can all play with the same toys at the same time without fighting over them! That's kind of like what Amazon EFS does for computers in the cloud.

Technical translation 👨🏿‍💻: EFS offers a network file system that can be accessed concurrently by multiple Amazon EC2 instances. This shared access facilitates collaboration and data sharing among different parts of your application.

Three Key Benefits:
Scalability: Automatically grows and shrinks as your storage needs change. 📈
Shared Access: Multiple services and instances can access the file system simultaneously. 🧑‍🤝‍🧑
Elasticity: Pay only for the storage you use, and scale your capacity as needed. 💰

And there you have it, folks! We've now learned how to store your stuff in the cloud (AWS). Whether you need a massive warehouse, an extra hard drive, or a shared file system, AWS has the perfect storage solution for you. Stay tuned for more cloud adventures in the next episode of Cloud in List of Threes! ☁️3️⃣

Check out the previous episode here.

#CloudComputing #AWS #S3 #EBS #EFS #CiLoTs #CiLoTsEp04

Cloud computing can be confusing, but it doesn't have to be! ☁️🤔 In the latest episode of Cloud in List of Threes (CiLoTs), I’m serving up easy-to-digest (pun intended 🤭) explanations analogy to explain Regions, Availability Zones, and Edge Locations

Ogooluwa Akinola — Tue, 14 Jan 2025 10:38:23 +0000

From Regions to Edge Locations: A CiLoTs Guide to Cloud Infrastructure

Ogooluwa Akinola ・ Jan 14

#aws #cloudcomputing #cilots #cloud

From Regions to Edge Locations: A CiLoTs Guide to Cloud Infrastructure

Ogooluwa Akinola — Tue, 14 Jan 2025 10:21:48 +0000

Hey cloud explorers! Welcome back to another episode of Cloud in List of Threes (CiLoTs) ☁️3️⃣, where we break down complex cloud concepts into bite-sized pieces, seasoned with fun analogies! 🤩 Today, we're taking a trip to the global restaurant of AWS, learning about Regions, Availability Zones, and Edge Locations. Get ready to order up some knowledge!

Region

Imagine AWS as a global chain of restaurants.🌍🏘️ Each region is like a different country/state where they have at least a restaurant. You would probably choose to eat at the restaurant closest to you for the best experience. Similarly, you'd typically choose an AWS region closest to you or your users for optimal performance and legal compliance.

Technical translation 👨🏿‍💻: AWS Regions are separate geographic areas where Amazon's cloud infrastructure (data centre) is located. Each region is isolated and independent, consisting of multiple Availability Zones. This isolation helps achieve high fault tolerance and stability. Choosing the right region is important for factors like latency, cost, and regulatory requirements. You can view Amazon’s Global Regions here.

Three Key Benefits:
- Data Sovereignty:
Keep your data in specific regions to comply with local regulations. (Like a restaurant sourcing ingredients locally 🧂🌶️)

- Disaster Recovery:
If one region goes down, your data is safe in another. (If one restaurant location is closed, you can go to another in a different country.)

- Low Latency:
Keep your data close to your users for faster access. (Customers get served faster at their local restaurant. 🚀)

Availability Zones (AZs)

Now imagine this global chain of restaurants, let’s call it Pizzalicious, and you’ve guessed it, they sell delicious pizzas. 🍕And as a pizza lover you purchase pizzas from a branch near you. However, sometimes, that branch is closed for cleaning or fixing something. 🧹🛠️ That means you can't have pizza that day! 😥
But what if that pizza place had another restaurant, just like it, in a different part of the city? 🌆 Then, if one restaurant was closed, you could still go to the other one and get your pizza! 🥳That's kind of like what Availability Zones are. They're like extra copies of things in the cloud, so if one "place" breaks, there's another one ready to go. ☁️🚀
So, you can always get your pizza, or whatever you need from the cloud, no matter what! 😊

Technical translation 👨🏿‍💻: Availability Zones are physically separated data centres within a Region, each with its own power, networking, and connectivity. AZs are connected by a low latency, high throughput, and highly redundant network and are physically separated by a meaningful distance, many kilometres, from any other AZs, although all are within 100 km (60 miles) of each other to achieve high consistency.

Three Key Benefits:
- Fault Tolerance:
If one AZ fails, your applications can still run in another. (If one Pizzalicious branch has a power outage, you can go to another in a different branch within the same city.)

- High Availability:
Ensures your applications are always accessible, even during disruptions. (There's always a Pizzalicious open somewhere, so you will always get your delicious pizza 🍕.)

- Scalability:
Easily add more resources as your needs grow. (Pizzalicious can open more branches to serve more customers.)

Edge Location

Imagine you're craving a Pizzalicious pizza, but it's all the way across town! 🍕🚗 It would take a long time to drive there, and you're super hungry! 😫
But guess what? They have a special pizza truck that comes to your neighbourhood! 🍕🚚 Now you can get your pizza much faster, without having to go all the way to the restaurant. 😄That’s basically what Edge Location is. It’s like a mini version of the cloud that's closer to you, so you can get things from the internet faster. 💻💨

Technical Translation👨🏿‍💻: An Edge Location is a smaller data centre strategically positioned around the globe within the AWS network, designed to deliver content with minimal latency to users by caching copies of data closer to their physical location, primarily used by services like Amazon CloudFront (CDN) to ensure faster access to web content for users across different regions; essentially acting as a local storage point to serve content quickly instead of fetching it from a distant origin server every time a request is made.

Three Key Benefits:
- Reduced Latency:
Faster content delivery for users far from Regions. (Pizzalicious customers get their pizza faster from a nearby food truck.)

- Bandwidth Savings:
Less data needs to travel long distances. (The pizza doesn't have to be transported from the main Pizzalicious branch.)

- Improved Performance:
Enhanced user experience with faster loading times. (Pizzalicious customers enjoy a quicker and more convenient service.)

So there you have it, folks! The next time you're grabbing a bite, remember those Regions, AZs, and Edge Locations working hard behind the scenes of your favourite cloud services. It's like a well-coordinated kitchen, ensuring your data is always hot and ready to serve! Stay tuned for more tasty cloud insights on Cloud in List of Threes! ☁️3️⃣

Check out the previous episode here.

#CloudComputing #AWS #AWSRegion #AvailabilityZone #EdgeLocation #CiLoTs #CiLoTsEp03

Forem: Ogooluwa Akinola

Hey folks! Checkout my latest tutorial on building a serverless sentiment analytics dashboard

Building a Serverless Social Media Sentiment Analytics Dashboard on AWS

Ogooluwa Akinola ・ Mar 25

Building a Serverless Social Media Sentiment Analytics Dashboard on AWS

Why Serverless?

Let’s get our Hands Dirty

Pre-requisite

1. Creating your secrets manager

2. Creating an S3 bucket for Code storage

3. Defining the DynamoDB Table with CloudFormation

Explanation:

4. Building the Lambda Functions

4.1 Data Collection Function

4.2 Sentiment Analysis Function

4.3 API Handlers Function

5. Setting up API Gateway with CloudFormation

Explanation:

6. Tying it All Together with a Main Stack

Explanation:

7. Deploying to AWS

8. Connecting the Frontend

9. Clean up:

Host a Static Website on Amazon Elastic Kubernetes Service (EKS)

Technologies & Tools

Pre-requsite

[Optional] Github Account & Repo

Setup AWS account and IAM User

Setup AWS CLI

Setup Docker

Setup Kubernetes CLI

Setup EKS CLI

Step 1

Step 2

Step 3

Step 4

Step 5

Step 5.1

Step 5.2

Step 6

Step 7

Step 8

Step 9

Step 10

A Quick Guide to Databases on AWS: Choosing the Right Tool for the Job🧰

1. Relational Databases

2. NoSQL Databases

3. Purpose-built Databases

Store weather data in Amazon S3

Technologies & Tools

Pre-requisite

Setup Python

[Optional] Github Account & Repo

Setup AWS account and IAM User

Setup AWS CLI

OpenWeather API

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8

Step 9

Step 10

Storing Your Stuff in the Cloud: A Simple Guide to S3, EBS, and EFS

Amazon S3 (Simple Storage Service) ☁️🗄️

Amazon EBS (Elastic Block Storage) 💾💻

Amazon EFS (Elastic File System) 📁🔗

Cloud computing can be confusing, but it doesn't have to be! ☁️🤔 In the latest episode of Cloud in List of Threes (CiLoTs), I’m serving up easy-to-digest (pun intended 🤭) explanations analogy to explain Regions, Availability Zones, and Edge Locations

From Regions to Edge Locations: A CiLoTs Guide to Cloud Infrastructure

Ogooluwa Akinola ・ Jan 14

From Regions to Edge Locations: A CiLoTs Guide to Cloud Infrastructure

Region

Availability Zones (AZs)

Edge Location