Maxima's Lab

2026년, AI 에이전트가 업무를 주도한다: 당신의 일상은 어떻게 바뀔까?

Minima — Tue, 10 Mar 2026 23:02:48 +0900

## 2026년, AI 에이전트가 업무를 주도한다: 당신의 일상은 어떻게 바뀔까?

**AI 에이전트, 무엇이 다른가?**

기존의 AI 도구들이 특정 작업을 효율적으로 수행하는 데 초점을 맞췄다면, AI 에이전트는 한 단계 더 나아가 '자율성(Autonomy)', '적응성(Adaptability)', '목표 지향성(Goal-oriented)'을 특징으로 합니다. 이들은 주어진 목표를 달성하기 위해 스스로 계획을 수립하고, 다양한 소프트웨어와 데이터를 활용하며, 예상치 못한 상황에 유연하게 대처할 수 있습니다. 예를 들어, 특정 시장 조사를 목표로 설정하면, AI 에이전트는 필요한 데이터를 인터넷에서 검색하고, 보고서를 작성하며, 심지어 관련 부서에 결과를 공유하는 일련의 과정을 자율적으로 수행할 수 있습니다. 이는 우리가 기존에 생각했던 업무의 개념을 완전히 재정의하는 사건입니다.

**업무 환경의 혁신: AI 에이전트가 주도하는 변화**

AI 에이전트의 등장은 기업의 생산성과 효율성을 극대화하는 동시에, 인간 노동의 본질에 대한 재정의를 요구하고 있습니다.

1.  **반복적이고 지루한 업무의 완전한 자동화**: 데이터 입력, 보고서 작성, 이메일 분류, 회의록 요약 등 반복적이고 규칙적인 업무는 AI 에이전트의 영역이 되고 있습니다. 이를 통해 직원들은 단순 작업에서 벗어나 더 창의적이고 전략적인 업무에 집중할 수 있게 됩니다. 예를 들어, 마케팅 부서에서는 AI 에이전트가 시장 트렌드 분석, 경쟁사 동향 파악, 캠페인 성과 보고서 작성을 전담하며, 마케터들은 새로운 전략 기획과 고객 관계 구축에 더 많은 시간을 할애할 수 있습니다.

2.  **초개인화된 업무 비서 및 의사결정 지원**: AI 에이전트는 개인의 업무 패턴과 선호도를 학습하여 맞춤형 정보를 제공하고, 의사결정을 돕는 개인 비서 역할을 수행합니다. 수많은 데이터 속에서 의미 있는 통찰을 도출하고, 잠재적 위험을 예측하며, 최적의 대안을 제시하는 능력을 갖추고 있습니다. 영업 사원은 AI 에이전트의 도움을 받아 고객의 니즈를 정확히 파악하고, 최적의 제품을 추천하며, 협상 전략을 수립하여 성공률을 높일 수 있습니다.

3.  **협업 및 프로젝트 관리의 효율 증대**: AI 에이전트는 팀원 간의 협업을 촉진하고 프로젝트 진행 상황을 실시간으로 추적하며, 잠재적 병목 현상을 예측하고 해결책을 제시합니다. 복잡한 프로젝트에서도 여러 AI 에이전트들이 각자의 전문 분야에 따라 역할을 분담하고 유기적으로 협력하여 목표를 달성하는 모습이 일반화되고 있습니다. 개발팀에서는 AI 에이전트가 코드 검토, 버그 탐지, 테스트 자동화를 수행하며 개발 주기를 단축하고 품질을 향상시킵니다.

4.  **새로운 비즈니스 모델과 산업의 탄생**: AI 에이전트는 기존 산업의 경계를 허물고, 완전히 새로운 서비스와 비즈니스 모델을 창출하고 있습니다. AI 에이전트가 직접 고객 서비스를 제공하거나, 맞춤형 콘텐츠를 생성하거나, 심지어 새로운 제품을 디자인하는 시대가 도래하고 있습니다. 이는 기업들에게 전례 없는 성장 기회를 제공하며, 동시에 경쟁 환경의 변화를 가속화하고 있습니다.

**개인의 역할과 역량 변화: 인간 고유의 가치 재조명**

AI 에이전트가 업무의 많은 부분을 주도하면서, 인간의 역할은 더욱 고도화되고 전문화될 것입니다. 단순 반복 업무에서 해방된 인간은 다음과 같은 역량에 집중해야 합니다.

1.  **창의성과 혁신**: AI 에이전트가 데이터를 분석하고 기존 지식을 조합하는 데 능숙하다면, 인간은 전혀 새로운 아이디어를 창출하고, 비판적으로 사고하며, 복잡한 문제에 대한 독창적인 해결책을 제시하는 데 강점을 가집니다. 예술, 디자인, 전략 기획 등 인간의 직관과 통찰력이 필요한 영역의 가치는 더욱 높아질 것입니다.

2.  **비판적 사고 및 문제 해결**: AI 에이전트가 제시하는 정보와 제안을 맹목적으로 받아들이기보다는, 그 타당성을 검토하고, 맥락을 이해하며, 최종적인 판단을 내리는 능력은 여전히 인간의 몫입니다. 예상치 못한 문제에 직면했을 때, 유연하게 사고하고 해결책을 찾아내는 능력 또한 중요합니다.

3.  **감성 지능 및 대인 관계**: AI 에이전트는 공감, 설득, 협상과 같은 감성적 영역에서 인간의 복잡한 상호작용을 완전히 대체하기 어렵습니다. 팀워크, 리더십, 고객과의 신뢰 구축 등 인간적인 소통과 관계 형성을 요구하는 역량은 더욱 중요해질 것입니다.

4.  **AI 에이전트와의 협업 능력**: AI 에이전트를 효과적으로 활용하고 관리하며, 이들과 시너지를 창출하는 능력은 미래의 핵심 역량입니다. AI 에이전트의 한계를 이해하고, 적절한 지시를 내리며, 그들의 결과물을 해석하고 개선하는 역할이 중요해집니다.

**일상생활의 변화와 미래 전망: 더 풍요로운 삶을 향하여**

업무 환경의 변화는 우리의 일상생활에도 지대한 영향을 미칩니다.

1.  **일과 삶의 균형 개선**: AI 에이전트가 업무 부담을 덜어주면서, 개인은 더 많은 여가 시간을 확보하고, 취미 활동이나 자기 계발에 투자할 수 있게 됩니다. 이는 삶의 질을 향상시키고, 정신적, 육체적 건강을 증진하는 데 기여할 것입니다.

2.  **평생 학습의 중요성 증대**: 기술의 빠른 변화 속도에 맞춰, 새로운 지식과 기술을 지속적으로 습득하는 평생 학습의 중요성이 더욱 커집니다. AI 에이전트는 개인화된 학습 콘텐츠를 제공하고, 학습 경로를 설계하는 데 도움을 줄 수 있습니다.

3.  **새로운 직업군의 등장**: 기존의 직업들이 사라지거나 변화하는 동시에, AI 에이전트를 개발, 관리, 감독하거나, AI가 해결하기 어려운 인간 고유의 영역에서 새로운 직업들이 탄생할 것입니다. AI 에이전트 윤리 전문가, AI 시스템 코치, AI 데이터 큐레이터 등이 그 예시입니다.

4.  **윤리적, 사회적 고려사항**: AI 에이전트의 광범위한 도입은 데이터 프라이버시, 알고리즘 편향, 책임 소재, 일자리 감소와 같은 윤리적, 사회적 문제들을 야기할 수 있습니다. 이에 대한 사회적 합의와 제도적 보완이 필수적입니다. 우리는 기술 발전의 혜택을 누리면서도, 그 그림자에 대한 깊은 성찰과 대응 방안을 마련해야 합니다.

2026년, AI 에이전트는 이미 업무의 중요한 파트너이자 주도자로서 우리의 삶에 깊이 관여하고 있습니다. 이러한 변화는 위기이자 동시에 엄청난 기회입니다. AI 에이전트의 잠재력을 이해하고, 그들과 효과적으로 협력하며, 인간 고유의 가치를 재발견하는 노력을 통해 우리는 더욱 생산적이고 풍요로운 미래를 만들어 나갈 수 있을 것입니다. 지금이야말로 AI 에이전트와 함께하는 새로운 시대에 대한 깊은 이해와 선제적인 준비가 필요한 시점입니다.

이 내용은 AI가 만들었어요! 참고용으로 활용하고, 중요한 내용은 꼭 확인해 보세요.

AI가 작성한 콘텐츠입니다. 사실 여부를 한 번 더 확인해 주세요!

[Apache] NiFi 설치 하는 방법 (Ubuntu)

Minima — Sat, 7 Jun 2025 10:35:01 +0900

안녕하세요, 오늘은 NiFi 설치하는 방법에 대해서 알아보겠습니다.

Apache NiFi는 데이터를 자동으로 모으고, 가공하고, 옮기고, 추적할 수 있는 GUI 기반 데이터 흐름 자동화 툴입니다.

그럼, Ubuntu에서 NiFi를 설치하는 방법에 대해서 알아보겠습니다.

sudo add-apt-repository ppa:openjdk-r/ppa
sudo apt update
sudo apt install openjdk-21-jdk -y
java -version

먼저, NiFi를 실행시키기 위해 Java를 설치해야 하는데 NiFi 2.4.0을 설치할 예정이기 떄문에 Java 21 개발 킷(JDK)을 설치해 줍니다.

wget https://archive.apache.org/dist/nifi/2.4.0/nifi-2.4.0-bin.zip
unzip nifi-2.4.0-bin.zip
cd nifi-2.4.0

NiFi 2.4.0 버전을 Apache 공식 아카이브에서 다운로드 후 압축을 풀어줍니다.

echo 'export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

첫번째에서 설치해 준 Java 21을 PATH에 등록해줍니다.

./bin/nifi.sh start

위의 명령어를 통해 NiFi를 시작할 수 있으며, 최종적으로는 https://localhost:8443/nifi 를 브라우저를 통해 접속가능합니다.

지금까지, Apache NiFi를 설치하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Apache] Kafka 설치 하는 방법 (Ubuntu)

Minima — Fri, 6 Jun 2025 14:34:14 +0900

안녕하세요, 오늘은 Kafka를 설치하는 방법에 대해서 알아보겠습니다.

실시간 데이터 스트리밍 플랫폼으로, 대규모 데이터를 빠르고 안정적으로 처리할 수 있게 해주는 분산 메시징 시스템 입니다.

Kafka 관련된 용어는 다음과 같습니다.

Producer	Kafka로 데이터를 보내는 주체 (예: 웹 서버, 센서 등)
Consumer	Kafka에서 데이터를 읽는 주체 (예: 분석 시스템, DB 등)
Topic	메시지가 저장되는 논리적인 공간. 데이터의 주제(채널) 같은 개념
Broker	Kafka 서버 하나하나를 의미. 여러 개가 클러스터로 동작
Zookeeper	Kafka 클러스터를 관리해주는 조율자 역할. 최근엔 KRaft 모드로 대체 가능
Partition	Topic을 나눈 작은 단위로, 병렬성과 처리 속도를 높이는 데 사용
Offset	Consumer가 Topic에서 읽은 메시지의 위치 정보 (재처리 또는 중단 복구에 사용)

이어서, Ubuntu에서 Kafka를 설치하는 방법에 대해서 알아보겠습니다.

wget https://archive.apache.org/dist/kafka/3.7.0/kafka_2.13-3.7.0.tgz
tar -xzf kafka_2.13-3.7.0.tgz
cd kafka_2.13-3.7.0

https://archive.apache.org/dist/kafka/

Index of /dist/kafka

archive.apache.org

이상으로, Ubuntu에서 Apache Kafka 설치하는 방법에 대해서 알아보았습니다.

감사드립니다.

[선형대수학, Python] 고윳값과 고유벡터 & PCA (주성분 분석)

Minima — Wed, 26 Mar 2025 22:36:53 +0900

안녕하세요, 오늘은 선형대수학 내 고윳값과 고유벡터 그리고 PCA (주성분 분석)에 대해서 알아보고 해당 개념들을 파이썬을 통해 예제로 알아보겠습니다.

Principal Component Analysis (PCA, 주성분 분석)은 고차원 데이터를 저차원 데이터로 줄임과 동시에 데이터의 주요 특성을 최대한 보존하는 방법을 의미한다.

이는, 데이터의 분산이 가장 큰 방향으로 데이터를 재 표현하는 방법이며, 해당 방향을 주성분이다.

이미지, 텍스트 등과 같은 데이터들은 다수의 특징(Feature)를 가지기 때문에 PCA를 통해 데이터 압축, 노이즈 제거, 시각화 등에 사용된다.

다음은 Logit 데이터를 PCA를 적용하는 파이썬 예시 이다.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

# [1] 데이터 로드
digits = load_digits()
X = digits.data      # (1797, 64) - Flattened 8x8 images
y = digits.target    # (1797,) - Digit labels

# [2] 평균 중심화
X_meaned = X - np.mean(X, axis=0)

# [3] 공분산 행렬 및 고유값 분해
cov_matrix = np.cov(X_meaned.T)
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

# [4] 고유값 내림차순 정렬 후 주성분 2개 선택
sorted_idx = np.argsort(eigenvalues)[::-1]
top2_vectors = eigenvectors[:, sorted_idx[:2]]

# [5] 2D로 투영
X_2D = X_meaned @ top2_vectors

# [6] 시각화
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_2D[:, 0], X_2D[:, 1], c=y, cmap='tab10', alpha=0.7)
plt.title("Visualization of handwriting data reduced by PCA (2D)")
plt.xlabel("Principal Component  1")
plt.ylabel("Principal Component  2")
plt.legend(*scatter.legend_elements(), title="Digit")
plt.grid(True)
plt.show()

위의 파이썬 코드를 실행한 결과는 다음과 같다.

PCA 적용 및 시각화 결과

지금까지, 고윳값, 고유벡터 그리고 PCA (주성분 분석)의 개념과 파이썬을 활용한 예시에 대해서 알아보았습니다.

감사드립니다.

[Python, Pytorch] Distributed Data Parallel (DDP) 사용법

Minima — Wed, 26 Mar 2025 00:11:39 +0900

안녕하세요, 오늘은 Distributed Data Parallel (DDP) 사용하는 방법에 대해서 알아보겠습니다.

Distributed Data Parallel (DDP)는 PyTorch에서 멀티 GPU 학습을 효율적으로 처리하는 병렬 학습 프레임워크입니다.

각 GPU가 자신의 모델 복사본을 가지고 데이터를 나누어 학습하므로써, Backward 시에만 Gradient를 서로 통신하여 동기화합니다.

다음은, DPP를 활용하는 코드 예시 입니다.

import os
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torchvision import datasets, transforms
from torch.utils.data import DataLoader, DistributedSampler

def main():
    # 환경 변수로부터 rank/local_rank/world_size 읽기
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(local_rank)

    # DDP 초기화
    dist.init_process_group(backend="nccl")

    # 데이터셋 및 DistributedSampler 설정
    transform = transforms.Compose([transforms.ToTensor()])
    train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
    train_sampler = DistributedSampler(train_dataset)
    train_loader = DataLoader(train_dataset, batch_size=128, sampler=train_sampler)

    # 모델, loss, optimizer
    model = CNN().to(local_rank)
    model = DDP(model, device_ids=[local_rank])
    criterion = nn.CrossEntropyLoss().to(local_rank)
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    num_epochs = 10
    import time
    start_time = time.time()
    for epoch in range(num_epochs):
        model.train()
        train_sampler.set_epoch(epoch)  # Epoch마다 셔플을 다르게
        total_loss = 0.0
        for images, labels in train_loader:
            images = images.to(local_rank)
            labels = labels.to(local_rank)

            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()

        if dist.get_rank() == 0:  # 0번 GPU만 출력
            print(f"[Epoch {epoch+1}] Loss: {total_loss:.4f}")

    print(time.time() - start_time)

    dist.destroy_process_group()

if __name__ == "__main__":
    main()

!torchrun --nproc_per_node=2 ddm.py

위의 코드는 GPUs가 2개인 경우에 DDP를 활용한 모델 학습 코드입니다.

해당 코드는 다음과 같은 내용으로 구성되어 있습니다.

GPU ID : 환경변수 LOCAL_RANK를 통해 각 프로세스가 사용할 GPU를 설정
CUDA 디바이스 설정 : torch.cuda.set_device(local_rank)로 GPU 지정
DDP 초기화 : dist.init_process_group(backend="nccl")로 GPU 간 통신 그룹 생성
데이터 로딩 : DistributedSampler로 GPU 마다 데이터 분할
종료 : dist.destroy_process_group()으로 통신 정리

다음은 DataParallel과 Distributed Data Parallel (DDP) 학습 결과를 보여줍니다. (GPU - RTX 4090 x2EA 기준)

DataParallel 결과

Distributed Data Parallel (DDP)

지금까지, PyTorch를 활용해서 Distributed Data Parallel (DDP)를 적용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python, Deep Learning] Tensorflow2 Classification 모델, .onnx & .trt 변환 및 Inference 방법

Minima — Sat, 13 Jul 2024 09:29:16 +0900

