AWS Database Services Fundamentals

Now that you understand AWS compute and storage services, let's explore the database services that power modern applications. In this lesson, you'll learn about AWS's managed database offerings and when to choose each type for different use cases.

Learning Goals

Understand the different types of AWS database services
Learn when to use relational vs. non-relational databases
Explore key AWS database services: RDS, DynamoDB, and Aurora
Practice basic database operations with code examples

Types of Databases on AWS

AWS offers two main categories of database services:

Relational Databases (SQL)

These use structured tables with predefined schemas and support SQL queries. They're ideal for applications requiring complex transactions and data integrity.

Non-Relational Databases (NoSQL)

These provide flexible schemas and are optimized for specific data models like key-value, document, or graph. They excel at scalability and performance for specific access patterns.

Amazon RDS (Relational Database Service)

Amazon RDS is a managed relational database service that supports multiple database engines:

MySQL and MariaDB - Popular open-source databases
PostgreSQL - Advanced open-source SQL database
Oracle and SQL Server - Enterprise commercial databases
Aurora - AWS-optimized MySQL and PostgreSQL compatible

Creating an RDS Instance

Here's how to create a MySQL RDS instance using AWS CLI:

create-rds.sh
aws rds create-db-instance \
    --db-instance-identifier my-database \
    --db-instance-class db.t3.micro \
    --engine mysql \
    --master-username admin \
    --master-user-password MyPassword123 \
    --allocated-storage 20 \
    --backup-retention-period 1

Connecting to RDS

Python
Node.js

connect-rds.py
import mysql.connector

config = {
    'user': 'admin',
    'password': 'MyPassword123',
    'host': 'my-database.123456789012.us-east-1.rds.amazonaws.com',
    'database': 'myapp',
    'port': 3306
}

try:
    connection = mysql.connector.connect(**config)
    cursor = connection.cursor()
    cursor.execute("SELECT VERSION()")
    version = cursor.fetchone()
    print(f"MySQL version: {version[0]}")
except mysql.connector.Error as err:
    print(f"Error: {err}")
finally:
    if 'connection' in locals() and connection.is_connected():
        cursor.close()
        connection.close()

connect-rds.js
const mysql = require('mysql2');

const connection = mysql.createConnection({
  host: 'my-database.123456789012.us-east-1.rds.amazonaws.com',
  user: 'admin',
  password: 'MyPassword123',
  database: 'myapp',
  port: 3306
});

connection.execute('SELECT VERSION()', (err, results) => {
  if (err) {
    console.error('Error:', err);
    return;
  }
  console.log('MySQL version:', results[0]['VERSION()']);
  connection.end();
});

tip

Always store database credentials in AWS Secrets Manager instead of hardcoding them in your application. RDS integrates seamlessly with Secrets Manager for secure credential rotation.

Amazon DynamoDB

DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability.

Basic DynamoDB Operations

dynamodb-example.py
import boto3
from boto3.dynamodb.conditions import Key

# Initialize DynamoDB resource
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')

# Put an item
table.put_item(
    Item={
        'UserID': 'user123',
        'Name': 'John Doe',
        'Email': 'john@example.com',
        'Age': 30
    }
)

# Get an item
response = table.get_item(
    Key={
        'UserID': 'user123'
    }
)
user = response.get('Item', {})
print(f"User: {user}")

# Query items
response = table.query(
    KeyConditionExpression=Key('UserID').eq('user123')
)
items = response.get('Items', [])

Amazon Aurora

Aurora is a MySQL and PostgreSQL-compatible relational database built for the cloud. It provides better performance and availability than standard RDS.

Aurora Features

Auto-scaling storage - Grows automatically up to 128TB
High availability - 6-way replication across Availability Zones
Backup and recovery - Continuous backup to S3
Global databases - Cross-region replication for disaster recovery

aurora-performance.sql
-- Aurora provides enhanced performance for certain operations
-- This query benefits from Aurora's optimized parallel query execution
SELECT 
    customer_id,
    COUNT(*) as order_count,
    SUM(total_amount) as total_spent
FROM orders 
WHERE order_date >= DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY customer_id
HAVING total_spent > 1000
ORDER BY total_spent DESC;

Choosing the Right Database

note

Database Selection Guide

RDS: Traditional applications, complex transactions, SQL reporting
DynamoDB: High-scale applications, simple queries, serverless architectures
Aurora: Enterprise applications requiring high performance and availability
Redshift: Data warehousing and analytics (covered in later lessons)
DocumentDB: MongoDB-compatible document database

Common Pitfalls

Cost underestimation: RDS and Aurora can become expensive; monitor usage and choose appropriate instance types
Security misconfiguration: Always use security groups to restrict database access and enable encryption at rest
Backup misunderstandings: Automated backups don't protect against accidental deletions; use snapshots for point-in-time recovery
Performance issues: Monitor read/write latency and use read replicas for read-heavy workloads
Lock-in concerns: Consider database portability when choosing between proprietary and open-source engines

Summary

In this lesson, you learned about AWS's core database services:

Amazon RDS for managed relational databases with multiple engine options
Amazon DynamoDB for scalable NoSQL key-value and document storage
Amazon Aurora for high-performance MySQL/PostgreSQL compatible databases

Each service serves different use cases, and understanding their strengths will help you architect efficient and cost-effective solutions.

Quiz