반응형

MySQL 파티션 테이블 가이드

들어가며: 파티션의 필요성

대규모 데이터베이스를 운영하다 보면 마치 거대한 도서관을 관리하는 것과 같은 어려움을 겪게 됩니다. 수백만 건의 데이터를 하나의 테이블에서 관리한다면, 책장 전체를 뒤져야 하는 것처럼 검색 시간이 오래 걸리고 관리도 어려워집니다. 이러한 문제를 해결하기 위해 MySQL은 파티셔닝이라는 강력한 기능을 제공합니다.

파티션 테이블의 이해

파티션 테이블은 마치 도서관의 책을 주제별로 나누어 관리하는 것과 같습니다. 하나의 큰 테이블을 여러 개의 작은 물리적 조각(파티션)으로 나누어 저장하지만, 사용자 입장에서는 여전히 하나의 테이블처럼 사용할 수 있습니다.

예를 들어, 온라인 쇼핑몰의 주문 내역을 연도별로 파티셔닝한다고 생각해봅시다:

-- 주문 내역 테이블을 연도별로 파티셔닝하는 예제
-- 실제 운영에서 자주 사용되는 구조입니다
CREATE TABLE orders (
    order_id INT,
    order_date DATE,
    customer_id INT,
    amount DECIMAL(10,2),
    -- 파티션 키가 포함된 PRIMARY KEY
    PRIMARY KEY (order_id, order_date)
) 
PARTITION BY RANGE (YEAR(order_date)) (
    PARTITION p2022 VALUES LESS THAN (2023),
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

이렇게 구성하면 2023년 주문을 조회할 때, MySQL은 p2023 파티션만 검색하면 되므로 성능이 크게 향상됩니다.

파티션의 종류와 실전 활용

1. Range Partitioning (범위 파티셔닝)

시간이나 숫자 범위로 데이터를 나눌 때 사용합니다. 주로 날짜별 로그 데이터나 연령대별 회원 정보 관리에 적합합니다.

-- 예제: 고객의 연령대별 파티셔닝
CREATE TABLE customers (
    id INT,
    birth_year INT,
    name VARCHAR(100),
    email VARCHAR(100),
    PRIMARY KEY (id, birth_year)
)
PARTITION BY RANGE (birth_year) (
    PARTITION p_gen_z VALUES LESS THAN (2000),
    PARTITION p_millenial VALUES LESS THAN (1995),
    PARTITION p_gen_x VALUES LESS THAN (1980),
    PARTITION p_others VALUES LESS THAN MAXVALUE
);

2. List Partitioning (목록 파티셔닝)

지역 코드나 카테고리처럼 고정된 값 목록으로 데이터를 나눌 때 사용합니다:

-- 예제: 지역별 매장 정보 파티셔닝
CREATE TABLE stores (
    store_id INT,
    region_code CHAR(2),
    store_name VARCHAR(100),
    revenue DECIMAL(10,2),
    PRIMARY KEY (store_id, region_code)
)
PARTITION BY LIST (region_code) (
    PARTITION p_capital VALUES IN ('SE', 'GG'),  -- 수도권
    PARTITION p_south VALUES IN ('BS', 'GJ', 'DG'),  -- 남부권
    PARTITION p_central VALUES IN ('DJ', 'GW')   -- 중부권
);

3. Hash Partitioning (해시 파티셔닝)

데이터를 균일하게 분산시키고 싶을 때 사용합니다. 시스템이 자동으로 데이터를 분산시켜줍니다:

-- 예제: 사용자 로그 데이터 해시 파티셔닝
CREATE TABLE user_logs (
    log_id INT,
    user_id INT,
    action_type VARCHAR(50),
    log_time TIMESTAMP,
    PRIMARY KEY (log_id, user_id)
)
PARTITION BY HASH(user_id)
PARTITIONS 4;  -- 4개의 파티션으로 균등하게 분할

파티션 관리와 최적화

파티션 상태 모니터링

-- 파티션별 데이터 분포 확인
SELECT 
    PARTITION_NAME,
    TABLE_ROWS,
    DATA_LENGTH/1024/1024 as 'Data Size (MB)'
FROM 
    INFORMATION_SCHEMA.PARTITIONS
WHERE 
    TABLE_NAME = 'your_table_name';

파티션 유지보수

-- 새로운 파티션 추가
ALTER TABLE orders ADD PARTITION (
    PARTITION p2025 VALUES LESS THAN (2026)
);

-- 오래된 파티션 삭제
ALTER TABLE orders DROP PARTITION p2022;

-- 파티션 재구성
ALTER TABLE orders REORGANIZE PARTITION p_future INTO (
    PARTITION p2025 VALUES LESS THAN (2026),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

실전 운영 팁

  1. 파티션 키 선정: 쿼리에서 자주 사용되는 WHERE 조건을 파티션 키로 선택합니다.
  2. 파티션 수 관리: 너무 많은 파티션은 오히려 성능을 저하시킬 수 있습니다. 일반적으로 테이블당 50개 이하를 권장합니다.
  3. 데이터 분포 모니터링: 특정 파티션에 데이터가 몰리지 않도록 주기적으로 확인합니다.
  4. 백업 전략: 파티션별로 백업을 수행하면 백업/복구 시간을 단축할 수 있습니다.

주의사항

  1. PRIMARY KEY에는 반드시 파티션 키가 포함되어야 합니다.
  2. FOREIGN KEY 제약조건은 파티션 테이블에서 사용할 수 없습니다.
  3. 파티션 간 JOIN 연산은 성능 저하를 초래할 수 있으므로 신중히 설계해야 합니다.
  4. 너무 잦은 파티션 키 값 변경은 성능 문제를 일으킬 수 있습니다.

마치며

파티션 테이블은 대용량 데이터 관리를 위한 강력한 도구이지만, 신중한 설계와 지속적인 관리가 필요합니다. 실제 데이터의 특성과 접근 패턴을 충분히 분석한 후, 적절한 파티셔닝 전략을 선택하시기 바랍니다.

반응형
반응형

파티션 테이블이란?

파티션 테이블은 대용량 데이터를 효과적으로 관리하기 위해 하나의 테이블을 여러 물리적 단위(파티션)로 나누어 저장하는 방식입니다. 논리적으로는 하나의 테이블로 동작하지만, 물리적으로는 데이터가 각 파티션에 분산 저장됩니다. 이를 통해 데이터를 조회하거나 관리할 때 성능과 효율성을 크게 향상시킬 수 있습니다.

파티션 테이블은 특히 Pruning이라는 최적화 기법을 지원합니다. 특정 데이터를 조회할 때 필요한 데이터가 위치한 파티션만 읽어들이는 방식으로, 쿼리 속도를 대폭 개선합니다. 또한, 파티션 테이블은 개발자 입장에서 기존 쿼리를 특별히 수정할 필요가 없으면서도 데이터 관리와 유지보수를 간소화할 수 있는 장점이 있습니다.


1. 파티션 테이블의 장단점

장점

  • 쿼리 성능 향상: 특정 조건에 맞는 데이터만 저장된 파티션을 조회하므로, 전체 테이블을 스캔하지 않아도 됩니다.
  • 가용성 강화: 디스크 장애가 발생해도 문제가 발생한 파티션만 복구하면 되므로 데이터 손실 위험이 줄어듭니다.
  • 효율적 데이터 관리: 파티션 단위로 데이터 삭제, 백업, 아카이빙 등을 수행할 수 있어 관리가 편리합니다.
  • 기존 쿼리와 호환성 유지: 논리적으로 하나의 테이블로 동작하므로, 기존 쿼리를 수정할 필요가 없습니다.
  • 병렬 처리 지원: 조인 작업이나 데이터 처리를 파티션 단위로 병렬 처리하여 성능을 향상시킬 수 있습니다.
  • I/O 부하 분산: 데이터를 물리적으로 분산 저장하므로 디스크 I/O 부하가 감소합니다.

단점

  • 복잡한 관리: 파티션 키 값 변경 시 별도의 관리가 필요하며, 설계와 유지보수가 복잡해질 수 있습니다.
  • 오버헤드 발생: 데이터 입력 시 어느 파티션에 저장할지 결정하는 연산이 추가되며, 인서트 속도가 느려질 수 있습니다.
  • JOIN 비용 증가: 파티션 간 데이터를 조인할 때 성능 저하가 발생할 가능성이 있습니다.
  • 설계 제약: 파티션 기준이 되는 컬럼과 데이터 분포를 잘못 설계하면 성능 저하 및 데이터 불균형 문제가 생길 수 있습니다.

2. 어떤 테이블을 파티션 테이블로 만들어야 할까?

파티션 테이블은 모든 테이블에 적합한 방법은 아니며, 아래 조건을 충족하는 경우 활용 가치가 높습니다.

  • 대규모 데이터: 데이터 양이 방대하고 지속적으로 증가하는 테이블(예: 로그 테이블).
  • 지속적인 데이터 입력: 대량의 데이터가 주기적으로 인서트되는 테이블.
  • 오래된 데이터 관리: 특정 기간이 지나면 삭제하거나 아카이빙해야 하는 데이터가 포함된 경우.
  • 범위 기반 쿼리: 날짜, 시간, 지역 등 특정 조건으로 데이터를 조회하는 경우가 많은 테이블.
  • 장애 복구가 중요한 테이블: 일부 데이터 손상에도 나머지 데이터를 정상적으로 사용해야 하는 경우.

3. 파티션 키 컬럼 (파티셔닝 키)

파티션 키는 데이터를 각 파티션에 분산 저장하는 기준이 되는 컬럼입니다. 적절한 파티션 키를 선택하면 데이터의 균등 분산과 쿼리 성능을 극대화할 수 있습니다.

파티션 키 선정 기준

  • 직관적인 데이터 분리: 날짜, 월, 연도 등 사용자가 데이터를 쉽게 이해하고 구분할 수 있는 컬럼.
  • 균등한 데이터 분포: 특정 파티션에 데이터가 집중되지 않도록 고른 분포가 가능한 컬럼.
  • I/O 효율성: 쿼리 조건에서 자주 사용되며, 데이터 접근 패턴과 부합하는 컬럼.
  • 데이터 관리 용이성: 데이터 삭제, 백업, 이동 시 유리한 컬럼.
  • 피해야 할 컬럼: Primary Key처럼 중복되지 않는 고유값은 분산 효과가 적어 적합하지 않음.

4. 파티션 테이블의 종류

1) Range Partitioning

특정 범위를 기준으로 데이터를 분할하는 방식입니다. 주로 날짜, 숫자 등 연속적인 값을 가진 컬럼에 적합합니다.

  • 장점: 관리가 간단하며, 시간 기반 데이터(로그, 이력 등)에 적합.
  • 단점: 데이터가 특정 범위에 몰릴 경우 부하가 증가.

2) Hash Partitioning

