DEV Community: drevispas

Quarkus, Just for fun

drevispas — Thu, 26 Jun 2025 10:40:15 +0000

미립자의 quark와 우리의 us가 합쳐진 Quarkus. 간단한 프로젝트를 레퍼런스를 따라서 타이핑해보고 있다. 아직은 획기적인지 체감이 잘 안 되고 있다.
Dev mode로 시작시키 놓으면 코드 변경을 저장하는 순간 매우 빠르게 리로드된다. 그리고 추가한 extension(외부 의존성)이 oidc라면 Keycloack docker 인스턴스가 자동으로 설정되어 시작된다.
좀 더 타이핑해봐야겠다.

Add Jira ID and branch name in commit message

drevispas — Fri, 16 Jun 2023 04:20:15 +0000

Create a file name .git/hook/prepare-commit-msg with following content.
.git/hook/prepare-commit-msg:

#!/bin/sh

# Not used for now
COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2
SHA1=$3

if [ -z "$EXCLUDED_BRANCHES" ]; then
  # 이 템플릿을 사용하지 않을 브랜치 설정
  EXCLUDED_BRANCHES=(main release master develop)
fi

BRANCH_NAME=$(git symbolic-ref --short HEAD)

# 브랜치 이름을 분해한다.
BRANCH_PATTERN="(.*)/([A-Z0-9]{2,5}-[0-9]{1,4}){0,1}[-_/]*(.*)"
[[ $BRANCH_NAME =~ $BRANCH_PATTERN ]]
BRANCH_TYPE=${BASH_REMATCH[1]}
JIRA_ID=${BASH_REMATCH[2]}
BRANCH_DESC=`echo ${BASH_REMATCH[3]} | tr '-' ' '`

# 템플릿 미사용 조건들
IS_EXCLUDED_BRANCH=$(printf "%s\n" "${EXCLUDED_BRANCHES[@]}" | grep -c "^$BRANCH_NAME$")
BRANCH_OCCURRENCES_IN_COMMIT=$(grep -c "\[$BRANCH_NAME\]" $1)

if [ -n "$BRANCH_NAME" ] && ! [[ $IS_EXCLUDED_BRANCH -eq 1 ]] && ! [[ $BRANCH_OCCURRENCES_IN_COMMIT -ge 1 ]]; then
  sed -i.bak -e "1s|^|[$JIRA_ID] $BRANCH_TYPE: $BRANCH_DESC\nSolves [$JIRA_ID] $BRANCH_TYPE: $BRANCH_DESC\n|" $1
fi

If you commit, the hook add two lines automatically.
Ex) A branch

feature/JIRA-123_this-is-a-description

makes a commit message

[JIRA-123] feature: this is a description
Solves [JIRA-123] feature: this is a description
{commit message}

Mermaid snippet

drevispas — Tue, 31 May 2022 03:30:29 +0000

Mermaid is a diagram creation tool built in the Github. You can create a diagram by typing '''mermaid''' on a markdown file (You have to replace quotes with back quotes actually).
Here a sequence diagram snippet being referred as a sample.

'''mermaid
sequenceDiagram
    %% Participants
    participant A as Alice
    participant B as Bob
    link A: Go to Wiki @ https://en.wikipedia.org/wiki/Alice

    %% Main loop
    autonumber %% Turn on sequence numbers on arrows
    loop Every minute
        opt A is ready
            A->>+B: OK?
        end
        note left of A: Note for Alice
        note right of B: Note for Bob
        alt B is ready
            B-->>A: Yes
        else B is not ready
            B-->>-A: No
        end
        note over A,B: Note for both
    end
'''

To render the sequence diagram you wrote at Intellij, enable "mermaid" markdown extension:

Elementary Lambda Calculus (in Korean)

drevispas — Sun, 12 Sep 2021 05:11:36 +0000

열기

여러 프로그래밍 언어에서 함수형 프로그래밍을 지원한다. 이러한 방식은 람다 대수가 이론적 근간이 된다고 하는데, 어떤 내용인지 궁금하므로 매우 짧게 이런 식이구나 까지만 알아보도록 한다.

정의

튜링 머신과 같이 어떤 계산가능한 함수도 표현할 수 있지만, 하드웨어보다는 소프트웨어적인 접근을 취하고 있다.
기본 용어는 name, expression이다. Name은 흔히 말하는 variable이라고 생각하면 되고 알파벳 문자로 표현된다. Expression은 아래와 같이 재귀적으로 표현된다.

따라서 표현식(expression)은 변수(name)이거나 함수(function)이거나 적용(application)이다. 함수(function)는 λ 키워드로 함수임을 알리고 인자(argument)로 변수와 본문(body)로 표현식을 써서 정의한다. 적용(application)은 표현식 하나를 다른 표현식에 적용시킨다는 의미로 이 자체가 표현식이다. 키워드는 점(.)과 람다기호(λ) 2가지 밖에 없다. 가독성을 위해 괄호를 사용할 수 있다.
간단한 함수(function)의 예로 항등 함수(identity function)가 있다.

바(|) 왼쪽은 람다 표현, 오른쪽은 이해를 돕기 위한 코틀린 코드에서의 표현이다(이제 코틀린 기초 문법 보는 중이라 틀렸을 수도 있음). 첫번째 x는 이 함수의 인자(argument)를 나타내고, 두번째 x는 함수의 본문(body)를 나타낸다. 즉 자기자신을 반환하는 함수이다. 일단 여기에서 람다 함수에는 sin(), sum()과 같은 이름이 없다는 것을 알 수 있다.
함수를 표현식에 “적용”할 수 있다. 실제로 표현식을 함수에 대입하지만 반대방향으로 표현한다.
가장 간단한 “적용”은,

