AWS RDS Tutorial for Beginners: Launch MySQL and Connect from Terminal

-

A relational database stores data in tables with rows and columns. Example: a products table with columns like id, name, description, price, and stock. These tables can be related using keys. Popular relational databases include MySQL, PostgreSQL, Oracle, MariaDB, and SQL Server.

When deploying applications (for example on EC2), they typically need one of these relational databases to store application data.

What is AWS RDS?

Amazon RDS (Relational Database Service) is a managed database service that allows you to create, operate, and scale relational databases without managing the underlying servers.

RDS automatically handles:

  • Provisioning
  • Backups
  • Patching
  • Monitoring

Supported engines:

  • Amazon Aurora (MySQL/PostgreSQL compatible)
  • MySQL
  • PostgreSQL
  • MariaDB
  • Oracle
  • Microsoft SQL Server
  • IBM Db2

You connect to RDS databases using normal CLI tools or JDBC URLs.

Create an RDS MySQL Database (Free Tier)

  • Open the RDS Console → Click Create database
  • Choose Standard create
  • Engine: MySQL Community Edition
  • Choose a MySQL version
  • Template: Free tier

Free Tier allows:

  • Single AZ instance
  • db.t4g.micro instance
  • 20 GB GP3 storage

Configuration:

  • DB identifier: database-1
  • Master username: admin
  • Password: admin1234 (example)
  • Instance class: db.t4g.micro

Connectivity & Security Settings

  • Public access: Yes (only for learning/demo)
  • VPC security group: allow port 3306 from your IP
  • Authentication: Password authentication
  • Monitoring: basic (free tier)

Click Create database. The instance will take a few minutes to become available.

Viewing RDS Instance Details

Once available, open the DB instance page. You will see:

  • Status: available
  • Engine: MySQL
  • AZ: e.g., ap-south-1a
  • Endpoint: used for connecting
  • Port: 3306

The endpoint is the hostname you use in your MySQL CLI or JDBC.

Connect to AWS RDS MySQL from Terminal

Install MySQL client:

  • macOS → Homebrew
  • Windows → MySQL Installer

Connect using:


mysql -h <endpoint> -P 3306 -u admin -p

Example:


mysql -h database-1.xxxxx.ap-south-1.rds.amazonaws.com -P 3306 -u admin -p

Enter your password when prompted.

Inside the MySQL shell:


SHOW DATABASES;
CREATE DATABASE demo_db;
USE demo_db;

CREATE TABLE employees (
  id INT PRIMARY KEY,
  name VARCHAR(100),
  salary INT
);

INSERT INTO employees VALUES (1, 'John', 50000);
SELECT * FROM employees;

Cleaning Up (Delete RDS Instance)

  • Go to RDS Console
  • Select your DB instance
  • Click Delete
  • Skip final snapshot (demo purpose)
  • Confirm deletion phrase

Status becomes deleting and then the instance disappears.

Any future connection attempts to the old endpoint will fail.

Summary

AWS RDS allows you to launch relational databases like MySQL without managing servers. You still connect and execute SQL exactly as you would with a local database. In the next step, this same RDS instance can be integrated with Spring Boot using normal JDBC URLs.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more