반응형
 

Argo Workflows 설치 방법

Argo Workflows를 설치하기 위해서는 Kubernetes 클러스터가 필요합니다. 아래는 Argo Workflows를 설치하는 방법입니다.

1. Kubernetes 클러스터 준비

  • 로컬에서 Kubernetes를 실행하려면 minikube나 kind를 사용할 수 있습니다. 클라우드에서는 Google Kubernetes Engine(GKE), Amazon EKS, Azure AKS 등을 사용할 수 있습니다.

2. Argo Workflows 설치

kubectl 설치: Kubernetes 클러스터에 접근하기 위해 kubectl을 설치합니다.

curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
 

Argo CLI 설치: Argo Workflows를 사용하기 위한 CLI를 설치합니다.

curl -sLO https://github.com/argoproj/argo-workflows/releases/latest/download/argo-linux-amd64
chmod +x argo-linux-amd64
sudo mv argo-linux-amd64 /usr/local/bin/argo

Argo Workflows 설치: Helm을 사용하여 Argo Workflows를 설치할 수 있습니다. Helm이 설치되어 있어야 합니다.

# Helm repository 추가
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update

# Argo Workflows 설치
helm install argo argo/argo-workflows --namespace argo --create-namespace

UI 접근: Argo Workflows는 웹 UI를 제공합니다. 포트 포워딩을 통해 UI에 접근할 수 있습니다.이제 브라우저에서 http://localhost:2746로 접근하여 Argo UI를 확인할 수 있습니다.

kubectl port-forward svc/argo-ui -n argo 2746:2746

Argo Workflows 예제 설명

1. Hello World 예제

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: hello-world-
spec:
  entrypoint: hello-world
  templates:
  - name: hello-world
    steps:
    - - name: say-hello
        template: hello

  - name: hello
    container:
      image: ubuntu:latest
      command: [bash, -c]
      args: ["echo Hello, World!"]
  • 예제 설명:
    • 이 워크플로우는 "Hello, World!"를 출력하는 간단한 작업을 수행합니다.
    • entrypoint에서 hello-world 템플릿을 시작으로 설정하고, steps를 통해 say-hello 작업을 정의합니다.
    • hello 템플릿에서는 Ubuntu 이미지를 사용해 echo 명령어를 실행합니다.

2. 데이터 생성 및 분석 예제

 
  • 예제 설명:
    • 이 워크플로우는 두 개의 작업을 수행합니다: 데이터 생성과 데이터 분석.
    • 첫 번째 작업(generate-data)은 1에서 100 사이의 무작위 숫자 10개를 생성하고 출력합니다.
    • 두 번째 작업(analyze-data)는 첫 번째 작업의 출력을 입력으로 받아 평균값을 계산합니다.
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: data-processing-
spec:
  entrypoint: process-data
  templates:
  - name: process-data
    steps:
    - - name: step-1
        template: generate-data
    - - name: step-2
        template: analyze-data
        arguments:
          parameters:
          - name: input-data
            value: "{{steps.step-1.outputs.result}}"

  - name: generate-data
    script:
      image: python:3.8
      command: [python]
      source: |
        import random
        data = [random.randint(1, 100) for _ in range(10)]
        print(data)

  - name: analyze-data
    inputs:
      parameters:
      - name: input-data
    script:
      image: python:3.8
      command: [python]
      source: |
        input_data = {{inputs.parameters.input-data}}
        avg = sum(input_data) / len(input_data)
        print("Average:", avg)

3. 병렬 작업 예제

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: parallel-jobs-with-follow-up-
spec:
  entrypoint: run-jobs
  templates:
  - name: run-jobs
    steps:
    - - name: job-1
        template: process-job
        arguments:
          parameters:
          - name: job-name
            value: "Job 1"
    - - name: job-2
        template: process-job
        arguments:
          parameters:
          - name: job-name
            value: "Job 2"
    - - name: job-3
        template: process-job
        arguments:
          parameters:
          - name: job-name
            value: "Job 3"
    
    # 병렬 작업이 완료된 후 실행할 작업
    - - name: follow-up-job
        template: follow-up

  - name: process-job
    inputs:
      parameters:
      - name: job-name
    container:
      image: ubuntu:latest
      command: [bash, -c]
      args: ["echo Processing {{inputs.parameters.job-name}}"]

  - name: follow-up
    container:
      image: ubuntu:latest
      command: [bash, -c]
      args: ["echo All jobs completed, executing follow-up task."]
  • 예제 설명:
    • 이 워크플로우는 세 개의 작업을 병렬로 실행합니다: Job 1, Job 2, Job 3.
    • 각 작업은 process-job 템플릿을 참조하고, 각 작업 이름을 인자로 전달합니다.
    • 각 작업은 자신에게 할당된 이름을 출력합니다.
    • 병렬 작업이 모두 완료된 후 follow-up-job이라는 후속 작업이 실행됩니다. 이 작업은 follow-up 템플릿을 사용하여 "All jobs completed, executing follow-up task."라는 메시지를 출력합니다.

4. 조건부 실행 예제

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: conditional-execution-
spec:
  entrypoint: conditional-workflow
  templates:
  - name: conditional-workflow
    steps:
    - - name: check-condition
        template: evaluate-condition

    - - name: run-if-true
        template: true-branch
        when: "{{steps.check-condition.outputs.result}} == 'true'"

  - name: evaluate-condition
    script:
      image: python:3.8
      command: [python]
      source: |
        # Here, implement your logic to evaluate a condition
        condition_met = True
        print(condition_met)

  - name: true-branch
    container:
      image: ubuntu:latest
      command: [bash, -c]
      args: ["echo Condition is true, executing this branch."]
  • 예제 설명:
    • 이 워크플로우는 특정 조건을 평가한 후 그 결과에 따라 다음 작업을 실행합니다.
    • evaluate-condition 템플릿에서 조건을 평가하고 결과를 출력합니다.
    • when 절을 사용하여 조건이 참일 때만 run-if-true 작업이 실행됩니다.

5. 재시도 메커니즘 예제

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: retry-job-
spec:
  entrypoint: retry-example
  templates:
  - name: retry-example
    steps:
    - - name: failing-job
        template: fail-with-retry

  - name: fail-with-retry
    retryStrategy:
      limit: 3
    container:
      image: ubuntu:latest
      command: [bash, -c]
      args: ["exit 1"]  # Always fails for demonstration
  • 예제 설명:
    • 이 워크플로우는 실패할 작업을 정의하고, 최대 3회 재시도합니다.
    • retryStrategy를 설정하여, 작업이 실패할 경우 자동으로 재시도하도록 합니다.

결론

Argo Workflows를 통해 Kubernetes 환경에서 복잡한 데이터 처리 및 분석 파이프라인을 효과적으로 관리할 수 있습니다. 위에서 설명한 설치 방법과 다양한 예제를 통해 Argo의 기본 기능을 이해하고, 필요에 맞게 파이프라인을 확장할 수 있습니다. 각 예제는 실제 사용 시나리오에 따라 조정할 수 있으며, 더 복잡한 작업 흐름을 생성하는 데 기초가 될 수 있습니다.

반응형

'Computer Science > linux' 카테고리의 다른 글

Docker Compose 사용하기  (0) 2024.09.20
Dockerfile 작성하기  (1) 2024.09.15
Docker 사용하기  (0) 2024.09.15
Slurm 설치  (0) 2024.06.05
사용자 계정 관리 및 조직의 구조화 툴 (LDAP)  (0) 2024.05.17
반응형

Docker Compose 사용법과 예시: 효율적인 컨테이너 관리 도구

Docker는 애플리케이션을 컨테이너로 격리하여 실행하는 강력한 도구입니다. 여러 컨테이너로 구성된 애플리케이션을 쉽게 관리하고 실행하기 위해 Docker Compose라는 도구가 제공됩니다. Docker Compose는 여러 컨테이너의 설정을 YAML 파일로 정의하고, 한 번의 명령으로 손쉽게 컨테이너를 관리할 수 있습니다.

이번 글에서는 Docker Compose의 사용법, 예시 파일, 환경 변수 파일(.env) 사용법, 그리고 단일 이미지 vs. Docker Compose의 장단점에 대해 설명해 보겠습니다.


Docker Compose란?

Docker Compose는 여러 개의 Docker 컨테이너를 정의하고, 이 컨테이너들을 한 번에 실행하고 관리할 수 있는 도구입니다. **docker-compose.yml**이라는 설정 파일에 컨테이너 구성을 정의하고, docker-compose up 명령어로 전체 서비스를 실행할 수 있습니다. 이를 통해 개발자들은 복잡한 애플리케이션의 컨테이너를 일일이 실행할 필요 없이, 간편하게 일괄 관리할 수 있습니다.


Docker Compose 예시 파일

아래는 Node.js 애플리케이션MySQL 데이터베이스를 포함한 간단한 Docker Compose 파일의 예시입니다.

#docker-compose.yaml

version: '3'

services:
  web:
    image: node:14
    container_name: node_web
    volumes:
      - ./app:/usr/src/app
    working_dir: /usr/src/app
    command: npm start
    ports:
      - "3000:3000"
    env_file:
      - .env
    depends_on:
      - db

  db:
    image: mysql:5.7
    container_name: mysql_db
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: mydatabase
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

설명:

  • version: Compose 파일의 버전을 지정합니다.
  • services: 컨테이너를 정의하는 부분으로, web과 db 두 개의 서비스가 있습니다.
    • web: Node.js 컨테이너를 정의하며, .env 파일을 사용하여 환경 변수를 설정합니다.
    • db: MySQL 데이터베이스 컨테이너로, 환경 변수로 데이터베이스 설정을 지정합니다.
  • volumes: 컨테이너의 데이터를 유지할 수 있는 볼륨을 정의하여, 컨테이너가 종료되더라도 데이터가 유지되도록 설정합니다.

환경 변수 파일 (.env) 사용법

환경 변수 파일을 사용하면 민감한 정보나 설정 값을 코드에서 분리할 수 있어 보안성과 가독성을 높일 수 있습니다. 예를 들어, .env 파일을 작성하여 다음과 같이 환경 변수를 설정할 수 있습니다:

#.env file
MYSQL_ROOT_PASSWORD=rootpassword
MYSQL_DATABASE=mydatabase
MYSQL_USER=user
MYSQL_PASSWORD=password

Compose 파일 내에서 env_file 지시어를 통해 이 파일을 참조함으로써, 환경 변수를 손쉽게 적용할 수 있습니다. 이는 유지보수를 용이하게 하고, 환경 설정을 보다 유연하게 관리할 수 있도록 도와줍니다.


Docker Compose 사용법

Docker Compose의 사용법은 매우 간단합니다. 아래는 기본적인 사용 명령어입니다.

Docker Compose 파일 작성: docker-compose.yml 파일을 작성합니다.

서비스 실행:이 명령어를 실행하면 docker-compose.yml에 정의된 모든 서비스가 실행됩니다.

docker-compose logs