이 경우 표현식 x가 함수라고 가정한 경우이다.
항등 함수로 적용의 예를 들면,

위 적용(λ(x.x))은 인자 x를 변수값 y로 대체하고 본체를 반환하기 때문에 결과는 y이다.

변수는 단지 값을 담는 place holder 역할이므로 x, y, z 등 어떤 이름으로 지어도 상관없다. 즉,

자유 변수(free variable), 종속 변수(bound variable)

위키백과 설명을 보자 (왠지 이해하기 더 어려워졌다):

논리학과 컴퓨터 과학에서, 자유 변수(自由變數, 영어: free variable)는 수식 속의 변수 가운데 상숫값으로 치환할 수 있는 것이다. 반대로 종속 변수(從屬變數, 영어: bound variable)는 상숫값으로 치환하였을 때 수식이 본래의 의미를 잃게 되는 변수이다.

람다 함수의 예를 보자.

함수 본문에 있는 변수가 인자에도 있으면 종속되었다고 하고, 그렇지 않으면 자유라고 한다. 따라서 x는 종속 변수이고, y는 자유 변수이다. 주의할 점은 변수 이름은 scope이 함수 하나에 한정된다는 것이다. 이름이 같더라도 옆 함수에서는 사실 다른 변수이다.

첫번째 표현식 (λx.x)에서 x는 종속 변수이고, 두번째 표현식 (λy.xy)에서 x는 자유 변수이며, 각 표현식의 x는 전혀 다른 변수이다.

치환

항등 함수에 항등 함수를 “적용”시킨다면 치환을 이용하여 그 결과를 추론할 수 있다. 위에서 설명했듯이 변수 이름은 함수들을 걸쳐서는 의미가 없으므로 치환하면,

앞 람다 함수 인자에 뒤의 표현식을 대입하면,

위 함수는 인자와 같은 것을 반환한다는 정의이므로 결과는,

즉 다시 항등 함수가 된다.

연습 문제1: (λx.(λy.xy))y를 치환하면?
풀이1: scope은 다른데 이름이 같은 변수들이 헷갈리므로 먼저 치환해서 모호함을 없앤다.

맨 오른쪽 y 변수를 인자 x로 치환해서 본체를 반환한다.

연습 문제2: (λx.(λy.(x(λx.xy)))y를 치환하면?
풀이2: 대입할 맨 오른쪽 y와 람다 함수 본문의 y는 서로 다른 변수이므로 본문 쪽을 치환

변수 y를 왼쪽 람다 인자로 치환해서 본문을 반환하면,

산술 연산

람다 대수에서는 모든 것이 함수라 숫자를 표현할 방법이 필요했다. 음이 아닌 정수 체계를 표현하고자 한다면, (1) 시작값(0)과 (2) 다음 값을 구하는 함수(successor), 두 가지만 있으면 구축할 수 있다. 시작값인 zero를 아래와 같이 정의했다(이게 도대체 왜 0이냐는 의문이 생기지만).

Zero는 함수 f(successor)와 변수 z(양의 정수)를 입력으로 받아 다시 변수 z를 반환하는 함수로 정의했다.

2, 3, … 모두 기본값에 successor 함수를 몇 번 적용했는지로 정의된다.
덧셈의 경우에도 함수로 정의되는데, 인자 (a, b)를 받아서 zero에 successor를 a번 적용하고, 그 결과에 다시 successor를 b번 적용한다.

마무리

여기까지가 보통 람다 대수 책의 앞 부분이다. 우리의 목적은 대수 이론을 체계적으로 배우기 보다는 함수형 프로그래밍에 근간이 되는 람다 대수가 어떤 느낌인지 확인하는 정도이기 때문에 여기에서 마무리해도 충분해 보인다.

Setup Laravel in Local Host

drevispas — Tue, 29 Jun 2021 13:59:46 +0000

This guide assume you are installing on a Mac OS.
Install composer which is a package manager for Laravel.

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('sha384', 'composer-setup.php') === '756890a4488ce9024fc62c56153228907f1545c228516cbf63f885e036d37e9a59d27d63f46af1d4d07ee0f76181c7d3') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"
sudo mv composer.phar /usr/local/bin/composer

Install laravel installer.

composer global require "laravel/installer"
export PATH=~/.composer/vendor/bin:$PATH

Now you can create a new Laravel project on the working directory.

laravel new {project}
cd {project}

Run the new project with sail tool.

composer require laravel/sail --dev
php artisan sail:install

After that docer-compser.yml and Dockerfile are created. For now mysql 8.0.25 and php8.0 were installed. It builds docker images and prints container logs like tail -f. You could use sail up -d to run containers in background.
Save the current code on github for backup.

git init
git add .
git commit -m "first commit"
git branch -M main
git remote add origin git@github.com:{username}/laravel-example.git
git push -u origin main

Let's see what containers are running. sail command is similar to docker-compose command.

# list containers
sail ps
# list databases
sail exec mysql mysql -usail -ppassword -e"show databases"

Open a browser and go to http://localhost to see Laravel.

To stop containers, open a new terminal and go to {project} directory and run down command.

sail down

Lastly install a debugger for php.