안녕하세요, 오늘은 Tensorflow 프레임워크에서 Classification 모델을 .onnx 파일과 .trt 파일로 변환하고 해당 파일을 활용하여 Inference 하는 방법에 대해서 알아보겠습니다.

이를 위해 TEST를 진행한 패키지 버전 및 환경은 다음과 같습니다.

- OS : Ubuntu 22.04
- CUDA : 11.8
- GPU : NVIDIA GeForce RTX 4070 Laptop GPU

- Python : 3.10.12

- tensorflow : 2.14.0
- tf2onnx : 1.16.1
- onnxruntime-gpu : 1.18.1
- nvidia-tensorrt : 8.4.3.1
- pycuda : 2024.1

먼저, tensorflow 2 모델을 onnx 파일로 변환하는 코드에 대해서 알아보겠습니다.

import tensorflow as tf

def convert_tf_to_onnx(tf_model_path, onnx_model_path):
    model = tf.keras.models.load_model(tf_model_path)
    spec = (tf.TensorSpec((1, 1024, 1024, 3), tf.float32, name="input"),)
    model_proto, _ = tf2onnx.convert.from_keras(model, input_signature=spec, opset=13, output_path=onnx_model_path)
    return onnx_model_path

위의 모델은 Tensorflow2 모델의 Input Shape : (1024, 1024, 3)인 상황입니다.

.onnx 파일에 대한 Inference 코드는 다음과 같습니다.

import onnxruntime as ort
import numpy as np

def do_inference_onnx(session, input_data):
    input_name = session.get_inputs()[0].name
    output_name = session.get_outputs()[0].name
    input_data = {input_name: input_data}
    output = session.run([output_name], input_data)
    return output
    
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
ort_session = ort.InferenceSession(onnx_model_path, providers=providers)
input_data = np.random.random((1, 1024, 1024, 3)).astype(np.float32)

for _ in range(100):
    onnx_outputs = do_inference_onnx(ort_session, input_data)

이어서, 변환된 .onnx 파일을 .trt 파일로 변환하는 코드에 대해서 알아보겠습니다.

imort os

def convert_onnx_to_trt(onnx_model_path, trt_engine_path):
    command = f"trtexec --onnx={onnx_model_path} --saveEngine={trt_engine_path} --verbose"
    os.system(command)
    return trt_engine_path

import pycuda.driver as cuda
import tensorrt as trt

def allocate_buffers(engine):
    inputs = []
    outputs = []
    bindings = []
    stream = cuda.Stream()

    for binding in engine:
        size = trt.volume(engine.get_binding_shape(binding)) * engine.max_batch_size
        dtype = trt.nptype(engine.get_binding_dtype(binding))
        host_mem = cuda.pagelocked_empty(size, dtype)
        device_mem = cuda.mem_alloc(host_mem.nbytes)
        bindings.append(int(device_mem))

        if engine.binding_is_input(binding):
            inputs.append((host_mem, device_mem))
        else:
            outputs.append((host_mem, device_mem))
    return inputs, outputs, bindings, stream
    
def load_trt_engine(trt_engine_path):
    with open(trt_engine_path, 'rb') as f:
        engine_data = f.read()
    runtime = trt.Runtime(TRT_LOGGER)
    if runtime is None:
        print("Failed to create TensorRT runtime")
    engine = runtime.deserialize_cuda_engine(engine_data)
    if engine is None:
        print("Failed to load TensorRT engine")
    return engine

# GPU device 설정
cuda.init()
device = cuda.Device(0) # gpu_id = 0 (int)
context = device.make_context()

""" TensorRT Engine 로드 """
engine = load_trt_engine(trt_engine_path)
context = engine.create_execution_context()

inputs, outputs, bindings, stream = allocate_buffers(engine)

""" Input Data를 설정 """
input_data = np.random.random_sample(inputs[0][0].shape).astype(np.float32)
np.copyto(inputs[0][0], input_data.ravel())

""" Inference """
for _ in range(1000):
    trt_outputs = do_inference(context, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream)
    
cuda.Context.pop()

지금까지, Tensorflow 2 모델을 .onnx 파일 및 .trt 파일로 변환하고 Inference 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] YAML (.yaml) 파일 작성 및 사용 하는 방법

Minima — Wed, 10 Jul 2024 21:58:06 +0900

안녕하세요, 오늘은 YAML 파일 작성 및 사용 하는 방법에 대해서 알아보겠습니다.

YAML 파일을 작성 후 Python에서 사용하기 위해서는 다음 패키지를 설치합니다.

pip install pyyaml

패키지 설치 후 다음과 같이 config.yaml 파일을 작성하는 예시를 살펴 보겠습니다.

YAML 파일을 작성하는 주요 데이터 형식은 다음과 같습니다.

문자열 (String)
정수 (Integer)
부동 소수점 (Float)
Boolean
Null 값
Collection (리스트, 딕셔너리)
복합 자료형

먼저, 문자열 (String) 예시에 대해서 알아보겠습니다.

string: "Hello, World!"
single_quoted_string: 'Hello, World!'
unquoted_string: HelloWorld
multiline_string: |
  This is a
  multiline string.

두번째, 정수 (Interger)에 대한 예시 입니다.

integer: 42
negative_integer: -42
octal_integer: 0o52
hex_integer: 0x2A

세번째, 부동 소수점(Float)에 대한 예시 입니다.

float: 3.14
negative_float: -3.14
exponential_float: 1.0e+2

네번째, Boolean에 대한 예시 입니다.

boolean_true: true
boolean_false: false

다섯번째, Null 값에 대한 예시 입니다.

null_value: null
empty_value:

여섯번째, Collecions 내 리스트에 대한 예시 입니다.

list:
  - item1
  - item2
  - item3
inline_list: [item1, item2, item3]

딕셔너리에 대한 예시 입니다.

dict:
  key1: value1
  key2: value2
inline_dict: {key1: value1, key2: value2}

마지막, 복합 자료형에 대한 예시 입니다.

1) 리스트 안에 딕셔너리

list_of_dicts:
  - name: server1
    ip: 192.168.1.1
    role: web
  - name: server2
    ip: 192.168.1.2
    role: db

2) 딕셔너리 안에 리스트

dict_of_lists:
  web_servers:
    - server1
    - server2
  db_servers:
    - server3
    - server4

위와 같이 작성된 YAML 파일을 파이썬에 대해서 다음과 같이 사용할 수 있습니다.

import yaml
# os.path.dirname(os.path.abspath(__file__))

# YAML 파일 읽기
with open('config.yaml', 'r') as file:
    config_data = yaml.safe_load(file)
    
# YAML 파일 업데이트
config_data[...] = ...

# YAML 파일 저장
with open('config.yaml', 'w') as file:
    yaml.dump(config_data, file, default_flow_style=False)

지금까지, YAML 파일을 작성하고 파이썬 패키지를 활용하여 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] Cryptography 라이브러리 (hazmat 모듈) 사용법

Minima — Tue, 9 Jul 2024 22:05:02 +0900

안녕하세요, 오늘은 Cryptography 라이브러리에서 hazmat 모듈을 사용하는 방법에 대해서 알아보겠습니다.

hazmat 모듈을 사용하는 예시는 다음과 같습니다.

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import os
import base64

def encrypt_file(file_path, password, output_path):
    backend = default_backend()
    salt = os.urandom(16)
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
        backend=backend
    )
    key = kdf.derive(password.encode())

    iv = os.urandom(16)
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
    encryptor = cipher.encryptor()

    with open(file_path, 'rb') as f:
        data = f.read()

    padder = padding.PKCS7(128).padder()
    padded_data = padder.update(data) + padder.finalize()

    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()

    with open(output_path, 'wb') as f:
        f.write(base64.b64encode(salt + iv + encrypted_data))

# 사용 예시
encrypt_file('model.h5', 'test_password', 'model.encrypted')

위의 코드는 tensorflow2 프레임워크 내 특정 모델 model.h5 파일을 특정 비밀번호 = 'test_password'를 활용해서 model.encrypted 파일로 암호화 하는 코드 입니다.

이어서, 해당 파일을 복호화하는 코드에 대해서 알아보겠습니다.

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64

def decrypt_file(encrypted_file_path, password, output_path):
    backend = default_backend()

    with open(encrypted_file_path, 'rb') as f:
        encrypted_data = base64.b64decode(f.read())

    salt = encrypted_data[:16]
    iv = encrypted_data[16:32]
    cipher_text = encrypted_data[32:]

    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
        backend=backend
    )
    key = kdf.derive(password.encode())

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
    decryptor = cipher.decryptor()

    padded_data = decryptor.update(cipher_text) + decryptor.finalize()

    unpadder = padding.PKCS7(128).unpadder()
    data = unpadder.update(padded_data) + unpadder.finalize()

    with open(output_path, 'wb') as f:
        f.write(data)

# 사용 예시
decrypt_file('model.encrypted', 'test_password', 'model.h5')

추가적으로, 복호화 시 따로 model.h5 파일로 저장하지 않고 복호화 후, 메모리 상헤서 바로 로드하여 사용하는 방법에 대해서 알아보겠습니다.

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64
import io
import h5py
import tensorflow as tf

def decrypt_and_load_model(encrypted_file_path, password):
    backend = default_backend()

    with open(encrypted_file_path, 'rb') as f:
        encrypted_data = base64.b64decode(f.read())

    salt = encrypted_data[:16]
    iv = encrypted_data[16:32]
    cipher_text = encrypted_data[32:]

    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
        backend=backend
    )
    key = kdf.derive(password.encode())

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
    decryptor = cipher.decryptor()

    padded_data = decryptor.update(cipher_text) + decryptor.finalize()

    unpadder = padding.PKCS7(128).unpadder()
    data = unpadder.update(padded_data) + unpadder.finalize()

    # 메모리 상에서 파일 객체로 변환
    model_data = io.BytesIO(data)

    # TensorFlow 모델 로드
    with h5py.File(model_data, 'r') as f:
    	model = tf.keras.models.load_model(f)

    return model

# 사용 예시
model = decrypt_and_load_model('model.encrypted', 'test_password')

위의 코드에서 파일을 저장하지 않고, io.BytesIO를 사용하여 데이터를 메모리 상의 파일 객체로 만들고, tf.keras.models.load_model() 함수를 사용하여 Tensorflow 모델을 로드할 수 있습니다.

추가적으로 각 OS 별로 환경 변수 설정하는 방법에 대해서 알아보겠습니다.

bash를 사용하는 경우 : nano ~/.bashrc
zsh를 사용하는 경우 : nano ~/.zshrc

파일 끝에 다음과 같은 줄을 추가 합니다.

export ENCRYPTION_PASSWORD=test_password

이어서 변경 사항을 적용합니다.

source ~/.bashrc  # 또는 ~/.zshrc 등

환경 변수로 정상적으로 적용되었는 지 확인하기 위해서는 다음 명령어로 확인 가능합니다.

echo $ENCRYPTION_PASSWORD

echo %ENCRYPTION_PASSWORD%

파이썬 코드에서 위와 같이 설정한 환경 변수를 사용하기 위해서는 다음과 같은 코드를 사용 가능합니다.

import os

# 환경 변수에서 비밀번호 가져오기
password = os.getenv('ENCRYPTION_PASSWORD')

if password is None:
    raise ValueError("환경 변수 ENCRYPTION_PASSWORD가 설정되지 않았습니다.")

# 사용 예시
model = decrypt_and_load_model('encrypted_model.encrypted', password)

지금까지, Cryptography 라이브러리 내 hazmat 모듈을 사용하여 파일을 암호화, 복호화 및 메모리 상의 파일 객체로 만드는 방법, 그리고 환경 변수 설정 및 사용방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] Node Selector 개념 및 예제 코드

Minima — Mon, 17 Jun 2024 22:50:59 +0900

안녕하세요, 오늘은 Node Selector 개념에 대해서 알아보고 예제 코드를 적용해보겠습니다.

https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodeselector

Assigning Pods to Nodes

You can constrain a Pod so that it is restricted to run on particular node(s), or to prefer to run on particular nodes. There are several ways to do this and the recommended approaches all use label selectors to facilitate the selection. Often, you do not

kubernetes.io

Node Selector 란?

: 노드에 할당된 라벨을 기반으로 파드를 특정 노드에만 스케줄링하도록 제한합니다

Node Selector는 Node에 할당된 Label과 Pod Spec에 정의된 Node Selector를 매칭하여 작동하며, Node가 Pod의 Node Selector 요구사항을 충족하는 라벨을 가지고 있으면 해당 파드를 해당 노드에 스케줄링할 수 있습니다.

다음은 Node Selector를 적용하는 YAML 파일 예시입니다.

아래 예시는 특정 Node에 SSD Storage에 대한 Label을 부여하고, Pod Spec을 통해 Node Selector을 정의하여 매칭합니다.

kubectl label nodes <노드 이름> disktype=ssd

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx
  nodeSelector:
    disktype: ssd

위의 YAML 파일을 통해 실행된 결과는 disktype=ssd 라벨을 가진 노드에서만 스케줄링 됩니다.

Node Selector 사용의 장점은 다음과 같습니다.

단순성: Node Selector는 사용법이 간단하고 이해하기 쉬워, 간단한 스케줄링 요구사항에 적합
제어: 노드 라벨을 기반으로 파드 배치를 제어하는 명확한 방법을 제공
자원 관리: Node Selector를 사용하여 특정 자원을 가진 노드에 워크로드를 효과적으로 배치 가능

Node Selector의 한계는 다음과 같습니다.

제한된 유연성: Node Selector는 라벨의 정확한 매칭만 지원하며, 더 복잡한 매칭 규칙이나 표현을 지원X
소프트 제약 없음: Node Selector는 선호도나 소프트 제약 조건을 지원하지 않습니다. 모든 지정된 제약 조건이 충족되어야만 파드를 스케줄링 가능

더 복잡한 Scheduling을 위해서는 Node Affinity 를 사용하면 됩니다.

지금까지, Node Selector의 개념과 예제 코드에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] Pod Scheduling (Taints & Tolerations) 개념 및 예제 코드

Minima — Thu, 13 Jun 2024 00:02:40 +0900

안녕하세요, 오늘은 Pod Scheduling을 하는 방법 중에 하나인 Taints와 Tolerations 개념과 예제 코드에 대해서 알아보겠습니다.

Taints와 Tolerations는 노드에 특정 Pod가 스케줄링되는 것을 제어하기 위한 메커니즘이며, 특정 노드에 특정 Pod가 배치되지 않도록 하거나, 특정 Pod가 특정 노드에서만 실행되도록 할 때 사용됩니다. Taints와 Tolerations는 함께 작동하여 노드의 리소스를 보다 효율적으로 사용하고, 특정 요구 사항을 가진 Pod의 배치를 제어하는 개념입니다.

Taints 개념을 적용하기 위한 형식은 다음과 같습니다.

kubectl taint nodes <node-name> key=value:effect

key: Taint의 키.
value: Taint의 값.
effect: Taint의 효과로, 노드에 적용되는 Taint의 동작을 정의하며, 3가지로 구성됨
- NoSchedule: Taint를 허용하지 않는 Pod는 이 노드에 스케줄링되지 않습니다.
- PreferNoSchedule: Taint를 허용하지 않는 Pod는 가능하면 이 노드에 스케줄링되지 않도록 합니다.
- NoExecute: Taint를 허용하지 않는 Pod는 즉시 이 노드에서 제거되거나, 처음부터 이 노드에 스케줄링되지 않습니다.

Tolerations 개념을 적용하기 위한 형식은 다음과 같습니다.

tolerations:
- key: "key1"
  operator: "Equal"
  value: "value1"
  effect: "NoSchedule"

이를 활용하여 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoSchedule"

위의 Taints와 Tolerations는 다음과 같은 상황에서 주로 사용하게 됩니다.

특정 노드에만 특정 Pod 스케줄링: 고성능 컴퓨팅을 필요로 하는 WorkLoad를 특정 노드에만 배치함
노드 유지보수: 노드를 유지보수 모드로 설정하여, 새로운 Pod가 스케줄링되지 않도록 하고, 기존 Pod를 점차 다른 노드로 이동함
특정 Pod 격리: 테스트 환경의 Pod가 프로덕션 노드에 스케줄링되지 않도록 함

지금까지, Pod Scheduling 방법 중 하나인 Taints와 Tolerations의 개념에 대해서 알아보고 적용하는 예시에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] YAML 파일 내 Object kind (k8s 객체 유형)

Minima — Sun, 9 Jun 2024 23:04:58 +0900

안녕하세요, 오늘은 Kubernetes에서 YAML 파일 내 kind 항목으로 사용할 수 있는 객체 유형들에 대해서 알아보겠습니다.

아래는 YAML 파일을 작성하는 간단한 예시 입니다.

apiVersion: v1
kind: Pod
metadata:
  name: sample-pod
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2

크게 나누면 다음과 같이 나눌 수 있습니다.

[Workloads : 애플리케이션을 정의하는 객체]