백그라운드에서 실행:-d 옵션을 사용하면 컨테이너가 백그라운드에서 실행됩니다.

docker-compose down

서비스 중지:모든 서비스를 중지하고 컨테이너를 삭제합니다.

docker-compose up -d

로그 확인:각 컨테이너에서 발생하는 로그를 확인할 수 있습니다.

docker-compose up

Docker Compose의 장점

  1. 간편한 멀티 컨테이너 관리: 여러 컨테이너를 동시에 관리할 수 있어 복잡한 애플리케이션 구성도 쉽게 실행 가능합니다.
  2. YAML 파일을 통한 설정: docker-compose.yml 파일로 구성 요소를 쉽게 정의하고 관리할 수 있습니다.
  3. 환경 의존성 제거: 로컬 개발 환경에서도 쉽게 컨테이너를 실행할 수 있으며, 배포 환경에서도 동일한 설정을 사용할 수 있습니다.
  4. 컨테이너 간 의존성 관리: depends_on 옵션을 사용해 컨테이너 간 의존성을 쉽게 정의할 수 있어, 서비스 실행 순서를 보장합니다.
  5. 데이터 유지: 볼륨을 정의해 데이터를 영구적으로 저장할 수 있어 컨테이너 종료 후에도 데이터가 유지됩니다.

Docker Compose의 단점

  1. 복잡한 설정 관리: 많은 컨테이너와 설정이 포함된 경우, docker-compose.yml 파일이 복잡해질 수 있습니다.
  2. 성능 이슈: 다수의 컨테이너를 로컬에서 실행할 경우, 시스템 리소스를 많이 소모할 수 있습니다.
  3. 초기 설정 어려움: 도커와 Compose에 익숙하지 않은 사용자에게는 초기 설정 과정이 다소 어려울 수 있습니다.
  4. 네트워크 이슈: Docker Compose의 기본 네트워크 설정으로 인한 포트 충돌이 발생할 수 있으며, 복잡한 네트워크 설정이 필요한 경우 추가적인 조정이 필요합니다.

단일 Docker 이미지 vs. Docker Compose

단일 Docker 이미지 사용의 장점

  1. 간편한 배포: 하나의 이미지만 있으면 배포가 용이합니다.
  2. 단순한 설정: 단일 애플리케이션을 실행할 때 설정이 간단합니다.
  3. 리소스 관리: 리소스 소모가 상대적으로 적습니다.

단일 Docker 이미지 사용의 단점

  1. 확장성 부족: 여러 서비스나 데이터베이스와의 연결이 필요할 경우 복잡해질 수 있습니다.
  2. 환경 관리 어려움: 각 서비스의 환경 설정을 별도로 관리해야 합니다.

Docker Compose 사용의 장점

  1. 복잡한 애플리케이션 구성: 여러 서비스를 쉽게 연결하고 관리할 수 있습니다.
  2. 환경 설정 통합: 모든 서비스의 환경 설정을 하나의 YAML 파일로 관리할 수 있습니다.
  3. 서비스 간 의존성 처리: 서비스 간의 실행 순서를 관리할 수 있습니다.

Docker Compose 사용의 단점

  1. 복잡한 설정 관리: 설정이 많아질수록 YAML 파일이 복잡해질 수 있습니다.
  2. 성능 소모: 여러 컨테이너를 동시에 실행하면 시스템 리소스 사용량이 증가할 수 있습니다.

결론

Docker Compose는 여러 컨테이너로 이루어진 애플리케이션을 손쉽게 관리하고 실행할 수 있는 강력한 도구입니다. YAML 파일을 통한 설정 관리와 환경 변수 파일을 활용한 민감한 정보 보호로 개발 환경과 운영 환경에서의 일관성을 유지할 수 있습니다. 복잡한 컨테이너 의존성도 간단히 관리할 수 있으며, 다양한 프로젝트에 적용해 보시기 바랍니다.

Docker Compose를 통해 개발과 운영 환경에서의 생산성을 크게 향상시킬 수 있으므로, 효율적인 컨테이너 관리를 위한 도구로 적극 활용해 보세요!

반응형

'Computer Science > linux' 카테고리의 다른 글

Argo workflow 설치와 예제  (0) 2024.09.22
Dockerfile 작성하기  (1) 2024.09.15
Docker 사용하기  (0) 2024.09.15
Slurm 설치  (0) 2024.06.05
사용자 계정 관리 및 조직의 구조화 툴 (LDAP)  (0) 2024.05.17
반응형

Dockerfile은 Docker 이미지를 빌드하기 위한 설정 파일입니다. 이 파일은 애플리케이션을 어떻게 컨테이너로 패키징할지 정의하는 스크립트입니다. Dockerfile을 통해 필요한 베이스 이미지부터 애플리케이션의 의존성 설치, 환경 변수 설정, 실행 명령어까지 정의할 수 있습니다. 아래는 Dockerfile을 작성하는 방법을 단계별로 설명합니다.


1. Dockerfile 기본 구조

Dockerfile의 기본적인 구성 요소는 다음과 같습니다:

  1. 베이스 이미지 설정: FROM 키워드를 사용하여 어떤 베이스 이미지를 사용할지 정의합니다.
  2. 의존성 설치: RUN 명령어로 애플리케이션이 실행되는 데 필요한 패키지나 의존성을 설치합니다.
  3. 작업 디렉토리 설정: WORKDIR 명령어로 애플리케이션을 실행할 디렉토리를 설정합니다.
  4. 파일 복사: COPY나 ADD 명령어로 호스트 시스템의 파일을 컨테이너로 복사합니다.
  5. 명령어 실행: CMD나 ENTRYPOINT 명령어로 컨테이너가 실행될 때 기본으로 실행할 명령을 설정합니다.

2. Dockerfile 작성 예제

1. 간단한 Node.js 애플리케이션의 Dockerfile 예제

# 1. 베이스 이미지 설정 (Node.js LTS 버전 사용)
FROM node:16

# 2. 애플리케이션의 작업 디렉토리 설정
WORKDIR /usr/src/app

# 3. 패키지 파일을 컨테이너로 복사
COPY package*.json ./

# 4. 의존성 설치
RUN npm install

# 5. 소스 코드를 컨테이너로 복사
COPY . .

# 6. 애플리케이션 실행 포트 설정
EXPOSE 8080

# 7. 컨테이너가 실행될 때 실행할 명령어
CMD ["npm", "start"]

이 Dockerfile은 다음 단계를 수행합니다:

  • 베이스 이미지 설정: Node.js 16 버전을 사용하는 이미지에서 시작.
  • 작업 디렉토리 설정: /usr/src/app 디렉토리를 컨테이너의 기본 작업 디렉토리로 지정.
  • 의존성 설치: package.json을 복사하고 npm install 명령어로 의존성을 설치.
  • 애플리케이션 복사: 현재 디렉토리의 파일을 컨테이너로 복사.
  • 포트 설정: 8080 포트를 컨테이너에서 노출.
  • 명령어 설정: 컨테이너가 실행되면 npm start로 애플리케이션을 시작.

2. Python Flask 애플리케이션 Dockerfile 예제

# 1. 베이스 이미지 설정
FROM python:3.9-slim

# 2. 환경 변수 설정
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

# 3. 작업 디렉토리 설정
WORKDIR /app

# 4. 의존성 설치
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 5. 애플리케이션 소스 복사
COPY . .

# 6. 애플리케이션 실행 명령어
CMD ["flask", "run", "--host=0.0.0.0", "--port=5000"]

이 Dockerfile은:

  • Python 3.9을 베이스 이미지로 사용하고 있습니다.
  • ENV 명령어로 환경 변수를 설정하여 Python 실행 시 캐시 파일을 기록하지 않게 설정.
  • requirements.txt 파일을 복사한 후 pip로 의존성을 설치.
  • 애플리케이션을 복사한 후 Flask 애플리케이션을 실행.

3. 주요 Dockerfile 명령어 설명

1. FROM

Dockerfile의 첫 번째 명령으로, 사용할 베이스 이미지를 지정합니다. 이 이미지는 모든 Dockerfile이 필수로 포함해야 합니다.

2. WORKDIR

작업 디렉토리를 설정합니다. 이후에 실행되는 모든 명령은 이 디렉토리에서 실행됩니다.

3. COPY

호스트 시스템의 파일을 컨테이너의 특정 경로로 복사합니다.

4. RUN

컨테이너가 빌드될 때 실행할 명령어를 지정합니다. 주로 패키지 설치, 파일 권한 설정 등 이미지 빌드 시 필요한 작업을 처리합니다.

5. CMD

컨테이너가 실행될 때 기본적으로 실행할 명령어를 설정합니다. 컨테이너가 시작할 때마다 이 명령어가 실행됩니다.

6. EXPOSE

컨테이너가 사용할 포트를 지정합니다. 실제 포트 매핑은 docker run 명령어에서 설정합니다.

7. ENTRYPOINT

CMD와 비슷하지만, 컨테이너 실행 시 항상 실행되며 주로 스크립트를 실행할 때 사용합니다. CMD는 추가 명령을 받을 수 있지만, ENTRYPOINT는 고정된 명령을 실행합니다.


4. Dockerfile을 사용하여 이미지 빌드하기

Dockerfile을 작성한 후, Docker 이미지를 빌드하려면 다음 명령어를 실행합니다:

docker build -t my_image_name .
  • -t 옵션은 이미지의 태그를 지정하는 데 사용됩니다.
  • .는 Dockerfile이 위치한 디렉토리를 의미합니다.

이미지 빌드가 완료되면 docker images 명령어로 빌드된 이미지를 확인할 수 있습니다.

docker images

5. 최적화된 Dockerfile 작성 팁

  1. 캐시 활용: RUN, COPY 명령어는 Docker 빌드 중 캐시가 사용됩니다. 의존성을 먼저 설치한 후, 애플리케이션 파일을 복사하면 소스 코드 변경 시에도 의존성 설치 단계는 캐시를 사용하게 되어 빌드 시간을 줄일 수 있습니다.
  2. 멀티스테이지 빌드: 애플리케이션 빌드와 런타임 환경을 분리하여 이미지 크기를 줄일 수 있습니다.
  3. 이미지 최소화: 불필요한 패키지를 설치하지 않거나, slim 버전과 같은 경량 이미지를 사용하여 이미지 크기를 최소화합니다.

Dockerfile을 통해 애플리케이션을 컨테이너화하고, 어디서나 동일한 환경에서 실행할 수 있는 이미지로 패키징할 수 있습니다. 이를 통해 배포 자동화와 일관된 개발 환경을 유지할 수 있습니다.

반응형

'Computer Science > linux' 카테고리의 다른 글

Argo workflow 설치와 예제  (0) 2024.09.22
Docker Compose 사용하기  (0) 2024.09.20
Docker 사용하기  (0) 2024.09.15
Slurm 설치  (0) 2024.06.05
사용자 계정 관리 및 조직의 구조화 툴 (LDAP)  (0) 2024.05.17
반응형

Docker란?