# on MacOS
pecl install xdebug
# on Ubuntu
sudo apt install php-xdebug

Spark Introduction

drevispas — Thu, 17 Dec 2020 09:33:43 +0000

Quick View

Spark의 기본에 대해서 정리해 보자.

RDD

RDD는 분산 자료구조이다 ≈ 일단 DB 테이블로 생각하자
Mutable 특성 ≈ 테이블인데 append만 되는 read-only table이라고 생각하자
Lazy execution 특성
- RDD "Actions"은 operator이며 결과로 새로운 RDD들을 만들어 낸다.
- RDD actions 체인을 거쳐서 최종 RDD를 설계한 다음,
- "Transformations"이 실제로 RDD의 actions들을 실행시킨다.
DAG (Directed Acyclic Graph)
- RDD의 actions / transformation은 결국 DAG를 설계하는 것이다.
작업 단위
- 크기 순: Job > Stage > Task
- Stage: shuffle이 발생하기 전까지 하나의 executor에 의해서 실행되는 구간
- Task: map(), filter()와 같은 단위 연산

SparkSQL

RDD에 DB table처럼 schema를 부여하여 SQL 질의를 가능하게 할 수 있다. 이러한 RDD를 "DataFrames"라고 부른다.

Spark Streaming

Data Source (Kafka/S3/Kinesis/…) → Spark Streaming → Data Destination (Cassandra/HDFS/…)
DStream (Discretized Stream)
- Stream block을 5초 동안 모아서 하나의 RDD로 만들어 낸 것이다. 결국 Spark Stream도 RDD 단위로 처리하는 셈

Spark Installation

Installing PySpark on Windows

설치 가이드를 따라 진행하다가 막히는 부분들을 여기저기 찾으며 정리한 것이다. Anaconda는 미리 설치되어 있다고 가정한다. Spark는 HDFS 파일시스템 위에서 동작하기 때문에 windows Hadoop을 설치해야 한다. 아래 미리 Windows용으로 빌드된 Hadoop을 설치한다.

https://github.com/karthikj1/Hadoop-2.7.1-Windows-64-binaries/releases/download/v2.7.1/hadoop-2.7.1.tar.gz

예를 들어, 압축을 풀고 "C:\app\hadoop"으로 이동시킨 후 환경변수를 설정한다. 현재 자바 최신 버전인 JDK 11은 아직 지원되지 않고 문제가 발생하므로 JDK 8 최신 버전을 설정한다.

JAVA_HOME=C:\app\Java\8\jdk
HADOOP_HOME=C:\app\hadoop
ANACONDA_HOME=C:\app\anaconda 
PYTHONPATH=%ANACONDA_HOME%
PYSPARK_PYTHON=%PYTHONPATH%\python.exe
PYTHONIOENCODING=UTF-8
PATH=%PATH%;%ANACONDA_HOME%;%ANACONDA_HOME%\Library\bin; 
%HADOOP_HOME%\bin;

Anaconda prompt를 열고 환경변수가 잘 설정되었는지 확인하고 pyspark를 설치한다. 현재 최신 PySpark 버전이 2.4.0이지만 dataframe 생성시 exception이 발생하여 2.3.2로 설치한다.

echo %JAVA_HOME%
echo %HADOOP_HOME%
...
conda install pyspark=2.3.2

IDE

Jupyter Notebook

Anaconda prompt에서 아래 명령어를 실행시키면 데몬이 시작되면서 기본 browser가 자동으로 열린다.

(base) C:\Users\brad>jupyter notebook
[I 22:47:18.529 NotebookApp] JupyterLab extension loaded from C:\app\anaconda\lib\site-packages\jupyterlab
[I 22:47:18.530 NotebookApp] JupyterLab application directory is C:\app\anaconda\share\jupyter\lab
[I 22:47:18.532 NotebookApp] Serving notebooks from local directory: C:\Users\brad
[I 22:47:18.532 NotebookApp] The Jupyter Notebook is running at:
[I 22:47:18.532 NotebookApp] http://localhost:8888/?token=6d3d60c01b9715eb8d3a94fd862f22eefab07192fe7aa1a0

New > Python 3로 새로운 edit 탭을 시작한다.

Syntax highlight와 괄호 닫기 자동 입력을 지원해준다. Shift+Enter로 작성한 상자 안에 코드를 수행해볼 수 있다. 작성 중간 중간에 File > Save를 해준다. 현재 directory 안에 .ipynb 화일로 저장된다.

PyCharm

편리한 편집 기능을 제공하는 PyCharm이다. 단축키와 스타일이 IntelliJ와 유사하다.

Troubleshooting

Numpy update 후에 PyCharm에서 다음과 같은 오류가 발생한다

"DLL Load Failed: The specified procedure could not be found."

Windows 환경 변수 PATH에 다음을 추가하고 PyCharm을 restart해보자.

%ANACONDA_HOME%\Library\bin

Anaconda Installation

Windows 10에 Anaconda를 설치하는 방법을 정리한다. 개인적으로 경로 상에 공백 문자가 없는 것을 선호하기 때문에 C:\app\anaconda 디렉토리 아래에 설치해 보도록 하겠다.

Downloading Anacond

아래 URL로 가서 최신 Anaconda 설치화일을 다운로드한다.

https://www.anaconda.com/download/

현재 최신 버전은, https://repo.continuum.io/archive/Anaconda3-2018.12-Windows-x86_64.exe 이다.

설치 창에서 경로를 "C:\app\anaconda"로 수정하고 설치를 완료한다.

