Aurora I/O 비용 최적화: 쿼리 패턴·인덱스·버퍼 적중률의 판단 기준
Aurora MySQL의 I/O 과금 지표와 buffer hit ratio를 구분하고, 쿼리·인덱스·메모리·스토리지 구성의 비용 절감 기준을 정리한다.
Aurora의 I/O 비용을 줄이는 일은 버퍼 적중률을 높이는 일과 같지 않다. 적중률이 높아도 요청량이 매우 많으면 스토리지 읽기가 늘 수 있고, 읽기를 줄이려고 추가한 인덱스가 쓰기와 저장 공간을 늘릴 수 있다. 반대로 응답 시간이 짧아진 쿼리가 더 적은 과금 I/O를 사용했다고 단정할 수도 없다.
운영 판단의 출발점은 업무 처리량 → SQL이 접근한 행과 페이지 → 인스턴스 캐시 → 클러스터 볼륨 I/O → 요금을 서로 다른 관측 단위로 구분하는 것이다. 이 글은 Aurora Standard와 Aurora I/O-Optimized의 차이를 전제로, 쿼리 구조를 먼저 개선하고 메모리와 요금 구성을 나중에 비교하는 절차를 설명한다.
검증 범위는 MySQL 8.0 폐기용 인스턴스에서의 진단 SQL, 인덱스 추가 전후 실행 계획, 가정 입력을 이용한 지표 계산이다. 실제 Aurora의 CloudWatch 수집, 과금 절감, 인스턴스 변경, Parallel Query 실행은 시험하지 않았다. 아래 SQL 결과를 Aurora의 실측 청구량으로 해석해서는 안 된다.
1. 행 접근·페이지 읽기·과금 I/O는 서로 다른 단위다
InnoDB는 행을 요청받더라도 저장 장치에서는 페이지 단위로 데이터를 읽는다. B+Tree의 탐색 경로와 리프 페이지, 보조 인덱스에서 찾은 기본 키를 이용한 클러스터 인덱스 접근이 읽기 작업을 만든다. 필요한 페이지가 버퍼 풀에 있으면 스토리지 읽기를 피할 수 있지만, SQL 실행에 필요한 CPU와 논리적 페이지 접근까지 없어지는 것은 아니다.
Aurora에서는 DB 인스턴스가 쿼리를 처리하고 클러스터 볼륨이 영속 데이터를 제공한다. 여러 reader가 같은 볼륨을 사용해도 각 인스턴스의 캐시 상태는 동일하지 않다. 새 reader, 재시작한 인스턴스, 다른 작업 집합을 처리하는 reader는 같은 SQL에 다른 읽기 비용을 보일 수 있다. 읽기를 여러 reader로 분산하는 것은 CPU 부하 분산에는 도움이 되지만, 동일 데이터의 캐시 적재가 여러 곳에서 발생하므로 클러스터 전체 I/O 감소를 보장하지 않는다.
flowchart TD
A[업무 요청과 반복 호출] --> B[실행 계획과 인덱스 접근]
B --> C[인스턴스별 버퍼 캐시]
C -->|적중| D[메모리에서 처리]
C -->|미적중| E[클러스터 볼륨 읽기]
F[행 변경과 인덱스 유지] --> G[변경 로그와 스토리지 쓰기]
E --> H[클러스터 단위 I/O 관측]
G --> H
H --> I{스토리지 요금 구성}
I --> J[Standard: I/O 요청 요금 반영]
I --> K[I/O-Optimized: 읽기·쓰기 I/O 별도 요금 없음]
이 흐름은 일반적인 버퍼 풀 경로를 단순화한 것이다. Aurora Parallel Query는 버퍼 풀을 사용하지 않는 실행 경로가 있으므로, 쿼리가 빨라져도 VolumeReadIOPs와 관련 비용이 증가할 수 있다. AWS 지표 문서도 이 경우를 명시한다. 따라서 높은 캐시 적중률과 높은 볼륨 읽기가 동시에 관측될 때 곧바로 지표 오류로 판단하지 않는다.
쓰기에서도 구분이 필요하다. Aurora의 분산 스토리지 내부 복제본 수를 애플리케이션의 쓰기 횟수에 곱해서 청구 I/O를 계산하지 않는다. 변경 로그의 묶음 처리와 엔진 동작이 개입하므로, 변경 행 수·커밋 수·Community MySQL의 파일 쓰기 카운터를 과금 건수로 직접 환산하는 방식은 부정확하다.
2. 먼저 계측 범위와 시간을 맞춘다
2.1 클러스터 지표와 인스턴스 지표
공식 CloudWatch 지표 정의상 VolumeReadIOPs는 클러스터 볼륨에서 발생한 과금 대상 읽기 작업을 모든 인스턴스에 걸쳐 집계한 5분 구간 횟수다. VolumeWriteIOPs 역시 클러스터 볼륨 쓰기를 5분 간격으로 보고한다. 이름 끝의 IOPs만 보고 초당 값으로 읽지 않는다. 5분 구간 값을 초당 평균으로 바꾸려면 300초로 나눈다.
BufferCacheHitRatio는 버퍼 캐시에서 처리된 요청의 백분율이며 인스턴스 단위다. writer의 적중률 하나와 클러스터 전체 VolumeReadIOPs를 비교하면 reader의 읽기가 빠진다. 최소한 다음을 같은 시간축에 수집한다.
- 클러스터:
VolumeReadIOPs,VolumeWriteIOPs, 스토리지 구성, 실제 청구 내역의 I/O 항목. - writer 및 각 reader:
BufferCacheHitRatio, CPU, 가용 메모리, DB 부하, 읽기 지연, 재시작·승격 시각. - 애플리케이션: 완료된 업무 요청 수, 재시도 수, p95/p99 지연, 연결 풀 분포.
- SQL: digest별 실행 횟수와 누적 시간, 검사 행 수, 반환 행 수, 실행 계획.
대시보드에서는 DBClusterIdentifier와 DBInstanceIdentifier를 혼동하지 않는다. 5분보다 짧은 주기를 지정해도 볼륨 지표에 새로운 세부 관측이 생기지 않는다. 여러 구간을 합산할 때는 동일 클러스터의 겹치지 않는 구간을 사용하고, 클러스터 합계를 인스턴스마다 다시 더하지 않는다. 결측은 0회가 아니라 미관측으로 남긴다.
2.2 Community MySQL에서 확인할 수 있는 진단 기반
다음 쿼리는 버퍼 관련 누적 카운터가 존재하는지와 버퍼 풀 크기를 확인한다. 실서비스에서는 카운터를 간격을 두고 두 번 수집해 차이를 사용한다. 한 번의 값만으로 최근 문제를 판정하거나 운영 서버의 카운터를 초기화하지 않는다.
SELECT VERSION() AS mysql_version,
@@global.innodb_buffer_pool_size AS buffer_pool_bytes;
SELECT VARIABLE_NAME, VARIABLE_VALUE
FROM performance_schema.global_status
WHERE VARIABLE_NAME IN (
'Innodb_buffer_pool_read_requests',
'Innodb_buffer_pool_reads',
'Innodb_buffer_pool_wait_free'
)
ORDER BY VARIABLE_NAME;
실행 결과(MySQL 8.0.x):
mysql> SELECT VERSION() AS mysql_version,
-> @@global.innodb_buffer_pool_size AS buffer_pool_bytes;
+---------------+-------------------+
| mysql_version | buffer_pool_bytes |
+---------------+-------------------+
| 8.0.46 | 67108864 |
+---------------+-------------------+
1 row in set (0.00 sec)
mysql> SELECT VARIABLE_NAME, VARIABLE_VALUE
-> FROM performance_schema.global_status
-> WHERE VARIABLE_NAME IN (
-> 'Innodb_buffer_pool_read_requests',
-> 'Innodb_buffer_pool_reads',
-> 'Innodb_buffer_pool_wait_free'
-> )
-> ORDER BY VARIABLE_NAME;
+----------------------------------+----------------+
| VARIABLE_NAME | VARIABLE_VALUE |
+----------------------------------+----------------+
| Innodb_buffer_pool_read_requests | 15364 |
| Innodb_buffer_pool_reads | 998 |
| Innodb_buffer_pool_wait_free | 0 |
+----------------------------------+----------------+
3 rows in set (0.00 sec)
Innodb_buffer_pool_read_requests는 논리적 읽기 요청, Innodb_buffer_pool_reads는 버퍼 풀에서 충족되지 않아 읽기가 필요했던 횟수를 파악하는 데 사용한다. 두 시점의 증가량으로 계산하는 전통적인 적중률은 다음과 같다.
적중률(%) = 100 × (1 - ΔInnodb_buffer_pool_reads / ΔInnodb_buffer_pool_read_requests)
분모가 0이면 적중률을 계산하지 않는다. 서버 재시작, 수집 대상 변경, 카운터 리셋으로 차이가 음수이면 해당 구간을 제외한다. 이 계산을 Aurora의 BufferCacheHitRatio 구현과 완전히 같은 공식이라고 단정하지 않으며, 특히 Innodb_buffer_pool_reads를 Aurora 청구 건수로 대체하지 않는다. 로컬 서버의 값은 진단 쿼리 실행 확인일 뿐이다.
Innodb_buffer_pool_wait_free 증가도 함께 본다. 단순한 캐시 미적중과, 재사용할 버퍼 페이지 확보가 지연되는 현상은 다른 문제다. 적중률 하나를 개선하느라 flush나 쓰기 병목을 놓치지 않는다.
3. 쿼리 패턴부터 줄여야 하는 이유
메모리 증설은 불필요한 작업을 캐시에 올려 더 빠르게 반복할 수 있게 만들지만, 불필요한 작업 자체를 제거하지는 않는다. 다음 순서가 일반적으로 유효하다.
- 호출 수를 줄인다. 목록의 각 행마다 조회하는 N+1, 짧은 주기의 전체 집계, 동일 결과의 중복 요청, 실패 후 무제한 재시도를 먼저 찾는다. 캐시를 추가한다면 만료·무효화·쓰기 후 읽기 일관성 계약을 함께 정한다.
- 접근 범위를 줄인다. 함수로 감싼 검색 조건, 자료형 불일치, 불필요한 전체 기간 검색, 깊은 OFFSET 페이지 처리를 점검한다. 키셋 페이지 처리도 정렬 키의 동률 처리와 동시 변경 의미를 정해야 한다.
- 읽는 폭을 줄인다. 필요한 열만 선택한다. 큰 TEXT/BLOB을 목록 조회에 포함하면 추가 페이지 접근과 전송량이 늘 수 있다. 커버링 인덱스가 가능한 쿼리와 상세 본문 조회를 분리한다.
- 인덱스를 검증한다. 필터·정렬·선택 열의 조합을 보고 구성하되, 쓰기 유지 비용과 저장량을 같이 확인한다. 모든 열을 인덱스에 넣는 방식은 피한다.
SQL digest의 누적 시간이 큰 쿼리는 좋은 출발점이지만, 시간 합계는 I/O 요금 합계가 아니다. 락 대기 때문에 느린 쿼리와 많은 페이지를 읽는 쿼리는 개선 방법이 다르다. 높은 실행 횟수와 높은 검사 행 수의 조합을 찾고, DB 부하의 대기 유형 및 볼륨 지표와 시간상 연관성을 확인한다. digest가 초기화되거나 수집이 비활성화된 구간은 별도로 처리한다.
3.1 복합 인덱스가 읽기 경로를 바꾸는 축소 예제
다음은 운영 테이블이 아닌 독립 테스트 스키마에서 실행하는 예제다. 작은 숫자 테이블을 네 번 조합해 주문 10,000건을 만들고, tenant별 기간 조회에 정렬과 LIMIT을 적용한다. 먼저 기본 키만 있는 상태의 계획을 확인한다. 이 블록과 다음 블록은 같은 스키마에서 순서대로 실행한다.
CREATE TABLE io_digit (d INT PRIMARY KEY);
INSERT INTO io_digit VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9);
CREATE TABLE io_orders (
id BIGINT PRIMARY KEY,
tenant_id INT NOT NULL,
created_at DATETIME NOT NULL,
amount DECIMAL(10,2) NOT NULL,
payload VARCHAR(300) NOT NULL
) ENGINE=InnoDB;
INSERT INTO io_orders
SELECT n, MOD(n,100),
DATE_ADD('2026-01-01 00:00:00', INTERVAL n MINUTE),
MOD(n,1000), REPEAT('x',200)
FROM (
SELECT a.d + 10*b.d + 100*c.d + 1000*d.d + 1 AS n
FROM io_digit a CROSS JOIN io_digit b
CROSS JOIN io_digit c CROSS JOIN io_digit d
) AS numbers;
ANALYZE TABLE io_orders;
EXPLAIN
SELECT id, created_at, amount
FROM io_orders
WHERE tenant_id = 7 AND created_at >= '2026-01-04 00:00:00'
ORDER BY created_at, id
LIMIT 20;
아래는 준비 명령을 축약하고 EXPLAIN의 핵심 열만 발췌한 실제 실행 결과다.
실행 결과(MySQL 8.0.x):
mysql> CREATE TABLE io_digit ...;
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO io_digit ...;
Query OK, 10 rows affected (0.00 sec)
Records: 10 Duplicates: 0 Warnings: 0
mysql> CREATE TABLE io_orders ...;
Query OK, 0 rows affected (0.01 sec)
mysql> INSERT INTO io_orders SELECT ...;
Query OK, 10000 rows affected (0.06 sec)
Records: 10000 Duplicates: 0 Warnings: 0
mysql> ANALYZE TABLE io_orders;
Msg_type: status, Msg_text: OK
mysql> EXPLAIN SELECT ...;
type: ALL
key: NULL
rows: 11947
Extra: Using where; Using filesort
그다음 equality 조건, 범위 및 정렬 조건, 반환 열 순서로 인덱스를 만든다. id는 InnoDB 보조 인덱스에 기본 키로 포함되지만, 여기서는 정렬 키가 amount보다 먼저 오도록 명시했다.
ALTER TABLE io_orders
ADD INDEX ix_tenant_created_id_amount
(tenant_id, created_at, id, amount),
ALGORITHM=INPLACE, LOCK=NONE;
ANALYZE TABLE io_orders;
EXPLAIN
SELECT id, created_at, amount
FROM io_orders
WHERE tenant_id = 7 AND created_at >= '2026-01-04 00:00:00'
ORDER BY created_at, id
LIMIT 20;
SELECT COUNT(*) AS matching_rows
FROM io_orders
WHERE tenant_id = 7 AND created_at >= '2026-01-04 00:00:00';
DROP TABLE io_orders, io_digit;
아래도 명령과 EXPLAIN의 핵심 열을 발췌했다. COUNT 결과는 LIMIT 적용 전 조건에 맞는 전체 행 수다.
실행 결과(MySQL 8.0.x):
mysql> ALTER TABLE io_orders ADD INDEX ...;
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> ANALYZE TABLE io_orders;
Msg_type: status, Msg_text: OK
mysql> EXPLAIN SELECT ...;
type: range
key: ix_tenant_created_id_amount
rows: 56
Extra: Using where; Using index
mysql> SELECT COUNT(*) AS matching_rows FROM io_orders WHERE ...;
+---------------+
| matching_rows |
+---------------+
| 56 |
+---------------+
1 row in set (0.00 sec)
mysql> DROP TABLE io_orders, io_digit;
Query OK, 0 rows affected (0.01 sec)
판정할 핵심은 ALL에서 range로 바뀌는지, 선택된 key가 새 인덱스인지, Using filesort가 없어지고 Using index가 나타나는지다. rows는 추정치이므로 실행 때마다 조금 달라질 수 있다. 이 예제는 데이터 경로가 좁아지고 커버링이 가능해짐을 확인한다. 실제 읽은 스토리지 페이지 수나 절감한 Aurora I/O 건수를 측정한 것은 아니다.
운영 적용 전에는 대표 데이터 분포에서 실제 실행 통계를 추가로 확인한다. EXPLAIN ANALYZE는 실제 쿼리를 실행하므로 무거운 조회에 무심코 사용하지 않는다. 커버링 계획도 MVCC 가시성 확인 등 내부 조건에 따라 추가 접근이 생길 수 있어, Using index를 물리 읽기 0의 보장으로 해석해서는 안 된다.
또한 LOCK=NONE은 모든 잠금이 없다는 의미가 아니다. 온라인 인덱스 생성도 메타데이터 잠금과 일시적인 I/O 부하를 만들 수 있다. 대형 테이블에서는 생성 비용, 여유 공간, 장기 트랜잭션, 복제 영향, 취소 조건을 별도로 계획한다.
4. 높은 적중률이 낮은 비용을 보장하지 않는다
다음 SQL의 수치는 실제 관측이 아닌 설명용 가정이다. 동일한 5분 창에서 요청량이 증가하면서 적중률도 높아진 두 경우를 계산한다. logical_requests와 misses는 캐시 산식의 예제이고, volume_reads는 별도로 주어진 볼륨 관측값을 가정한다. 둘 사이에 자동 환산 관계를 두지 않았다.
WITH samples AS (
SELECT 'A' AS scenario, 1000000 AS logical_requests,
10000 AS misses, 12000 AS volume_reads,
2000 AS completed_requests
UNION ALL
SELECT 'B', 10000000, 50000, 60000, 10000
)
SELECT scenario,
ROUND(100.0 * (1 - misses / NULLIF(logical_requests,0)),2)
AS hit_pct,
misses,
ROUND(volume_reads / 300.0,2) AS volume_reads_per_sec,
ROUND(volume_reads / NULLIF(completed_requests,0),2)
AS reads_per_request
FROM samples
ORDER BY scenario;
실행 결과(MySQL 8.0.x):
mysql> WITH samples AS (
-> SELECT 'A' AS scenario, 1000000 AS logical_requests,
-> 10000 AS misses, 12000 AS volume_reads,
-> 2000 AS completed_requests
-> UNION ALL
-> SELECT 'B', 10000000, 50000, 60000, 10000
-> )
-> SELECT scenario,
-> ROUND(100.0 * (1 - misses / NULLIF(logical_requests,0)),2)
-> AS hit_pct,
-> misses,
-> ROUND(volume_reads / 300.0,2) AS volume_reads_per_sec,
-> ROUND(volume_reads / NULLIF(completed_requests,0),2)
-> AS reads_per_request
-> FROM samples
-> ORDER BY scenario;
+----------+---------+--------+----------------------+-------------------+
| scenario | hit_pct | misses | volume_reads_per_sec | reads_per_request |
+----------+---------+--------+----------------------+-------------------+
| A | 99.00 | 10000 | 40.00 | 6.00 |
| B | 99.50 | 50000 | 200.00 | 6.00 |
+----------+---------+--------+----------------------+-------------------+
2 rows in set (0.00 sec)
적중률은 좋아졌지만 미적중 횟수와 초당 볼륨 읽기는 늘어난다. 반면 완료 요청당 읽기가 같다면, 비용 증가가 접근 효율 악화가 아니라 업무량 증가 때문일 수 있다. 따라서 총비용과 단위 업무당 비용을 함께 관리한다. 서로 다른 무게의 요청을 섞는 서비스라면 단순 요청 수 대신 주문 완료, 보고서 생성 등 업무 유형별 분모를 사용한다.
이 계산은 낮은 적중률을 방치해도 된다는 뜻이 아니다. 큰 작업 집합이 메모리에 들어가지 않거나, 배치 스캔이 자주 사용되는 페이지를 밀어내거나, reader마다 캐시가 충분히 데워지지 않았는지 확인해야 한다. 단, 적중률 목표를 일률적으로 정해 증설하는 것은 피한다. 메모리 추가 비용과 절약 가능한 I/O·CPU·지연을 동일 기간의 총비용으로 비교해야 한다.
5. 인덱스·메모리·스토리지 구성을 함께 비교한다
5.1 읽기 절감과 쓰기 증폭
인덱스를 추가하면 선택적 조회와 정렬에는 도움이 되지만 INSERT·DELETE 및 인덱스 열 UPDATE의 유지 작업이 늘어난다. 인덱스 페이지도 캐시 공간을 사용한다. 넓은 기본 키는 보조 인덱스 크기에도 영향을 주며, 넓은 커버링 인덱스는 단일 조회를 빠르게 하면서 전체 작업 집합을 키울 수 있다.
따라서 배포 직후 읽기 지표만 비교하지 않는다. 정상 업무 주기에서 쓰기량, 커밋 지연, 스토리지 증가, writer CPU, reader 지연을 같이 확인한다. 인덱스 구축 중의 일시적 부하와 구축 후 정상 상태는 분리한다. Invisible index로 조회 계획의 의존성을 시험할 수 있지만, 보이지 않는 인덱스도 계속 유지되므로 그 시험만으로 쓰기 비용 절감을 확인한 것은 아니다.
5.2 메모리 확대 또는 reader 추가
메모리 확대는 반복 접근하는 작업 집합이 현재 캐시보다 약간 큰 경우에 효과적일 수 있다. 그러나 한 번 읽고 버리는 대규모 스캔은 메모리를 늘려도 비용 개선이 제한적일 수 있다. 이때는 배치 주기, 조회 범위, 요약 테이블, 분석 경로 분리를 검토한다.
reader 추가 역시 쿼리 수 자체를 줄이지 않는다. 연결 단위 분산 때문에 특정 reader가 여전히 과부하일 수도 있다. 변경 후에는 인스턴스별 부하뿐 아니라 클러스터 합계와 단위 업무당 읽기를 확인한다. 승격·재시작 직후의 캐시 준비 구간을 평상시와 섞으면 증설 효과를 잘못 판단할 수 있다.
5.3 Aurora Standard와 I/O-Optimized
Aurora Standard는 인스턴스·스토리지와 요청 기반 I/O 비용을 함께 계산한다. Aurora I/O-Optimized는 읽기·쓰기 I/O에 별도 요금을 부과하지 않지만, 인스턴스와 스토리지 요금 구조가 다르다. 따라서 I/O 비용 항목이 사라진다는 사실만으로 총비용 절감을 선언하지 않는다.
AWS 요금 페이지의 “I/O 지출이 전체 Aurora 비용의 25%를 넘는 경우”는 비교를 시작할 수 있는 안내이지 모든 리전·인스턴스·할인 조합에 적용되는 손익분기 공식은 아니다. 실제 비교식은 다음처럼 구성한다.
Standard 총비용 = Standard 컴퓨팅 + Standard 스토리지 + 읽기·쓰기 I/O + 기타 비용
I/O-Optimized 총비용 = I/O-Optimized 컴퓨팅 + I/O-Optimized 스토리지 + 기타 비용
같은 기간·리전·토폴로지·할인 조건으로 비교하며, Serverless v2라면 실제 ACU 사용 패턴도 반영한다. Global Database의 리전 간 복제·전송 등 다른 요금 항목을 모두 0으로 지우지 않는다. 현재 적용 가능한 구성과 전환 제약은 변경 시점의 AWS 문서에서 다시 확인한다.
I/O-Optimized를 선택한 뒤에도 쿼리 최적화는 유효하다. 과금 항목이 없어졌을 뿐 불필요한 읽기, CPU, 지연, 캐시 경쟁이 사라진 것은 아니다. 반대로 쿼리 개선으로 I/O가 크게 줄면 기존의 요금 구성 선택이 여전히 경제적인지도 재평가한다.
6. 변경 전후를 비교하는 운영 절차
기준선 확보: 최소한 업무 피크와 정기 배치를 포함하는 대표 기간을 고른다. 인스턴스 구성, 엔진 버전, 스토리지 구성, 배포·재시작 이력과 데이터 증가량을 기록한다. 누락된 지표와 부하 패턴이 다른 날은 비교 대상에서 구분한다.
가설 선택: “적중률을 올린다”보다 “반복 보고서의 전체 스캔을 줄인다”, “tenant별 목록 조회의 기본 키 재접근을 줄인다”처럼 원인과 변경 대상을 명확히 정한다. SQL 변경, 인덱스, 메모리, 요금 구성을 동시에 바꾸면 효과를 분리하기 어렵다.
검증 및 배포: 결과 집합·정렬·경계값의 동일성을 먼저 확인하고 실행 계획과 지연을 검증한다. 대형 인덱스 생성은 별도의 변경 작업이다. 사전 중단 기준과 복귀 방법을 정한 뒤 제한된 트래픽에서 확대한다.
효과 판정: 같은 업무량 기준으로 볼륨 읽기·쓰기, p95/p99, CPU, 완료 요청 수를 함께 비교한다. 개선 직후의 캐시 준비와 일시적인 DDL 부하는 별도 구간으로 표기한다. 지표상의 감소를 청구서상의 절감과 구분하고, 최종적으로 비용 내역을 대조한다.
점검표
7. 결론
Aurora I/O 비용 최적화의 핵심은 적중률 숫자를 높이는 것이 아니라, 필요한 업무를 더 적은 불필요한 접근으로 처리하는 것이다. 쿼리 호출과 접근 범위를 줄이고, 목적이 분명한 인덱스를 검증한 뒤, 메모리와 스토리지 요금 구성을 비교해야 한다. 캐시 비율·절대 I/O·단위 업무당 비용을 함께 봐야 성능 개선과 비용 개선을 혼동하지 않는다.
이 원칙은 이후 용량 계획과 비용 운영의 기준이 된다. 피크 처리량, 장애 후 캐시 준비, 데이터 증가, 배치 주기를 포함한 비용 모델을 유지하면 일회성 튜닝을 지속적인 운영 판단으로 확장할 수 있다.
참고 문서
- AWS Aurora CloudWatch 지표 정의: VolumeReadIOPs·VolumeWriteIOPs의 5분 구간 정의, BufferCacheHitRatio, Parallel Query 주의사항.
- Amazon Aurora 요금: Standard와 I/O-Optimized, 비교 기준 및 Global Database의 별도 요금 항목. 단가와 지원 조건은 사용 리전 및 변경 시점 기준으로 확인한다.