Docker는 애플리케이션을 컨테이너로 패키징하여 실행할 수 있는 오픈 소스 플랫폼입니다. 컨테이너는 애플리케이션과 그 의존성을 함께 묶어 격리된 환경에서 실행되도록 합니다. 이를 통해 개발자는 애플리케이션을 어디서나 동일한 환경에서 실행할 수 있으며, 배포 및 관리를 단순화할 수 있습니다. Docker는 특히 가상 머신보다 더 가볍고 빠르게 애플리케이션을 실행할 수 있는 장점을 가지고 있어, 개발과 운영 환경에서 널리 사용되고 있습니다.

Docker의 주요 특징:

  • 컨테이너: 격리된 환경에서 애플리케이션을 실행할 수 있어, 다른 컨테이너나 시스템에 영향을 미치지 않음.
  • 이미지: 애플리케이션과 의존성을 포함한 패키지로, 한번 빌드하면 어디서나 동일한 환경에서 실행 가능.
  • 경량성: 가상 머신보다 적은 리소스를 사용하며, 더 빠른 배포 및 실행이 가능.

Docker의 장점

1. 애플리케이션의 이식성

Docker는 애플리케이션을 컨테이너화하여 운영 체제의 종류나 환경에 상관없이 동일하게 실행할 수 있습니다. 이를 통해 개발, 테스트, 프로덕션 환경 간에 애플리케이션의 이식성을 보장할 수 있습니다.

2. 빠르고 경량

컨테이너는 가상 머신에 비해 매우 가볍고 빠릅니다. 가상 머신은 각각 운영 체제를 포함하는 반면, Docker 컨테이너는 호스트 운영 체제의 커널을 공유하므로 시작 속도와 리소스 사용량이 적습니다.

3. 개발 및 배포의 일관성

Docker 이미지를 사용하면 애플리케이션을 어디서나 동일한 환경에서 실행할 수 있습니다. 개발자가 작성한 코드를 프로덕션 환경에 배포할 때, 환경 차이로 인한 문제를 최소화할 수 있습니다.

4. 버전 관리 및 롤백

Docker 이미지는 여러 레이어로 구성되며, 이미지의 버전을 관리할 수 있습니다. 이를 통해 쉽게 롤백하거나 특정 버전의 애플리케이션을 실행할 수 있습니다.

5. 확장성

Docker는 클러스터링 및 오케스트레이션 도구(Kubernetes 등)와 결합하여 대규모 애플리케이션을 쉽게 확장할 수 있습니다. 이를 통해 클라우드 환경에서의 자원 관리와 확장성을 극대화할 수 있습니다.

Docker의 단점

1. 복잡한 네트워킹 설정

Docker의 네트워킹은 복잡할 수 있으며, 특히 여러 컨테이너 간의 통신이나 클러스터링 환경에서는 네트워크 설정에 대한 깊은 이해가 필요합니다.

2. 컨테이너 보안 문제

Docker는 기본적으로 root 권한으로 실행되기 때문에, 보안 취약점이 발견되면 컨테이너 탈출 공격 등이 발생할 수 있습니다. 이를 방지하기 위해 rootless Docker나 보안 강화 설정이 필요합니다.

3. 상태 관리의 어려움

컨테이너는 기본적으로 비상태성(stateless)으로 설계되어 있습니다. 이를 사용하여 영속적인 데이터를 저장하거나 관리하는 것은 다소 복잡할 수 있으며, 적절한 볼륨 관리가 필요합니다.

 

1. Rootless Docker와 일반 Docker 차이 및 설치 방법

sudo systemctl enable docker
sudo systemctl start docker

1. 일반 Docker 설치 방법

Ubuntu에서 일반 Docker를 설치하려면 다음 단계를 따릅니다:

  • Docker 패키지 설치를 위한 필수 패키지를 먼저 설치합니다.
sudo systemctl enable docker
sudo systemctl start docker
  • Docker GPG 키를 추가한 후, Docker 공식 저장소를 설정합니다.
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  • Docker 패키지를 설치합니다.
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  • Docker 설치 후, Docker 서비스를 활성화하고 시작합니다.
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release

2. Docker 사용 시 그룹에 사용자 추가

Docker는 기본적으로 root 권한으로 실행되기 때문에, sudo 없이 Docker 명령어를 실행하려면 사용자를 docker 그룹에 추가해야 합니다. 다음 명령어를 실행하여 현재 사용자를 docker 그룹에 추가합니다.

sudo usermod -aG docker $USER

사용자를 docker 그룹에 추가한 후, 적용을 위해 로그아웃하고 다시 로그인합니다. 또는 아래 명령어를 실행하여 새로 추가된 그룹을 바로 적용할 수 있습니다.

newgrp docker

이제 sudo 없이 Docker 명령을 실행할 수 있습니다.

docker run hello-world

Rootless Docker 설치 방법

Rootless Docker는 root 권한 없이 컨테이너를 실행할 수 있도록 지원하는 도구입니다. 보안이 중요한 환경에서 주로 사용되며, 다음과 같이 설치할 수 있습니다:

  1. 일반 Docker를 먼저 설치하고,
  2. Rootless 설정을 활성화합니다.
dockerd-rootless-setuptool.sh install
export PATH=/usr/bin:$PATH
export DOCKER_HOST=unix:///run/user/$(id -u)/docker.sock
systemctl --user start docker

Rootless Docker는 루트 권한 없이 실행되기 때문에 보안성 측면에서 매우 유리합니다. 특히 여러 사용자가 동일한 서버에서 컨테이너를 실행하거나, 루트 권한을 요구하지 않는 환경에서 적합합니다.


2. Docker 컨테이너에서 볼륨 권한 문제 해결

Docker 컨테이너에서 호스트 파일 시스템과 볼륨을 마운트할 때, 컨테이너가 생성한 파일은 기본적으로 root 권한으로 작성됩니다. 이로 인해 호스트 시스템에서 권한 문제가 발생할 수 있습니다.

문제 상황

  • 컨테이너에서 생성한 파일이 root 소유자로 설정되어, 호스트의 일반 사용자가 해당 파일을 수정하거나 삭제할 수 없습니다.

해결 방법

  • 컨테이너 실행 시 특정 사용자로 실행: --user 옵션을 사용하여 컨테이너 내부에서 파일을 생성하는 사용자의 권한을 설정할 수 있습니다. 이 방법은 호스트 시스템의 사용자와 권한을 맞추는 데 유용합니다.
docker run -v /host/path:/container/path --user $(id -u):$(id -g) my_container
  • 권한 수정: 컨테이너 내에서 chown 명령을 사용하여 마운트된 디렉토리의 소유권을 변경할 수 있습니다.
docker run -v /host/path:/container/path my_container bash -c "chown -R user:group /container/path && your_command"

이 방법을 통해 컨테이너 내에서 생성된 파일의 소유자를 호스트 시스템의 사용자와 일치시켜, 권한 문제를 해결할 수 있습니다.


3. Rootless Docker 사용이 적합한 상황

Rootless Docker는 다음과 같은 경우에 적합합니다:

보안이 중요한 환경

Rootless Docker는 root 권한을 사용하지 않기 때문에, 컨테이너 내부에서 발생하는 보안 문제가 호스트 시스템에 영향을 미치지 않습니다. 여러 사용자가 동일한 서버에서 컨테이너를 실행하거나, 멀티 테넌트 시스템을 운영하는 환경에서 유용합니다.

루트 권한을 얻기 어려운 환경

루트 권한을 얻을 수 없는 공유 서버나 클라우드 환경에서는 Rootless Docker를 사용하여 비루트 사용자로도 컨테이너를 실행할 수 있습니다.

컨테이너 격리 테스트

보안 취약성 테스트나 컨테이너의 격리성에 대한 테스트를 진행할 때도 Rootless Docker는 유용합니다. 루트 권한을 사용하지 않기 때문에, 더 높은 수준의 보안을 유지하면서 테스트를 수행할 수 있습니다.

 

Docker는 다양한 환경에서 애플리케이션을 손쉽게 배포하고 관리할 수 있는 도구이지만, 컨테이너와 호스트 시스템 간의 권한 문제는 종종 발생합니다. 특히 컨테이너 내부에서 생성된 파일의 권한 문제를 해결하거나, 보안이 중요한 환경에서 Rootless Docker를 사용하는 방법을 잘 이해하면, 보다 안전하고 효율적인 Docker 사용이 가능합니다.

반응형

'Computer Science > linux' 카테고리의 다른 글

Docker Compose 사용하기  (0) 2024.09.20
Dockerfile 작성하기  (1) 2024.09.15
Slurm 설치  (0) 2024.06.05
사용자 계정 관리 및 조직의 구조화 툴 (LDAP)  (0) 2024.05.17
Docker와 MariaDB연결하기  (0) 2022.08.24
반응형

서론: NGS 데이터 분석 완료 이벤트 처리 방법

NGS(Next-Generation Sequencing) 기술을 이용한 연구에서, 시퀀싱 완료나 분석 완료 이벤트가 발생했을 때 이를 자동으로 처리하거나 알림을 받는 방법에 대해 고민하는 상황이 종종 발생합니다. 많은 기술에서 이미 이러한 기능을 제공하고 있으며, 특히 Slack 같은 협업 도구는 웹훅(Webhook) 기능을 통해 이벤트 알림을 쉽게 설정할 수 있습니다. 하지만, 만약 이러한 기능을 웹 애플리케이션에 직접 구현하고 싶다면 고려해야 할 요소들이 있습니다. 이 글에서는 **웹훅(Webhook)**과 Apache Kafka를 비교하고, 두 기술을 활용해 알림을 구현하는 방법을 소개합니다.


1. 웹훅(Webhook)과 Apache Kafka의 차이점

웹훅(Webhook)

**웹훅(Webhook)**은 HTTP 요청을 통해 실시간으로 데이터를 전달하는 방식입니다. 특정 이벤트가 발생할 때, 서버에서 즉시 알림이나 데이터를 외부 서버로 전송할 수 있는 간단한 방법을 제공합니다. 특히, 실시간 알림이나 간단한 데이터 전달에 적합합니다.

  • 동작 원리: 이벤트 발생 시 대상 서버로 HTTP POST 요청을 보냄.
  • 통신 방식: 푸시(push) 방식으로 즉각적으로 데이터를 전달.
  • 사용 예시: NGS 데이터 분석이 완료되었을 때 웹 애플리케이션에 알림을 전송.
  • 장점:
    • 설정이 간단하고, HTTP 기반으로 다양한 애플리케이션과 쉽게 연동 가능.
    • 실시간 처리에 적합하며, 간단한 이벤트 전달에서 유리함.
  • 단점:
    • 알림 전송이 실패할 경우 별도의 재시도 로직을 직접 구현해야 함.
    • 이벤트가 발생할 때마다 대상 서버가 실시간으로 응답해야 함.

Apache Kafka