Setting Environment Variables

Windows 10의 시스템 환경변수에 다음과 같이 추가한다.

ANACONDA_HOME=C:\app\anaconda 
PYTHONPATH=%ANACONDA_HOME%
PYTHONIOENCODING=UTF-8
PATH=%PATH%;%ANACONDA_HOME%;%ANACONDA_HOME%\Library\bin;

Adding Mirror Site

Anaconda 설치 후 새로 생긴 Anaconda Prompt를 실행한다.

기본적으로 Anaconda는 아래 채널을 갖고 있는데 속도가 느려서 중국의 미러 채널을 추가해 보도록하겠다.

default_channels:
 https://repo.anaconda.com/pkgs/main
 https://repo.anaconda.com/pkgs/free
 https://repo.anaconda.com/pkgs/r
 https://repo.anaconda.com/pkgs/pro
 https://repo.anaconda.com/pkgs/msys2

다음 URL을 참조하여 채널을 추가한다.

https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --set show_channel_urls yes
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/

테스트 삼아 numpy를 설치해본다.

conda install numpy

Updating Conda Package

설치되어 있는 Anaconda package들을 살펴보자.

conda list

Package들을 update해본다.

conda update --all

캐쉬된 잔여물들을 삭제한다.

conda clean --all

Troubleshooting

Unknown Encoding

만일 conda update 중 아래와 같은 메시지를 만나게 된다면 Windows 10에서 기본 문자셋을 UTF-8로 설정했기 때문일 것이다. 환경변수 "PYTHONIOENCODING=UTF8"으로 설정했음에도 불구하고 6500이라는 숫자로 변경되었다.

Preparing transaction: done
 Verifying transaction: done
 Executing transaction: done
 Fatal Python error: init_sys_streams: can't initialize sys standard streams
 LookupError: unknown encoding: 6500

Anaconda Prompt를 닫고 "C:\app\anaconda\Scripts\activate.bat" 끝에 아래 라인을 강제로 추가한다.

set PYTHONIOENCODING=UTF-8

다시 Anaconda Prompt를 열고 encoding을 확인한다.

(base) C:\Users\brad>echo %PYTHONIOENCODING%
UTF-8

(base) C:\Users\brad>conda update conda
Solving environment: /

Spark SQL

긴 설명은 생략하고 직관적으로 이해할 수 있도록 Python 샘플 코드를 통해서 레퍼런스처럼 참조할 수 있도록 정리한다. Ctrl+F로 검색하기 쉽도록 외래어는 가능하면 알파벳으로 표시할 것이다.

Spark SQL Session

Spark에서 DataFrame을 생성하고 SQL을 수행하기 위해서
pyspark.sql.SparkSession 인스턴스를 만든다.

from pyspark.sql import SparkSession
spark = SparkSession.builder.master("local").appName("MyApp").getOrCreate()

File I/O

대부분의 경우 대량의 입력 데이터를 수기로 입력할 수는 없고 다른 data source로부터 받아야 한다. 가장 기본이 되는 방식으로 하나의 File을 읽어서 DataFrame으로 변환해 보자.

테스트를 위하여 다음 링크에서 붓꽃 데이터를 다운로해서 저장한다.

https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data

아래 예제는 Pyspark v2.4.0 기준이고, 이하 모든 예제는 사용 버전에 따라 코드가 달라질 수 있다.

# spark = SparkSession.builder.getOrCreate()
irisDf = spark.read.csv('data/iris.data', sep=",", header="false", inferSchema="true")

sep: 구분자. 기본은 콤마(,)
header: csv에 헤더가 있는지 여부
inferSchema: 컬럼 내용을 보고 data type을 유추해서 결정해 준다. Default인 "false"로 하면 string type으로 인식한다.

DataFrames

방금 CSV file을 읽어서 dataframe 한 개로 전환하였다. Dataframe의 정확한 정의는 따로 있겠지만 이해하기 쉽도록 schema를 가진 RDD라고 생각하자. DB table처럼 schema가 있기 때문에 SQL로 조작이 가능해진다. 이제 dataframe에 대한 기초 조작법을 정리해 보자.

Schema

>>> df.columns
['_c0', '_c1', '_c2', '_c3', '_c4']
>>> df.dtypes
[('_c0', 'double'), ('_c1', 'double'), ('_c2', 'double'), ('_c3', 'double'), ('_c4', 'string')]
>>> df.printSchema()
root
 |-- _c0: double (nullable = true)
 |-- _c1: double (nullable = true)
 |-- _c2: double (nullable = true)
 |-- _c3: double (nullable = true)
 |-- _c4: string (nullable = true)

Print

DataFrame을 화면에 출력하는 기능이다. 앞에 chain이 얼마나 길든 상관없이 최종 결과 DataFrame을 화면에 출력한다.

# Print a DataFrame in table format. All the belows print the same table.
irisDf.show(3)
irisDf.select('*').show(3)
irisDf.limit(3).show(3)
# Display
+---+---+---+---+-----------+
|_c0|_c1|_c2|_c3|        _c4|
+---+---+---+---+-----------+
|5.1|3.5|1.4|0.2|Iris-setosa|
|4.9|3.0|1.4|0.2|Iris-setosa|
|4.7|3.2|1.3|0.2|Iris-setosa|
+---+---+---+---+-----------+

Query

First N