해시 함수를 사용하여 데이터를 고르게 분산하는 방식으로, 값의 분포가 불규칙하거나 예측하기 어려운 경우 유용합니다.

  • 장점: 데이터가 균등하게 분산되어 부하가 고르게 분산.
  • 단점: 파티션 간 데이터 분포를 사용자가 직접 제어할 수 없음.

3) List Partitioning

명시적으로 정의된 특정 값의 목록에 따라 데이터를 분할합니다. 카테고리, 지역 등 그룹화가 필요한 데이터에 적합합니다.

  • 장점: 사용자가 원하는 값에 따라 데이터를 명확히 구분 가능.
  • 단점: 모든 값에 대한 리스트를 정의해야 하므로 설정이 번거로울 수 있음.

4) Composite Partitioning

두 가지 이상의 파티셔닝 방식을 조합하여 사용하는 고급 방식입니다(예: Range + Hash).

  • 장점: 다양한 데이터 요구를 동시에 충족할 수 있음.
  • 단점: 관리 복잡도가 높아지고, 파티션 수가 너무 많아질 위험이 있음.

파티션 테이블은 대규모 데이터 환경에서 성능과 관리 효율성을 높이는 데 매우 유용한 기법입니다. 하지만 데이터의 특성과 사용 패턴을 면밀히 분석해 설계하지 않으면 오히려 성능 저하와 관리 복잡성을 초래할 수 있습니다. 따라서 적절한 파티션 키 선정과 파티션 종류의 활용이 핵심입니다.

