AWS: Storage and Databases

☁️ Architecture

Mar 27, 2025

11 min read

Creating an Amazon S3 Bucket

Creating an S3 Bucket

Navigate to S3 from the AWS Management Console
Click Create bucket
Enter a unique name for your bucket and pick your nearest region
Leave the bucket settings to default
Click on Create bucket

Implementing Bucket Policies to Manage and Restrict Access

Click on the bucket you created earlier
Select the Permissions tab
Uncheck all the options
Click on Save changes
On the edit bucket policy page, specify a JSON policy to control your Amazon S3 bucket access (to grant public access to your Amazon S3 bucket)
Replace the resource key with the ARN of the bucket you created

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": ["s3:GetObject"],
      "Effect": "Allow",
      "Resource": "BUCKET_ARN/*",
      "Principal": "*"
    }
  ]
}

Click on Save changes

Uploading and Downloading Objects in a S3 Bucket

In your S3 bucket, click Upload
Click on Add files and upload an image/document
The item can also be downloaded

Setting Up a Static Website on Amazon S3

Serve a Static Website on Amazon S3

Navigate to S3 and click Create bucket
Name: <bucket-name> (must be globally unique and follow naming rules - consider adding a timestamp for uniqueness)
Region: choose the region where you want to store your bucket
Uncheck the box that says, Block all public access
Once you’ve created your bucket, click on Upload
Save the following HTML file as index.html and upload it

<!DOCTYPE html>
<title>Static Website on Amazon S3</title>
<style>
  body {
    text-align: center;
    padding: 150px;
  }
  h1 {
    font-size: 50px;
  }
  body {
    font: 20px Helvetica, sans-serif;
    color: #333;
  }
  article {
    display: block;
    text-align: left;
    width: 650px;
    margin: 0 auto;
  }
  a {
    color: #dc8100;
    text-decoration: none;
  }
  a:hover {
    color: #333;
    text-decoration: none;
  }
  .sample {
    padding: 10px 20px 10px;
    border-top: groove;
    border-bottom: groove;
  }
</style>

<article>
  <div class="sample">
    <h1>Welcome to my website!</h1>
  </div>
</article>

Once this is uploaded, go to the Properties tab
Ensure Static website hosting is enabled and the index document is set to index.html
Click Save changes
Your bucket URL should have the following format: https://bucketName.s3-website.region.amazonaws.com

Setting the Permissions Required in Hosting a Public Static Website

Go back to your S3 bucket and navigate to the Permissions tab
Click in the Edit button (top right)
Add the following bucket policy in JSON format

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::[bucket-name]/index.html"
    }
  ]
}

Click on Save changes and navigate to the URL of your website to see the changes made

Retrieving Data using Amazon S3 Select

S3 Select allows you to retrieve data from objects without downloading and processing the whole file
It’s an ideal tool for extracting insights from big datasets; it retrieves, filters and processes data from your objects
Easily integrated with AWS Glue and Amazon Athena

Creating an S3 Bucket

Create a bucket with a unique name

Uploading a File to a S3 Bucket

Create a json file with data and upload it into the bucket

Retrieving Data using Amazon S3 Select

On the left hand side, click on Buckets
Choose the bucket with the object you to select content from and the name of the object json file you uploaded
On the Actions dropdown menu, click Query with S3 Select
Select JSON as the Input and Output format
To extract records from chosen object, under SQL query, run the following: SELECT * FROM s3object s LIMIT 5

Using Aggregate Functions in Amazon S3 Select Query

Count: SELECT COUNT(s.gender) AS "Your Alias" FROM s3object s
Max: SELECT MAX(s.your_attribute) AS "Your Alias" FROM s3object s WHERE condition
Min: SELECT MIN(s.your_attribute) AS "Your Alias" FROM s3object s WHERE condition
Avg: SELECT AVG (s.your_attribute) AS "Your Alias" FROM s3object s
Cast (calculate the average and convert it to an integer data type): SELECT CAST(AVG(s.your_attribute) AS INT) AS "Your Alias" FROM s3object s WHERE condition