전체 row 또는 앞 n 개 row를 질의할 수 있는 몇가지 방법들을 제공한다. 테스트 결과 아래 구문들은 모두 동일한 Row 객체 리스트를 반환한다.

# Whatever methods below return the same list of Row object.
irisDf.head(3)
irisDf.take(3)
irisDf.collect()[:3]
irisDf.limit(3).collect()
irisDf.select('*').limit(3).collect()
# Result
[Row(_c0=5.1, _c1=3.5, _c2=1.4, _c3=0.2, _c4='Iris-setosa'), Row(_c0=4.9, _c1=3.0, _c2=1.4, _c3=0.2, _c4='Iris-setosa'), Row(_c0=4.7, _c1=3.2, _c2=1.3, _c3=0.2, _c4='Iris-setosa')]

take(n): 앞의 n개 row를 fetch
show(n): 앞의 n개 row를 print

API Queries

SQL과 유사한 API로 질의한다.

>>> df.select('_c4').filter('_c0 > 5.0 and _c2 < 1.5').show(3)
+-----------+
|        _c4|
+-----------+
|Iris-setosa|
|Iris-setosa|
|Iris-setosa|
+-----------+
>>> df.groupby('_c4').agg({'_c1':'max', '_c2':'count'}).show()
+---------------+--------+----------+
|            _c4|max(_c1)|count(_c2)|
+---------------+--------+----------+
| Iris-virginica|     3.8|        50|
|    Iris-setosa|     4.4|        50|
|Iris-versicolor|     3.4|        50|
+---------------+--------+----------+

filter(): SQL의 WHERE에 해당한다.
groupby(): SQL과 달리 SELECT가 없고 group by column을 명시하지 않는다.
agg(): 'column명':'항수명' 형태로 aggregation columns를 표현한다.
show(): 앞의 fiter, groupby, agg 등은 transformations여서 실제 수행은 하지 않고 설계만 하는 것이고, action인 show()를 불러야 실제로 조회가 시작된다.

Columns

지금까지는 windows command 창에서 수행하였는데 코딩이 수월한 PyCharm으로 옮기겠다.

Column Functions

Column를 전문적으로 다루는 module이 따로 있다. Alias, aggregation 등 편리한 기능들이 있다.

from pyspark.sql import functions as F
df.groupby('_c4').agg(F.max('_c1').alias('_c1_max'), F.count('_c2').alias('_c2_count')).show()
+---------------+-------+---------+
|            _c4|_c1_max|_c2_count|
+---------------+-------+---------+
| Iris-virginica|    3.8|       50|
|    Iris-setosa|    4.4|       50|
|Iris-versicolor|    3.4|       50|
+---------------+-------+---------+

Add Column

df.withColumn('_c5', F.col('_c1')*2).show(3)
+---+---+---+---+-----------+---+
|_c0|_c1|_c2|_c3|        _c4|_c5|
+---+---+---+---+-----------+---+
|5.1|3.5|1.4|0.2|Iris-setosa|7.0|
|4.9|3.0|1.4|0.2|Iris-setosa|6.0|
|4.7|3.2|1.3|0.2|Iris-setosa|6.4|
+---+---+---+---+-----------+---+
df.show(3)
+---+---+---+---+-----------+
|_c0|_c1|_c2|_c3|        _c4|
+---+---+---+---+-----------+
|5.1|3.5|1.4|0.2|Iris-setosa|
|4.9|3.0|1.4|0.2|Iris-setosa|
|4.7|3.2|1.3|0.2|Iris-setosa|
+---+---+---+---+-----------+
df2 = df.withColumn('_c5', F.col('_c1')*2)
df2.show(3)
+---+---+---+---+-----------+---+
|_c0|_c1|_c2|_c3|        _c4|_c5|
+---+---+---+---+-----------+---+
|5.1|3.5|1.4|0.2|Iris-setosa|7.0|
|4.9|3.0|1.4|0.2|Iris-setosa|6.0|
|4.7|3.2|1.3|0.2|Iris-setosa|6.4|
+---+---+---+---+-----------+---+

withColumn(): 새로운 column을 마지막에 추가
df.show(3): Spark RDD나 DataFrame은 mutable 자료구조라 in-place update가 안 된다. 다른 변수에 assign해서 변경을 유지해 나간다.

Update Column

df.withColumn('_c4', df['_c4'].substr(1,4)).show(3)
+---+---+---+---+----+
|_c0|_c1|_c2|_c3| _c4|
+---+---+---+---+----+
|5.1|3.5|1.4|0.2|Iris|
|4.9|3.0|1.4|0.2|Iris|
|4.7|3.2|1.3|0.2|Iris|
+---+---+---+---+----+

Type Casting

df.select(F.col('_c0').cast('integer')).show(3)
+---+
|_c0|
+---+
|  5|
|  4|
|  4|
+---+

Join

DataFrame class의 member method인 join()은 INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER, CROSS 등의 join 기능을 제공한다.

