Sevity Blog

TLS Termination

원래 서버가 처리하던 TLS 암호화/복호화를 CDN 이 대신 수행하는 방식입니다. Redirect Service 는 트래픽이 매우 많고 요청이 단순하기 때문에, CDN 레이어에서 SSL 종료를 하면 서버가 암호화 작업을 하지 않아도 되어 부하를 줄일 수 있고, 글로벌 사용자 입장에서도 TLS 핸드셰이크가 CDN 엣지 서버에서 빠르게 처리되어 응답 속도도 개선됩니다. 또한, SSL 인증서 관리나 갱신을 CDN 에서 자동으로 해주기 때문에 운영 효율성도 좋아집니다.

사용자 ── TLS 암호화 ──> CDN (CloudFront, Fastly 등) ── HTTP 평문 ──> Redirect Service

Redis vs Cassandra

Redis는 key-value중심에 메모리에 들어갈 사이즈일때 효율 극대화

Cassandra는 RDB와 Redis중간정도에서 적당히 빠르고 메모리가 아닌 디스크기반이며 단순 key-value가 아니어도 SQL비슷한 느낌지원

Redis심화

Redis Cluster에서 채널개념

3개의 Redis server로 클러스터를 구성하면 이걸 Node라고 하는데, 

레디스키를 해시해서 어떤 노드에서 어떤 키를 처리할지 맵을 만들어서 클라이언트가 들고 있음

따라서 특정 키에 대한 처리는 특정 노드에서만 하고 클라이언트에서는 직접 이서버로 요청해서 key-value조회를 함(DNS같은것 필요없는 정적인 구조)

Pub/Sub개념

이건 Redis cluster에서는 모든 노드를 구독하지 않는한 전달이 안되서 비추,

단일노드 Redis나 Sentinel 구조에서는 kafka비슷하게 사용가능(근데 이거 키에 종속적인 개념은 아니다)

인풋파싱

아래는 4개 숫자를 stdin에서 읽어오는 코드

import sys
input = sys.stdin.readline

# 입력 받기: H, W, N, M
H, W, N, M = map(int, input().split())

숫자하나 + 문자열리스트

3
MBC
KBS1
KBS2

인풋이 위와 같을때

import sys
input = sys.stdin.readline

# 채널의 수 N을 입력받음
N = int(input().strip())

# N개의 채널 이름을 리스트로 입력받음
channels = [input().strip() for _ in range(N)]

기본문법

기본 for루프

for y in range(H):

N+1개씩 건너뛰기

for y in range(0, H, N+1):  # 행을 N+1씩 건너뛰며 반복

주의사항들

재귀관련해서 메모아이제이션과 호출깊이가 깊을때 조정코드(N=1000이라도 아래코드 필요)

import sys
sys.setrecursionlimit(10**6)  #여기1

from functools import lru_cache
input = sys.stdin.readline

N = int(input().strip())

@lru_cache(maxsize=None) #여기2
def go(remain):
    if remain == 0:
        return False
    if not go(remain-1):
        return True
    if remain >=3 and not go(remain-3):
        return True
    return False
    
print("SK" if go(N) else "CY")

단순구현부터 해봤는데 역시 TLE난다.

#include <string>
#include <vector>

using namespace std;
typedef long long ll;

// 뭐지 단순 구현문제인가.. long long이라 아닐거 같기도 하고 흠..
long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    //일단 단순 구현해보자.
    for(ll a=0;a<1000000;a++)for(ll b=0;b<1000000;b++){
        if(k*k*a*a+k*k*b*b<=d*d) {
            //printf("(%d,%d),", a*k,b*k);
            answer++;
        }
        else break;
    }
    return answer;
}

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

// 뭐지 단순 구현문제인가.. long long이라 아닐거 같기도 하고 흠..
long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    //일단 단순 구현해보자.
    for(ll a=0;a<1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) continue;
        double bb = sqrt((double)s)/(double)k;
        //if(bb<0) continue;
        //printf("%lld\n", bb);
        answer+=bb+1;
    }
    return answer;
}

이건 일부 케이스WA나네..

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    for(ll a=0;a<=1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) break;
        ll bb = sqrt(s)/k;
        answer+=bb+1;
    }
    return answer;
}

뭐지? 1000000포함안시킨거랑 double연산 때문에 WA났던거네?

double연산시 오류나는건 좀 그렇네.. 흠..