※ MySQL 에서 파티션 테이블의 생성 방법을 알고 싶다면 아래 글을 참고해주세요

[MySQL] MySQL 파티션 테이블 가이드

 

[DB] MySQL 파티션 테이블 가이드

MySQL 파티션 테이블 가이드들어가며: 파티션의 필요성대규모 데이터베이스를 운영하다 보면 마치 거대한 도서관을 관리하는 것과 같은 어려움을 겪게 됩니다. 수백만 건의 데이터를 하나의

ethank.tistory.com

 

반응형
반응형

커버링 인덱스(Covering Index)란 무엇인가?

커버링 인덱스는 쿼리가 필요로 하는 모든 컬럼을 포함하는 인덱스를 말합니다. 이 인덱스를 사용하면 테이블의 실제 데이터 페이지에 접근하지 않고도 인덱스만으로 원하는 데이터를 조회할 수 있어 디스크 I/O를 절약할 수 있습니다.

MySQL 공식 문서 정의:

*"쿼리에서 검색되는 모든 컬럼을 포함하는 인덱스입니다. 인덱스 값을 전체 테이블 행을 찾는 포인터로 사용하는 대신, 쿼리는 인덱스 구조에서 값을 반환하여 디스크 I/O를 절약합니다. InnoDB는 MyISAM보다 더 많은 인덱스에 이 최적화 기술을 적용할 수 있습니다. 왜냐하면 InnoDB의 보조 인덱스에는 기본 키 컬럼도 포함되어 있기 때문입니다. InnoDB는 해당 트랜잭션이 끝날 때까지 트랜잭션에 의해 수정된 테이블에 대한 쿼리에 이 기술을 적용할 수 없습니다."*

단일 컬럼 인덱스와 다중 컬럼 인덱스 모두 커버링 인덱스로 활용될 수 있습니다. 적절한 인덱스 설계와 쿼리 작성으로 이 최적화 기법을 최대한 활용할 수 있습니다.


커버링 인덱스를 사용하는 이유

  • 디스크 I/O 감소: 인덱스만으로 데이터를 조회하므로 디스크 접근 횟수가 줄어듭니다.
  • 성능 향상: 디스크 I/O 감소로 쿼리 응답 속도가 빨라집니다.
  • 잠금 경합 감소: 테이블 데이터 페이지에 대한 접근이 줄어들어 잠금 경합이 감소합니다.

클러스터드 인덱스와 비클러스터드 인덱스

클러스터드 인덱스 (Clustered Index)

  • 정의: 테이블의 실제 데이터가 인덱스와 동일한 구조로 저장되는 인덱스입니다.
  • 특징:
    • 테이블 당 하나만 존재합니다.
    • 기본 키(primary key)가 클러스터드 인덱스로 사용됩니다.
  • 장점:
    • 인덱스를 통해 바로 데이터에 접근하므로 조회 속도가 빠릅니다.

비클러스터드 인덱스 (Non-clustered Index)

  • 정의: 인덱스는 별도의 구조로 저장되고, 인덱스 엔트리는 데이터의 물리적 위치를 가리킵니다.
  • 특징:
    • 테이블 당 여러 개의 비클러스터드 인덱스를 가질 수 있습니다.
  • 단점:
    • 인덱스를 통해 데이터를 찾은 후 실제 데이터 페이지를 다시 조회해야 하므로 추가적인 I/O가 발생합니다.

MySQL 공식 문서 인용:

*"클러스터드 인덱스를 통해 행에 접근하는 것은 빠릅니다. 왜냐하면 인덱스 검색이 행 데이터가 있는 페이지로 직접 연결되기 때문입니다. 테이블이 큰 경우, 클러스터드 인덱스 아키텍처는 인덱스 레코드와 다른 페이지에 행 데이터를 저장하는 스토리지 구조와 비교했을 때 디스크 I/O 작업을 절약할 수 있습니다."*


커버링 인덱스 사용과 미사용 시 성능 비교

실험: 100만 건의 데이터로 임시 테이블 생성 후 성능 비교

  1. 데이터 준비

    CREATE TABLE test_table (
        id INT PRIMARY KEY,
        col1 VARCHAR(100),
        col2 VARCHAR(100),
        col3 VARCHAR(100)
    );
    
    INSERT INTO test_table (id, col1, col2, col3)
    SELECT
        t1.number AS id,
        MD5(RAND()) AS col1,
        MD5(RAND()) AS col2,
        MD5(RAND()) AS col3
    FROM
        numbers AS t1  -- numbers 테이블은 1부터 1,000,000까지의 숫자를 가진 테이블이라고 가정
    LIMIT 1000000;
  2. 인덱스 설정

    • 커버링 인덱스 생성

      CREATE INDEX idx_col1_col2 ON test_table (col1, col2);
    • 인덱스 미사용

      • 인덱스를 생성하지 않음.
  3. 쿼리 실행 및 성능 측정

    • 커버링 인덱스 사용 시

      SELECT col1, col2 FROM test_table WHERE col1 = 'some_value';
      • 인덱스만으로 쿼리를 처리하여 빠른 응답 속도를 보입니다.
    • 인덱스 미사용 시

      SELECT col1, col2 FROM test_table WHERE col1 = 'some_value';
      • 전체 테이블 스캔이 발생하여 응답 시간이 느려집니다.
  4. 결과

    • 커버링 인덱스를 사용하면 쿼리 성능이 현저히 향상됩니다.
    • 인덱스를 사용하지 않으면 대량의 데이터를 처리할 때 성능 저하가 발생합니다.

GROUP BY에서의 커버링 인덱스 활용