# Create python lists.
dept = [(1,'hr'), (2,'dev'), (3,'special_force')]
emp = [(11, 'john', 1), (12, 'james', 2), (13, 'jennis', 1), (14, 'brad', 2), (15, 'doctor-x', 4)]
# Create RDDs.
deptRdd = sc.parallelize(dept)
empRdd = sc.parallelize(emp)
# Create DataFrames.
deptDf = spark.createDataFrame(dept, ['dept_id', 'dept_name'])
empDf = spark.createDataFrame(emp, ['emp_id', 'emp_name', 'dept_id'])
# Join two DataFrames.
joinDf = deptDf.join(empDf, on='dept_id')
joinDf.show()
+-------+---------+------+--------+
|dept_id|dept_name|emp_id|emp_name|
+-------+---------+------+--------+
|      1|       hr|    11|    john|
|      1|       hr|    13|  jennis|
|      2|      dev|    12|   james|
|      2|      dev|    14|    brad|
+-------+---------+------+--------+
deptDf.join(empDf, deptDf.dept_id == empDf.dept_id, 'left_outer').show()
+-------+-------------+------+--------+
|dept_id|    dept_name|emp_id|emp_name|
+-------+-------------+------+--------+
|      1|           hr|    11|    john|
|      1|           hr|    13|  jennis|
|      3|special_force|  null|    null|
|      2|          dev|    12|   james|
|      2|          dev|    14|    brad|
+-------+-------------+------+--------+
deptDf.join(empDf, deptDf['dept_id'] == empDf['dept_id'], 'full_outer').show()
+-------+-------------+------+--------+
|dept_id|    dept_name|emp_id|emp_name|
+-------+-------------+------+--------+
|      1|           hr|    11|    john|
|      1|           hr|    13|  jennis|
|      3|special_force|  null|    null|
|      2|          dev|    12|   james|
|      2|          dev|    14|    brad|
|      4|         null|    15|doctor-x|
+-------+-------------+------+--------+

Spark RDD

Python sample code를 예로 해서 RDD를 어떻게 다루는지 기본 조작 방법들을 정리해 보자.

RDD

RDD는 Resilient Distributed Dataset의 약자인데 이름에 유추할 수 있듯이 fault-tolerant하고 분산되어 병렬 처리되는 자료구조이다. 우리는 보통 S3, HDFS, DB에 있는 source data를 읽어서 RDD 형태로 로드하게 된다.

Spark SQL이 테이블 형태의 스키마를 가지고 SQL로 조작하기 위한 자료구조라면, RDD는 map-reduce로 조작하기 위한 자료구조이다. 양방향으로 치환이 가능하다. 따라서 주로 python tuple 형태 (k, v)로 data를 만들어 놓고, map/reduce 함수로 조작하게 된다.

하나의 RDD는 논리적인 하부구조인 하나 이상의 partition으로 이루어진다.

RDD에 대한 기본 조작을 python 예제로 살펴보자. 관련 method가 많으므로 자주 사용되는 몇가지만 살펴본다.

Cluster Structure

Driver program은 우리들이 작성한 Spark code이고 PC client에서 실행할 수도 있고 Spark cluster node 안에서 실행시킬 수도 있다.

지금부터의 클러스터 내용은 정확하지 않을 수 있는데 나중에 수정하도록 하겠다. Driver가 data를 load해서 cluster의 각 node에 분산시켰다고 하자. Driver는 cluster node 중에 지정된 app master에게 RDD 조작 명령을 내린다. App master는 RDD를 보관하고 있는 각 executor node에게 다시 명령을 전달한다.

Spark Context

Spark cluster에 접속하기 위해서 SparkContext를 생성한다.

from pyspark import SparkContext, SparkConf

conf = SparkConf().setAppName('MyApp').setMaster('local[4]')
sc = SparkContext(conf=conf)

Creating RDD

아래에서 생성한 RDD는 이후 example에서도 계속 사용된다.

From Driver Program

# Small printer
import pprint
def pp(o):
    pprint.pprint(o)
    pprint.pprint(type(o))

# parallelize: Get a Python data and distribute on Spark cluster nodes.
personList = [('David',101),('Bob',102),('Charles',103),('Brad',104)]
personRdd = sc.parallelize(personList)
pp(personRdd)
ParallelCollectionRDD[13] at parallelize at PythonRDD.scala:194
<class 'pyspark.rdd.RDD'>

From External Data Source

filePath = 'data/hollins.dat.gz'
# textFile: Open a file and return a RDD.
fileRdd = sc.textFile(filePath)
pp(fileRdd.count())
29888
<class 'int'>

Listing Elements

All

# collect: Return a python list from a RDD.
pp(personRdd.collect())
[('David', 101), ('Bob', 102), ('Charles', 103), ('Brad', 104)]
<class 'list'>

First N

# first: Return the 1st element of list.
pp(personRdd.first())
('David', 101)
<class 'tuple'>

# take: Return the first n elements of list.
pp(personRdd.take(2))
[('David', 101), ('Bob', 102)]
<class 'list'>

# top: Return the largest n elements of list.
pp(personRdd.top(2))
[('David', 101), ('Charles', 103)]
<class 'list'>

Key-Value

# lookup: like get() in most cache systems
pp(personRdd.lookup('Charles'))
[103]
<class 'list'>

Transformation Operations

map/groupby/join 등과 같이 RDD를 변형시키는 연산들이며 연산 결과가 다시 RDD이므로 연산들을 chainning할 수 있다. Lazy approach라서 transformation은 여러 번을 적용하더라도 실제로 연산이 수행되지는 않는다. Action 연산을 적용할 때 한꺼번에 수행된다. Transformation/Action 연산 리스트는 아래 spark guide page에 나열되어 있다.

https://spark.apache.org/docs/latest/rdd-programming-guide.html

Action Operations

reduce/count/collect와 같이 RDD를 python scalar나 list 등으로 최종 결과를 얻어낼 때 사용한다. 그 앞에 적용한 transformation 연산들을 있다면 실제로 순서대로 수행하고 마지막에 action을 수행한다.

