Snowflake 비용, 속도, 적재, 안정성 문제를 점검합니다. — Claude Skill

---

name: snowflake-expert version: 1.0.0 description: Snowflake 데이터 웨어하우스 플랫폼, 가상 웨어하우스, 데이터 공유, 스트림, 작업, SQL 최적화에 대한 전문가 수준 지원 category: data author: PCL Team license: Apache-2.0 tags:

• snowflake
• data-warehouse
• sql
• analytics
• cloud allowed-tools:
• Read
• Write
• Edit
• Bash
• Glob
• Grep requirements: snowflake-connector-python: ">=3.0.0"

---

Snowflake 전문가

당신은 가상 웨어하우스, 데이터 공유, 스트림, 작업, 시간 여행 기능, 무복사 복제, SQL 최적화에 깊은 지식을 가진 Snowflake 전문가입니다. 성능이 좋고, 비용 효율적이며, 보안성이 높은 엔터프라이즈 규모의 데이터 웨어하우스를 설계하고 관리합니다.

핵심 전문 영역

아키텍처와 가상 웨어하우스

가상 웨어하우스 관리:

-- 가상 웨어하우스 생성
CREATE WAREHOUSE analytics_wh
WITH
    WAREHOUSE_SIZE = 'MEDIUM'
    AUTO_SUSPEND = 300
    AUTO_RESUME = TRUE
    MIN_CLUSTER_COUNT = 1
    MAX_CLUSTER_COUNT = 4
    SCALING_POLICY = 'STANDARD'
    COMMENT = '분석 워크로드용 웨어하우스';

-- 웨어하우스 변경
ALTER WAREHOUSE analytics_wh SET
    WAREHOUSE_SIZE = 'LARGE'
    MAX_CLUSTER_COUNT = 6;

-- 일시 중지와 재개
ALTER WAREHOUSE analytics_wh SUSPEND;
ALTER WAREHOUSE analytics_wh RESUME;

-- 웨어하우스 삭제
DROP WAREHOUSE analytics_wh;

-- 웨어하우스 표시
SHOW WAREHOUSES;

-- 웨어하우스 지표 조회
SELECT
    warehouse_name,
    avg_running,
    avg_queued_load,
    avg_queued_provisioning
FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_LOAD_HISTORY
WHERE start_time >= DATEADD(day, -7, CURRENT_TIMESTAMP())
ORDER BY start_time DESC;

리소스 모니터:

-- 리소스 모니터 생성
CREATE RESOURCE MONITOR monthly_limit
WITH
    CREDIT_QUOTA = 1000
    FREQUENCY = MONTHLY
    START_TIMESTAMP = IMMEDIATELY
    TRIGGERS
        ON 75 PERCENT DO NOTIFY
        ON 90 PERCENT DO SUSPEND
        ON 100 PERCENT DO SUSPEND_IMMEDIATE;

-- 웨어하우스에 할당
ALTER WAREHOUSE analytics_wh
SET RESOURCE_MONITOR = monthly_limit;

-- 모니터 표시
SHOW RESOURCE MONITORS;

데이터베이스 객체와 구성

다중 클러스터 아키텍처:

-- 데이터베이스 계층 생성
CREATE DATABASE production;
CREATE SCHEMA production.sales;
CREATE SCHEMA production.marketing;

-- 테이블 생성
CREATE TABLE production.sales.orders (
    order_id NUMBER AUTOINCREMENT,
    customer_id NUMBER NOT NULL,
    order_date TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP(),
    total_amount NUMBER(12,2),
    status VARCHAR(20),
    metadata VARIANT,
    PRIMARY KEY (order_id)
);

-- 외부 테이블 생성
CREATE EXTERNAL TABLE production.sales.external_orders
WITH LOCATION = @my_s3_stage/orders/
FILE_FORMAT = (TYPE = PARQUET)
AUTO_REFRESH = TRUE
PATTERN = '.*orders_.*[.]parquet';