아이디어 자체는 chatGPT랑 동일하다.

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    for(ll a=0;a<=1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) break;
        double bb = (double)sqrt(s)/k;
        answer+=(ll)(bb+1e-9)+1;
    }
    return answer;
}

double은 위처럼 하면 되는거 보니, 형변환시 문제인거 같다. 2.0이 1.999로 되는등..

으허.. 머리에 쥐나긴했는데.. chatGPT한테 힌트 받고 스스로 풀긴했다 ㄷ

재귀를 통해서 하는건데.. 알아두면 두고두고 써먹을거 같긴하다.

#include <bits/stdc++.h>
using namespace std;

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

typedef long long ll;

ll length[21];
ll val[21];//val[3]이면 F(3)일때 1의 개수

ll solution_sub(int n, ll l, ll r) {
    if (n <= 0) return 1;
    ll answer = 0;
    if (n == 1) {
        for (int i = l; i <= r; i++) {
            if (i != 3) answer += 1;
        }
        return answer;
    }

    //n에 대해서 5등분 해서 재귀로 들어가면 되지 않을까?
    ll lx = (l - 1) / length[n - 1] + 1;
    ll rx = (r - 1) / length[n - 1] + 1;

    ll nl = l - length[n - 1] * ((l - 1) / length[n - 1]);
    ll nr = r - length[n - 1] * ((r - 1) / length[n - 1]);


    if (lx == rx) {
        if(lx!=3) answer += solution_sub(n - 1, nl, nr);
    } else {
        //왼쪽

        //answer += solution_sub(n - 1, l - length[n-1]*((l-1)/length[n-1]), r - length[n - 1] * ((r - 1) / length[n - 1]));
        ll nl = l - length[n - 1] * ((l - 1) / length[n - 1]);
        ll nr = r - length[n - 1] * ((r - 1) / length[n - 1]);
        ll a = ((l - 1) / length[n - 1] + 1) * length[n - 1];
        ll rv = nr; if (r > a) rv = length[n - 1];
        if(lx!=3) answer += solution_sub(n - 1, nl, rv);

        //오른쪽
        a = ((r - 1) / length[n - 1]) * length[n - 1];
        ll lv = nl; if (l < a) lv = 1;
        if(rx!=3) answer += solution_sub(n - 1, lv, nr);

        //중간
        for (int i = lx + 1; i < rx; i++) {
            if (i != 3) answer += val[n - 1];
        }

    }
    return answer;
}


ll solution(int n, ll l, ll r) {
    length[1] = 5; for (int i = 2; i <= 21; i++) length[i] = length[i - 1] * 5;
    val[1] = 4; for (int i = 2; i <= 21; i++) val[i] = val[i - 1] * 4;

    return solution_sub(n, l, r);
}

int main() {
    cout << solution(3, 35, 102) << endl;
    // 예시 입력: n = 2, l = 4, r = 17 → 결과는 8이어야 함
    cout << solution(2, 4, 17) << endl;

    return 0;
}

초기구현.. 거의 한번에 AC받긴함

1. RDD
   • 초창기 Spark가 제공하던 가장 기본적인 분산 데이터 구조
   • 스키마/최적화 부재 → 낮은 수준의 유연성은 높지만, 최적화 성능은 DataFrame/Dataset보다 떨어질 수 있음
2. DataFrame
   • 스키마가 있는 구조화된 데이터셋(Dataset[Row])
   • SQL-like 문법, Catalyst 최적화로 사용 편의성 및 성능 측면에서 개선
   • 컬럼 접근 시 컴파일 타임 타입 체크가 안 됨 → 런타임 오류 가능성
3. Dataset
   • DataFrame의 장점(스키마, 최적화) + RDD의 장점(타입 안정성)을 모두 제공
   • 스칼라의 케이스 클래스 등에 매핑해 사용하면 컴파일 시점에 타입을 체크
   • Spark SQL의 강력한 최적화 엔진(Catalyst) 적용 가능

결국, 데이터에 스키마가 있고 SQL 연산을 자주 사용한다면 DataFrame/Dataset을 추천하고, 추가로 컴파일 시점의 타입 안전성을 원한다면 Dataset을 사용하는 편이 좋습니다. 아직도 아주 범용적이거나, 스키마 없이 자유로운 처리가 필요한 상황(저수준 제어 등)에서는 RDD를 쓰기도 하지만, 일반적인 애플리케이션에서는 주로 DataFrame/Dataset을 사용해 개발/성능 양쪽을 만족시킵니다.

RDD와 List자료구조와의 차이