Pod : 클러스터에서 실행 중인 프로세스의 단일 인스턴스
ReplicationController : 관리하는 Pod를 지속적으로 관리 하여 원하는 복제본 수를 유지
ReplicaSet : 세트 기반 선택기를 지원하여 이 기능을 확장하여 포드 선택 및 관리 방법에 대한 더 큰 유연성과 제어 기능을 제공
Deployment : 롤링 업데이트를 지원하므로 가동 중지 시간 없이 애플리케이션을 업데이트 가능
StatefulSet : 지속적인 스토리지와 안정적인 네트워크 ID가 필요한 상태 저장 애플리케이션을 관리
DaemonSet : Pod의 복사본이 클러스터의 모든(또는 일부) 노드에서 실행되는지 확인
Job : 하나 이상의 Pod를 생성하고 지정된 수의 Pod가 성공적으로 종료되는지 확인
CronJob : 백업, 보고서 생성, 이메일 전송과 같은 정기적인 작업을 수행하는 데 유용

[Service Discovery and Load Balancing : 클러스터 내 및 외부에서 서비스가 노출되고 액세스되는 방식을 관리]

Service : Pod 그룹에 액세스하기 위해 안정적인 IP 주소와 DNS 이름을 제공
Endpoint : 서비스의 대상이 되는 Pod의 실제 IP 주소를 정의
Ingress : 서비스(일반적으로 HTTP)에 대한 외부 액세스를 관리

[Config and Storage : 애플리케이션의 구성 데이터와 영구 저장소를 관리]

ConfigMap : 구성 데이터를 키-값 쌍으로 저장
Secret : 비밀번호, OAuth 토큰, SSH 키 등 민감한 데이터를 암호화된 형식으로 저장
PersistentVolume : 개별 Pod의 수명이 다할 때까지 데이터를 유지하는 데 사용
PersistentVolumeClaim : Pod에서 영구 스토리지 리소스를 요청하는 데 사용
Volume : 임시 스토리지, 영구 스토리지, 네트워크 스토리지 등 다양한 스토리지 솔루션을 제공

[Cluster : 클러스터 수준에서 리소스와 권한을 관리]

Namespace : 여러 사용자 또는 팀 간에 클러스터 리소스를 나누어 격리를 제공하고 리소스 할당을 관리
Node : 클러스터의 작업자 노드를 나타내며, Kubernetes 런타임을 실행하고 애플리케이션을 구성하는 컨테이너를 호스팅
LimitRange : Namespace 내의 CPU 및 메모리와 같은 리소스에 대한 최소/최대 제약 조건을 정의
ResourceQuota : Namespace 마다 총 리소스 소비를 관리
ServiceAccount : Pod에서 실행되는 프로세스에 대한 ID를 제공
Role : Namespace 내의 권한을 정의
RoleBinding : Namespace 내의 사용자, 그룹 또는 서비스 계정에 역할에 정의된 권한을 부여
ClusterRole : Cluster 전체 권한을 정의
ClusterRoleBinding : ClusterRole에 정의된 권한을 모든 Namespace의 사용자, 그룹 또는 서비스 계정에 부여

지금까지, YAML 파일을 구성하는 Object kind 항목들에 대해서 알아보았습니다.

감사드립니다.

[Ubuntu] lsblk, lsblk -f, df - h,파일 시스템, 마운트, 자동 마운트

Minima — Sat, 25 May 2024 14:26:56 +0900

안녕하세요, 오늘은 Ubuntu 에서 디스크와 파티션을 관리하는 방법에 대해서 알아보겠습니다.

Linux에서 블록 장치 정보를 출력하는 명령어는 다음과 같습니다.

lsblk

위의 명령어를 입력하게 되면 시스템에 연결된 모든 블록 장치의 목록들이 나타납니다.

추가적으로 -f 옵션을 사용하면 파일 시스템 정보도 확인 가능합니다.

lsblk -f

여기서, 파일 시스템은 데이터를 저장하고 조작하는 방법을 정의하는 시스템입니다. 이때, 우분투에서 자주 사용되는 파일 시스템은 `ext4` 입니다.

이때, 특정 파이션에 파일 시스템이 없는 경우에는 파일 시스템을 생성합니다. (예시)

sudo mkfs.ext4 /dev/sdb1

이어서, 마운트를 하기 위해서는 마운트할 디렉토리를 생성합니다.

sudo mkdir /mnt/mydisk1

마운트할 디렉토리에 파티션을 마운트합니다.

sudo mount /dev/sdb1 /mnt/mydisk1

시스템 재 부팅 후에서 자동으로 마운트 할 수 있게 하려면 다음과 같이 설정해주셔야 합니다.

sudo nano /etc/fstab

/dev/sdb1 /mnt/mydisk1 ext4 defaults 0 0

마운트의 결과가 정상적으로 적용되었는 지 확인하기 위해서는 다음 명령어로 확인 가능합니다.

df -h

지금까지, 우분투에서 디스크와 파티션을 관리하면서 파티션을 마운트 및 자동 마운트 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] Rancher Desktop 설치 방법 (Ubuntu)

Minima — Wed, 22 May 2024 22:53:44 +0900

안녕하세요, 오늘은 Ubuntu OS에서 Rancher Desktop을 설치하는 방법에 대해서 알아보겠습니다.

https://docs.rancherdesktop.io/getting-started/installation/

Installation | Rancher Desktop Docs

Rancher Desktop is delivered as a desktop application. You can download it from

docs.rancherdesktop.io

위의 링크에 접속 후 다음 명령어 입력을 통해 Rancher Desktop을 설치합니다.

위의 이미지 속 명령어는 다음과 같습니다.

curl -s https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/Release.key | gpg --dearmor | sudo dd status=none of=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg
echo 'deb [signed-by=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg] https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/ ./' | sudo dd status=none of=/etc/apt/sources.list.d/isv-rancher-stable.list
sudo apt update
sudo apt install rancher-desktop

지금까지 Ubuntu OS에서 Rancher Desktop을 설치하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Flask] Json Web Token (JWT) 사용 방법 - (Token 생성 및 접근)

Minima — Tue, 21 May 2024 23:04:46 +0900

안녕하세요, 오늘은 Vue.js 프로젝트에서 Json Web Tokens (JWT)를 사용하는 방법에 대해서 알아보겠습니다.

Backend에서는 Flask를 사용하여 Token을 생성할 예정입니다.

먼저, 다음과 같이 파이썬 패키지를 설치합니다.

pip install flask flask_cors flask_apscheduler flask[async] Flask-SoketIO 
pip install Flask-JWT-Extented python-dotenv

import os

from flask_socketio import SocketIO, emit
from flask import Flask, request, jsonify, render_template, redirect, session, g
from flask_cors import CORS
from flask_apscheduler import APScheduler
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity, verify_jwt_in_request
from dotenv import load_dotenv

load_dotenv()

class Config:
    SCHEDULE_API_ENABLED = True

app = Flask(__name__)
app.config.from_object(Config())
jwt = JWTManager(app)

app.config['SECRET_KEY'] = os.getenv('SECRET_KEY')
app.config['JWT_SECRET_KEY'] = os.getenv('JWT_SECRET_KEY')

CORS(app, resources={r'/*': {'origins' : '*'}})

# user 및 비밀번호 설정
users = {"test": "testpw"}


# Route 설정 및 JWT token 생성
@app.route('/login', methods=['POST'])
def login():
    username = request.json.get('username', None)
    password = request.json.get('password', None)

    if not username or not password:
        return jsonify({"msg": "잘못된 요청"}), 400

    if username not in users or users[username] != password:
        return jsonify({"msg": "유저 또는 비밀번호 잘못된 입력"}), 401

    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token), 200


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

위의 코드에서 다음과 같은 명령어로 token에 접근할 수 있습니다.

curl -X POST -H "Content-Type: application/json" -d '{"username": "test", "password": "testpW' http://127.0.0.1:5000/login

해당 명령어 입력에 따른 결과는 다음과 같습니다.

{"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTcxNjI5OTcxNSwianRpIjoiMzU1MmQ2MGUtZTIzMy00NWQyLWE4ZTEtZTNiMjYwNGUwOGM1IiwidHlwZSI6ImFjY2VzcyIsInN1YiI6InRlc3R1c2VyIiwibmJmIjoxNzE2Mjk5NzE1LCJjc3JmIjoiZjFkMmMyYWQtZDEwZi00NzYzLWJkN2ItMmM1NTIzZDZmOGNhIiwiZXhwIjoxNzE2MzAwNjE1fQ.ZZIhJKC3yis-KusJIC6Z7oTu69dkTrB0Xi5gtsAOff4"}

위의 access_token은 POST 할때 마다 다른 token이 생성되게 됩니다.

지금까지, Flask에서 Toekn을 생성하고 접근하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Linux] Ubuntu 부팅 디스크 만드는 방법 (Ubuntu 23.10, 22.04)

Minima — Sat, 18 May 2024 11:40:28 +0900

안녕하세요, 오늘은 Ubuntu 부팅 디스크를 만드는 방법에 대해서 알아보겠습니다.

Ubuntu 부팅 디스크를 만들기 위해 필요한 것들은 다음과 같습니다.

USB
Rufus 프로그램
Ubuntu 23.10 .iso 파일

1번 USB 파일을 준비 되어있는 상태에서 Rufus 프로그램을 설치하는 링크는 다음과 같습니다.

https://rufus.ie/ko

Rufus - 간편하게 부팅 가능한 USB 드라이브 만들기

Rufus는 USB 메모리 및 플래시 드라이브를 포맷하고 부팅할 수 있도록 만드는 도구입니다. 이 페이지 아래에 나열된 ISO 이미지 이외에도 Rufus는 여러 종류의 ISO 이미지를 지원합니다. (1) Windows 8 이

rufus.ie

이어서, Ubuntu .iso 파일을 다음 링크에서 설치합니다.

https://mirror.kakao.com/ubuntu-releases/

Ubuntu Releases

There are 2 types of Ubuntu releases: Interim and LTS. Each Ubuntu LTS is maintained for 10 years total: 5 years of standard support + 5 years of ESM. Interim releases are maintained for 9 months. For the Ubuntu release cycle please see: The Ubuntu lifecyc

mirror.kakao.com

Desktop or Server 설치에 따라서 해당 .iso 이미지를 설치해주시면 됩니다.

설치 후 Rufus 프로그램을 실행시킵니다.

(이때, USB는 연결된 상태이며, 기존 파일 및 데이터가 있는 경우 백업 및 포맷에 유의하셔야 합니다.)

Rufus 프로그램 실행 화면

위의 화면에서 부팅 선택 후 ISO 이미지를 선택 후 시작 버튼을 눌러 OK 및 진행해주시면 됩니다.

지금까지, Ubuntu 부팅 디스크를 만드는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] .bat 파일을 활용하여 공유 폴더 설정 및 해제(Windows)

Minima — Fri, 10 May 2024 22:05:48 +0900

안녕하세요, 오늘은 Windows 운영체제에서 .bat 파일을 활용하여 파이썬에서 공유 폴더 설정 및 해제 하는 방법에 대해서 알아보겠습니다.

공유 폴더 설정 및 해제를 위해 유의해야할 부분은 "관리자 권한"으로 실행해야한다는 부분입니다.

관리자 권한으로 실행하기 위해서 다음과 같이 .bat 파일을 구성해야 합니다.

@echo off

>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system"
if '%errorlevel%' NEQ '0' (
    echo Requesting administrative privileges...
    goto UACPrompt
) else ( goto gotAdmin )

:UACPrompt
echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
set params = %*:"=""
echo UAC.ShellExecute "cmd.exe", "/c %~s0 %params%", "", "runas", 1 >> "%temp%\getadmin.vbs"
"%temp%\getadmin.vbs"
del "%temp%\getadmin.vbs"
exit /B

:gotAdmin
pushd "%CD%"
CD /D "%~dp0"

{실행할 명령어}
pause

위의 .bat 파일에서 {실행할 명령어} 부분만 수정하면 됩니다.

위의 파일을 활용하여, 다음과 같이 코드를 수정합니다.

def create_admin_batch(script_name):
    batch_content = f"""
@echo off
>nul 2>&1 "%SYSTEMROOT%\\system32\\cacls.exe" "%SYSTEMROOT%\\system32\\config\\system"

if '%errorlevel%' NEQ '0' (
    echo Requesting administrative privileges...
    goto UACPrompt
) else ( goto gotAdmin )

:UACPrompt
echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\\getadmin.vbs"
set params = %*:"=""
echo UAC.ShellExecute "cmd.exe", "/c %~s0 %params%", "", "runas", 1 >> "%temp%\\getadmin.vbs"

"%temp%\\getadmin.vbs"
del "%temp%\\getadmin.vbs"
exit /B

:gotAdmin
pushd "%CD%"
CD /D "%~dp0"

{script_name}
pause
"""

    with open("run_as_admin.bat", "w") as file:
        file.write(batch_content)
    print("배치 파일이 생성  완료.")

위의 함수를 활용하여, 다음과 같이 관리자 권한으로 batch 파일을 실행 가능합니다.

import subprocess

def run_batch_file(batch_file_path):
    # 프롬프트가 보이지 않도록 설정
    si = subprocess.STARTUPINFO()
    si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    si.wShowWindow = subprocess.SW_HIDE  # CMD 창을 숨깁니다.

    # subprocess.run을 사용하여 배치 파일 실행
    result = subprocess.run(batch_file_path, shell=True, text=True, capture_output=True, startupinfo=si)
    
    # 실행 결과 출력
    if result.returncode == 0:
        print("배치 파일이 성공적으로 실행되었습니다.")
        print("출력:", result.stdout)
    else:
        print("배치 파일 실행 중 오류가 발생했습니다.")
        print("오류 메시지:", result.stderr)

# 배치 파일 경로 지정
batch_file_path = 'run_as_admin.bat'

# 배치 파일 실행 함수 호출
run_batch_file(batch_file_path)

위의 2가지 함수를 활용하여 공유 폴더를 생성하는 함수를 실행할 수 있습니다.

import subprocess

def create_shared_folder(share_name, folder_path):
    # 공유명과 폴더 경로를 설정합니다.
    # /grant:everyone,full은 모든 사용자에게 전체 권한을 부여합니다.
    cmd = f'net share {share_name}="{folder_path}" /grant:everyone,full'
    
    create_admin_batch(cmd)
    
    # 배치 파일 경로 지정
    batch_file_path = 'run_as_admin.bat'

    # 배치 파일 실행 함수 호출
    run_batch_file(batch_file_path)
    
    

folder_path = "D:\\새로운 공유 폴더"
share_name = "MySharedFolder"
create_shared_folder(share_name, folder_path)

반대로 공유 폴더를 해제하는 함수를 실행할 수 있습니다.

import subprocess

def remove_shared_folder(share_name):
    cmd = f'net share {share_name} /delete'
    
    create_admin_batch(cmd)
    
    # 배치 파일 경로 지정
    batch_file_path = 'run_as_admin.bat'

    # 배치 파일 실행 함수 호출
    run_batch_file(batch_file_path)
    
    

share_name = "MySharedFolder"
remove_shared_folder(share_name)

지금까지, Windows 운영체제에서 .bat 파일을 활용하여 Python에서 공유 폴더를 설정 및 해제 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] 공유 폴더 설정 및 삭제 하기 (Ubuntu, Samba, smbclient, mount/unmount)

Minima — Tue, 7 May 2024 21:53:11 +0900

안녕하새요, 오늘은 Ubuntu 운영 체제에서 Samba 서비스를 사용하여 공유 폴더를 설정하고 해제하는 방법에 대해서 알아보겠습니다.

먼저, samba 패키지를 설치합니다.

sudo apt-get update
sudo apt-get install samba

위의 명령어를 통해 samba 패키지를 설치 후 서비스 상태 확인을 다음 명령어를 통해 확인합니다.

sudo systemctl status smbd

서비스 상태가 정상적인 것을 확인 후 다음 명령어를 통해 시스템 사용자 추가 후 Samba 사용자로 추가합니다.

sudo adduser 사용자이름

sudo smbpasswd -a 사용자이름

위의 명령어 실행 후 사용자의 Samba 비밀번호를 입력가능합니다.

또한, 외부에서 Samba 서비스에 접근하기 위해서는 필요한 포트를 방화벽에서 열어주어야 합니다.

sudo apt-get install ufw
sudo ufw enable

이어서 특정 IPs에 대해 Samba 서비스에 접근할 수 있도록 설정해줄 수 있습니다.

sudo ufw allow from {IP-1} to any port 445 proto tcp
sudo ufw allow from {IP-2} to any port 445 proto tcp
sudo ufw allow from {IP-3} to any port 445 proto tcp

설정이 올바르게 적용되었는 지 다음 명령어를 통해 확인 가능합니다.

sudo ufw status verbose

최종적으로 반드시 방화벽을 Reload 해주어야 합니다.

sudo ufw reload

이어서, 파이썬을 통해 공유 폴더를 설정하는 코드에 대해서 알아보겠습니다.

import os

def add_samba_share(share_name, path, read_only=True):
    with open('/etc/samba/smb.conf', 'a') as file:
        file.write(f"\n[{share_name}]\n")
        file.write(f"path = {path}\n")
        file.write(f"valid users  {사용자이름}\n")
        file.write("browseable = yes\n")
        file.write(f"read only = {'yes' if read_only else 'no'}\n")
        file.write("guest ok = no\n")

    os.system("sudo systemctl restart smbd")