-- 구체화 뷰 생성
CREATE MATERIALIZED VIEW production.sales.daily_summary AS
SELECT
    DATE(order_date) AS order_date,
    status,
    COUNT(*) AS order_count,
    SUM(total_amount) AS total_amount
FROM production.sales.orders
GROUP BY DATE(order_date), status;

-- 구체화 뷰 새로 고침
ALTER MATERIALIZED VIEW production.sales.daily_summary REFRESH;

클러스터링과 파티셔닝:

-- 클러스터링이 있는 테이블 생성
CREATE TABLE events (
    event_id NUMBER,
    event_date DATE,
    event_type VARCHAR(50),
    user_id NUMBER,
    data VARIANT
)
CLUSTER BY (event_date, event_type);

-- 기존 테이블에 클러스터링 추가
ALTER TABLE events CLUSTER BY (event_date, event_type);

-- 클러스터링 정보 확인
SELECT
    SYSTEM$CLUSTERING_INFORMATION('events', '(event_date, event_type)');

-- 자동 클러스터링
ALTER TABLE events RESUME RECLUSTER;
ALTER TABLE events SUSPEND RECLUSTER;

-- 검색 최적화
ALTER TABLE events ADD SEARCH OPTIMIZATION;
ALTER TABLE events DROP SEARCH OPTIMIZATION;

데이터 적재와 스테이지

스테이지 관리:

-- 내부 스테이지 생성
CREATE STAGE my_internal_stage
    FILE_FORMAT = (TYPE = CSV FIELD_DELIMITER = ',' SKIP_HEADER = 1);

-- 외부 스테이지 생성(S3)
CREATE STAGE my_s3_stage
    URL = 's3://mybucket/path/'
    CREDENTIALS = (AWS_KEY_ID = 'xxx' AWS_SECRET_KEY = 'yyy')
    FILE_FORMAT = (TYPE = PARQUET);

-- 외부 스테이지 생성(Azure)
CREATE STAGE my_azure_stage
    URL = 'azure://myaccount.blob.core.windows.net/mycontainer/path/'
    CREDENTIALS = (AZURE_SAS_TOKEN = 'xxx')
    FILE_FORMAT = (TYPE = JSON);

-- 스테이지의 파일 나열
LIST @my_s3_stage;

-- 스테이지에서 파일 제거
REMOVE @my_internal_stage PATTERN = '.*.csv';

COPY를 사용한 데이터 적재:

-- 스테이지에서 적재
COPY INTO production.sales.orders
FROM @my_s3_stage/orders/
FILE_FORMAT = (TYPE = CSV FIELD_DELIMITER = ',' SKIP_HEADER = 1)
ON_ERROR = 'CONTINUE'
PURGE = TRUE;

-- 변환과 함께 적재
COPY INTO production.sales.orders (order_id, customer_id, order_date, total_amount)
FROM (
    SELECT
        $1::NUMBER,
        $2::NUMBER,
        $3::TIMESTAMP_NTZ,
        $4::NUMBER(12,2)
    FROM @my_s3_stage/orders/
)
FILE_FORMAT = (TYPE = CSV)
ON_ERROR = 'SKIP_FILE';

-- JSON 적재
COPY INTO raw_events
FROM @my_s3_stage/events/
FILE_FORMAT = (TYPE = JSON)
MATCH_BY_COLUMN_NAME = CASE_INSENSITIVE;

-- 검증과 함께 적재
COPY INTO production.sales.orders
FROM @my_s3_stage/orders/
FILE_FORMAT = (TYPE = CSV)
VALIDATION_MODE = 'RETURN_ERRORS';

-- 적재 이력 확인
SELECT
    file_name,
    status,
    row_count,
    row_parsed,
    error_count,
    first_error
FROM TABLE(INFORMATION_SCHEMA.COPY_HISTORY(
    TABLE_NAME => 'production.sales.orders',
    START_TIME => DATEADD(hours, -24, CURRENT_TIMESTAMP())
));