Kafka는 대용량 데이터를 효율적으로 처리하기 위한 분산 메시징 시스템입니다. 웹훅이 단순한 실시간 알림에 적합하다면, Kafka는 대규모의 이벤트 스트리밍과 비동기 메시징 처리에 유리합니다.

  • 동작 원리: 이벤트가 발생하면 이를 메시지로 Kafka 브로커에 저장하고, 필요할 때 해당 메시지를 컨슈머가 가져가서 처리.
  • 통신 방식: 풀(pull) 방식으로, 컨슈머가 준비된 시점에 데이터를 가져옴.
  • 사용 예시: NGS 데이터를 실시간으로 스트리밍하고, 후속 분석을 비동기적으로 처리.
  • 장점:
    • 매우 높은 확장성과 내구성. 대규모 데이터를 처리하는 데 적합.
    • 이벤트를 비동기적으로 처리하며, 실패한 이벤트에 대한 재처리가 용이.
  • 단점:
    • 설정이 복잡하고 운영 비용이 높음.
    • 실시간 알림보다는 대용량 데이터 처리에 더 적합.

2. 웹훅과 Kafka의 비교 요약

요소웹훅(Webhook)Kafka
통신 방식 푸시(push) 풀(pull)
메시지 처리 방식 실시간 알림 비동기 처리 및 큐 기반
설정 복잡도 간단 복잡
확장성 제한적 (대규모 처리에 부적합) 매우 높은 확장성
실패 처리 직접 재시도 로직 필요 메시지 재처리 가능
적용 예시 간단한 실시간 알림 (예: NGS 분석 완료) 대규모 스트리밍 데이터 처리

3. 웹 애플리케이션에서 웹훅 직접 구현하기

웹 애플리케이션에서 웹훅을 직접 구현하는 방법은 비교적 간단합니다. 웹 서버에서 특정 이벤트가 발생하면 해당 이벤트를 처리하는 다른 시스템(예: 알림 시스템)에 HTTP 요청을 보내는 방식입니다. 이를 통해 이벤트 발생 시 실시간으로 알림을 받을 수 있습니다.

구현 단계:

  1. 이벤트 트리거 설정: NGS 시퀀싱이나 분석이 완료되면 웹훅을 호출하도록 이벤트를 설정.
  2. HTTP 요청 전송: 해당 이벤트가 발생하면, 대상 서버로 HTTP POST 요청을 보내 데이터를 전달.
  3. 대상 서버에서 처리: 대상 서버는 해당 요청을 받아 알림을 표시하거나 추가적인 처리를 진행.

예시 코드 (Python Flask 기반 웹훅):

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    data = request.json
    print(f"Webhook received: {data}")
    # 여기서 데이터를 처리하거나 알림을 띄움
    return jsonify({"status": "success"}), 200

if __name__ == '__main__':
    app.run(port=5000)

이 코드는 웹훅을 받아 처리하는 간단한 Flask 서버 예제입니다. NGS 분석 완료 시 이 서버로 HTTP 요청을 보내 알림을 처리할 수 있습니다.


결론

NGS 기술에서 시퀀싱 완료나 분석 완료와 같은 이벤트를 웹 애플리케이션에 알람으로 통합하고자 할 때, **웹훅(Webhook)**과 Kafka는 각각의 장점과 단점을 가지고 있습니다. 간단한 실시간 알림 처리를 원한다면 웹훅이 적합하며, 대규모 데이터 스트리밍이나 비동기적인 처리가 필요하다면 Kafka를 고려하는 것이 좋습니다. 상황에 맞는 적절한 기술 선택이 중요합니다.


 
 
4o

나의 말:

웹훅을 호출하는건 watchdog에서 하면 되겠지? 그 코드도 알려줘
 

ChatGPT의 말:

ChatGPT

네, 웹훅(Webhook)을 호출하는 작업은 파일 또는 디렉터리의 변경을 감지하는 Watchdog 라이브러리를 사용하여 처리할 수 있습니다. Watchdog는 파일 시스템 이벤트를 감지하고, 해당 이벤트가 발생했을 때 특정 작업(예: 웹훅 호출)을 수행할 수 있습니다.

여기서는 Python의 Watchdog 라이브러리를 사용하여 파일 시스템 변화를 감지하고, 변동이 있을 때 웹훅을 호출하는 예시 코드를 보여드리겠습니다.

1. Watchdog 설치

먼저, Watchdog 라이브러리를 설치해야 합니다. 다음 명령어를 사용하여 설치하세요:

bash
코드 복사
pip install watchdog

2. Watchdog과 웹훅 호출 코드

import time
import requests
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

# 웹훅을 호출하는 함수
def trigger_webhook(event):
    url = 'http://your-webhook-url.com/webhook'
    data = {
        'event': event.event_type,
        'file': event.src_path
    }
    response = requests.post(url, json=data)
    if response.status_code == 200:
        print(f"Webhook triggered successfully: {event.src_path}")
    else:
        print(f"Failed to trigger webhook: {response.status_code}")

# 파일 시스템 이벤트 핸들러 클래스
class WatchdogHandler(FileSystemEventHandler):
    def on_modified(self, event):
        print(f"File modified: {event.src_path}")
        trigger_webhook(event)  # 파일 변경 감지 시 웹훅 호출

    def on_created(self, event):
        print(f"File created: {event.src_path}")
        trigger_webhook(event)  # 파일 생성 감지 시 웹훅 호출

    def on_deleted(self, event):
        print(f"File deleted: {event.src_path}")
        trigger_webhook(event)  # 파일 삭제 감지 시 웹훅 호출

# 감시할 디렉토리 설정 및 감시자(Observer) 설정
if __name__ == "__main__":
    path = "/path/to/monitor"  # 감시할 디렉토리 경로
    event_handler = WatchdogHandler()
    observer = Observer()
    observer.schedule(event_handler, path, recursive=True)  # 재귀적으로 하위 디렉토리도 감시

    observer.start()
    try:
        while True:
            time.sleep(1)  # 계속 실행
    except KeyboardInterrupt:
        observer.stop()  # 종료 시 감시 중단
    observer.join()

3. 코드 설명

  • trigger_webhook(event) 함수: 파일 시스템 이벤트가 발생했을 때 웹훅을 호출하는 함수입니다. requests.post()를 사용해 지정한 URL로 HTTP POST 요청을 보냅니다.
  • WatchdogHandler 클래스: Watchdog의 이벤트 핸들러입니다. 파일이 생성, 수정, 삭제되는 이벤트를 감지하고, 해당 이벤트가 발생할 때마다 trigger_webhook() 함수를 호출합니다.
  • Observer: 지정한 디렉토리를 감시하며, 파일 시스템 이벤트를 핸들러로 전달합니다.

4. 사용 예시

  • NGS 데이터 분석 디렉토리를 감시할 수 있습니다. 분석 완료 파일이 생성되거나 수정되면 Watchdog이 이를 감지하여 웹훅을 호출하게 설정할 수 있습니다.
 
 
4o

나의 말:

근데 이러면 웹훅은 이벤트 마다 설정해줘야하는거 같은데 kafka는 초기 설정만 해두면 변경하는게 간단할거같아
 

ChatGPT의 말:

ChatGPT

맞습니다! Kafka는 특히 대규모 이벤트 스트리밍이나 다양한 이벤트 처리가 필요한 경우 더 적합한 선택일 수 있습니다. 웹훅은 특정 이벤트마다 HTTP 요청을 설정해줘야 하므로 이벤트 수가 많아지면 관리가 번거로울 수 있습니다. 반면에 Kafka는 초기 설정만 해두면 다양한 이벤트를 중앙에서 처리할 수 있으며, 새로운 이벤트를 추가할 때도 비교적 간단합니다.

Kafka의 주요 장점:

  1. 확장성: Kafka는 대규모의 이벤트 스트림을 처리할 수 있으며, 여러 이벤트를 동시에 처리하는 데 탁월합니다. 새로운 이벤트를 처리할 때 토픽을 추가하는 것만으로 쉽게 확장할 수 있습니다.
  2. 유연성: 프로듀서(이벤트 생성자)와 컨슈머(이벤트 처리자) 간의 결합이 느슨해서, 하나의 이벤트를 여러 컨슈머가 구독하여 각각 다른 방식으로 처리할 수 있습니다.
  3. 재처리 가능성: Kafka는 이벤트를 일정 기간 저장하므로, 이벤트가 처리되지 않거나 실패한 경우에도 나중에 다시 처리할 수 있는 유연성을 제공합니다.
  4. 비동기 처리: 이벤트가 즉시 처리되지 않아도 상관없는 경우, 비동기적으로 이벤트를 처리할 수 있어 시스템 부하를 줄일 수 있습니다.

Kafka 사용 시의 흐름:

  1. 이벤트 발생: NGS 시퀀싱 완료나 데이터 분석 완료와 같은 이벤트가 발생하면, 해당 이벤트를 Kafka의 **토픽(Topic)**에 전달합니다.
  2. 이벤트 저장: Kafka는 이 이벤트를 큐에 저장하고, 원하는 컨슈머가 이를 처리할 준비가 되었을 때 메시지를 꺼내갑니다.
  3. 컨슈머에서 처리: 각 컨슈머는 해당 이벤트를 처리하고, 결과를 데이터베이스에 저장하거나 다른 시스템으로 전달할 수 있습니다. 예를 들어, Slack에 알림을 보내거나 웹 애플리케이션에 표시할 수 있습니다.

Kafka 사용 예시:

  1. 프로듀서 (이벤트 생성자):
from kafka import KafkaProducer
import json

producer = KafkaProducer(bootstrap_servers='localhost:9092', value_serializer=lambda v: json.dumps(v).encode('utf-8'))

def send_event(event_type, data):
    event = {"type": event_type, "data": data}
    producer.send('ngs-events', value=event)
    producer.flush()

# NGS 분석 완료 이벤트 발생 시 호출
send_event('NGS_ANALYSIS_COMPLETE', {'sample_id': 123, 'status': 'completed'})

2. 컨슈머 (이벤트 처리자):

from kafka import KafkaConsumer
import json

consumer = KafkaConsumer('ngs-events', bootstrap_servers='localhost:9092', value_deserializer=lambda v: json.loads(v.decode('utf-8')))

for message in consumer:
    event = message.value
    print(f"Received event: {event}")
    # 이벤트 타입에 따라 다른 처리 수행
    if event['type'] == 'NGS_ANALYSIS_COMPLETE':
        print(f"Sample {event['data']['sample_id']} completed with status {event['data']['status']}")

이 코드에서는 프로듀서가 이벤트를 Kafka에 보내고, 컨슈머가 이를 받아 처리합니다. 새로운 이벤트가 생길 때마다 이벤

트 핸들러를 추가하거나 수정하는 것이 Kafka에서는 매우 간단하며, 대규모 이벤트 처리에 적합합니다.

결론:

  • 웹훅은 간단한 이벤트 처리나 알림에 적합하지만, 많은 수의 이벤트를 처리하거나 복잡한 데이터 흐름이 필요할 경우 관리가 어렵습니다.
  • Kafka는 다양한 이벤트를 중앙에서 관리하고, 확장성과 유연성이 뛰어나므로, 특히 대규모 시스템이나 복잡한 이벤트 처리가 필요한 경우 더 효율적인 선택이 될 수 있습니다.