Protecting Data on Amazon S3 Against Accidental Delete and Overwrite using S3 Versioning

Creating an Amazon S3 Bucket

Add a bucket with a unique name and description
In Bucket Versioning, ensure Bucket Versioning is enabled
Click Create a bucket

Restoring a File From an Accidental Overwrite

Create a text file that contains the words, “List of Dishes” and save it
Upload the text file to the object
Edit the file locally and re-upload it to the bucket
To view all versions of the objects stored in the bucket, select the Versions option
- The console will display a list of unique version IDs for each object version, along with the data and time it was created (as well as other relevant properties)
In case you accidentally make changes to the file, restore the previous version of the file by the following steps
- Go to the Versions page of the first text file and select the check box next to the Version ID for the versions you want to retrieve
- Chose Actions and the Download and save the object

Restoring a File from an Accidental Deletion

Open the bucket of the deleted object and toggle Show Versions to on
Select the pervious version of the object (do not select the type with the delete marker)
Click on the Download button

Setting Up and Managing a Database on an Amazon EC2 Instance

Launch an Instance

Name: <instance-name>
AMI: Ubuntu Server 24.04 LTS
Instance type: t2.micro
Key pair (create a new one)
- Name: <key-pair-name>
- Type: RSA
- Format: .pem
Network settings (click edit)
- Leave VPC and Subnet with default settings
- Auto assign public IP: enabled
- Firewall (security groups)
  - Name: <security-group-name>
  - Description: <security-group-description>
  - Allow SSH traffic from: My IP
Click Launch instance

Install MySQL Database Software

Connect to instance via SSH: ssh -i <your-key.pem> <ec2-user@your-ec2-public-dns>
Update and upgrade packages: sudo apt update and sudo apt upgrade -y
Install MySQL Server: sudo apt install mysql-server -y
Run the security script to improve security of MySQL: sudo mysql_secure_installation
- Review and follow the prompts to set the root password
Access MySQL: sudo mysql -u root -p

Create a Database and User

Create a database: CREATE DATABASE <database-name>;
Check databases created: SHOW DATABASES;
Create a new user
- CREATE USER '<user-name>'@'localhost' IDENTIFIED BY '<password>';
- Check the list of users: SELECT User, Host FROM mysql.user;
- Grant privileges to the new user of the database: GRANT ALL PRIVILEGES ON <user-name>.* TO '<user-name>'@'localhost';
- Apply changes: FLUSH PRIVILEGES;
- Exit MySQL prompt: exit

Creating an Amazon RDS Database

Creating Security Groups to Manage Access to the RDS DB Instance

Navigate to EC2 and select Security Groups under Network & Security
Configurations
- Name: <db-name>
- Description: <db-description>
- VPC: Chose a default VPC
- Add an inbound rule
  - Type: MySQL/Aurora
  - Ip addresses: My IP
Click Create security group

Create a MySQL Database using Amazon RDS

Search for RDS within the AWS Management Console
Click on Create database
Chose Database creation method and ensure Standard Create is selected
Select MySQL as the database engine
In templates chose the Free tier and this will automatically select the db.t2.micro or db.t3.micro instance type
Configure database instance
- Instance Identifier: <db-instance-unique-name>
- Master username and password: to be set by yourself
Set the allocated storage to 20GiB only
Under Connectivity, enable the Public Access option and select the previously created security group
Click on Create database

Connect to the RDS DB Instance using MySQL Workbench

Download MySQL Workbench
Once downloaded and, up and running, click on the plus icon next to MySQL Connections to create a new connect
Configurations
- Connection Name: <unique-connection-name>
- Hostname: use the endpoint provided in the RDS console
- Port: use the port provided in the RDS console
- Username & password: the credentials you set earlier
Click OK and then Test Connection
Double click on your connection to establish a connect to the RDS DB instance