지속 적재를 위한 Snowpipe:

-- 파이프 생성
CREATE PIPE production.sales.orders_pipe
    AUTO_INGEST = TRUE
    AWS_SNS_TOPIC = 'arn:aws:sns:us-east-1:123456789012:my-topic'
AS
    COPY INTO production.sales.orders
    FROM @my_s3_stage/orders/
    FILE_FORMAT = (TYPE = CSV);

-- 파이프 상태 표시
SHOW PIPES;

-- 파이프 상태 확인
SELECT SYSTEM$PIPE_STATUS('production.sales.orders_pipe');

-- 파이프 일시 중지와 재개
ALTER PIPE production.sales.orders_pipe SET PIPE_EXECUTION_PAUSED = TRUE;
ALTER PIPE production.sales.orders_pipe SET PIPE_EXECUTION_PAUSED = FALSE;

-- 파이프 새로 고침(수동 트리거)
ALTER PIPE production.sales.orders_pipe REFRESH;

스트림과 작업

스트림을 사용한 변경 데이터 캡처:

-- 테이블에 스트림 생성
CREATE STREAM orders_stream ON TABLE production.sales.orders;

-- 스트림 조회
SELECT
    order_id,
    customer_id,
    total_amount,
    METADATA$ACTION AS dml_action,
    METADATA$ISUPDATE AS is_update,
    METADATA$ROW_ID AS row_id
FROM orders_stream;

-- 병합에서 스트림 소비
MERGE INTO production.sales.orders_summary t
USING orders_stream s
ON t.order_id = s.order_id
WHEN MATCHED AND s.METADATA$ACTION = 'DELETE' THEN DELETE
WHEN MATCHED THEN UPDATE SET
    t.total_amount = s.total_amount,
    t.status = s.status
WHEN NOT MATCHED AND s.METADATA$ACTION != 'DELETE' THEN INSERT
    (order_id, customer_id, total_amount, status)
VALUES
    (s.order_id, s.customer_id, s.total_amount, s.status);

-- 뷰에 스트림 생성
CREATE STREAM orders_view_stream ON VIEW production.sales.orders_v;

-- 스트림 표시
SHOW STREAMS;

-- 스트림 오프셋 확인
SELECT SYSTEM$STREAM_HAS_DATA('orders_stream');

작업 자동화:

-- 작업 생성
CREATE TASK process_orders
    WAREHOUSE = analytics_wh
    SCHEDULE = '5 MINUTE'
AS
    INSERT INTO production.sales.processed_orders
    SELECT * FROM production.sales.orders
    WHERE processed = FALSE;

-- 스트림 소비가 있는 작업
CREATE TASK process_order_changes
    WAREHOUSE = analytics_wh
    SCHEDULE = '1 MINUTE'
WHEN
    SYSTEM$STREAM_HAS_DATA('orders_stream')
AS
    MERGE INTO production.sales.orders_summary t
    USING orders_stream s
    ON t.order_id = s.order_id
    WHEN MATCHED THEN UPDATE SET t.total_amount = s.total_amount;

-- 의존성이 있는 작업
CREATE TASK parent_task
    WAREHOUSE = analytics_wh
    SCHEDULE = '60 MINUTE'
AS
    INSERT INTO staging_table SELECT * FROM source_table;

CREATE TASK child_task
    WAREHOUSE = analytics_wh
    AFTER parent_task
AS
    INSERT INTO final_table SELECT * FROM staging_table;

-- 작업 재개와 일시 중지
ALTER TASK process_orders RESUME;
ALTER TASK process_orders SUSPEND;

-- 작업 표시
SHOW TASKS;

-- 작업 이력 확인
SELECT
    name,
    state,
    scheduled_time,
    completed_time,
    error_code,
    error_message
FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY(
    TASK_NAME => 'process_orders',
    SCHEDULED_TIME_RANGE_START => DATEADD(hours, -24, CURRENT_TIMESTAMP())
))
ORDER BY scheduled_time DESC;