GROUP BY 절에서도 커버링 인덱스를 활용하여 성능을 개선할 수 있습니다.

  • 인덱스 생성

    CREATE INDEX idx_col1_col2 ON test_table (col1, col2);
  • 쿼리 실행

    SELECT col1, COUNT(*) FROM test_table GROUP BY col1;
  • 설명

    • col1col2를 포함하는 인덱스를 생성하여 GROUP BY 시 인덱스만으로 결과를 도출합니다.
    • 디스크 I/O를 최소화하여 쿼리 성능을 높입니다.

참고 자료

  1. MySQL 공식 문서 - InnoDB Index Types
  2. MySQL 공식 문서 - Covering Indexes
반응형

'Database > My SQL' 카테고리의 다른 글

[DB] MySQL 파티션 테이블 가이드  (0) 2025.01.04
[DB] 파티션 테이블(Partition Table)이란?  (0) 2025.01.04
MySQL Index 정리 및 팁  (0) 2022.05.16
반응형

데이터 복구 과정에서 학습한 내용 기록

이번에 회사에서 AWS RDS로 DB 서버를 단계적으로 이전하는 과정에서 프로덕션 데이터가 소실되는 상황이 발생하였습니다. 다행히 바이너리 로그(binlog)를 보관하는 기간 내에 있어서 MySQL binlog를 활용하여 데이터를 복구할 수 있었습니다. 이때 학습한 내용을 기록 차원에서 남깁니다.


데이터 복구 과정

  1. 프로덕션 서버에서 binlog 확인

    SHOW BINARY LOGS;

    결과는 다음과 같았습니다:

  2. +---------------+-----------+ | Log_name | File_size | +---------------+-----------+ | binlog.000015 | 724935 | | binlog.000016 | 733481 | +---------------+-----------+

  3. 먼저, 프로덕션 서버에 binlog가 존재하는지 확인하였습니다.

  4. binlog 덤프 진행

    mysqlbinlog --read-from-remote-server --host=<프로덕션 호스트> --raw --user=<계정> --password \
    binlog.000015 binlog.000016

    이 명령어는 지정한 binlog 파일들을 로컬 디렉토리로 가져옵니다.

  5. 프로덕션 호스트로부터 binlog를 로컬로 덤프하기 위해 mysqlbinlog 유틸리티를 사용하였습니다.

  6. binlog에서 INSERT 및 UPDATE 추출

    mysqlbinlog binlog.000015 binlog.000016 --database=<DB명> --base64-output=DECODE-ROWS -v > output.sql
    • --database 옵션은 특정 데이터베이스만 대상으로 합니다.
    • --base64-output=DECODE-ROWS-v 옵션은 binlog 이벤트를 사람이 읽을 수 있는 SQL 형식으로 변환합니다.
  7. 덤프한 binlog 파일에서 특정 데이터베이스의 DML 문을 추출하기 위해 다음과 같이 파싱하였습니다.

  8. SQL 문 실행을 통한 데이터 복구

  9. 추출된 output.sql 파일에서 필요한 INSERT와 UPDATE 문을 확인하고, 이를 데이터베이스에 적용하여 데이터를 복구하였습니다.


향후 개선 사항

이번 복구 과정을 통해 몇 가지 개선할 점을 발견하였습니다.

  1. 자동화 도구 활용

    python binlog2sql.py -h <프로덕션 호스트> -u <계정> -p<비밀번호> \
    --start-file='binlog.000015' --stop-file='binlog.000016' \
    --databases=<DB명> --output-file=output.sql
  2. 수동으로 binlog를 파싱하는 대신, binlog2sql과 같은 도구를 사용하면 더욱 효율적으로 복구 작업을 수행할 수 있습니다. 이 도구는 binlog를 직접 파싱하여 DDL과 DML 쿼리문을 생성해주므로, 수작업을 최소화할 수 있습니다.

  3. Point-in-Time Recovery 활용

    mysqlbinlog --start-datetime="2023-10-01 00:00:00" --stop-datetime="2023-10-01 23:59:59" \
    binlog.000015 binlog.000016 | mysql -u <계정> -p<비밀번호> -h <데이터베이스 호스트> <DB명>
  4. MySQL의 Point-in-Time Recovery 기능을 활용하면 특정 시점까지의 데이터를 복구할 수 있습니다. 이를 통해 binlog를 사용하여 원하는 시점까지 데이터를 복원할 수 있으며, 수동으로 SQL 문을 파싱하지 않아도 됩니다.


복구 진행 시 참고한 자료

  1. MySQL 공식 문서 - mysqlbinlog
  2. https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog.html
  3. Amazon RDS에서 MySQL 바이너리 로그 액세스하기
  4. https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.MySQL.Binarylog.html
  5. Percona 블로그 - binlog2sql을 활용한 포인트 인 타임 복구
  6. https://www.percona.com/blog/binlog2sql-binlog-to-raw-sql-conversion-and-point-in-time-recovery/

추가로 알아두면 좋은 점

  • binlog_format 설정 확인

    SHOW VARIABLES LIKE 'binlog_format';
  • MySQL의 binlog_format 설정에 따라 binlog에 기록되는 내용이 달라집니다. 일반적으로 복구를 위해서는 ROW 또는 MIXED 포맷이 더 유용합니다.

  • binlog 보관 기간 설정

    SET GLOBAL expire_logs_days = 7;
  • 데이터 복구를 대비하여 binlog의 보관 기간(expire_logs_days)을 적절히 설정하는 것이 중요합니다.

  • 정기적인 백업 수행

  • binlog를 이용한 복구는 최후의 수단일 수 있으므로, 정기적인 데이터베이스 백업을 통해 데이터 소실에 대비해야 합니다.


결론

이번 경험을 통해 binlog의 중요성과 이를 활용한 데이터 복구 방법에 대해 깊이 있게 이해하게 되었습니다. 향후에는 자동화 도구와 MySQL의 내장 기능을 적극 활용하여 더욱 효율적으로 데이터 복구를 진행할 수 있을 것으로 기대합니다.

반응형
반응형

인덱스(Index)란 무엇인가?