따라서, 이벤트의 수가 많고, 확장 가능성을 고려해야 한다면 Kafka를 사용하는 것이 더 효율적일 것입니다.

 

그러나 kafka에서 수신되는 메시지를 slack으로 전송하고 싶다면 아래 방법을 적용할 수 있습니다.

 

from kafka import KafkaProducer
import requests
import json

# Slack Webhook URL
webhook_url = 'https://hooks.slack.com/services/your/webhook/url'

# Kafka Producer 설정
producer = KafkaProducer(bootstrap_servers='localhost:9092')

# Slack으로 메시지 전송 함수
def send_to_slack(message):
    data = {'text': message}
    response = requests.post(webhook_url, data=json.dumps(data),
                             headers={'Content-Type': 'application/json'})
    if response.status_code != 200:
        raise ValueError(f'Slack API Error: {response.status_code}, {response.text}')

# Kafka에 메시지 전송 전에 Slack으로 메시지 보내기
def send_message_to_kafka_and_slack(topic, message):
    # Slack으로 메시지 보내기
    send_to_slack(f"New Kafka message: {message}")
    # Kafka로 메시지 보내기
    producer.send(topic, value=message.encode('utf-8'))

# 메시지 전송 예시
send_message_to_kafka_and_slack('my_topic', 'This is a test message')
반응형
반응형

파이썬에서 동적 속성과 프로퍼티(dynamic attributes and properties)는 객체 지향 프로그래밍에서 중요한 개념으로, 객체의 속성을 더 유연하고 강력하게 관리할 수 있도록 도와줍니다. 이 두 가지 개념을 이해하면, 더 효율적이고 유지보수하기 쉬운 코드를 작성할 수 있습니다. 아래에 각각의 개념을 자세히 설명하겠습니다.

1. 동적 속성 (Dynamic Attributes)

파이썬에서는 객체에 동적으로 속성을 추가하거나 제거할 수 있습니다. 이것은 파이썬의 유연한 클래스 구조 덕분에 가능한데, 다른 많은 프로그래밍 언어에서는 클래스에 정의된 속성만을 사용할 수 있는 경우가 많습니다.

 

동적 속성의 사용 사례

동적 속성은 객체의 속성을 런타임에 결정해야 하거나, 객체가 다루는 데이터 구조가 매우 유동적일 때 유용합니다. 예를 들어, JSON 응답에서 키를 동적으로 객체 속성으로 변환할 때 사용할 수 있습니다.

 

2. 프로퍼티 (Properties)

프로퍼티는 파이썬에서 제공하는 특수한 속성으로, 속성에 접근할 때 특정한 동작을 수행할 수 있게 해줍니다. 예를 들어, 속성의 값을 가져오거나 설정할 때 추가적인 로직을 수행할 수 있습니다.

 

프로퍼티의 사용 사례

프로퍼티는 다음과 같은 경우에 유용합니다:

  • 속성의 값을 가져오거나 설정할 때 검증 로직을 추가해야 할 때
  • 속성 값을 계산한 후 반환해야 할 때 (지연된 계산)
  • 속성 접근 방식을 일관되게 유지하면서 내부 구현을 변경하고 싶을 때

 

데이터 랭글링과 동적 속성의 관계

데이터 랭글링 과정에서는 데이터의 형태가 일정하지 않거나, 데이터의 구조가 런타임에 결정될 수 있습니다. 이러한 상황에서 파이썬의 동적 속성은 매우 유용하게 사용됩니다. 예를 들어, JSON이나 XML과 같은 비정형 데이터를 객체로 변환할 때, 동적 속성을 사용하면 해당 데이터를 쉽게 다룰 수 있습니다.

 

동적 속성을 이용한 데이터 랭글링의 장점

  1. 유연성: 데이터를 구조화하는 방법이 사전에 정의되지 않았을 때, 동적 속성을 사용하면 어떤 형태의 데이터도 쉽게 객체로 변환할 수 있습니다.
  2. 유지보수성: 새로운 데이터 필드가 추가되거나 변경될 때, 코드 수정이 최소화됩니다. 동적 속성을 통해 데이터를 자동으로 객체 속성으로 변환할 수 있기 때문입니다.
  3. 가독성: 동적으로 생성된 속성을 통해 데이터에 접근하는 것이, 복잡한 딕셔너리나 리스트 구조를 탐색하는 것보다 직관적이고 읽기 쉬운 코드를 작성하는 데 도움이 됩니다.

실제 활용 예시

동적 속성을 사용한 데이터 랭글링은 특히 웹 애플리케이션, API 응답 처리, 데이터 분석에서 자주 사용됩니다. 예를 들어, API 응답 데이터를 객체로 변환하여 사용하는 경우, 새로운 데이터 필드가 응답에 추가되더라도 별도의 코드 수정 없이 그 필드를 동적으로 추가하여 처리할 수 있습니다.

요약하자면, "동적 속성을 이용한 데이터 랭글링"은 파이썬의 동적 속성을 활용하여 다양한 형태의 데이터를 유연하게 다루고, 이를 통해 데이터 변환, 정제, 조작을 더 효율적으로 수행하는 방법을 의미합니다.

 

import json

class DynamicObject:
    def __init__(self, **entries):
        self.__dict__.update(entries)

# JSON 데이터를 파싱하여 파이썬 딕셔너리로 변환
json_data = '{"name": "Alice", "age": 30, "city": "New York"}'
data = json.loads(json_data)

# 동적 속성을 사용하여 객체로 변환
obj = DynamicObject(**data)

# 동적으로 추가된 속성에 접근
print(obj.name)  # 출력: Alice
print(obj.age)   # 출력: 30
print(obj.city)  # 출력: New York

 

json 파일을 원래 상태 그대로 다루다보면, 아래와 같이 번거로운 구문이 반복된다.

feed['Schedule']['speakers'][0]['name']

 

동적 속성을 이용하여 아래와 같이 사용할 수 있다면 아주 편할 것이다.

raw_feed = load()
feed = FrozenJSON(raw_feed)
print(len(feed.Schedule.speakers))
print(sorted(feed.Schedule.keys()))
print(feed.Schedule.speakers[0].name)

 

FrozenJSON class는 위와 같은 기능을 구현하고 있다.

가장 핵심은 __getattr__() method이다. 피드가 순회되면서 내포된 데이터 구조체가 차례로 FrozenJSON 포켓으로 변환된다.

from collections import abc
from loader import load

class FrozenJSON:
    '''
    점 표기법을 이용하여 JSON 객체를 순회하는
    읽기 전용 parsed class
    '''

    def __init__(self, mapping):
        self.__data = dict(mapping)

    def __getattr__(self, name):
        if hasattr(self.__data, name):
            return getattr(self.__data, name)
        else:
            return FrozenJSON.build(self.__data[name])

    @classmethod
    def build(cls, obj):
        if isinstance(obj, abc.Mapping):
            return cls(obj)
        elif isinstance(obj, abc.MutableSequence):
            return [cls.build(item) for item in obj]
        else:
            return obj


raw_feed = load()
feed = FrozenJSON(raw_feed)
print(len(feed.Schedule.speakers))
print(sorted(feed.Schedule.keys()))
print(feed.Schedule.speakers[0].name)

 

프로퍼티의 기본 사용법

프로퍼티는 property() 함수를 사용하거나, 데코레이터 @property와 그와 관련된 데코레이터(@<property_name>.setter, @<property_name>.deleter)를 사용하여 정의할 수 있습니다.

class MyClass:
    def __init__(self, value):
        self._value = value
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Value must be non-negative")
        self._value = new_value

    @value.deleter
    def value(self):
        del self._value

# 사용 예시
obj = MyClass(10)
print(obj.value)  # 10

obj.value = 20  # 정상적으로 값이 설정됨
print(obj.value)  # 20

obj.value = -5  # ValueError 발생

 

1. 프로퍼티에서 getter를 사용하는 경우

파이썬에서는 @property 데코레이터를 사용하여 속성 접근 시 자동으로 호출되는 getter 메서드를 정의할 수 있습니다. 이 방법은 속성에 접근할 때 obj.attribute 형태로 간단하게 사용할 수 있습니다.

장점

  1. 직관적이고 간결한 문법:
  2. 캡슐화:
  3. 속성에 접근할 때 추가 로직을 쉽게 추가:
  4. 유지보수성:

단점

  1. 은밀한 동작:
  2. 디버깅 어려움:

값을 얻기 위한 메서드를 따로 작성하는 경우

이 방법에서는 get_value()와 같은 이름으로 값을 얻기 위한 메서드를 직접 정의합니다. 이는 명시적으로 값을 얻기 위한 함수 호출임을 나타냅니다.

장점

  1. 명확성:
  2. 의도 표현:
  3. 구조적 일관성:

단점

  1. 사용의 불편함:
  2. 캡슐화의 부족:

결론: 언제 어떤 것을 사용할지

  • 프로퍼티(getter) 사용:
    • 속성 접근처럼 보이지만, 내부적으로 추가 로직이 필요한 경우.
    • 코드의 가독성과 간결성을 중시할 때.
    • 객체의 속성을 외부에 노출하면서도 캡슐화를 유지하고 싶을 때.
  • 메서드 사용:
    • 접근하는 값이 계산이나 복잡한 로직에 의해 생성되는 경우.
    • 메서드 호출임을 명확히 표현하고 싶을 때.
    • 코드의 명확성과 의도 표현이 중요한 경우.

 

프로퍼티 팩토리

"프로퍼티 팩토리(Property Factory)"는 파이썬에서 프로퍼티를 동적으로 생성하거나, 다수의 프로퍼티를 공통된 패턴에 따라 쉽게 정의하기 위해 사용하는 방법입니다. 즉, 객체의 속성을 정의할 때, 비슷한 패턴이나 규칙에 따라 다수의 속성을 자동으로 생성하고자 할 때 유용합니다.

 

def make_property(attr_name):
    def getter(self):
        return getattr(self, f"_{attr_name}")

    def setter(self, value):
        if value < 0:
            raise ValueError(f"{attr_name} cannot be negative")
        setattr(self, f"_{attr_name}", value)

    return property(getter, setter)

class MyClass:
    name = make_property('name')
    age = make_property('age')

    def __init__(self, name, age):
        self._name = name
        self._age = age

# 사용 예시
obj = MyClass("Alice", 30)
print(obj.age)  # 출력: 30

# 음수 값을 설정하려고 하면 ValueError 발생
try:
    obj.age = -5
except ValueError as e:
    print(e)  # 출력: age cannot be negative

 

 

반응형

'Computer Science > python' 카테고리의 다른 글

연산자 오버로딩  (0) 2024.07.09
추상클래스의 활용  (0) 2024.06.12
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

 