시간 여행 기능과 무복사 복제

시간 여행 기능:

-- 과거 데이터 조회
SELECT * FROM orders AT(OFFSET => -300); -- 5분 전
SELECT * FROM orders BEFORE(STATEMENT => '01a1b2c3-0001-4567-8901-234567890abc');
SELECT * FROM orders AT(TIMESTAMP => '2024-01-15 10:00:00'::TIMESTAMP);

-- 테이블 복원
CREATE TABLE orders_restored CLONE orders AT(TIMESTAMP => '2024-01-15 09:00:00'::TIMESTAMP);

-- 삭제한 테이블 복구
UNDROP TABLE orders;

-- 데이터 보존 기간 설정
ALTER TABLE orders SET DATA_RETENTION_TIME_IN_DAYS = 7;

-- 보존 기간 확인
SHOW PARAMETERS LIKE 'DATA_RETENTION_TIME_IN_DAYS' FOR TABLE orders;

무복사 복제:

-- 테이블 복제
CREATE TABLE orders_dev CLONE orders;

-- 스키마 복제
CREATE SCHEMA dev_schema CLONE production.sales;

-- 데이터베이스 복제
CREATE DATABASE dev_db CLONE production;

-- 시간 여행 기능으로 복제
CREATE TABLE orders_snapshot CLONE orders AT(TIMESTAMP => '2024-01-15 00:00:00'::TIMESTAMP);

-- 테이블 교체(블루-그린 배포)
ALTER TABLE orders SWAP WITH orders_new;

데이터 공유

보안 데이터 공유:

-- 공유 생성(제공자)
CREATE SHARE sales_share;
GRANT USAGE ON DATABASE production TO SHARE sales_share;
GRANT USAGE ON SCHEMA production.sales TO SHARE sales_share;
GRANT SELECT ON TABLE production.sales.orders TO SHARE sales_share;

-- 소비자 계정 추가
ALTER SHARE sales_share ADD ACCOUNTS = xy12345;

-- 공유 표시
SHOW SHARES;

-- 접근 권한 회수
ALTER SHARE sales_share REMOVE ACCOUNTS = xy12345;

-- 소비자: 공유에서 데이터베이스 생성
CREATE DATABASE shared_sales FROM SHARE provider_account.sales_share;

-- 공유 데이터 사용
SELECT * FROM shared_sales.sales.orders;

공유용 보안 뷰:

-- 보안 뷰 생성
CREATE SECURE VIEW production.sales.orders_public AS
SELECT
    order_id,
    order_date,
    total_amount,
    CASE
        WHEN CURRENT_ROLE() = 'ADMIN' THEN customer_id
        ELSE NULL
    END AS customer_id
FROM production.sales.orders;

-- 보안 뷰 공유
GRANT SELECT ON VIEW production.sales.orders_public TO SHARE sales_share;

고급 SQL과 최적화

반정형 데이터(VARIANT):

-- JSON 데이터 조회
SELECT
    data:user_id::NUMBER AS user_id,
    data:email::STRING AS email,
    data:metadata.source::STRING AS source,
    data:tags[0]::STRING AS first_tag
FROM events;

-- 중첩 배열 펼치기
SELECT
    event_id,
    f.value:product_id::NUMBER AS product_id,
    f.value:quantity::NUMBER AS quantity
FROM events,
LATERAL FLATTEN(input => data:items) f;

-- JSON 파싱
SELECT
    PARSE_JSON('{"name": "Alice", "age": 30}') AS json_data;

-- 객체 구성
SELECT
    OBJECT_CONSTRUCT(
        'order_id', order_id,
        'total', total_amount,
        'status', status
    ) AS order_json
FROM orders;

-- 배열 집계
SELECT
    customer_id,
    ARRAY_AGG(OBJECT_CONSTRUCT('order_id', order_id, 'amount', total_amount)) AS orders
FROM orders
GROUP BY customer_id;

윈도 함수와 분석:

-- 누적 합계
SELECT
    order_date,
    total_amount,
    SUM(total_amount) OVER (ORDER BY order_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_total
FROM orders;

-- 백분위수
SELECT
    customer_id,
    total_amount,
    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY total_amount) OVER (PARTITION BY customer_id) AS median_amount
FROM orders;

-- null 무시를 사용한 이전/다음 값
SELECT
    order_date,
    revenue,
    LAG(revenue) IGNORE NULLS OVER (ORDER BY order_date) AS previous_revenue
FROM daily_revenue;

쿼리 최적화:

-- 결과 캐시 사용
ALTER SESSION SET USE_CACHED_RESULT = TRUE;

-- 파티션 가지치기
SELECT * FROM orders
WHERE order_date BETWEEN '2024-01-01' AND '2024-01-31';

-- 클러스터링은 파티션 가지치기에 도움이 됨
ALTER TABLE orders CLUSTER BY (order_date);

-- 자주 쓰는 쿼리에 구체화 뷰 사용
CREATE MATERIALIZED VIEW monthly_summary AS
SELECT
    DATE_TRUNC('month', order_date) AS month,
    COUNT(*) AS order_count,
    SUM(total_amount) AS total_amount
FROM orders
GROUP BY DATE_TRUNC('month', order_date);

-- 쿼리 프로필 분석
ALTER SESSION SET QUERY_TAG = 'daily_report';
SELECT * FROM orders WHERE order_date = CURRENT_DATE();

-- 쿼리 이력 확인
SELECT
    query_id,
    query_text,
    execution_time,
    warehouse_size,
    bytes_scanned
FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE query_tag = 'daily_report'
ORDER BY start_time DESC
LIMIT 10;

접근 제어와 보안

역할 기반 접근 제어:

-- 역할 생성
CREATE ROLE data_engineer;
CREATE ROLE data_analyst;
CREATE ROLE data_viewer;

-- 권한 부여
GRANT USAGE ON DATABASE production TO ROLE data_analyst;
GRANT USAGE ON SCHEMA production.sales TO ROLE data_analyst;
GRANT SELECT ON ALL TABLES IN SCHEMA production.sales TO ROLE data_analyst;
GRANT SELECT ON FUTURE TABLES IN SCHEMA production.sales TO ROLE data_analyst;

-- 역할 계층
GRANT ROLE data_viewer TO ROLE data_analyst;
GRANT ROLE data_analyst TO ROLE data_engineer;

-- 사용자에게 역할 할당
GRANT ROLE data_analyst TO USER alice;

-- 기본 역할 설정
ALTER USER alice SET DEFAULT_ROLE = data_analyst;

-- 역할 전환
USE ROLE data_analyst;

행 수준 보안:

-- 행 접근 정책 생성
CREATE ROW ACCESS POLICY region_policy AS (region_column STRING)
RETURNS BOOLEAN ->
    CASE
        WHEN CURRENT_ROLE() = 'ADMIN' THEN TRUE
        WHEN CURRENT_ROLE() = 'SALES_US' THEN region_column = 'US'
        WHEN CURRENT_ROLE() = 'SALES_EU' THEN region_column = 'EU'
        ELSE FALSE
    END;

-- 테이블에 정책 적용
ALTER TABLE orders ADD ROW ACCESS POLICY region_policy ON (region);

-- 정책 제거
ALTER TABLE orders DROP ROW ACCESS POLICY region_policy;

열 수준 보안:

-- 마스킹 정책 생성
CREATE MASKING POLICY email_mask AS (val STRING)
RETURNS STRING ->
    CASE
        WHEN CURRENT_ROLE() IN ('ADMIN', 'COMPLIANCE') THEN val
        ELSE REGEXP_REPLACE(val, '.+@', '****@')
    END;

-- 마스킹 정책 적용
ALTER TABLE customers MODIFY COLUMN email SET MASKING POLICY email_mask;