MySQL에서 인덱스는 데이터를 효율적으로 검색하기 위해 사용되는 자료구조입니다. 기본적으로 MySQL은 B-Tree 인덱스를 사용하며, 이는 데이터를 정렬된 상태로 저장하여 빠른 검색을 가능하게 합니다.

B-Tree 구조


B-Tree 인덱스 구조

  • 브랜치 노드: 각 노드는 여러 키와 자식 노드를 가지며, 데이터는 정렬된 형태로 저장됩니다.
  • 정렬된 데이터: 인덱스는 앞의 키를 기준으로 뒤의 키가 정렬되어 있습니다.
  • 빠른 검색: 로그 시간 복잡도로 데이터를 탐색할 수 있습니다.

카디널리티(Cardinality)란?

카디널리티는 데이터의 중복도를 나타내는 수치입니다.

  • 높은 카디널리티 (High Cardinality): 중복도가 낮은 데이터 (예: 주민등록번호, 핸드폰 번호).
  • 낮은 카디널리티 (Low Cardinality): 중복도가 높은 데이터 (예: 성별, 국가 코드).

카디널리티가 높을수록 인덱스의 효율성이 높아집니다.


인덱스 동작 방식

테이블에 인덱스를 설정할 때 고려해야 할 세 가지 경우가 있습니다.

1. 한 컬럼에 인덱스를 설정하는 경우

  • 데이터 중복도가 낮은 컬럼을 선택하여 인덱스를 설정합니다.
  • 높은 카디널리티를 가진 컬럼에 인덱스를 걸면 검색 성능이 향상됩니다.

2. 다중 컬럼에 각각 인덱스를 설정하는 경우

  • 여러 컬럼에 단일 컬럼 인덱스를 각각 설정합니다.
  • 쿼리 실행 시 MySQL은 Index Merge 최적화를 통해 인덱스 결과를 병합합니다.
  • 참고: MySQL Index Merge Optimization

3. 다중 컬럼 인덱스(Multiple-column Index)를 설정하는 경우

  • 여러 컬럼을 하나의 인덱스로 설정합니다.
  • 인덱스 설정 시 카디널리티가 높은 순서로 컬럼을 나열하는 것이 좋습니다.

카디널리티에 따른 인덱스 성능 비교

카디널리티 내림차순 (높은 → 낮은) 카디널리티 오름차순 (낮은 → 높은)
더 나은 성능 제공 상대적으로 낮은 성능 제공

3.1 다중 컬럼 인덱스 사용 조건

  • WHERE 절에서 =, >, <=, BETWEEN, IN 등의 연산자를 사용하는 경우 B-Tree 인덱스가 효율적으로 작동합니다.

    *"B-Tree 자료 구조는 WHERE 절에서 =, >, <=, BETWEEN, IN 등의 연산자에 대응하여 특정 값, 값의 집합 또는 값의 범위를 빠르게 찾을 수 있게 해줍니다."*

  • 조인 시 인덱스가 걸린 컬럼을 사용하면 성능이 향상됩니다.

    *"조인을 수행할 때 다른 테이블에서 행을 가져오기 위해 인덱스를 사용합니다. MySQL은 동일한 타입과 크기로 선언된 컬럼의 인덱스를 더 효율적으로 사용할 수 있습니다."*

  • 인덱스된 컬럼의 데이터 타입과 크기가 동일하면 더욱 효율적입니다.

    • 예를 들어, VARCHAR(10)CHAR(10)은 동일한 크기로 간주되지만, VARCHAR(10)CHAR(15)는 그렇지 않습니다.

인덱스된 컬럼의 크기와 성능

인덱스된 컬럼의 크기가 작을수록 성능이 향상됩니다. 아래는 데이터 타입별 크기와 성능을 비교한 예시입니다.

데이터 타입 크기 성능
BIGINT 8바이트 보통
UUID 16바이트 느림
VARCHAR(32) 최대 32바이트 빠름

풀 테이블 스캔을 피하는 방법

풀 테이블 스캔은 대량의 데이터를 처리할 때 성능 저하를 유발합니다. 이를 피하기 위해 다음을 고려해야 합니다.

  1. 적절한 인덱스 설정: 자주 조회되는 컬럼에 인덱스를 설정합니다.
  2. 쿼리 최적화: 불필요한 전체 테이블 검색을 피하도록 쿼리를 작성합니다.
  3. 통계 정보 최신화: ANALYZE TABLE 명령어를 사용하여 통계 정보를 업데이트합니다.

참고 자료:

반응형
반응형

Kafka에서의 Exactly Once Delivery 구현

메시지 시스템을 사용하다 보면 메시지의 전달 보장 방식에 대해 고려해야 합니다. 일반적으로 다음 세 가지 전달 방식이 있습니다.

  1. At Least Once Delivery: 메시지가 최소 한 번 전달됩니다. 중복 메시지가 발생할 수 있습니다.
  2. At Most Once Delivery: 메시지가 최대 한 번 전달됩니다. 메시지가 손실될 수 있습니다.
  3. Exactly Once Delivery: 메시지가 정확히 한 번 전달됩니다. 중복이나 손실이 없습니다.

Kafka를 사용할 때, 메시지의 정확한 전달을 보장하는 것은 중요한 이슈입니다. 특히 Consumer 측에서 메시지를 처리하는 과정에서 중복이나 손실 없이 메시지를 정확히 한 번씩 처리하도록 구현하는 방법을 알아보겠습니다.


Kafka의 기본 전달 보장 방식

Kafka는 기본적으로 At Least Once Delivery를 제공합니다. 이는 메시지가 최소 한 번 소비자에게 전달됨을 의미하며, 네트워크 장애나 처리 오류로 인해 중복 메시지가 발생할 수 있습니다.


Exactly Once Delivery를 위한 설정과 구현

1. Idempotent Producer 설정

Producer 측에서 동일한 메시지를 여러 번 전송하더라도 중복 없이 처리되도록 설정할 수 있습니다.

  • enable.idempotence 옵션을 true로 설정합니다.

    Properties props = new Properties();
    props.put("enable.idempotence", true);
  • 이 설정을 통해 프로듀서는 메시지 전송 시 고유한 PID(Producer ID)와 시퀀스 넘버를 사용하여 중복 전송을 방지합니다.