Run SQL Commands

Create a database: Create DATABASE EmployeesDB;
Chose the database that has been created: USE EmployeesDB;
Create a table

CREATE TABLE Employees (
  ID INT PRIMARY KEY,
  Name VARCHAR(50),
  Age INT,
  Salary DECIMAL(10, 2)
  );

Run the command by clicking the Lightning icon
Write to the table

INSERT INTO Employees (ID, Name, Age, Salary)
VALUES (1, 'Jose Rizal', 25, 50000.

INSERT INTO Employees (ID, Name, Age, Salary)
VALUES (2, 'Andres Bonifacio', 25, 50000.00);

INSERT INTO Employees (ID, Name, Age, Salary)
VALUES (3, 'Emilio Aguinaldo', 25, 50000.00);

Run the command again by clicking the Lightning icon
Reading from the table: SELECT * FROM Employees;
Run the new command

Creating and Restoring RDS Backups using Snapshots

Creating a DB Snapshot

Navigate to RDS and click on Databases (on the left hand side)
From the list of available DB instances, select the one you want to create a snapshot of
Locate the Actions menu (at the top) and chose Take snapshot
A Take DB Snapshot window should appear
- Ensure you input a name for your snapshot and click Take snapshot

Restoring a DB Instance from a DB Snapshot

On the left hand, click on Snapshots and select the specific DB snapshot you want to restore
Click on Actions and chose Restore snapshot, you will then be taken to the Restore snapshot page
With the Instance will selected, chose Actions and then Instance Settings and then Change Instance Type
In the DB Instance Settings section, leave the DB engine and license model as default
In Availability and durability, create a standby instance in a different AZ zone
Under Settings provide a unique name for the restored DB instance in the Db Instance Identifier field
Select the desired DB instance class (chose Burstable classes, including t classes and then pick db.t3.small)
In Connectivity, keep the following as default settings
- Virtual private cloud (vpc)
- DB subnet group
- Public access
- VPC security group (firewall)
Keep encryption as default settings
Expand the Additional configuration section at the bottom of the page
Under Database options
- DB Parameter group: keep the default parameter group
- Option group: keep the recommended
- Enable deletion protection by checking the Enable deletion protection
Click on Restore DB instance

Enabling Multi-AZ on Amazon RDS

Creating an RDS Database and Enabling Multi-AZ

Navigate to RDS through the AWS Management Console
Click on Create Database
Chose MySQL as the database engine
Template: Dev/Test
Availability and durability: multi-az db instance
Configure database settings
- DB instance identifier: give your db a unique name
- Tick the box on the auto-generate password
Instance configuration: db.t3.micro
Set allocated storage to 20 GiB
Click on Create Database
Return to the RDS dashboard, monitor the DB Instance Status to ensure it transitions from Modifying to Available
Verify if the multi-az has been successfully enabled after the status turns to Available

Check the time of the Failover Process

Trigger the failover process by rebooting the database
Tick the checkbox on the Reboot With Failover and then click Confirm
Once rebooted, go to Events on the left hand side
Check if the failover process completed within 60-120 seconds

Integrating Amazon RDS to Amazon EC2 Instance

Setting Up an Amazon RDS Instance

Database creation method: standard create
Engine options
- Type: MySQL
- Version: leave as default
Templates: free tier
Settings
- DB instance identifier: <db-name>
- Master username: admin
- Credentials management: self managed
- Click on Auto generate password (for testing/set up only)
Instance configuration
- DB instance size: db.t3.micro
Storage
- Type: General Purpose SSD (gp2)
- Allocated storage: 20
Connectivity
- Compute resource: don’t connect to an EC2 compute resource
Virtual private cloud (VPC): leave as default
- DB subnet group: create a new DB subnet group
- Public access: no
- VPC security group (firewall): select create new
  - New VPC security group name: <vpc-name>
  - Availability zone: select nearest AZ
Leave the rest as default
Click on Create database
Wait for the RDS Instance to be Available
Click View connection details and take note od the details

Setting Up an Amazon EC2 Instance

Name: <ec2-name>
- AMI: Amazon Linux
Instance type: t2.micro
Key pair (create a new one)
- Name: <key-pair-name>
- Type: RSA
- Format: .pem
Network settings (click edit)
- Leave VPC and subnet with default
- Auto-assign public IP address: enable
- Firewall (security groups): tick on Create security group
  - Security group name (required): <security-group-name>
  - Description: <security-group-description>
  - Inbound security group rules
    - Type: SSH
      - Source type: My IP
    - Type: MySQL/Aurora
      - Source type: <db-of-rds-instance>
Click on Launch Instance

Integrating Amazon RDS to Amazon EC2 Instance

Connect to an EC2 instance
- Open your SSH client
- Connect to the EC2 Instance via the public DNS name and key pair: ssh -i </path/to/your-key-pair.pem> ec2-user@<your-ec2-public-dns>
Install a MySQL Client Application
sudo dnf install mariadb105
Navigate to EC2 Console > Security Groups > DB-SG
- Edit the inbound rule
  - Inbound rule one
    - Type: MySQL/Aurora
    - Source: select the web server
Connect to the RDS Instance from EC2
- mysql -h <your-rds-endpoint> -P 3306 -u <your-master-username> -p
- Enter master password when prompted
- Verify connection: SHOW DATABASES;

Create a database and table

Create DATABASE EmployeesDB;
SHOW DATABASES;
USE EmployeesDB;

CREATE TABLE Employees (
  ID INT PRIMARY KEY,
  Name VARCHAR(50),
  Age INT,
  Salary DECIMAL(10, 2)
);

DESCRIBE Employees;

Creating an Amazon DynamoDB Table

Navigate to DynamoDB via AWS Management Console
Click on Create Table
Configurations
- Name: <table-name>
- Partition key: any attribute of your data (this will serve as the primary means of partition of data)
- Sort key (optional): another way to organise data
- Data types include things like, numbers, strings and binary
- Leave default settings as they are and click on Create table
Once the table has a status of active, you need to enable point-in-time recovery
- Go to the DynamoDB table console
- Click on backups tab, click edit and ensure the checkbox Tun on point-in-time recovery is checked, and click Save changes

Backing Up an Amazon DynamoDB Table

Create the DynamoDB Table and Items

Navigate to DynamoDB via the AWS Management Console
Create a new table with the following config
- Name: <db-name>
- Primary key: ItemID
- Settings: default settings
- Click Create table
Make sure table status is Active
Create the following items
- Item one
  - ID: 001 (string)
  - ProductName: Product 101 (string)
  - Category: Example (string)
  - Price: 100.1 (number)
  - StockQuantity: 100 (number)
- Item two
  - ID: 002 (string)
  - ProductName: Product 102 (string)
  - Category: Example (string)
  - Price: 100.2 (number)
  - StockQuantity: 102 (number)
- Item three
  - ID: 003 (string)
  - ProductName: Product 103 (string)
  - Category: Example Two (string)
  - Price: 100.3 (number)
  - StockQuantity: 103 (number)

Create an On-Demand Backup

Navigate back to DynamoDB and click on Backups under Tables on the left hand side
Click Create backup and then select Create on-demand backup
Add in the source table: <name-of-your-table>
Backup settings
- Select Customize settings
- Backup management: backup with DynamoDB
  - Backup name: <dynamodb-backup-name>
- Click Create backup

Simulate Data Loss or Table Deletion

Go back to DynamoDB and click on tables on the left hand side
Select the table you created earlier and click on delete
Wait for the table to be deleted and click the refresh button to check

Restore the Table from Backup

Go to Backups on the left hand side
Click on Restore
Enter a new table name and select Restore the entire table for the secondary indexes
Leave all other things as default
Click Restore to create a new table from the backup
Once the status of the table becomes Active, go to the new table and verify the data has been restored