“방대하게 분산 처리되는 부분”이나 “불변(Immutable)” 같은 특성을 잠시 제쳐두고, 코드를 짤 때 RDD를 다루는 경험적 관점으로 보자면, 일반적인 컬렉션(List나 Seq 같은)을 ‘함수형 스타일’로 조작하는 느낌과 꽤 유사합니다.

• filter, map, flatMap, reduce 등 함수형 연산을 체인으로 연결해 쓰는 방식이, 스칼라의 List나 Seq에 있는 메서드와 유사하기 때문입니다.
• 다만 RDD는 **‘지연 평가(Lazy Evaluation)’**라서, map, filter 등으로 변환(Transformation)을 쌓아두다가, 최종적으로 collect(), count() 등의 **액션(Action)**을 호출할 때 한 번에 계산을 실행한다는 점이 가장 다른 부분입니다.

그래서 “분산, 불변” 등을 빼고 보면, 개발자 입장에서 연산을 작성하는 흐름은 오히려 스칼라의 List/Seq보다 스칼라의 Stream(Lazy)이나 자바의 Stream API 같은 지연성 컬렉션에 더 가깝다고 볼 수도 있습니다.

1. 함수형 메서드 체인
   • map, filter, flatMap 식으로 컬렉션을 변환하는 점은 List나 Seq와 유사
2. 지연 평가
   • RDD는 변환을 쌓아두고, 액션을 만나야 계산을 실행하는 특성이 있으므로,
   • 일반적인 즉시 평가형 List보다는 지연(Lazy) 컬렉션 혹은 자바의 Stream에 더 가깝다.
3. 불변/분산을 배제한다 해도, “RDD = 일종의 큰 컬렉션을 함수형 연산으로 다룬다”는 점에서,
   • 개발자 입장에서는 ‘(Lazy)Seq’나 ‘Stream’을 다루는 것과 유사한 경험이 될 것이다.

결국, “방대한 분산 처리”나 “불변”을 잠시 잊고, 코드를 작성·사용하는 관점만 놓고 보면,

• 스칼라의 List/Seq에 함수형 메서드를 적용하는 방식과 상당히 닮았고,
• 평가 시점이 지연된다는 점에서는 **Lazy 컬렉션(Stream류)**에 더 가깝다고 볼 수 있습니다.

Competitive Progrmming Helper의 약자로 백준같은 사이트에서 testcase같은걸 긁어다가 vscode에서 할 수 있게 해준다.

chrome에서도 확장프로그램을 설치해야하고(Competitive Companion)

vscode에서도 확장을 설치해야한다(Competitive Programming Helper)

원격ssh로 실행하는 경우는 포트전달이 필요할수도 있다.

왼쪽 하단 SSH부분 클릭해서 연결정보를 설정해준다.

처음에 Linux냐 Windows냐 mac이냐를 묻는 화면이 지속적으로 나온다면 Ctrl+,를 누른다음 위처럼 remote.ssh.remotePlatform을 검색해서 해당 ip에 대한 값을 linux등으로 정해주면 된다.

https://www.coupang.jobs/en/jobs/job/senior-staff-back-end-engineer-advertiser-platform-5673805/?gh_jid=5673805

여기, 여기가 이해하기 쉬운편

다만 TF-IDF실제 계산 수치가 따로 해보면 똑같이 잘 안나온다.

Q. TF-IDF계산하면 원본 문장에서 단어별로 TF-IDF스칼라 값이 하나 나온다?

A. 맞다.

TF-IDF는 여기 참조

예시코드

from sklearn.feature_extraction.text import TfidfVectorizer
text_data = ['사과 바나나 자동차', '바나나 자동차 기차',
    '자동차 기차 사과 포도', '바다 사과 기차 여름']
    
tfidfvec = TfidfVectorizer()

tfidfvec.fit(text_data)
print("Vocabulary: ", tfidfvec.vocabulary_)


sentence = [text_data[0]]
print(sentence)
print(tfidfvec.transform(sentence).toarray())

결과

Vocabulary:  {'사과': 3, '바나나': 1, '자동차': 5, '기차': 0, '포도': 6, '바다': 2, '여름': 4}
['사과 바나나 자동차']
[[0.         0.65782931 0.         0.53256952 0.         0.53256952
  0.        ]]

보면 알겠지만 '사과 바나나 자동차' 입력 문장에서의 단어개수가 아닌 전체 단어개수(기차0부터 포도6까지 7개)에 해당하는 벡터가 생성된다.

직접 tf-idf값을 계산해보려면 아래 참조