add_samba_share('MyShare', '/home/username/shared_folder', read_only=False)

이어서 공유 폴더 해제 하는 코드에 대해서 알아보겠습니다.

def remove_samba_share(share_name):
    with open("/etc/samba/smb.conf", "r") as file:
        lines = file.readlines()

    with open("/etc/samba/smb.conf", "w") as file:
        in_section = False
        for line in lines:
            if line.strip().startswith(f"[{share_name}]"):
                in_section = True
            elif in_section and line.startswith('['):
                in_section = False

            if not in_section:
                file.write(line)

    os.system("sudo systemctl restart smbd")

remove_samba_share('MyShare')

이어서, Linux 및 유닉스 시스템에서 Samba 공유 폴더에 접근하기 위한 도구인 smbclient에 대해서 알아보겠습니다.

이를 사용하기 위해서 다음 명령어를 통해 설치 가능합니다.

sudo apt update
sudo apt install smbclient

설치 완료 후 다음 명령어를 통해 Samba 공유 목록을 볼수 있습니다.

smbclient -L //서버주소 -U 사용자명

위의 명령어를 통해 확인한 공유 폴더를 cifs-utils 패키지를 통해 Mount 할 수 있습니다.

sudo apt-get update
sudo apt-get install cifs-utils

위의 명령어를 통해 cifs-utils 패키지를 설치 후 Mount 할 디렉토리를 생성합니다.

(Mount 시에는 빈 디렉토리에 적용하는 것이 좋습니다.)

sudo mkdir /mnt/samba_share

디렉토리 생성 후 다음 명령어를 통해 수동 Mount 가능합니다.

sudo mount -t cifs //서버주소/공유명 /mnt/samba_share -o username=사용자명,password=비밀번호

하지만, 수동 Mount 시에 시스템 재부팅 하면 다시 Mount를 해주어야 하기 때문에 /etc/fstab 파일에 다음과 같이 추가합니다.

//서버주소/공유명 /mnt/samba_share cifs username=사용자명,password=비밀번호,iocharset=utf8,sec=ntlmssp 0 0

sudo mount -a

Mount 된 공유에 대해 Unmount 하기 위한 명령어는 다음과 같습니다.

sudo umount /mnt/samba_share

지금까지, Ubuntu(Linux)에서 공유 폴더를 설정하고 해제 및 Mount/Unmount 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Vue.js] PrimeVue 사용하는 방법 (UI Component 라이브러리)

Minima — Tue, 30 Apr 2024 00:00:48 +0900

안녕하세요, 오늘은 Vue.js를 위한 UI Component 라이브러리인 PrimeVue를 사용하는 방법에 대해서 알아보겠습니다.

PrimeVue를 사용하기 위한 명령어는 다음과 같습니다.

npm install primevue 
npm install primeicons

위의 명령어를 통해 라이브러리를 설치 후 main.js 파일을 다음과 같이 수정합니다.

import { createApp } from 'vue';
import App from './App.vue';
import PrimeVue from 'primevue/config';
import 'primevue/resources/themes/saga-blue/theme.css';     
import 'primevue/resources/primevue.min.css';                
import 'primeicons/primeicons.css';                      

const app = createApp(App);
app.use(PrimeVue);
app.mount('#app');

자세한 내용 관련 해서는 다음 링크를 통해 확인 가능합니다.

https://primevue.org/introduction/

PrimeVue | Vue UI Component Library

The ultimate collection of design-agnostic, flexible and accessible Vue UI Components.

primevue.org

지금까지, Vue.js를 위한 UI Component 라이브러리인 PrimeVue를 사용하는 방법에 대해서 알아보았습니다.
감사드립니다.

[Vue.js] Material Design Icons (MDI) 사용법

Minima — Mon, 29 Apr 2024 23:40:28 +0900

안녕하세요, 오늘은 Material Design Icons (MDI) 사용 하는 방법에 대해서 알아보겠습니다.

이를 위해 다음과 같은 명령어를 통해 패키지를 설치합니다.

npm install @mdi/js

npm install @jamescoyle/vue-icon

위의 패키지를 설치 후 Vue Component 내 다음과 같이 사용할 수 있습니다.

<script>
import {mdiCamera} from "@mdi/js";
import SvgIcon from '@jamescoyle/vue-icon'

export default {
  name: 'TestApp',
  components: {
    SvgIcon
  },

  data: () => ({
    path: mdiCamera,

  }),
}

</script>

위의 코드는 Javascript 관련 코드 입니다. 이를 활용하여, <template></template> 내부에서 다음과 같이 사용할 수 있습니다.

<template>
	<svg-icon type="mdi" :path="path"></svg-icon>
</template>

다양한 Icons 관련 해서는 다음 링크에서 확인 가능합니다.

https://pictogrammers.com/library/mdi/

Material Design Icons - Icon Library - Pictogrammers

The original. Following Google's Material Design guidelines for system icons, MDI is our largest library, touting over 7200 unique icons!

pictogrammers.com

이상으로, Vue.js에서 Material Design Icons (MDI)를 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker를 활용한 GitLab 설치 및 사용 방법

Minima — Sun, 21 Apr 2024 15:35:47 +0900

오늘은 Docker를 활용하여 GitLab을 설치하고 사용하는 방법에 대해서 알아보겠습니다.

GitLab을 설치하고 사용하기 위해 필요한 Docker 이미지는 다음과 같습니다.

다음 명령어를 통해, GitLab에 대한 Container를 생성합니다.

docker run --detach \                                                                                                                                                                      Py base 15:02:30
  --hostname gitlab.example.com \
  --publish 1980:80 --publish 1922:22 --publish 19443:443 \
  --name gitlab \
  --restart always \
  --volume $HOME/gitlab/config:/etc/gitlab \
  --volume $HOME/gitlab/logs:/var/log/gitlab \
  --volume $HOME/gitlab/data:/var/opt/gitlab \
  gitlab/gitlab-ce:latest

위의 명령어를 실행 후 몇분의 시간이 지난 다음 localhost:1980 접속을 하면 다음과 같은 초기 화면이 나옵니다.

GitLab 초기 실행 화면

초기 실행 화면에서 Root 계정으로 로그인 하는 방법은 다음과 같습니다.

docker exec -it gitlab /bin/bash

cat /etc/gitlab/initial_root_password

위의 명령어를 통해 출력되는 초기 root 비밀번호를 통해 로그인 합니다 (username : root)

root 계정 로그인 화면

이후, 개인 User들은 초기 화면에서 Register 메뉴를 통해 가입 후 Root 계정이 승인하면 로그인 가능합니다.

지금까지, Docker를 통해 GitLab을 설치하고 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker를 활용하여 Jenkins 사용하는 방법 (CI/CD)

Minima — Thu, 18 Apr 2024 00:01:31 +0900

안녕하세요, 오늘은 Docker를 활용하여 Jenkins를 사용하는 방법에 대해서 알아보겠습니다.

https://www.jenkins.io/

Jenkins

Jenkins – an open source automation server which enables developers around the world to reliably build, test, and deploy their software

www.jenkins.io

Jenkins는 다양한 CI/CD 프로세스를 지원하는 강력한 오픈 소스 자동화 서버로, 구축, 테스트, 배포와 관련된 소프트웨어 개발 측면을 자동화하여 지속적인 통합과 지속적인 제공을 촉진합니다. 이는 플러그인 기반이기 떄문에, 다양한 플러그인을 확장하여 프로젝트들의 구축, 배포 및 자동화를 지원할 수 있습니다.

1. Jenkins를 사용하기 위해 첫번째 단계는 Docker 이미지를 가져오는 것입니다.

docker pull jenkins/jenkins:lts

2. Jenkins 컨테이너 실행

docker run -d -p 8080:8080 -p 50000:50000 --name jenkins-master jenkins/jenkins:lts

컨테이너 실행 후에는 httpL//<docker-host-ip>:8080으로 이동하여 액세스 가능합니다.

Jenkins 초기 실행 화면

3. 초기 설정

docker exec jenkins-master cat /var/jenkins_home/secrets/initialAdminPassword

위의 명령어로 나온 initialAdminPassword를 입력하여 초기 설정을 진행합니다.

초기 설정 진행 화면

지금까지, Docker를 활용하여 Jenkins를 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker Image 분할 압축 및 해제 방법

Minima — Wed, 17 Apr 2024 21:57:23 +0900

안녕하세요, 오늘은 Docker Image를 분할 압축하는 방법에 대해서 알아보겠습니다.

Docker Image를 생성하다보면 대용량 Docker Image가 생성되어 해당 Docker Image를 다른 PC로 복사하지 못하는 것을 확인할 수 있습니다. 이를 해결하기 위해 각 Docker Image를 분할 압축하여 다른 PC로 전달 후 분할된 Files을 다시 결합시켜 해당 Docker Image를 Load 하는 방법입니다.

먼저, 다음의 예시와 같이 용량이 큰 Docker Image를 Pull 합니다.

docker pull pytorch/pytorch:2.2.2-cuda12.1-cudnn8-devel

Docker Image를 호스트 시스템에 저장하는 코드는 다음과 같습니다.

docker save pytorch/pytorch:2.2.2-cuda12.1-cudnn8-devel > pytorch_save.tar

위의 코드는 "pytorch/pytorch:2.2.2-cuda12.1-cudnn8-devel" Docker 이미지를 pytorch_save.tar 파일로 저장합니다.

이어서, 해당 파일을 XZ 형식으로 압축하는 코드입니다.

xz -z -v -T 0 pytorch_save.tar

해당 명령어의 결과로 pytorch_save.tar.xz 파일이 생성되게 됩니다.

다음은 위의 결과로 생성된 pytorch_save.tar.xz 파일을 여러 개의 작은 파일로 분할하는 코드입니다.

split -b 1G -d pytorch_save.tar.xz pytorch_save_part_

위의 코드는 pytorch_save.tar.xz 파일을 1G(1 기가) 씩 여러개의 작은 파일로 분할합니다.

분할된 작은 파일들을 원래의 압축 파일로 재생성 후 XZ 압축 파일을 해제 후 Docker 이미지를 로드 하는 과정은 다음과 같습니다.

cat pytorch_save_part_* > pytorch_save.tar.xz
xz -d -v pytorch_save.tar.xz
docker load < pytorch_save.tar

지금까지, Docker 이미지를 분할 압축 및 해제 후 로드하는 과정에 대해서 알아보았습니다.

감사드립니다.

[Database, DB] psycopg2 패키지를 활용하여 PostgreSQL 사용하는 방법 (Table 생성, 삭제, Data 초기화)

Minima — Wed, 17 Apr 2024 00:19:07 +0900

안녕하세요, 오늘은 psycopg2 패키지를 활용하여, PostgreSQL (DB)를 사용하는 방법에 대해서 알아보겠습니다.

먼저, psycopg2 패키지를 설치합니다.

pip install psycopg2-binary

이어서, DB에 연결하여, Table을 생성하는 방법에 대해서 알아보겠습니다.

import psycopg2

conn = psycopg2.connect(host='localhost', database='postgres', user='postgres', password='<Enter Password>', port=5432)
cur = conn.cursor()