2. Transactions 활용

Kafka는 트랜잭션 기능을 통해 메시지의 원자성을 보장합니다.

  • 트랜잭션 초기화

    producer.initTransactions();
  • 트랜잭션 시작과 종료

    try {
        producer.beginTransaction();
        // 메시지 전송 로직
        producer.send(record);
        producer.commitTransaction();
    } catch (Exception e) {
        producer.abortTransaction();
    }

3. Consumer 측의 처리 보장

Consumer에서 Exactly Once Semantics(EOS)를 구현하기 위해서는 다음을 고려해야 합니다.

  • Kafka Streams API 사용

    Kafka Streams는 EOS를 기본적으로 지원하며, 상태 저장 프로세싱에 유용합니다.

  • 오프셋 커밋 관리

    수동으로 오프셋을 커밋하여 메시지 처리와 오프셋 관리의 원자성을 보장합니다.

    consumer.commitSync();
  • 데이터베이스 트랜잭션과 연계

    메시지 처리 결과를 데이터베이스에 저장할 때, Kafka 오프셋 커밋과 데이터베이스 트랜잭션을 연계하여 원자성을 확보합니다.

반응형
반응형

이미 현업에서 자주 사용하지만 따로 정리하지는 않아서 이번 기회에 공식 레퍼런스를 보며 내용을 정리해보았다.

스프링 트랜잭션 처리

스프링 공식 문서: 트랜잭션 관리

@Transactional 애노테이션은 인터페이스, 클래스, 또는 메서드에 트랜잭션의 의미를 부여하는 메타데이터이다. 예를 들어, "이 메서드가 호출될 때 새로운 읽기 전용 트랜잭션을 시작하고, 기존 트랜잭션은 일시 중지한다"는 의미를 가진다. @Transactional의 기본 설정은 다음과 같다:

  • 전파(Propagation): PROPAGATION_REQUIRED
  • 격리 수준(Isolation Level): ISOLATION_DEFAULT
  • 읽기-쓰기(Read-Write) 모드: 트랜잭션은 기본적으로 읽기-쓰기 모드이다.
  • 타임아웃(Timeout): 트랜잭션 타임아웃은 기본 트랜잭션 시스템의 기본값을 따르거나, 타임아웃을 지원하지 않을 경우 설정되지 않는다.
  • 롤백 규칙(Rollback Rules): RuntimeException이나 그 하위 클래스가 발생하면 롤백이 트리거되며, 체크드 예외는 롤백을 트리거하지 않는다.

스프링 트랜잭션 처리 중 예외가 발생했을 때, 아래의 옵션들을 명시적으로 사용하여 롤백 여부를 결정할 수 있다:

  • rollbackFor: 롤백을 실행시키는 예외 클래스 목록
  • rollbackForClassName: 롤백을 실행시키는 예외 클래스 이름들
  • noRollbackFor: 롤백을 실행시키지 않는 예외 클래스 목록
  • noRollbackForClassName: 롤백을 실행시키지 않는 예외 클래스 이름들

예를 들어, 특정 체크드 예외에 대해서도 롤백을 원한다면 rollbackFor 옵션을 사용하여 설정할 수 있다.

자바와 스프링 트랜잭션 처리에 대한 오해

구글에서 "자바 트랜잭션 처리"로 검색해 보면 Checked ExceptionUnchecked Exception 에 대한 비교와 함께, 언체크드 예외에 대해 롤백이 수행된다는 내용을 많이 볼 수 있다.

하지만 이는 정확하지 않다. 자바에서는 기본적으로 트랜잭션에 대한 메커니즘을 제공하지 않으므로, 체크드 예외이든 언체크드 예외이든 트랜잭션의 롤백은 프로그래머가 직접 관리해야 한다. 즉, 언체크드 예외에 롤백하는 메커니즘은 스프링 프레임워크를 사용할 때 적용되는 기본 설정이지, 다른 프레임워크나 순수 자바 SDK만을 사용하여 DB 처리를 할 경우에는 해당되지 않는다.

이러한 오해는 자바와 스프링을 동일시하는 데에서 비롯되며, 자바 개발자들 사이에서 흔히 발생하는 잘못된 인식이라고 생각한다.

추가 설명

  • 자바의 예외 처리: 자바는 예외를 체크드 예외와 언체크드 예외로 구분하지만, 이는 컴파일러가 예외 처리를 강제하는지 여부와 관련이 있다. 트랜잭션 롤백과는 직접적인 연관이 없다.
  • 트랜잭션 관리: 순수 자바에서는 Connection 객체를 사용하여 수동으로 트랜잭션을 관리하며, 예외 발생 시 롤백을 직접 호출해야 한다.
  • 스프링의 트랜잭션 관리: 스프링은 AOP를 활용하여 선언적인 트랜잭션 관리를 제공하며, 기본적으로 RuntimeException 발생 시 롤백을 수행한다. 필요에 따라 설정을 변경하여 체크드 예외에도 롤백이 가능하다.
반응형
반응형

하이버네이트는 내부적으로 두종류의 캐쉬를 지원하는데 하나는 First-level cache 이고 다른 한종류는 Second-level Cache 이다

 

First-level cache?

대부분의 ORM (Object Relational Mapping) 프레임워크가 지원하는것처럼 하이버네이트또한 일차적 캐쉬를 지원한다. 

일차캐쉬는 Hibernate 의 Session 단계에서 지원하는 캐쉬로 가장 비싼 연산작업중 하나인 데이터베이스와의 대화를 줄여주기 위해 존재한다. Session 안에서 동작하는 캐쉬이기 때문에 Session 이 종료되면 캐쉬도 같이 사라지게 된다.

 

Second-level cache?

First level cache 이 세션 단계에서의 캐쉬라면 second level cache 는 session factory 단계에서 지원하는 캐쉬로 session factory 에서 생성되는 session 간에 공유가 된다. 

 

 