연산자 오버로딩은 파이썬에서 클래스에 특별한 메서드를 정의함으로써, 사용자 정의 객체가 기본 제공 연산자와 함께 사용될 때의 동작을 지정하는 기능입니다. 이를 통해 +, -, *, / 같은 연산자를 객체에 대해 직접 사용할 수 있습니다. 연산자 오버로딩을 통해 코드의 가독성을 높이고, 객체 지향 프로그래밍의 장점을 살릴 수 있습니다.

 

장점

  1. 코드 가독성 향상:
    • 연산자 오버로딩을 사용하면 코드가 더 직관적이고 읽기 쉬워집니다. 예를 들어, 벡터 덧셈을 vector1 + vector2로 표현할 수 있어 수학적인 표현과 일치합니다.
  2. 객체 지향 프로그래밍의 일관성:
    • 사용자 정의 객체도 기본 자료형처럼 사용할 수 있어 객체 지향 프로그래밍의 일관성을 유지할 수 있습니다. 예를 들어, Complex 클래스에서 복소수 덧셈을 정의하면, 복소수 객체를 숫자처럼 다룰 수 있습니다.
  3. 캡슐화:
    • 객체의 내부 구현을 숨기고, 연산자 오버로딩을 통해 외부에서 객체를 더 간편하게 사용할 수 있습니다. 사용자는 객체의 내부 구조를 몰라도 연산자를 통해 객체를 조작할 수 있습니다.
  4. 재사용성:
    • 연산자 오버로딩을 통해 정의된 연산은 다양한 상황에서 일관되게 사용될 수 있어 코드의 재사용성을 높입니다.

단점

  1. 가독성 저하 가능성:
    • 과도한 연산자 오버로딩은 오히려 코드의 가독성을 떨어뜨릴 수 있습니다. 연산자가 실제로 어떤 일을 하는지 명확하지 않으면, 코드를 이해하기 어려워집니다.
  2. 디버깅 어려움:
    • 연산자 오버로딩으로 인해 연산자 호출 시 실제로 어떤 메서드가 호출되는지 추적하기 어려울 수 있습니다. 이는 디버깅을 복잡하게 만들 수 있습니다.
  3. 예상치 못한 동작:
    • 연산자 오버로딩이 잘못 사용되면 예상치 못한 동작을 초래할 수 있습니다. 특히, 연산자가 일반적인 의미와 다른 동작을 수행할 경우 혼란을 초래할 수 있습니다.
  4. 유지보수 어려움:
    • 복잡한 연산자 오버로딩은 코드를 유지보수하기 어렵게 만듭니다. 시간이 지나면 코드 작성자조차도 오버로딩된 연산자의 동작을 이해하기 어려울 수 있습니다.
  5. 성능 저하:
    • 연산자 오버로딩을 남용하면 불필요한 객체 생성이나 복잡한 연산이 포함될 수 있어 성능이 저하될 수 있습니다.

 

파이썬에서 연산자 오버로딩을 위해 사용되는 특별한 메서드들(매직 메서드라고도 불림)은 다음과 같습니다:

  • __add__(self, other) - + 연산자
  • __sub__(self, other) - - 연산자
  • __mul__(self, other) - * 연산자
  • __truediv__(self, other) - / 연산자
  • __floordiv__(self, other) - // 연산자
  • __mod__(self, other) - % 연산자
  • __pow__(self, other) - ** 연산자
  • __eq__(self, other) - == 연산자
  • __ne__(self, other) - != 연산자
  • __lt__(self, other) - < 연산자
  • __le__(self, other) - <= 연산자
  • __gt__(self, other) - > 연산자
  • __ge__(self, other) - >= 연산자
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2
print(v3)  # Output: Vector(7, 10)

 

연산자 오버로딩은 같은 클래스의 인스턴스 간에도 사용될 수 있지만, 다른 클래스의 인스턴스 간에도 사용할 수 있습니다. 연산자 오버로딩 메서드에서 타입 검사를 하여 원하는 동작을 정의할 수 있습니다. 예를 들어, 서로 다른 클래스의 객체를 더하는 경우를 살펴보겠습니다.

 

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2          # 두 벡터의 덧셈
v4 = v1 + 10          # 벡터와 스칼라의 덧셈
v5 = 10 + v1          # 스칼라와 벡터의 덧셈 (__radd__ 사용)

print(v3)  # Output: Vector(7, 10)
print(v4)  # Output: Vector(12, 13)
print(v5)  # Output: Vector(12, 13)

 

위의 예제들은 길이가 다른 벡터를 더하는 다양한 방법을 보여줍니다. 어떤 방법을 사용할지는 특정 문제의 요구사항에 따라 결정하면 됩니다. 일반적으로는 길이가 다른 벡터를 더하는 것이 자연스럽지 않으므로, 명확한 의도가 없으면 에러를 발생시키는 것이 좋습니다.

 

__add__와 __radd__는 파이썬에서 연산자 오버로딩을 위해 사용되는 특별한 메서드들입니다. 이 메서드들은 + 연산자를 객체에 대해 사용할 때의 동작을 정의합니다.

 

__add__(self, other)

__add__ 메서드는 두 객체를 더할 때 호출됩니다. 즉, a + b와 같은 표현식을 평가할 때, a 객체의 __add__ 메서드가 호출됩니다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2  # v1.__add__(v2)가 호출됨
print(v3)  # Output: Vector(6, 8)

__radd__(self, other)

__radd__ 메서드는 객체가 오른쪽에 있을 때 호출됩니다. 즉, b + a와 같은 표현식에서 a 객체의 __radd__ 메서드가 호출됩니다. 이는 a + b와 b + a의 표현식에서 a 객체가 __add__를 지원하지 않는 경우, 또는 a 객체의 타입이 b 객체의 타입과 다를 때 유용합니다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)  # 동일한 로직을 사용

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
result = 5 + v1  # v1.__radd__(5)가 호출됨
print(result)  # Output: Vector(7, 8)

 

복합 할당 연산자

복합 할당 연산자는 대입 연산자(=)와 다른 연산자를 결합하여 더 간결하게 표현한 연산자입니다. 이 연산자는 변수를 업데이트하는데 사용되며, 다음과 같은 다양한 형태가 있습니다:

a = 10
b = 3

a += b  # a = 13
a -= b  # a = 10
a *= b  # a = 30
a /= b  # a = 10.0
a //= b  # a = 3
a %= b  # a = 1
a **= b  # a = 1
a &= b  # a = 1
a |= b  # a = 3
a ^= b  # a = 0
a <<= b  # a = 0
a >>= b  # a = 0

 

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __iadd__(self, other):
        if isinstance(other, Vector):
            self.x += other.x
            self.y += other.y
        elif isinstance(other, (int, float)):
            self.x += other
            self.y += other
        else:
            return NotImplemented
        return self

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(4, 5)
v1 += v2  # v1.__iadd__(v2)가 호출됨
print(v1)  # Output: Vector(6, 8) - 원래 객체가 변경됨

 

복합 연산자는 코드의 간결성을 높이고, 반복적인 코드 작성을 줄이는 데 매우 유용합니다. 특히 데이터 처리나 반복적인 계산을 수행할 때 자주 사용됩니다. 다음은 복합 연산자를 응용한 예제로, 벡터 클래스에서 각 요소에 다른 벡터의 요소를 더하는 복합 연산(+=)을 구현하는 예입니다.

 

class Vector:
    def __init__(self, *components):
        self.components = list(components)

    def __iadd__(self, other):
        if isinstance(other, Vector):
            # 길이가 다른 경우 더 긴 벡터에 맞춰 짧은 벡터를 확장
            if len(self.components) < len(other.components):
                self.components.extend([0] * (len(other.components) - len(self.components)))
            elif len(self.components) > len(other.components):
                other.components.extend([0] * (len(self.components) - len(other.components)))
                
            for i in range(len(self.components)):
                self.components[i] += other.components[i]
        elif isinstance(other, (int, float)):
            self.components = [x + other for x in self.components]
        else:
            return NotImplemented
        return self

    def __repr__(self):
        return f"Vector({', '.join(map(str, self.components))})"

# 사용 예시
v1 = Vector(1, 2, 3)
v2 = Vector(4, 5, 6)
v1 += v2  # v1.__iadd__(v2)가 호출됨
print(v1)  # Output: Vector(5, 7, 9)

v3 = Vector(1, 2)
v4 = Vector(3, 4, 5)
v3 += v4  # v3.__iadd__(v4)가 호출됨
print(v3)  # Output: Vector(4, 6, 5)

v5 = Vector(1, 2, 3)
v5 += 10  # 모든 요소에 10을 더함
print(v5)  # Output: Vector(11, 12, 13)

 

Scalar 클래스와 Vector 클래스의 객체 간의 덧셈을 보여줍니다. s + v1에서는 Scalar 클래스의 __add__ 메서드가 호출되고, v1 + s에서는 Vector 클래스의 __add__ 메서드가 NotImplemented를 반환하여 Scalar 클래스의 __radd__ 메서드가 호출됩니다.

 

class Scalar:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(other.x + self.value, other.y + self.value)
        return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)

    def __repr__(self):
        return f"Scalar({self.value})"

# 사용 예시
s = Scalar(10)
v1 = Vector(1, 2)

# 스칼라와 벡터의 덧셈 (__radd__ 사용)
v6 = s + v1  # Scalar의 __add__가 호출됨
print(v6)    # Output: Vector(11, 12)

v7 = v1 + s  # Vector의 __add__가 호출되고 NotImplemented를 반환, Scalar의 __radd__가 호출됨
print(v7)    # Output: Vector(11, 12)

 

반응형

'Computer Science > python' 카테고리의 다른 글

동적 속성과 프로퍼티  (0) 2024.08.16
추상클래스의 활용  (0) 2024.06.12
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

Python의 추상 클래스와 MutableMapping을 활용한 데이터 구조 설계

Python은 객체 지향 프로그래밍(OOP) 언어로서, 추상 클래스를 통해 명확한 인터페이스를 정의하고 이를 기반으로 다양한 데이터 구조를 설계할 수 있는 기능을 제공합니다. 특히, Python의 collections.abc 모듈에서 제공하는 MutableMapping 추상 클래스를 활용하면, 딕셔너리와 같은 유연한 데이터 구조를 커스터마이즈하고 확장할 수 있습니다.

이 글에서는 Python의 추상 클래스 개념과 MutableMapping을 활용한 데이터 구조 설계 방법을 설명하고, 실질적인 예제를 통해 그 활용 방법을 소개합니다.

추상 클래스 (Abstract Class)

추상 클래스는 하나 이상의 추상 메서드를 포함하는 클래스입니다. 추상 메서드는 선언만 되어 있고, 실제 구현은 제공하지 않습니다. 추상 클래스는 객체를 직접 생성할 수 없으며, 반드시 상속받아 추상 메서드를 구현해야 합니다. 이를 통해 일관된 인터페이스를 강제할 수 있습니다.

추상 클래스의 정의

from abc import ABC, abstractmethod

class AbstractDataStructure(ABC):
    @abstractmethod
    def add(self, item):
        pass

    @abstractmethod
    def remove(self, item):
        pass

    @abstractmethod
    def find(self, item):
        pass

 