print(cur.closed == 0)

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
    user_id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    password VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(100),
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
"""

try:
    cur.execute(create_users_table)
    conn.commit()

except Exception as e:
    print(e)

위의 코드에서 cur.closed == 0 이면 정상적으로 DB 연결이 지속되고 있다는 의미입니다.

또한, "users" 라는 table을 생성하기 위한 sql을 작성하였으며, columns은 순서대로 user_id, username, password, email, created_at 입니다.

다음은, Table을 삭제하는 방법에 대해서 알아보겠습니다.

import psycopg2

conn = psycopg2.connect(host='localhost', database='postgres', user='postgres', password='temptemp', port=5432)
cur = conn.cursor()

print(cur.closed == 0)

def drop_table(connection, table_name):
    cursor = connection.cursor()
    try:
        cursor.execute(f"DROP TABLE IF EXISTS {table_name} CASCADE;")
        connection.commit()
        print(f"Table '{table_name}' dropped successfully")
    except Exception as e:
        print(f"An error occurred: {e}")

try:
    drop_table(conn, 'users')

except Exception as e:
    print(e)

위의 코드에서 drop_table이라는 함수는 connection 변수와 table_name을 입력으로 받아 해당 Table이 존재하는 경우 삭제하는 함수입니다.

다음은 특정 Table의 Data를 초기화하는 방법입니다.

import psycopg2

conn = psycopg2.connect(host='localhost', database='postgres', user='postgres', password='temptemp', port=5432)
cur = conn.cursor()

print(cur.closed == 0)

def reset_data(connection, table_name):
    cursor = connection.cursor()
    cursor.execute(f"TRUNCATE TABLE {table_name} RESTART IDENTITY;")
    connection.commit()
    print("Table reset and data initialized successfully")

try:
    reset_data(conn, 'users')

except Exception as e:
    print(e)

위의 코드에서 reset_data 함수는 connection 변수와 table_name을 입력으로 받아 해당 Table 내 Data를 Reset하는 함수입니다.

지금까지, psycopg2 패키지를 활용해서 PostgreSQL을 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Database, DB] PostgreSQL & DBeaver Community 설치 및 사용 방법

Minima — Mon, 15 Apr 2024 21:33:57 +0900

안녕하세요, 오늘은 PostgreSQL & DBeaver Community 설치 및 사용 방법에 대해서 알아보겠습니다.

https://www.postgresql.org/download/

PostgreSQL: Downloads

www.postgresql.org

위의 링크에서 각 OS에 맞게 다운로드 및 설치를 해주시면 됩니다.

이어서, DBeaver Community 설치 경로는 다음과 같습니다.

https://dbeaver.io/download/

Download | DBeaver Community

Download DBeaver Community 24.0.2 Released on April 8th 2024 (Milestones). It is free and open source (license). Also you can get it from the GitHub mirror. DBeaver PRO 24.0 Released on March 11th, 2024 PRO version website: dbeaver.com Trial version is ava

dbeaver.io

PostgreSQL 및 DBeaver Community 설치가 완료되었다면, DBeaver Community를 실행시켜줍니다.

DBeaver Community 실행 화면

기본적으로, 초기에는 database='postgres', user='postgres', port=5432로 설정되어 실행됩니다.

이상으로, PostSQL & DBeaver Community 설치 및 실행하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] 파이썬으로 한글 Text를 Encoding, Decoding 하는 방법

Minima — Sat, 13 Apr 2024 13:14:31 +0900

안녕하세요, 오늘은 파이썬으로 한글 Text를 Encoding 및 Decoding 하는 방법에 대해서 알아보겠습니다.

한글 Text에 대해서 Encoding을 하기 위해서는 각 문자를 초성, 중성, 종성으로 구분해서 Encoding을 진행해야합니다.

먼저, 초성, 중성, 종성이 될 수 있는 자음과 모음들에 대해서 알아보겠습니다.

def generate_hangul_jamos():
    # 초성
    choseong = [chr(code) for code in range(0x1100, 0x1113)]
    # 중성 (모음)
    jungseong = [chr(code) for code in range(0x1161, 0x1176)]
    # 중성
    jongseong = [chr(code) for code in range(0x11A8, 0x11C3)]
    return choseong + jungseong + jongseong

위의 함수는 각각 초성, 중성, 종성이 될수 있는 자음과 모음들을 계산하여 합쳐 1개의 List로 반환하는 함수입니다.

함수의 결과는 다음과 같습니다.

['ᄀ', 'ᄁ', 'ᄂ', 'ᄃ', 'ᄄ', 'ᄅ', 'ᄆ', 'ᄇ', 'ᄈ', 'ᄉ', 'ᄊ', 'ᄋ', 'ᄌ', 'ᄍ', 'ᄎ', 'ᄏ', 'ᄐ', 'ᄑ', 'ᄒ', 'ᅡ', 'ᅢ', 'ᅣ', 'ᅤ', 'ᅥ', 'ᅦ', 'ᅧ', 'ᅨ', 'ᅩ', 'ᅪ', 'ᅫ', 'ᅬ', 'ᅭ', 'ᅮ', 'ᅯ', 'ᅰ', 'ᅱ', 'ᅲ', 'ᅳ', 'ᅴ', 'ᅵ', 'ᆨ', 'ᆩ', 'ᆪ', 'ᆫ', 'ᆬ', 'ᆭ', 'ᆮ', 'ᆯ', 'ᆰ', 'ᆱ', 'ᆲ', 'ᆳ', 'ᆴ', 'ᆵ', 'ᆶ', 'ᆷ', 'ᆸ', 'ᆹ', 'ᆺ', 'ᆻ', 'ᆼ', 'ᆽ', 'ᆾ', 'ᆿ', 'ᇀ', 'ᇁ', 'ᇂ']

이어서, 위의 List의 각 원소와 Index 값을 Dictionary로 반환하는 함수는 다음과 같습니다.

def generate_hangul_jamo_to_index():
    hangul_jamos = generate_hangul_jamos()
    jamo_to_index = {jamo: index for index, jamo in enumerate(hangul_jamos)}
    return jamo_to_index

해당 함수의 실행 결과는 다음과 같습니다.

{'ᄀ': 0, 'ᄁ': 1, 'ᄂ': 2, 'ᄃ': 3, 'ᄄ': 4, 'ᄅ': 5, 'ᄆ': 6, 'ᄇ': 7, 'ᄈ': 8, 'ᄉ': 9, 'ᄊ': 10, 'ᄋ': 11, 'ᄌ': 12, 'ᄍ': 13, 'ᄎ': 14, 'ᄏ': 15, 'ᄐ': 16, 'ᄑ': 17, 'ᄒ': 18, 'ᅡ': 19, 'ᅢ': 20, 'ᅣ': 21, 'ᅤ': 22, 'ᅥ': 23, 'ᅦ': 24, 'ᅧ': 25, 'ᅨ': 26, 'ᅩ': 27, 'ᅪ': 28, 'ᅫ': 29, 'ᅬ': 30, 'ᅭ': 31, 'ᅮ': 32, 'ᅯ': 33, 'ᅰ': 34, 'ᅱ': 35, 'ᅲ': 36, 'ᅳ': 37, 'ᅴ': 38, 'ᅵ': 39, 'ᆨ': 40, 'ᆩ': 41, 'ᆪ': 42, 'ᆫ': 43, 'ᆬ': 44, 'ᆭ': 45, 'ᆮ': 46, 'ᆯ': 47, 'ᆰ': 48, 'ᆱ': 49, 'ᆲ': 50, 'ᆳ': 51, 'ᆴ': 52, 'ᆵ': 53, 'ᆶ': 54, 'ᆷ': 55, 'ᆸ': 56, 'ᆹ': 57, 'ᆺ': 58, 'ᆻ': 59, 'ᆼ': 60, 'ᆽ': 61, 'ᆾ': 62, 'ᆿ': 63, 'ᇀ': 64, 'ᇁ': 65, 'ᇂ': 66}

최종적으로 전달받은 Text를 Encoding해서 정수 값으로 구성된 리스트로 반환하는 코드는 다음과 같습니다.

import unicodedata
jamo_to_index = generate_hangul_jamo_to_index()

def encode_text_to_jamo_indices(text, jamo_to_index):
    decomposed_text = unicodedata.normalize('NFD', text)
    return [jamo_to_index.get(jamo, -1) for jamo in decomposed_text if jamo in jamo_to_index]

sample_text = "안녕하세요 내 이름은 홍길동입니다"
encoded_indices = encode_text_to_jamo_indices(sample_text, jamo_to_index)

print("Encoded Indices:", encoded_indices)

출력결과는 다음과 같습니다.

Encoded Indices: [11, 19, 43, 2, 25, 60, 18, 19, 9, 24, 11, 31, 2, 20, 11, 39, 5, 37, 55, 11, 37, 43, 18, 27, 60, 0, 39, 47, 3, 27, 60, 11, 39, 56, 2, 39, 3, 19]

위의 Encoding 결과를 다시 Decoding 하기 위한 코드는 다음과 같습니다.

def decode_jamo(indices, jamo_to_index):
    idx2jamo = {idx: jamo for jamo, idx in jamo_to_index.items()}
    composed = ''.join(unicodedata.normalize('NFC', idx2jamo[idx]) for idx in indices)
    return composed

decoded_text = decode_jamo(encoded_indices, jamo_to_index)
print("Decoded Text:", decoded_text)

출력 결과는 다음과 같습니다.

Decoded Text: 안녕하세요내이름은홍길동입니다

이상으로, 파이썬으로 한글 Text를 Encoding 및 Decoding하는 방법에 대해서 알아보았습니다.

[Tensorflow] 대용량 데이터 학습 방법 (Tensorflow 2)

Minima — Sat, 13 Apr 2024 07:53:51 +0900

안녕하세요, 오늘은 Tensorflow 2에서 대용량 데이터를 학습하는 방법에 대해서 알아보겠습니다.

먼저, MNIST 데이터 셋(28, 28)을 Resize(512, 512) 해서 정해진 경로에 저장하는 코드는 다음과 같습니다.

import tensorflow as tf
from PIL import Image
import os
import cv2

# MNIST 데이터셋 로드
mnist = tf.keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 디렉토리 생성
os.makedirs('/mnist_png', exist_ok=True)

# (28, 28) => (512, 512) Resize 후 이미지 저장
def save_image(image, label, index):
    os.makedirs(f'/mnist_png/{label}', exist_ok=True)
    image_path = f'/mnist_png/{label}/{index}.{format}'
    image = cv2.resize(image, (512, 512))
    cv2.imwrite(image_path, image)

for i in range(len(train_images)): 
    image, label = train_images[i], train_labels[i]
    save_image(image, label, i)

위의 코드를 통해 mnist_png 디렉토리 내 (512, 512) 이미지들이 저장된 것을 확인할 수 있습니다.

해당 대용량 데이터를 학습하기 위한 코드는 다음과 같습니다.

import tensorflow as tf
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split
import os
import glob
import numpy as np

def read_image(mnist_dir=None):
  mnist_img_list = glob.glob('./mnist_png/**/*.png', recursive=True)
  mnist_img_array = np.array(mnist_img_list)
  label_array = np.array([os.path.dirname(os.path.basename(img_path)) for img_path in mnist_img_list])

  np.random.seed(200)
  np.random.shuffle(mnist_img_array)
  np.random.seed(200)
  np.random.shuffle(label_array)

  return mnist_img_array, to_categorical(label_array, 10)

def fn(mnist_img_path, label):

  tmp = tf.io.read_file(mnist_img_path)
  decode_img = tf.image.decode_png(tmp, channels=1)
  decode_img = tf.cast(decode_img, tf.float32)

  return decode_img, tf.cast(label, tf.float32)


x_dataset, y_dataset = read_image()

X_train, X_test, y_train, y_test = train_test_split(x_dataset, y_dataset, test_size=0.2, random_state=42, stratify=y_dataset)

train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)) \ 
                .map(fn, num_parallel_calls = tf.data.experimental.AUTOTUNE) \ 
                .shuffle(buffer_size=256) \ 
                .batch(4) \ 
                .prefetch(tf.data.experimental.AUTOTUNE)

validation_dataset = tf.data.Dataset.from_tensor_slices((X_test, y_test)) \
                     .map(fn, num_parallel_calls=tf.data.experimental.AUTOTUNE) \
                     .batch(4)

model = ...

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), 
    loss="categorical_crossentropy", metrics=["acc"])

epochs = 200
model.fit(train_dataset, epochs=epochs, validation_data=validation_dataset)

위의 전체 코드에 대해서 순차적으로 설명드리겠습니다.

def read_image(mnist_dir=None):
  mnist_img_list = glob.glob('./mnist_png/**/*.png', recursive=True)
  mnist_img_array = np.array(mnist_img_list)
  label_array = np.array([os.path.dirname(os.path.basename(img_path)) for img_path in mnist_img_list])

  np.random.seed(200)
  np.random.shuffle(mnist_img_array)
  np.random.seed(200)
  np.random.shuffle(label_array)

  return mnist_img_array, to_categorical(label_array, 10)

(512, 512) 저장된 mnist_png 디렉토리 내 저장된 이미지들의 파일 경로들을 list -> np.array로 변환 및 shuffle 후 반환하는 코드입니다.

def fn(mnist_img_path, label):

  tmp = tf.io.read_file(mnist_img_path)
  decode_img = tf.image.decode_png(tmp, channels=1)
  decode_img = tf.cast(decode_img, tf.float32)

  return decode_img, tf.cast(label, tf.float32)

위의 함수는 mnist_img_path 및 label를 전달받아 Tensorflow 문자열 Tensor로 변환 후 tf.image.decode_png 함수를 통해 디코딩 과정을 거치게 됩니다. 최종적으로 tf.cast 함수를 통해 decode_img의 DType를 변환 후 반환합니다.

위의 코드에서 mnist_img_path(이미지)의 확장자가 .bmp, jpg인 경우에는 각각 다음 함수를 사용해주시면 됩니다.

tf.image.decode_bmp()
tf.image.decode_jpeg()

train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)) \ 
                .map(fn, num_parallel_calls = tf.data.experimental.AUTOTUNE) \ 
                .shuffle(buffer_size=256) \ 
                .batch(4) \ 
                .prefetch(tf.data.experimental.AUTOTUNE)

위의 코드를 구성하는 요소들은 다음과 같습니다.

map : 데이터셋의 각 요소에 주어진 fn 함수를 적용
num_parallel_calls = tf.data.experimental.AUTOTUNE : 데이터 전처리를 병렬로 수행 (자동으로 최적의 Thread 수 결정)
shuffle & buffer_size : 데이터셋을 무작위로 섞으며, 섞을 요소의 수를 정의
prefetch & tf.data.experimental.AUT : 모델 학습 동안 다음 Batch를 미리 준비하여 입출력 시간 지연을 최소화하고, 계산과 데이터 로드를 병렬로 수행

이상으로 Tensorflow 2에서 대용량 데이터 학습하는 방법에 대해서 알아보았습니다.

[Docker] Docker-Compose를 활용해서 MariaDB, Flask, Vue.js 연동하는 방법

Minima — Tue, 2 Apr 2024 21:41:39 +0900

안녕하세요, 오늘은 Docker-Compose를 활용해서 MariaDB, Flask Server, Vue.js Server를 연동하는 방법에 대해서 알아보겠습니다.

먼저, docker-compose.yml 파일에 대해서 알아보겠습니다.

version: '3.8'

services:

  flask-app:
    build: ./flask
    ports:
      - "4000:4000"
    environment:
      - DATABASE_HOST=mariadb
      - DATABASE_USER=exampleUser
      - DATABASE_PASSWORD=exampleUserPassword
    volumes:
      - ./flask:/app
    networks:
    - server_network

  vue-app:
    build: ./vue-practice
    ports:
      - "8080:8080"
    volumes:
      - ./vue-practice:/app
    environment:
      - CHOKIDAR_USEPOLLING=true
    networks:
    - server_network

  mariadb:
    image: mariadb:latest
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=exampleRootPassword
      - MYSQL_DATABASE=exampleDatabase
      - MYSQL_USER=exampleUser
      - MYSQL_PASSWORD=exampleUserPassword
    ports:
      - "3306:3306"
    volumes:
      - ./data:/var/lib/mysql
    networks:
    - server_network

networks:
  server_network:

디렉토리 구조 시각화 결과

위의 docker-compose.yml 파일에 대해 대응되는 디렉토리 구조 시각화 결과는 위의 이미지를 참고해주시면 됩니다.

이이서, docker-compose.yml 파일을 단계적으로 설명드리겠습니다.

  flask-app:
    build: ./flask
    ports:
      - "4000:4000"
    environment:
      - DATABASE_HOST=mariadb
      - DATABASE_USER=exampleUser
      - DATABASE_PASSWORD=exampleUserPassword
    volumes:
      - ./flask:/app
    networks:
    - server_network

위의 코드는 service 이름이 flask-app이며, ./flask 폴더 내의 Dockerfile를 활용해서 Build 작업을 진행합니다. 또한, Database는 mariadb (Service)를 사용하게 됩니다. 나머지는, volume과 networks에 대한 설정 등 입니다.

  vue-app:
    build: ./vue-practice
    ports:
      - "8080:8080"
    volumes:
      - ./vue-practice:/app
    environment:
      - CHOKIDAR_USEPOLLING=true
    networks:
    - server_network

위의 코드는 flask-app과 유사하지만 port 번호가 상이하며 나머지는 유사하게 적용된 것을 확인할 수 있습니다.

  mariadb:
    image: mariadb:latest
    restart: always
    environment:
      - MARIADB_ROOT_PASSWORD=exampleRootPassword
      - MARIADB_DATABASE=exampleDatabase
      - MARIADB_USER=exampleUser
      - MARIADB_PASSWORD=exampleUserPassword
    ports:
      - "3306:3306"
    volumes:
      - ./data:/var/lib/mysql
    networks:
    - server_network

networks:
  server_network:

마지막으로, mariadb (Service)에 대한 설명입니다. 해당 Service를 위해서 Docker Image는 mariadb:latest를 사용하였지만 호환성을 위해서는 구체적인 tag를 지정하는 것을 추천드립니다.

flask-app (Service)에서도 보셨듯이, Database 관련 Password, Database 등의 설정을 맞춰주셔야 합니다. 마찬가지로 나머지는 volume과 networks 관련 정보가 되겠습니다.

이상으로, Docker-Compose를 활용하여 MariaDB, Flask, Vue.js Server를 연동하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker-Compose를 활용한 WordPress 배포하는 방법

Minima — Wed, 27 Mar 2024 22:21:38 +0900

안녕하세요, 오늘은 Docker-Compose를 활용해서 WordPress를 배포하는 방법에 대해서 알아보겠습니다.

먼저 Docker-Compose를 적용하기 위한 word_press.yml 파일은 다음과 같습니다.

version: '3.1'

services:
  wordpress:
    container_name: mywordpress
    image: wordpress:latest
    ports:
      - "8000:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    restart: always
    volumes:
      - wordpress_data:/var/www/html
    networks:
      - mynetwork

  db:
    container_name: certainmysql
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    restart: always
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - mynetwork

volumes:
  wordpress_data:
  db_data:

networks:
  mynetwork:

위의 애플리케이션을 구성하기 위한 Services(Containers)는 다음과 같습니다.

wordpress
db

총 2개의 Services(Containers)로 구성되어 있습니다.

순차적으로, 첫번째 Service인 wordpress에 대해서 알아보겠습니다.

  wordpress:
    container_name: mywordpress
    image: wordpress:latest
    ports:
      - "8000:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    restart: always
    volumes:
      - wordpress_data:/var/www/html
    networks:
      - mynetwork

container_name : 사용 할 컨테이너 이름 (Unique 해야함)
image : WordPress Docker Image 중 최신 이미지를 사용
ports: 호스트의 포트(8000)을 컨테이너 내부 포트(80)에 맵핑
environment: WordPress Container에서 사용할 환경 변수 설정
restart: 컨테이너가 충돌하거나 서버가 재부팅되는 경우 컨테이너가 다시 시작하도록 설정
volumes: Volume Mount
networks: 사용자 정의 네트워크에 연결

이어서, db Service(Container)에 대해서 설명하겠습니다.

  db:
    container_name: certainmysql
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    restart: always
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - mynetwork

첫번째 container와 유사하게 container_name, image, environment, restart, volumes, networks를 위와 같이 설정하였습니다.

다음 명령어를 통해 빌드합니다.

docker-compose -f word_press.yml up -d

docker port mywordpress

0.0.0.0:8000 접속 결과

이상으로, Docker-Compose를 활용해서 WordPress를 배포하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker-Compose를 사용해서 Vue.js & Flask Server 연동하는 방법

Minima — Thu, 21 Mar 2024 23:43:30 +0900

안녕하세요, 오늘은 Docker-Compose를 사용해서 Vue.js & Flask Server를 연동하는 방법에 대해서 알아보겠습니다.

먼저, 해당 내용을 위해 디릭토리 구조 구성은 다음과 같습니다. (tree -L 2 -f)

디렉토리 구조 시각화

먼저, Flask Server에 대해서 알아보겠습니다.

./flask/app.py 파일에 대한 코드는 다음과 같습니다.

from flask import Flask, jsonify
from flask_cors import CORS

app = Flask(__name__)
cors = CORS(app, resources={r"/*": {"origin": "*"},})

@app.route('/message', methods=['POST', 'GET'])
def get_message():
    return jsonify({'test_message': 'Hello from Flask!'})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=4000)

위의 Flask Server는 Port 4000번 입니다.

위의 Flask 애플리케이션을 실행하기 위한 패키지 정보는 다음을 통해 저장할 수 있습니다.

pip list --format=freeze > requirements.txt

최종적으로 Flask Server의 Dockerfile은 다음과 같습니다.

FROM python:3.8-slim
WORKDIR /app
COPY requirements.txt /app/
RUN pip install -r requirements.txt
COPY . /app
CMD ["python", "app.py"]

이어서, Vue.js Server에 대해서 알아보겠습니다.

<template>
  <h1>{{ message }}</h1>
</template>

<script>
import axios from 'axios';
export default {
  name: 'HelloWorld',
  props: {
    msg: String
  },

  data() {
    return {
      message: '',
    };
  },

  mounted() {
    axios.get('http://localhost:4000/message')
      .then(response => {
        this.message = response.data.test_message;
      })
      .catch(error => {
        console.log(error);
      });
  }
}
</script>

Vue.js Server 내 Dockerfile은 다음과 같습니다.

FROM node:lts-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "run", "serve"]

최종적으로 Docker-Compose를 통해 빌드하는 명령어는 다음과 같습니다.

docker-compose up --build

아래 명령어는 Background에서 실행하는 명령어 입니다.

docker-compose up -d

Docker-Compose를 활용하여, Flask Server와 Vue.js Server를 연동하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python, GPU Programming] CuPy 란? (vs NumPy)

Minima — Sat, 16 Mar 2024 13:49:24 +0900

안녕하세요, 오늘은 CuPy 라이브러리에 대해서 설명하겠습니다.

CuPy는 NumPy와 호환되며, NIVIDIA CUDA GPU에서 실행되는 라이브러리입니다. 이는 NumPy API의 GPU 가속 버전을 제공하여 대규모 수학 연산을 빠르게 수행하며 높은 수준의 병렬 처리를 수행합니다.

아래는 NumPy를 사용한 CPU 버전, 그리고 CuPy를 사용한 GPU 버전에 대한 파이썬 코드입니다.

import numpy as np
import time

# 2개의 행렬 초기화
a_cpu = np.random.rand(2000, 2000).astype(np.float32)
b_cpu = np.random.rand(2000, 2000).astype(np.float32)

for _ in range(0, 10):
  # CPU에서 행렬 곱 연산 시간 측정
  start_time = time.time()
  result_cpu = np.dot(a_cpu, b_cpu)
  cpu_time = time.time() - start_time

  print(f"CPU Matrix Multiplication Time: {cpu_time} seconds")

CPU에서 측정 결과

import cupy as cp
import time

# 2개의 행렬 초기화
a_gpu = cp.random.rand(2000, 2000).astype(cp.float32)
b_gpu = cp.random.rand(2000, 2000).astype(cp.float32)

for _ in range(0, 10):
  # GPU에서 행렬의 곱 연산 시간 측정
  start_time = time.time()
  result_gpu = cp.dot(a_gpu, b_gpu)
  cp.cuda.Stream.null.synchronize()
  gpu_time = time.time() - start_time

  print(f"GPU Matrix Multiplication Time: {gpu_time} seconds")

GPU에서 측정 결과

이상으로, CuPy에 대해서 알아보고 해당 라이브러리를 사용한 간단한 예제에 대해서 알아보았습니다.

감사드립니다.

[Python, Opencv] Binary Objects을 포함하는 가장 작은 사각형 찾기

Minima — Sat, 16 Mar 2024 13:25:29 +0900

안녕하세요, 오늘은 Binary Objects을 포함하는 가장 작은 사각형을 찾는 방법에 대해서 알아보겠습니다.

알고리즘을 적용하고자 하는 이미지는 다음과 같습니다.

이미지

위의 이미지는 총 3개의 Connected Objects로 구성되어 있습니다.

이미지 내 각 Connected Object들을 포함하는 가장 작은 사각형을 구하는 코드는 다음과 같습니다.

import cv2
import matplotlib.pyplot as plt
import numpy as np

img = cv2.imread("...png")
draw_img = img.copy()

# Contours 찾기
contours, _ = cv2.findContours(img[:, :, 0], cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

for certain_contour in contours:

    rect = cv2.minAreaRect(certain_contour)
    box = cv2.boxPoints(rect)
    box = np.intp(box)

    # 사각형 그리기
    cv2.drawContours(draw_img, [box], 0, (0, 255, 0), 2)

plt.imshow(np.hstack([img, draw_img]))
plt.axis('off')
plt.show()

위의 코드를 통해 알고리즘을 적용한 결과는 다음과 같습니다.

알고리즘 적용 결과

이상으로, Binary Objects를 포함하는 가장 작은 사각형을 찾는 방법에 대해서 알아보았습니다.

감사드립니다.

[Vue.js 3 + Vuetify 3] Data table (Component) 사용법

Minima — Tue, 12 Mar 2024 01:31:40 +0900

안녕하세요, 오늘은 Vuetify 3에서 Data table (Component) 사용하는 방법에 대해서 알아보겠습니다.

https://vuetifyjs.com/en/components/data-tables

https://vuetifyjs.com/en/components/data-tables/

vuetifyjs.com

먼저, Data table (Component)에 대한 코드 예시는 다음과 같습니다.

<template>
  <v-card
    title="A High School"
    flat
  >
    <template v-slot:text>
      <v-text-field
        v-model="search"
        label="Search"
        prepend-inner-icon="mdi-magnify"
        variant="outlined"
        hide-details
        single-line
      ></v-text-field>
    </template>

    <v-data-table
      :headers="headers"
      :items="students"
      :search="search"
    ></v-data-table>
  </v-card>
</template>

<script>
  export default {
    name : 'App',
    components:{
    },
    data () {
      return {
        search: '',
        headers: [
          { align: 'center', key: 'index', sortable: false, title: 'Index' },
          { align: 'center', key: 'name', title: 'Name' },
          { align: 'center', key: 'id', title: 'Student ID'},
          { align: 'center', key: 'grade', title: 'Grade' },
        ],

        students: [
          {
            index: '1',
            name: 'Name-1',
            id: '2024-1',
            grade: 'A+'
          },

          {
            index: '2',
            name: 'Name-2',
            id: '2023-1',
            grade: 'B-'
          },

          {
            index: '3',
            name: 'Name-3',
            id: '2021-1',
            grade: 'A-'
          },

          {
            index: '4',
            name: 'Name-4',
            id: '2024-2',
            grade: 'B+'
          },

          {
            index: '5',
            name: 'Name-5',
            id: '2024-3',
            grade: 'A+'
          },
        ],
      }
    },
  }
</script>

위의 코드 실행 결과는 다음과 같습니다.

실행 결과

위의 코드에서 header를 구성하는 titles는 다음과 같습니다.

Index
Name
Student ID
Grade

그리고, 해당 Table의 Items를 구성하는 변수는 students 입니다.

변수 students는 List 이며, 각 원소는 Dictionary로 구성되어 해당 원소는 Titles에 대한 Key-Value 쌍으로 구성됩니다.

이상으로, Vuetify 3에서 Data table (Component)에 대해서 알아보았습니다.

감사드립니다.

[Vue.js 3 + Vuetify 3] File inputs (Component) 사용법

Minima — Tue, 12 Mar 2024 00:01:08 +0900

안녕하세요, 오늘은 Vuetify 3에서 File inputs (Component)을 사용하는 방법에 대해서 알아보겠습니다.

https://vuetifyjs.com/

Vuetify — A Vue Component Framework

Vuetify is a no design skills required Open Source UI Component Framework for Vue. It provides you with all of the t...

vuetifyjs.com

File inputs (Component)를 다양한 예시들을 활용한 결과는 다음과 같습니다.

<template>
  <v-file-input label="File input"></v-file-input>
  <v-file-input label="File input" variant="outlined"></v-file-input>
  <v-file-input label="File input" variant="underlined"></v-file-input>
  <v-file-input label="File input" variant="solo"></v-file-input>
  <v-file-input label="File input" variant="solo-filled"></v-file-input>
  <v-file-input label="File input" variant="solo-inverted"></v-file-input>
  <v-file-input accept="image/*" label="File input"></v-file-input>
  <v-file-input label="File input w/ chips" chips multiple></v-file-input>
  <v-file-input label="File input" counter multiple show-size></v-file-input>
  <v-file-input density="compact" label="File input"></v-file-input>
</template>

실행 결과

위의 코드에서 variant 값의 따라서 디자인이 위의 예시 처럼 변화하는 것을 확인할 수 있으며, accept 옵션은 특정 파일 format이나 타입을 지정할 수 있습니다. 그리고, counter 옵션은 업로드 한 파일들의 수를, multiple 옵션은 다수의 파일 선택할 수 있게, 그리고 show-size는 해당 파일들의 size를 확인할 수 있습니다.

이어서, 조금 더 복잡한 Case에 대해서 알아보겠습니다.

<template>
  <v-file-input
    v-model="files"
    :show-size="1000"
    color="deep-purple-accent-4"
    label="File input"
    placeholder="Select your files"
    prepend-icon="mdi-paperclip"
    variant="outlined"
    counter
    multiple
  >
    <template v-slot:selection="{ fileNames }">
      <template v-for="(fileName, index) in fileNames" :key="fileName">
        <v-chip
          v-if="index < 2"
          class="me-2"
          color="deep-purple-accent-4"
          size="small"
          label
        >
          {{ fileName }}
        </v-chip>

        <span
          v-else-if="index === 2"
          class="text-overline text-grey-darken-3 mx-2"
        >
          +{{ files.length - 2 }} File(s)
        </span>
      </template>
    </template>
  </v-file-input>
</template>

<script>
export default {
  name: 'App',
  components: {
  },
  data () {
    return {
      files: [],
    }
  },

}
</script>

위의 코드에 대한 실행 결과는 다음과 같습니다. 첨부 파일들 중 처음 2개의 파일을 시각화 하며, 3개 이상이여서 2개를 초과하는 파일 개수에 대해서는 요약하여 우측에 표시하게 됩니다.

실행 결과

이상으로, Vuetify 3에서 File inputs (Component)를 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Vue.js 3 + Vuetify 3] Vuetify 3 설치 및 적용하는 방법

Minima — Mon, 11 Mar 2024 20:47:53 +0900

안녕하세요, 오늘은 Vuetify 3을 설치하고 적용하는 방법에 대해서 알아보겠습니다.

먼저, Vue.js 3에 대한 프로젝트를 생성한 상태라고 가정하겠습니다.

이어서, 아래 명령어를 통해 vuetify를 설치합니다.

npm install vuetify@next

npm i -D vuetify vite-plugin-vuetify
npm i @mdi/font

위의 명령어 실행 후 다음과 같은 경로에 파일을 추가해줍니다. (vuetify.js)

src/plugins/vuetify.js

// src/plugins/vuetify.js
import '@mdi/font/css/materialdesignicons.css'
import 'vuetify/styles'
import { createVuetify } from 'vuetify'
import * as components from 'vuetify/components'
import * as directives from 'vuetify/directives'

export default createVuetify({
  components,
  directives,
})

이어서, main.js 파일을 다음과 같이 수정합니다.

src/main.js

// src/main.js
import { createApp } from 'vue'
import App from './App.vue'
import vuetify from './plugins/vuetify'

const app = createApp(App)

app.use(vuetify)

app.mount('#app')

위와 같이 수정하면, 모든 준비는 완료하였습니다. App.vue 파일에 간단한 Vuetify 3 버튼을 추가해보겠습니다.

src/App.vue

<template>
  <v-app>
    <v-btn color="primary">Click Me</v-btn>
  </v-app>
</template>

<script>

export default {
  name: 'App',
  components: {
  }
}
</script>

<style>
#app {
  font-family: Avenir, Helvetica, Arial, sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  text-align: center;
  color: #2c3e50;
  margin-top: 60px;
}
</style>

위의 실행 결과는 다음과 같습니다.

실행 결과

이상으로, Vuetify 3을 설치하고 적용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] Flask 애플리케이션을 Kubernetes 클러스터 배포하는 방법

Minima — Sun, 3 Mar 2024 01:46:06 +0900

안녕하세요, 오늘은 Flask 애플리케이션을 Kubernetes 클로스터에 배포하는 방법에 대해서 알아보겠습니다.

다음과 같은 과정으로 이루어집니다.

Flask 애플리케이션 준비
Dockerfile 작성
Docker 이미지 빌드 및 푸시
쿠버네티스 Deployment 정의
쿠버네티스 Service 정의
Deployment 및 Service 적용
애플리케이션 접근 확인

먼저, Flask 애플리케이션을 준비하는 단계입니다. (app.py)

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Kubernetes!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=8080)

이어서, Dockerfile을 작성합니다.

# 기본 이미지로 파이썬 3.8을 사용
FROM python:3.8-slim

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

# 애플리케이션 파일 복사
COPY . /app

# 필요한 패키지 설치
RUN pip install --no-cache-dir flask

# 애플리케이션 실행
CMD ["python", "app.py"]

다음은 Docker 이미지를 빌드합니다.

docker build -t my-flask-app:v1 .

쿠버네티스 Deployment를 정의하는 YAML 파일을 작성합니다. (flask-deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: flask-app
  template:
    metadata:
      labels:
        app: flask-app
    spec:
      containers:
      - name: flask-app
        image: my-flask-app:v1
        ports:
        - containerPort: 8080

이어서, Flask 애플리케이션을 외부에서 접근하기 위해 Service를 정의하는 YAML 파일을 작성합니다. (flask-servie.yaml)

apiVersion: v1
kind: Service
metadata:
  name: flask-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: flask-app

마지막으로, kubectl apply 명령어를 사용하여 Deployment와 Service를 쿠버네티스 클러스터에 적용합니다.

kubectl apply -f flask-deployment.yaml
kubectl apply -f flask-service.yaml

그리고, kubectl get services 명령어를 사용하여 외부 IP 또는 URL을 확인할 수 있습니다.

위의 명령어를 통해 출력되는 EXTERNAL-IP가 외부에서 서비스에 접근할 수 있는 IP 주소입니다.

웹 브라우저에서 "http://EXTERNAL-IP"로 입력하면 쿠버네티스 클러스터에서 실행 중인 Flask 애플리케이션의 홈페이지에 접속할 수 있습니다.

지금까지, Flask 애플리케이션을 Kubernetes 클러스터 배포하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] kubectl 개념 및 사용 방법 (create, apply, get, edit, scale 등)

Minima — Sat, 2 Mar 2024 23:50:55 +0900

안녕하세요, 오늘은 kubectl를 사용하는 방법에 대해서 알아보겠습니다.

kubectl는 쿠버네티스에서 클러스터를 관리하기 위한 커맨드 라인 도구이며, kubectl 명령어를 사용하여 클러스터의 리소스를 생성, 조회, 수정, 삭제할 수 있습니다.

리소스 생성 및 적용
리소스 조회
리소스 수정
리소스 삭제
로그 조회 및 디버깅

먼저, 리소스 생성 및 적용하는 방법에 대해서 알아보겠습니다.

kubectl create namespace my-namespace

위의 명령어 처럼 kubectl create 명령어를 사용하여 새로운 리소스를 생성할 수 있습니다. 이어서, YAML 파일을 통해 리소스를 적용하는 명령어는 다음과 같습니다.

kubectl apply -f my-resource.yaml

이어서, 리소스 조회하는 방법입니다.

모든 Pod를 보기 위한 명령어는 다음과 같습니다.

kubectl get pods

Namespace를 지정하여 조회하는 명령어 입니다.

kubectl get pods --namespace=my-namespace

kubectl describe 명령어를 사용하여 리소스의 상세 정보를 조회할 수 있습니다.

kubectl describe pod my-pod-name

리소스 수정하는 방법입니다.

kubectl edit 명령어를 사용하여 리소스를 직접 편집할 수 있으며, YAML 정의를 텍스트 에디터에서 열어 수정할 수 있게 합니다.

kubectl edit deployment my-deployment

kubectl scale 명령어를 사용하여 Deployment, Replica Set 등의 리소스를 스케일링 할 수 있습니다.

kubectl scale deployment my-deployment --replicas=5

리소스 삭제하는 방법입니다.

kubectl delete 명령어를 사용하여 리소스를 삭제할 수 있습니다.

kubectl delete pod my-pod-name

다음은 파일을 사용하여 리소스를 삭제하는 명령어입니다.

kubectl delete -f my-resource.yaml

로그 조회 및 디버깅하는 방법입니다.

kubectl logs 명령어를 사용하여 Pod의 로그를 조회할 수 있습니다.

kubectl logs my-pod-name

kubectl exec 명령어를 사용하여 실행 중인 Pod 내부에 명령을 실행할 수 있습니다.

kubectl exec -it my-pod-name -- /bin/bash

이상으로, kubectl 개념과 이를 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] YAML 파일 작성하는 방법 (Pod, Deployment, Service, ConfigMap, Secret, PVC)

Minima — Sat, 2 Mar 2024 23:26:34 +0900

안녕하세요, 오늘은 쿠버네티스에서 YAML 파일 작성하는 방법에 대해서 알아보겠습니다.

YAML 파일은 리소스의 정의, 구성, 관리를 위해 사용되며, Pod, Deployment, Service 등의 리소스를 생성하고 관리하기 위해 작성 가능합니다.

리소스들의 종류는 다음과 같습니다.

Pod
Deployment
Service
ConfigMap
Secret
PersistentVolumeClasim (PVC)

먼저, Pod에 대해서 설명하겠습니다.

Pod는 하나 이상의 컨테이너를 실행하는 가장 기본적인 배포 단위로써, 컨테이너의 집합이며 네트워크와 Storage 리소스를 공유합니다.

다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
  labels:
    app: myapp
spec:
  containers:
    - name: container-name
      image: container-image
      ports:
        - containerPort: 8080

apiVersion : 쿠버네티스 API 버전, Pod의 경우 v1
kind : 리소스 유형
metadata : 리소스의 이름, 레이블 등 메타데이터를 정의
spec : Pod가 실행해야할 컨테이너 및 설정 명시

Deployment는 Pod의 선언적 업데이트와 자동 롤아웃을 관리하며, 애플리케이션의 상태를 관리하고 복제본 수를 조절하여 가용성을 보장합니다. 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: container-name
        image: container-image
        ports:
        - containerPort: 8080

apiVersion : Deployment의 경우 apps/v1
replicas : 실행할 Pod의 복제본 수
selector : Deployment가 관리할 Pod를 선택하는데 사용되는 레이블 셀렉터
template : 생성될 Pod의 Template

Service는 Pod 집합에 대한 안정적인 접근 포인트를 제공하며, Service를 사용하면 Pod를 직접 노출하지 않고도 외부 또는 내부에서 Pod에 접근할 수 있습니다. 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: Service
metadata:
  name: example-service
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

selector : Service가 포워딩할 트래픽을 받는 Pod를 결정
ports : Service가 수신하는 포트와 Pod로 포워딩하는 targetPort를 정의
type : Sercice 타입 지정함. LoadBalancer는 클라우드 제공자의 로드 밸런서를 사용하여 Pod를 인터넷에 노출

ConfigMap은 구성 데이터를 Key-Value 쌍으로 저장하여 애플리케이션에 전달하는 데 사용됩니다. 애플리케이션 설정, 호스트 이름, 데이터베이스 URL 등을 Pod에 전달할 수 있습니다. 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: ConfigMap
metadata:
  name: example-configmap
data:
  key1: value1
  key2: value2

data : 구성 데이터를 Key-Value 쌍으로 저장

Secret은 비밀번호, OAuth 토큰, ssh 키와 같은 민감한 정보를 저장하는데 사용되며, Secret은 ConfigMap과 유사하지만 민간하 정보를 보호하기 위해 사용됩니다. 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: Secret
metadata:
  name: example-secret
type: Opaque
data:
  password: cGFzc3dvcmQ=

data : 민감한 정보를 base64 인코딩된 형태로 저장

PVC는 Storage 리소스를 동적으로 요청하는 방법을 제공하며, PVC를 사용하면 애플리케이션이 필요로 하는 Storage를 추상화하여 사용할 수 있습니다. 다음과 같이 YAML 파일을 작성할 수 있습니다.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: example-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

accessModes : PVC가 Storage에 접근하는 방식입니다. 예를 들어, ReadWriteOnce는 볼륨을 단일 노드에서 읽기/쓰기 모드로 마운트할 수 있음을 의미
resources : 요청된 Storage 양을 의미

이상으로, 쿠버네티스에서 YAML 파일을 작성하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Kubernetes] Container와 POD 개념 설명 및 사용 방법

Minima — Sat, 2 Mar 2024 21:16:22 +0900

안녕하세요, 오늘은 쿠버네티스에서 Container와 Pod의 개념에 대해서 알아보겠습니다.

먼저 Container (컨테이너)에 대해서 알아보겠습니다.

컨테이너는 애플리케이션 실행에 필요한 코드와 모든 종속성을 포함하는 독립적인 실행 환경입니다. 컨터이너화된 애플리케이션은 다양한 컴퓨터 환경에서 일관된 방식으로 실행될 수 있습니다. 이는 다음과 같은 장점을 가지고 있습니다.

환경 일관성 : 개발, 테스트, Production 환경 간에 일관성을 제공합니다.
효율성 : 더 적은 시스템 리소를 사용하면서 격리된 환경을 제공합니다.
이식성 : 어떤 환경에서든 동일하게 실해될 수 있어, 클라우드 환경과 온프레미스 환경 간 이동이 용이합니다.
빠른 배포 및 시작 시간 : 애플리케이션과 서비스를 빠르게 시작하고, 확장 가능합니다.

이어서, Pod (포드)에 대해서 알아보겠습니다.

Pod는 쿠버네티스의 기본적인 배포 단위로, 하나 이상의 컨테이너를 포함할 수 있습니다. Pod 내의 컨테이너는 스토리지, 네트워크를 공유하고, 동일한 노드에서 스케줄링되어 실행됩니다. 이는 다음과 같은 특정을 포함하고 있습니다.

공유된 네트워크와 Storage : Pod 내의 컨테이너는 같은 IP 주소와 포트 공간을 공유하고, 서로를 localhost를 통해 찾을 수 있습니다. 또한, 볼륨을 공유하여 데이터를 교환할 수 있습니다.
생명주기 관리 : Pod는 컨테이너의 집합으로, 포드가 시작되거나 종료될때 Pod 내의 모든 컨테이너도 함께 시작되고 종료됩니다.
높은 결합도 작업의 쉬운 관리 : 밀접하게 관련된 컨테이너를 함께 포드에 배치함으로써 관리를 용이하게 합니다.

다음은, Pod를 활용해서 단일 컨테이너를 실행하는 코드 예시 입니다. 이는 nginx를 사용해서 웹서버를 실행하는 컨테이너를 포드 안에 배치하는 YAML 파일 예시입니다.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx-container
    image: nginx:latest
    ports:
    - containerPort: 80

위의 YAML 파일을 구성하는 요소들에 대한 설명은 다음과 같습니다.

apiVersion : 쿠버네티스 API 버전 (보통 v1을 사용)
kind : 생성하려는 쿠버네티스 리소스 종류
metadata : 리소스에 대한 메타데이터
spec : Pod에 대한 명세입니다.

위의 YAML 파일 (nginx-pod.yaml)을 쿠버네티스 클러스터에 적용하기 위해서는 다음과 같은 명령어를 실행합니다.

kubectl apply -f nginx-pod.yaml

쿠버네티스 클러스터에서 포드 상태를 확인하기 위해서는 다음 명령어를 사용 가능합니다.

kubectl get pods

쿠버네티스에서 포드를 삭제하는 명령은 다음과 같습니다.

kubectl delete pod nginx-pod

위의 명령어와 같이 특정 Pod의 이름을 사용하여 삭제할 수도 있지만, 다음과 같이 특정 레이블(selector)에 일치하는 모든 포드를 삭제하는 방법은 다음과 같습니다.

kubectl delete pods -l app=nginx

위의 명령어는 app=nginx 레이블을 가진 모든 Pod를 삭제하는 명령어 입니다.

이상으로 Container와 Pod의 개념에 대해서 알아보고 사용하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] NVIDIA Container Toolkit 설치하는 방법

Minima — Tue, 27 Feb 2024 22:43:05 +0900

안녕하세요, 오늘은 NVIDIA Container Toolkit을 설치하는 방법에 대해서 알아보겠습니다.

NVIDIA Container Toolkit를 설치하는 목적은 Docker 컨테이너 내에서 NVIDIA GPU를 효율적으로 활용할 수 있게 하여 GPU 가속화 애플리케이션의 배포와 실행을 용이하기 하기 위해 사용합니다.

NVIDIA Docker를 설치 하기 위해 호스트 시스템에 설치되어 있어야 하는 항목들은 다음과 같습니다.

NVIDIA GPU Driver 설치
Docker Engine 설치

위의 항목들 중 NVIDIA GPU Driver와 Docker Container Toolkit이 설치되어 있는 상황에서 NVIDIA Container Toolkit을 설치하는 방법에 대해서 알아보겠습니다.

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update
sudo apt-get install -y nvidia-docker2

위의 명령어를 실행 후 다음과 같이 Docker 데몬 설정을 업데이트 합니다. (/etc/docker/daemon.json)

{
    "runtimes": {
        "nvidia": {
            "path": "nvidia-container-runtime",
            "runtimeArgs": []
        }
    },
    "default-runtime": "nvidia"
}

마지막으로 Docker 서비스를 재시작 합니다.

sudo systemctl restart docker

정상적으로, Docker Container Toolkit이 설치되었는 지 다음과 같은 명령어로 확인할 수 있습니다.

docker run --rm nvidia/cuda:11.0-base nvidia-smi

위에서 호스트 시스템의 NVIDIA Driver 버전에 따라서 CUDA 버전을 다르게 확인할 수 있습니다.

또한 Docker 데몬 설정을 업데이트하는 이유는 "nvidia-container-runtime"을 Docker 기본 런타임으로 설정하므로써, 모든 Container가 자동적으로 NVIDIA GPU에 접근할 수 있게 됩니다. 이는 GPU를 사용하는 애플리케이션을 배포할 때 추가 구성 없이 GPU 가속을 할 수 있게 됩니다.

이상으로, NVIDIA Container Toolkit 설치하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] 쉘 스크립트 (배치) 파일 내부에서 쉘 스크립트 (배치) 파일 실행하는 방법

Minima — Tue, 27 Feb 2024 22:13:59 +0900

안녕하세요, 오늘은 쉘 스크립트 파일 & 배치 파일에서 각각 쉘 스크립트 파일들과 배치 파일들을 실행하는 방법에 대해서 알아보겠습니다.

먼저, 쉘 스크립트 파일에서 쉘 스크립트 파일들을 실행하는 예제입니다. (순차 실행)

./script1.sh
./script2.sh

위의 코드는 2개의 쉘 스크립트 파일들을 순차적으로 실행하는 쉘 스크립트 파일입니다.

다음은 병렬 실행하는 코드입니다.

./script1.sh &
./script2.sh &
wait

순차 실행하는 쉘 스크립트 파일과 다르게 각 쉘 스크립트 파일 실행 시 맨 끝에 "&"가 붙게 되며 2개의 쉘 스크립트 파일이 실행이 끝날때 까지 기다리기 위해 "wait" 명령어를 사용하게 됩니다.

이어서, 배치 파일(.bat)의 경우에 순차 실행 및 병렬 실행하는 코드에 대해서 알아보겠습니다.

@echo off
call batch1.bat
call batch2.bat

@echo off
start batch1.bat
start batch2.bat

위의 코드들은 순서대로 각각 순차 실행 및 병렬 실행하는 .bat 파일들입니다.

이상으로, 쉘 스크립트 파일 및 배치 파일 내부에서 각각 쉘 스크립트 파일들과 배치 파일들을 실행하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] 쉘 스크립트 파일(.sh) & 배치 파일(.bat) 작성 및 실행하는 방법

Minima — Tue, 27 Feb 2024 21:51:51 +0900

안녕하세요, 오늘은 쉘 스크립트 & 배치 파일을 작성하고 실행하는 방법에 대해서 알아보겠습니다.

먼저, 쉘 스크립트 파일을 생성합니다.

touch run_script.sh

작성한 쉘 스크립트 파일에 실행 권한을 부여합니다.

chmod +x run_script.sh

최종적으로 다음 명령어를 통해 쉘 스크립트 파일을 실행할 수 있습니다.

./run_script.sh

위의 쉘 스크립트 파일을 다음과 같이 구성합니다. (run_script.sh)

아래 코드는 각 script 파일을 순차적으로 실행하는 쉘 스크립트 구성입니다.

python script_1.py arg_1-1 arg_1-2
python script_2.py arg_2-1 arg_2-2 arg_2-3
python script_3.py arg_3-1 arg_3-2 arg_3-3 arg_3-4

각 script.py 파일은 다음과 같이 동일하게 구성하였습니다.

import sys

# 명령줄 인자 출력
print("인자:", sys.argv[1:])

위의 쉘 스크립트 파일을 활용하여 실행한 결과는 다음과 같습니다.

쉘 스크립트 파일 실행 결과 (순차 실행)

다음 쉘 스크립트 파일은 각 script 파일을 병렬적으로 실행하도록 구성한 코드 입니다.

python script_1.py arg_1-1 arg_1-2 &
python script_2.py arg_2-1 arg_2-2 arg_2-3 &
python script_3.py arg_3-1 arg_3-2 arg_3-3 arg_3-4 &
wait

위의 코드에서 각 명령어 끝에 "&"를 붙이게 되면 병렬적으로 실행하게 되고 "wait" 을 붙이게 되면 모든 작업이 완료될때 까지 기다리게 됩니다.

위의 쉘 스크립트 파일을 활용하여 실행한 결과는 다음과 같습니다.

쉘 스크립트 파일 실행 결과 (병렬 실행)

이어서, 배치 파일 (.bat)에서 순차 실행 및 병렬 실행하는 방법에 대해서 알아보겠습니다.

@echo off
python script_1.py arg_1-1 arg_1-2
python script_2.py arg_2-1 arg_2-2 arg_2-3
python script_3.py arg_3-1 arg_3-2 arg_3-3 arg_3-4

@echo off
start python script_1.py arg_1-1 arg_1-2
start python script_2.py arg_2-1 arg_2-2 arg_2-3
start python script_3.py arg_3-1 arg_3-2 arg_3-3 arg_3-4

병렬 실행하기 위해서 .sh에서 "&"을 사용하는 것과 달리 "start"를 사용합니다.

이상으로, 쉘 스크립트 파일 및 배치 파일을 작성하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker Image 저장 및 로드 하는 방법

Minima — Mon, 26 Feb 2024 23:32:22 +0900

안녕하세요, 오늘은 Docker Image를 로컬에 저장하고 저장된 Docker Image에 대해 로드 하는 방법에 대해서 알아보겠습니다.

먼저, Docker Image를 로컬에 저장하기 위해 현재 보유하고 있는 Docker Image 목록을 확인합니다.

docker images

docker images 결과

docker 이미지를 저장하기 위해서 다음 같은 명령어를 사용할 수 있습니다.

docker save -o <파일명>.tar <이미지 이름>

docker save -o vuedocker_save.tar vuedocker:latest

위의 명령어를 통해 "vuedocker:latest" Docker Imagerk vuedocker_save.tar 파일의 형태로 저장되게 됩니다.

이어서, 로컬에 저장된 docker 이미지를 불러오기 위해서 다음 같은 명령어를 사용할 수 있습니다.

docker load -i <파일명>.tar

docker load -i vuedocker_save.tar

이상으로, Docker Image를 로컬에 저장하고 불러오는 방법에 대해 알아보았습니다.

감사드립니다.

[Docker] Dockerfile를 사용해서 Vue.js 프로젝트를 실행하는 방법

Minima — Mon, 26 Feb 2024 23:08:25 +0900

안녕하세요, 오늘을 Dockerfile를 사용해서 Vue.js 프로젝트를 실행하는 방법에 대해서 알아보겠습니다.

먼저, Vue.js 프로젝트를 생성합니다.

vue create vuedocker --no-git

이어서, 해당 디렉토리로 이동 후 다음과 같은 코드를 사용해서 Dockerfile을 생성합니다.

cd vuedocker
touch Dockerfile

위의 코드를 통해 생성된 Dockerfile을 다음과 같은 코드로 작성합니다.

# Docker 이미지를 구성하기 위해 베이스 이미지로 Node.js의 최신 버전을 사용
FROM node:latest

# 컨테이너 내부에서 /app 디렉토리를 작업 디렉토리로 설정
WORKDIR /app

# package.json 및 package-lock.json(있는 경우) 파일을 현재 디렉토리(작업 디렉토리 /app)로 복사 및 설치
COPY package*.json ./
RUN npm install

# Dockerfile이 위치한 디렉토리의 모든 파일과 디렉토리를 컨테이너의 작업 디렉토리(/app)로 복사
COPY . .

# 프로젝트를 빌드하기 위해 package.json에 정의된 build 스크립트를 실행
RUN npm run build

# http 서버를 전역으로 설치 후 빌드된 정적 파일을 호스팅
RUN npm install -g http-server

# 컨테이너의 8080 포트를 노출
EXPOSE 8080

CMD [ "http-server", "dist" ]

docker build -t "docker_image_name_by_user" .

docker image 이름을 유저가 직접 설정할 수 있습니다.

docker run -d -p 8080:8080 --name "container_name_by_user" "docker_image_name_by_user"

마찬가지로, conatiner 이름도 유저가 직접 설정 가능합니다.

실행 결과는 다음과 같습니다.

Docker Image에 실행 결과

지금까지, Dockerfile을 사용해서 Vue.js 프로젝트를 생성하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Web Programming] Modal Dialog 커스터마이징 하는 방법

Minima — Fri, 23 Feb 2024 23:27:18 +0900

안녕하세요, 오늘은 Modal Dialog 기능들에 대해서 커스터마이징 하는 방법에 대해서 알아보겠습니다.

해당 기능을 구현하기 위해 편의상 html, css, js 파일에 대해 다음과 같이 구성하였습니다.

index.html
style.css
script.js

위 파일들로 구성된 결과 이미지에 대해서 먼저 보도록 하겠습니다.

Modal Dialog 실행 결과

먼저 index.html 코드는 다음과 같습니다.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Custom Modal Example</title>
<link rel="stylesheet" href="style.css">
</head>
<body>


<button id="openModalCenterBtn">모달 실행</button>

<div id="myModal" class="modal">
  <div class="modal-content">
    <span class="close">&times;</span>
    <p>사용자 정의 메시지를 입력하세요...</p>
    <button id="okBtn" style="width: 50px;">확인</button>
    <button id="cancelBtn" style="width: 50px;">취소</button>
  </div>
</div>

<script src="script.js"></script>
</body>
</html>

위의 코드에서 button은 총 3개로 구성되어 있으며, 다음과 같습니다.

모달 실행
확인
취소

이어서, style.css 코드는 다음과 같습니다.

/* 모달 스타일 */
.modal {
    display: none; /* 기본적으로 숨김 */
    position: fixed; /* 화면에 고정, 필요시 absolute로 변경 */
    left: 50%;
    top: 50%;
    transform: translate(-50%, -50%); /* 중앙 정렬 */
    width: 400px; /* 너비 */
    height: 200px; /* 높이 */
    background-color: #fefefe;
    padding: 20px;
    border: 1px solid #888;
    z-index: 1; /* 다른 요소 위에 표시 */
  }
  
  /* 닫기 버튼 스타일 */
  .close {
    color: #aaa;
    float: right;
    font-size: 28px;
    font-weight: bold;
  }
  
  .close:hover,
  .close:focus {
    color: black;
    text-decoration: none;
    cursor: pointer;
  }

마지막으로, script.js 코드입니다.

document.addEventListener("DOMContentLoaded", function() {
    var modal = document.getElementById("myModal");
    var btnCenter = document.getElementById("openModalCenterBtn");
    var btnOkay = document.getElementById("okBtn");
    var btnCancel = document.getElementById("cancelBtn");
    var span = document.getElementsByClassName("close")[0];
  
    btnCenter.onclick = function() {
      modal.style.display = "block";
      modal.style.position = "fixed";
      modal.style.left = "50%";
      modal.style.top = "50%";
      modal.style.transform = "translate(-50%, -50%)";
    }
  
    span.onclick = function() {
      modal.style.display = "none";
    }

    btnOkay.onclick = function() {
        modal.style.display = "none";
    }

    btnCancel.onclick = function() {
        modal.style.display = "none";
    }
  
  });

모달 실행 시 화면 중앙에서 실행되도록 하였으며, 최초에 .modal을 "none" 상태 였다가 모달 실행 버튼 클릭 시 "block" 상태로 바뀌면서 Modal Dialog가 실행되게 됩니다. 추가적으로, 확인 및 취소 버튼 클릭에 따라 "none" 상태로 변화하도록 하였습니다. 필요에 따라, btnOkay.onclick과 btnCancel.onclick 부분을 추가 Customize 할 수 있습니다.

이상으로, Modal Dialog 기능에 대해서 커스터마이징 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Web Programming] Vue.js 사용하여 그림판 기능 구현

Minima — Sat, 17 Feb 2024 13:03:23 +0900

안녕하세요, 오늘은 Vue.js 프레임 워크를 사용해서 간단판 그림판 기능을 구현하는 방법에 대해서 알아보겠습니다.

간단한 그림판 기능을 구현하기 위한 항목들은 다음과 같습니다.

Canvas 그리기
모두 지우기
Pen 두께 증가
Pen 두께 감소

Vue.js 프레임워크를 활용하기 위해 프로젝트를 생성해줍니다.

생성된 프로젝트 내 src/App.vue 파일을 다음과 같이 수정해줍니다.

<template>
  <div id="app">
    <canvas
      ref="canvas"
      width="800"
      height="800"
      @mousedown="startDrawing"
      @mousemove="draw"
      @mouseup="stopDrawing"
      @mouseout="stopDrawing"
    ></canvas>

    <div id="designtool">
      <button @click="buttonErase">모두 지우기</button>
      <button @click="increaseThickness">두껍게</button>
      <button @click="decreaseThickness">얇게</button>
    </div>
  </div>
</template>

<script>
export default {
  name: "App",
  data() {
    return {
      drawing: false,
      context: null,
      lastX: 0,
      lastY: 0,
    };
  },
  mounted() {
    this.initCanvas();
  },
  methods: {
    initCanvas() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      this.context.strokeStyle = "#000";
      this.context.lineWidth = 5; 
    },
    startDrawing(e) {
      this.drawing = true;
      this.lastX = e.offsetX;
      this.lastY = e.offsetY;
    },
    draw(e) {
      if (!this.drawing) return;
      this.context.beginPath();
      this.context.moveTo(this.lastX, this.lastY);
      this.context.lineTo(e.offsetX, e.offsetY);
      this.context.stroke();
      this.lastX = e.offsetX;
      this.lastY = e.offsetY;
    },
    stopDrawing() {
      this.drawing = false;
    },

    buttonErase() {
      this.context.clearRect(0, 0, this.$refs.canvas.width, this.$refs.canvas.height);
    },

    increaseThickness() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      this.context.lineWidth += 1; 
    },

    decreaseThickness() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      if (this.context.lineWidth > 1) {
        this.context.lineWidth -= 1; // 
      }
    },

  },
};
</script>

<style scoped>
header {
  line-height: 1.5;
}

.logo {
  display: block;
  margin: 0 auto 2rem;
}

@media (min-width: 1024px) {
  header {
    display: flex;
    place-items: center;
    padding-right: calc(var(--section-gap) / 2);
  }

  .logo {
    margin: 0 2rem 0 0;
  }

  header .wrapper {
    display: flex;
    place-items: flex-start;
    flex-wrap: wrap;
  }
}

canvas {
  border: 2px solid white;
  background-color: green;
  cursor: pointer;
}

button {
  width: 200px;
  height: 50px;
}

</style>

위의 코드의 결과로 실행한 초기 화면 결과는 다음과 같습니다.

실행 결과 이미지

위에서 모두 지우기, 두껍게, 얇게 버튼에 대한 기능 동작에 대한 script 코드에 대해서 자세히 설명드리겠습니다.

3가지 버튼에 대한 설명에 앞서, Canvas 위에 Pen으로 그리는 기능에 대한 설명입니다.

    initCanvas() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      this.context.strokeStyle = "#000"; // 
      this.context.lineWidth = 5; // 
    },
    startDrawing(e) {
      this.drawing = true;
      this.lastX = e.offsetX;
      this.lastY = e.offsetY;
    },
    draw(e) {
      if (!this.drawing) return;
      this.context.beginPath();
      this.context.moveTo(this.lastX, this.lastY);
      this.context.lineTo(e.offsetX, e.offsetY);
      this.context.stroke();
      this.lastX = e.offsetX;
      this.lastY = e.offsetY;
    },
    stopDrawing() {
      this.drawing = false;
    },

위의 코드에서 initCanvas() 함수에 대해 최초에 mount를 적용하고, startDrawing, draw, stopDrawing 함수에 걸쳐서 Pen을 사용해서 Canvas에서 그릴 수 있습니다.

이어서, 모두 지우기 버튼에 대한 함수 설명은 다음과 같습니다.

    buttonErase() {
      this.context.clearRect(0, 0, this.$refs.canvas.width, this.$refs.canvas.height);
    },

모두 지우기 버튼을 누르게 되면 위의 함수가 실행되면서 canvas 내부의 모든 그림이 지워지게 됩니다.

이어서, "두껍게" & "얇게" 버튼에 대한 함수 설명은 다음과 같습니다.

    increaseThickness() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      this.context.strokeStyle = "#000";
      this.context.lineWidth += 1; 
    },

    decreaseThickness() {
      const canvas = this.$refs.canvas;
      this.context = canvas.getContext("2d");
      this.context.strokeStyle = "#000";
      if (this.context.lineWidth > 1) {
        this.context.lineWidth -= 1;
      }
    },

"두껍게", "얇게" 버튼을 누르게 되면서 각각 increaseThickness, decreaseThickness 함수가 실행되면서 lineWidth를 1씩 증가 또는 감소시키게 됩니다.

위의 기능들을 활용해서 그린 결과는 다음과 같습니다.

순서대로, 초기 & 두껍게 & 얇게 그린 결과

이상으로, Vue.js 프레임워크를 활용해서 간단한 그림판 기능을 구현해보았습니다.

감사드립니다.

[Docker] Docker Container를 활용한 Grafana 실행

Minima — Fri, 9 Feb 2024 00:16:36 +0900

안녕하세요, 오늘은 Docker Container를 활용해서 Grafana를 실행하는 방법에 대해서 알아보겠습니다.

https://grafana.com/

Grafana: The open observability platform | Grafana Labs

Play around with the Grafana Stack Experience Grafana for yourself, no registration or installation needed.

grafana.com

Grafana는 모니터링을 위한 오픈 소스 플랫폼입니다.

먼저, Docker Hub에서 Grafana Image의 최신 버전을 다운받아야 합니다.

docker pull grafana/grafana

docker images 결과

이어서 Grafana Container를 실행하는 방법에 대해서 알아보겠습니다.

docker run -d -p 3000:3000 --name=grafana grafana/grafana

docker ps 결과

위의 사진과 같이 localhost:3000으로 접속하게 되면 다음과 같은 화면이 접속되게 됩니다.

초기의 계정과 비밀번호는 각각 admin, admin을 입력해주시면 됩니다.

지금까지, Docker Container를 활용해서 Grafana를 실행하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Docker] Docker 사용 명령어 - 1 (images, inspect, build, run 등등)

Minima — Sat, 3 Feb 2024 16:10:39 +0900

안녕하세요, 오늘은 Docker를 사용하는 방법에 대해서 알아보겠습니다.

먼저, 로컬에 저장된 Docker Image 목록을 확인하는 명령어에 대해서 알아보겠습니다.

docker images

docker images 결과

이어서, 특정 Docker Image의 세부 정보를 확인하는 방법에 대해서 알아보겠습니다.

docker inspect "Docker 이미지 이름":TAG

해당 명령어에 대한 예시 입니다.

docker inspect python:3.8 결과

다음과 같이, Docker Image ID를 통해서도 세부 정보를 확인할 수 있습니다.

docker inspect dcdd1a525267 결과

이어서 실행 중인 Containers 보는 명령어는 다음과 같습니다.

docker ps

다음 명령어는 실행중이지 않은 모든 Containers를 보는 명령어입니다.

docker ps -a

실행 중인 Container를 중지하는 명령어입니다.

docker stop <container-id>

Container를 삭제하는 명령어입니다.

docker rm <container-id>

다음 명령어는 Dockerfile을 작성 후 이미지를 빌드 하는 명령어 입니다.

docker build -t temp-app .

위의 명령어는 Dockerfile을 활용하여 TEMP-APP이라는 Docker 이미지를 빌드하는 코드이며, 위의 명령어를 실행 후 docker images 명령어를 실행하면 temp-app (REPOSITORY)의 Docker 이미지가 생성된 것을 볼 수 있습니다.

이때 유의하셔야 할 사항은 REPOSITORY 명은 소문자로 정해주셔야 합니다.

Docker 이미지 빌드 후 Container를 실행하는 방법은 다음과 같습니다.

docker run -it --rm temp-app

이상으로, Docker를 사용하는 명령어에 대해서 알아보았습니다.

감사드립니다.

[Python, Tensorflow] Custom Callback 만들기 (Classification)

Minima — Tue, 30 Jan 2024 21:57:58 +0900

안녕하세요, 오늘은 Tensorflow 2에서 Classification 모델 학습 시 Callback을 Customize 하는 방법에 대해서 알아보겠습니다.

MNIST 데이터 셋을 활용하여, 모델 학습하는 예시 입니다.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.callbacks import Callback
import numpy as np

class SimpleCallBack(Callback):
    def __init__(self, patience=0):
        super(SimpleCallBack, self).__init__()
        self.best_weights = None

    def on_train_begin(self, logs=None):
        self.best_train_accuracy = 0.0
        self.best_validation_accuracy = 0.0

    def on_epoch_begin(self, epoch, logs=None):
        pass

    def on_epoch_end(self, epoch, logs=None):
        
        epoch_accuracy = logs.get("accuracy")
        epoch_validation_accuracy = logs.get("val_accuracy")

        print(f"[EPOCH : {epoch+1:3d}] >>> Train Accuracy : {epoch_accuracy:.3f}, Validation Accuracy : {epoch_validation_accuracy:.3f}")

        if np.less(self.best_validation_accuracy, epoch_validation_accuracy):
          self.best_weights = self.model.get_weights()
          self.model.save("./mnist_best")

          self.best_validation_accuracy = epoch_validation_accuracy
          print("MNIST Best Model Saved...")


    def on_train_end(self, logs=None):
        print("Train Finished...")

위의 코드를 구성하는 함수에 대해서 알아보게습니다.

on_train_begin : 모델 학습이 시작될 때 실행되는 함수
on_epoch_begin : 모델 학습 중 특정 Epoch이 시작될 때 실행되는 함수
on_epoch_end : 모델 학습 중 특정 Epoch이 종료될 때 실행되는 함수
on_train_end : 모델 학습이 종료될 때 실행되는 함수

위의 코드에서 유심히 봐야할 코드는 다음과 같습니다.

    def on_epoch_end(self, epoch, logs=None):
        
        epoch_accuracy = logs.get("accuracy")
        epoch_validation_accuracy = logs.get("val_accuracy")

        print(f"[EPOCH : {epoch+1:3d}] >>> Train Accuracy : {epoch_accuracy:.3f}, Validation Accuracy : {epoch_validation_accuracy:.3f}")

        if np.less(self.best_validation_accuracy, epoch_validation_accuracy):
          self.best_weights = self.model.get_weights()
          self.model.save("./mnist_best")

          self.best_validation_accuracy = epoch_validation_accuracy
          print("MNIST Best Model Saved...")

위의 코드는 특정 Epoch에 대하여 학습이 완료되었을 때 logs에서 train/validation accuracy를 불러와서 validation accuracy가 개선이 되었을 때 Model Weights을 저장하는 코드입니다.

위의 코드들을 활용한 전체 코드에 대해서 보여드리겠습니다.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.callbacks import Callback
import numpy as np

class SimpleCallBack(Callback):
    def __init__(self, patience=0):
        super(SimpleCallBack, self).__init__()
        self.best_weights = None

    def on_train_begin(self, logs=None):
        self.best_train_accuracy = 0.0
        self.best_validation_accuracy = 0.0

    def on_epoch_begin(self, epoch, logs=None):
        pass

    def on_epoch_end(self, epoch, logs=None):
        
        epoch_accuracy = logs.get("accuracy")
        epoch_validation_accuracy = logs.get("val_accuracy")

        print(f"[EPOCH : {epoch+1:3d}] >>> Train Accuracy : {epoch_accuracy:.3f}, Validation Accuracy : {epoch_validation_accuracy:.3f}")

        if np.less(self.best_validation_accuracy, epoch_validation_accuracy):
          self.best_weights = self.model.get_weights()
          self.model.save("./mnist_best")

          self.best_validation_accuracy = epoch_validation_accuracy
          print("MNIST Best Model Saved...")


    def on_train_end(self, logs=None):
        print("Train Finished...")


# MNIST 데이터 셋 로드
(x_train, y_train), (x_val, y_val) = mnist.load_data()
x_train, x_val = x_train / 255.0, x_val / 255.0


model = Sequential([
    Flatten(input_shape=(28, 28)), 
    Dense(128, activation='relu'), 
    Dense(64, activation='relu'),  
    Dense(10, activation='sigmoid') 
])

# 모델 컴파일
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

simple_callback = SimpleCallBack()

# 모델 학습
model.fit(x_train, y_train, batch_size=16, epochs=100, verbose=0, validation_data = (x_val, y_val), callbacks=[simple_callback])

모델 학습 시 출력 결과

이상으로, Tensorflow 2에서 Callback을 Customize 하는 방법에 대해서 알아보았습니다.

감사드립니다.

[Python] tqdm 패키지 사용법

Minima — Mon, 29 Jan 2024 21:25:47 +0900

안녕하세요, 오늘은 tqdm 패키지 사용하는 방법에 대해서 알아보겠습니다.

패키지 설치를 위한 방법은 다음과 같습니다.

pip install tqdm

패키지 설치 후 먼저 간단한 예시에 대해서 알아보겠습니다.

from tqdm import tqdm

for _ in tqdm(range(100000000), desc="Example - 1"):
   pass

range(100000000)이 아닌 일반적인 List를 활용한 예시는 다음과 같습니다.

from tqdm import tqdm
import numpy as np

A = np.random.randint(0, 100, (100,))
print(A, "\n")

for _ in tqdm(A, desc="Example - 2"):
   pass

tqdm를 활용해서 enumerate()와 유사한 기능을 사용하기 위한 예시는 다음과 같습니다.

from tqdm import tqdm
import numpy as np

A = np.random.randint(0, 100, (100,))
print(A, "\n")

for A_ele, index in zip(tqdm(A, desc="Example - 2"), range(len(A))):
   print("\n", A_ele, index)

이상으로, tqdm 패키지를 활용하여 간단한 예시를 구현하는 방법에 대해 알아보았습니다.

감사드립니다.

[Python, Numpy] np.meshgrid를 활용하여 Image Processing 구현 - 1 (반원 그리기)

Minima — Mon, 8 Jan 2024 22:08:25 +0900

안녕하세요, 오늘은 Numpy 패키지 내 np.meshgrid 함수를 활용하여 이미지 Processing 하는 방법들에 대해서 알아보겠습니다.

1. Opencv 패키지를 활용하여 Circle을 그리고 위쪽 반원만을 구하는 예시 입니다.

import cv2
import numpy as np

circle_image = np.zeros((512, 512, 3), np.uint8)
cv2.circle(circle_image, (256, 256), 100, (0, 255, 0), -1)

x_grid, y_grid = np.meshgrid(np.arange(512), np.arange(512))
mask_image = np.where(y_grid <= 256, 1, 0)
mask_image = np.stack([mask_image, mask_image, mask_image], axis=-1)


semicircle_image = (circle_image * mask_image).astype(np.uint8)

위의 코드에서 circle_image는 다음과 같습니다.

circle_image

또한, mask_image는 다음과 같습니다.

mask_image

위의 circle_image와 mask_image를 통해 최종적으로 구한 semicircle_image는 다음과 같습니다.

semicircle_image

최종적으로 위 반원을 얻은 것을 확인할 수 있습니다.

이상으로, Numpy 패키지 내 np.meshgrid 함수를 활용해서 반원을 그리는 방법에 대해서 알아보았습니다.

감사드립니다.