표로 다시 정리하면

  First Level  Second Level
범위 Session  Session Factory (all sessions) 
기본 활성화 O X
설정 따른 설정 필요없음 설정필요
캐쉬 백엔드에 따라 다른 설정 추가 필요

 

동시성 캐쉬 전략

이름  
READ_ONLY 읽기에 대한 캐쉬를 생성한다. 설정값 같이 어플리케이션이 시작되고 변화하지 않는 값에 대해 사용
NONSTRICT_READ_WRITE READ_WRITE 와 비슷하지만 때때로 데이터를 읽는 경우에 최신의 데이터를 가지고 오지 않을수도 있늠점에 유의해햐한다. 
어플리케이션이 같은 데이터에 대해 접근하는 일이 많이 없고 강한 트랜잭션 격리가 필요없는 경우 사용
READ_WRITE 읽기와 쓰기에 대해 캐쉬를 생성한다. Seriazliable 트랜잭션 격리수준은 적용되지 않는다
TRANSACTIONAL
트랜잭션 대한 캐쉬를 지원한다. Seriazliable 트랜잭션 격리.
TA Transaction Provider 와 같이 사용하여 분산 트랙잭션을 사용하는 경우 사용하면 좋을 거 같다 

 

Entity 에 대해 캐쉬 사용할때 샘플코드

@Entity(name = "Company")
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public static class Company {

}

 

참조: 

1. https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#caching

반응형

'Java > JPA' 카테고리의 다른 글

JPA Cascade Types  (0) 2021.12.19
JPA 테이블 매핑과 어노테이션 가이드  (0) 2016.09.13
반응형

JPA를 사용해서 엔티티간의 관계를 설정할때 아래와 어노테이션을 작성하는 일이 많은데 어떤 의미를 가지고 있는지 알아보자

@OneToMany(cascade={CascadeType.REFRESH, CascadeType.MERGE}, fetch = FetchType.LAZY)

 

먼저 각각의 CaseType에 들어가기전에 영속성 컨텍스트와 JPA의 상태에 대한 선행지식이 필요하다

 

Persistence Conxtet (영속성 컨텍스트)

공식문서의 정의를 참조해보자 

 

EntityManager (Java(TM) EE 7 Specification APIs)

Interface used to interact with the persistence context. An EntityManager instance is associated with a persistence context. A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. W

docs.oracle.com

A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. The 
EntityManager
 API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities.

어렵게 정의되어 있지만 간단하게 요약하자면 영속성 컨텍스트가 영속성 컨텍스트안에 있는 엔티티들의 변화를 추적하고 관리한다는 이야기다.

 

엔티티 객체의 상태

상태 설명
Transient 엔티티 객체가 데이터베이스에 아직 저장되기 전의 상태 
Persistent 엔티티 객체가 데이터베이스에 저장된 상태
Detached Persistent 상태였던  엔티티 객체가 더이상 영속성 컨텍스트에 속해있지 않는 상태

JPA의 동작들

동작 설명 특징
Save 하이버네이트 구현체에만 있는 기능 Persist 와 같은 기능.  Persist 는 생성된 ID 를 돌려주지 않으나 Save 는 돌려준다
Persist 엔티티를 영속성 컨텍스트에 포함시킨다 1. 엔티티가 Transient 상태라면 엔티티는 Persistent 상태가 된고 관련 동작들을 전파한다. (PERSIST, ALL로 설정된 경우)
2. 엔티티가 이미 Persistent 상태라면 엔티티에 직접적인 영향은 없다. 그러나 관련 동작들은 여전히 자식으로 전파된다
3. 엔티티가 Detached 상태라면 에러를 발생시킨다
Merge Persistent 상태의 엔티티 객체를 Deatched 상태의 객체의 값들로 업데이트한다  
Update 하이버네이트에만 존재하는 동작으로 Merge 와 같은 동작을 수행한다  
SaveOrUpdate 하이버네이트에만 존재하는 동작으로   

Cascade 종류

 

 

Hibernate ORM 5.6.3.Final User Guide

Fetching, essentially, is the process of grabbing data from the database and making it available to the application. Tuning how an application does fetching is one of the biggest factors in determining how an application will perform. Fetching too much dat

docs.jboss.org

JPA 표준에 사용하면 아래와 같이 6가지 Cascade Type 있다

종류 특징
ALL 아래에 기술된 모든 동장들을 자식 엔티티에게 전파한다
PERSIST JPA의 Persist 동작 (save, persist )을 부모 엔티티에서 자식 엔티티에게 전파된다
MERGE 부모 엔티티가 업데이트 될때 자식 엔티티들도 업데이트 된다
REMOVE 자식 엔티티들을 부모 엔티티 삭제시 동시에 삭제한다
REFRESH 데이터베이스로부터 데이터르 다시 읽어 들이는 refresh 동작을 부모에서 자식 엔티티로 전파
DETACH Detach 를 부모에서 자식 엔티티로 전파한다

하이버네이트에만 존재하는 CaseCade Type

종류 특징
REPLICATE Replicate 를 사용할떄 자식엔티티에게도 같은 동작을 전파한다.
**자동생성되는 ID 사용하지 않고 엔티티를 복제할 필요가 있을때 사용하면 좋다.
SAVE_UPDATE 하이버네이트 구현체의 save, update, saveOrUpdate 동작을 수행시에 자식 엔티티에게 같은 동작을전파한다
LOCK 이미 Detached 된 부모 엔티티 객체를 다시 영속성 객체에 추가시에 자식엔티티도 같이 추가된다

 

참조:

1. https://docs.jboss.org/hibernate/orm/5.6/userguide/html_single/Hibernate_User_Guide.html

2. https://stackoverflow.com/questions/161224/what-are-the-differences-between-the-different-saving-methods-in-hibernate

반응형

'Java > JPA' 카테고리의 다른 글

JPA & Hibernate Cache  (0) 2022.01.19
JPA 테이블 매핑과 어노테이션 가이드  (0) 2016.09.13
반응형