위 예제에서 AbstractDataStructure는 추상 클래스이며, add, remove, find 메서드는 추상 메서드로 정의되어 있습니다. 이 클래스는 상속받아 구체적인 구현을 제공해야 합니다.

MutableMapping 추상 클래스

collections.abc 모듈의 MutableMapping 추상 클래스는 딕셔너리와 같은 매핑 타입을 정의하는 데 사용됩니다. MutableMapping은 Mapping을 상속받아 변경 가능한 매핑 타입의 인터페이스를 정의합니다.

MutableMapping을 활용한 사용자 정의 클래스

MutableMapping을 상속받아 커스터마이즈된 딕셔너리 클래스를 구현할 수 있습니다. 이를 통해 기본 딕셔너리 기능을 확장하거나 새로운 기능을 추가할 수 있습니다.

from collections.abc import MutableMapping

class CustomDict(MutableMapping):
    def __init__(self):
        self._store = {}

    def __getitem__(self, key):
        return self._store[key]

    def __setitem__(self, key, value):
        self._store[key] = value

    def __delitem__(self, key):
        del self._store[key]

    def __iter__(self):
        return iter(self._store)

    def __len__(self):
        return len(self._store)

# CustomDict 사용 예제
custom_dict = CustomDict()
custom_dict['a'] = 1
custom_dict['b'] = 2

print(custom_dict['a'])  # 출력: 1
print(custom_dict)  # 출력: {'a': 1, 'b': 2}

del custom_dict['a']
print(custom_dict)  # 출력: {'b': 2}
print(len(custom_dict))  # 출력: 1

 

CustomDict에 예제 메서드 추가 및 활용

CustomDict 클래스에 예제 메서드를 추가하여 실제로 어떻게 활용할 수 있는지 살펴보겠습니다. 이 예제에서는 increment라는 메서드를 추가하여, 특정 키의 값을 증가시키는 기능을 구현해보겠습니다.

CustomDict 클래스 정의 및 예제 메서드 추가

 

from collections.abc import MutableMapping

class CustomDict(MutableMapping):
    def __init__(self):
        self._store = {}

    def __getitem__(self, key):
        return self._store[key]

    def __setitem__(self, key, value):
        self._store[key] = value

    def __delitem__(self, key):
        del self._store[key]

    def __iter__(self):
        return iter(self._store)

    def __len__(self):
        return len(self._store)

    # 예제 메서드 추가: 특정 키의 값을 증가시키는 메서드
    def increment(self, key, amount=1):
        if key in self._store:
            self._store[key] += amount
        else:
            self._store[key] = amount

# CustomDict 사용 예제
custom_dict = CustomDict()
custom_dict['a'] = 1
custom_dict.increment('a')
custom_dict.increment('b', 5)

print(custom_dict['a'])  # 출력: 2
print(custom_dict['b'])  # 출력: 5
print(custom_dict)  # 출력: {'a': 2, 'b': 5}

 

위 예제에서 CustomDict 클래스에 increment 메서드를 추가하여, 특정 키의 값을 증가시키는 기능을 구현했습니다.

Dictionary에서 비슷하게 구현

기본 dict를 사용하여 비슷한 기능을 구현할 수도 있습니다. 이를 위해 별도의 함수를 정의해보겠습니다.

# 기본 dict를 사용하여 increment 기능을 제공하는 함수
def increment(d, key, amount=1):
    if key in d:
        d[key] += amount
    else:
        d[key] = amount

# dict 사용 예제
basic_dict = {'a': 1}
increment(basic_dict, 'a')
increment(basic_dict, 'b', 5)

print(basic_dict['a'])  # 출력: 2
print(basic_dict['b'])  # 출력: 5
print(basic_dict)  # 출력: {'a': 2, 'b': 5}

CustomDict와 기본 dict를 사용한 구현의 장단점

CustomDict의 장점

  1. 메서드 추가 및 확장 용이:
    • 클래스 메서드로 기능을 구현하면, 객체 지향적인 접근이 가능하고, 상태를 쉽게 관리할 수 있습니다.
    • 메서드를 통해 기능을 캡슐화하여 코드의 재사용성과 유지보수성을 높일 수 있습니다.
  2. 인터페이스 일관성:
    • MutableMapping을 상속받아 딕셔너리와 동일한 인터페이스를 제공하므로, 기존의 딕셔너리 사용 패턴과 호환됩니다.
  3. 추가 기능 구현의 용이성:
    • CustomDict 클래스를 확장하여 새로운 기능을 쉽게 추가할 수 있습니다.

CustomDict의 단점

  1. 복잡성 증가:
    • 기본 dict를 사용하는 것보다 클래스를 정의하고 관리하는 데 더 많은 코드와 복잡성이 필요합니다.
  2. 성능 저하 가능성:
    • 추가된 추상화 계층으로 인해 성능이 약간 저하될 수 있습니다.

기본 dict의 장점

  1. 단순성:
    • 별도의 클래스를 정의하지 않고, 단순한 함수로 기능을 구현할 수 있어 코드가 간결합니다.
    • 기본 dict는 Python의 내장 자료형이므로 추가적인 학습이나 설정 없이 바로 사용할 수 있습니다.
  2. 성능:
    • Python의 기본 dict는 C로 구현되어 있어 매우 빠릅니다.

기본 dict의 단점

  1. 재사용성 및 유지보수성 저하:
    • 기능을 함수로 구현하면, 상태와 기능이 분리되어 있어 재사용성과 유지보수성이 낮아질 수 있습니다.
    • 여러 함수로 기능을 확장하는 경우, 코드의 일관성을 유지하기 어렵습니다.
  2. 객체 지향 프로그래밍의 한계:
    • 객체 지향 프로그래밍의 이점을 활용하지 못하므로, 복잡한 상태 관리나 기능 확장이 어렵습니다.

결론

  • CustomDict: 객체 지향적인 접근으로, 상태와 기능을 캡슐화하여 코드의 재사용성과 유지보수성을 높일 수 있습니다. 복잡한 기능을 확장하는 데 유리하지만, 기본 dict보다 구현과 관리가 더 복잡합니다.
  • 기본 dict: 간단하고 성능이 우수하지만, 복잡한 기능을 확장하거나 유지보수할 때 어려움이 있을 수 있습니다.

두 접근 방식 모두 장단점이 있으므로, 특정 상황과 요구 사항에 따라 적절한 방법을 선택하는 것이 중요합니다.

반응형

'Computer Science > python' 카테고리의 다른 글

동적 속성과 프로퍼티  (0) 2024.08.16
연산자 오버로딩  (0) 2024.07.09
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

프로토콜 (Protocol)

프로토콜은 특정 메소드나 속성을 구현해야 하는 비공식적인 인터페이스입니다. Python은 강력한 덕 타이핑(duck typing) 덕분에 공식적으로 인터페이스를 정의하지 않아도 됩니다. 객체가 특정 메소드나 속성을 가지고 있다면, 그 객체는 해당 프로토콜을 구현한다고 간주합니다.

예를 들어, Python의 시퀀스 프로토콜은 __len__과 __getitem__ 메소드를 요구합니다. 리스트, 튜플, 문자열 등은 모두 이 프로토콜을 구현합니다.

 

 

인터페이스를 정의한다는 것은 클래스가 가져야 할 메소드와 속성을 명시하는 것을 의미합니다. 이는 객체 지향 프로그래밍에서 매우 중요한 개념입니다. 인터페이스는 클래스가 특정한 기능을 제공할 것이라는 계약(Contract)을 정의하며, 이를 통해 코드의 일관성을 유지하고 재사용성을 높일 수 있습니다.

인터페이스의 개념

인터페이스는 일반적으로 다음을 포함합니다:

  • 메소드 서명(Signature): 메소드의 이름, 매개변수, 반환 타입 등을 명시합니다.
  • 속성(Property): 클래스가 가져야 할 속성을 정의합니다.

인터페이스는 구현을 포함하지 않으며, 인터페이스를 상속받는 클래스는 해당 인터페이스에서 정의된 모든 메소드와 속성을 구현해야 합니다.

 

class CustomSequence:
    def __len__(self):
        return 10
    
    def __getitem__(self, index):
        return index * 2

seq = CustomSequence()
print(len(seq))        # 10
print(seq[3])          # 6

 

abc 모듈 (추상 기반 클래스)

Python의 abc 모듈은 추상 기반 클래스를 정의하는 기능을 제공합니다. 추상 클래스는 하나 이상의 추상 메소드를 포함할 수 있으며, 이러한 메소드는 서브클래스에서 반드시 구현해야 합니다. 이를 통해 공통 인터페이스를 정의하고 구현 강제를 할 수 있습니다.

추상 클래스 정의

추상 클래스는 ABC 클래스를 상속받고, 추상 메소드는 @abstractmethod 데코레이터를 사용하여 정의합니다.

 

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Bark"

 

추상 클래스의 역할

  1. 공통 인터페이스 정의: 추상 클래스는 여러 구체적인 클래스가 반드시 구현해야 하는 메소드와 속성을 정의합니다. 이를 통해 모든 서브클래스가 동일한 인터페이스를 가지게 됩니다.
  2. 코드 재사용성 증가: 추상 클래스는 공통 기능을 한 곳에 모아서 구현할 수 있습니다. 이를 상속받는 구체적인 클래스들은 이러한 공통 기능을 재사용할 수 있습니다.
  3. 유지보수성 향상: 코드를 수정할 때, 공통 기능은 추상 클래스에서 한 번만 수정하면 되므로 유지보수성이 높아집니다.
  4. 다형성 지원: 동일한 인터페이스를 통해 다양한 클래스와 상호작용할 수 있게 하여 다형성을 지원합니다.

 

from abc import ABC, abstractmethod

