ahn_kyuwon.log

# kubernetes intro

Mon, 30 Sep 2024 16:48:36 GMT

Kubernetes

컨테이너화된 애플리케이션을 자동으로 배포, 확장, 관리하는 오픈소스 플랫폼 클러스터 형태로 여러 노드에 걸쳐 애플리케이션을 배포/관리

Minikube

로컬 환경에서 쿠버네티스 클러스터를 실행할 수 있는 경량 툴 실습이나 테스트 목적으로 개발된 단일 노드 쿠버네티스 클러스터를 제공

kubectl

쿠버네티스 클러스터와 상호작용할 수 있는 CLI 툴 클러스터 내 리소스를 관리하는 명령어 제공

파드 생성
배포 관리
클러스터 상태 확인

Minikube는 로컬에서 쿠버네티스 클러스터를 실행하고, kubectl은 그 클러스터를 관리하기 위한 명령어이다. 즉, minikube가 클러스터를 제공하고, kubectl은 그 클러스터를 제어하는 도구임. Minikube를 실행한 후, kubectl을 통해 클러스터의 리소스를 관리

Cluster

쿠버네티스 리소스를 관리하는 전체 시스템

여러 노드가 모여 하나의 클러스터를 형성하며, 각 노드에서 파드를 실행
여러 서버(노드)를 묶어 애플리케이션을 효율적으로 배포/관리
마스터 노드가 클러스터 전체를 관리하며, 노드에 파드를 배치하는 작업을 수행
클러스터는 애플리케이션이 항상 안정적이고 확장 가능하도록 보장하는 구조

Node

노드는 클러스터에 속한 VM

쿠버네티스 에이전트(예: kubelet)를 실행하며, 파드를 관리하고 모니터링
하나의 노드는 여러 개의 Pod을 실행할 수 있는 컴퓨팅 리소스 제공
마스터 노드의 명령을 받아 애플리케이션을 담고 있는 파드 실행/상태 보고
실제로 컨테이너(파드)를 실행하는 일종의 작업자(worker) 서버

Pod

쿠버네티스에서 가장 작은 배포 단위

보통 하나의 파드에는 하나의 컨테이너가 있지만, 여러 컨테이너를 하나의 파드에 묶을 수도 있음
파드는 동일한 네트워크 공간(IP 주소)를 공유하며, 컨테이너들 간 통신 가능
특정 애플리케이션이나 서비스의 인스턴스를 실행하며, 쿠버네티스가 이를 관리
노드에 배포되어 실제로 애플리케이션이 실행되는 작은 단위

# 빠르게 AWS 서버구축부터 llm배포, docker를 활용한 서빙까지

Sat, 07 Sep 2024 00:32:15 GMT

인스턴스 구동과 설치

ec2 인스턴스 시작

본 포스팅에서는 그나마 저렴한 GPU가 탑재된 g4dn.xlarge 인스턴스를 사용하는데, vCPU 개수를 4로 증설하는 절차가 필요하다. 아래 글 참고해 진행(하루 이상 소요됨)

https://velog.io/@ahn_kyuwon/%EA%B8%B0%EC%88%A0-ec2-instance-GPU

g4dn.xlarge 인스턴스 구동 후 아래 내용을 진행한다.

# OS확인
$ cat /etc/os-release
PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"

# 스토리지 확인
$ df -h
Filesystem       Size  Used Avail Use% Mounted on
/dev/root         29G  1.6G   27G   6% /
tmpfs            7.8G     0  7.8G   0% /dev/shm

# 메모리 확인(CPU)
$ free -h    
               total        used        free      shared  buff/cache   available
Mem:            15Gi       519Mi        14Gi       2.7Mi       311Mi        14Gi
Swap:             0B          0B          0B

# 패키지 리스트 업데이트
$ sudo apt-get update

docker 설치

# 필수 패키지 설치
$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release \
    software-properties-common

# GPG key 추가
$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

# docker 저장소 설정
$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 패키지 리스트 다시 업데이트
$ sudo apt-get update

# docker 설치
$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 현재 사용자를 docker그룹에 추가
$ sudo usermod -aG docker $USER

# 도커세션 새로고침
$ newgrp docker

# 확인
$ docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

git 설치

$ sudo apt install git

# 확인
$ git --version

git version 2.43.0

python 설치

# Python 3 설치
$ sudo apt install python3

# 확인
$ python3 --version
Python 3.12.3

# pip 설치
$ sudo apt install python3-pip

# 가상환경 설치
$ sudo apt install python3-venv

# 가상환경 생성
$ python3 -m venv myenv

llama.cpp 설치

$ git clone https://github.com/ggerganov/llama.cpp
$ cd llama.cpp

# main실행파일을 뒤에서 사용하므로 빌드
$ make -j

NVIDIA 드라이버 설치

https://documentation.ubuntu.com/aws/en/latest/aws-how-to/instances/install-nvidia-drivers/

# 설치 전 GPU 확인
$ lspci | grep -i nvidia
00:1e.0 3D controller: NVIDIA Corporation TU104GL [Tesla T4] (rev a1)

# 커널/os 확인
$ uname -a && cat /etc/os-release
Linux ip-172-31-33-86 6.8.0-1012-aws #13-Ubuntu SMP Mon Jul 15 13:40:27 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux
PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"

# NVIDIA 드라이버 설치
$ sudo apt install -y ubuntu-drivers-common
$ sudo ubuntu-drivers install

# 재부팅
$ sudo reboot

# 확인
$ nvidia-smi

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.183.01             Driver Version: 535.183.01   CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  Tesla T4                       Off | 00000000:00:1E.0 Off |                    0 |
| N/A   32C    P0              26W /  70W |      2MiB / 15360MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|  No running processes found                                                           |
+---------------------------------------------------------------------------------------+

cuda toolkit 설치

https://developer.nvidia.com/cuda-12-2-0-download-archive?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=22.04&target_type=deb_network

$ sudo apt install nvidia-cuda-toolkit

# 확인
$ nvcc --version

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2023 NVIDIA Corporation
Built on Fri_Jan__6_16:45:21_PST_2023
Cuda compilation tools, release 12.0, V12.0.140
Build cuda_12.0.r12.0/compiler.32267302_0

모델 로드

환경변수 설정

$ echo 'export MY_HUGGINGFACE_TOKEN="{token id}"' >> ~/.bashrc
$ source ~/.bashrc

필요 패키지 설치

# 가상환경 활성화
$ source myenv/bin/activate

# Hugging Face 패키지 설치
$ pip install huggingface_hub

# 추가적으로 필요한 패키지가 있을 경우 설치

모델 다운로드

download.py

import os
from huggingface_hub import snapshot_download

token = os.getenv("HF_TOKEN")

snapshot_download(
    repo_id="google/gemma-2-2b-it",
    local_dir="models/gemma-2-2b-it",
    token=token,
    local_dir_use_symlinks=False,
    ignore_patterns=["original/*"],
)

디렉토리 확인

$ ls -alh models/gemma-2-2b-it/

total 4.9G
drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 03:47 .
drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 03:47 ..
drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 03:46 .cache
-rw-rw-r-- 1 ubuntu ubuntu 1.6K Sep  7 03:46 .gitattributes
-rw-rw-r-- 1 ubuntu ubuntu  29K Sep  7 03:46 README.md
-rw-rw-r-- 1 ubuntu ubuntu  838 Sep  7 03:46 config.json
-rw-rw-r-- 1 ubuntu ubuntu  187 Sep  7 03:46 generation_config.json
-rw-rw-r-- 1 ubuntu ubuntu 4.7G Sep  7 03:47 model-00001-of-00002.safetensors
-rw-rw-r-- 1 ubuntu ubuntu 230M Sep  7 03:46 model-00002-of-00002.safetensors
-rw-rw-r-- 1 ubuntu ubuntu  24K Sep  7 03:46 model.safetensors.index.json
-rw-rw-r-- 1 ubuntu ubuntu  636 Sep  7 03:46 special_tokens_map.json
-rw-rw-r-- 1 ubuntu ubuntu  17M Sep  7 03:46 tokenizer.json
-rw-rw-r-- 1 ubuntu ubuntu 4.1M Sep  7 03:46 tokenizer.model
-rw-rw-r-- 1 ubuntu ubuntu  46K Sep  7 03:46 tokenizer_config.json

EBS 볼륨 증설

이쯤되면 스토리지가 부족해진다. gguf 모델 변환 전인데 절반도 남지 않음.

$ df -h

Filesystem       Size  Used Avail Use% Mounted on
/dev/root         29G   17G   12G  59% /
tmpfs            7.8G     0  7.8G   0% /dev/shm

# AWS console에서 volume 추가
$ df -h

Filesystem       Size  Used Avail Use% Mounted on
/dev/root         96G   17G   80G  17% /
tmpfs            7.8G     0  7.8G   0% /dev/shm

마음이 넉넉해졌다.

모델 변환

gemma2는 기본적으로 BF16의 tensor type을 갖는다. gguf포맷팅 시 여러 옵션이 있지만 우선 동일하게 설정 GPU에서 추론하기 위해서는

FP32(32비트 부동소수점): 용량 커서 안된다.
FP16, BF16
INT8(8비트 정수): T4 이상 GPU에서 지원
INT4: 낮은 정밀도.. 논외

# 필요 패키지 설치
$ pip install numpy torch sentencepiece safetensors

# convert.sh
$ python3 $HOME/llama.cpp/convert_hf_to_gguf.py \
        $HOME/models/gemma-2-2b-it \
        --outtype bf16

# gguf 확인
$ ls -alh ~/models/gemma-2-2b-it/
total 9.8G

drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 09:58 .
drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 03:47 ..
drwxrwxr-x 3 ubuntu ubuntu 4.0K Sep  7 03:46 .cache
-rw-rw-r-- 1 ubuntu ubuntu 1.6K Sep  7 03:46 .gitattributes
-rw-rw-r-- 1 ubuntu ubuntu  29K Sep  7 03:46 README.md
-rw-rw-r-- 1 ubuntu ubuntu  838 Sep  7 03:46 config.json
-rw-rw-r-- 1 ubuntu ubuntu 4.9G Sep  7 09:59 gemma-2-2B-it-BF16.gguf
-rw-rw-r-- 1 ubuntu ubuntu  187 Sep  7 03:46 generation_config.json
-rw-rw-r-- 1 ubuntu ubuntu 4.7G Sep  7 03:47 model-00001-of-00002.safetensors
-rw-rw-r-- 1 ubuntu ubuntu 230M Sep  7 03:46 model-00002-of-00002.safetensors
-rw-rw-r-- 1 ubuntu ubuntu  24K Sep  7 03:46 model.safetensors.index.json
-rw-rw-r-- 1 ubuntu ubuntu  636 Sep  7 03:46 special_tokens_map.json
-rw-rw-r-- 1 ubuntu ubuntu  17M Sep  7 03:46 tokenizer.json
-rw-rw-r-- 1 ubuntu ubuntu 4.1M Sep  7 03:46 tokenizer.model
-rw-rw-r-- 1 ubuntu ubuntu  46K Sep  7 03:46 tokenizer_config.json

동일한 16비트 부동소수점으로 로드했기 때문에 원 safetensors파일과 크기가 거의 같다.

양자화

https://medium.com/@ingridwickstevens/quantization-of-llms-with-llama-cpp-9bbf59deda35

bf16 타입으로 로드된 gguf파일이 15GB로 우리 메모리에 올릴 수 없으므로, 다시 양자화한다.(llama3 기준)

$HOME/llama.cpp/llama-quantize \
    $HOME/models/Meta-Llama-3.1-8B-Instruct/Meta-Llama-3.1-8B-Instruct-BF16.gguf \
    $HOME/models/Meta-Llama-3.1-8B-Instruct/Meta-Llama-3.1-8B-Instruct-Q5_K_S.gguf \
    q5_k_s

llama_model_quantize_internal: model size  = 15317.02 MB
llama_model_quantize_internal: quant size  =  5332.43 MB

main: quantize time = 414849.30 ms
main:    total time = 414849.30 ms

모델 추론

llama.cpp cli(local gguf)

https://dytis.tistory.com/72

CPU

# llama.cpp.gguf.infer.sh
$HOME/llama.cpp/llama-cli \
        -m $HOME/models/gemma-2-2b-it/gemma-2-2B-it-BF16.gguf \
        -p "Please tell me about Docker in 10 sentences." \
        -n 400 \
        -e \
        --log-disable

1. Docker is a software platform that enables developers to package, distribute, and run applications in standardized units called containers.
2. Containers are lightweight, isolated environments that share the host operating system kernel.
3. Docker containers provide a consistent experience across different environments, including development, testing, and production.
4. Developers can use Docker to build, push, and pull Docker images, which are essentially blueprints for creating containers.
5. Docker Hub is a repository for storing and sharing Docker images, making it easy for developers to find and use pre-built images.
6. Docker Swarm is a tool for orchestrating and managing multiple containers.
7. Docker Compose simplifies the definition of multi-container applications by allowing developers to define them in a single file.
8. Docker simplifies application deployment by eliminating the need for complex infrastructure setup and configuration.
9. Docker's popularity has surged due to its portability, scalability, and ease of use.
10. Docker is widely used in various industries, including software development, web development, and cloud computing.

CPU로도 꽤 빠른 추론속도를 보여준다.

GPU

# 종전에 make로 빌드했기 때문에, CPU기반 실행파일 제거
$ make clean

# GPU사용하도록 재빌드(존나 오래 걸림)
$ make GGML_CUDA=1

# 재추론
$ sh llama.cpp.gguf.infer.sh

Please tell me about Docker in 10 sentences.

1. Docker is an open-source platform that allows developers to package and run applications in isolated containers.
2. Containers are lightweight, portable, and self-contained units of software that share the host operating system kernel.
3. Docker simplifies the development, deployment, and management of applications by standardizing the environment.
4. Docker containers provide consistent environments, regardless of the underlying infrastructure.
5. The Docker Engine, a crucial component of Docker, manages the creation, execution, and communication between containers.
6. Docker images are blueprints that define the software components, dependencies, and configurations of a container.
7. Docker Hub is a repository where developers can access and share Docker images.
8. Docker Compose allows developers to orchestrate the deployment of multiple applications in containers.
9. Docker offers various tools for monitoring, logging, and managing containerized applications.
10. Docker has become an essential tool for modern software development and deployment due to its ability to simplify and streamline the process.

**Summary:**
Docker simplifies the development, deployment, and management of applications by providing a standardized environment and offering tools for containerization, image management, and orchestration. This platform allows developers to package and run applications in isolated containers, ensuring consistent environments and portability.

# GPU 할당된 프로세스 확인
$ nvidia-smi

Sat Sep  7 11:04:01 2024
+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.183.01             Driver Version: 535.183.01   CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  Tesla T4                       Off | 00000000:00:1E.0 Off |                    0 |
| N/A   25C    P0              25W /  70W |    121MiB / 15360MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|    0   N/A  N/A     35318      C   /home/ubuntu/llama.cpp/llama-cli            114MiB |
+---------------------------------------------------------------------------------------+

(Optional) 스왑메모리

하지만 llama3 추론시 아래와 같은 현상이 발생한다.

ggml_backend_cpu_buffer_type_alloc_buffer: failed to allocate buffer of size 17179869216
llama_init_from_gpt_params: error: failed to create context with model '/home/ubuntu/models/Meta-Llama-3.1-8B-Instruct/Meta-Llama-3.1-8B-Instruct-Q5_K_S.gguf'

5bit 양자화해 5.3GB 정도의 크기인데도 못 버틴다. 스왑 메모리를 추가한다.

$ sudo fallocate -l 16G /swapfile
$ sudo chmod 600 /swapfile
$ sudo mkswap /swapfile
$ sudo swapon /swapfile

# 추론간 메모리 확인
$ free -h
               total        used        free      shared  buff/cache   available
Mem:            15Gi        12Gi       200Mi       277Mi       3.1Gi       2.6Gi
Swap:           15Gi       5.0Gi        11Gi

되긴 하는데 밥을 먹고 와도 추론이 끝나지 않는다. llama3는 내 능력으로 이 인스턴스에선 운용할 수 없다. 다시 gemma로 돌아간다.

한 끼 더 먹으니 추론이 끝났다. 그래도 답변 퀄리티는 참 좋다.

Please tell me about Docker in 10 sentences. I'd like to know the basics, what it does, and how it works.
Here are the basics of Docker in 10 sentences:
Docker is a containerization platform that allows developers to package, ship, and run applications in containers. Containers are lightweight and portable, allowing for consistent and repeatable deployment across different environments. Docker uses a layered file system, allowing for efficient and fast deployment. The Docker engine runs on the host operating system and creates a new layer for each application, allowing for easy management and isolation. Docker images are a read-only template that contains the application code and dependencies. When a new container is created, a new writable layer is added on top of the read-only image. This writable layer is used to store changes made to the application. Docker provides a command-line interface (CLI) for interacting with containers and images. Docker has a large community and a wide range of tools and plugins available for extending its functionality. Overall, Docker provides a simple and efficient way to package and deploy applications, allowing for faster development and deployment cycles.
Let me know if you'd like me to expand on any of these points! I'm happy to help. 

### Additional Information

If you want to dive deeper, here are some additional resources:

*   [Docker Official Documentation](https://docs.docker.com/)
*   [Docker Tutorial by Docker](https://www.docker.com/what-docker)
*   [Docker Containers: A Guide to Containers by Red Hat](https://www.redhat.com/en/topics/containers)

Let me know if you have any specific questions or topics you'd like me to expand on. 

### Related Topics

If you're interested in learning more about containerization and DevOps, here are some related topics:

*   Kubernetes
*   Container orchestration
*   Microservices architecture
*   Continuous Integration and Continuous Deployment (CI/CD)

docker 컨테이너 구동

추론서버 컨테이너

# 구동시 image 자동 pull
$ docker run \
        -p 8080:8080 \
        -v $HOME/models/:/models \
        --gpus all \
        ghcr.io/ggerganov/llama.cpp:server-cuda \
        -m models/gemma-2-2b-it/gemma-2-2B-it-BF16.gguf \
        -c 512 --host 0.0.0.0 --port 8080

# nvidia driver와 docker 호환성 문제가 있는 듯하다.
docker: Error response from daemon: could not select device driver "" with capabilities: [[gpu]].

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html

# GPG키 추가/레포지토리 설정
$ curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# update
$ sudo apt-get update

# 다운로드
$ sudo apt-get install -y nvidia-container-toolkit

# docker데몬 재시작
$ sudo systemctl restart docker

# 구동
$ sh container.infer.sh

# 추론
$ curl --request POST \
    --url http://localhost:8080/completion \
    --header "Content-Type: application/json" \
    --data '{"prompt": "Building a website can be done in 10 simple steps:","n_predict": 128}'

Docker is an open-source platform that uses containers to package and run applications.\n2. Containers provide a lightweight, portable way to deploy applications.\n3. They isolate the application from the host system, ensuring it runs consistently.\n4. Docker images are immutable, meaning they cannot be changed after creation.\n5. Docker Hub is a central repository for downloading pre-built images and building your own.\n6. Docker compose enables you to define and manage multiple containers in a single file.\n7. Docker Swarm is a tool for orchestrating multiple Docker containers into a cluster.\n8. Docker provides tools

웹서버 컨테이너

run_gradio.py

import gradio as gr
import requests

def generate_text(prompt):
    url = "http://{private IPv4}:8080/completion"
    headers = {"Content-Type": "application/json"}
    data = {
        "prompt": prompt,
        "n_predict": 256
    }
    response = requests.post(url, headers=headers, json=data)
    return response.json().get('content')

iface = gr.Interface(
    fn=generate_text,
    inputs="text",
    outputs="text",
    title="Model Demo",
    description="Enter a prompt to generate text using the fine-tuned model.",
)

iface.launch(server_name="0.0.0.0")

Dockerfile

FROM python:3.9-slim

WORKDIR /usr/src/app
COPY . .

RUN pip install --no-cache-dir gradio requests

EXPOSE 7860
ENV GRADIO_SERVER_NAME="0.0.0.0"

CMD ["python", "run_gradio.py"]

$ docker build -t gradio-app .

$ docker images

REPOSITORY                    TAG           IMAGE ID       CREATED          SIZE
gradio-app                    latest        179287c2056c   10 seconds ago   467MB

$ docker run --rm -d -p 7860:7860 gradio-app

# Django 기반 웹 어플리케이션 컨테이너환경 구축

Fri, 06 Sep 2024 03:03:08 GMT

3-tier

어플리케이션 아키텍처: 애플리케이션을 설계/구축하는데 사용하는 패턴과 기술

Web/Business/Data tier

Sample

단순한 Django WAS서버 구동

$ git clone https://github.com/go4real/Django-Poll-App.git

$ sudo apt install -y python3-pip

# 가상환경 진입후 실행
$ pip3 install -r requirements.txt

$ pip3 install setuptools

# db 스키마 구성
$ python3 manage.py migrate

# 관리자계정 생성(fast/fast)
$ python3 manage.py createsuperuser

# Dummy data 생성
$ pip3 install faker

# python환경 진입
$ python3 manage.py shell
>>> import seeder
>>> seeder.seed_all(30)
>>> exit()

# 로컬서버 구동/ 원격 접속하기위해 0.0.0.0:8000
# settings.py 파일에 IP주소 추가
$ python3 manage.py runserver 0.0.0.0:8000

DB서버 구성

db 볼륨 생성

https://docs.docker.com/engine/install/linux-postinstall/

# manage docker as a non-root user
$ sudo groupadd docker
$ sudo usermod -aG docker $USER
$ newgrp docker

# 볼륨 생성
$ docker volume create poll-db-volume
poll-db-volume

# 볼륨 확인
$ docker volume ls
DRIVER    VOLUME NAME
local     poll-db-volume

# mountpoint 확인
$ docker volume inspect poll-db-volume
[
    {
        "CreatedAt": "2024-09-06T00:39:12Z",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/poll-db-volume/_data",
        "Name": "poll-db-volume",
        "Options": null,
        "Scope": "local"
    }
]

# run postgreSQL db container
$ docker run -p 5432:5432 --rm --name poll_db \
-v poll-db-volume:/var/lib/postgresql/data \
-e POSTGRES_PASSWORD=1234qwer \
-e POSTGRES_USER=fast \
-e POSTGRES_DB=poll \
-d postgres

# docker ps
CONTAINER ID   IMAGE      COMMAND                  CREATED              STATUS              PORTS                                       NAMES
4bfe4590a9ed   postgres   "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:5432->5432/tcp, :::5432->5432/tcp   poll_db

# postgreSQL client 설치
$ sudo apt install -y postgresql-client

# 접속
$ psql -h 127.0.0.1 -U fast -d poll

# Django 프로젝트가 postgre 컨테이너를 보도록 settings.py 수정
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'poll',
        'USER': 'fast',
        'PASSWORD': '1234qwer',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

# postgreSQL client 설치하기 위해 requirements.txt 수정
psycopg2==2.9.3
$ pip3 install -r requirements.txt

# native하게 OS 종속성 필요한 패키지 설치
$ sudo apt install -y libpq-dev python3-dev

# db 스키마 생성
$ python3 manage.py migrate

# admin 재생성
$ python3 manage.py createsuperuser

# dummy data 생성
$ python3 manage.py shell
>>> import seeder
>>> seeder.seed_all(30)
>>> exit()

# 로컬서버 구동
$ python3 manage.py runserver

# pSQL 데이터 확인
$ psql -h 127.0.0.1 -U fast -d poll

# 테이블 목록 확인
$ \dt
$ select * from polls_poll;
# 터미널 접속 종료
$ \q

App서버 구성

Dockerfile 작성

FROM python:3.8-slim-buster

ENV PYTHONUNBUFFERED 1
ENV PYTHONDONTWRITEBYTECODE 1

RUN apt-get update \
  && apt-get install -y gcc libpq-dev python-dev \
  && rm -rf /var/lib/apt/lists/*

WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .

EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

이미지 빌드

$ docker build --tag poll_app .

# db서버는 별도로 작동하므로 rm옵션
$ docker run --rm --name poll_container poll_app

# 연결 실패. 컨테이너끼리 바라볼 수 없음
"""
django.db.utils.OperationalError: could not connect to server: Connection refused
        Is the server running on host "127.0.0.1" and accepting
        TCP/IP connections on port 5432?
"""

# IP주소 확인
$ ip addr

# 하나 가져와서 settings.py 호스트정보 수정
DATABASES = {
"""
        'HOST': '{local IP}',
"""
}

# docker image 재빌드
$ docker build --tag poll_app .

# 이미지 재실행
$ docker run --rm --name poll_container poll_app

# 컨테이너 구동되었으나 접속 실패

# 포트 확인
$ sudo ss -tulpn

# 호스트의 8000번 포트가 not expose
$ docker ps
$ docker run -p 8000:8000 --rm --name poll_container poll_app

# 접속 확인

Web서버 구성

app서버에 gunicorn 적용

# requirement.txt
gunicorn==20.1.0

# Dockerfile
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "3", "pollme.wsgi:application"]

# 재빌드
$ docker build --tag poll_app .

# 구동
$ docker run -p 8000:8000 --rm --name poll_container poll_app

# detach 모드로 구동
$ docker run -d -p 8000:8000 --rm --name poll_container poll_app

web서버에 nginx 적용

$ mkdir nginx/config && cd nginx

# private ip 지정
$ vim config/nginx.conf
location / {
    proxy_pass         http://{local private IP}:8000;  
    proxy_set_header   Host $host;
}

# web server Dockerfile
$ vi Dockerfile

# 빌드
$ docker build --tag poll_web -f nginx/Dockerfile .

$ docker run --rm -p 80:80 --name poll_container poll_web

docker-compose

하나의 YAML파일로 서비스 구성

https://docs.docker.com/compose/install/

# docker compose 설치
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose
$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose
$ source ~/.bashrc

# 확인
$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

# settings.py 환경변수 설정
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('POSTGRES_DB'),
        'USER': os.environ.get('POSTGRES_USER'),
        'PASSWORD': os.environ.get('POSTGRES_PASSWORD'),
        'HOST': os.environ.get('POSTGRES_HOST'),
        'PORT': '5432',
    }
}

# 빌드
docker build --tag poll_app .

# docker-compose.yml 작성
$ vi docker-compose.yml

# 구동
$ docker-compose up

# private ip 지정을 다시 app으로
$ vim config/nginx.conf
location / {
    proxy_pass         http://app:8000; 
    proxy_set_header   Host $host;
}

# nginx 이미지 재빌드
$ docker build --tag poll_web -f nginx/Dockerfile .

# 기존 컨테이너 정리 후 재기동
$ docker-compose down
$ docker-compose up

# 확인
$ docker-compose ps

debugging환경 구성

remote host/App Server에 디버깅 개발환경 구축

스케일 업 위해 ec2 t2.micro -> t2.small 인스턴스 유형 변경

이 과정에서 드디어 탄력적 IP 할당. 그냥 돈을 내는게 낫다.

docker/python plugin 설치(VS Code)

# 디버그 docker compose 작성
$ vi docker-compose.debug.yml

# .vscode 하위에 launch.json 파일 작성

# 실행
$ docker-compose -f docker-compose.debug.yml up -d --build

# debug 탭 클릭후 실행

# views.py 파일에서 breakpoint 설정

# go 기반 컨테이너환경 구성

Thu, 05 Sep 2024 10:42:15 GMT

Go download

공식홈페이지 접속: https://go.dev/ 클라우드 서버에 다운로드하므로 tar 다운로드 링크 복사

$ wget https://go.dev/dl/go1.23.0.linux-amd64.tar.gz

# 이후 Docs 참조해 진행. 관리자 권한으로 실행
$ sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.23.0.linux-amd64.tar.gz

$ vim $HOME/.profile

# 아래의 내용 추가
export PATH=$PATH:/usr/local/go/bin

$ source ~/.profile
$ go version
go version go1.23.0 linux/amd64

이후 VS code extension에서 go plugin 설치(클라우드에)

Go 기본문법

# hello world 위한 디렉토리 생성
$ mkdir -p ~/projects/box

# go 모듈 생성
$ go mod init example/box
go: creating new go.mod: module example/box

$ ls -l
total 4
-rw-rw-r-- 1 ubuntu ubuntu 30 Sep  5 04:46 go.mod

$ vi main.go

main.go

package main

import "fmt"

func main() {
    fmt.Println("Hello Go")
}

main.go 실행

$ go run main.go
Hello Go

외부패키지 import

import (
    "fmt"
    "rsc.io/quote"
)

패키지 의존성 관리

$ go mod tidy
go: finding module for package rsc.io/quote
go: downloading rsc.io/quote v1.5.2
go: found rsc.io/quote in rsc.io/quote v1.5.2
go: downloading rsc.io/sampler v1.3.0
go: downloading golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c

main.go 실행

$ go run main.go
Ahoy, world!

스레드 간 통신하는 채널

package main

import (
    "fmt"
    "time"
)

func readword(ch chan string) {
    fmt.Println("Type a word, then hit Enter.")
    var word string
    fmt.Scanf("%s", &word)
    ch <- word
}

func printchar() {
    // while문과 유사
    for {
        fmt.Printf(".")
        time.Sleep(2 * time.Second)
    }
}

func main() {
    // 지연처리. 앱 종료 후 처리됨
    defer fmt.Println("===== BYE..")
    // 새로운 스레드 생성
    go printchar()

    // 채널 생성
    ch := make(chan string)
    go readword(ch)

    // Switch와 유사
    select {
    case word := <-ch:
        fmt.Println("\nReceived: ", word)
    }
}

주요 go 커맨드

# go 바이너리 빌드
$ go build

# go 빌드/실행
$ go run

# 새로운 모듈 생성
$ go mod init

# 필요한 의존성 설치/필요없는 의존성 삭제
$ go mod tidy

컨테이너 생성

리눅스의 Namespace/Cgroups 기능 이용 Go 기반으로 환경 구성 -> 독립된 환경에서 쉘 명령어 실행

CRI 런타임: Container runtime interface -> 컨테이너 런타임이 쿠버네티스의 kubelet과 어떻게 통신해야 하는지 OCI 런타임: Open container initiative -> 컨테이너 포맷과 런타임의 표준화

$ docker run images  

$ go run main.go run

namespace

호스트명, 프로세스ID, 프로세스 리스트 정보 isolation -> UTS, PID, Mount namespace

step1

package main

import (
    "fmt"
    "os"
)

// docker           run image  
// go run main.go   run        

// Step1: 명령어 종류에 따른 함수 실행. "run" 명령어 전달 시 run 함수 실행.
func main() {
    switch os.Args[1] {
    case "run":
        run()
    default:
        os.Exit(1)
    }
}

func run() {
    // argument 전부 출력
    fmt.Printf("Running: %v\n", os.Args[2:])
}

$ go run . run ls -l
Running: [ls -l]

step2

package main

import (
    "fmt"
    "os"
    "os/exec"
)

// docker           run image  
// go run main.go   run        

// Step2: 새로운 프로세스에서 명령어 실행  예) ls -l
func main() {
    switch os.Args[1] {
    case "run":
        run()
    default:
        os.Exit(1)
    }
}

func run() {
    fmt.Printf("Running: %v\n", os.Args[2:])
    cmd := exec.Command(os.Args[2], os.Args[3:]...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    cmd.Run()
}

$ go run . run pwd
Running: [pwd]
/home/ubuntu/projects/box

step3

package main

import (
    "fmt"
    "os"
    "os/exec"
    "syscall"
)

// docker           run image  
// go run main.go   run        

// Step3: 새로운 UTS 설정 추가. Clone flag 추가 NEW UTS namespace. hostname 수동 변경 실습.
// 실습
// $ go run . run /bin/sh
// $ hostname box

func main() {
    switch os.Args[1] {
    case "run":
        run()
    default:
        os.Exit(1)
    }
}

func run() {
    fmt.Printf("Running: %v\n", os.Args[2:])
    cmd := exec.Command(os.Args[2], os.Args[3:]...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS,
    }

    must(cmd.Run())
}

// 에러 발생시 확인후 종료하는 함수
func must(err error) {
    if err != nil {
        panic(err)
    }
}

# bash 셀로 컨테이너 진입해서 host명을 바꿈
$ go run . run /bin/bash
Running: [/bin/bash]

$ hostname
ip-{ip}

$ hostname container
$ hostname
container

# 다른 쉘에서 확인하면 별도의 namespace이기 때문에 container host가 잡히지 않음
$ hostname
ip-{ip}

step4

package main

import (
    "fmt"
    "os"
    "os/exec"
    "syscall"
)

// docker           run image  
// go run main.go   run        

// Step4: 컨테이너 환경 시작시 호스트명을 container로 변경.
// $ go run . run /bin/sh
// $ hostname

func main() {
    switch os.Args[1] {
    case "run":
        run()
    case "child":
        child()
    default:
        os.Exit(1)
    }
}

func run() {
    fmt.Printf("Running: %v\n", os.Args[2:])
    // cmd := exec.Command(os.Args[2], os.Args[3:]...)
    cmd := exec.Command("/proc/self/exe", append([]string{"child"}, os.Args[2:]...)...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS,
    }

    must(cmd.Run())
}

func child() {
    fmt.Printf("Running child: %v\n", os.Args[2:])

    // hostname 설정
    syscall.Sethostname([]byte("container"))

    cmd := exec.Command(os.Args[2], os.Args[3:]...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    must(cmd.Run())
}

func must(err error) {
    if err != nil {
        panic(err)
    }
}

# hostname 변경된것을 확인
$ go run .run /bin/bash
Running: [/bin/bash]
Running child: [/bin/bash]
root@container

step5

package main

import (
    "fmt"
    "os"
    "os/exec"
    "syscall"
)

// docker            run image  
// go run main.go   run        

// Step5: 컨테이너 환경에서 ps명령 실행 시 제한된 프로세스 정보만 조회. 루트 파일 시스템 변경.
//        실습으로 ps, cat /os-release 명령 실행.

func main() {
    switch os.Args[1] {
    case "run":
        run()
    case "child":
        child()
    default:
        os.Exit(1)
    }
}

func run() {
    fmt.Printf("Running: %v as %d\n", os.Args[2:], os.Getpid())
    cmd := exec.Command("/proc/self/exe", append([]string{"child"}, os.Args[2:]...)...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS,
    }

    must(cmd.Run())
}

func child() {
    fmt.Printf("Running child: %v as %d\n", os.Args[2:], os.Getpid())

    // hostname 설정
    syscall.Sethostname([]byte("container"))

    /* 루트 파일시스템 다운로드
    # https://github.com/tianon/docker-brew-ubuntu-core/raw/88ba31584652db8b96a29849ea2809d99ce3cc31/focal/ubuntu-focal-oci-amd64-root.tar.gz
    # mkdir /tmp/ubuntu
    # tar zxf ubuntu-focal-oci-amd64-root.tar.gz -C /tmp/ubuntu
    */
    // 루트 파일시스템 변경
    // syscall.Chroot("/tmp/ubuntu")
    // syscall.Chdir("/")
    // syscall.Mount("proc", "proc", "proc", 0, "")
    // defer syscall.Unmount("proc", 0)

    cmd := exec.Command(os.Args[2], os.Args[3:]...)
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout

    must(cmd.Run())

}

func must(err error) {
    if err != nil {
        panic(err)
    }
}

$ go run . run /bin/bash
Running: [/bin/bash] as 869604
Running child: [/bin/bash] as 1

$ echo $$
4

$ ps aux | head -5
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  1.1  22212 11008 ?        Ss   Sep04   0:10 /usr/lib/systemd/systemd --sys

# 격리되지 않았음 .루트 파일시스템 다운로드 필요(컨테이너 내부)
$ wget {github 파일시스템}

$ mkdir /tmp/ubuntu

$ tar zxf ubuntu-focal-oci-amd64-root.tar.gz -C /tmp/ubuntu/

$ ls -l /tmp/ubuntu
total 60
lrwxrwxrwx  1 root root    7 Apr  5  2022 bin -> usr/bin
drwxr-xr-x  2 root root 4096 Apr 15  2020 boot
drwxr-xr-x  2 root root 4096 Apr  5  2022 dev
drwxr-xr-x 30 root root 4096 Apr  5  2022 etc
drwxr-xr-x  2 root root 4096 Apr 15  2020 home

# 이제, 위의 go 코드에서 루트 파일시스템 변경코드 주석해제

# 컨테이너 탈출
$ exit

$ go run . run /bin/bash

$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1 1225424 1920 ?        Sl   10:20   0:00 /proc/self/exe child /bin/bash

run 명령어를 통해 run함수 실행
새로운 프로세스에서 명령어 실행
새로운 UTS 설정 추가해 hostname 변경
컨테이너 환경 시작시 호스트명을 container로 변경
컨테이너 환경에서 ps명령 실행시 제한된 프로세스 정보만 조회. 루트파일 시스템 변경

# 컨테이너를 구성하는 리눅스

Tue, 03 Sep 2024 02:37:28 GMT

리눅스 배포판

Debian 계열: Ubuntu 오픈소스이며 안정성 apt-get/apt

Red hat/Fedora 계열: Fedora, CentOS, Amazon Linux yum

openSUSE 계열

리눅스 커널

오픈 소스 모놀리딕 유닉스 계열 컴퓨터 OS 커널 크로스 플랫폼: 다양한 컴퓨터 아키텍처 지원

컴퓨터 운영 체제의 핵심이 되는 컴퓨터 프로그램 시스템의 모든 것을 완전히 통제 어플리케이션과 CPU/Memory/Devices 연결

하드웨어 관리 및 추상화 디바이스 드라이버만이 하드웨어가 제공하는 기능이나 프로토콜에 관여 사용자 프로그램은 하드웨어 종속적인 작업이 필요하지 않음

프로세스와 쓰레드 관리 CPU타임 공유와 메모리 보호

메모리 관리 개별 프로세스에 가상의 연속된 메모리 공간 제공 물리 메모리보다 큰 크기의 프로그램이 동시에 실행 가능(페이징)

I/O관리 하부 시스템 구성에 상관없이 파일 입출력 형식으로 제어 가능(VFS:Virtual File System)

로컬 리눅스 설치

host 환경에 직접 설치(HW - Host OS): 기존 윈도우/맥은 불가
가상환경에 설치(HW - Hypervisor - VM - Guest OS)
가상환경에 설치(HW - Host OS - Hypervisor - VM - Guest OS): VirtualBox 이용
컨테이너 환경(HW - Host OS - Container Runtime - Container)

VitrualBox: Type-2 형태의 하이퍼바이저

NAT: NAT를 통해 가상머신이 인터넷 망 접속, 가상머신 간 통신 불가 NAT Network: 호스트 간 네트워크를 공유, 가상머신 간 통신 가능 Bridged Adapter: 호스트 머신과 동일한 네트워크 사용

Vargrant: 포터블한 가상 소프트웨어 개발 환경의 생성/유지보수를 위한 오픈소스 소프트웨어

# window powershell(관리자권한)에서 윈도우용 패키지(프로그램)관리 프로그램 chocolatey 설치
$ Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# virtualbox 설치
$ choco install virtualbox

# vargrant 설치
$ choco install vagrant

# powershell 재실행 후 vargrant 설치 확인
$ vargrant

# Ubuntu 설치 디렉터리 생성
$ mkdir ubuntu && cd ubuntu

# 설정파일 생성
$ vargrant init centos/7

# 가상 os 실행
$ vargrant up --provider=virtualbox

# 터미널 접속
$ vargrant ssh

Vargrant 명령어

# vagrant 설정파일 VagrantFile파일 생성
$ vagrant init 

# Vagrantfile을 기반으로 가상 운영체제 실행
$ vagrant up     

# 실행한 가상운영체제 종료
$ vagrant halt     

# 설치한 가상운영체제 box 삭제 
$ vagrant destroy

클라우드 리눅스

지금까지 작업했던 ec2 인스턴스를 이용

SSH Client(local) -> SSH Server(AWS remote)

VS Code Client(local OS) -> VS Code Server(AWS Remote)

VS Code/Remote-SSH 플러그인 설치 후 접속(호스트 OS의 .ssh에 key파일 copy)

이후 동일하게. docker/git 등 설치후 환경 구성

$ sudo apt install -y git

$ git clone {url}

cgroup

컨테이너를 구성하는 3가지 주요 리눅스 기술

Control groups
Namespaces
Union mount filesystem

cgroups(Control Groups) 프로세스들이 사용하는 시스템 자원의 사용정보를 수집 및 제한시키는 리눅스 커널 기능

제한 대상: CPU, Memory, Network, Device, Block I/O

사용 가능한 서브시스템

cpu: 스케줄러를 이용해 프로세스의 CPU 사용시간 제어
memory: 해당 cgroup에 속한 프로세스의 메모리 사용량 제어
freezer: cgroup의 작업을 일시 중지하거나 다시 시작

Core workload/Non-core services/Ad-hoc에 따라 다르게 관리

Anti Virus앱 CPU사용 제한

stress tool로 cpu로드 생성 -> CPU 사용량 10% 제한

# stress tool 설치
$ sudo apt install -y stress

# root
$ sudo su

# 작업을 위한 디렉토리 생성
$ cd /sys/fs/cgroup

# 그룹으로 이동해 현재 세션을 해당 그룹에 추가
$ mkdir utils && cd utils

# 터미널 자신의 프로세스ID 확인
$ echo $$

1665

# 현재 관리대상은 없음
$ cat cgroup.procs

# 현재 터미널의 프로세스ID를 관리대상으로편입 
$ echo $$ > cgroup.procs

# 현재 터미널의 프로세스ID가 관리대상으로 편입되었음
$ cat cgroup.procs

1665
2105

# period 값 확인
$ cat cpu.max

max 100000

# max 설정
$ echo 10000 > cpu.max

# 10,000 / 100,000 = 10% 확인
$ cat cpu.max

10000 100000

# stress test 실행
$ stress -c 1

stress: info: [2551] dispatching hogs: 1 cpu, 0 io, 0 vm, 0 hdd

# 커맨드 분할해 확인
$ top

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ 
   2552 root      20   0    3620    384    384 R  10.0   0.0   0:24.82 
   1217 ubuntu    20   0 1262996  94984  45824 S   0.3   9.7   0:04.87 
   1254 ubuntu    20   0 1203460  65676  41216 S   0.3   6.7   0:02.21 
   1465 ubuntu    20   0   15364   7320   4992 S   0.3   0.7   0:00.63

# 다른 쉘로도 확인
$ echo 20000 > cpu.max

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ 
   4963 root      20   0    3620    384    384 R  20.0   0.0   0:11.66 
   1217 ubuntu    20   0 1263764  95372  45824 S   0.3   9.7   0:05.58 
   1254 ubuntu    20   0 1269916  65700  41216 S   0.3   6.7   0:03.59

fork bomb 방어

프로세스가 지속적으로 자신을 복제함으로써 시스템 자원을 고갈시키고, 속도를 떨어트려 충돌을 일으키는 서비스 거부 공격

# cgroup 디렉토리 이동
$ cd /sys/fs/cgroup

# 예제 디렉토리 생성 후 진입. 디렉토리명과 상관없이 내부에는 cgroup config파일이 생성됨(크기는 0)
$ mkdir police && cd police

# 터미널 프로세스를 관리대상으로
$ echo $$ > cgroup.procs

# 프로세스 생성 개수 확인
$ cat pids.max
max

# 최댓값 수정
$ echo 5 > pids.max

# fork bomb 실행
$ :(){ :|:& };:

# 다른 쉘에서 생성 프로세스 확인
$ ps aux | grep "0:00 bash" | wc -l

ubuntu      1373  0.0  0.3   7872  3584 ?        Ss   05:23   0:00 bash
root        1740  0.0  0.4   8132  4224 pts/2    S+   05:23   0:00 bash
root        8927  0.0  0.2   8132  2556 pts/2    S    05:33   0:00 bash
root        8994  0.0  0.2   8132  2560 pts/2    S    05:33   0:00 bash
root        8996  0.0  0.2   8132  2560 pts/2    S    05:33   0:00 bash
root        8997  0.0  0.2   8132  2560 pts/2    S    05:33   0:00 bash
root        8998  0.0  0.2   8132  2560 pts/2    S    05:33   0:00 bash
root        8999  0.0  0.2   8132  2560 pts/2    S    05:33   0:00 bash
root        9209  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9231  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9232  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9244  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9245  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9246  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9247  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9248  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash
root        9250  0.0  0.2   8132  2560 pts/2    S    05:34   0:00 bash

20개 가량

namespace

프로세스별로 별도의 커널 자원을 분할하는 리눅스 커널의 기능으로 리눅스 컨테이너 기술의 근간

격리대상: 프로세스ID, Network, File system, user정보 등

cgroup how much you can use namespaces what you can see

PID 네임스페이스: Process ID정보 격리, 네임스페이스 외의 다른 프로세스에 접근 불가능
Network 네임스페이스: 네트워크 장치, IP주소, 포트, 라우팅 테이블 등의 네트워크 리소스 격리
User 네임스페이스: 프로세스 별 UID, GID 정보 격리
Mount 네임스페이스: 프로세스별로 마운트되는 파일시스템 격리

Mount 네임스페이스

새로운Mount 네임스페이스에서 마운트한 위치에 파일 생성

# unshare 명령어 확인
$ man unshare

# 프로세스 확인
$ echo $$
29687

# 새로운 mount namespace 생성
$ unshare -m /bin/bash

# 새로운 쉘 확인
$ echo $$
32123

# 프로세스 확인
$ ps auxf

# /mnt에 tmpfs(메모리에 생성되는 가상 파일 시스템) 마운드하여 임시 스토리지로 사용
$ mount -t tmpfs tmpfs /mnt

$ cd /mnt

$ echo "Hello" > hello.txt

# 새로운 터미널에서 확인하면 namespace가 다르기 때문에 해당파일 접근할 수 없음. 따라서 해당 namespace PID로 접근
$ nsenter -t 32123 -a
$ ls -l /mnt
total 4
-rw-r--r-- 1 root root 6 Sep  4 06:03 hello.txt

PID 네임스페이스

PID 네임스페이스 생성 후 프로세스 트리 정보 확인, 독립된 프로세스 환경임을 확인

$ echo $$
29687

# 새로운 PID namespace 생성(순서대로 PID, mount, IPC, child process)
$ unshare -pmif

$ echo $$
1

# 1번 프로세스이므로 상위 5개 확인
$ ps aux | head -n5

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.1  1.3  22096 13204 ?        Ss   05:21   0:04 /sbin/init
root           2  0.0  0.0      0     0 ?        S    05:21   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        S    05:21   0:00 [pool_workqueue_release]
root           4  0.0  0.0      0     0 ?        I<   05:21   0:00 [kworker/R-rcu_g]

# 해당 정보는 profile 시스템에서 읽어야 하므로 새로운 namespace에 맞는 proc filesystem 마운트

$ mount -t  proc none /proc
$ ls /proc

# 프로세스 재확인
$ ps aux | head -n5
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.5   9192  5376 pts/4    S    06:19   0:00 -bash
root          17  0.0  0.4  11320  4352 pts/4    R+   06:24   0:00 ps aux
root          18  0.0  0.1   6124  1792 pts/4    S+   06:24   0:00 head -n5

Network 네임스페이스

새로운 Network 네임스페이스 생성 후 생성된 네임스페이스 간의 네트워크 연결 확인(Docker/Bridge 형태)

VETH(Virtual Ethernet Pair): 로컬 이더넷 터널로 네트워크 네임스페이스 간 연결 가능하게 하며 페어로 구성됨

CETH(Container Ethernet Interface): 컨테이너 내의 가상 네트워크 인터페이스

$ sudo su

# network namespace 생성
$ ip netns add ns0
$ ip netns add ns1

$ ip netns list
ns0
ns1

# net namespace 안에 어떤 link 있는지 확인
$ ip link # root
$ ip netns exec ns0 ip link # ns0

# network namespace 내의 인터페이스 확인(ns0 에서 실행됨)
$ ip netns exec ns0 ip link
1: lo:  mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

# 구동
$ ip netns exec ns0 ip link set lo up
$ ip netns exec ns1 ip link set lo up

# bridge 확인
$ ip link show type bridge

# 호스트에 새로운 브릿지 네트워크 br0 생성 후 구동
$ ip link add br0 type bridge
$ ip link set br0 up
$ ip link show type bridge
4: br0:  mtu 1500 qdisc noqueue state DOWN mode DEFAULT group default qlen 1000
    link/ether d2:38:95:8f:5b:e3 brd ff:ff:ff:ff:ff:ff

# 브릿지 네트워크에 IP 설정  
$ ip addr add 192.168.2.1/24 dev br0
$ ip addr
4: br0:  mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether d2:38:95:8f:5b:e3 brd ff:ff:ff:ff:ff:ff
    inet 192.168.2.1/24 scope global br0
       valid_lft forever preferred_lft forever

# 확인
$ ping -c 2 192.168.2.1
PING 192.168.2.1 (192.168.2.1) 56(84) bytes of data.
64 bytes from 192.168.2.1: icmp_seq=1 ttl=64 time=0.029 ms
64 bytes from 192.168.2.1: icmp_seq=2 ttl=64 time=0.033 ms

--- 192.168.2.1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1045ms
rtt min/avg/max/mdev = 0.029/0.031/0.033/0.002 ms

# veth 페어 생성
$ ip link add veth0 type veth peer name ceth0
$ ip link add veth1 type veth peer name ceth1

# veth를 master br0에 연결&구동
$ ip link set veth0 master br0
$ ip link set veth1 master br0

$ ip link set veth0 up
$ ip link set veth1 up

# ceth를 namespace에 연결&구동
$ ip link set ceth0 netns ns0
$ ip link set ceth1 netns ns1

$ ip netns exec ns0 ip link set ceth0 up
$ ip netns exec ns1 ip link set ceth1 up

# 구동 확인
$ ip netns exec ns1 ip link
1: lo:  mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
7: ceth1@if8:  mtu 1500 qdisc noqueue state UP mode DEFAULT group default qlen 1000
    link/ether 7a:06:0f:4e:51:72 brd ff:ff:ff:ff:ff:ff link-netnsid 0

# IP가 없으므로 지정
$ ip netns exec ns0 ip addr add 192.168.2.2/24 dev ceth0
$ ip netns exec ns1 ip addr add 192.168.2.3/24 dev ceth1

# IP 확인
$ ip netns exec ns0 ip addr
5: ceth0@if6:  mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether 8e:20:ca:4e:dd:ed brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 192.168.2.2/24 scope global ceth0
       valid_lft forever preferred_lft forever

# 네임스페이스 간 통신 확인
$ ip netns exec ns0 ping -c 2 192.168.2.3

!!!!!!!!!!!!!!!!!!!!!!!!
# FORWARD 정책 확인
$ iptables -L FORWARD
Chain FORWARD (policy DROP 16 packets, 1344 bytes)

# DROP이므로 ACCEPT로 바꿔줘야함
$ iptables -P FORWARD ACCEPT
Chain FORWARD (policy ACCEPT)
!!!!!!!!!!!!!!!!!!!!!!!!

union mount filesystem

하나의 디렉토리 위치에 파일 시스템을 마운트하면?

$ mount -t tmpfs tmpfs /home/ubuntu/linux_campus

$ mount | grep tmpfs
tmpfs on /home/ubuntu/linux_campus type tmpfs (rw,relatime,inode64)

$ ls -l linux_campus/
total 0

$ umount /home/ubuntu/linux_campus

$ ls -l linux_campus/
total 20
drwxrwxr-x  4 ubuntu ubuntu 4096 Sep  3 15:46 Part2

Union mount: 하나의 디렉토리 위치에 여러개의 디렉토리를 마운트하면 하나의 통합된 디렉토리처럼 보이게 하는 방법

Image Layer: 마지막 레이어를 제외하고 Read-Only CoW(Copy-on-write): 변경된 파일만 저장

Docker 적용? 스토리지 드라이버 e.g. overlay Overlay FS: 하나의 파일 시스템을 다른 파일 시스템 상단에 overlay

OverylayFS로 Union mount

lower1, lower2, upper(writable), merged(실제 사용), work(file system에서 관리목적)

$ mkdir /tmp/{lower1,lower2,upper,merged,work}

$ echo "lower1 a" > /tmp/lower1/a.txt
$ echo "lower1 b" > /tmp/lower1/b.txt
$ echo "lower2 a" > /tmp/lower2/a.txt
$ echo "lower2 c" > /tmp/lower2/c.txt

# read only overlay(/tmp/merged)
$ mount -t overlay overlay overlay -o lowerdir=/tmp/lower1:/tmp/lower2 /tmp/merged

$ mount | grep overlay
overlay on /tmp/merged type overlay (ro,relatime,lowerdir=/tmp/lower1:/tmp/lower2,redirect_dir=on,nouserxattr)

$ cat /tmp/merged/a.txt
lower1 a

$ echo "hello ro" > /tmp/merged/d.txt
bash: /tmp/merged/d.txt: Read-only file system

$ umount /tmp/merged

# Read/Write 갖는 uppder지정
$ mount -t overlay overlay -o lowerdir=/tmp/lower1:/tmp/lower2, upperdir=/tmp/upper,workdir=/tmp/work /tmp/merged

# RW 확인
$ mount | grep overlay
overlay on /tmp/merged type overlay (rw,relatime,lowerdir=/tmp/lower1:/tmp/lower2,upperdir=/tmp/upper,workdir=/tmp/work,uuid=on,nouserxattr)

$ echo "Hello World" > /tmp/merged/hello.txt

$ cat /tmp/merged/hello.txt
Hello World

$ ls -l /tmp/upper
total 4
-rw-r--r-- 1 root root 12 Sep  4 09:07 hello.txt

$ umount /tmp/merged

# busy는, 해당 디렉토리에 들어가 있어서 발생함. 빠져나와서 umount

docker union mount test

$ docker pull nginx

# 데몬으로 실행
$ docker run --rm -d nginx

$ mount | grep overlay

# rw, lowerdir에 여러 디렉토리 지정됨을 확인, uppderdir에 하나의 디렉토리 지정 확인, workdir 지정 확인

# 컨테이너 기반 가상화

Tue, 03 Sep 2024 00:57:35 GMT

인프라 환경의 변화

온프레미스(직접 구매/설치/관리) -> 클라우드(필요한 만큼 할당 및 비용지불/API와 SDK를 이용한 컴퓨팅 자원의 자동화)

가상머신(하드웨어 가상화 기반/스케일 업아웃을 가상머신 단위로 확장) -> 컨테이너(운영체제 기반 가상화로 컨테이너 패키지 가상화/빠른 확장성/자원 격리)

쉘스크립트 -> 자동화 도구(추상화된 형태로 자원을 기술)

리눅스 명령의 이해(서버 직접 접속/리눅스 명령어 기반으로 분석) -> 리눅스 이해(중앙 집중화된 로깅과 모니터링/수집데이터 기반 장애 판단)

컨테이너

애플리케이션의 코드, 종속성, 실행환경을 하나의 패키지로 구성 컨테이너 런타임이 있는 곳이라면 동일한 패키지가 실행됨

VM과의 비교

하이퍼바이저(가상머신 모니터) 호스트 컴퓨터에서 다수의 운영체제를 동시에 실행하기 위한 논리적 플랫폼 CPU/메모리/스토리지 등 리소스 에뮬레이션해 한 대의 서버에 독립된 여러 머신환경 구성

컨테이너는 애플리케이션 구동에 필요한 모든 종속성을 포함한 소프트웨어 패키지를 운영체제 위에서 가상화. 컨테이너는 리눅스 관점에서 하나의 프로세스로 대표적인 엔진은 docker

Host OS를 공유하기 때문에 단일 OS만 사용 가능

Docker

ec2 인스턴스 최초실행 후 환경세팅

# ec2 인스턴스 가동 후 OS 확인
$ cat /etc/os-release

PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"

# 패키지 리스트 업데이트
$ sudo apt-get update

# 필수 패키지 설치
$ sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release

# docker 공식 GPG키 추가
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# docker 저장소 설정
$ echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 패키지 리스트 다시 업데이트
$ sudo apt-get update

# docker 엔진 설치
$ sudo apt-get install docker-ce docker-ce-cli containerd.io

# docker 설치 확인
$ sudo docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
c1ec31eb5944: Pull complete
Digest: sha256:53cc4d415d839c98be39331c948609b659ed725170ad2ca8eb36951288f81b75
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

다중 운영체제 이미지 확인

# 단독작업하니 root로그인
$ sudo su

# fedora image 다운로드. default 태그인 latest 설정됨
$ docker pull fedora

# image 확인
$ docker images

REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
fedora        latest    9146ee7fcff0   7 days ago      222MB
hello-world   latest    d2c94e258dcb   16 months ago   13.3kB

# fedora image로 컨테이너를 구동해 os를 확인하고, rm 옵션으로 바로 모든 자원 제거
$ docker run --rm fedora cat /etc/os-release

NAME="Fedora Linux"
VERSION="40 (Container Image)"
ID=fedora
VERSION_ID=40
VERSION_CODENAME=""
PLATFORM_ID="platform:f40"
PRETTY_NAME="Fedora Linux 40 (Container Image)"

# 컨테이너가 바로 종료되어 구동중인 컨테이너가 없음을 확인
$ docker ps

CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

즉 docker는 커널이 여러 격리된 사용자 공간 인스턴스의 존재를 허용하는 운영체제 패러다임

# 호스트OS(Ubuntu 24.04) 커널정보 확인
$ uname -a

Linux ip-172-31-7-80 6.8.0-1012-aws #13-Ubuntu SMP Mon Jul 15 13:40:27 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux

# 컨테이너OS(fedora) 커널정보 확인
$ docker run --rm fedora uname -a

Linux aa12c5aa7385 6.8.0-1012-aws #13-Ubuntu SMP Mon Jul 15 13:40:27 UTC 2024 x86_64 GNU/Linux

# 동일한 6.8.0-1012-aws 커널

리눅스와 리눅스 배포판, 리눅스 커널의 차이

리눅스 배포판: Ubuntu, Redhat, CentOS = 리눅스 커널 + 컴포넌트(e.g. 윈도우시스템, 데스크톱 환경, 서비스 데몬, 패키지 매니저, 애플리케이션 등) 패키징된 산물

리눅스 커널: 하드웨어 자원을 관리하고 추상화하여 프로세스에게 할당하고 관리하는 역할을 수행

Ubuntu 호스트 Docker에 Amazon Linux 배포판 실행?

-> 리눅스 커널 + 컴포넌트(윈도우 시스템X, 데스크톱 환경X, 서비스 데몬X, 패키지 매니저O, 애플리케이션O)

Ubunt 호스트 Docker에 Windows 컨테이너 실행?

-> 커널이 다르기 때문에 동작하지 않음. Linux환경을 지원하는 Windows 이미지도 존재하지 않음. 이미지 pull이 실패

Windows 호스트에 Ubuntu 컨테이너 / MacOS 호스트에 Ubuntu 컨테이너 동작?

가능하지만, 추가적인 레이어가 더 구성됨.(가상화 환경 + LinuxKit) 따라서 Docker는 Linux환경이 권장됨..

Alpine Linux 이미지

보안/간편성/리소스 효율을 위해 디자인된 리눅스 배포판

fedora 기반으로 아래의 내용 수행 yum(Yellodog Update Modified): 레드햇 계열의 리눅스 배포판에서 사용하는 프로그램(패키지) 설치 관리 도구

# fedora package update 실행
$ docker run --rm fedora yum update -y

$ mkdir base_image && cd base_image

# Alpine Linux용 루트파일 다운로드
$ wget https://github.com/alpinelinux/docker-alpine/raw/fc965e3222f368bea8e07c1c1da70b6928281a76/x86_64/alpine-minirootfs-3.15.4-x86_64.tar.gz

$ ls -haltr

total 2.7M
drwxr-x--- 5 ubuntu ubuntu 4.0K Sep  3 01:56 ..
drwxr-xr-x 2 root   root   4.0K Sep  3 02:08 .
-rw-r--r-- 1 root   root   2.7M Sep  3 02:08 alpine-minirootfs-3.15.4-x86_64.tar.gz

$ mkdir alpine_root

$ tar zxf alpine-minirootfs-3.15.4-x86_64.tar.gz -C alpine_root/

$ ls -l alpine_root

total 68
drwxr-xr-x  2 root root 4096 Apr  4  2022 bin
drwxr-xr-x  2 root root 4096 Apr  4  2022 dev
drwxr-xr-x 16 root root 4096 Apr  4  2022 etc
drwxr-xr-x  2 root root 4096 Apr  4  2022 home
drwxr-xr-x  7 root root 4096 Apr  4  2022 lib
drwxr-xr-x  5 root root 4096 Apr  4  2022 media
drwxr-xr-x  2 root root 4096 Apr  4  2022 mnt
drwxr-xr-x  2 root root 4096 Apr  4  2022 opt
dr-xr-xr-x  2 root root 4096 Apr  4  2022 proc
drwx------  2 root root 4096 Apr  4  2022 root
drwxr-xr-x  2 root root 4096 Apr  4  2022 run
drwxr-xr-x  2 root root 4096 Apr  4  2022 sbin
drwxr-xr-x  2 root root 4096 Apr  4  2022 srv
drwxr-xr-x  2 root root 4096 Apr  4  2022 sys
drwxrwxrwt  2 root root 4096 Apr  4  2022 tmp
drwxr-xr-x  7 root root 4096 Apr  4  2022 usr
drwxr-xr-x 12 root root 4096 Apr  4  2022 var

# image build를 위한 Dockerfile 생성
$ vim Dockerfile

FROM fedora
COPY ./alpine_root /
CMD ["/bin/sh"]

# 현시점 root디렉토리를 전부 copy하면 타겟디렉토리와 충돌발생하여 /bin 지정해주었음
COPY ./alpine_root/bin /bin/

# alpine image 생성(현재 디렉토리의 Dockerfile과 하위 디렉토리를 재료로)
$ docker build --tag alpine_fedora .

$ docker images | grep alpine_fedora

alpine_fedora   latest    e5017f9356b5   34 seconds ago   223MB

# 기존의 fedora는 yum으로 가능하지만, alpine은 apk 명령어로 구동 가능(루트파일을 엎어쳤기 때문에)
# 하지만 ... /bin만 변경되었기 때문에 되지는 않는다. 개념만 ..
$ docker run --rm alpine_fedora apk update

에코시스템

CNCF: 벤더 중립적인 클라우드 지향 오픈소스 프로젝트 관리재단

클라우드 네이티브: 퍼블릭/프라이빗/하이브리드 클라우드 환경에서 확장 가능한 형태로 빠르고 민첩하게 애플리케이션을 빌드하고 실행하는 것을 목표로 함

OCI(Open Container Initiative) 컨테이너 형식과 런타임의 업계 표준 구성(docker 대표적)

OCI Runtime 컨테이너 실행에 필요한 저수준 컨테이너 런타임

runc OCI 스펙에 따라 컨테이너를 생성 및 실행하기 위한 CLI 도구

CRI(Container Runtime Interface) 쿠버네티스에서 다양한 컨테이너 런타임을 사용할 수 있도록 하는 플러그인 인터페이스

CRI runtime 컨테이너 실행에 필요한 고수준 컨테이너 런타임

# 파이썬 자료구조

Sun, 25 Aug 2024 09:23:14 GMT

List

대표적인 열거형 자료구조
순서대로 값 저장
배열과 유사하지만, 각 요소들이 다른 데이터 타입으로 구성될 수 있음
확장에 있어서 자유로움

empty_list = []
my_list = [1, 2, 3, 4]

요소: 리스트의 각 항목
문자열에서처럼, 리스트[인덱스]로 접근하며 슬라이싱 가능

>>> my_list = [1, 2, 3, 4]
>>> my_list[2]
3
>>> my_list[3:]
[4]
>>> my_list[-1]
4

복합 리스트: 리스트의 요소로 리스트를 사용할 수 있음
문자열과 동일하게 연산 가능

[1, 2] + [a, b] # [1, 2, a, b]
[1, 2] * 2 # [1, 2, 1, 2]

len(['l', 'i', 's', 't']) # 4
max([1, 2, 3, 5]) # 5

s = ['l', 'i', 's', 't']
s.index('i') # 1
't' in s # True
'a' not in s # True
s.count('1') # 1

Tuple

열거형 자료구조
순서대로 값을 저장
배열과 유사
불변(str:새로운 저장공간에 문자열이 할당됨, tuple) / 가변(list)

괄호 () 를 사용, 각 항목은 쉼표로 구분

empty_tuple = ()
single_tuple = (1, )
my_tuple = (1, 2, 3, 4)

리스트와 동일하게 튜플[인덱스]로 접근하며 슬라이싱 가능
```
>>> my_tuple = (1, 2, 3, 4)
>>> my_tuple[1]
2
>>> my_tuple[:2]
(1, 2)
```
리스트와 동일하게 +, * 연산 가능

s = ('l', 'i', 's', 't')
len(s) # 4
s.index('i') # 1
't' in s # True
'x' not in s # True

패킹: 여러 값을 하나의 튜플로 묶는 것
```
tp = 1, 2, 3
```
언패킹: 하나의 튜플의 값을 여러 변수에 할당하는 것
```
tp = (1, 2, 3)
x, y, z = tp # x=1, y=2, z=3
```

x, _, _, y, z = (1, -1, 0, 2, 5)

val1, *vals, val2, val3 = (1, 2, 3, 4, 5) print(vals) [2, 3] # 리스트로 반환


## Dictionary
---

- 매핑 자료구조
- Key/Value
- 해시 테이블과 유사

- 중괄호 `{}`를 사용
- 각 요소의 키와 값은 콜론 `:`으로 구분
- 각 요소 간에는 쉼표 `,`으로 구분

```python
empty_dict = {}
my_dict = {'one': 1, 'two': 2, 'three': 3}

dictionary[key] 로 접근

>>> my_dict = {'one': 1, 'two': 2, 'three': 3}
>>> my_dict
{'one': 1, 'two': 2, 'three': 3}
>>> my_dict['one']
1
>>> my_dict['four']
KeyError: 'four'

key는 불변 타입만 사용 가능(list 불가/tuple 가능)
value는 제약 없음
keys(): 저장된 key 목록
values(): 저장된 value 목록
items(): 저장된 (key, value) 쌍

Set

집합 자료구조
중복 불가능
각 요소들이 해싱되어 저장되며 순서를 가지지 않음
인덱스를 통한 요소 조회, 슬라이싱 불가

{} 또는 set() 을 통해 정의

my_set = {1, 2, 2, 3} # {1, 2, 3}
good_set = set("Good") # {"G", "o", "d"}
empty_set = set()

# AWS Cloud Practitioner_오답정리2

Sat, 17 Aug 2024 08:45:33 GMT

Q. EC2 인스턴스의 공급과 수요에 따라 가격을 조정하는 구조

A. 스팟 인스턴스 예비 컴퓨팅 용량으로 스팟 인스턴스 요청을 생성해 사용 온디맨드 인스턴스 실행하는 인스턴스 유형에 따라 시간 또는 초 단위로 컴퓨팅 용량 비용 지불

Q. 마이그레이션이 안전하고 효율적인지

A. 보안 관점

Q. AWS Config의 이점

A. 규제 요구사항 및 모범 사례 준수 촉진 AWS 리소스의 구성 기록을 기록하고 내부 정책 및 모범 사례를 준수하는지 평가

Q. IAM의 계정 별칭

A. 고객의 계정에 대한 웹 주소의 계정 ID

Q. EBS 지원 EC2 인스턴스를 시작할 때 필요하지 않은 것

A. 탄력적 IP주소 필요: VPC 및 서브넷 정의, EBS루트볼륨, 보안그룹

Q. AWS CloudTrail에 대한 설명으로 옳은 것

A. AWS Management Console에서 추적을 생성하면 기본적으로 추적이 모든 AWS 리전에 적용됨 AWS 계정의 거버넌스/규정 준수/운영 감사/위험 감사를 지원하는 서비스 모든 고객에 기본적으로 활성화 첫 번째 관리추적에 대해서는 비용을 청구하지 않음

Q. 비즈니스 커뮤니케이션 채널과 고객 서비스 경험을 개선하는 서비스

A. Amazon Chime, Amazon Connect Amazon Chime 온라인 회의 Amazon Connect 음성/채팅 AWS Transfer family SFTP, FTPS 프로토콜을 사용해 Amazon S3/EFS로 기업 간 파일을 반복적으로 전송

Q. Amazon SQS 사용 이유

A. 시스템 특정부분 분리/애플리케이션 이벤트 또는 메시지를 위한 내구성 있는 저장소 Amazon SWF 워크플로우에서 특정작업 자동화

Amazon RedShift 대규모 데이터 세트 저장 및 분석을 위해 설계된 완전 관리형 페타바이트 규모의 클라우드 기반 데이터 웨어하우스 제품

Neptune 그래프 데이터베이스 서비스

S3 객체 스토리지 서비스로 정적 웹사이트 호스팅/데이터 저장 및 보관

Macie 기계학습 및 패턴일치를 사용해 AWS에서 중요한 데이터를 검색하고 보호하는 완전 관리형 데이터 개인정보 보호 서비스

Glue 고객이 분석을 위해 데이터 ETL 지원 서비스

Polly TTS 서비스(텍스트를 음성으로 변환)

Elastic Beanstalk 개별 리소스 자체를 프로비저닝하지 않고 애플리케이션 배포

AWS의 책임 호스트 운영체제 패치/인프라 실행 하드웨어,소프트웨어,네트워킹 및 시설 보호

고객의 책임 게스트 운영체제 패치 및 관리/인스턴스에 설치한 애플리케이션 관리/보안그룹 관리

AWS Opsworks Puppet의 관리형 인스턴스를 제공하는 구성 관리 서비스

AWS CloudFormation JSON/YAML 코드를 통해 인프라 구성

Service Catalog 배포되는 IT서비스를 중앙에서 관리

AWS CloudFront 짧은 지연시간/빠른 전송속도로 전세계 고객에게 데이터/애플리케이션/API 제공하는 콘텐츠 전송 네트워크(CDN)

AWS Shield AWS에서 실행되는 애플리케이션을 보호하는 관리형 DDoS보호 서비스

WAF 웹 어플리케이션 방화벽

GuardDuty AWS 계정과 워크로드 보호하기 위해 모니터링하는 위협 탐지 서비스

Detective 잠재적인 보안 문제나 의심스러운 활동의 근본원인을 분석, 조사 및 식별

Sumerian 3D, 증강현실(AR), 가상현실(VR) 애플리케이션 생성 및 실행

Cognito 앱 리소스에 액세스하기 위한 임시 보안 자격 증명

CloudHSM 모든 데이터 암호화 작업에 하드웨어 장치

Secrets Manager 애플리케이션/서비스/IT리소스 액세스하는데 필요한 암호 보호

AWS GuardDuty 인프라 및 리소스에 대한 위협 탐지

AWS Shield DDoS공격으로부터 보호

Amazon Inspector 애플리케이션에서 보안 모범 사례 위반 및 취약성 검사

WAF 애플리케이션으로 들어오는 요청 모니터링

# AWS Cloud Practitioner_오답정리1

Fri, 16 Aug 2024 11:17:33 GMT

Q. 공간이 제한된 환경에서 사용할 수 있는 테라바이트 급 데이터 스토리지를 확보하고 AWS로 전송할 수 있는 서비스

A. AWS Snowcone 기존 데이터 센터 외부에서 사용할 수 있도록 제작됨 엣지 컴퓨팅, 엣지 스토리지 및 데이터 전송장치로 구성

AWS Data Pipeline 실외 위치에 데이터 스토리지 제공

AWS SnowMobile 공간이 제한된 환경에서는 사용할 수 없음

AWS Transit Gateway Amazon VPC와 온프레미스 네트워크를 단일 게이트웨이에 연결할 수 있게 해주는 서비스

Q. 단 며칠만에 테스트 환경을 가동하고 서비스 출시시간 단축하는 AWS 클라우드의 이점

A. 민첩성 클라우드 컴퓨팅은 IT리소스를 인터넷을 통해 온디맨드로 제공하고 사용한 만큼 비용 지불하는 것을 뜻하며, 물리적 데이터 센터와 서버를 구입/소유/관리하는 대신 AWS와 같은 클라우드 공급자로부터 필요에 따라 컴퓨팅파워/스토리지/데이터베이스와 같은 기술 서비스에 액세스

빠르게 기술 서비스 배포/아이디어 구현 가능하며 자유롭게 실험하고 고객경험 차별화

탄력성 리소스를 사전에 오버 프로비저닝할 필요 없으며 실제로 필요한 만큼 프로비저닝 비용 절감 고정 비용을 가변 비용으로 전환/규모의 경제로 가변 비용이 저렴 몇 분만에 전세계 배포 새로운 지리적 리전으로 빠르게 확장 및 전세계 배포 최종 사용자와 애플리케이션을 가깝게 배치하면 지연 시간이 단축되고 사용자 경험 향상

Q. 클라우드 아키텍처에서 CI/CD(지속적 통합 및 전달) 구현시 애플리케이션 코딩, 구축, 테스트/배포를 위한 개발 및 도구 체인을 쉽게 설정할 수 있는 서비스

A. AWS CodeStar AWS에서 애플리케이션 신속하게 개발/구축/배포

AWS CodeCommit 기업이 안전하고 확장성이 뛰어난 프라이빗 Git 리포지토리를 쉽게 호스팅할 수 있게 해주는 완전관리형 소스제어 서비스 AWS CoreBuild 소스코드 컴파일/테스트 실행/배포 준비가 된 소프트웨어 패키지를 생성하는 완전관리형 빌드 서비스 AWS CodePipeline 릴리스 파이프라인 자동화 도구 전체 개발 및 지속적인 전달 도구 체인을 제공하지는 않음

Q. AWS Lambda 함수에 대한 추적/모니터링 기능 제공하는 서비스

A. AWS X-Ray Lambda를 사용해 구축된 서버리스 애플리케이션에 대한 요청 추적

Amazon Inspector AWS에 배포된 애플리케이션의 보안 규정 및 준수를 개선하는 보안 평가 서비스 Amazon Macie 머신러닝을 통해 AWS의 민감한 데이터를 자동으로 검색/분류/보호하는 보안 서비스 AWS Shield AWS에서 실행되는 애플리케이션을 보호하는 관리형 DDoS(분산 서비스 거부) 보호 서비스

Q. AWS 계정에서 이루어진 모든 활동 추적하는 방법

A. AWS CloudTrail에서 다중 리전 추적 생성 AWS 계정!!!의 거버넌스/규정 준수/운영 감사/위험 감사 지원 서비스 인프라 전반의 작업과 관련된 계정 활동을 기록하고 지속적으로 모니터링

Amazon CloudWatch Logs 고객 계정의 사용자 작업과는 관련 없음 애플리케이션/AWS 서비스 로그를 단일 서비스로 집중

Q. 업데이트 및 보안 패치를 포함하여 게스트 운영 체제에 대한 책임과 관리를 맡는 AWS에서 새 데이터베이스 시작 요구

A. Amazon EC2 고객은 게스트 운영체제/애플리케이션 소프트웨어 및 AWS 제공 보안 그룹 방화벽 구성에 대한 책임과 관리 EC2는 클라우드에서 안전하고 크기 조정이 가능한 컴퓨팅 용량을 제공하는 웹 서비스 인스턴스를 제어할 수 있으므로 원하는 데이터베이스를 설치하고 필수 업데이트 및 보안 패치를 포함해 운영체제 관리

Amazon DocumentDB MongoDB 워크로드 지원 완전 관리형 문서 데이터베이스 서비스 Amazon Aurora 사용자의 수동 개입 없이 하드웨어 프로비저닝/데이터베이스 설정/패치와 백업과 같이 시간이 많이 소요되는 관리작업 자동화하는 완전관리형 서비스 Amazon DynamoDB 완전 관리형 데이터베이스 서비스이므로 기본 게스트 운영체제를 관리하거나 업데이트/보안패치 적용할 필요 없음

Q. EC2 인스턴스의 방화벽 역할 서비스

A. Security Group

Elastic Network Interface 가상 네트워크 카드를 나타내는 VPC의 논리적 네트워크 구성 요소 VPC 가상 네트워크에서 AWS 리소스를 시작할 수 있는 AWS 클라우드의 논리적으로 격리된 섹션을 프로비저닝 Network ACL Access control list. 인바운드/아웃바운드 트래픽 제어해 서브넷 보호

Q. AWS 글로벌 인프라 구성 요소 중 각각 중복된 전원,네트워킹 및 연결 기능을 갖추고 별도의 시설에 보관되어 있는 하나 이상의 개별 데이터 센터로 구성되어 있는 것

A. 가용 영역 리전은 여러 가용영역이 있는 전 세계의 물리적 위치 AZ는 하나 이상의 개별 데이터 센터로 구성되며 각 데이터 센터는 별도의 시설에 예비 전원/네트워킹 및 연결 기능을 갖추고 있음

VPC 사용자가 정의한 가상 네트워크에서 AWS 리소스를 시작할 수 있는 AWS 클라우드의 논리적으로 격리된 섹션을 프로비저닝할 수 있는 서비스 엣지 로케이션 CloudFront가 모든 위치의 사용자들에게 더 빠른 전송을 위해 콘텐츠 사본을 캐시하는데 사용하는 사이트

Q. 솔루션은 재해 발생시 데이터 손실을 최소화하면서 AWS에서 현재 환경을 복제하는 빠르고 효율적인 방법을 제공해야 함. Disaster Recovery 솔루션을 위해 어떤 도구를 채택해야 하는가?

A. AWS Elastic Disaster Recovery 저렴한 스토리지/최소한의 컴퓨팅 및 특정 시점 복구를 사용해 온프레미스 및 클라우드 기반 애플리케이션을 빠르고 안정적으로 복구 AWS Migration Hub 마이그레이션 상태 모니터링 AWS Database Migration Service 데이터베이스를 AWS로 마이그레이션 AWS Application Migration Service 애플리케이션을 AWS로 마이그레이션

Q. 자가 치유가 가능하고 처리량 높은 데이터베이스

A. Amazon Aurora 고급 상용 데이터베이스의 안정성과 속도/오픈소스 데이터베이스의 단순성 및 비용 효율성을 결합한 관계형 데이터베이스 엔진으로 자가복구

Q. AWS 클라우드에 디렉터리를 설정하거나 AWS 리소스를 기존 온프레미스 Microsoft Active Directory와 연결할 수 있는 서비스

A. AWS Directory Service 디렉터리 인식 워크로드와 AWS 리소스가 AWS클라우드에서 관리형 Active Directory를 사용할 수 있음 AWS Direct Connect 기업이 기존 연락 센터보다 저렴한 비용으로 음성/채팅을 통해 고객 서비스를 제공할 수 있도록 돕는 옴니채널 클라우드 연락센터 서비스 AWS Site-to-Site VPN 온프레미스와 AWS 연결 설정

Q. 여러 리소스로 트래픽을 라우팅하고 각 리소스로 라우팅되는 트래픽의 양을 결정하려면 어떤 AWS Route 53 라우팅 정책?

A. 가중치 기반 라우팅 정책 사용자가 지정하는 비율에 따라 여러 리소스로 트래픽을 라우팅하는 경우 단순 라우팅 정책 도메인에 대해 특정 기능을 수행하는 하나의 리소스만 있는 경우 장애 조치 라우팅 정책 액티브-패시브 장애 조치 구성 지연 시간 라우팅 정책 여러 AWS 리전에 리소스가 있고 최상의 지연 시간 제공 프라이빗 호스팅 영역에서 레코드 생성

Q. Business Support Plan

A. 프로덕션 시스템 다운시 1시간 이내 응답 Basic-Developer-Business-Enterprise Business는 장애시 4시간/다운시 1시간 Enterprise는 (프로덕션)장애시 4시간/(비즈니스)장애시 1시간/다운시 15분/일반 안내에 24시간 응답

Q. 저렴한 비용으로 ETL 및 분석을 수행할 수 있도록 Apache Spark와 같은 다양한 비즈니스 인텔리전스 도구를 지원하는 AWS 서비스

A. Amazon EMR 기업/연구원/개발자가 방대한 양의 데이터를 쉽고 비용 효과적으로 처리할 수 있도록 지원하는 웹 서비스

Q. AWS CLI를 통해 클라우드 리소스를 관리하는 데 사용되는 액세스 키와 연결된 IAM 자격 증명

A. IAM User 액세스 키는 IAM 사용자 또는 AWS 계정 루트 사용자에 대한 장기 보안 인증 IAM Policy 정책을 생성하고 이를 IAM 자격 증명 또는 AWS 리소스와 연결 IAM Group IAM 사용자 모음 IAM Role 액세스 키와 연결되지 않음

Q. 기존 서버 바인딩 소프트웨어 라이선스를 사용해 규정 준수 요구사항을 충족하고 비용 절감하는 EC2 구매 옵션

A. 전용 호스트 EC2 인스턴스 용량을 사용자 전용으로 제공하는 물리적 서버 인스턴스를 동일한 물리적 서버에 일관적으로 배포함으로 기존 서버 바인딩 소프트웨어 라이선스 사용

Q. 수백 개의 EC2 인스턴스에서 동시에 액세스하여 기존 파일에 데이터를 추가하는 스토리지 서비스

A. Amazon Elastic File System 다수의 인스턴스에 파일 시스템 인터페이스/액세스/스토리지 제공 Amazon Elastic Block Store 고성능 블록 스토리지 서비스로 여러 인스턴스에스 액세스할 수 없음 Amazon Simple Storage Service 확장성/가용성/보안 제공 객체 스토리지 서비스 Instance Store 인스턴스에 임시 블록 스토리지 제공 호스트 컴퓨터에 물리적으로 연결된 디스크에 위치

Q. WebSocket을 사용해 경로 기반 라우팅/호스트 기반 라우팅 지원하는 Elastic Load Balancer 유형

A. Application Load Balancer

Network Load Balancer TCP/UDP 트래픽에 적합 Classic Load Balancer 기본 Gateway Load Balancer 레이어 3/4, 패킷의 어떤 부분도 변경하지 않는 투명한 범프인더와이어 장치

Q. 빠르게 변화하는 데이터를 저장하고 읽기/쓰기 지연 시간이 짧은 경우

A. Amazon RDS/EBS Amazon S3 다양한 종류의 정보 저장에 최적 Amazon Snowball 하드웨어 장치

Q. 소셜ID 제공업체 및 엔터프라이즈 ID 제공업체와의 로그인을 지원하는 기능을 갖춘 모바일 앱에 사용자 등록/로그인 액세스 추가하는 서비스

A. Amazon Cognito

Q. AWS Well-Architected 6대 원칙

A. 운영 우수성/보안/안정성/성능 효율성/비용 최적화/지속 가능성

Q. 고객이 AWS환경에서 잠재적인 보안 문제나 의심스러운 활동의 근본 원인을 분석/조사/식별할 수 있도록 지원하는 서비스

A. Amazon Detective

Amazon Inspector 애플리케이션 보안 수준에 중점 Amazon GuardDuty 기계학습 및 이상탐지를 사용해 손상된 EC2인스턴스/무단 API호출 식별 및 경고 AWS Security Hub 여러 AWS계정 및 서비스 전반에 걸쳐 보안/규정 준수 문제에 대한 중앙 집중식 가시성

Q. 가가가가

A. 나나나 다다다

Q. 가가가가

A. 나나나 다다다

Q. 가가가가

A. 나나나 다다다

Q. 가가가가

A. 나나나 다다다

# AWS Cloud Practitioner_module8,9,10,11

Fri, 16 Aug 2024 07:55:10 GMT

AWS free tier

상시 무료/12개월 무료/평가판

통합 결제

한 회사에서 여러 AWS계정 소유시 AWS Oraganizations 통해 관리 모든 계정을 집계해 대량 할인 요금을 적용받을 수 있음

AWS Cost Explorer

AWS에서 지출하는 비용을 시각적으로 확인/분석

AWS Support Plan

소규모 스타트업~~대기업/민간~~공공 부문 관계없이 모든 비즈니스가 특정 요구에 맞게 설계된 지원 옵션을 사용할 수 있음.

Basic Support

24시간 고객서비스
문서/벡서/지원 포럼
제한된 AWS Trusted Advisor검사 액세스
AWS Personal Health Dashboard

Developer tier

Basic 포함
이메일로 고객지원 액세스

Business tier

이전 항목 포함
Trusted Advisor을 통해 계정에 대한 전체 모범 사례 검사 제공
프로덕션 시스템에 장애가 있는 경우 클라우드 지원 엔지니어에 직접 전화
인프라 이벤트 관리

Enterprise tier

비즈니스 크리티컬 워크로드에 대해 15분 SLA
전담 기술지원관리자(TAM)

Well-Architected 5가지 구성 요소: 운영 우수성/보안/안정성/성능 효율성/비용 최적화

AWS Marketplace

AWS 아키텍처에서 실행되는 타사 소프트웨어를 검색/배포/관리하는 단계를 간소화하는 큐레이트된 디지털 카탈로그

AWS에서 실행되는 소프트웨어 검색/평가/구매/원클릭 배포

환자 기록을 보호하기 위한 솔루션을 구현하거나 기계 학습 모델을 사용하여 환자의 병력을 분석하고 잠재적 건강 위험을 예측하는 등 소프트웨어가 도움이 되는 사용 사례를 검토

# AWS Cloud Practitioner_module7_모니터링 및 분석

Fri, 16 Aug 2024 04:03:09 GMT

Amazon CloudWatch

모니터링: 시스템을 관찰하고 지표를 수집한 다음 데이터를 사용해 의사결정

시스템 성능 측정/문제 발생시 알림 제공/디버깅과 해결

AWS인프라와 AWS에서 실행하는 애플리케이션 실시간 모니터링 지표(리소스에 연결된 변수, 사용자 지정 가능)를 추적하고 모니터링하는 방식으로 작동하는 서비스

CloudWatch 경보를 통해 사용자가 지표에 대한 임계값 설정, 도달시 작업 트리거

중앙 위치에서 모든 지표에 액세스
분산 스택에 대한 지표를 통해 인사이트 시각화
MTTR(평균 문제 해결 시간) 단축, TCO(총 소유 비용) 개선

AWS CloudTrail

IT에서 트랜잭션을 감사하는 기능은 대부분의 규정준수 요소에서 필수적임

포괄적인 API 감사 도구로 모든 요청이 CloudTrail 엔진에 기록됨 안전한 S3 버킷에 무제한으로 저장 저장소 잠금과 같은 변조 방지 기능 사용

AWS Trusted Advisor

자동화된 조언 도구 5대 핵심 원칙을 기준으로 리소스 평가: 비용 최적화/성능/보안/내결함성/서비스 한도

각 범주의 조사에 대해 권장 작업 목록을 제공하고 AWS 모범 사례를 자세히 알아볼 수 있는 추가 자료 제공

녹색: 문제가 감지되지 않은 항목 수
주황: 권장 조사 항목
빨강: 권장 조치 수

# AWS Cloud Practitioner_module6_보안

Fri, 16 Aug 2024 04:02:40 GMT

공동 책임 모델

AWS는 클라우드 자체의 보안을 책임 고객은 클라우드 내부의 보안을 책임

단일 객체는 서로 다른 두 존재가 최종적으로 책임질 수 없지만 고객의 환경은 다른 부분들이 서로를 기반으로 구축된 일종의 모음

EC2 인스턴스는 물리적 공간 안에 있으며 데이터 센터의 보안 유지되어야 하며 고객의 인스턴스를 지원하는 네트워크와 하이퍼바이저가 있음. 고객 레이어에는 운영체제/애플리케이션/데이터

고객

고객 데이터
플랫폼, 애플리케이션, 자격 증명 및 액세스 관리
운영 체제, 네트워크, 방화벽 구성
클라이언트 측 데이터 암호화/서버 측 암호화/네트워킹 트래픽 보호

AWS

컴퓨팅/스토리지/데이터베이스/네트워킹
하드웨어/글로벌 인프라: 리전, 가용영역, 엣지 로케이션

사용자 권한 및 액세스

AWS 계정을 생성하면 AWS 계정 루트 사용자 자격 부여(계정의 소유자): 계정의 모든 리소스에 액세스/제어(데이터베이스, EC2, 블록체인 서비스 등)

따라서 MFA(Multi Factor authentication) 활성화해 이메일과 비밀번호 뿐 아니라 일회용 토큰까지 있어야 로그인할수 있도록 하는 것이 좋음

IAM(Identity and Access Management) 을 사용하면 액세스를 세부적으로 제어 가능

IAM 사용자를 만들면 기본적으로는 아무 권한도 없지만, 필요한 것에만 사용자 권한을 명시적으로 부여해야 함(최소 권한의 원칙) IAM 정책(사용자가 할 수 있거나 할 수 없는 API호출을 설명하는 JSON 문서)을 IAM 사용자에 연결

Effect: Allow/deny Action: AWS API호출 나열 Resource: 특정 API호출에 대한 AWS 리소스 나열

IAM 그룹으로 분류(사용자 모음)해 그룹에 IAM 정책을 할당 가능

역할: 관련 권한 허용 또는 거부, 일시적으로 역할 할당, 사용자 이름 또는 암호가 없으며 맡으면 임시 권한을 이용할 수 있는 자격 증명. 맡으면 이전 권한 폐기하고 해당 역할의 권한 수임

AWS Organizations

개발자는 개발 리소스 액세스/회계 직원은 결제 정보 액세스

여러 AWS계정을 관리하는 중앙 위치: 통합 결제/계정의 계층적 그룹화/AWS 서비스 및 API작업 액세스 제어

SCP(Service control policy-서비스 제어 정책)

IAM 정책은 IAM 사용자/그룹/역할에 적용 SCP 서비스제어정책은 조직루트/개별멤버계정/조직단위(OU)에 적용

규정 준수

일반 데이터 보호 규정(GDPR): EU 데이터 HIPAA: 미국 건강데이터

선택한 운영 리전이 규정 준수 요구사항 충족에 도움이 될 수 있음 적절한 리전 선택시 AWS에서 자동으로 리전의 데이터 복제

AWS Artifact

다양한 규정 준수 표준을 충족함이 입증된, 제3자가 작성한 규정 준수 보고서를 확인할 수 있음

AWS Artifact Agreements: 개별 계정 및 AWS Organizations 내 모든 계정에 대한 계약을 검토/수락/관리 AWS Artifact Reports: 다양한 글로벌, 지역별, 산업별 보안 표준 및 규정을 준수했음을 검증한 규정 준수 보고서

서비스 거부 공격

DDoS: 분산 서비스 거부 공격 작동하지 못할 때까지 시스템에 과부하를 걸어 애플리케이션의 기능 정지 인터넷에 연결된 다른 장치를 활용해 그 장치가 자신도 모르는 사이에 사용자의 인프라 공격

UDP Flood: 공격자가 서버에 요청할 때 가짜 회신 주소를 적는다(좀비PC) -> 솔루션: 보안 그룹으로 적절한 요청 트래픽만 허용. 날씨 보소서 같은 요소에는 고객이 사용하는 것과 완전히 다른 프로토콜을 사용. 목록에 없다면 서버와 통신하지 않음 HTTP 수준 공격: 정상적인 고객과 같은 공격자가 평범한 정보(제품 검색)를 계속 요구. 일반 고객이 들어갈 수 없음 -> ELB(Elastic load balancer) 통해 http 트래픽 요청을 먼저 처리하며 속도에 상관없이 모든 메시지가 완료될 때까지 기다린 다음 웹 서버로 전송 SLOWLORIS 공격: 연결이 대단히 느린 것처럼 가정. 전체 패킷을 얻기 전까지 다음 스레드(고객)으로 이동할 수 없음

AWS WAF 사용 AWS SHIELD: 웹 어플리케이션 방화벽을 사용해 수신 트래픽을 필터링해 해커의 서명을 찾음. 계속 증가하는 벡터 공격으로부터 사전 예방적으로 방어

암호화: 권한 있는 당사자만 액세스할 수 있는 방식으로 메시지/데이터 보안 저장 중 암호화: 데이터가 유휴 상태(저장된 상태에서 이동하지 않는 것) 전송 중 암호화

Amazon KMS(key management service): 테이블을 암호화하는데 사용되는 암호화 키 관리

Amazon Inspector: 인프라에 대해 자동화된 보안 평가 실행 Amazon GuardDuty: 위협 탐지. 계정에서 생성된 메타데이터의 연속 스트림 등에서 발견된 네트워크 활동 분석

# AWS Cloud Practitioner_module5_storage, database

Tue, 13 Aug 2024 03:51:44 GMT

인스턴스 스토어 및 Amazon EBS

Amazon EBS(Elastic Block Store)

어플리케이션은 CPU, 메모리, 네트워크, 스토리지 액세스 필요

블록 수준 스토리지 액세스는 모든 블록을 업데이트하지 않기 때문에, 데이터베이스/엔터프라이즈 SW/파일 시스템에 최적화된 하드 드라이브임.

EC2 인스턴스 유형에 따라 인스턴스 스토리지 볼륨이라는 로컬 저장소 제공
EC2 인스턴스가 실행되는 호스트에 물리적으로 연결됨 물리적 호스트에 연결되므로, 인스턴스 중지/종료시 데이터가 삭제됨
휘발적인 특성 때문에 임시 파일, 스크래치 데이터관리에 유용

데이터 백업을 위해 EBS(Amazon Elastic Block Store) EBS 볼륨이라고 하는 가상 하드 드라이브를 만들어 EC2 인스턴스에 연결

로컬 인스턴스 볼륨과는 다른 드라이브로, 호스트에 바로 연결되지 않아 그대로 유지됨
다양한 크기와 유형으로 제공됨
볼륨을 프로비저닝해 인스턴스에 연결
애플리케이션이 쓰기 작업을 할 수 있는 하드드라이브를 가지는 것

스냅샷이라고 하는 데이터 증분 백업을 만들 수 있음 드라이브가 손상되어도 데이터가 손실되지 않으며, 복구할 수 있음 증분 백업이므로 처음 볼륨을 백업하면 모든 데이터가 복사되고, 이후의 백업에서는 가장 최근의 스냅샷 이후 변경된 데이터 블록만 저장

Amazon S3(Simple Storage Service)

데이터 저장 및 검색할 수 있는 데이터 저장소 데이터는 객체로 저장되지만 파일 디렉토리가 아닌 버킷에 저장됨

하드 드라이브에 있는 파일은 객체이며 파일 디렉토리는 버킷으로 이해

객체의 버전을 관리해 삭제 방지 여러 버킷을 생성해 다양한 데이터 클래스나 계층에 저장 객체 액세스 제어

스토리지 사용 사례에 맞게 계층 분리(자주 액세스하는 데이터/수년간 유지해야 하는 감사데이터)

Amazon S3 Standard 99.9% 내구성 AWS가 별개의 스토리지 시설 두 곳에서 발생하는 동시 데이터 손실을 감당할 수 있음(데이터가 3개 이상의 시설에 저장됨) 정적 웹사이트 호스팅(HTML파일 모음) 각 파일은 실제 사이트의 물리적 페이지와 비슷 모든 HTML, 정적 웹 자산 등을 버킷에 업로드해 정적 웹사이트로 호스팅 가능

Amazon S3-IA(Amazon S3 Standard-Infrequent Access) 액세스 빈도는 낮지만 필요할 때는 빠르게 백업, 재해 복구 파일, 장기 보관 파일

Amazon S3 Glacier 데이터를 Glacier로 옮기거나 저장소를 만든 다음 아카이브로 채움 저장소 잠금 정책 적용 가능(한번 쓰기/여러번 읽기와 같은 옵션 적용)

수명 주기 관리: 계층 사이에서 데이터를 자동으로 이동 ex) Standard 90일 -> S3-IA 30일 -> Glacier 영구

스토리지 클래스 비교

EBS vs S3

16TiB 크기/인스턴스 종료 후에도 생존/SSD(플래시 메모리)와 HDD(자기 디스크) 제공 vs

리전 객체 스토리지로 무한대의 스토리지 제공/최대 5TB의 개별 객체/한번 쓰기와 여러번 읽기 최적화/99.99 내구성

사진 분석 웹사이트 사진 업로드 -> 비슷한 동물 검출 동물사진 수백만 장 인덱싱, 사용자 수천명이 동시에 볼 수 있어야 함

S3에 적합

웹 지원
모든 객체에 URL
이미지 접근에 대한 권한제어
리전별 분산
EBS에서 동일한 스토리지 로드에 비해 비용절감
서버리스로 EC2 인스턴스 필요하지 않음

오류를 수정해야 하는 80GB 동영상 파일

객체 스토리지는 모든 파일을 완성된 개별 객체로 취급 전체 객체로서 업로드되고 사용되는 문서, 이미지와 동영상 파일에 적합 객체가 변경될 때마다 전체 파일을 다시 업로드해야 함. 증분 업데이트 지원되지 않음

S3을 사용하면 변경 사항을 저장할 때마다 시스템에서 80GB 전체를 업로드해야함 완성 객체를 사용하거나 변경 횟수가 적을 때 사용

블록 스토리지는 이러한 파일을 작은 구성 요소(블록)으로 나눔 80GB 영상의 한 장면을 편집하고 변경 사항을 저장하면 엔진은 해당 비트가 있는 블록만 업데이트 복잡한 읽기/쓰기/변경 기능

EBS에 적합

Amazon EFS(Elastic File System)

관리형 파일 시스템 (as-is) 공유 파일 시스템에 저장된 대량의 데이터에 대한 분석을 수행하는 여러 서버가 있을 때, 이 데이터는 온프레미스에서 호스팅되었음. 저장 중인 데이터 양을 스토리지가 계속 감당할 수 있는지 확인해야 함. 백업이 수행되었는지, 데이터가 중복으로 저장되었는지 확인 필요했음. (to-be) 규모 조정 및 복제라는 작업을 AWS에일임 가능. 여러 인스턴스가 액세스 가능.

EBS에서도 EC2 인스턴스에서 액세스할 수 있는 파일을 저장할 수 있는데? EBS 볼륨은 EC2 인스턴스에 연결되며 가용영역 수준의 리소스(하드 드라이브). 자동으로 볼륨을 확장해주지는 않음.

Amazon RDS(Relational Database Service)

고객이 음료를 여러 번 주문한다면, 다음 구매 시 사용할 수 있는 할인 쿠폰을 주는 행위와 같다. AWS 클라우드에서 관계형 데이터베이스를 실행할 수 있는 서비스

RDBMS

관계형 데이터베이스 관리 시스템 주요 DB엔진.. MySQL, PostgreSQL, Oracle, Microsoft SQL Server 지원 온프레미스 RDBMS를 클라우드로 마이그레이션

자동 패치, 백업, 이중화, 장애조치 지원

Amazon Aurora

데이터베이스 워크로드 실행 마이그레이션/배포 관리기능이 뛰어난 RDBMS 옵션 MySQL, PostgreSQL와 호환되며 상용데이터베이스 비용의 1/10 S3로의 지속적 백업

Amazon DynamoDB

서버리스 데이터베이스로 기본 인스턴스/인프라 관리할 필요 없음 테이블 생성: 데이터 저장/쿼리 데이터: 항목/속성 두가지 요소

테이블에 항목이 몇 개가 있든 DynamoDB가 사용자를 대신해 기본 스토리지 관리 AZ 전체에 데이터 중복 저장

SQL을 사용하지 않음. 비관계형 NoSQL DB 고정적인 스키마가 아닌, 단순하고 유연한 스키마로 테이블에 있는 항목에서 속성을 추가하거나 제거할 수 있음

키로 지정되는 작은 속성 하위 집합을 기반으로 쿼리 작성

AWS Redshift

데이터가 복잡해 기존 관계형 데이터베이스로 관리가 힘들어지면 데이터 웨어하우스로 빅 데이터 관리/운영 분석이 아닌 기록 분석 가능

비즈니스 질문이 과거를 향한다면 해당 비즈니스 인텔리전스에는 데이터 웨어하우스가 올바른 솔루션

데이터 웨어하우스가 조율되고 복원력을 가지며 지속적으로 규모를 조정하도록 하는 획일적인 작업 부담을 줄이기 위해 AWS Redshift 사용

서비스로서의 데이터 웨어하우징 제품

데이터 레이크에서 실행되는 수 엑사바이트의 비정형 데이터를 대상으로 단일 SQL 쿼리 실행

빅데이터 BI솔루션이 필요할 때 RedShift 서비스를 통해 단일 API 호출로 작업 시작

AWS DMS(Database Migration Service)

기존 데이터베이스를 안전하고 쉽게 AWS로 마이그레이션 마이그레이션 중에도 소스 데이터베이스의 모든 기능이 정상 작동하므로 가동 중지시간 최소화 원본과 대상 DB의 유형이 동일할 필요 없음

스키마 구조, 데이터 유형, 데이터베이스 코드가 원본과 대상 사이에서 호환

소스: 온프레미스, Amazon EC2, Amazon RDS 타겟: Amazon EC2, Amazon RDS

이종 데이터베이스(원본과 대상 데이터베이스의 유형이 다를 때) 이종 마이그레이션

원본과 대상의 스키마 유형, 데이터 유형, 데이터베이스 코드가 다르므로 AWS Schema Conversion Tool을 사용해 변환해 스키마/데이터베이스 코드 일치하도록 변환
DMS를 사용해 원본 데이터베이스의 데이터를 대상 데이터베이스로 마이그레이션

개발 및 테스트 데이터베이스 마이그레이션: 프로덕션 사용자에게 영향을 주지 않고 프로덕션 데이터를 통해 테스트. 개발/테스트 데이터베이스로 마이그레이션 데이터베이스 통합: 여러 데이터베이스를 단일 데이터베이스로 통합 연속 복제: 일회성 마이그레이션을 수행하는 것이 아니라 데이터의 진행 중 복제본을 다른 대상 원본으로 전송

Etc

모든 목적에 적합한 데이터베이스는 없음.

Amazon Document DB: 콘텐츠 관리, 카탈로그, 사용자 프로필에 적합하며 mongoDB 호환 Amazon Neptune: 그래프 데이터베이스로 소셜 네트워킹 및 추천 엔진을 고려해 설계 Amazon Managed Blockchain: 오픈소스 프레임워크를 사용해 블록체인(여러 당사자가 중앙기관 없이 거래를 실행하고 데이터를 공유하는 분산현 원장 시스템) 네트워크를 생성하고 관리 Amazon QLDB(Quantum Ledger Database): 원장 데이터베이스. 애플리케이션 데이터에 발생한 모든 변경 사항의 전체 기록 검토. 어떤 항목도 감사에서 제거할 수 없는 변경 불가능한 시스템 데이터베이스 엑셀러레이터 Amazon ElasticCache: 캐싱 기능을 추가해 일반 요청을 밀리초에서 마이크로초로3배 개선 Amazon DynamoDB Accelerator: 비관계형 데이터 개선

# AWS Cloud Practitioner_module4_network

Mon, 05 Aug 2024 14:56:58 GMT

네트워킹

Amazon VPC(Virtual Private Cloud)

사용자 고유 프라이빗 네트워크
사용자가 정의한 가상 네트워크에서 AWS 리소스를 실행할 수 있는, 논리적으로 격리된 AWS 클라우드 섹션 프로비저닝
인터넷으로 접속할 수 있는 퍼블릭일수도, 프라이빗일수도 있음
퍼블릭/프라이빗 리소스 그룹을 서브넷이라고 하며, VPC에 있는 IP주소의 범위(모음)
퍼블릭 서브넷: 인터넷과 통신 가능 ex. 웹사이트 프라이빗 서브넷: 인터넷과 통신 불가 ex. db, HR
공개 인터넷의 트래픽이 VPC를 출입하도록 허용하려면 IGW(인터넷 게이트웨이)를 VPC에 연결해야함 = 커피숍의 정문

가상 프라이빗 게이트웨이

VPC 내의 비공개 리소스에 액세스하기 위함 보호된 인터넷이 VPC로 들어오도록 허용
VPC와 프라이빗 네트워크(온프레미스 데이터 센터 또는 회사 내부 네트워크) 간 VPN(가상 프라이빗 네트워크) 연결 설정 가능
승인된 네트워크에서 나오는 트래픽만 VPC로 들어가도록 허용

AWS Direct Connect

비공개 전용 광섬유 연결
네트워크 비용 절감/대역폭 늘리는 데 도움

서브넷 및 네트워크 액세스 제어 목록

VPC에서 게이트웨이에 대한 액세스 관리를 위해 서브넷을 사용해야 함
패킷: 인터넷에서 보내는 메시지
서브넷 경계를 지나는 모든 패킷은 ACL(네트워크 액세스 제어 목록)에서 검사되어 발신자/통신방식 기준으로 패킷에 서브넷출입권한을 확인
ACL은 서브넷 경계를 지나는 패킷만 평가함 패킷이 특정 EC2 인스턴스에 접근할 수 있는지는 평가할 수 없으므로, 인스턴스 수준의 보안 설정도 필요
EC2 인스턴스는 시작되면 보안그룹으로 이동해 모든 IP와 포트가 차단됨
보안 그룹은 상태를 저장하므로 과거에 지나갔던 패킷을 통과시켜 주지만, ACL은 상태 비저장으로 항상 목록을 확인해야 함
보안 그룹은 인스턴스 단계이며, ACL은 서브넷 단계
보안 그룹은 기본적으로 모든 인바운드 트래픽을 거부하고 모든 아웃바운드 트래픽을 허용
기본 네트워크 ACL은 기본적으로 모든 인바운드 및 아웃바운드 트래픽을 허용/사용자 지정 네트워크 ACL은 기본적으로 모든 트래픽 거부

퍼블릭 서브넷은 웹 사이트와 같이 누구나 액세스할 수 있어야 하는 리소스를 포함
프라이빗 서브넷은 DB와 같이 프라이빗 네트워크를 통해서만 액세스할 수 있는 리소스를 포함

글로벌 네트워킹

Amazon Route 53

AWS의 Domain Name Service

DNS는 웹사이트 이름을 IP(인터넷 프로토콜)로 번역

Amazon CloudFront

CDN: 고객과 최대한 가까운 곳으로 컨텐츠 제공

# AWS Cloud Practitioner_module3_global infra

Mon, 05 Aug 2024 14:56:24 GMT

글로벌 인프라

리전이라 부르는 대규모 그룹에 자체 데이터센터를 구축해 재난발생에 대비

비즈니스 트래픽 수요 지점과 가까운 곳에 리전 구축
각 리전에는 애플리케이션을 실행하는 데 필요한 컴퓨팅, 스토리지 및 기타 서비스 구비된 데이터센터 설치
각 리전은 다른 리전과 격리됨으로써 데이터 유입되지 않음
정부 규정 준수 요구사항 등으로, 리전에 저장된 데이터는 리전을 벗어나지 않음

지역 법률/국가 법령 등을 고려해 리전 선택

규정 준수
근접성: 지연시간
기능 가용성: 가까운 리전에서 원하는 AWS 서비스가 제공되지 않을 수 있음
가격: 일부 지역은 운영비용이 더 비쌈

가용 영역

리전 내의 단일 데이터센터 또는 그룹

지연 시간이 짧을 정도로 충분히 가까움
한 부분에서 재해가 발생할 경우 다른 가용 영역이 영향을 받지 않을 만큼 떨어져 있음
한 리전의 두 개 이상의 가용 영역에서 애플리케이션 실행

AWS Outposts

마법사 및 자동화된 워크플로에 액세스하여 AWS 서비스에서 작업을 수행

엣지 로케이션

고객이 리전과 멀리 떨어진 도시에 있다면? 위성 점포를 만들어 대응(고객 로컬 설치, 데이터 복사본 캐싱) 사용자가 어디 있든 콘텐츠를 더 빠르게 전송하기 위해 캐싱하는데 사용하는 사이트

CDN(콘텐츠 전송 네크워크 더 빠른 콘텐츠 전송을 위해 콘텐츠 사본 캐싱

Amazon CloudFront 데이터, 동영상, 어플리케이션, API를 짧은 지연시간으로 제공하는 서비스

고객이 어디에 있더라도, 리전의 데이터를 엣지 로케이션으로 push

AWS Outposts AWS가 사용자의 데이터센터 내부에 정상적으로 작동하는 소형 리전 설치 서비스 사용가능하지만 건물 내부에 격리됨

AWS리소스 프로비저닝

AWS의 모든 것은 API와 관련됨 API를 호출해 AWS 리소스 구성/관리

EC2 인스턴스 생성
Lambda함수 생성

AWS Management Console

browser based 학습하기 좋음

테스트 환경
청구서 확인
모니터링
기술과 무관한 리소스 사용

AWS CLI

수동 프로비저닝은 오류 발생할 수 있음 API 호출시 프로그래밍하는 도구 바로 자동화하기 좋지는 않음

머신의 터미널을 사용해 API 호출 Console의 시각적 호출과 다름 프로비저닝 작업을 스크립트해 반복 인적 오류 줄임 예약/다른프로세스의 트리거로 자동화

EC2 인스턴스 시작 후 특정 Auto Scaling 그룹에 연결

AWS SDK

다양한 프로그래밍 언어로 리소스와 상호작용

C++
Java
.NET 등

AWS Elastic Beanstalk

EC2 기반 환경 프로비저닝 지원

네트워크, 인스턴스, 규모 조정 구축을 위해 콘솔클릭/ 명령작성 하지 않음

애플리케이션 코드와 원하는 구성을 제공하면, 해당 정보를 바탕으로 환경 구축 환경 구성을 저장해 다시 배포 가능 개별적으로 프로비저닝/관리하는 번거로움 줄임

인프라가 아닌 비즈니스 애플리케이션에 집중할 수 있음

AWS CloudFormation

리소스 정의 코드형 인프라 도구. 인프라를 코드로 취급 JSON, YAML 텍스트 기반 문서를 사용해 선언적인 방식으로 AWS리소스 정의

스토리지, 데이터베이스, 분석, 머신러닝 등 다양한 리소스 지원

리소스 정의되면 CloudFormation이 템플릿을 구문 분석해 병렬로 정의한 리소스의 프로비저닝 시작

백엔드 AWS로 가는 호출과 API를 사용자 대신 관리

여러 사용자/ 리전에서 실행 가능하며 동일한 환경이 생성됨. 자동화된 프로세스이므로 오류 감소

# LLM Service:RAG

Wed, 31 Jul 2024 22:39:24 GMT

서비스

데이터 보안

사용할 데이터의 현재 상태와 흐름, 프로세스 고려

AI 앱

배포, 프론트엔드 고려

시스템 통합

기존 시스템의 요구사항 및 데이터 상황 고려

파인튜닝

데이터셋 보유 여부, 학습 관리/업데이트/테스트 프로세스 자동화 고려

반복업무를 LLM에게 훈련

데이터셋, 회사의 의도, tool 고려

LLM 특성

왜 RAG인가?

언어모델/사람의 뇌는 데이터베이스가 아니지만, 정확하게 기억한다고 착각할 수 있음.

오픈북 시험으로 바꾸면, 답변에 가이드라인을 제시함으로써 환각 현상 등을 줄일 수 있음.(모르는 것을 만들어내는 현상 방지)

RAG

AWS 대규모 언어 모델의 출력을 최적화하여 응답을 생성하기 전에 학습 데이터 소스 외부의 신뢰할 수 있는 지식 베이스를 참조하도록 하는 프로세스

대규모 언어 모델(LLM)은 방대한 양의 데이터를 기반으로 학습되며 수십억 개의 매개 변수를 사용하여 질문에 대한 답변, 언어 번역, 문장 완성과 같은 작업에 대한 독창적인 결과를 생성

RAG는 이미 강력한 LLM의 기능을 특정 도메인이나 조직의 내부 지식 기반으로 확장하므로 모델을 다시 교육할 필요가 없으며, LLM 결과를 개선하여 다양한 상황에서 관련성, 정확성 및 유용성을 유지하기 위한 비용 효율적인 접근 방식

Grouning

LLM이 사실(ground)에 기반해 답변할 수 있도록

Retrieval

외부 지식데이터로부터 지식을 가져옴

Augmented

LLM에게 더 나아진 프롬프트 전달

Generation

답변 생성

프롬프트 엔지니어링의 일부. 데이터 자체를 프롬프트에 포함시킨다.

데이터는 여러 소스(PDF, 마크다운, 텍스트 파일 등)이므로 그것을 어떻게 가져오는가?

Embeddings

Embed

일반적 의미: 어떤 것을 다른 것에 삽입하거나 통합 ex) 웹 페이지에 비디오나 지도 등의 외부 콘텐츠를 '임베드'
기술적 의미: 특정 데이터/기능을 한 시스템 또는 장치 안에 내장

Embeding

삽입되거나 통합된 결과물

AI에서의 Embedding

단어와 문장과 같은 텍스트 데이터를 벡터의 형태로 표현
LLM 내부에서 어떤 위치에 있는지

embedding_model = SentenceTransformer("thenlper/gte-large")

"""get embedding vector"""
def get_embedding(text: str) -> list[float]:
    if not text.strip():
      print("empty")
      return []
    return embedding_model.encode(text).tolist()

Cosine 유사도

벡터공간 내에서 두 벡터 사이의 거리가 얼마나 가까운지(얼마나 유사한 의미를 가지는지)
두 벡터 사이의 코사인 각을 이용
방향이 비슷할수록 1에 가까워지고, 반대일수록 -1에 가까워짐

Semantic search

문서를 의미적 표현을 통해 색인화
검색 시 쿼리의 의미적 표현에서 가장 관련성 높은 문서를 찾기 위해 유사도 검색
텍스트 일치가 아닌 문맥을 고려한 일치 정도를 확인

Vector indexing

통상 DB에서는 인덱스/PK 활용

"key" 를 임베딩, "value" 를 원본 텍스트로 지정 -> vector DB

Pinecone
Weaviate
FAISS
AMZ: ElasticSearch
MS: Cognitive Search

Ranking, cutoff

쓸데없는 내용 검색될 수 있음
검색 내용이 너무 많으면 토큰 수가 늘어나고 부정확
가장 유사도가 높은 검색 결과 n개를 이용해 메타 프롬프트를 생성

Chunking

정해진 사이즈로 청킹하면 의미가 손실되어 잘릴 수 있음.(보통 1024 토큰)

겹치는 부분을 설정하더라도, 문맥을 반영해야 하는 문제가 해결되지 않음.

문단으로 자르더라도, 꼭 문단으로 되어있지 않으며 각 문단의 길이가 다를 수 있음.

논문과 같이 정해진 포맷의 문서를 처리한다면 메타데이터를 포함해 청킹할 수 있지만 논문이 아닌 다른 타입 문서에는 적용하기 힘듦.

LlamaIndex

PDF, DB, API로 데이터를 전송해 청킹/인덱싱

study간 아래 URL참고

https://www.deeplearning.ai/short-courses/building-applications-vector-databases/ https://www.deeplearning.ai/short-courses/advanced-retrieval-for-ai/ https://www.deeplearning.ai/short-courses/preprocessing-unstructured-data-for-llm-applications/

https://wikidocs.net/231147 https://www.youtube.com/@AI-km1yn/videos

후처리[Post Processing]

답변이 문제가 있거나 처리가 필요할 때

Relevance: 관련성, 동문서답

moderation: 내용 검열 API. 사용자 쿼리에도 적용. 기존에는 긴 프롬프트로 적용했음

RAI: responsible, 윤리적

groundedness: 사실 기반

메타 프롬프트가 너무 길어지다 보니, moderation API로 프롬프트 확인.

Groundedness

https://docs.ragas.io/en/stable/concepts/metrics/index.html

RAGAS: RAG 파이프라인 평가하는 python framework

def ragas_eval(eval_sets):
  return evaluate(
      eval_sets,
      metrics=[
          context_precision,
          faithfulness,
          answer_relevancy,
          context_recall,
          answer_correctness
      ]
  )

busan_context_right = [
    "부산광역시는 한반도 남동부에 위치한 광역시이다. 대한민국 제 2의 도시이다."
]

eval_set = {
    "question": ["대한민국에서 두 번째로 큰 도시가 어디야?"],
    "answer": ["대한민국에서 가장 두번째로 큰 도시는 부산입니다."],
    "contexts": [busan_context_right],
    "ground_truth": ["부산"]
}

eval_sets = Dataset.from_dict(eval_set)

ragas_eval(eval_sets)

Evaluating: 100%
 5/5 [00:04<00:00,  1.34it/s]
{'context_precision': 1.0000, 'faithfulness': 1.0000, 'answer_relevancy': 0.9044, 'context_recall': 1.0000, 'answer_correctness': 0.9725}

파인튜닝과의 비교

정의 대규모 언어 모델의 출력을 최적화하여 응답을 생성하기 전에 학습 데이터 소스 외부의 신뢰할 수 있는 지식 베이스를 참조하도록 하는 프로세스 vs 특정 작업이나 도메인에 높은 적합성을 확보하기 위해, 이미 훈련된 대규모 언어 모델에 특정 데이터셋을 사용하여 추가적인 학습을 수행하는 프로세스

정확성

신뢰할 수 있는 소스에서 관련 정보를 검색하여 결과의 정확성 높임 vs 모델을 특정 작업이나 도메인에 맞게 최적화하여 효율성 증가

의존성

데이터에 기반해 응답을 생성하므로 신뢰도가 높음 vs 광범위한 데이터를 통해 모델 재학습

업데이트 가능성

참조 데이터셋을 새로운 정보로 업데이트 vs 모델을 업데이트

연산 비용 데이터를 검색하는 추가 단계 필요 vs 파인튜닝 과정이 자원을 많이 소모

데이터 품질 의존성 부족한 데이터는 효과를 제한 vs 학습 데이터의 품질에 따라 모델 성능이 좌우됨

확장성 데이터베이스 확장이 어렵고 자원 집약적 vs 모델을 바꿔야 함

소스 데이터에 대한 과도한 의존 새로운 응답을 생성하는 능력이 제한될 수 있음 vs 그런거 없음

정보의 오류 가능성 검색 오류/구식 정보 vs 트레이닝대로 답을 생성하지 않을 수 있음

개인정보 보호 데이터의 개인정보 유지 vs 개인정보 문제 야기 가능성

특화 task 작은 데이터셋, 모델의 잦은 업데이트 vs 새로운 장르, 분야, 특정한 업무의 퍼포먼스, 아웃풋 방식이 특수, 새로운 데이터

# AWS Cloud Practitioner_module2_클라우드 컴퓨팅

Wed, 31 Jul 2024 09:47:34 GMT

EC2(Amazon Elastic Compute Cloud)

온프레미스 리소스 사용의 단점

하드웨어 구매
서버 배달 지연
서버 설치
필요한 모든 구성 수행

EC2 인스턴스 사용의 장점

인스턴스 프로비저닝 간소화
워크로드 종료시 인스턴스 사용 중지로 비용 절약
컴퓨팅 시간에 대해서만 비용 지불
필요한 서버 용량에 대해서만 비용 지불

작동 방식

인스턴스 시작

템플릿 선택(os와 서버, 애플리케이션 등)해 인스턴스 유형 선택
보안 설정

연결 및 사용

EC2 인스턴스 유형

범용 인스턴스

컴퓨팅, 메모리, 네트워킹 리소스를 균형 있게 제공

애플리케이션 서버
게임 서버
엔터프라이즈 애플리케이션용 백엔드 서버
중소 규모 데이터베이스

컴퓨팅 최적화 인스턴스

고성능 프로세서를 활용하는 컴퓨팅 집약적인 애플리케이션에 적합. 범용 인스턴스와 마찬가지로 컴퓨팅 최적화 인스턴스는 웹 서버, 애플리케이션 서버, 게임 서버와 같은 워크로드에 사용

고성능 웹 서버, 컴퓨팅 집약적 애플리케이션 서버 및 게임 전용 서버에 적합하다는 점이 범용 인스턴스와 다름. 또한 단일 그룹에서 많은 트랜잭션을 처리해야 하는 일괄 처리 워크로드에 사용할 수 있음.

메모리 최적화 인스턴스

메모리에서 대규모 데이터 세트를 처리하는 워크로드를 위한 빠른 성능을 제공하기 위해 설계

컴퓨팅에서 메모리는 임시 스토리지 영역이며 CPU가 작업을 완료하는 데 필요한 모든 데이터와 명령이 들어 있음.

컴퓨터 프로그램이나 애플리케이션은 스토리지에서 메모리로 로드된 후 실행되며, CPU가 컴퓨터 프로그램에 직접 액세스할 수 있음.

애플리케이션을 실행하기 전에 많은 데이터를 미리 로드해야 하는 워크로드(많은 메모리가 필요한 워크로드)

고성능 데이터베이스
방대한 양의 비정형 데이터의 실시간 처리가 필요한 워크로드

액셀러레이티드 컴퓨팅 인스턴스

하드웨어 액셀러레이터 또는 코프로세서를 사용하여 일부 기능을 CPU에서 실행되는 소프트웨어에서보다 더 효율적으로 수행

데이터 처리 가속화

부동 소수점 수 계산
그래픽 처리
데이터 패턴 일치
그래픽 애플리케이션

EC2 요금

온디맨드 인스턴스

중단할 수 없는 불규칙한 단기 워크로드가 있는 애플리케이션에 매우 적합

선결제 비용이나 최소 약정은 적용되지 않고 인스턴스는 중지될 때까지 계속 실행되며, 사용한 컴퓨팅 시간에 대해서만 비용 지불

1년 이상 지속되는 워크로드에는 권장X (예약 인스턴스가 대안)

애플리케이션 개발 및 테스트
예측할 수 없는 사용 패턴이 있는 애플리케이션 실행

Saving Plans

EC2를 비롯한 여러 컴퓨팅 서비스에 대한 Savings Plans를 제공

Amazon EC2 Savings Plans를 사용하면 1년 또는 3년 기간 동안 일정한 컴퓨팅 사용량을 약정하여 컴퓨팅 비용을 절감

약정 사용량까지는 할인된 Savings Plan 요금이 청구되며,(예: 시간당 10 USD) 약정을 초과한 사용량에 대해서는 일반 온디맨드 요금이 부과

예약 인스턴스 계정에서 온디맨드 인스턴스를 사용할 때 적용되는 결제 할인 옵션

표준 예약 및 컨버터블 예약 인스턴스는 1년 또는 3년 약정으로, 정기 예약 인스턴스는 1년 약정으로 구입

예약 인스턴스 약정 기간이 끝나면 중단 없이 Amazon EC2 인스턴스를 계속 사용할 수 있지만,다음 중 하나를 수행할 때까지는 온디맨드 요금이 부과

인스턴스 종료
새 예약 인스턴스 구입

스팟 인스턴스

시작 및 종료 시간이 자유롭거나 중단을 견딜 수 있는 워크로드에 적합

미사용 Amazon EC2 컴퓨팅 용량 사용

필요에 따라 시작 및 중지할 수 있는 백그라운드 처리 작업(예: 고객 설문 조사 데이터 처리 작업)이 있다고 가정해 보겠습니다. 전반적인 비즈니스 운영에는 영향을 주지 않고 처리 작업을 시작하고 중지하려고 합니다. 스팟 요청을 하고 Amazon EC2 용량을 사용할 수 있는 경우 스팟 인스턴스가 시작됩니다. 하지만 스팟 요청을 했는데 Amazon EC2 용량을 사용할 수 없다면 용량을 사용할 수 있을 때까지 요청이 성공하지 못합니다. 용량을 사용할 수 없으므로 백그라운드 처리 작업의 시작이 지연될 수 있습니다.

전용 호스트

사용자 전용의 Amazon EC2 인스턴스 용량을 갖춘 물리적 서버로 가장 비쌈.

EC2 Auto Scaling

변화하는 애플리케이션 수요에 따라 Amazon EC2 인스턴스를 자동으로 추가/제거

필요에 따라 인스턴스를 자동으로 조정하여 애플리케이션 가용성을 효과적으로 유지

동적 조정: 수요 변화에 대응
예측 조정:예측된 수요에 따라 적절한 수의 Amazon EC2 인스턴스를 자동으로 예약

Elastic Load Balancing

들어오는 애플리케이션 트래픽을 Amazon EC2 인스턴스와 같은 여러 리소스에 자동으로 분산하는 AWS 서비스

로드 밸런서는 Auto Scaling 그룹으로 들어오는 모든 웹 트래픽의 단일 접점 역할

들어오는 트래픽의 양에 맞춰 Amazon EC2 인스턴스를 추가/제거하므로 이러한 요청이 로드 밸런서로 먼저 라우팅되고, 요청을 처리할 여러 리소스로 분산됩니다. 예를 들어 Amazon EC2 인스턴스가 여러 개인 경우 Elastic Load Balancing은 워크로드를 여러 인스턴스에 분산하므로 어느 한 인스턴스가 대량으로 워크로드를 처리할 필요가 없음.

EC2 Auto Scaling 서비스와 서로 연동

Amazon SQS(Simple Queue Service)

메시지 대기열 서비스

메시지 손실이나 다른 서비스 사용 없이 소프트웨어 구성 요소 간에 메시지를 전송, 저장, 수신

애플리케이션이 메시지를 대기열로 전송하고, 사용자 또는 서비스는 대기열에서 메시지를 검색하여 처리한 후 대기열에서 삭제

Amazon SNS(Simple Notification Service)

게시/구독 서비스

게시자는 Amazon SNS 주제를 사용하여 구독자에게 메시지를 게시

구독자는

웹 서버
이메일 주소
AWS Lambda 함수 또는 그 밖의 여러 옵션

서버리스

EC2에서 실행하려는 애플리케이션이 있는 경우 아래의 절차

인스턴스(가상 서버) 프로비저닝
사용자 코드 업로드
애플리케이션이 실행되는 동안 계속해서 인스턴스를 관리

서버리스라는 용어는 코드가 서버에서 실행되지만 이러한 서버를 프로비저닝하거나 관리할 필요가 없다는 뜻

서버를 유지 관리하는 대신 새로운 제품과 기능을 혁신하는 데 더 집중할 수 있으며, 자동으로 확장할 수 있는 유연성을 갖춤. 처리량 및 메모리와 같은 소비 단위를 수정하여 애플리케이션의 용량을 조정할 수 있음.

AWS Lambda

서버를 프로비저닝하거나 관리할 필요 없이 코드를 실행할 수 있는 서비스

사용한 컴퓨팅 시간에 대해서만 비용을 지불

코드를 Lambda에 업로드
AWS 서비스, 모바일 애플리케이션 또는 HTTP 엔드포인트와 같은 이벤트 소스에서 트리거되도록 코드를 설정
Lambda는 트리거된 경우에만 코드를 실행
사용한 컴퓨팅 시간에 대한 요금만 지불

컨테이너

애플리케이션의 코드와 종속성을 하나의 객체로 패키징하는 표준 방식을 제공

보안성, 안정성, 확장성 요구 사항이 매우 중요한 프로세스 및 워크플로에도 컨테이너를 사용

ECS(Amazon Elastic Container Service)

컨테이너식 애플리케이션을 실행하고 확장할 수 있는 확장성이 뛰어난 고성능 컨테이너 관리 시스템

Docker 애플리케이션을 신속하게 구축, 테스트, 배포할 수 있는 소프트웨어 플랫폼

EKS(Amazon Elastic Kubernetes Service)

AWS에서 Kubernetes를 실행하는 데 사용할 수 있는 완전 관리형 서비스입니다.

Kubernetes 컨테이너식 애플리케이션을 대규모로 배포하고 관리하는 데 사용할 수 있는 오픈 소스 소프트웨어

AWS Fargate

컨테이너용 서버리스 컴퓨팅 엔진으로, Amazon ECS와 Amazon EKS에서 작동

서버를 프로비저닝하거나 관리할 필요가 없으며 자동으로 서버 인프라를 관리

애플리케이션 혁신과 개발에 더 집중할 수 있으며, 컨테이너를 실행하는 데 필요한 리소스에 대해서만 비용을 지불

# AWS Cloud Practitioner_module1_AWS 개요

Wed, 31 Jul 2024 09:22:37 GMT

클라이언트-서버

클라이언트

사람이 컴퓨터 서버에 요청을 보내기 위해 상호 작용하는 웹 브라우저 또는 데스크톱 애플리케이션

서버

일종의 가상 서버인 Amazon Elastic Cloud Compute(Amazon EC2)와 같은 서비스(AWS에서)

상호작용

클라이언트가 특정 요청시 서버는 요청을 평가하고 클라이언트에 정보를 반환함으로써 요청 이행

클라우드 컴퓨팅

클라우드 컴퓨팅 종량 과금제 요금으로 인터넷을 통해 필요에 따라 IT리소스 제공

클라우드 기반 배포

기존 애플리케이션을 클라우드로 마이그레이션하거나 클라우드에서 새 애플리케이션을 설계 및 빌드한다.

예를 들어 기업은 완전히 클라우드에 기반한 가상 서버, 데이터베이스, 네트워킹 구성 요소로 구성된 애플리케이션을 운영

애플리케이션의 모든 부분을 클라우드에서 실행
기존 애플리케이션을 클라우드로 마이그레이션
클라우드에서 새 애플리케이션을 설계 및 빌드

온프레미스 배포

온프레미스 배포는 프라이빗 클라우드 배포라고도 하며, 리소스는 가상화 및 리소스 관리 도구를 사용하여 온프레미스에 배포됨.

애플리케이션에 필요한 기술의 모든 요소가 온프레미스 데이터 센터에 저장되는 경우가 있을 수 있음. 이 모델은 레거시 IT 인프라와 매우 비슷하지만 애플리케이션 관리 및 가상화 기술이 통합되어 리소스 사용률을 높이는 데 도움이 됨.

가상화 및 리소스 관리 도구를 사용하여 리소스를 배포
애플리케이션 관리 및 가상화 기술을 사용하여 리소스 활용

회사 자체 구축 데이터센터를 생각하면 됨.

하이브리드 배포

클라우드 기반 리소스는 온프레미스 인프라에 연결되며, 여러 상황에서 사용할 수 있다.

온프레미스에서 더 잘 유지 관리되는 레거시 애플리케이션이 있거나 정부 규정에 따라 비즈니스에서 특정 레코드를 온프레미스에 보관해야 하는 경우

예를 들어 회사에서 배치 데이터 처리 및 분석을 자동화할 수 있는 클라우드 서비스를 사용하고자 한다고 가정한다. 그런데 이 회사에는 온프레미스에 더 적합하여 클라우드로 마이그레이션되지 않을 몇 가지 레거시 애플리케이션이 있기 때문에,하이브리드 배포를 통해 레거시 애플리케이션을 온프레미스로 유지하면서 클라우드에서 실행되는 데이터 및 분석 서비스의 이점을 활용할 수 있음.

클라우드 기반 리소스를 온프레미스 인프라에 연결
클라우드 기반 리소스를 레거시 IT 애플리케이션과 통합

클라우드 컴퓨팅의 이점

선행 비용 -> 가변 비용
데이터 센터 유지관리 불필요
용량 추정 불필요
속도 향상
배포

멀티테넌시

전체 호스트를 소유하지 않는다. 다른 여러 인스턴스(가상머신)와 호스트를 고유하며, 호스트에서 실행하는 하이퍼바ㅣ저가 가상머신간의 물리적 리소스 공유를 제어

호스트의 리소스를 공유하는 가상머신을 서로 분리
EC2 인스턴스 간 인식하지 못함

# [기술] 백그라운드 프로세스

Wed, 24 Jul 2024 12:27:16 GMT

[docker container]

$ docker run \
    --name python-gradio-container \
    -it -d -p 7870:8000 \
    -v ~/html/:/var/www/html \
    image1:tag1 bash

위와 같이 -d 옵션을 통해 컨테이너를 백그라운드 실행할 수 있지만, 컨테이너 실행과 동시에 프로그램이 실행되지 않는다면 바로 종료된다.

따라서 sleep infinity 옵션을 줌으로써 프로세스와 관계 없이 실행이 유지되는 컨테이너를 관리할 수 있다.

# sleep infinity 옵션
$ docker run \
    --name python-gradio-container \
    -it -d -p 7870:8000 \
    -v ~/html/:/var/www/html \
    image1:tag1 bash sleep infinity

# 컨테이너 실행
$ docker start {container name}

# 실행중인 컨테이너에 bash 접속
$ docker exec -it gradio_container /bin/bash

[리눅스 프로세스 백그라운드 실행]

프로세스 실행 후 중단

$ ctrl+z

중단된 프로세스를 background에서 실행

$ bg

작업의 소유권을 shell session에서 해제

$ disown -h

ssh 로그아웃

이후 해당 프로세스의 종료가 필요하다면,

$ ps -ef

확인된 프로세스ID kill

kill -9 {PID}

[URL]

https://github.com/Integerous/TIL/blob/master/Linux/Maintaining_Process.md

# [기술] ec2 instance GPU

Wed, 17 Jul 2024 09:03:56 GMT

[인스턴스 선택]

인스턴스는 기계 학습 추론 및 그래픽 집약적 워크로드의 속도를 개선하는 데 도움이 되도록 설계되었습니다.

기능: 2세대 인텔 제온 스케일러블 프로세서(캐스케이드 레이크 P-8259CL)

최대 8개의 NVIDIA T4 Tensor 코어 GPU
최대 100Gbps의 네트워킹 처리량
최대 1.8TB의 로컬 NVMe 스토리지

가장 가성비 있는 GPU 유형으로 선택. 아래는 스펙이다.

[vCPU 할당량 증가]

https://calculator.aws/#/createCalculator/ec2-enhancement 위 링크에서 vCPU 계산 https://aws.amazon.com/ko/ec2/instance-types/ || 위 링크에서 확인

g4dn.xlarge의 경우 4

http://aws.amazon.com/contact-us/ec2-request 위 링크에서 사례를 제출해야함

한도 증가 요청 1
Service: EC2 Instances
Primary Instance Type: All G instances
Region: Asia Pacific (Seoul)
한도 이름: Instance Limit
새 한도 값: 4
------------
활용 사례 설명: need to inference llm

위와 같이 사례 제출 후 하루 정도 경과되면 AWS 담당자가 승인해준다.

사용 가능

[GPU setting]

https://docs.nvidia.com/cuda/cuda-installation-guide-linux/ Amazon Linux 2023 사용으로 3.11. 참고해서 진행 https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html#nvidia-GRID-driver 옵션3 GRID 드라이버 https://repost.aws/ko/articles/ARwfQMxiC-QMOgWykD9mco1w/how-do-i-install-nvidia-gpu-driver-cuda-toolkit-and-optionally-nvidia-container-toolkit-in-amazon-linux-2023-al2023?sc_ichannel=ha&sc_ilang=en&sc_isite=repost&sc_iplace=hp&sc_icontent=ARwfQMxiC-QMOgWykD9mco1w&sc_ipos=13 CUDA Toolkit

인스턴스의 GPU 확인

$ lspci | grep -i nvidia
00:1e.0 3D controller: NVIDIA Corporation TU104GL [Tesla T4] (rev a1)

지원되는 linux버전 확인

$ uname -m && cat /etc/*release
x86_64
Amazon Linux release 2023.5.20240708 (Amazon Linux)

gcc 컴파일러 설치 확인

$ gcc --version
gcc (GCC) 11.4.1 20230605 (Red Hat 11.4.1-2)
Copyright (C) 2021 Free Software Foundation, Inc.

실행 중인 커널 버전 확인

$ uname -r

kernel update

$ sudo dnf update -y
$ sudo dnf install -y dkms kernel-devel kernel-modules-extra
$ sudo reboot

재시작 후 ADD NVIDIA repo

$ sudo dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/amzn2023/x86_64/cuda-amzn2023.repo
$ sudo dnf clean expire-cache

NVIDIA driver

$ sudo dnf module install -y nvidia-driver:latest-dkms

CUDA toolkit

$ sudo dnf install -y cuda-toolkit
Disk Requirements:
   At least 5686MB more space needed on the / filesystem.

https://docs.aws.amazon.com/ebs/latest/userguide/recognize-expanded-volume-linux.html?icmpid=docs_ec2_console

CUDA toolkit 중 볼륨 30GiB -> 100GiB 로 확장처리했음

재부팅 후 Verify NVIDIA driver

$ sudo reboot
$ nvidia-smi
Thu Jul 18 13:13:36 2024
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 555.42.06              Driver Version: 555.42.06      CUDA Version: 12.5     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  Tesla T4                       Off |   00000000:00:1E.0 Off |                    0 |
| N/A   39C    P0             27W /   70W |       1MiB /  15360MiB |      8%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+

Verify CUDA toolkit

$ /usr/local/cuda/bin/nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Thu_Jun__6_02:18:23_PDT_2024
Cuda compilation tools, release 12.5, V12.5.82
Build cuda_12.5.r12.5/compiler.34385749_0

[추론]

https://github.com/ggerganov/llama.cpp/blob/master/examples/server/README.md lla.cpp reference 참고

docker로 llama.cpp server-cuda image pull

$ docker pull ghcr.io/ggerganov/llama.cpp:server-cuda

llama.cpp 서버 콘테이너 구동, -v로 호스트의 모델 동기화

$ docker run -p 8080:8080 -v ./model/model/:/models --gpus all ghcr.io/ggerganov/llama.cpp:server-cuda -m models/ggml-model-q8_0.gguf -c 512 --host 0.0.0.0 --port 8080 --n-gpu-layers 99

docker: Error response from daemon: could not select device driver "" with capabilities: [[gpu]].

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html

nvidia-container-toolkit 설치 필요

$ curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | \
  sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo
$ sudo yum-config-manager --enable nvidia-container-toolkit-experimental  
$ sudo yum install -y nvidia-container-toolkit
$ sudo systemctl restart docker

docker(웹서버 컨테이너)에서 요청하기 때문에, 8080 포트를 열어줘야 한다.

curl

$ curl --request POST \
    --url http://localhost:8080/completion \
    --header "Content-Type: application/json" \
    --data '{"prompt": "Building a website can be done in 10 simple steps:","n_predict": 128}'

{"content":"\n1. Choose a domain name\n2. Register the domain\n3. Choose a host\n4. Buy web space\n5. Set up email\n6. Write your first page\n7. Test your site\n8. Link to others\n9. Add new pages\n10. Update your site\nThe steps above are not in any particular order. You can do the steps in any order that you like. The order below is based on the order that we do things in our office.\n1. Choose a domain name\nThere are many different ways to choose a domain name, but here are a few things to","id_slot":0,"stop":true,"model":"models/ggml-model-f16.gguf","tokens_predicted":128,"tokens_evaluated":14,"generation_settings":{"n_ctx":512,"n_predict":-1,"model":"models/ggml-model-f16.gguf","seed":4294967295,"temperature":0.800000011920929,"dynatemp_range":0.0,"dynatemp_exponent":1.0,"top_k":40,"top_p":0.949999988079071,"min_p":0.05000000074505806,"tfs_z":1.0,"typical_p":1.0,"repeat_last_n":64,"repeat_penalty":1.0,"presence_penalty":0.0,"frequency_penalty":0.0,"penalty_prompt_tokens":[],"use_penalty_prompt_tokens":false,"mirostat":0,"mirostat_tau":5.0,"mirostat_eta":0.10000000149011612,"penalize_nl":false,"stop":[],"n_keep":0,"n_discard":0,"ignore_eos":false,"stream":false,"logit_bias":[],"n_probs":0,"min_keep":0,"grammar":"","samplers":["top_k","tfs_z","typical_p","top_p","min_p","temperature"]},"prompt":"Building a website can be done in 10 simple steps:","truncated":false,"stopped_eos":false,"stopped_word":false,"stopped_limit":true,"stopping_word":"","tokens_cached":141,"timings":{"prompt_n":14,"prompt_ms":32.572,"prompt_per_token_ms":2.326571428571429,"prompt_per_second":429.8170207540218,"predicted_n":128,"predicted_ms":2887.882,"predicted_per_token_ms":22.561578125,"predicted_per_second":44.323140626936976}}

python

def llama_cpp_server_call(prompt):
    url = "http://{Private IP Address}:8080/completion"
    headers = {"Content-Type": "application/json"}
    data = {
        "prompt": prompt,
        "n_predict": 256
    }
    print(prompt)
    response = requests.post(url, headers=headers, json=data)
    print(response.json())
    return response.json().get('content')

demo = gr.Interface(fn=llama_cpp_server_call, inputs="text", outputs="text")
demo.launch(server_name="0.0.0.0", server_port=7870)

[URL]

https://aws.amazon.com/ko/ec2/instance-types/