Spring Boot 및 일반 Spring 환경에서 외부 서비스 기반 설정 관리 방법

어플리케이션을 구동할 때 필요한 설정값들은 보통 환경변수(Environment Variables)나 파일에 저장하여 관리합니다. 하지만 최근에는 설정값을 Zookeeper, AWS Secrets Manager와 같은 외부 서비스에서 불러오거나, 보안을 강화하기 위해 메모리 내에서만 설정값을 저장하는 방식이 점점 더 선호되고 있습니다. 이러한 요구사항을 충족시키기 위해 Spring Boot와 일반 Spring 환경에서 설정값을 효과적으로 관리하는 방법을 소개합니다.

Spring Boot에서 환경 설정값 관리하기

Spring Boot는 EnvironmentPostProcessor를 활용하여 어플리케이션 시작 시점에 환경 설정값을 동적으로 변경하거나 추가할 수 있습니다. 이를 통해 외부 서비스에서 설정값을 불러와 적용하는 것이 가능합니다.

EnvironmentPostProcessor 활용 예제

import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;

import java.util.Map;
import java.util.stream.Collectors;
import java.util.Arrays;
import java.util.List;

public class PriceCalculationEnvironmentPostProcessor implements EnvironmentPostProcessor {

    private static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";
    private static final List<String> names = Arrays.asList("config.key1", "config.key2"); // 예시 키 리스트

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        var system = environment.getPropertySources().get(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME);

        Map<String, Object> prefixed = names.stream()
            .collect(Collectors.toMap(this::rename, system::getProperty));
        environment.getPropertySources()
            .addAfter(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, new MapPropertySource("prefixer", prefixed));
    }

    private String rename(String originalName) {
        return "prefix." + originalName; // 원하는 방식으로 키 이름 변경
    }
}

적용 방법

  1. Spring Boot의 spring.factories 파일에 등록

src/main/resources/META-INF/spring.factories 파일에 다음 내용을 추가합니다:

org.springframework.boot.env.EnvironmentPostProcessor=\
com.example.PriceCalculationEnvironmentPostProcessor
  1. 어플리케이션 실행 시 자동으로 적용

Spring Boot는 spring.factories에 등록된 EnvironmentPostProcessor를 자동으로 감지하여 적용합니다.

Spring Boot를 사용하지 않는 환경에서 설정값 관리하기

Spring Boot가 아닌 일반 Spring 환경에서도 설정값을 외부 서비스에서 불러오거나 메모리 내에서 관리할 수 있습니다. 이를 위해 ApplicationContextInitializer를 활용할 수 있습니다.

ApplicationContextInitializer 활용 예제

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.boot.context.properties.bind.Binder;

public class PropertyOverrideContextInitializer 
        implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        var environment = applicationContext.getEnvironment();
        MyConfigProps configProps = Binder.get(environment)
                                         .bind("my-config", MyConfigProps.class)
                                         .orElse(new MyConfigProps());
        System.out.println(configProps.getHomekey());
        // 추가 설정 로직 구현
    }
}

적용 방법

ApplicationContextInitializer를 적용하는 방법은 여러 가지가 있습니다. 아래에 네 가지 주요 방법을 소개합니다.

  1. web.xml 또는 Java Config에서 contextInitializerClasses 추가

web.xml을 사용하는 경우:

<context-param>
    <param-name>contextInitializerClasses</param-name>
    <param-value>com.example.PropertyOverrideContextInitializer</param-value>
</context-param>

Java Config를 사용하는 경우:

import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;

@ContextConfiguration(initializers = PropertyOverrideContextInitializer.class)
public class AppConfig {
    // Bean 정의 등
}
  1. Spring만 사용하는 경우
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
        ctx.addInitializer(new PropertyOverrideContextInitializer());
        ctx.register(AppConfiguration.class);
        ctx.refresh();

        JobLauncher launcher = ctx.getBean(JobLauncher.class);
        // 어플리케이션 로직 실행
    }
}
  1. spring.factories 파일을 통한 자동 설정 (Spring Boot)

src/main/resources/META-INF/spring.factories 파일에 다음 내용을 추가합니다:

org.springframework.context.ApplicationContextInitializer=\
com.example.PropertyOverrideContextInitializer
  1. 어플리케이션 실행 시 코드로 추가 (Spring Boot)

SpringApplication을 사용하는 경우:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class YourApp {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(YourApp.class);
        application.addInitializers(new PropertyOverrideContextInitializer());
        application.run(args);
    }
}

SpringApplicationBuilder을 사용하는 경우:

import org.springframework.boot.builder.SpringApplicationBuilder;

public class YourApp {
    public static void main(String[] args) {
        new SpringApplicationBuilder(YourApp.class)
            .initializers(new PropertyOverrideContextInitializer())
            .run(args);
    }
}

프로퍼티 파일을 통한 설정:

application.properties 또는 application.yml 파일에 다음과 같이 설정합니다:

context.initializer.classes=com.example.PropertyOverrideContextInitializer

결론

외부 서비스에서 설정값을 불러오거나, 보안을 강화하기 위해 메모리 내에서만 설정값을 관리하고자 할 때, Spring Boot와 일반 Spring 환경에서 제공하는 EnvironmentPostProcessor와 ApplicationContextInitializer를 활용하면 효과적으로 설정값을 관리할 수 있습니다. 각 방법은 어플리케이션의 구조와 요구사항에 따라 적절히 선택하여 적용할 수 있으며, 이를 통해 보다 유연하고 안전한 설정 관리가 가능합니다.

참고 자료

  1. Baeldung - Spring Tests: Override Properties
  2. Stack Overflow - How to add custom ApplicationContextInitializer to a Spring Boot application
  3. Stack Overflow - Spring ApplicationContextInitializer and properties
  4. Stack Overflow - ApplicationContextInitializer in a non-web Spring context

이 글이 Spring 기반 어플리케이션에서 설정값을 효과적으로 관리하는 데 도움이 되길 바랍니다. 추가적인 질문이나 의견이 있으시면 댓글로 남겨주세요!

반응형

+ Recent posts