class Animal(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def sound(self):
        return "Some generic animal sound"

    @abstractmethod
    def move(self):
        return "Some generic animal movement"

    def display_info(self):
        print(f"{self.name} says {self.sound()} and {self.move()}")

class Dog(Animal):
    def sound(self):
        return "Bark"

    def move(self):
        return "Runs"

class Cat(Animal):
    def sound(self):
        return "Meow"

    # move 메소드를 재정의하지 않음

class Fish(Animal):
    # sound 메소드를 재정의하지 않음

    def move(self):
        return "Swims"

# 동물원 관리 시스템
class Zoo:
    def __init__(self):
        self.animals = []

    def add_animal(self, animal: Animal):
        self.animals.append(animal)

    def show_all_animals(self):
        for animal in self.animals:
            animal.display_info()

# 동물원에 동물 추가
zoo = Zoo()
zoo.add_animal(Dog("Buddy"))
zoo.add_animal(Cat("Whiskers"))
zoo.add_animal(Fish("Nemo"))

# 모든 동물 정보 표시
zoo.show_all_animals()

 

실행 결과

Buddy says Bark and Runs
Whiskers says Meow and Some generic animal movement
Nemo says Some generic animal sound and Swims

 

예제에서는 추상클래스 "Animal"을 선언하고 각각 Dog, Cat 그리고 Fish 클래스가 이를 상속하도록 했습니다.

 

구체적인 클래스 Zoo 에서 Dog, Cat 그리고 Fish 오브젝트를 생성하였으며 여기서 모든 동물들에게 상속받은 추상 클래스 display_info를 호출하면 실행 결과를 출력하게 됩니다.

 

 

추상클래스는 다중 상속도 가능합니다.

from abc import ABC, abstractmethod

class Printable(ABC):
    @abstractmethod
    def print(self):
        pass

class Scannable(ABC):
    @abstractmethod
    def scan(self):
        pass

class MultifunctionPrinter(Printable, Scannable):
    def print(self):
        return "Printing document"

    def scan(self):
        return "Scanning document"

# MultifunctionPrinter 클래스는 Printable과 Scannable의 추상 메소드를 모두 구현해야 합니다
mfp = MultifunctionPrinter()
print(mfp.print())  # "Printing document"
print(mfp.scan())   # "Scanning document"

 

MultifunctionPrinter에 Printable와 Scannable 추상 클래스를 다중 상속 하고 있습니다.

 

일반 메서드의 경우, 서브클래스에서 재정의하지 않으면 상속된 메서드를 그대로 사용할 수 있습니다. 즉, 서브클래스는 필요에 따라 메서드를 재정의할 수도 있고, 그렇지 않으면 상위 클래스에서 정의된 메서드를 사용할 수 있습니다.

 

그러나 추상 클래스에서 정의된 추상 메서드는 특별한 경우입니다. 추상 메서드는 기본적으로 구현되지 않은 메서드입니다. 따라서 추상 클래스에서 추상 메서드를 정의하면, 이를 상속받는 클래스는 반드시 그 추상 메서드를 재정의하여 구현해야 합니다. 그렇지 않으면 해당 서브클래스는 추상 클래스로 간주되어 인스턴스화할 수 없습니다.

 

from abc import ABC, abstractmethod

class AbstractClass(ABC):
    @abstractmethod
    def abstract_method(self):
        pass

    def concrete_method(self):
        print("This is a concrete method from the abstract class.")

class ConcreteClass(AbstractClass):
    def abstract_method(self):
        print("This is the implementation of the abstract method.")

# 인스턴스 생성
instance = ConcreteClass()
instance.abstract_method()  # This is the implementation of the abstract method.
instance.concrete_method()  # This is a concrete method from the abstract class.

 

추상 클래스의 목적은 인터페이스를 정의하고, 특정 메서드를 서브클래스에서 반드시 구현하도록 강제하는 것입니다. 이를 통해 코드의 일관성을 유지하고, 서브클래스가 필요한 기능을 올바르게 구현하도록 보장합니다.

 

 

 

직접 ABC를 정의할 수 있지만 가능하면 collections.abc나 파이썬 표준 라이브러리의 모듈에서 상속해서 써라!

 

 

반응형

'Computer Science > python' 카테고리의 다른 글

연산자 오버로딩  (0) 2024.07.09
추상클래스의 활용  (0) 2024.06.12
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
flask_sqlalchemy  (0) 2022.05.23
반응형

SLURM 이란

SLURM(Simplified Linux Utility for Resource Management)은 대규모 병렬 컴퓨팅 환경에서 작업 스케줄링과 리소스 관리를 위한 오픈 소스 클러스터 관리 시스템입니다. SLURM은 슈퍼컴퓨터와 대규모 클러스터에서 사용되며, 사용자가 제출한 작업을 효율적으로 스케줄링하고 자원을 배분하는 역할을 합니다. 주요 기능으로는 작업 큐잉, 우선순위 스케줄링, 자원 할당, 작업 모니터링 등이 있습니다.

SLURM 설치 방법

여기서는 SLURM을 설치하고 설정하는 절차를 단계별로 설명합니다.

설치를 위한 절차

1. 컨트롤 서버와 노드 서버를 결정

먼저, SLURM 클러스터에서 컨트롤 서버와 노드 서버를 결정합니다. 컨트롤 서버는 SLURM의 중앙 관리 노드로, 작업 스케줄링과 자원 관리를 담당합니다. 노드 서버는 실제로 작업이 실행되는 컴퓨팅 노드입니다.

2. MUNGE 설치 및 설정

MUNGE(Munge Uid 'N' Gid Emporium)는 SLURM에서 인증을 처리하는 데 사용됩니다. 모든 컨트롤 서버와 노드 서버에 MUNGE를 설치하고 설정합니다.

 

2.1. MUNGE 설치

모든 서버에서 MUNGE를 설치합니다.

sudo apt install -y munge libmunge-dev

 

2.2. MUNGE 키 생성 및 배포

컨트롤 서버에서 MUNGE 키를 생성하고, 모든 노드 서버로 배포합니다.

# 컨트롤 서버에서 MUNGE 키 생성 
sudo /usr/sbin/create-munge-key 
# MUNGE 키 파일을 모든 노드 서버로 복사 
sudo scp /etc/munge/munge.key user@node-server:/etc/munge/

 

2.3. MUNGE 키 파일 권한 설정

각 노드 서버에서 MUNGE 키 파일의 권한을 설정합니다.

sudo chown munge:munge /etc/munge/munge.key 
sudo chmod 400 /etc/munge/munge.key

 

2.4. MUNGE 데몬 시작 및 활성화

모든 서버에서 MUNGE 데몬을 시작하고 부팅 시 자동으로 시작되도록 설정합니다.

sudo systemctl enable munge 
sudo systemctl start munge

3. SLURM 설치

3.1. 컨트롤 서버에 SLURM 설치

컨트롤 서버에서 SLURM 컨트롤 데몬(slurmctld)을 설치합니다.

sudo apt install -y slurm-wlm

 

3.2. 노드 서버에 SLURM 설치

모든 노드 서버에서 SLURM 데몬(slurmd)을 설치합니다. 컨트롤 서버에서도 작업을 실행하려면 SLURM 데몬도 함께 설치합니다.

sudo apt install -y slurmd

4. slurm.conf 설정

SLURM의 주요 설정 파일인 slurm.conf를 작성합니다. 이 파일은 클러스터의 구성과 동작을 정의합니다.

# slurm.conf file generated by configurator.html. 
# Put this file on all nodes of your cluster. 
# SLURM 컨트롤러 노드의 호스트 이름 
ControlMachine=controller 

# 인증 방법 설정 
AuthType=auth/munge 

# SLURM 데몬이 사용할 포트 설정 
SlurmdPort=6818 SlurmctldPort=6817 

# 상태 정보 저장 위치 설정 
StateSaveLocation=/var/spool/slurm-llnl/state 
SlurmdSpoolDir=/var/spool/slurmd 

# 프로세스 추적 방법 설정 
ProctrackType=proctrack/cgroup 

# 노드가 서비스로 돌아가는 방식을 제어 
ReturnToService=1 

# 스케줄링 메커니즘 설정 
SchedulerType=sched/backfill 

# SLURM 데몬의 로그 파일 위치 설정 
SlurmdLogFile=/var/log/slurmd.log 
SlurmctldLogFile=/var/log/slurmctld.log 

# SLURM 데몬의 PID 파일 위치 설정 
SlurmctldPidFile=/run/slurm/slurmctld.pid 
SlurmdPidFile=/run/slurm/slurmd.pid 

# 작업 자격 증명에 사용할 키 설정 
JobCredentialPrivateKey=/var/spool/slurm-llnl/cred_priv.pem 
JobCredentialPublicCertificate=/var/spool/slurm-llnl/cred_pub.pem 

# SLURM 데몬의 시간 초과 값 설정 
SlurmdTimeout=300 
SlurmctldTimeout=300 

# 노드 선택 메커니즘 설정 
SelectType=select/cons_tres 
SelectTypeParameters=CR_Core_Memory 

# 작업 관리 플러그인 설정 
TaskPlugin=task/affinity 

# 클러스터 이름 설정 
ClusterName=my_cluster 

# 클러스터의 노드 설정 
NodeName=node[1-4] CPUs=16 RealMemory=64000 State=UNKNOWN 

# 클러스터의 파티션 설정 
PartitionName=debug Nodes=node[1-4] Default=YES MaxTime=INFINITE State=UP

5. cgroup.conf 설정 (GPU 사용 시)

GPU 자원을 관리하려면 cgroup.conf 파일을 설정해야 합니다.

예제: cgroup.conf

CgroupAutomount=yes 
CgroupReleaseAgentDir="/etc/slurm-llnl/cgroup" 
ConstrainCores=yes 
ConstrainRAMSpace=yes 
ConstrainDevices=yes 
AllowedDevicesFile="/etc/slurm-llnl/cgroup_allowed_devices_file.conf"

 

예제: cgroup_allowed_devices_file.conf

/dev/nvidiactl 
/dev/nvidia-uvm 
/dev/nvidia0 
/dev/nvidia1 ...

6. 설정 파일 배포

작성한 slurm.conf와 cgroup.conf 파일을 모든 노드 서버로 배포합니다.

scp /etc/slurm-llnl/slurm.conf user@node-server:/etc/slurm-llnl/ 
scp /etc/slurm-llnl/cgroup.conf user@node-server:/etc/slurm-llnl/ 
scp /etc/slurm-llnl/cgroup_allowed_devices_file.conf user@node-server:/etc/slurm-llnl/

요약

이 포스트에서는 SLURM 설치 및 설정 절차를 다루었습니다. 다음은 간단한 요약입니다:

  1. 컨트롤 서버와 노드 서버를 결정.
  2. 모든 서버에 MUNGE 설치 및 설정.
  3. 컨트롤 서버에 slurmctld 설치, 노드 서버에 slurmd 설치.
  4. slurm.conf 설정 파일 작성.
  5. GPU 사용 시 cgroup.conf 설정 파일 작성.
  6. 설정 파일을 모든 서버에 배포.

이 단계를 통해 SLURM 클러스터를 구축하고 관리할 수 있습니다. SLURM을 통해 대규모 병렬 컴퓨팅 환경에서 효율적으로 작업을 스케줄링하고 자원을 관리할 수 있습니다.

 

주의할 점.

1. munge나 slurm을 실행할 때 로그 파일의 디렉토리가 생성되어 있지 않으면 에러가 날 수 있습니다.

2. 클러스터 노드의 CPU, Memory 등을 설정하기 위해서 $lscpu와 $free -m 명령어를 사용하여 노드의 자원 상태를 파악할 수 있습니다.

3. 설정 파일(slurm.conf, cgroup.conf, munge.key) 등이 노드 서버로 복사 된 이후에 서비스를 재시작하여야 합니다.

반응형

'Computer Science > linux' 카테고리의 다른 글

Dockerfile 작성하기  (1) 2024.09.15
Docker 사용하기  (0) 2024.09.15
사용자 계정 관리 및 조직의 구조화 툴 (LDAP)  (0) 2024.05.17
Docker와 MariaDB연결하기  (0) 2022.08.24
centos 8에 slurm 설치하기  (0) 2022.05.11

+ Recent posts