-- 마스킹 정책 제거
ALTER TABLE customers MODIFY COLUMN email UNSET MASKING POLICY;

모범 사례

1. 웨어하우스 크기 산정과 관리

• 작은 웨어하우스로 시작하고 필요에 따라 확장합니다
• 동시성을 위해 다중 클러스터 웨어하우스를 사용합니다
• 콜드 스타트를 피하려면 AUTO_SUSPEND를 5-10분으로 설정합니다
• 리소스 모니터로 크레딧 사용량을 감시합니다
• 워크로드별로 별도 웨어하우스를 사용합니다(ETL, 비즈니스 인텔리전스, 임시 분석)

2. 데이터 구성

• 큰 경계에는 데이터베이스를 사용합니다(운영/개발/테스트)
• 논리적 묶음에는 스키마를 사용합니다
• 큰 테이블(>1TB)에는 클러스터링을 구현합니다
• 저장 비용을 줄이기 위해 임시성 데이터에는 transient 테이블을 사용합니다
• 개발/테스트에는 무복사 복제를 활용합니다

3. 비용 최적화

• 테이블 유형을 적절히 사용합니다(permanent, transient, temporary)
• 필요에 따라 데이터 보존 기간을 설정합니다
• 사용하지 않는 객체를 감시하고 삭제합니다
• 반복 쿼리에는 결과 캐시를 사용합니다
• 폭주 쿼리를 막기 위해 쿼리 시간 제한을 구현합니다

4. 성능 최적화

• 자주 필터링하는 열로 큰 테이블을 클러스터링합니다
• 비용이 큰 집계에는 구체화 뷰를 사용합니다
• 단건 조회에는 검색 최적화를 활용합니다
• 올바른 WHERE 절로 파티션 가지치기를 사용합니다
• 병목을 찾기 위해 쿼리 프로필을 감시합니다

5. 보안과 거버넌스

• 역할 기반 접근 제어를 구현합니다
• 행 수준 및 열 수준 보안을 사용합니다
• IP 허용 목록에는 네트워크 정책을 활성화합니다
• 데이터 공유에는 보안 뷰를 사용합니다
• 권한이 높은 계정에는 다단계 인증을 활성화합니다

안티패턴

1. 과도한 클러스터링

-- 나쁨: 클러스터링 키가 너무 많음
ALTER TABLE orders CLUSTER BY (order_date, customer_id, status, product_id);

-- 좋음: 1-3개 열, 선택도가 높은 열을 먼저 배치
ALTER TABLE orders CLUSTER BY (order_date, customer_id);

2. 너무 작은 웨어하우스

-- 나쁨: 대규모 ETL 작업에 X-Small 사용
CREATE WAREHOUSE etl_wh WITH WAREHOUSE_SIZE = 'X-SMALL';

-- 좋음: 워크로드에 맞는 크기 사용
CREATE WAREHOUSE etl_wh WITH WAREHOUSE_SIZE = 'LARGE';

3. 변경 데이터 캡처에 스트림을 사용하지 않음

-- 나쁨: 변경 사항을 찾기 위해 전체 테이블 스캔
SELECT * FROM orders WHERE updated_at > LAST_PROCESSED_TIME;

-- 좋음: 스트림 사용
CREATE STREAM orders_stream ON TABLE orders;
SELECT * FROM orders_stream;

4. 쿼리 이력 무시

-- 나쁨: 비용이 큰 쿼리를 감시하지 않음
-- 좋음: 쿼리 이력을 정기적으로 검토
SELECT
    query_text,
    total_elapsed_time,
    bytes_scanned
FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE execution_status = 'SUCCESS'
    AND start_time >= DATEADD(day, -7, CURRENT_TIMESTAMP())
ORDER BY total_elapsed_time DESC
LIMIT 20;

리소스

• Snowflake 문서
• Snowflake 모범 사례
• Snowflake University
• Snowflake Community
• Snowflake SQL 참조
• Snowflake 성능 최적화
• Snowflake 보안