Kubernetes in Baremetals

drevispas — Thu, 17 Dec 2020 09:21:13 +0000

Motivation

I have move to a division of my company that is quite different from the before workspace. First of all, I can't use any cloud service due to strong security policies. I was creating a REST API server with Flask and decided to deploy it on containers.

Change history

Dockerfile

At first, I wrote some Dockerfiles for Flask, MongoDB, Docker registry, NginX, Redis. It was good to deal with samll number of images like in my case and was satisfied that all things were in my control. However building and running several images serially was a bit annoying.

Docker Compose

My previous team used to deploy systems with Docker compose. So I tried to go with that and was able to combine related imanges with the Docker compose after some investigation. I was happy with the ways in that images were built and run by a single docker-compose.yaml file.
I could utilize the existing Dockerfiles to make the Docker compose to build images. docker-compose up -d started up the related containers in a shot. To stop all together, docker-compose stop made thigns simple. If you delete every containers and images, run docker-compose down. To delete even the used volumes, just run docker-compse down --volumes.
Now buding images and running/stopping containers are sufficient. next how should I secure high-availablity and scalability with that? Remind me, I can't use any cloud services. Services like ELB and auto-scaling was not for me. Kubernetes could have helped me.

KinD

KinD saved me at that time. I had no servers to test the Kubernetes in my new environment. KinD means "Kubernetes in Docker" and we can deploy multi-node Kubernetes even in a single machine. At first, configuring KinD was not that easy. The version was still beta and had changed during my test. Furthermore I had to rethink the host layout because the nodes was actually containers. Thus I configured Docker port-publishing to access the Kubernetes nodePort from the hosting machine.
I was quite satified with KinD. I wrote ConfigMaps, Secrets, Services, Deplyments, StatefulSets, and Ingress (of nginx) and run the resources successfully. I really liked Kustomize with that I can update the existing base YAMLs, combine all YAMLs, and even run all together with kubectl apply -k ./. But I was worried that these configurations are not real and would be much different from the production environment.

Multi-machine Kubernetes

As times passes, I was able to use serveral Linux machines at last and tried to configure multi-node Kubernetes in multiple machines. Consequently KinD is virtually identical to Kubernetes in multiple machines. That was faster to configure Kubernetes than doing for KinD. Plus it's more intuitive than KinD because control plane and work nodes are just hosts.

Baremetal-specific

Unfortunately Kubernetes is not a all-in-one solution. By design, they have reserved empty rooms for some specific implementations. For instance, Pod-to-Pod network, LoadBalancer type Service, Ingress, Persistent volume should be added by some means. If I used a cloud service, it would be not that difficult. In baremetal case, I had to configure plugin solutions for those.

Module required	Solution	Comment
Pod-to-Pod networking	`Flannel`	The defualt `vxlan` works fine.
Local persistence volume	`Local Persistence Volume Provisioner`	Good for performance but Pod and node are coupled.
Remote persistence volume	`NFS Provisioning`	A NFS server provides volumes dynamically (on demand volume). Intuitive and easy to view the volume contents
External load balancer	`MetalLB`	It make use `LoadBalancer`-type Service and assigns an external IP address for the Service. I choose a narrow range of IPs of my subnet.

Helm

Kustomize was convenient to use and easy to understand. Beyond that, Helm is a package manager for Kubernetes and gives us templating feature. Templating is a familiar concept with us if we have experienced Thymeleaf, Ansible, or Flask template. Plus we can manage the version of our Kubernetes packages with Helm.
The package metadata is in Chart.yaml, values for template variables are in the file values.yaml, and resource manaifests are located under a directory templates, Code snippets are in the file templates/_helper.tpl.
Fist time, I was confused how many parts be in whether values file or manifest files. It may depends on package own usages.
Finally I deployed my Flask and MongoDB with Helm and felt that managment was more superior than Kustomize.

Common SSL Commands

drevispas — Thu, 09 Apr 2020 15:07:46 +0000

Here are TLS commands used many times. I will add little by little.

################################################################################
# Let
# server.crt: a server certificate file
# root.crt: a self-signed root certificate file
# All certificates are in the format of PEM.
################################################################################

# View the contents of a certificate:
openssl x509 -in server.crt -text -noout

# Check a certificate chains:
openssl verify -verbose -CAfile root.crt server.crt
openssl verify -verbose -CAfile <(cat interm.crt root.crt) server.crt

# Extract public key from private key
openssl rsa -pubout -in server.key -out server.pub

# Test connection with certificate.
openssl s_client -connect www.example.com:8443 -state -CAfile como.crt

# Save server certificate in PEM
openssl s_client -showcerts -connect www.example.com:443 </dev/null | openssl x509 -outform PEM > example.pem.crt

# Save server certificate in DER
openssl s_client -showcerts -connect www.example.com:443 </dev/null | openssl x509 -outform DER > example.der.crt

# List certificate from pkcs12 keystore
keytool -list -v -keystore example.p12 -storetype PKCS12 -storepass ${storepass}

# Extract certificate from pkcs12 keystore
keytool -export -keystore example.p12 -alias ${alias} -file example.crt

# Create a new JKS trustore
keytool -import -alias rootca -file root.crt -keystore truststore.jks -storepass changeit

Let's see an example says full steps of making root, intermediate, and server certificates:

# Create a CA key pair
openssl genrsa -out root.key 8192
# Create a self-signed CA certificate
openssl req -sha256 -new -x509 -days 3650 -key root.key \
-subj "/C=KR/L=Seoul/OU=Example/CN=Example Root CA" -out root.crt

# Or you can combined above two commands:
openssl req -nodes -x509 -sha256 -newkey rsa:8192 -keyout "root.key" -out "root.crt" -days 3650 \
-subj "/C=KR/L=Seoul/OU=Example/CN=Example Root CA"

# Create a server key pair
openssl genrsa -out server.key 4096

# Create a CSR
openssl req -new -sha256 -key server.key \
-subj "/C=KR/L=Seoul/OU=Example/CN=svc.example.com" -out server.crt

# Create a server certificate
openssl x509 -req -in server.key -CA root.crt -CAkey root.key -set_serial 01 -out server.crt

Do you want to view the contents of certificate chain? Let call the followin script 'chain.sh' and run like "./chain.sh combined_certificates.crt".

#!/bin/bash

chain_pem="${1}"

if [[ ! -f "${chain_pem}" ]]; then
    echo "Usage: $0 BASE64_CERTIFICATE_CHAIN_FILE" >&2
    exit 1
fi

if ! openssl x509 -in "${chain_pem}" -noout 2>/dev/null ; then
    echo "${chain_pem} is not a certificate" >&2
    exit 1
fi

awk -F'\n' '
        BEGIN {
            showcert = "openssl x509 -noout -subject -issuer"
        }

        /-----BEGIN CERTIFICATE-----/ {
            printf "%2d: ", ind
        }

        {
            printf $0"\n" | showcert
        }

        /-----END CERTIFICATE-----/ {
            close(showcert)
            ind ++
        }
    ' "${chain_pem}"

echo
openssl verify -untrusted "${chain_pem}" "${chain_pem}"

PKI Certificates

drevispas — Tue, 07 Apr 2020 15:36:01 +0000

Trust chain

It is importan for web developers to understand the concept of PKI such as private/public key, certificate and CA. Let us see the concepts briefly.

We are using SSL certificates subconsciously everyday. Our web browsers have pre-built root certificates which are the roots of trust.
When we visit a web page, the web server encrypts some messages and return back to the web browser. The browser realizes that the server certificate is signed by a certificat authority who is one of the pre-built authorities in the browser and then trusts the server finally.

Self-signed Certificates

In most cases, we use certificates from public CAs for https purpose. But if connections happend only in closed networks, it is efficient and convinient to use self-signed certificate as trusted root certificates.

A private root CA key and self-signed root certificate is created in a secure and closed machine. I used a hardware appliance called HSM to generate or import private root CA private key and certificate. But in small testing scenarios, it is ok just like in a common linux machine.

Plus we can make intermediate CAs if we want trust hierarchy. I made three tier of certificates comprising a single root, several intermediate, and device certificate per device.

A server creates an CSR filled with information like CN and expiration date, then sends it to an intermediate or root CA server. The CA server signs it with its pair of private key and certificate and generates the server certificate that consists of issues, subject, revocation endpoint and public key of the server.

Next time, I would like to talk about 2-way SSL which makes securer than the above 1-way SSL.

Database High Availability in Old Days

drevispas — Thu, 13 Feb 2020 14:05:45 +0000

In old days, under the pressure of budge, we decided to utilize open source HA solution for the production database system.

I struggled to install Linux packages and find the right version dependencies between packages. After writing the configuration files for each layer like corosync, pacemake, and hearbeat, I tested individual layers and then all layers together. This had ran on the production for quite a while.

Nowadays DBaaS is really good to lighten the burden of setup.

Heap Sort

drevispas — Mon, 03 Feb 2020 14:57:58 +0000

The heap sort is useful to get min/max item as well as sorting. We can build a tree to a min heap or max heap. A max heap, for instance, keeps a parent being not smaller than children.
The following code is for a max heap. The top indicates the next insertion position in the array which is identical to the array size.

    class Heap {
        private int[] arr;
        private int top;
        public Heap(int sz) { arr=new int[sz]; top=0; }
        public void push(int num) {
            arr[++top]=num;
            climbUp(top);
        }
        public void pop() {
            int min=arr[1];
            arr[1]=arr[top--];
            climbDown(1);
            arr[top+1]=min;
        }
        public int size() { return top; }
        private void climbUp(int p) {
            if(p<=1||arr[p]<=arr[p/2]) return;
            swapAt(p,p/2);
            climbUp(p/2);
        }
        private void climbDown(int p) {
            int np=p*2;
            if(np>top) return;
            if(np<top&&arr[np+1]>arr[np]) np++;
            if(arr[p]>=arr[np]) return;
            swapAt(p,np);
            climbDown(np);
        }
        private void swapAt(int p,int q) {
            int t=arr[p];
            arr[p]=arr[q];
            arr[q]=t;
        }
    }

Programming Template: BackTraking

drevispas — Mon, 03 Feb 2020 14:39:56 +0000

This is a simple code example of backtraking. This traverses the problem space in depth-first order. I memorized it as a solution template.

const int MAXC = 4;
int finished = 0;
void bt(int a[], int k, int n) {
    int candidates[MAXC], numCand, i;
    if (solved(a, k, n)) {
        answer(a, k, n);
        return;
    }
    numCand = getCandidates(a, k, n, candidates);
    for (i = 0; i < numCand; i++) {
        a[k] = candidates[i];
        bt(a, k + 1, n);
        if (finished) return;
    }
}