Suyeon's Blog

[가상화] Xen과 KVM 하이퍼바이저 아키텍처

suyeon96 — Wed, 9 Feb 2022 01:00:14 +0900

가상화와 하이퍼바이저에 대해 작성한 이전 글들을 읽고 오는 것을 권장한다.

Xen Architecture

Xen은 AWS, Citrix, 알리바바클라우드, 화웨이, 인텔, AMD, KT 등에서 정말 많이 사용하는 오픈소스 하이퍼바이저이다. Xen은 대표적인 반가상화 하이퍼바이저로 등장했지만, HVM(하드웨어 기반 가상화) 기능을 활용하여 전가상화도 지원한다.

도메인(Domain)은 Xen 환경에서 동작하고 있는 가상머신을 의미한다. 도메인은 크게 Dom0와 DomU 2가지로 나뉘는데, Dom0는 실제 물리 디바이스와 통신하기 위한 디바이스 드라이브가 존재하는 가상화된 시스템이라고 보면 된다. 다시 정리하면, 실제 하드웨어와 연결되는 디바이스 드라이브를 가지고 다른 도메인들을 제어하는 Guest OS인 것이다. 이를 제외한 특권이 없는 (Unprivileged) 나머지 도메인을 DomU라고 한다.

Flow를 보면, 각 도메인은 Hypercall로 xen 하이퍼바이저에게 입/출력 요청을 하게 되고, Xen 하이퍼바이저는 이를 도메인 0에게 전달한다. Dom0는 받은 요청을 실제 디바이스에 전달하고 이런 방식으로 실제 장치와 입/출력을 하게 된다.

Dom0에서는 하나의 장치를 여러 도메인이 공유할 수 있도록 해야하기에 장치를 에뮬레이션 하는 방법을 통해 이를 해결한다. Xen에서는 QEMU라는 오픈소스 에뮬레이터를 Dom0에 동작시켜 BIOS, 디크 컨트롤러 그래픽 어댑터, 네트워크 카드 같은 장치를 에뮬레이션한다.

다른 도메인들의 장치 드라이브가 Dom0의 장치 드라이브와 연결이 되어야 하는데, Dom0의 XenStore라는 곳이 이를 가능하도록 하고 XenBus라는 것을 통해서 통신하게 된다. 도메인 간 통신 방법으로 shared memory라는 것을 사용하고, 도메인 간 메모리 공유를 지원하기 위해 Grant Table이란 자료구조를 사용한다.

KVM Architecture

KVM(Kernel-based Virtual Machine) 또한 전가상화 반가상화 모두 지원하지만, KVM은 대표적인 전가상화 하이퍼바이저이다. KVM의 가장 큰 특징이 이전 글에서 다루었던 하드웨어 지원 가상화이기에 전가상화 기준의 provisioning 관점에서 확인해보자.

당연히 KVM을 사용하기 위해서는 CPU에서 HVM(하드웨어 기반 가상화) 기능을 제공해야 한다. 간단하게 복습하자면, 예전에 Virtual Memory(가상메모리)를 지원하기 위해 CPU에서 Paging 기능을 하드웨어 차원에서 제공했던 것과 같이, CPU에서 가상화 기능을 하드웨어 차원에서 제공해주는 것이다.

하드웨어 기반 가상화를 위해 emulation이 필요한데 이 역할을 QEMU가 수행한다. QEMU로 OS 이미지를 실행하면 QEMU가 KVM에 요청을 하고 이 과정에서 vcpu 등이 생성된다. KVM이 Vm Entry 명령어를 실행하면 VMX root 모드에서 VMX non-root 모드로 전환된다. (trap 발생) non-root 모드의 Guest OS에서 실행되는 모든 system call은 trap이 걸려서 root모드로 이동해서 처리되고 다시 non-root 모드로 리턴하게 된다. 이렇게 vm을 사용하다가 guest os를 종료하면 KVM 디바이스 드라이버를 통해서 모든 리소스를 정리하고 끝나게 되는 것이다.

정리

XEN과 KVM 하이퍼바이저의 차이는 사실 개념부터 조금 다른데, Xen은 하이퍼바이저 위에서 모든 처리를 한다는 개념이면, KVM은 하이퍼바이저를 커널의 서브 모듈로 취급한다. 하지만 두 하이퍼바이저 모두 전가상화와 반가상화 둘다 지원한다. 그래서 오늘날엔 하이퍼바이저가 전가상화니 반가상화니 구분하는 경계가 모호해졌다. 전가상화 또한 cpu의 발달에 따라 점차 하드웨어 가상화로 자리 잡고 있는 추세이다.

Reference

[가상화] Full Virtualization & Para Virtualization (전가상화와 반가상화)

suyeon96 — Tue, 8 Feb 2022 01:00:19 +0900

이전 글에서 가상화와 하이퍼바이저에 대해서 알아보았다. 하이퍼바이저는 다시 가상화 방식에 따라 Full Virtualization과 Para Virtualization으로 분류된다.

Full Virtualization (전가상화)

Full Virtualization은 한글로 전가상화라고 한다. 말 그대로 하드웨어를 완전히 가상화하는 방식이다. 전부 가상화하기 때문에 Guest OS가 Host 시스템과 완전히 분리되어 실행된다. 따라서 Full Virtualization 방식에서 Guest OS는 자신이 가상머신의 OS인지 인지하지 못한다.

Host 하드웨어와 Guest OS 사이에 Hypervisor가 분명 존재하나, VM 입장에서는 가상화된 하드웨어를 진짜(물리) 하드웨어로 인지하고 있기 때문에, 실제 물리 자원에 대해 요청을 보낸다고 생각하게 된다. 원래 system call에 의해 App → Kernal → Hardware 순서로 서비스를 요청하는데, 이 과정을 하이퍼바이저 단에서 처리해 주는 것이다.

Hardware Assisted Full Virtualization

Full Virtualization을 구현하는 방법은 하드웨어 지원 가상화라는 방법과 소프트웨어 적으로 구현하는 방법으로 나뉜다. 사실 오늘날 전가상화는 하드웨어 지원 가상화와 동일한 개념으로 언급된다. 이 과정에 대해 자세히 살펴보자.

Dual-mode operation

(뒷 내용을 이해하기 위해 선행되어야 하는 내용이라 추가함)

먼저, OS는 Dual-mode operation(이중 동작 모드)라는 것을 지원한다. 사용자와 OS는 시스템 자원을 공유하는데, 사용자에게 제한을 두지 않으면 사용자가 메모리 내의 주요 자원들을 망가뜨릴 수 있기 때문에 이를 보호하기 위해 마련된 장치인 것이다.

이중동작 모드는 사용자모드와 커널모드로 구성되어 있다. 사용자가 사용하는 application이 사용자모드에서 작동되다가 OS에게 시스템 요청을 하게 되는 경우, 커널모드로 바꿔 요청된 서비스를 실행한 후에 다시 사용자모드로 전환되는 구조이다.

다시 본론으로 들어와서 하드웨어 지원 가상화 방법에 대해 살펴보려 한다. 가장 대표적으로 Intel CPU에서 하드웨어 지원 가상화를 위해 VT-x를 사용하는데, 이 메커니즘을 조금 뜯어보며 Trap과 Emulation에 대해 알아보자.

Trap & Emulation

하이퍼바이저는 Root모드에서 동작하고, 도메인은 Non-root모드에서 동작하도록 되어 있다. Non-root 모드에서 동작하는 도메인이 특권 명령을 실행하면 Trap이 발생하고 트랩 핸들러가 VM exit 명령을 수행해서 하이퍼바이저가 실행하도록 한다. 처리가 완료되면 다시 vm enter 명령을 통해 다시 도메인이 실행되도록 하드웨어가 명령어를 지원하는 방식인 것이다.

Hypervisor에서 이 모든 걸 다 처리해야 하고, 트랩이 발생할 때마다 에뮬레이션이 처리하는 오버헤드까지 생각하면 성능 저하가 생길 수밖에 없다.

Binary Translation

또한 Guest OS는 다양한 종류의 OS가 올라갈 수 있기에, 가상화된 하드웨어에 요청을 할 때 OS마다 인터페이스가 각기 다르다. 이런 다양한 형식을 하나의 형식으로 번역해주는 작업을 Binary Translation 이라고 한다.

당연히 Binary Translation 과정에서도 오버헤드가 발생하게 된다.

Hardware Assisted Full Virtualization vs Software Assisted Full Virtualization

하드웨어 지원 전가상화의 경우 Trap과 Emulation을 이용하여 Guest OS의 Application이 직접 하드웨어의 리소스를 요청해 사용할 수 있는 구조이다.

반면 소프트웨어 적으로 전가상화를 처리하는 경우 Binary Translation을 이용하여 각 단계에서 모든 명령에 대해 하나하나 다 가상화하는 방법으로 진행된다.

Para Virtualization (반가상화)

앞서 계속 언급했듯이 Full Virtualization의 경우 거쳐야 할 단계가 많기에 오버헤드가 발생하며, 성능이 느려진다. 그래서 이를 해결하고자 Para Virtualization이 등장했다.

Para Virtualization은 한글로 반가상화라고도 하는데, 핵심은 Hyper Call이다. Para Virtualization에 사용되는 Guest OS는 Hyper Call이라는 인터페이스를 통해 하이퍼바이저에 직접 요청을 날린다. 방식은 사실 OS에서 Application이 커널에게 system call로 서비스를 요청하는 방식과 동일하다. 요청을 날리는 주체가 Guest OS이고, 받는 대상이 하이퍼바이저라는 점이 다를 뿐이다.

전가상화에서의 Guest OS는 자신이 Guest OS인지 모른다고 하였다. 하지만 반가상화에서는 Guest OS가 Hypervisor에 직접 Hyper Call을 날려야 하기에, 자신이 Guest OS라는 사실을 인지해야만 한다. 따라서 반가상화 하이퍼바이저에 올라가는 Guest OS는 커널을 수정하여, Guest용 OS를 따로 만들어야 한다.

예시로 Para Virtualization 이해하기

전가상화는 모든 명령어를 가상화해야 하지만, 반가상화에서는 굳이 모든 명령어를 가상화할 필요가 없다. 이러한 메커니즘과 반가상화에서는 왜 Guest OS의 커널을 수정해야 하는지 개발자 관점에서 설명을 하려 한다.

xor eax, eax    # eax register 초기화
mov cr0, eax    # control register 값 설정

자주 사용되는 어셈블리 명령어를 예시로 드려하는데, 어셈블리를 처음 접하는 분들을 위해 간단히 설명을 하자면... 첫 번째는 범용레지스터 중에 산술연산이나 논리연산을 수행하는 eax라는 레지스터가 있는데, xor연산으로 이 레지스터의 값을 0으로 초기화시키는 명령어이다. 두 번째는 프로세서 상태와 동작모드를 제어하는 여러가지 제어 flag를 가지는 cr0라는 레지스터에 flag 값을 설정하는 명령어이다.

첫번째 명령어는 단순하게 범용 레지스터를 초기화시키는 명령어라 가상화하지 않아도 된다. 반면 두번째 명령어는 컨트롤 레지스터의 값을 수정하는 중요한 명령어기 때문에 반드시 가상화해야 한다.

전가상화에서는 내가 Guest OS인지 모르기 때문에 모든 명령어를 가상화하게 된다. 반면 반가상화에서는 이렇게 꼭 필요한 중요한 명령어만 가상화한다. 필요한 명령어만 가상화하니까 당연히 모든 명령어를 가상화하는 전가상화 보다 성능이 좋을 수밖에 없다.

따라서 반가상화를 위해서는 중요한 명령어와 아닌 명령어를 구분할 수 있어야 하는데, 그렇기에 Guest OS의 커널의 수정이 필요한 것이다. 그리고 Guest OS가 하이퍼바이저에게 명령어를 가상화해달라고 직접 요청하는데, 이게 Hyper Call이다.

Reference

[가상화] 하이퍼바이저와 가상화

suyeon96 — Mon, 7 Feb 2022 23:00:20 +0900

가상화 (Virtualization)

가상화란?

우리가 일반적으로 사용하는 PC는 cpu와 memory를 적게 사용하는 경우 전력도 적게 공급되도록 설계되어 있다. 반면, 서버의 경우 항상 최상의 성능을 유지해야 하기 때문에 전력을 최대로 공급해야 할뿐더러 서버를 조금 사용하든 많이 사용하든 IDC 임대료는 동일하다. 그렇다면 서버의 남는 cpu와 memory를 놀리지 말고 활용할 수 있는 방법을 찾아야 했다.

가장 간단한 방법은 동시에 여러 개의 Application을 동시에 올리는 방법이다. 웹서버, DB서버, DNS 등등... 그러나 이런 경우 서로 간의 영향이 생길뿐더러 서버가 다운되었을 때 모든 서비스가 중단되는 위험이 있다. 보안 문제도 필연적으로 발생하게 된다.

여기서 가상화의 개념이 시작된다.

가상화를 처음 접하는 경우 너무나도 추상적인 단어에 감을 잡기 어려울 수 있다. 사실 가상화라는 단어는 일종의 마케팅 용어라고 필자는 생각한다. 그래서 조금 쉽게 설명하자면, 가상화라는 것은 물리적인 하드웨어를 논리적으로 구분하는 것을 의미한다.

VM과 컨테이너

가상화의 핵심은 Isolation이다. 논리적으로 격리가 제대로 이루어지면, 격리된 각각의 가상 시스템에서 문제가 생겨도, 다른 영역에 영향을 미치지 않는다.

오늘날 가상화는 크게 2가지 유형이 존재하는데, 가상머신(vm)과 컨테이너(container)이다. 이 두 개는 개발자라면 혹은 IT에 발을 들였다면 이미 사용 중이거나 익숙한 단어일 것이다. 불과 몇 년 만에 얼마나 클라우드 transformation이 진행되었는지 실감이 난다. 앞으로는 더더욱 클라우드 기반 환경 위에서 모든 서비스가 운영되고, 개발이 진행될 것이다.

잠깐 옆으로 샜는데, 오늘은 활용적인 측면에서가 아니라 가상화 관점에서 이들을 바라볼 것이다. 두 개의 차이점을 간단하게 설명하자면, vm은 하이퍼바이저를 이용하여 리소스 전체를 가상화하는 방법이고, 컨테이너는 OS수준에서 프로세스를 컨테이너 형태로 격리하는 방법이다.

두 개의 차이점이 극명하며 그에 따른 장단점도 분명하기에, 각각의 기술에 대한 배경과 철학을 이해하면 큰 도움이 될 것이다. 이 글에서는 하이퍼바이저 가상화에 대해서 다룰 예정이다. (~~컨테이너도 원해요? 그럼 500원~~)

하이퍼바이저 (Hypervisor)

하이퍼바이저란?

위에서 계속 하이퍼바이저라는 단어를 언급했는데, 그렇다면 이 하이퍼바이저는 머 하는 친구일까?

vm을 만들기 위해서는 위 그림에서 보는 것처럼 물리적인 하드웨어를 논리적으로 가상화해야 한다. 이때 이를 담당하는 애가 바로 하이퍼바이저이다.

아직 이해가 안 된다면 Hypervisor라는 이름이 왜 붙었는지 뜯어보면 조금 더 명확하게 알 수 있다.

In general, operating systems are referred as supervisors.
As a hypervisor software is a supervisor of a “supervisor”, it is called hypervisor.

vm은 각각 독립적인 OS를 가지며, Application을 띄우고 Process를 올리는 것을 OS가 수행하고 관리한다. 따라서 일반적으로 운영체제를 supervisor라고 부른다. 위 그림에서 Guest OS가 supervisor 라면, 하이퍼바이저는 supervisor의 supervisor인 셈인 것이다.

TYPE 1 vs TYPE 2

하이퍼바이저는 크게 Type1 하이퍼바이저와 Type2 하이퍼바이저로 분류된다.

Type1 방식은 Native 혹은 베어메탈 형 하이퍼바이저라고도 불린다. 위 그림에서 볼 수 있듯이 Type1 하이퍼바이저는 베어메탈 하드웨어 위에 직접 설치되어 구동된다. 대표적인 Type1 하이퍼바이저에는 Xen, KVM, XenServer(Citrix), Hyper-V(Microsoft), ESX-i(vmware) 등이 있다.

Type2 방식은 Hosted 하이퍼바이저라고 불린다. Type2 하이퍼바이저는 다른 Application과 마찬가지로 Host OS 위에 설치된다. 베어메탈 하드웨어 위에 Host OS가 설치되고, 그 위에 하이퍼바이저가 실행되는 형태인 것이다. 테스트환경을 구성할 때 자주 사용하는 Oracle VirtualBox나 vmware Workstation이 여기에 해당된다.

당연히 Type2 방식이 Host OS라는 하나의 Layer가 더 존재하므로, 성능면에서 Type1이 Type2보다 유리하다. 실제 IDC를 클라우드화 시키는데 사용되는 하이퍼바이저도 모두 Type1 방식이다.

하이퍼바이저는 다시 가상화 방식에 따라 Full Virtualization과 Para Virtualization으로 분류된다. 다음 글에서 계속...

Reference

https://medium.com/@yavuzsert/q-a-hypervisors-58d6bccfd909

[Network] ONOS로 Open vSwitch 제어하기

suyeon96 — Tue, 1 Feb 2022 03:00:31 +0900

이 글 또한 작년 여름에 실습하며 정리한 내용인데, 블로그 활동을 잠시 쉬게 되면서 오늘에서야 포스팅하게 되었다. 이 글을 읽기 전 Cloud 카테고리의 [Network] Prefix가 붙은 글을 먼저 읽는 것을 권장한다.

ONOS란?

ONOS(Open Network Operating System)는 SDN/NFV 솔루션을 구축하기 위한 오픈소스 SDN 컨트롤러이다. (Apache 2.0 라이센스)

ONOS는 단순화된 프로그래밍 상의 인터페이스로 새로운 동적 네트워크 서비스를 생성하고 구축할 수 있는 유연성을 제공하며, 통신사급 솔루션을 구축하고자 하는 사업자의 요구를 충족시키기 위해 설계되었다. ONOS는 네트워크의 구성과 실시간 제어를 모두 제어하므로, 네트워크 패브릭 내에서 라우팅과 스위칭 제어 프로토콜을 실행할 필요가 없다.

ONOS 프로젝트는 고가용성, 확장성, 탄력성을 제공하는 컨트롤러 개발을 목적으로 하며, 대규모 네트워크 사업자들이 사용할 만한 수준의 고성능 SDN 컨트롤러 플랫폼을 지향한다. 또한 ONOS는 OpenFlow를 포함한 다양한 Southbound API 프로토콜을 지원한다.

ONOS 실습 시나리오

실습 내용 및 아키텍처

오늘은 아~주 간단한 SDN 환경을 구성해보려 한다. Open vSwitch로 docker container들 간의 네트워크 통신을 구성하고, SDN 컨트롤러인 ONOS를 통해 이를 제어할 것이다.

실습환경

vm : AWS EC2
os : Ubuntu Server 18.04 LTS (HVM)
spec : 2Core 8GB (t3.large)
disk : 80GB(ssd)

1. OVS 설치

$ sudo apt install -y openvswitch-switch

ovs 설치 확인

$ sudo ovs-vsctl show
  2d739b44-181a-4749-acad-8b4152da30c4
      ovs_version: "2.9.8"

$ ps -el | grep ovs
  5 S     0  2804     1  0  70 -10 -  5350 poll_s ?        00:00:00 ovsdb-server
  5 S     0  2868     1  0  70 -10 -  6734 poll_s ?        00:00:00 ovs-vswitchd

2. Docker 설치

$ sudo apt install docker.io

만약 아래와 같은 에러가 난다면...

E: Unable to locate package docker.io
E: Couldn't find any package by glob 'docker.io'
E: Couldn't find any package by regex 'docker.io'

apt update를 한번 해주자

$ sudo apt-get update

docker 설치 확인

$ docker version
    Client:
     Version:           20.10.2
     API version:       1.41
     Go version:        go1.13.8
     Git commit:        20.10.2-0ubuntu1~18.04.2
     Built:             Tue Mar 30 21:24:16 2021
     OS/Arch:           linux/amd64
     Context:           default
     Experimental:      true

    Server:
     Engine:
      Version:          20.10.2
      API version:      1.41 (minimum version 1.12)
      Go version:       go1.13.8
      Git commit:       20.10.2-0ubuntu1~18.04.2
      Built:            Mon Mar 29 19:27:41 2021
      OS/Arch:          linux/amd64
      Experimental:     false
     containerd:
      Version:          1.4.4-0ubuntu1~18.04.2
      GitCommit:
     runc:
      Version:          1.0.0~rc95-0ubuntu1~18.04.1
      GitCommit:
     docker-init:
      Version:          0.19.0
      GitCommit:

$ docker info
    Client:
     Context:    default
     Debug Mode: false

    Server:
     Containers: 0
      Running: 0
      Paused: 0
      Stopped: 0
     Images: 0
     Server Version: 20.10.2

현재 container를 올리지 않았기 때문에 count가 0 임을 확인할 수 있다.

docker network 확인

$ docker network ls
    NETWORK ID     NAME      DRIVER    SCOPE
    653f9e41c710   bridge    bridge    local
    f070c409eca0   host      host      local
    babc348f1c09   none      null      local

$ docker network inspect bridge
    [
        {
            "Name": "bridge",
            "Id": "653f9e41c710a0ad44198a509be9de04a099d902dace631ca45cf234ec983e44",
            "Created": "2021-07-07T07:39:52.188188984Z",
            "Scope": "local",
            "Driver": "bridge",
            "EnableIPv6": false,
            "IPAM": {
                "Driver": "default",
                "Options": null,
                "Config": [
                    {
                        "Subnet": "172.17.0.0/16"
                    }
                ]
            },
            "Internal": false,
            "Attachable": false,
            "Ingress": false,
            "ConfigFrom": {
                "Network": ""
            },
            "ConfigOnly": false,
            "Containers": {},
            "Options": {
                "com.docker.network.bridge.default_bridge": "true",
                "com.docker.network.bridge.enable_icc": "true",
                "com.docker.network.bridge.enable_ip_masquerade": "true",
                "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
                "com.docker.network.bridge.name": "docker0",
                "com.docker.network.driver.mtu": "1500"
            },
            "Labels": {}
        }
    ]

3. ovs-docker 설치

ovs와 docker 연결을 간단하게 control 하기 위해 ovs-docker utility를 이용할 것이다.

(자세한 내용은 https://github.com/openvswitch/ovs/blob/master/utilities/ovs-docker 참고)

$ cd /usr/bin

$ sudo wget https://raw.githubusercontent.com/openvswitch/ovs/master/utilities/ovs-docker
    --2021-07-07 07:54:06--  https://raw.githubusercontent.com/openvswitch/ovs/master/utilities/ovs-docker
    Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
    Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
    HTTP request sent, awaiting response... 200 OK
    Length: 8064 (7.9K) [text/plain]
    Saving to: ‘ovs-docker.1’

    ovs-docker.1             100%[==================================>]   7.88K  --.-KB/s    in 0s

    2021-07-07 07:54:06 (74.8 MB/s) - ‘ovs-docker.1’ saved [8064/8064]

4. OVS Bridge 생성

ovs-vsctl(OVS 제어 CLI)로 ovs1 브릿지를 생성한다.

$ ovs-vsctl add-br ovs1

생성한 ovs1 브릿지에 호스트 외부 접속 인터페이스 생성

$ ifconfig ovs1 173.16.1.1 netmask 255.255.255.0 up

ifconfig 명령어로 확인해보면 ovs스위치(ovs1)가 생성된 것을 확인할 수 있다.

$ ifconfig
    docker0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
            inet 172.17.0.1  netmask 255.255.0.0  broadcast 172.17.255.255
            ether 02:42:0f:30:4d:ce  txqueuelen 0  (Ethernet)
            RX packets 0  bytes 0 (0.0 B)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 0  bytes 0 (0.0 B)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
            inet 10.0.1.76  netmask 255.255.255.0  broadcast 10.0.1.255
            inet6 fe80::1b:19ff:feff:ef86  prefixlen 64  scopeid 0x20<link>
            ether 02:1b:19:ff:ef:86  txqueuelen 1000  (Ethernet)
            RX packets 73502  bytes 106507952 (106.5 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 6360  bytes 625896 (625.8 KB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
            inet 127.0.0.1  netmask 255.0.0.0
            inet6 ::1  prefixlen 128  scopeid 0x10<host>
            loop  txqueuelen 1000  (Local Loopback)
            RX packets 228  bytes 20072 (20.0 KB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 228  bytes 20072 (20.0 KB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    ovs1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet 173.16.1.1  netmask 255.255.255.0  broadcast 173.16.1.255
            inet6 fe80::580b:adff:fe18:1348  prefixlen 64  scopeid 0x20<link>
            ether 5a:0b:ad:18:13:48  txqueuelen 1000  (Ethernet)
            RX packets 0  bytes 0 (0.0 B)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 6  bytes 516 (516.0 B)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

5. container 생성

이제 docker container 2개를 생성해주자.

$ sudo docker run -t -i -d --name container1 alpine
    4f982ff32be0f196800fd6ac0c389914218f680d583c23d103761944d5d75d8c

$ sudo docker run -t -i -d --name container2 alpine
    5a3c1d7d1ec8ba8592d5a8d458ba3ab1aca4f2e9cb623987460292930cc92fcd

Container ID 확인

$ sudo docker ps
    CONTAINER ID   IMAGE     COMMAND     CREATED          STATUS          PORTS     NAMES
    5a3c1d7d1ec8   alpine    "/bin/sh"   15 seconds ago   Up 13 seconds             container2
    4f982ff32be0   alpine    "/bin/sh"   36 seconds ago   Up 34 seconds             container1

각 container의 네트워크 인터페이스 확인

$ sudo docker exec container1 ifconfig
    eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:02
              inet addr:172.17.0.2  Bcast:172.17.255.255  Mask:255.255.0.0
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:16 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:0
              RX bytes:1392 (1.3 KiB)  TX bytes:0 (0.0 B)

    lo        Link encap:Local Loopback
              inet addr:127.0.0.1  Mask:255.0.0.0
              UP LOOPBACK RUNNING  MTU:65536  Metric:1
              RX packets:0 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
$ sudo docker exec container1 ping 1.1.1.1

$ sudo docker exec container2 ifconfig
    eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:03
              inet addr:172.17.0.3  Bcast:172.17.255.255  Mask:255.255.0.0
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:54 errors:0 dropped:0 overruns:0 frame:0
              TX packets:42 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:0
              RX bytes:4856 (4.7 KiB)  TX bytes:3948 (3.8 KiB)

    lo        Link encap:Local Loopback
              inet addr:127.0.0.1  Mask:255.0.0.0
              UP LOOPBACK RUNNING  MTU:65536  Metric:1
              RX packets:0 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
$ sudo docker exec container2 ping 1.1.1.1

6. container와 ovs bridge 연결

ovs1과 container를 연결해주기 위해서는 각각 port를 만들고 ip를 할당하고 링크해줘야 하는데, 이걸 간단하게 수행하기 위해 아까 설치한 ovs-docker를 이용한다.

$ sudo ovs-docker add-port ovs1 eth1 container1 --ipaddress=173.16.1.2/24
$ sudo ovs-docker add-port ovs1 eth1 container2 --ipaddress=173.16.1.3/24

다시 각 container의 네트워크 인터페이스를 확인해보면, OVS와 연결된 eth1을 확인할 수 있다.

또한 각 container 간 ping 테스트도 정상적으로 수행된다.

(글이 길어져서 container2만 기재함)

$ sudo docker exec container2 ifconfig # check for Internet
    eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:03
              inet addr:172.17.0.3  Bcast:172.17.255.255  Mask:255.255.0.0
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:424 errors:0 dropped:0 overruns:0 frame:0
              TX packets:410 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:0
              RX bytes:39996 (39.0 KiB)  TX bytes:38948 (38.0 KiB)

    eth1      Link encap:Ethernet  HWaddr CE:C5:78:89:8C:50
              inet addr:173.16.1.3  Bcast:0.0.0.0  Mask:255.255.255.0
              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
              RX packets:10 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:796 (796.0 B)  TX bytes:0 (0.0 B)

    lo        Link encap:Local Loopback
              inet addr:127.0.0.1  Mask:255.0.0.0
              UP LOOPBACK RUNNING  MTU:65536  Metric:1
              RX packets:0 errors:0 dropped:0 overruns:0 frame:0
              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
              collisions:0 txqueuelen:1000
              RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

$ sudo docker exec container2 ping 173.16.1.2
    PING 173.16.1.2 (173.16.1.2): 56 data bytes
    64 bytes from 173.16.1.2: seq=0 ttl=64 time=0.922 ms
    64 bytes from 173.16.1.2: seq=1 ttl=64 time=0.176 ms
    64 bytes from 173.16.1.2: seq=2 ttl=64 time=0.111 ms
    64 bytes from 173.16.1.2: seq=3 ttl=64 time=0.101 ms
    64 bytes from 173.16.1.2: seq=4 ttl=64 time=0.114 ms

7. ONOS 설치

지금까지 구성한 환경에서 OVS는 L2 스위치 역할을 수행한다.

이제는 본 포스팅의 목적이었던 SDN Controller ONOS를 설치하고 연결할 것이다.

ONOS 설치

$ sudo docker run -t -d -p 1181:8181 -p 1101:8101 -p 1653:6653 --name onos1 onosproject/onos
    latest: Pulling from onosproject/onos
    7595c8c21622: Pull complete
    d13af8ca898f: Pull complete
    70799171ddba: Pull complete
    b6c12202c5ef: Pull complete
    a3caae5bc1ad: Pull complete
    c041e8f95d65: Pull complete
    ed1837af27c7: Pull complete
    Digest: sha256:f6b624201b99aa3fbfb25ee9410f48c4a1b3be8bf5ebafb62816f1b694142224
    Status: Downloaded newer image for onosproject/onos:latest
    4916b224f3200337a78489c6a2198a193020daa825be3fec21366a3a78298127

8181 : web dashboard 접속을 위한 port
8101 : CLI 접속을 위한 ssh port
6653 : ovs - onos 통신을 위한 port

여러 개의 ONOS를 구성할 수 있기 때문에 임의로 포트포워딩을 해줬다.

http://{ipaddress:1181}/onos/ui로 ONOS web에 접속할 수 있다.

(1181로 포트포워딩을 하지 않은 경우 8181로 접속)

default 계정으로 로그인하면 아래와 같은 화면을 볼 수 있다.

(ID : onos, Password : rocks)

ovs 정보를 확인해보자.

$ sudo ovs-vsctl show
    2d739b44-181a-4749-acad-8b4152da30c4
        Bridge "ovs1"
            Port "da5a724dd0214_l"
                Interface "da5a724dd0214_l"
            Port "7abbaea7e4494_l"
                Interface "7abbaea7e4494_l"
            Port "ovs1"
                Interface "ovs1"
                    type: internal
        ovs_version: "2.9.8"

docker ps 확인

$ docker ps
    CONTAINER ID   IMAGE              COMMAND                  CREATED        STATUS        PORTS                                                                                        NAMES
    4916b224f320   onosproject/onos   "./bin/onos-service …"   14 hours ago   Up 14 hours   6640/tcp, 9876/tcp, 0.0.0.0:1653->6653/tcp, 0.0.0.0:1101->8101/tcp, 0.0.0.0:1181->8181/tcp   onos1
    5a3c1d7d1ec8   alpine             "/bin/sh"                15 hours ago   Up 15 hours                                                                                                container2
    4f982ff32be0   alpine             "/bin/sh"                15 hours ago   Up 15 hours                                                                                                container1

8. ONOS(SDN Controller)에 OVS 연결

ovs1을 ONOS controller에 연결한다.

$ sudo ovs-vsctl set-controller ovs1 tcp:172.17.0.4:6653

다시 ovs 정보를 확인해보자.

ovs1 Bridge에 Controller가 추가된 것을 확인할 수 있다.

$ sudo ovs-vsctl show
    2d739b44-181a-4749-acad-8b4152da30c4
        Bridge "ovs1"
            Controller "tcp:172.17.0.4:6653"
            Port "da5a724dd0214_l"
                Interface "da5a724dd0214_l"
            Port "7abbaea7e4494_l"
                Interface "7abbaea7e4494_l"
            Port "ovs1"
                Interface "ovs1"
                    type: internal
        ovs_version: "2.9.8"

vm의 네트워크 인터페이스 구성 확인

$ ifconfig
    7abbaea7e4494_l: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet6 fe80::5419:c9ff:fead:8bf0  prefixlen 64  scopeid 0x20<link>
            ether 56:19:c9:ad:8b:f0  txqueuelen 1000  (Ethernet)
            RX packets 71544  bytes 6060936 (6.0 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 67802  bytes 6979026 (6.9 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    da5a724dd0214_l: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet6 fe80::8c9b:76ff:fe2c:c856  prefixlen 64  scopeid 0x20<link>
            ether 8e:9b:76:2c:c8:56  txqueuelen 1000  (Ethernet)
            RX packets 57500  bytes 5465320 (5.4 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 67852  bytes 6983926 (6.9 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    docker0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet 172.17.0.1  netmask 255.255.0.0  broadcast 172.17.255.255
            inet6 fe80::42:fff:fe30:4dce  prefixlen 64  scopeid 0x20<link>
            ether 02:42:0f:30:4d:ce  txqueuelen 0  (Ethernet)
            RX packets 191928  bytes 27898779 (27.8 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 174754  bytes 39969595 (39.9 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
            inet 10.0.1.76  netmask 255.255.255.0  broadcast 10.0.1.255
            inet6 fe80::1b:19ff:feff:ef86  prefixlen 64  scopeid 0x20<link>
            ether 02:1b:19:ff:ef:86  txqueuelen 1000  (Ethernet)
            RX packets 717884  bytes 834421238 (834.4 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 209467  bytes 31302450 (31.3 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
            inet 127.0.0.1  netmask 255.0.0.0
            inet6 ::1  prefixlen 128  scopeid 0x10<host>
            loop  txqueuelen 1000  (Local Loopback)
            RX packets 454  bytes 44426 (44.4 KB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 454  bytes 44426 (44.4 KB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    ovs1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet 173.16.1.1  netmask 255.255.255.0  broadcast 173.16.1.255
            inet6 fe80::580b:adff:fe18:1348  prefixlen 64  scopeid 0x20<link>
            ether 5a:0b:ad:18:13:48  txqueuelen 1000  (Ethernet)
            RX packets 55  bytes 4396 (4.3 KB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 36  bytes 2616 (2.6 KB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    veth5225a25: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet6 fe80::8485:afff:fe25:9c5f  prefixlen 64  scopeid 0x20<link>
            ether 86:85:af:25:9c:5f  txqueuelen 0  (Ethernet)
            RX packets 73191  bytes 6952974 (6.9 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 73227  bytes 6955458 (6.9 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    vethb61a685: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet6 fe80::fc67:f0ff:fe39:9a90  prefixlen 64  scopeid 0x20<link>
            ether fe:67:f0:39:9a:90  txqueuelen 0  (Ethernet)
            RX packets 73207  bytes 6954486 (6.9 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 73247  bytes 6957398 (6.9 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    vethed92c01: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
            inet6 fe80::1cff:1bff:fe40:2d5c  prefixlen 64  scopeid 0x20<link>
            ether 1e:ff:1b:40:2d:5c  txqueuelen 0  (Ethernet)
            RX packets 45530  bytes 16678311 (16.6 MB)
            RX errors 0  dropped 0  overruns 0  frame 0
            TX packets 28389  bytes 26064505 (26.0 MB)
            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

9. ONOS 설정

최초에는 Default Drivers와 ONOS GUI2 만 running 상태이다.

필요한 Application을 찾아서 올려주자.

토폴로지를 확인하면 OVS bridge에 container 2개가 연결된 것을 확인할 수 있다.

토폴로지 단축키 참고!

10. docker network 확인

bridge 정보 확인

$ docker network inspect bridge
    [
        {
            "Name": "bridge",
            "Id": "653f9e41c710a0ad44198a509be9de04a099d902dace631ca45cf234ec983e44",
            "Created": "2021-07-07T07:39:52.188188984Z",
            "Scope": "local",
            "Driver": "bridge",
            "EnableIPv6": false,
            "IPAM": {
                "Driver": "default",
                "Options": null,
                "Config": [
                    {
                        "Subnet": "172.17.0.0/16"
                    }
                ]
            },
            "Internal": false,
            "Attachable": false,
            "Ingress": false,
            "ConfigFrom": {
                "Network": ""
            },
            "ConfigOnly": false,
            "Containers": {
                "4916b224f3200337a78489c6a2198a193020daa825be3fec21366a3a78298127": {
                    "Name": "onos1",
                    "EndpointID": "24f811b1e99723ba5eac54f3754106488a4a7e688283b5e33268135e37382469",
                    "MacAddress": "02:42:ac:11:00:04",
                    "IPv4Address": "172.17.0.4/16",
                    "IPv6Address": ""
                },
                "4f982ff32be0f196800fd6ac0c389914218f680d583c23d103761944d5d75d8c": {
                    "Name": "container1",
                    "EndpointID": "9a9012e246ca997921de6b15a75ea60cb81cbe59878e17c4e776a991ad92188a",
                    "MacAddress": "02:42:ac:11:00:02",
                    "IPv4Address": "172.17.0.2/16",
                    "IPv6Address": ""
                },
                "5a3c1d7d1ec8ba8592d5a8d458ba3ab1aca4f2e9cb623987460292930cc92fcd": {
                    "Name": "container2",
                    "EndpointID": "858a1b678e7771ffcc439d5594e7c8903a5fca66e4ffb82d84315dcbde4570cc",
                    "MacAddress": "02:42:ac:11:00:03",
                    "IPv4Address": "172.17.0.3/16",
                    "IPv6Address": ""
                }
            },
            "Options": {
                "com.docker.network.bridge.default_bridge": "true",
                "com.docker.network.bridge.enable_icc": "true",
                "com.docker.network.bridge.enable_ip_masquerade": "true",
                "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
                "com.docker.network.bridge.name": "docker0",
                "com.docker.network.driver.mtu": "1500"
            },
            "Labels": {}
        }
    ]

host 정보도 확인해보자

$ docker network inspect host
    [
        {
            "Name": "host",
            "Id": "f070c409eca02b9afd47922696154def19c06157830181310936ac09749a6875",
            "Created": "2021-07-07T07:39:52.129644722Z",
            "Scope": "local",
            "Driver": "host",
            "EnableIPv6": false,
            "IPAM": {
                "Driver": "default",
                "Options": null,
                "Config": []
            },
            "Internal": false,
            "Attachable": false,
            "Ingress": false,
            "ConfigFrom": {
                "Network": ""
            },
            "ConfigOnly": false,
            "Containers": {},
            "Options": {},
            "Labels": {}
        }
    ]

iptable 확인

$ iptables -t nat -L -n
    Chain PREROUTING (policy ACCEPT)
    target     prot opt source               destination
    DOCKER     all  --  0.0.0.0/0            0.0.0.0/0            ADDRTYPE match dst-type LOCAL

    Chain INPUT (policy ACCEPT)
    target     prot opt source               destination

    Chain OUTPUT (policy ACCEPT)
    target     prot opt source               destination
    DOCKER     all  --  0.0.0.0/0           !127.0.0.0/8          ADDRTYPE match dst-type LOCAL

    Chain POSTROUTING (policy ACCEPT)
    target     prot opt source               destination
    MASQUERADE  all  --  172.17.0.0/16        0.0.0.0/0
    MASQUERADE  tcp  --  172.17.0.4           172.17.0.4           tcp dpt:8181
    MASQUERADE  tcp  --  172.17.0.4           172.17.0.4           tcp dpt:8101
    MASQUERADE  tcp  --  172.17.0.4           172.17.0.4           tcp dpt:6653

    Chain DOCKER (2 references)
    target     prot opt source               destination
    RETURN     all  --  0.0.0.0/0            0.0.0.0/0
    DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:1181 to:172.17.0.4:8181
    DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:1101 to:172.17.0.4:8101
    DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:1653 to:172.17.0.4:6653

Reference

[Network] Virtual Network와 Open vSwitch (네트워크 가상화)

suyeon96 — Sun, 30 Jan 2022 23:34:09 +0900

예전에 올리려고 정리해놨던 글인데, 블로그 활동을 잠시 쉬다가 오랜만에 포스팅한다. Cloud 카테고리에서 Network 영역을 지속해서 다루는 이유는, 네트워크가 가상화의 핵심 요소이며 Cloud를 이해하기 위한 기본적인 소양이기 때문이다.

네트워크 가상화

기존 network 인프라

기존의 레거시 인프라에서는 Application을 호스팅하기 위해 물리적인 서버와 네트워크 장비들이 필요했다. 서버들 간 통신을 가능하도록 하기 위해서 각 서버에는 외부 네트워크에 연결되는 NIC(Network Interface Card)가 포함되어 있어야 하며, NIC은 네트워크 인프라를 통해 endpoint 간 통신을 가능하도록 한다.

위 그림에서 볼 수 있듯이 스위치는 이러한 endpoint 간 효율적인 패킷 통신을 지원하기 위한 장비인 것이다.

가상화된 network 인프라

반면 VM(가상머신) 환경에서는 물리적 하드웨어를 가상화하여 여러 운영체제와 Application이 하드웨어를 공유할 수 있도록 한다. (하이퍼바이저가 이런 일을 수행하는데, 가상화와 하이퍼바이저에 대해서는 곧 새로운 글로 포스팅할 예정)

하이퍼바이저는 각 VM에 대해 하나 이상의 가상 NIC(vNIC)을 생성할 수 있다. vNIC은 NIC의 인터페이스를 구현하여 마치 VM의 물리적 NIC처럼 역할을 수행한다. 이렇게 하이퍼바이저는 가상 네트워크의 동적 구현을 허용하도록 하며, 가상 스위치(vSwitch)를 통해 VM 간 통신이 가능하도록 한다. 또한 하이퍼바이저는 서버의 물리적인 NIC을 하이퍼바이저의 가상화된 네트워크 인프라에 연결하여, 외부 네트워크와의 통신을 가능하도록 한다.

네트워크 가상화로 인해 Virtual Appliance 등 다른 많은 혁신이 가능해졌는데, Virtual Switch에 대해 조금 더 알아보자.

Virtual Switching

네트워크 가상화를 개발하는데 있어 주요 항목 중 하나는 가상 스위치의 개발이다. 가상 스위치는 vNIC을 물리적 NIC에 연결하고, local 통신을 위해 vNIC을 다른 서버의 vNIC들과 연결한다. 흥미로운 점은 가상 스위치 내에서의 속도 limit이 네트워크 속도에 구애받는 것이 아니라, 메모리 대역폭에 관련되어 있다는 점이다. 이는 네트워크 인프라의 오버헤드를 최소화시키며, Local VM들 간 호율적인 통신을 가능하도록 한다. (물리적인 네트워크는 물리적 서버 내에서 VM들 간 트래픽이 격리된 상태에서 서버 간의 통신에만 사용된다.)

하지만 리눅스는 이미 커널 내에 Layer2 스위치를 포함하고 있는데, 왜 가상 스위치가 필요할까? 여러 이유가 있지만, 가장 중요한 핵심 중 하나는 Distributed Virtual Switch(분산 가상 스위치)이다. 이 스위치 유형은 근본적인 서버 아키텍처를 투명하게 만드는 방식으로 서버 간 bridging을 가능하도록 한다.

위 그림에서 볼 수 있듯이, 한 서버 내의 가상 스위치는 다른 서버의 가상 스위치와 투명하게 결합할 수 있으며, 다른 서버의 분산 가상 스위치에 연결할 수 있다. 이는 서버 간의 VM 마이그레이션 혹은 Virtual Interface의 마이그레이션을 훨씬 간단하게 만들어준다.

참고로 서버 내에서 로컬 트래픽을 격리하게 되면, 트래픽을 외부(network analyzer 등)에서 볼 수 없다는 문제가 있다. 이 문제를 해결하기 위해 OpenFlow, NetFlow, sFlow와 같은 다양한 체계를 통해 원격으로 트래픽을 제어하고 모니터링할 수 있다.

Open vSwitch

Open vSwitch는 가상 스위치 분야에서 가장 중요한 프로젝트이다. 초기에 분산 가상 스위치의 구현체들은 closed되었고, 독립적인 하이퍼바이저 세트로만 운영되도록 제한되었다. 하지만 오늘날의 클라우드 환경에서는 여러 하이퍼바이저가 공존할 수 있는 이기종 환경을 지원하는 것이 일반적이다.

Open vSwitch는 Apache 2.0 라이선스에 따라 오픈 소스로 사용할 수 있는 multilayer 가상 스위치이며, Zen, KVM, VirtualBox 등 다양한 오픈소스 하이퍼바이저 솔루션을 지원한다.

Open vSwitch는 스위치 데몬과 flow-based 스위칭을 관리하는 companion 커널 모듈로 구성된다. NetFlow, sFlow, CLI 및 RSPAN과 같은 표준 관리 인터페이스를 지원할 뿐만 아니라, OpenFlow를 사용하여 프로그램 확장 및 제어를 수용할 수 있다. 또한 Open vSwitch는 OVSDB라는 관리 프로토콜을 사용한다.

관리하는 모든 것들을 실제로 물리적으로 만질 수 있는 시절이 있었다. 하지만 오늘날, 가상화 기술이 발전하는 세상에서 물리적인 장치와 서비스들은 점차 사라지고 있다. 물리적 네트워크 또한 트래픽을 격리하고, 지리적으로 다른 엔티티들 간 네트워크를 가상화시키기 위해 논리적으로 분할된다.

네트워크를 가상화 함으로써 클라우드 환경의 유연성과 확장성은 더욱 늘어나게 되며, 이는 생산성을 높이고 비용을 절감하는 효과를 가져온다. 또한 하드웨어가 간소화되고 원격으로 작업이 가능해지며, 이를 운영하는 엔터프라이즈 기업은 네트워크를 제어하고 모니터링하고 관리하는데 필요한 리소스를 줄일 수 있다.

Reference

https://developer.ibm.com/tutorials/l-virtual-networking/

https://www.bmc.com/blogs/virtual-network/

https://www.openvswitch.org/

https://en.wikipedia.org/wiki/Open_vSwitch

[Network] SDN/NFV의 관계와 차이 (feat. VNF, CNF)

suyeon96 — Wed, 28 Jul 2021 10:23:54 +0900

최근 SDDC 또는 5G에 대하여 이야기할 때 SDN/NFV라는 2개의 용어가 항상 등장한다.

여기에 VNF, 더 나아가 CNF까지 함께 이야기하곤 한다.

이들의 차이는 무엇이고 어떤 관계인지 알아보자.

SDN (Software Defined Networking)

간단하게 설명하자면 SDN이란 소프트웨어를 이용하여 네트워크 리소스를 가상화하는 것이다.

한줄로 설명하기에는 너무나도 추상적이며 불친절하다.

조금 더 핵심적인 부분을 설명하자면, SDN은 네트워크 장치의 Control Plane(제어부)과 Data Plane(전송부)을 분리하는 개념이다.

따라서 중앙에서 전체 네트워크를 프로그래밍하고 관리할 수 있으며, 하나의 SDN 컨트롤러가 여러 개의 네트워크 장치를 제어할 수 있는 것이다.

결과적으로 SDN을 한 단어로 표현하자면 네트워크 추상화(Abstraction)이다.

SDN에 대한 자세한 설명은 이전글([Network] SDN이란?)에서 다루었으니 한번 읽어보면 도움이 될 것이다.

NFV (Network Function Virtualization)

NFV란 기존의 네트워크 하드웨어 장비를 소프트웨어 형태로 가상화하는 개념이다.

즉, 라우터(Router), 방화벽(Firewall), 로드밸런서(Load Balancer), IDS, IPS, DNS, 캐싱 등의 물리적인 네트워크 기능을 여러 사용자 또는 필요한(+저렴한) 리소스(서버, 스토리지 등)에서 사용할 수 있는 것이다.

NFV 또한 일반적인 리소스 가상화의 특징을 그대로 가지고 있다.

네트워크 기능이 가상화 됨으로써 값비싼 장비와 전용 솔루션 대신 저렴한 범용 하드웨어를 사용할 수 있다.

네트워크 인프라를 구축하고 운영함에 있어서 유연성과 효율성이 높아짐은 당연하다.

이는 특히 SDN 환경에서 큰 효과를 발휘한다.

(SDN에 대한 이전 글을 보고왔다면 이 말을 바로 이해할 수 있을 것이다)

SDN과 NFV의 차이와 관계

그렇다면 SDN과 NFV의 차이를 정리해보자.

SDN은 네트워크의 제어 기능과 전달 기능을 소프트웨어로 분리하여 추상화시키는 것이다.

좀더 엄밀히 말하면 Control Plain을 소프트웨어화 시키는 것이다.

OSI 7Layer 기준으로 SDN은 2-3 Layer를 담당하며, 스위치, 라우터, 무선 access 포인트 같은 네트워크 인프라를 최적화한다.

NFV는 네트워크 Appliance 기능을 가상화하여 하드웨어와 소프트웨어로 분리하는 것이다.

네트워크 기능 가상화에 초점이 맞춰져 있으며, 이는 Data Plain을 가상화한다는 의미이다.

OSI 7Layer 기준으로 NFV는 4-7 Layer를 포함하며, Edge 인증, 로드밸런서, 방화벽, WAN 컨트롤러 등의 네트워크 기능의 배포를 최적화한다.

SDN과 NFV는 서로 상호 보완적이지만, 독립적인 구성도 가능하다.

SDN 없이 NFV만 구현할 수도 있고, SDN을 구현하는데 반드시 NFV만을 사용해야 하는것도 아니다.

NFV는 SDN을 구현하기 위한 하나의 usecase인 것이다.

하지만 SDN 환경에서 NFV의 효율이 매우 뛰어나기 때문에 이 둘은 항상(?) 붙어다니고 있다.

NFV Architecture

참고로 ETSI(유럽통신표준협회)는 NFV 인프라 아키텍처를 VNF, NFVi, MANO 3가지 구성요소로 정의한다.

VNFs (Virtualized Network Functions)

VNF는 네트워크 기능을 제공하는 소프트웨어 애플리케이션이며, VM(가상머신)으로 배포된다.

VNF에 대해서는 아래에서 조금 더 자세하게 설명할 예정이다.

NFVI (NFV Infrastructure)

NFVI는 VNF를 호스팅하기 위해 하드웨어 리소스를 제공하고, VNF가 네트워크 기능을 수행할 수 있도록 소프트웨어를 지원하는 가상화 계층이다.

보통 호스트 서버의 HW자원을 가상화하고 여러 VM들을 독립적으로 실행하기 위해 하이퍼바이저를 이용한다.

대표적인 NFVI 플랫폼(VIM)으로는 OpenStack이 있다.

MANO (Management and Network Orchestration)

NFV 인프라 관리를 위한 프레임워크이다.

새로운 VNF를 생성하고 설정하며, 전체 NFV를 조직하고 관리한다.

운영자 중심 커뮤니티인 OSM(Open Source MANO)에서는 상업용 NFV네트워크 요구사항을 만족하는 오픈 소스 MANO 스택을 제공한다.

VNF (Virtual Network Function) / CNF (Cloud-Native Network Function)

위 그림에서 보았듯이 NFV로부터 VNF라는 개념도 함께 등장하였다.

VNF란 네트워크 기능을 가상머신 상에서 구현한 것을 의미한다.

네트워크 하드웨어를 emulate한 vm을 이용하면, Cloud 컴퓨팅 환경을 완벽하게 가상화할 수 있다.

또한, 최근에는 컨테이너를 이용하여 네트워크 기능을 생성한다.

이를 Cloud-Native Network Function(CNF)라고 한다.

Cloud Native 구조에서는 VNF가 모듈화되어 VNF 구성요소들이 기능 또는 특성별로 마이크로서비스들로 분리되고, 마이크로서비스들은 컨테이너에 배포된다.

마이크로서비스들은 재사용이 가능하며 뛰어난 확장성을 갖는다.

하지만, MSA 구조는 서비스 민첩성이 향상되는 동시에 복잡성도 증가하기 때문에 CNF의 생성, 배포, 확장을 자동화하여 네트워크 운영의 편의성과 효율성을 높이는 일은 매우 중요하다.

Reference

https://codilime.com/the-difference-between-sdn-and-nfv-a-simple-guide/

https://www.netmanias.com/ko/post/blog/14631/5g-sdn-nfv/evolution-to-5g-cloud-native-1

https://post.naver.com/viewer/postView.nhn?volumeNo=12596096&memberNo=34920570

https://osm.etsi.org/

[Network] SDN(Software Defined Network) 이란?

suyeon96 — Mon, 26 Jul 2021 10:27:00 +0900

SDN이란?

SDN(Software Defined Network)이란 소프트웨어를 통해 네트워크 리소스를 가상화하고 추상화하는 네트워크 인프라에 대한 접근 방식을 의미한다.

조금 더 쉽게 설명하자면, 소프트웨어 애플리케이션과 API를 이용하여 네트워크를 프로그래밍하고, 중앙에서 전체 네트워크를 제어하고 관리하는 것이다.

SDN 작동방식

SDN에서 가장 핵심은 네트워크 장비의 Control Plane(제어부)와 Data Plane(전송부)의 분리이다.

Control Plane은 네트워크 장비를 제어하는 뇌에 해당하고, Data Plane은 데이터를 전송하는 역할을 하는 것이다.

기존의 라우터(Router)라는 네트워크 장비에는 제어부와 전송부가 같이 존재한다.

제어부에서 최적의 경로를 계산하고 전송부가 데이터를 전송하는 방식이다.

따라서 네트워크 운영자는 각각의 네트워크 장비를 수동으로 관리해야 했으며, 전체 기능이 필요하지 않은 경우에도 비싼 라우터를 구매하여 사용하는 수밖에 없었다.

(* 첨언으로 Cisco는 전 세계의 네트워크 장비를 수십 년간 거의 독점적으로 공급하며 어마어마하게 성장하였다.)

SDN을 적용하면 제어부와 전송부를 분리한다.

제어부를 별도의 컴퓨팅 서버로 분리하고, 네트워크 장비는 데이터 전송 기능만 담당하도록 하는 것이다.

SDN 장점

1. 비용 절감

제어부는 여러 네트워크 장비를 제어할 수 있기 때문에 관리가 관소화 되고 운영에 들어가는 비용을 줄일 수 있다.

또한, 각 장비의 사양을 각각의 기능에 최적화시킬 수 있으므로 더 이상 눈물을 머금고 리소스의 낭비를 보고 있을 필요가 없다.

2. 확장성 및 유연성

"가상화"라는 기술을 설명할 때 항상 따라오는 장점이다.

SDN 또한 네트워크를 가상화한다는 점에서 마찬가지이다.

하드웨어를 소프트웨어로 전환하며, 더 이상 물리적인 리소스의 한계에 구애받지 않아도 된다.

원하는 시기에 필요한 만큼 네트워크 리소스를 확장하거나 축소할 수 있다.

벤더 별로 각각의 장치를 프로그래밍하고 그 한계에 타협하는 상황에서 벗어나, 네트워크 장비를 선택할 때 더 높은 유연성을 확보할 수 있게 된다.

SDN의 역사

아래 지표에서 볼 수 있듯이 네트워크를 프로그래밍 하는 것은 과거 20년 전부터 지속해서 발전해왔다.

컴퓨터와 통신에 있어 네트워크는 정말 중요한 분야이다. (매우 기본이지만 매우 어렵기도 하다..)

Legacy 네트워크와 별개로 우리는 네트워크를 Software화 시키는 것이 왜 중요한지, 이를 위해 역사상 어떤 노력들이 진행되어 왔는지 살펴볼 필요가 있다.

위 지표를 가져온 논문(The Road to SDN: An Intellectual History of Programmable Networks)에서 이를 확인할 수 있다.

하나하나 짚고 넘어가고 싶지만, 글이 너무 길어질 것 같아 (사실 필자가 글로 서술할 정도로 완벽하게 이해하지 못함) 넘어간다..

하지만 SDN의 창시자로 불리는 Scott Shenker(UC버클리 교수)과 Nick Mckeown(스탠포드 대학 교수) 2명은 알아두도록 하자.

이들을 비롯한 SDN 창시자들은 ONF(Open Networking Foundation)라는 비영리 단체를 만들고, OpenFlow와 SDN Controller ONOS(Open Network Operating System)를 개발하였다.

구글 G-scale 발표

실제로 SDN이 현업에 적용되며 빠르게 발전한 계기는 2012년 4월 구글에서 G-scale SDN 적용 사례를 발표하고 나서부터가 아닌가 싶다.

G-Scale은 구글이 2010년에 시작한 OpenFlow 프로젝트로 전 세계에 흩어져있는 구글 데이터센터 백본(Backbone) 구간을 SDN 기반으로 전환하는 프로젝트이다.

백본(Backbone) 네트워크는 사용자 네트워크와 다르게 한번에 대용량 데이터가 전송된다.

(참고 : 백본 네트워크 - 데이터센터 간 연결망, 사용자 네트워크 - 사용자와 구글 서비스의 연결망)

딱 봐도 어마어마하게 많은 구글의 초울트라 빅데이터들을 옮기는 작업은 보통 어려운 일이 아닐 것이다.

이에 구글은 자체적으로 네트워크 장비를 제작하고 Openflow를 도입하여 SDN을 구현하고 이를 해결하였다.

SDN 적용으로 구글은 크게 3가지 이득을 볼 수 있었다.

1. 50% → 100%

기존의 Legacy Network 인프라의 경우 리소스 활용률이 평균 50%가 채 되지 못한다고 한다.

각각의 네트워크 장비들이 벤더에 종속되어 있어 호환성 문제로 기능을 100% 활용할 수 없을 뿐만 아니라 전체 네트워크 스위치들에 대한 컨트롤이 불가능하기 때문이다.

위에서 언급했듯이 다양한 네트워크 상황에 딱맞는 장비를 구할 수도 없기 때문에 오버스펙의 장비를 구매해야 한다.

하지만 구글은 SDN을 구현하여 거의 100%에 가까운 인프라 리소스 활용률을 만들어냈다. ㄷㄷ

2. WAN(Wide Area Network) 분야에서의 경로 최적화

WAN대역에서 가장 빠른 경로를 계산하여 데이터 전송 속도를 높이고, 사용자에게는 빠르고 고품질의 서비스를 제공하게 되었다.

구글은 전 세계를 대상으로 하는 서비스이기 때문에 WAN 대역에서의 데이터 전송 성능 향상은 더욱 중요하였다.

3. 비용 절감

SDN 컨트롤러와 화이트박스 스위치의 조합을 통해 데이터센터 내의 네트워크 구축 비용을 획기적으로 낮췄다.

화이트박스 스위치(WhiteBox Switch)란 SDN에서 나온 개념으로 기존 레거시 장비의 제어 방식이 공개가 안 돼서 ‘블랙박스’라고 불리는 것과 반대의 개념이다. 네트워크 장비의 동작 방식을 사용자가 결정하고 투명하게 공개되어 있다는 의미이다.

또한 동시에 데이터센터 내의 서비스 트래픽 특성을 전체적으로 파악하여 최적의 네트워크를 구성하고, 비용 또한 최적화시킬 수 있었다.

이후 세계의 통신사들은 주도적으로 SDN을 도입하고 네트워크를 가상화하기 시작하였으며, 네트워크 장비 제조사들 또한 SDN의 주도권을 가지기 위해 적극적으로 뛰어들게 된다.

참고로 오래되고 대표적인 SDN업체 Nicira가 2012년 VMware에 인수되었다. Cisco는 2014년 Tail-f와 Insieme을 인수하고, 오픈 커뮤니티를 이끌며 오픈 데이라이트(Open Daylight)라는 SDN Controller를 개발하였다.

SDN Architecture

SDN 아키텍처는 Application Layer, Control Plane(SDN 컨트롤러), Data Plane(SDN 전송 장비) 으로 구성되는 3 계층 구조로 표현할 수 있다.

그리고 계층 간 연동을 위해서 Southbound Interface(ex. OpenFlow)와 Northbound Interface가 존재한다.

출처 : Unveil the Myths About SDN Switch FS Community

Application Layer

Routing, Loadbalance, ACL 등 네트워크를 제어하는 데 사용되는 소프트웨어 애플리케이션들이다.

SDN 컨트롤러에서 제공받은 API와 여러 서비스들을 이용하여 Control 기능을 구현한다.

SDN Controller

SDN 컨트롤러는 전체 네트워크 자원에 대한 중앙 집중적 제어를 담당하는 네트워크 운영체제 역할을 담당한다.

중앙 집중적 네트워크 제어를 위해 글로벌 뷰를 기반으로 포워딩을 제어하고 토폴로지 및 자원의 상태를 관리하는 기본 기능을 수행한다.

또한 여러 네트워크 장비와 통신할 수 있도록 South-bound API를 제공하거나 추가할 수 있으며, 여러 가지 기능의 애플리케이션을 개발하고 다른 운영 도구과 통신할 수 있게 해주는 North-bound API도 제공한다.

대표적인 SDN Controller에는 위에서 언급했듯이 ONF의 주도로 만들어진 ONOS가 있으며, 이 외에도 Floodlight, Trema, Maestro, Opendaylight 등이 있다.

Data Plane

Data Plane의 SDN 디바이스는 SDN 컨트롤러의 지시에 따라 패킷 전송을 수행하는 네트워크 장치를 통칭한다.

앞서 구글의 사례에서 보았듯이 SDN의 개념과 화이트박스 스위치와를 이용하여 레거시 장비 대비 획기적으로 낮은 가격으로 데이터센터의 네트워크를 구축할 수 있다.

OpenFlow

기존 레거시 장비에서는 Control Planer과 Data Plane이 하나의 장비 내에 같이 탑재되었기 때문에 통신이 필요 없었다.

하지만 SDN에서는 Control Planer과 Data Plane이 구분되며, SDN 컨트롤러는 Data Plane 계층에 대한 포워딩을 제어(Match & Action)하고 정보를 수집하기 위해 Southbound 인터페이스를 사용한다.

이 표준 통신(RPC) 규격 중 하나가 바로 ONF에서 정의하고있는 OpenFlow Protocol이다.

즉, OpenFlow는 이론으로만 가능했던 SDN을 구현하기 위해 처음으로 제정된 최초의 표준 통신 인터페이스이다.

OpenFlow는 OpenFlow 스위치, OpenFlow 컨트롤러로 구성되며, 흐름(flow) 정보를 제어하여 패킷의 전달 경로 및 방식을 결정한다.

OpenFlow 스위치 내부에는 패킷 전달 경로와 방식에 대한 정보를 가지고 있는 FlowTable이라는 것이 존재한다.

패킷이 발생하면 제일 먼저 FlowTable이 해당 패킷에 대한 정보를 가지고 있는지 확인하고, 없다면 패킷에 대한 제어 정보를 OpenFlow 컨트롤러에 요청하는 것이다.

OpenFlow 컨트롤러 내의 패킷 제어 정보는 외부에서 API를 통해 입력할 수 있다.

Reference

[AWS] AWS CloudFormation으로 인프라 배포 자동화

suyeon96 — Sat, 17 Jul 2021 13:53:57 +0900

IaC (Infrastructure as Code)란?

IaC(Infrastructure as Code)란 Code로 인프라를 구축하고 관리하며 배포하는 것을 의미한다.

Code 기반으로 인프라를 제어하고 관리한다는 것은 수많은 이점을 가진다.

우선 반복되는 인프라 작업을 자동화시킬 수 있다. 자연스럽게 작업시간이 단축되며, 사람이 수동으로 작업하며 발생할 수 있는 휴먼에러를 최소화할 수 있다.

또한 인프라 구성사항 및 작업내용을 문서화할 수 있다. 인프라의 일관성을 향상시킬 수 있으며, 버전을 관리할 수 있게 된다. 버전관리는 IaC의 큰 장점 중 하나이다.

당연히 이 모든 것은 비용절감으로 이어진다.

IaC는 DevOps 개념에서 아주 중요한 부분이다.

운영자가 하던 인프라 작업의 대부분을 code로 처리할 수 있게 되며 개발과 운영의 경계가 옅어지고 있다. 인프라 관리를 위한 code와 애플리케이션 실행을 위한 code의 경계도 좁아지고 있으며, 인프라 프로비저닝과 애플리케이션 배포를 동시에 할 수 있다.

이미 DevOps는 충분히 수면위로 떠올랐으며, IaC 또한 더 이상 새로운 기술이 아니다.

개인적으로는 멀지 않은 미래에 대부분의 인프라 관리와 작업이 code 기반으로 완전하게 전환될 것이라고 생각한다. (즉, Operator 직무도 개발을 기본으로 해야 한다는 이야기... 반대로 말하면 개발자도 인프라를 알아야 한다는 이야기...)

IaC 툴에는 대표적으로 Terraform, Chef, Ansible, Puppet, AWS CloudFormation 등이 있다.

오늘 포스팅에서는 AWS CloudFormation을 통해 AWS 인프라를 자동으로 배포하는 방법에 대해 알아보자.

참고로 AWS CloudFormation은 무료이다. (AWS::*, Alexa::*, Custom::*과 같은 네임스페이스의 리소스 공급자에서 사용하는 경우)

만약 외부의 리소스 공급자를 사용하는 경우 핸들러 작업 당 요금이 부과된다. (참고 : https://aws.amazon.com/cloudformation/pricing/)

AWS CloudFormation 동작 원리

1. template 작성

JSON/YAML 코드로 템플릿을 작성한다. .json, .yaml, .template, .txt 등 모든 확장명으로 파일을 저장할 수 있다.

템플릿은 5가지 유형의 요소로 구성된다.

템플릿 파라미터의 선택적 목록(스택 생성 시 입력 값이 제공됨)
출력 값의 선택적 목록(예: 웹 애플리케이션에 대한 전체 URL)
정적 구성 값을 조회하는 데 사용되는 데이터 테이블의 선택적 목록(예: AMI 이름)
AWS 리소스 및 해당 구성 값 목록
템플릿 파일 형식 버전 번호

2. template 업로드

작성한 템플릿을 local 또는 S3 버킷에 저장하여 업로드한다.

3. stack 생성

Cloudformation은 스택이라는 하나의 단위로 관련 리소스를 관리한다.

스택의 모든 리소스는 템플릿으로 정의되며, Cloudformation은 템플릿 코드를 읽어 스택을 생성한다.

만약 템플릿에 파라미터가 포함된 경우 스택을 생성할 때 입력 값을 지정할 수 있다.

4. stack 설정 및 resource 생성

3단계와 4단계의 구분은 사실 의미가 없긴 하다.

템플릿에 정의된 리소스가 생성된 후 CloudFormation은 유저에게 스택이 생성되었다고 보고한다.

그러면 유저는 스택의 리소스를 사용할 수 있는 것이다.

스택의 리소스를 업데이트해야 하는 경우 스택의 템플릿을 수정하면 된다.

CloudFormation은 수정된 템플릿을 원본 템플릿과 비교하여 변경 사항을 검토하고 스택을 업데이트한다.

스택을 삭제하는 경우 기본적으로 해당 스택과 스택 내 모든 리소스를 삭제하지만, 일부 리소스를 보존하고 싶은 경우 삭제 정책을 이용할 수 있다.

AWS CloudFormation 실습 시나리오

1. network 계층 배포

network 인프라 구성을 위한 템플릿 파일은 아래와 같다.

템플릿에 대한 해석은 따로 하지 않겠다. AWS를 이용해보았다면 코드만 보아도 대충 감은 잡힐 것이다. 자세한 내역이 궁금하다면 가이드문서를 참고 바란다.

lab-network.yaml

AWSTemplateFormatVersion: 2010-09-09
Description: >-
  Network Template: Sample template that creates a VPC with DNS and public IPs enabled.

# This template creates:
#   VPC
#   Internet Gateway
#   Public Route Table
#   Public Subnet

######################
# Resources section
######################

Resources:

  ## VPC

  VPC:
    Type: AWS::EC2::VPC
    Properties:
      EnableDnsSupport: true
      EnableDnsHostnames: true
      CidrBlock: 10.0.0.0/16

  ## Internet Gateway

  InternetGateway:
    Type: AWS::EC2::InternetGateway

  VPCGatewayAttachment:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      VpcId: !Ref VPC
      InternetGatewayId: !Ref InternetGateway

  ## Public Route Table

  PublicRouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId: !Ref VPC

  PublicRoute:
    Type: AWS::EC2::Route
    DependsOn: VPCGatewayAttachment
    Properties:
      RouteTableId: !Ref PublicRouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway

  ## Public Subnet

  PublicSubnet:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      CidrBlock: 10.0.0.0/24
      AvailabilityZone: !Select 
        - 0
        - !GetAZs 
          Ref: AWS::Region

  PublicSubnetRouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      SubnetId: !Ref PublicSubnet
      RouteTableId: !Ref PublicRouteTable

  PublicSubnetNetworkAclAssociation:
    Type: AWS::EC2::SubnetNetworkAclAssociation
    Properties:
      SubnetId: !Ref PublicSubnet
      NetworkAclId: !GetAtt 
        - VPC
        - DefaultNetworkAcl

######################
# Outputs section
######################

Outputs:

  PublicSubnet:
    Description: The subnet ID to use for public web servers
    Value: !Ref PublicSubnet
    Export:
      Name: !Sub '${AWS::StackName}-SubnetID'

  VPC:
    Description: VPC ID
    Value: !Ref VPC
    Export:
      Name: !Sub '${AWS::StackName}-VPCID'

1.1 템플릿 지정

위의 템플릿 코드를 직접 업로드하였다.

1.2 Stack 세부정보 지정

1.3 Stack 옵션 구성

1.4 Stack 생성

최종 검토 후에 스택을 생성하면 아래와 같은 화면을 볼 수 있다.

1.5 Resources 확인

템플릿에 정의한 리소스들이 정상적으로 생성되었음을 확인할 수 있다.

1.6 Events 확인

스택 또는 리소스 상태의 이벤트 또한 확인 가능하다.

1.7 Outputs 확인

스택 간에 정보를 공유하기 위해서 스택의 Output을 설정할 수 있다.

필자의 경우 위 템플릿의 마지막 문단에서 PublicSubnet ID와 VPC ID를 Output으로 지정해놓았고, 생성된 리소스들의 ID가 정상적으로 출력되는 것을 확인할 수 있다.

2. application 계층 배포

네트워크 구성을 완료했으니 이번에는 애플리케이션 계층을 배포할 차례이다.

lab-network 스택에서 생성한 리소스에 웹서버를 띄우기 위한 템플릿을 준비하였다.

lab-application.yaml

AWSTemplateFormatVersion: 2010-09-09
Description: >-
  Application Template: Demonstrates how to reference resources from a different stack.
  This template provisions an EC2 instance in a VPC Subnet provisioned in a different stack.

# This template creates:
#   Amazon EC2 instance
#   Security Group

######################
# Parameters section
######################

Parameters:

  NetworkStackName:
    Description: >-
      Name of an active CloudFormation stack that contains the networking
      resources, such as the VPC and subnet that will be used in this stack.
    Type: String
    MinLength: 1
    MaxLength: 255
    AllowedPattern: '^[a-zA-Z][-a-zA-Z0-9]*$'
    Default: lab-network

  AmazonLinuxAMIID:
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2

######################
# Resources section
######################

Resources:

  WebServerInstance:
    Type: AWS::EC2::Instance
    Metadata:
      'AWS::CloudFormation::Init':
        configSets:
          All:
            - ConfigureSampleApp
        ConfigureSampleApp:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <img src="<https://s3.amazonaws.com/cloudformation-examples/cloudformation_graphic.png>" alt="AWS CloudFormation Logo"/>
                <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
              mode: 000644
              owner: apache
              group: apache
          services:
            sysvinit:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      InstanceType: t2.micro
      ImageId: !Ref AmazonLinuxAMIID
      NetworkInterfaces:
        - GroupSet:
            - !Ref WebServerSecurityGroup
          AssociatePublicIpAddress: true
          DeviceIndex: 0
          DeleteOnTermination: true
          SubnetId:
            Fn::ImportValue:
              !Sub ${NetworkStackName}-SubnetID
      Tags:
        - Key: Name
          Value: Web Server
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum update -y aws-cfn-bootstrap
          # Install the files and packages from the metadata
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --configsets All --region ${AWS::Region}
          # Signal the status from cfn-init
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  DiskVolume:
    Type: AWS::EC2::Volume
    Properties:
      Size: 100
      AvailabilityZone: !GetAtt WebServerInstance.AvailabilityZone
      Tags:
        - Key: Name
          Value: Web Data
    DeletionPolicy: Snapshot

  DiskMountPoint:
    Type: AWS::EC2::VolumeAttachment
    Properties:
      InstanceId: !Ref WebServerInstance
      VolumeId: !Ref DiskVolume
      Device: /dev/sdh

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP ingress
      VpcId:
        Fn::ImportValue:
          !Sub ${NetworkStackName}-VPCID
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      Tags:
        - Key: Name
          Value: Web Server Security Group

######################
# Outputs section
######################

Outputs:
  URL:
    Description: URL of the sample website
    Value: !Sub '<http://$>{WebServerInstance.PublicDnsName}'

2.1 stack 생성

위에서 한번 해본 과정이랑 동일하기 때문에 빠르게 넘어가자.

다른 것이 있다면 parameter에 lab-network를 지정해야 한다.

2.2 Resources 확인

템플릿에 정의한 대로 EC2 인스턴스, 보안그룹, 디스크볼륨이 정상적으로 생성된 것을 확인할 수 있다.

2.3 Outputs 확인

이번엔 웹서버를 띄웠기 때문에 외부에서 http(80)로 접속할 수 있도록 인스턴스의 PublicDnsName을 출력하였다.

2.4 Access 확인

3. Stack update

이번에는 lab-application 스택을 업데이트하여 리소스가 변경되는 것을 테스트해보자.

기존 템플릿에서 파일 contents를 변경하고 보안그룹에 인바운드 SSH 트래픽을 허용하도록 하는 코드를 추가하였다.

lab-application2.yaml

AWSTemplateFormatVersion: 2010-09-09
Description: >-
  Application Template: Demonstrates how to reference resources from a different stack.
  This template provisions an EC2 instance in a VPC Subnet provisioned in a different stack.

# This template creates:
#   Amazon EC2 instance
#   Security Group

######################
# Parameters section
######################

Parameters:

  NetworkStackName:
    Description: >-
      Name of an active CloudFormation stack that contains the networking
      resources, such as the VPC and subnet that will be used in this stack.
    Type: String
    MinLength: 1
    MaxLength: 255
    AllowedPattern: '^[a-zA-Z][-a-zA-Z0-9]*$'
    Default: lab-network

  AmazonLinuxAMIID:
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2

######################
# Resources section
######################

Resources:

  WebServerInstance:
    Type: AWS::EC2::Instance
    Metadata:
      'AWS::CloudFormation::Init':
        configSets:
          All:
            - ConfigureSampleApp
        ConfigureSampleApp:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <img src="<https://s3.amazonaws.com/cloudformation-examples/cloudformation_graphic.png>" alt="AWS CloudFormation Logo"/>
                <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                <h3>Update Stack Test - by Suyeon<h3>
              mode: 000644
              owner: apache
              group: apache
          services:
            sysvinit:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      InstanceType: t2.micro
      ImageId: !Ref AmazonLinuxAMIID
      NetworkInterfaces:
        - GroupSet:
            - !Ref WebServerSecurityGroup
          AssociatePublicIpAddress: true
          DeviceIndex: 0
          DeleteOnTermination: true
          SubnetId:
            Fn::ImportValue:
              !Sub ${NetworkStackName}-SubnetID
      Tags:
        - Key: Name
          Value: Web Server
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum update -y aws-cfn-bootstrap
          # Install the files and packages from the metadata
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --configsets All --region ${AWS::Region}
          # Signal the status from cfn-init
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  DiskVolume:
    Type: AWS::EC2::Volume
    Properties:
      Size: 100
      AvailabilityZone: !GetAtt WebServerInstance.AvailabilityZone
      Tags:
        - Key: Name
          Value: Web Data
    DeletionPolicy: Snapshot

  DiskMountPoint:
    Type: AWS::EC2::VolumeAttachment
    Properties:
      InstanceId: !Ref WebServerInstance
      VolumeId: !Ref DiskVolume
      Device: /dev/sdh

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP ingress
      VpcId:
        Fn::ImportValue:
          !Sub ${NetworkStackName}-VPCID
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
      Tags:
        - Key: Name
          Value: Web Server Security Group

######################
# Outputs section
######################

Outputs:
  URL:
    Description: URL of the sample website
    Value: !Sub '<http://$>{WebServerInstance.PublicDnsName}'

3.1 Update Stack

3.2 변경사항 확인

Review 단계에서 변경사항을 확인할 수 있다.

Replacement = False라는 것은 각 리소스에 최소한의 변경만 있으며, 해당 리소스에 대한 참조는 변경할 필요가 없다는 것을 의미한다.

3.3 update 중...

현재 Status를 보면 update 중인 것을 확인할 수 있다.

3.4 Events 확인

정상적으로 업데이트가 완료되었다.

3.5 리소스 변경 확인

Security Group 대시보드에서 SSH(22) rule이 추가된 것을 확인할 수 있다.

4. AWS CloudFormation Designer

CloudFormation Designer는 템플릿을 간편하게 확인하고 제어하기 위한 그래픽 기반의 도구이다.

이를 사용하면 템플릿의 리소스 간 연관성을 빠르게 파악하고 쉽게 수정할 수 있다.

이런 식으로 리소스를 끌어서 템플릿에 자동으로 삽입하고, 리소스 간 관계를 만들 수도 있다.

5. Stack 삭제

5.1 Delete Stack

생성한 Stack을 삭제할 차례이다.

5.2 Events 확인

Events를 보면 스택의 리소스들이 삭제되는 것을 확인할 수 있다.

5.3 DeletionPolicy

삭제 정책을 이용하면 스택이 삭제될 때 리소스를 보존하거나 백업할 수 있다.

DeletionPolicy 속성

Retain 옵션을 지정하면 스택 삭제 시 리소스가 유지된다.
Snapshot 옵션을 지정하면 해당 리소스를 삭제하기 전에 리소스의 스냅샷을 생성한다.
Delete 옵션을 지정하면 스택과 함께 리소스가 삭제된다.

Snapshot 옵션을 선택한 경우 아래와 같이 DataVolume에 대한 스냅샷이 생성된 것을 확인할 수 있다.

[AWS] 단계별 시나리오를 통해 알아보는 EC2 Auto Scaling

suyeon96 — Mon, 12 Jul 2021 01:35:31 +0900

AutoScaling이란?

클라우드 컴퓨팅의 대표적인 장점 중 하나는 유연성이다.

유연성이라는 단어는 상당히 추상적이며 많은 의미를 내포하고 있지만 그 중 핵심은 빠르고 쉽게 서비스를 확장하거나 축소하는 것을 의미할 것이다.

Auto Scaling은 이 유연성을 돋보이게 하는 핵심 기술로 CPU, Memory, Disk, Network 등의 시스템 Metric값이나 Application을 모니터링하고 size를 자동으로 조절하는 기술이다.

Auto Scaling을 통해 얻을 수 있는 이득은 크게 2가지로 정의할 수 있다.

예상치 못한 서비스 부하에 효과적으로 대응할 수 있다.
최대한 저렴한 비용으로 안정적이고 예측 가능한 성능을 유지할 수 있다.

AWS Auto Scaling Resource

AWS에서는 인스턴스, DB 등 다양한 서비스에서 Auto Scaling을 지원한다.

이 중 오늘 포스팅에서는 EC2 Auto Scaling에 대해 알아보자.

EC2 Auto Scaling 실습 시나리오

1. S3 버킷 및 IAM 생성

우선 ec2에 연결할 S3 버킷을 생성한다.

굳이 필요없는 작업이긴 하지만 조금이나마 의미있는 시나리오를 구성하기 위해 준비하였다.

web 서버를 띄우고 나서 보여줄 index.html를 작성하고 저장한다.

<!DOCTYPE html>
<html>
<head>
  <title>AUSG Bigchat</title>
</head>
<body>
  <h1>Auto Scaling Test!!</h1>
</body>
</html>

Auto Scaling을 통해 생성될 ec2 인스턴스에 s3 access 권한을 부여하기 위해 IAM도 생성해주었다.

Policy : AmazonS3FullAccess

2. VPC 및 Subnet 구성

Auto Scaling을 테스트할 인프라 구성을 위해 VPC를 하나 생성한다.

Public Subnet도 2개 생성해주고

이전 포스팅에서 다뤘던 것처럼 Internet Gateway 생성 후 VPC와 연결해주자.

Route Table 생성 후 Public Subnet 2개와 연결해주고

인터넷 연결을 위해 0.0.0.0/0 (모든 네트워크)에 대해서 Routes를 추가해준다.

3. EC2 AMI 생성

Auto Scaling에 사용할 AMI를 생성할 차례이다.

우선 인스턴스를 하나 생성하자.

AMI : Amazon Linux 2 AMI (HVM), SSD Volume Type
Instance Type : t3.micro (2vCPU 1GiB)
Network : 위에서 만든 ausg-bigchat-as-test-VPC VPC
Subnet : 위에서 만든 as-test-Subnet-Public1 서브넷
IAM Role : 위에서 만든 s3_fullaccess_as_test IAM

User Data

#!/bin/bash

yum install -y httpd
systemctl start httpd.service
systemctl enable httpd.service

aws s3 cp s3://ausg-bigchat-as-test/index.html /var/www/html –region ap-northeast-2

user data란 ec2 인스턴스가 올라가면서 수행할 action을 정해주는 것이다.

이번 시나리오에서는 간단하게 웹서버(httpd)를 설치하고 아까 만든 S3버킷에서 index.html을 받아올 것이다.

생성된 인스턴스를 기준으로 AMI를 생성한다.

4. Elastic Load Balancer 구축

Type : Application (L7)
체계 : internet-facing
IP 주소 유형 : ipv4
VPC 및 Subnet : 위에서 만든 것

TargetGroup을 생성하고 대상으로 생성해놓은 ec2 web서버를 지정한다.

4. Autoscaling Launch Configuration 생성

Auto Scaling Launch Configuration(시작 구성) 생성

Amazon Machine Image(AMI) : web서버 인스턴스로부터 만든 이미지
Instance Type : t3.micro (2 vCPU, 1 GiB, EBS 전용)
IAM : s3_fullaccess_as_test
Security Group : 동일하게
Key pair : 동일하게

user data

#!/bin/bash

yum install -y httpd
systemctl start httpd.service
systemctl enable httpd.service

aws s3 cp s3://ausg-bigchat-as-test/index.html /var/www/html –region ap-northeast-2

5. Auto Scaling Group 생성

1) Launch Configuration 선택

위에서 만들었듯이 Launch Configuration은 오토스케일링 그룹에서 생성될 서버의 사양과 설정을 정의하는 것이다.

2) VPC 및 Subnet 선택

3. ELB 연결

Elastic Load Balancing(ELB) 상태 확인을 활성화하면 연결된 로드 밸런서가 Amazon EC2 상태 확인에 실패할 때뿐만 아니라 비정상으로 보고할 때 Amazon EC2 Auto Scaling에서 인스턴스를 교체할 수 있다.

상태확인 유예 기간은 300초가 적당하다.

우후죽순으로 빨리빨리 만들어져봐야 소용없기 때문.

4) Auto Scaling Group Size

Desired Size : 오토스케일링 시 원하는 서버 수를 지정
Min Size : 오토스케일링 그룹의 최소 유지 서버 수 (Desired > = MinSize)
Max Size : 오토스케일링 그룹의 최대 보유 서버 수 (Desired < = MaxSize)

5) scaling policies

오토스케일링 그룹에 포함된 가상 서버의 시스템 메트릭 값이 미리 지정한 임계치를 초과할 경우 가상서버 수를 늘리고(Scale-out), 임계치 미만이면 가성 서버 수를 줄이도록(Scale-in) 설정할 수 있다.

지표 유형에는 아래와 같은 것들이 있다.

평균 CPU 사용률
평균 네트워크 입력 (bytes)
평균 네트워크 출력 (bytes)
대상당 Application Load Balancer 요청 수

6) 알림 추가

6. Autoscaling Group 생성 후 인스턴스 확인

Desired Size를 2로 지정하였기 때문에 2대의 ec2 인스턴스가 올라온 것을 확인할 수 있다.

7. ELB Target Group 확인

Scale-out 된 인스턴스들이 ELB에 자동으로 연결된 것을 확인할 수 있다.

현재 Scale-out 된 인스턴스들에 웹서버 설치가 되지 않아 unhealthy 상태로 체크된다.

아까 Auto Scaling Group 생성 시 Health Check Type에 ELB를 체크하였기 때문에 unhealthy 상태의 인스턴스를 삭제하고 새로 생성하는 작업을 반복한다.

인프라 구성을 맞추기 위해 기존에 등록한 AMI용 인스턴스는 언바인딩 하였으며, ELB DNS 접속도 정상적으로 되는 것을 확인하였다.

8. CloudWatch 경보 및 조정정책 설정

우선 단계 조정정책 또는 단순 조정정책을 생성하기 위해 CloudWatch 경보를 생성해야 한다.

Auto Scaling Group의 CPU 사용률이 5% 이하면 경보가 발생하도록 설정하였다.

자고 일어났다...

당연히 아무것도 하지 않기 때문에 CPU는 5% 이하가 유지되고 있었으며, 경보가 발생한 상태이다.

해당 경보를 이용하여 경보가 발생하면 인스턴스가 1개 Scale-In 되도록 단계 조정정책을 추가하였다.

인스턴스 하나가 내려가는 것을 확인할 수 있다.

Scale-out 도중 ELB 언바인딩 또한 진행된다는 것을 알 수 있다.

또한 예약 작업을 생성하여 원하는 시간대에 Auto Scaling Group 사이즈를 유연하게 조정할 수 있으며, 인스턴스 개수 또한 조정 가능하다.

9. cpu 부하 테스트 (Scale-out)

Scale-out 테스트를 위해 CloudWatch에서 CPU 사용률이 60% 이상이 되면 발생하는 경보를 추가하였다.

해당 경보를 이용하여 조정 정책을 생성한다.

CPU 사용률이 60%~80%이면 1개의 인스턴스를 증가시키고, 80% 이상이면 2개의 인스턴스를 증가시킨다.

현재 Auto Scaling Group에는 아래와 같이 2개의 조정정책이 설정되어 있다.

부하 발생을 위해 Auto Scaling Group 내의 인스턴스에서 stress를 주었다.

$ sudo amazon-linux-extras install epel

$ sudo yum -y install epel-release
$ sudo yum -y install stress

$ stress -c 2

top 명령어로 확인해보면 CPU 사용률이 100%까지 올라간 것을 확인할 수 있다.

CloudWatch에서 5% 이하 경보는 해제되고 60% 이상 경보가 발생한다.

80%를 넘어 100% 사용률을 나타내고 있다.

cpu 사용률이 80% 이상이면 인스턴스 2개가 증가하도록 조정정책을 설정해 놓았기 때문에, 2개의 인스턴스가 Scale out 되는 것을 확인할 수 있다.

지정해놓은 300초(5분)가 지나자 아직 경보가 해제되지 않았기 때문에 인스턴스가 1대 더 Scale out 되는 것을 확인할 수 있다.

또한 Auto Scaling Group 내에서 AZ 또한 유연하게 분산배치된 것을 확인할 수 있다.

Auto Scaling Group에 총 4대의 인스턴스가 올라가 Cpu 평균 사용률이 감소하고 경보가 해제되는 과정 또한 확인할 수 있다.

이것이 Auto Scaling을 사용하는 이유이다.

[AWS] VPC 환경 구성 (Public, Private Subnet)

suyeon96 — Sat, 10 Jul 2021 14:07:41 +0900

일반적으로 네트워크 작업은 어렵다.

케이블 배선부터 시작하여 각종 네트워크 장비를 제어해야 하고 전문 기술이 필요하다.

간단하다고 생각하는 환경에서도 생각보다 네트워크 구성은 복잡하다.

AWS를 사용한다면 Amazon VPC를 활용하여 복잡한 요소를 거치지 않고 Private network를 간단하게 구성하고 보안을 챙길 수 있다.

이번 포스팅에서는 자체 VPC를 구성하고, Public subnet과 Private subnet을 생성하는 아주 심플한 시나리오를 진행한다.

1. VPC 생성

우선 VPC를 하나 생성한다.

인스턴스의 public 또는 private IPv4 주소에 해당하는 DNS hostname을 제공하도록 설정할 수 있다.

위 그림처럼 Enable에 체크하면 앞으로 VPC에서 실행된 Amazon EC2 인스턴스에서 DNS hostname을 자동으로 수신한다.

Public DNS hostname은 ec2-public-ipv4-address.region.compute.amazonaws.com 형식으로 지정된다.

Amazone Route53을 사용하여 나중에 더 유의미한 DNS hostname을 추가할 수 있다.

참고로 Amazon DNS 서버는 Public DNS hostname을 인스턴스 네트워크 외부에서는 인스턴스의 Public IPv4 주소로 변환하고, 인스턴스 네트워크 내부에서는 인스턴스의 Private IPv4 주소로 변환한다. (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses)

2. Public Subnet 생성

이제 Subnet 탭으로 가서 Public 용도의 Subnet을 생성하자.

(10.0.0.0/24 → 10.0.0.x 대역의 모든 IP 주소를 포함한다.)

Public Subnet 안에서 시작되는 모든 인스턴스에 Public IP주소가 자동으로 할당되도록 설정해주자.

Public 용으로 생성한 Subnet이지만 아직 Public상태는 아니다.

퍼블릭 서브넷에는 인터넷 게이트웨이가 있어야 하며, 이후에 IGW를 생성하고 연결할 것이다.

3. Private Subnet 생성

Public Subnet을 완성하기 전에 Private 용도의 Subnet도 하나 만들어주자.

방법은 똑같지만 Subnetting을 위한 CIDR notation을 /23으로 지정하였다.

(10.0.2.0/23 → 10.0.2.x 및 10.0.3.x 대역의 모든 IP 주소 포함한다.)

일반적으로 대부분의 리소스는 Private 환경에 구성해야 하므로, Public Subnet의 2배 크기를 가지도록 설정한다.

4. Internet Gateway 생성

Internet Gateway는 수평적 확장을 통해 이중화를 지원하고 가용성이 높은 VPC 구성 요소로서, VPC와 인터넷 간 통신할 수 있도록 해준다.

인터넷 게이트웨이를 사용하는 목적은 2가지가 있다.

인터넷 라우팅 가능 트래픽에 대하여 VPC 라우팅 테이블에 연결 대상 제공
Public IPv4 주소가 할당된 인스턴스에 대해 NAT(Network Address Translation) 수행

아까 Step2에서 생성한 Public Subnet에 인터넷 트래픽이 액세스 할 수 있도록 Internet Gateway를 생성하자.

생성 후 VPC에 attach 해줘야한다.

5. Route table 구성

Route table은 Subnet 또는 Gateway의 네트워크 트래픽이 전송되는 위치를 결정하는 데 사용되는 route 규칙의 집합으로 이루어져 있다.

VPC에 있는 각 Subnet은 Route table에 연결되어 있어야 하며, 라우팅 테이블이 Subnet에 대한 라우팅을 제어한다.

Route table에 인터넷에 바인딩된 트래픽을 Internet Gateway로 향하도록 지시하는 Route 경로를 포함하고 이를 Subnet에 연결하면 Public Subnet이 된다.

우선 기본적으로 위에서 만든 VPC와 연결된 라우팅 테이블이 존재한다.

이 라우팅 테이블은 트래픽을 로컬로 라우팅 하기 때문에 Private Routing 테이블이라고 이름을 변경해 주었다.

이 테이블에서의 Route 경로는 하나다.

VPC 범위의 IP로 향하는 모든 트래픽이 local로 라우팅 된다는 것을 볼 수 있다.

이는 VPC 내 모든 서브넷이 서로 통신할 수 있다는 것을 의미한다.

이제 Public 트래픽을 Internet Gateway로 전송할 Public Route table 생성하자.

인터넷 바운드 트래픽(0.0.0.0/0)을 Internet Gateway로 보내는 Route 경로를 추가하자.

해당 Route table을 Public 서브넷에 연결하면, 이제서야 진정한 Public Subnet이 된다.

6. Public Subnet에서 EC2 생성

EC2 생성 시 위에서 만든 VPC와 Public Subnet을 선택할 수 있다.

아까 Public Subnet에서 인스턴스에 자동으로 Public IP가 assign 되도록 설정해주었기 때문에, default setting이 활성화되어있는 것을 확인할 수 있다.

[Git] CentOS7 GitLab RPM 설치 및 Migration (GitBlit → GitLab)

suyeon96 — Fri, 9 Jul 2021 13:22:13 +0900

팀에서 기존에 사용 중이던 Git 서버를 반납해야 했기에, 새로운 Git 서버를 구축해야 하는 미션이 떨어졌다.

우선 기존 GitBlit을 버리고 GitLab으로 갈아타기로 마음먹었으며, 이번 기회에 팀 내의 Git Branch 전략을 새롭게 정립하고 CI/CD 또한 개선하려 한다.

이번 포스팅에서는 Internet이 안되는 Intranet 환경에서 GitLab을 설치하는 과정과, Git Repository를 이전하는 방법에 대해 다룬다.

1. Install and configure the necessary dependencies

1.1 gitlab 설치에 필요한 패키지 설치

$ sudo yum install -y curl policycoreutils-python openssh-server perl

1.2 sshd 실행

$ sudo systemctl enable sshd
$ sudo systemctl start sshd

1.3 http, https 방화벽 open

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
$ sudo systemctl reload firewalld

# open 확인
$ sudo firewall-cmd --list-all

# 방화벽 재시작
$ sudo systemctl restart firewalld

iptables -L -vn 으로 firewall list 확인

1.4 메일링을 위한 postfix 메일서버 설치

$ sudo yum install postfix

$ sudo systemctl enable postfix
$ sudo systemctl start postfix

2. Add the GitLab package repository and install the package

인터넷이 된다면 아래 명령어를 이용하여 GitLab package repository를 등록하고 설치하면 된다.

$ curl -s <https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh> | sudo bash

$ sudo yum install gitlab-ce-13.11.3-ce.0.el7.x86_64

우리는 offline 환경이기 때문에 GitLab에서 제공하는 RPM 패키지를 다운받아서 설치하자.

https://packages.gitlab.com/gitlab/gitlab-ce

$ rpm -Uvh gitlab-ce-13.11.3-ce.0.el7.x86_64.rpm

3. Configure GitLab

3.1 /etc/gitlab/gitlab.rb 경로의 파일에서 gitlab 설정 확인

$ vi /etc/gitlab/gitlab.rb

3.2 external_url 변경

도메인 이름을 설정하려면 external_url 변수를 수정하면 된다.

## GitLab URL
##! URL on which GitLab will be reachable.
##! For more details on configuring external_url see:
##! <https://docs.gitlab.com/omnibus/settings/configuration.html#configuring-the-external-url-for-gitlab>
##!
##! Note: During installation/upgrades, the value of the environment variable
##! EXTERNAL_URL will be used to populate/replace this value.
##! On AWS EC2 instances, we also attempt to fetch the public hostname/IP
##! address from AWS. For more details, see:
##! <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html>
external_url "<http://gitlab.example.com>"

3.3 IP, Port 변경

만약 IP와 Port를 변경하고 싶은 경우 unicorn['listen']과 unicorn['port'] 변수를 수정하면 된다.

################################################################################
## GitLab Unicorn
##! Tweak unicorn settings.
##! Docs: <https://docs.gitlab.com/omnibus/settings/unicorn.html>
################################################################################

### Advanced settings
# unicorn['listen'] = 'localhost'
# unicorn['port'] = 8080
# unicorn['socket'] = '/var/opt/gitlab/gitlab-rails/sockets/gitlab.socket'
# unicorn['pidfile'] = '/opt/gitlab/var/unicorn/unicorn.pid'
# unicorn['tcp_nopush'] = true
# unicorn['backlog_socket'] = 1024

###! **Make sure somaxconn is equal or higher then backlog_socket**
# unicorn['somaxconn'] = 1024

3.4 data repo 변경

git_data_dirs({
    "default" => {
        "path" => "/mnt/nfs-01/git-data"
  }
)}

만약 이 부분을 설정하지 않고 # 주석 처리가 되어 있다면, default 저장소 path는 /var/opt/gitlab/git-data로 설정된다.

나는 이 부분을 새로 마운트한 /data volume으로 변경해주었다.

만약 directory를 새롭게 추가하였다면, gitlab이 접근할 수 있도록 권한을 확인해 주어야 한다.

권한이 없다면 아래 명령어로 권한을 부여하자

$ chown -R git:git /data/git-data/

3.5 SMTP setting

gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.server"
gitlab_rails['smtp_port'] = 465
gitlab_rails['smtp_user_name'] = "smtp user"
gitlab_rails['smtp_password'] = "smtp password"
gitlab_rails['smtp_domain'] = "example.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_openssl_verify_mode'] = 'peer'

# If your SMTP server does not like the default 'From: gitlab@localhost' you
# can change the 'From' with this setting.
gitlab_rails['gitlab_email_from'] = 'gitlab@example.com'
gitlab_rails['gitlab_email_reply_to'] = 'noreply@example.com'

# If your SMTP server is using self signed certificates you can specify a custom ca file
gitlab_rails['smtp_ca_file'] = '/path/to/your/cacert.pem'

참고 : https://docs.gitlab.com/omnibus/settings/smtp.html

4. GitLab 초기화 및 설치 진행

$ sudo gitlab-ctl reconfigure

5. Web 접속 및 로그인

최초 접속 시 password reset 화면으로 redirect 된다.

default 계정의 username은 root 이다.

password 설정 후 root로 로그인하여 사용할 유저를 등록하면 된다.

6. Git Repository Migration (GitBlit → GitLab)

이제 준비는 끝났다.

기존에 사용하던 GitBlit의 Repository를 새로 구축한 GitLab으로 이동해야 한다.

--mirror 옵션을 사용하면 원격 저장소(Remote Repository)의 복사본을 만들어 간단하게 Repository를 이전할 수 있다.

참고로 --mirror는 --bare 옵션을 포함한다.

git clone --mirror {기존 리파지토리 주소}
cd {기존 리파지토리 명}.git
git remote set-url --push origin {신규 리파지토리 주소}
git push --mirror

Reference

부동산 투자에서의 레버리지 효과와 위험성

suyeon96 — Mon, 3 May 2021 15:08:09 +0900

레버리지 효과란?

레버리지 효과(leverage effect)란 타인이나 금융기관으로부터 차입한 자본을 이용하여 자기자본이익률을 높이는 것을 말한다. 빌린 돈을 지렛대(lever) 삼아 이익을 창출한다는 의미에서 지렛대 효과라고도 한다. 지렛대를 사용하면 작은 힘으로 무거운 무게를 들 수 있는데, 차입한 자본이 지렛대가 되고 그 힘이 나의 자본과 합쳐져서 높은 수익을 낼 수 있다는 의미이다. 즉, 자신의 자본을 최소화하고 타인의 자본을 빌려 수익률을 극대화하는 것이다.

예를 들어 A와 B가 동일하게 1년동안 10억원을 투자하여 2억원의 순이익을 얻었다. A는 대출 없이 자신의 돈 10억원을 투자하였으며, B는 은행에서 대출받은 5억원과 자신의 돈 5억원을 합쳐 투자하였다. A와 B 모두 총자본이익률은 20%로 동일하다. 하지만 자기자본이익률을 비교했을 때 A는 20%(2/10)이지만, B는 40%(2/5)이다. 이자율 5%를 계산하더라도 35%(2-(5*0.05)/5)로 자기자본이익률이 A보다 높은 것을 알 수 있다.

이처럼 적은 자본으로 많은 수익을 낼 수 있는 것이 투자에 있어서 레버리지의 매력이다.

레버리지 위험성

레버리지 효과의 전제조건은 투자로 인해 발생하는 수익률이 차입금의 이자율보다 높아야 한다. 이를 정(正)의 지렛대 효과라고 한다. 하지만 수익률이 차입금의 이자율보다 낮은 경우 금리 부담이 커지게 된다. 수익률이 마이너스가 되는 경우 즉 손실이 났을 때는 레버리지가 오히려 더 큰 손해를 야기하게 된다. 이를 부(負)의 지렛대 효과라고 한다.

레버리지 비율이 높을수록 높은 이익을 얻을 수도 있지만, 반대로 위험도 그만큼 증가한다. 여기서 레버리지 비율은 부채 대 자기자본 비율을 말한다. 투자에 있어 지나치게 높은 레버리지 비율은 과도한 부채부담을 의미하고, 이는 원리금 상환부담의 증가와 연결된다. 이러한 경우 단순히 나의 돈을 잃고 끝나는 것을 넘어 채무불이행 등의 위험으로 이어질 수 있다.

부동산 투자에서의 레버리지 효과

우리나라는 주식이나 금융상품에 대한 투자비중보다 부동산 투자비중이 높은 모습을 보인다. 그 이유로는 ‘높은 수익률’ 또는 ‘안정성’ 등이 있을 것이다. 하지만 필자는 위에서 언급한 ‘레버리지’가 부동산 투자의 최대 장점이라고 생각한다. 부동산 투자에서의 레버리지 효과를 활용하는 대표적인 방법은 은행으로부터 대출을 받아 부동산을 구매하는 것이다.

돈이 돈을 번다는 이야기를 한번쯤은 들어봤을 것이다. A와 B라는 아파트가 있다. A아파트는 1억원이고 B아파트는 10억원이다. 시세차익으로 두 아파트에서 동일하게 1억원의 수익을 얻기 위해서는 A아파트는 가격 상승률이 100%여야 하지만, B아파트는 가격 상승률이 10%면 가능하다. B아파트를 소유한 사람이 A아파트를 소유한 사람보다 돈을 많이 벌 수 있는 확률이 더 높다. 사실 너무 당연한 이야기이다. 여기서 중요한 것은 우리가 10억원의 자본이 없더라도 레버리지 효과를 이용하여 B아파트에 투자하고, 그만큼의 이익을 얻을 수 있다는 것이다.

부동산 투자에 빠질 수 없는 단어가 바로 갭투자이다. 갭투자란 간단하게 매매가와 전세가의 차이(gap)를 이용한 투자이다. 위에서 언급한 10억짜리 B아파트의 전세가가 8억이다. 그럼 B아파트를 사는데 내 자본은 2억원만 있으면 된다. B아파트가 나중에 11억이 된다면 이에 따른 자기자본이익률은 무려 50%이다. 이 또한 레버리지 효과라고 할 수 있다. 또한 시세차익 이외에도 임대수익을 얻을 수도 있다. 은행 대출만이 아니라 타인의 자본을 이용하여 내 자본금에 비해 큰 수익을 얻을 수 있는 것이다.

하지만 역시나 부동산투자에서도 레버리지의 위험성은 존재한다. 단편적으로 집값이 하락하는 경우 개인에게도 비극이지만 부채를 이용하여 부동산을 구매한 사람들은 신용불량자가 될 것이다. 은행 또한 원리금을 상환받지 못해 수익이 악화되고 금융 위기도 피할 수 없게 된다. 정부는 이를 방지하고자 지난 글에서 언급하였던 주택담보인정비율(LTV), 총부채상환비율(DTI), 총부채원리금상환비율(DSR) 규제 등을 이용하여 과도한 레버리지 효과를 제한한다.

결론

레버리지 효과는 양날의 검을 가지고 있다. 필자는 아직까지는 부동산 투자가 우리나라에서 레버리지 효과를 이용하여 안정성과 고수익 모두 잡을 수 있는 투자종목이라고 생각한다. 물론 부동산 투자에 있어서 재산세, 종합부동산세, 양도소득세 등 각종 세금과 차입금에 대한 이자율, 위험부담 등을 함께 고려해야 한다. 물론 레버리지 효과로 수익을 얻기 위해서는 레버리지의 위험성 또한 반드시 이해해야 한다. 하지만 이러한 모든 위험성을 사전에 숙지하고 투자에 임한다면 레버리지 효과는 자산을 키우는 데 있어서 큰 도움이 될 것이다. 투자에 있어서 부채를 무조건적으로 부정적인 시선으로 바라볼 필요는 없다는 점을 주장하며 글을 마무리한다.

Reference

이권복(2019). 토익 공부보다 돈 공부. 서울: 한스미디어.

Zvi Bodie, Alex Kane & Alan J. Marcus(2020). Essentials of Investments (11th ed.). (남상구, 최승두 공역). 서울: 지필미디어.

DSR 규제에 대하여... (+ LTV, DTI)

suyeon96 — Mon, 3 May 2021 15:00:34 +0900

DSR이란?

DSR은 총부채원리금상환비율(Debt Service Ratio)의 약자로 총 금융부채 원리금 상환액을 연간 소득으로 나눈 비율을 뜻한다. 즉, DSR 규제란 대출자의 연소득에 대비하여 1년간 원리금으로 내는 돈이 얼마인지를 따져 대출금액을 제한하는 규제이다. 예를 들어 1년에 1억원을 버는 사람이 당해 전체 대출에 대한 원금과 이자로 4000만원을 내고 있다면 DSR은 40%인 것이다. 대출자의 모든 대출 원금 및 이자 상환액이 얼마나 부담이 되는지를 측정하는 지표이며, 수치가 낮을수록 상환 능력이 높다고 볼 수 있다.

DSR규제 현황 및 4.29 차주단위 규제 발표

현재 금융감독원은 시중은행에 은행 별로 DSR을 40%로 유지하도록 권고하고 있다. 은행 전체 고객들의 평균치로 계산하기 때문에 고객에 따라서는 DSR이 40%가 넘는 대출자도 있다. 일부 고소득자에 대해서는 개인별로 DSR을 적용하기도 한다. 하지만 최근 들어 금융위원회는 DSR 규제를 완전히 개인별로 적용하려는 시도를 하고 있다. 금융위는 지난달 29일 34차 비상경제중앙대책본부회의에서 ‘가계부채 관리 선진화 방안’에 따라 2023년 7월부터 DSR 규제를 차주 단위로 적용한다고 발표하였다. 앞으로는 개인별로 1인당 DSR 40%를 일괄 적용하여 개인의 대출 한도를 축소시킨다는 것이다. 이는 지난해 8%까지 치솟은 가계대출 증가세를 낮추고, 최근 유행하는 빛내서 투자하는 행위를 어느 정도 차단하기 위한 조치이다. 또한 고액의 신용대출 한도를 줄여 부동산 시장의 수요를 억제하려는 목적도 존재한다.

하지만 여기에는 단점도 존재한다. 일반적으로 주택담보대출을 받을 때는 대부분 대출한도를 꽉 채워서 받는 경우가 많은데, DSR 규제를 강화하면 추가 대출이 어렵게 된다. 급하게 자금이 필요한 경우 대출을 받지 못하게 되는 것이다. 또한 저소득자의 경우 더욱 대출이 힘들어질 것이다. 부동산 시장과 가계부채를 안정시키기 위한 조치이지만, 코로나19로 인해 경제가 침체되고 있는 상황에서 돈의 흐름이 더욱 약해지고 불경기가 심해지지 부작용이 생기지 않을까 하는 걱정도 든다.

LTV·DTI

주택담보대출의 대출금액을 제한하는 규제에는 DSR이외에도 대표적으로 LTV와 DTI가 있다. LTV는 주택담보인정비율(Loan to Value)의 약자로 주택의 담보가치에 따른 대출금의 비율을 의미한다. 즉, 주택의 시세에 대비하여 대출 가능한 한도 금액을 나타내는 것이다. DTI는 총부채상환비율(Debt To Income)의 약자로 금융부채 상환능력을 소득으로 따져서 대출한도를 정하는 비율이다. 연간 소득에서 매년 갚아야 하는 원금 및 이자가 차지하는 비율을 뜻한다. DTI와 DSR 연소득 대비 대출 가능한 한도를 계산하는데 쓰이는 지표로서, 주택담보대출 시 차주의 상환능력을 판단하고 규제하는 용도로 사용된다.

그렇다면 DTI와 DSR의 차이는 무엇일까? DTI는 해당 대출 건 이외의 대출은 이자 상환액만을 고려하는 반면, DSR은 기존 대출의 이자는 물론 원금까지 포함하여 계산한다. 따라서 DTI보다 DSR가 더 엄격하다고 볼 수 있으며, DSR 규제에서는 금융부채가 더욱 크게 반영되기 때문에 DTI 규제보다 대출 한도가 줄어든다.

[ELK Stack] 4. Metricbeat로 System Monitoring

suyeon96 — Sat, 13 Feb 2021 02:53:41 +0900

ELK Stack 목차

[ELK Stack] 1. ELK Stack 이란? (Beats, Logstash, Elasticsearch, Kibana)
[ELK Stack] 2. Elasticsearch, Logstash, Kibana 설치 및 구성
[ELK Stack] 3. Filebeat와 ELK Stack으로 Apache log 관리
[ELK Stack] 4. Metricbeat로 System Monitoring

1. Metricbeat란?

Metricbeat를 이용하면 시스템과 서비스에서 메트릭 정보를 손쉽게 수집할 수 있다.

Cpu, Memory, File system, Disk IO, Network IO 등과 시스템에서 실행되는 모든 프로세스에 대한 통계를 수집하여 전송한다.

또한 기본적으로 내장되어 있는 모듈은 Apache, Jolokia, NGINX, MongoDB, MySQL, PostgreSQL, Prometheus 등의 다양한 서비스로부터 메트릭을 수집하며, 원하는 모듈이 없다면 Go Language로 새로운 모듈을 간단하게 생성할 수도 있다.

2. Metricbeat 설치

이전 게시글에서는 yum으로 ELK stack을 설치했지만 이번에는 download 받아서 설치한다.

$ curl -L -O https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-7.10.2-x86_64.rpm
$ sudo rpm -vi metricbeat-7.10.2-x86_64.rpm

3. Metricbeat 설정

/etc/metricbeat/metricbeat.yml 파일을 아래와 같이 설정한다.

Kibana

# =================================== Kibana ===================================

# Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API.
# This requires a Kibana endpoint configuration.
setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "3.35.108.182:5601"

  # Kibana Space ID
  # ID of the Kibana Space into which the dashboards should be loaded. By default,
  # the Default Space will be used.
  #space.id:

구축된 Kibana dashboard를 사용하기 위해 Kibana endpoint를 설정해주면 된다.

Elasticsearch Output

# ================================== Outputs ===================================

# Configure what output to use when sending the data collected by the beat.

# ---------------------------- Elasticsearch Output ----------------------------
output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["3.35.108.182:9200"]

  # Protocol - either `http` (default) or `https`.
  #protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elk-user"
  password: "P@ssword!"

# ------------------------------ Logstash Output -------------------------------
#output.logstash:
  # The Logstash hosts
  #hosts: ["localhost:5044"]

  # Optional SSL. By default is off.
  # List of root certificates for HTTPS server verifications
  #ssl.certificate_authorities: ["/etc/pki/root/ca.pem"]

  # Certificate for SSL client authentication
  #ssl.certificate: "/etc/pki/client/cert.pem"

  # Client Certificate Key
  #ssl.key: "/etc/pki/client/cert.key"

Elasticsearch 또는 Logstash Output을 설정할 수 있다.

Filebeat 실습 때 Logstash를 통해 Elasticsearch로 보내봤으니, 이번에는 바로 Elasticsearch로 보낸다.

4. Kibana Dashboard 설정

$ metricbeat setup --dashboards

5. Metricbeat 실행

기본 초기화 셋팅

$ metricbeat setup -e

서비스 활성화

$ sudo systemctl enable metricbeat

$ sudo chkconfig --add metricbeat

시작

$ sudo systemctl start metricbeat

6. Elasticsearch Index 확인

$ curl localhost:9200/_cat/indices?v

7. Kibana 확인

우선 metricbeat-* Index Pattern을 만들어야 한다.

7.1 Kibana Discover

7.2 Kibana Dashboard

metricbeat의 kibana dashboard template를 다운받았기 때문에 Dashboard에 들어가면 수많은 템플릿이 기본적으로 제공된다.

이중 기본적인 [Metricbeat System] Host overview ECS 템플릿이다.

기본 템플릿 만으로도 충분히 활용 가능하며, 추가로 커스터마이징 하여 입맛에 맞게 변경할 수 있다.

Reference

[ELK Stack] 3. Filebeat와 ELK Stack으로 Apache log 관리

suyeon96 — Sat, 13 Feb 2021 02:47:06 +0900

ELK Stack 목차

[ELK Stack] 1. ELK Stack 이란? (Beats, Logstash, Elasticsearch, Kibana)
[ELK Stack] 2. Elasticsearch, Logstash, Kibana 설치 및 구성
[ELK Stack] 3. Filebeat와 ELK Stack으로 Apache log 관리
[ELK Stack] 4. Metricbeat로 System Monitoring

1. Filebeat 란?

log파일을 Logstash로 수집하지 않고 Filebeat를 사용하는 이유는 경량화되어 data 수집 및 전달에 최적화되어있기 때문이다.

(Filebeat는 Logstash보다 시스템 공간과 사용 공간이 적기 때문에 더 적은 리소스를 요구한다.)

Filebeat는 크게 Prospector, Harvester, Spooler로 이루어져 있다.

Prospector는 읽어야 할 소스를 식별하고 구분하는 역할을 한다. log, stdin 타입을 지원하며 Prospector 당 2개 이상의 type 선언이 가능하며, 어디까지 읽었는지 meta data를 별도 디스크에 저장한다. (default : /var/lib/filebeat/registry)

Harvester는 파일을 읽고 출력하는 역할을 한다. 하나의 Harvester가 각각 하나의 파일을 담당하는 구조를 가진다. 파일을 열고 닫는 것까지 담당하기 때문에 Harvester가 실행되고 있다는 것은 file descriptor가 남아 있다는 의미이다.

Spooler는 Harvester가 읽은 데이터를 집계하고 각각 설정한 output으로 전달한다.

2. Apache 설치

2.1 apache 설치

$ sudo yum -y install httpd

2.2 apache 설치 확인

$ httpd -v

2.3 apache 실행

$ sudo systemctl start httpd

2.4 apache web service 접근

2.5 apache access log 확인

$ tail -f /var/log/httpd/access_log

3. Filebeat 설치

3.1. Import the Elasticsearch GPG Key

공개 서명키 (public signing key) 설치

$ sudo rpm --import https://packages.elastic.co/GPG-KEY-elasticsearch

3.2 Filebeat 설치

/etc/yum.repos.d/ 디렉토리 아래에 Elastic.repo 파일을 만들고 아래와 같이 내용을 입력한다.

$ vi /etc/yum.repos.d/Elastic.repo
    [elastic-7.x]
    name=Elasticsearch repository for 7.x packages
    baseurl=https://artifacts.elastic.co/packages/7.x/yum
    gpgcheck=1
    gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
    enabled=1
    autorefresh=1
    type=rpm-md

파일을 추가한 후 yum명령을 이용해 filebeat 설치한다.

$ sudo yum -y install filebeat

3.3 Filebeat module list 확인

$ filebeat modules list

4. Filebeat 설정

Filebeat를 이용하여 apache log를 수집하고 logstash 또는 elasticsearch에 보내는 방법은 크게 2가지가 있다.

4.1 Enable apache module

첫 번째는 filebeat에서 제공하는 apache 모듈을 이용하는 것이다.

# apache module 활성화
$ filebeat modules enable apache

$ filebeat modules list

apache 모듈을 활성화시킨 후 초기 환경을 셋팅한다.

$ filebeat setup -e  # -e : debug mode

이후 /etc/filebeat/modules.d/apache.yml 파일을 아래와 같이 수정한다.

$ vi /etc/filebeat/modules.d/apache.yml

# Module: apache
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.10/filebeat-module-apache.html

- module: apache
  # Access logs
  access:
    enabled: true
    input:
      fields:
        server_name: elk-web
        log_type: apache_access
    var.paths: ["/var/log/httpd/access_log"]

    # Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths:

  # Error logs
  error:
    enabled: true
    input:
      fields:
        server_name: elk-web
        log_type: apache_error
    var.paths: ["/var/log/httpd/error_log"]

    # Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths:

하지만 우리는 apache module을 사용하지 않고 filebeat.yml 파일을 직접 수정하여 log를 수집할 것이다.

이를 위해 위에서 활성화한 apache module은 다시 비활성화 해주자.

$ filebeat modules disable apache

4.2 Configuration filebeat.yml

/etc/filebeat/filebeat.yml 파일을 아래와 같이 설정한다.

Inputs

# ============================== Filebeat inputs ===============================

filebeat.inputs:

# Each - is an input. Most options can be set at the input level, so
# you can use different inputs for various configurations.
# Below are the input specific configurations.

- type: log
  # Change to true to enable this input configuration.
  enabled: true

  # Paths that should be crawled and fetched. Glob based paths.
  paths:
    - /var/log/httpd/access_log
    #- c:\programdata\elasticsearch\logs\*

  # Exclude lines. A list of regular expressions to match. It drops the lines that are
  # matching any regular expression from the list.
  #exclude_lines: ['^DBG']

  # Include lines. A list of regular expressions to match. It exports the lines that are
  # matching any regular expression from the list.
  #include_lines: ['^ERR', '^WARN']

  # Exclude files. A list of regular expressions to match. Filebeat drops the files that
  # are matching any regular expression from the list. By default, no files are dropped.
  #exclude_files: ['.gz$']

  # Optional additional fields. These fields can be freely picked
  # to add additional information to the crawled log files for filtering
  fields:
    server_name: elk-web
    log_type: apache-access
  #fields:
  #  level: debug
  #  review: 1

fields의 항목은 output으로 보낼 때 추가한 필드를 포함하여 보낸다.

나중에 Kibana에서 해당 필드 키워드를 이용하여 data를 컨트롤할 수 있다.

Outputs

# ================================== Outputs ===================================

# Configure what output to use when sending the data collected by the beat.

# ---------------------------- Elasticsearch Output ----------------------------
#output.elasticsearch:
  # Array of hosts to connect to.
  #hosts: ["localhost:9200"]

  # Protocol - either `http` (default) or `https`.
  #protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  #username: "elastic"
  #password: "changeme"

# ------------------------------ Logstash Output -------------------------------
output.logstash:
  # The Logstash hosts
  hosts: ["3.35.108.182:5044"]

  # Optional SSL. By default is off.
  # List of root certificates for HTTPS server verifications
  #ssl.certificate_authorities: ["/etc/pki/root/ca.pem"]

  # Certificate for SSL client authentication
  #ssl.certificate: "/etc/pki/client/cert.pem"

  # Client Certificate Key
  #ssl.key: "/etc/pki/client/cert.key"

elasticsearch output을 주석 처리하고 logstash output을 활성화한다.

hosts는 elk-master 서버의 IP로 설정한다.

hosts에는 여러 노드를 입력할 수 있으며, 각각의 host에서 data를 균등하게 보내고 싶다면 loadbalance: true 설정을 넣어주면 된다.

5. Run Filebeat

systemd 기준

$ sudo systemctl start filebeat

Filebeat 데몬 로그 확인

$ tail -f /var/log/filebeat/filebeat

6. Logstash 파이프라인 설정

/etc/logstash/conf.d/filebeats.conf를 아래와 같이 설정한다.

$ vi /etc/logstash/conf.d/filebeats.conf

input {
  beats {
    port => 5044
  }
}
filter {
  grok {
    match => { "message" => "%{TIMESTAMP_ISO8601:time}\t%{DATA:tag}\t{ % {DATA:data} }" }
  }
  mutate {
    add_field => { "json_data" => "{ %{data}}" }
  }
  json {
    source => "json_data"
  }
  alter {
    remove_field => [ "data", "json_data" ]
  }
  date {
    match => [ "time", "yyyy-MM-dd'T'HH:mm:ssZZ" ]
  }
}
output {
  elasticsearch {
    hosts => "localhost:9200"
    index => "%{[fields][log_type]}-%{+YYYY.MM.dd}"
  }
}

filter에서 grok 등의 패턴을 이용하여 메시지를 가공할 수 있지만 일단 test를 위해 filter 없이 bypass 시켜보자.

7. Logstash 실행

$ sh /usr/share/logstash/bin/logstash -f /etc/logstash/conf.d/filebeats.conf

8. Elasticsearch index 생성 확인

$ curl localhost:9200/_cat/indices?v

9. Kibana 확인

9.1 Kibana index pattern 생성

index pattern을 검색하면 방금 생성한 apache-access-2021.02.08이 확인된다.

@timestamp 필드를 설정하고 최종 생성을 한다.

만들어진 Index Patterns에 아까 filebeat.yml에서 설정한 2개의 fields값이 포함되어 있는 것을 확인할 수 있다. (log_type, server_name)

9.2 Kibana 데이터 탐색 및 조회

Discover 메뉴로 진입하면 elk-web 서버의 apache access_log를 수집한 것을 확인할 수 있다.

message field를 확인해보자.

Reference

[ELK Stack] 2. Elasticsearch, Logstash, Kibana 설치 및 구성

suyeon96 — Sat, 13 Feb 2021 02:37:14 +0900

ELK Stack 목차

[ELK Stack] 1. ELK Stack 이란? (Beats, Logstash, Elasticsearch, Kibana)
[ELK Stack] 2. Elasticsearch, Logstash, Kibana 설치 및 구성
[ELK Stack] 3. Filebeat와 ELK Stack으로 Apache log 관리
[ELK Stack] 4. Metricbeat로 System Monitoring

1. 환경 구성

ELK Stack으로 web 서버의 Apache log와 metric data를 분석하고 관리하는 환경을 구성해보려 한다.

우선 AWS EC2로 web 서버와 master 서버를 준비하였다.

web 서버에는 Filebeat와 Metricbeat를 설치하여 Apache log와 시스템 메트릭 data를 수집한다.

master 서버에는 Elasticsearch, Logstash, Kibana를 설치하여 web서버의 data를 집계한다.

2. JAVA 환경 설정

Elasticsearch 및 Logstash 실행을 위해 자바 1.8 이상의 버전을 설치해야 한다.

2.1 JAVA 설치

$ yum list java*jdk-devel
  Loaded plugins: fastestmirror, langpacks
  Available Packages
  java-1.8.0-openjdk-devel.i686 1:1.8.0.275.b01-0.el7_9 updates
  java-1.8.0-openjdk-devel.x86_64 1:1.8.0.275.b01-0.el7_9 updates
  java-11-openjdk-devel.i686 1:11.0.9.11-2.el7_9 updates
  java-11-openjdk-devel.x86_64 1:11.0.9.11-2.el7_9 updates

$ yum -y install java-1.8.0-openjdk-devel.x86_64

$ java -version
  openjdk version "1.8.0_275"
  OpenJDK Runtime Environment (build 1.8.0_275-b01)
  OpenJDK 64-Bit Server VM (build 25.275-b01, mixed mode)

$ readlink -f /usr/bin/java
  /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.275.b01-0.el7_9.x86_64/jre/bin/java

2.2 JAVA 환경변수 설정

$ vi /etc/profile
  # setting java
  JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.275.b01-0.el7_9.x86_64
  PATH=$PATH:$JAVA_HOME/bin
  CLASSPATH=$JAVA_HOME/jre/lib:$JAVA_HOME/lib/tools.jar
  export JAVA_HOME PATH CLASSPATH

$ source /etc/profile
$ echo $JAVA_HOME
  /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.275.b01-0.el7_9.x86_64

3. ElasticSearch / logstash / kibana 설치

RPM(yum)으로 설치하며 systemd를 사용한다.

3.1 Import the Elasticsearch GPG Key

공개 서명키 (public signing key) 설치

$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

3.2 Installing from the RPM repository

먼저 최신 버전의 elasticsearch를 yum으로 설치하기 위해 /etc/yum.repos.d/ 디렉토리 아래에 elasticsearch.repo 파일을 만들고 아래와 같이 내용을 입력한다.

$ vi /etc/yum.repos.d/Elastic.repo

[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

파일을 추가한 후 yum명령을 이용해 Elasticsearch, Logstash, Kibana를 설치한다.

$ sudo yum -y install elasticsearch logstash kibana

$ yum list elasticsearch logstash kibana

3.3 ELK 환경 설정

3.3.1 jvm.options

Elasticsearch과 Logstash는 Java Runtime 가상머신 위에서 실행되는데 1gb의 힙 메모리가 기본으로 설정되어 있다. (7.0 기준) 원활한 환경을 위해 jvm.options 파일에서 아래 내용들을 수정한다.

# elasticsearch
$ vi /etc/elasticsearch/jvm.options
  # -Xms1g
  # -Xmx1g
  -Xms2g
  -Xmx2g

# logstash
$ vi /etc/logstash/jvm.options
  # -Xms1g
  # -Xmx1g
  -Xms2g
  -Xmx2g

(테스트용 master서버는 2Core/4GB라 logstash는 1g로 설정함)

3.3.2 elasticsearch.yml

elasticsearch 실행 환경에 대한 설정들은 대부분 elasticsearch.yml 파일에서 설정한다. YAML 파일이기 때문에 옵션을 설정할 때는 들여쓰기에 유의해야 한다.

vi /etc/elasticsearch/elasticsearch.yml
  ...
  # -------------------- Cluster --------------------
  cluster.name: suyeon-app
  # -------------------- Node --------------------
  node.name: suyeon.elktest.com
  # -------------------- Paths --------------------
  path.data: /ELK/elasticsearch        # 별도 disk
  path.logs: /ELK/log/elasticsearch    # 별도 disk
  # -------------------- Network --------------------
  network.host: 0.0.0.0    # ANY
  http.port: 9200
  # -------------------- Discovery --------------------
  discovery.seed_hosts: ["192.168.56.x", "127.0.0.1", "[::1]"]    # my IP
  cluster.initial_master_nodes: ["suyeon.elktest.com"]

  node.master: true

cluster.name : 클러스터 명 설정 (default는 elasticsearch이며 충돌을 방지하기 위해 반드시 고유한 이름으로 설정 필요)
node.name : elasticsearch 노드 명 설정
path.data : 색인된 데이터를 저장하는 경로 지정
path.logs : elasticsearch 실행 로그를 저장하는 경로 지정
bootstrap.memory_lock : Elasticsearch가 사용중인 힙메모리 영역을 다른 자바 프로그램이 간섭 못하도록 미리 점유하는 설정 (항상 true로 사용하는 것을 권장)
network.host : Elasticsearch가 실행되는 서버의 ip 주소 (default는 127.0.0.1(loopback)이며 0.0.0.0으로 설정 시 ANY로 통신이 가능)
http.port : Elasticsearch가 클라이언트와 통신하기 위한 http 포트를 설정 (default는 9200이며, 포트가 이미 사용 중인 경우 9200 ~ 9299 사이 값을 차례대로 사용)
transport.port : Elasticsearch 노드들 끼리 서로 통신하기 위한 tcp 포트를 설정 (default는 9300이며, 포트가 이미 사용 중인 경우 9300 ~ 9399 사이 값을 차례대로 사용)
cluster.initial_master_nodes : 클러스터가 최초 실행 될 때 명시된 노드들을 대상으로 마스터 노드를 선출
node.master : 마스터 후보(master eligible) 노드 여부를 설정

디스크 용량 및 성능 관리차원에서 로그파일 및 데이터파일을 별도로 분리 저장하여 관리하는 것이 좋다. 이를 위해 EBS를 새로 생성하여 마운트하였다.

yml 파일에 설정한 데로 data와 log 파일을 담을 디렉토리를 생성하고 권한을 설정해야 한다.

$ mkdir -p /ELK/elasticsearch
$ mkdir -p /ELK/log/elasticsearch
$ chown -R elasticsearch.elasticsearch /ELK

3.3.3 logstash.yml

logstash에 대한 설정 또한 logstash.yml 파일에서 설정한다.

$ vi /etc/logstash/logstash.yml
  # -------------------- Data path --------------------
  #path.data: /var/lib/logstash
  path.data: /ELK/logstash
  # -------------------- Data path --------------------
  #path.logs: /var/log/logstash
  path.logs: /ELK/log/logstash

pipeline.batch.size : 개별 worker 스레드가 input에서 수집할 최대 이벤트 개수 설정. 일반적으로 배치크기가 클수록 효율적이지만 메모리 오버해드가 증가함. (default : 125)
pipeline.batch.delay : 크기가 작은 배치를 pipeline worker에게 발송하기 전 각 이벤트를 기다리는 시간 (default : 50ms)

logstash 또한 data와 log 디렉토리를 따로 관리하자.

$ mkdir -p /ELK/logstash
$ mkdir -p /ELK/log/logstash
$ chown -R logstash.logstash /ELK

3.3.4 kibana.yml

$ vi /etc/kibana/kibana.yml
  #server.port: 5601
  server.port: 5601
  #server.host: "localhost"
  server.host: "0.0.0.0"
  #server.name: "your-hostname"
  server.name: "ktds.elklab.com"
  #elasticsearch.hosts: ["http://localhost:9200"]
  elasticsearch.hosts: ["http://localhost:9200"]    # or server IP

server.port : kibana가 통신할 포트 설정 (Default : 5601)
server.host : 백엔드 서버의 host IP 지정 (Default는 "localhost"이며, 원격 사용자의 연결을 허용하려면 kibana 서버의 IP주소 또는 DNS 이름으로 설정
server.name : kibana 인스턴스 명 설정
elasticsearch.hosts : 모든 쿼리에 사용할 Elasticsearch 인스턴스의 url 설정 (설정된 모든 노드는 동일한 클러스터에 있어야 함)

3.4 Run ELK Service

Elasticsearch 서비스

$ sudo /bin/systemctl daemon-reload

# To configure Elasticsearch to start automatically when the system boots up, run the following commands
$ sudo chkconfig --add elasticsearch
$ sudo systemctl enable elasticsearch.service

# Elasticsearch can be started and stopped as follows
$ sudo systemctl start elasticsearch.service
$ sudo systemctl stop elasticsearch.service

logstash 서비스

$ sudo chkconfig --add logstash
$ sudo systemctl enable logstash.service

$ sudo systemctl start logstash.service

kibana 서비스

$ sudo chkconfig --add kibana
$ sudo systemctl enable kibana.service

$ sudo systemctl start kibana.service

3.5 상태 확인

elasticsearch

$ sudo systemctl status elasticsearch
$ ps-ef | grep elasticsearch

logstash

$ systemctl status logstash.service
$ ps -ef | grep logstash

kibana

$ systemctl status kibana.service
$ ps -ef | grep kibana

네트워크 상태 (port) 확인

$ netstat -nlp | grep 9200
$ netstat -nlp | grep 5601

3.6 방화벽 open

$ firewall-cmd --add-port=9200/tcp --permanent --zone=public
$ firewall-cmd --add-port=9300/tcp --permanent --zone=public

$ firewall-cmd --add-port=5443/udp --permanent --zone=public
$ firewall-cmd --add-port=5443/tcp --permanent --zone=public

$ firewall-cmd --add-port=5601/tcp --permanent --zone=public

$ firewall-cmd --reload
$ firewall-cmd --list-all
  ...
  ports: 9200/tcp 9300/tcp 5443/udp 5443/tcp 5601/tcp
  ...

master 서버의 인바운드 규칙을 아래와 같이 설정하였다.

4. Checking ELK stack

4.1 Elasticsearch running 테스트

$ curl -X GET "localhost:9200/?pretty"

{
  "name" : "Cp8oag6",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "AT69_T_DTp-1qgIJlatQqA",
  "version" : {
    "number" : "7.10.2",
    "build_flavor" : "default",
    "build_type" : "tar",
    "build_hash" : "f27399d",
    "build_date" : "2016-03-30T09:51:41.449Z",
    "build_snapshot" : false,
    "lucene_version" : "8.7.0",
    "minimum_wire_compatibility_version" : "1.2.3",
    "minimum_index_compatibility_version" : "1.2.3"
  },
  "tagline" : "You Know, for Search"
}

4.2 Elasticsearch web 접속 테스트

4.3 Kibana 접속 테스트

Reference

elasticsearch 참고 : https://www.elastic.co/guide/en/elasticsearch/reference/current/setup.html
logstash 참고 : https://www.elastic.co/guide/en/logstash/current/setup-logstash.html
kibana 참고 : https://www.elastic.co/guide/en/kibana/current/setup.html

[ELK Stack] 1. ELK Stack 이란? (Beats, Logstash, Elasticsearch, Kibana)

suyeon96 — Sat, 13 Feb 2021 02:24:20 +0900

ELK Stack 목차

[ELK Stack] 1. ELK Stack 이란? (Beats, Logstash, Elasticsearch, Kibana)
[ELK Stack] 2. Elasticsearch, Logstash, Kibana 설치 및 구성
[ELK Stack] 3. Filebeat와 ELK Stack으로 Apache log 관리
[ELK Stack] 4. Metricbeat로 System Monitoring

ELK Stack 이란?

ELK는 Elasticsearch, Logstash, Kibana 세 가지 오픈소스 프로젝트의 이니셜이다.

Elasticsearch

Elasticsearch는 JSON 기반의 분산형 RESTful 검색 및 분석 엔진이다.

Apache Lucene 기반으로 구축되었으며 분산형 및 개방형을 특징으로 한다.

Lucene이 JAVA로 만들어졌기 때문에 Elasticsearch 또한 JAVA로 개발되어 있다.

Elasticsearch의 가장 큰 장점은 실시간(Real-time) 분석 시스템이라는 것이다.

현재 대용량 데이터 분석에 가장 널리 사용되고 있는 하둡(Hadoop)은 배치 기반으로 데이터수집 → 분석 → 결과도출 루틴으로 실행된다.

반면 Elasticsearch는 클러스터가 실행되고 있는 동안 계속해서 데이터가 입력(Indexing)되고, 그와 동시에 실시간에 가까운 속도로 색인된 데이터의 검색과 집계가 가능하다.

이가 가능한 이유는 역인덱스(Inverted file index) 데이터 구조를 사용하여 풀텍스트(Full text) 검색을 할 수 있도록 설계되었기 때문이다.

역색인이란 전공서적 맨 뒷편의 색인된 키워드를 이용해 역으로 본문을 찾는 방식을 생각하면 된다.

참고로 Elasicserach의 핵심 기능들은 Apache 2.0 라이센스로 배포되고 있으며, 6.3 버전부터는 Elastic 라이센스와 Apache 라이센스가 섞여있다.

X-Pack 디렉토리 아래의 파일들이 Elastic EULA 라이센스가 적용되고 그 외의 파일은 Apache 라이센스를 따른다.

최근 이를 두고 벌어지는 AWS와 Elastic사의 분쟁이 굉장한 이슈이다.

이에 대해 이야기하려면 따로 포스팅을 해야할 정도라 간단하게 요약하자면...

Elastic사에서 AWS를 막기 위해 라이센스를 변경했고, AWS는 Apache 2.0 라이센스의 Elasticsearch를 fork하여 직접 운영하겠다고 발표하였다.

앞으로 Elastic과 AWS의 Elasticsearch(상표권은 사용 못하겠지만)가 어떤 행보를 보일지, 개발자 커뮤니티는 어떤 버전을 선택할지가 초미의 관심사이다.

Logstash

Logstash는 실시간 파이프라인 기능을 가진 오픈소스 데이터 수집 엔진이다.

JRuby로 되어있으며, Ruby로 개발되어 JAVA Runtime 가상머신 위에서 돌아간다.

원래는 Elasticsearch와 별개로 시작된 프로젝트였으나, Logstash에서 출력 API로 Elasticsearch를 지원하기 시작하면서 많은 사용자들이 Elasticsearch의 입력 수단으로 Logstash를 사용하며 ELK로 통합되었다.

Logstash는 Server-side 데이터 처리 파이프라인으로 다양한 소스에서 동시에 데이터를 수집하고 통합한다.

또한 수집된 데이터를 정규화하여 Elasticsearch 등의 목적지로 전송하는 역할을 한다.

거의 대부분의 이벤트를 수집하여 변호나할 수 있으며 기본으로 제공되는 여러 코덱을 이용하여 수집(Ingestion) 프로세스를 한층 더 간소화할 수 있다.

Kibana

Kibana는 Elasticsearch에 색인된 데이터를 검색하고 시각화하는 오픈소스 프론트엔드 서비스이다.

Elasticsearch로부터 document, aggregation 집계 결과 등을 불러와 웹으로 시각화 한다.

기본적으로 Discover, Visualize, Dashboard 메뉴와 다양한 App으로 구성되어 있으며, 플러그인을 통해 확장 가능하다.

Discover는 Elasticsearch에 색인된 소스 데이터들의 검색을 위한 메뉴이다.

Dashboard는 Visualize 메뉴에서 만들어진 시각화 도구(수집된 차트, 그래프, 메트릭, 검색 및 지도 등)들을 조합하여 단일 페이지에 모아 놓고 다양한 관점에서 데이터에 요약된 인사이트를 제공한다.

ELK Stack 구성

기존에는 세 가지 오픈소스 제품을 통합하여 ELK라고 하였으나, 2015년 Beats가 도입되며 ELK Stack 또는 Elasic Stack이라는 서비스로 부르기 시작하였다.

Beats란 서버에 에이전트로 설치하여 다양한 유형의 데이터를 Elasticsearch 또는 Logstash로 전송하는 오픈소스이다.

경량 에이전트 Beats가 서버에 설치되어 데이터를 Logstash 또는 Elasticsearch로 전송한다.

Logstash는 다양한 소스에서 데이터를 수집하고 가공, 변환하여 Elasticsearch에 인덱싱하여 전송한다.

Elasticsearch는 수신된 데이터를 저장소에 저장하고, 탐색하는 역할을 수행한다.

마지막으로 사용자는 Kibana를 통해 Elasicsearch에 저장된 데이터를 시각화하여 실시간 분석 등을 할 수 있다.

참고로 Beats 제품군은 아래와 같다.

Reference

[DevOps] Jenkins Scaling (master + slave 구성)

suyeon96 — Sun, 31 Jan 2021 23:39:06 +0900

이전 글에서 master 노드에 Jenkins를 설치하고 정적 web site와 docker 이미지를 각각 AWS S3와 AWS ECR에 배포하고 배포된 이미지를 AWS ECS에 올리는 작업을 하였다.

하지만 작업이 많아지고 무거워지는 경우 서버 한대에서 이를 처리하기에 버거워질 것이다.

오늘은 slave 서버를 추가하여 master 노드가 slave 노드와 작업을 분산할 수 있도록 구성을 해보자.

slave 노드에는 별도로 Jenkins를 설치하지 않고 ssh 통신으로 master 노드가 slave 노드에 작업을 지시하도록 할 것이다.

1. AWS EC2 slave node 생성

우선 master와 동일하게 AWS EC2로 Slave 서버를 생성한다.

2. slave 환경설정

master 서버와 동일하게 java, git, docker를 설치한다.

$ sudo yum install -y java-1.8.0-openjdk git docker

3. ssh connection

master에 ssh-keygen을 생성한 후

$ ssh-keygen

slave의 authorized_keys에 master의 public key를 추가한다.

$ vi ~/.ssh/authorized_keys

master → slave ssh 연결 확인!

4. Credential 추가

Jenkins에서 slave와의 ssh 연결을 위해 Credential을 추가한다.

Private Key 항목에는 master node의 private key를 입력한다.

$ cat ~/.ssh/id_rsa

생성된 Credentials 목록이다.

5. Node 추가

slave node를 추가할 차례이다.

테스트 용이므로 slave node에 일을 시켰을 때 동작되는 것을 확인하고자 Usage 항목에서 'Only build jobs with label expressions matching this node'를 선택한다.

slave node가 정상적으로 추가되었다.

node 목록에서 master와 slave를 확인할 수 있다.

6. Jenkinsfile 수정

default로 master node에서 빌드될 수 있도록 상단에서 agent label을 'master'로 설정하고, 'Deploy Server' Stage는 slave node에서 빌드될 수 있도록 설정하였다.

def DEPLOY_TO

pipeline {
  //agent any
  agent {
    label 'master'
  }

  parameters {
    ...
  }

  stages {
    stage('Decide Deploy To') {
      ...
    }

    stage('Check deploy parameter') {
      ...
    }

    stage('Build website') {
      ...
    }

    stage('Deploy website') {
      ...
    }

    stage('Build Server') {
      ...
    }

    stage('Deploy Server') {
      agent {
        label 'slave'
      }
      steps {
        script {
          withAWS(region:'ap-northeast-2', credentials:'jenkinsaws') {
            sh """
              aws ecs update-service \
                --region ap-northeast-2 \
                --cluster ${DEPLOY_TO}-app \
                --service ${DEPLOY_TO}-webserver \
                --force-new-deployment \
                --desired-count 2
              aws ecs wait services-stable \
                --cluster ${DEPLOY_TO}-app \
                --services ${DEPLOY_TO}-webserver
            """
          }
        }
      }
    }

  }
}

7. 배포 테스트

master 노드와 slave 노드에서 동시에 빌드되는 중이다.

정상적으로 빌드도 완료되었으며,

log를 봐도 'Deploy Server' Stage가 slvae 노드에서 빌드되었음을 확인할 수 있다.

ps. 이렇게 활용할 수도...

stage('Some Parallel Stage') {
  parallel {
    stage('frontend test') {
      agent { label 'slave1' }
      ...
    }
    stage('backend test') {
      agent { label 'slave2' }
      ...
    }
    stage('master job') {
      agent { label 'master' }
      ...
    }
  }
}

위 Stage 처럼 Parallel 하게 3개의 Stage를 각각 다른 node에서 돌아가도록 설정할 수도 있다.

[DevOps] Jenkins 설치 및 Static web page, Docker 배포 (AWS S3, ECR, ECS)

suyeon96 — Sun, 31 Jan 2021 14:13:01 +0900

Jenkins

Jenkins란 오픈소스 자동화 서버로 구축, 테스트, 배포와 관련된 소프트웨어 개발 프로세스를 자동화하고 CI/CD 제공하는 툴이다.

Java Runtime 위에서 작동되며 다양한 플러그인을 지원하여 인프라 운영 상황에 맞게 입맛대로 파이프라인을 구성할 수 있다.

Jenkins Pipeline

Jenkins Pipeline이란 CI/CD를 Jenkins에 구현하고 통합하기 위한 플러그인의 모음이다.

코드가 커밋된 후부터 실환경에 배포되기까지 릴리즈 과정은 꽤나 복잡하다.

코드를 빌드하고 여러 단계의 테스트를 거쳐 각각의 환경에 배포해야 한다.

우리는 Pipeline을 미리 정의하여, 이러한 프로세스를 자동화할 수 있다.

Jenkins Pipeline은 Pipeline DSL 구문을 통해 코드 형태로 복잡한 파이프라인을 모델링할 수 있으며, Jenkinsfile이라는 text 파일로 정의하여 프로젝트에 포함시켜 활용할 수 있다.

Jenkinsfile로 Pipeline을 관리하는 경우 프로젝트의 여러 구성원이 쉽게 공유하고 리뷰/수정할 수 있으며, Pipeline audit에 대한 추적이 가능하다.

또한 Pipeline 빌드 프로세스를 자동으로 생성해주며, Jenkins 노드가 재시작되어도 안전하다.

Pipeline의 2가지 주요 개념에 대해 알아보자.

Stage : 전체 파이프라인에서 수행되는 작업을 개념적 구분해놓은 단계이다. (스텝들의 모음)

Step : 젠킨스가 특정 시점에서 수행해야 하는 단순한 하나의 task를 의미한다.

아래는 Jenkins Pipeline 시나리오 예시이다.

오늘은 Jenkins를 통해 AWS S3 배포와 Docker 이미지/컨테이너 배포를 해 볼 계획이다.

또한 Git과 연동하여 master 브랜치는 Prod 환경에, develop 브랜치는 Dev 환경에 배포되도록 Pipeline을 구성할 것이다.

1. 환경 설정

1.1. Jenkins Node 준비

AWS EC2를 하나 준비하였다.

AMI : Amazon Linux 2 AMI
인스턴스 유형 : t2.small (1Core/2GB)

1.2. Jenkins 설치

$ sudo yum update -y

# Jenkins 패키지 추가
$ sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins.io/redhat/jenkins.repo &&
$ sudo rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key

# Install java, docker, git
$ sudo yum install -y java-1.8.0-openjdk jenkins git docker

# 자바 버전 8 로 설정
$ sudo alternatives --config java
$ sudo service jenkins start

1.3. docker 그룹에 Jenkins 추가

# docker 그룹에 jenkins 추가
$ sudo usermod -aG docker jenkins
$ sudo systemctl start docker
$ sudo service docker start
$ sudo chmod 666 /var/run/docker.sock
$ sudo -su jenkins

1.4. Jenkins Dashboard 접속

Jenkins Dashboard에 접속하기 위해서는 우선 기본 port인 8080을 열어줘야 한다.

최초 접속 시 Password를 입력해야 한다.

초기 Password는 화면에 적혀있듯이 아래 경로에서 확인 가능하다.

# 초기 비밀번호 확인
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

1.5. 시작

1.6. 추가 Pulg-in 설치

Pipeline에서 사용하기 위한 plugin을 추가한다.

1.7. Git Credentials 추가

Jenkins와 Git의 연결을 위해 Credentials을 추가해줘야 한다.

우선 Git Access Token을 발급받는다.

Jenkins관리 > Manage Credentials 메뉴에서 Credentials를 추가한다.

1.8. AWS Credentials 추가

동일하게 AWS와의 연결을 위해 우선 AWS에서 jenkins 사용자를 만들고

Jenkins Credentials를 추가한다.

방금 만든 2개의 Credentials이다.

1.9. Pipeline 생성

git을 붙이기 위해 Multibranch Pipeline item을 만들었다.

이름과 설명을 간단하게 입력하고

Git Project Repository를 선택한다.

마지막으로 Jenkinsfile의 위치를 설정하고, Trigger 배치 간격을 정해준다.
(test를 원활하게 진행하기 위해 1분으로 설정하였다.)

2. Parameter 관리 (AWS Parameter Store)

본격적으로 배포를 하기 전에 Parameter를 받아오는 방법에 대해 알아보고 가자.

인프라 운영에서 Parameter 관리는 매우 중요하다.

자체적으로 Parameter 서버를 따로 운영하기도 하고, 심지어는 DB나 File로 관리하기도 한다.

이번에는 AWS Parameter Store에 파라미터를 설정하고 Jenkinsfile에서 이를 받아오도록 구현해보려 한다.

2.1 AWS parameter store에 환경 별 파라미터 저장

2.2 jq install

Jenkins node에서 jq 명령을 수행하기 위해 yum 설치

$ sudo yum jq
$ sudo yum install jq

2.3 Jenkinsfile 설정

def DEPLOY_TO

pipeline {
  agent any

  parameters {
    string(name:'MYSQL_HOST', defaultValue: 'devMysql', description: 'dev mysql host')
    string(name:'MYSQL_PASSWORD', defaultValue: 'new1234!', description: 'dev mysql password')
  }

  stages {
    // branch명을 기준으로 배포할 환경 설정
    stage('Decide Deploy To') {
      steps {
        script {
          if (env.BRANCH_NAME == 'master'){
            DEPLOY_TO = 'prod'
          } else if (env.BRANCH_NAME == 'develop'){
            DEPLOY_TO = 'dev'
          } else if (env.BRANCH_NAME == 'qa'){
            DEPLOY_TO = 'qa'
          }
        }
        echo "DEPLOY_TO: ${DEPLOY_TO}"
      }
    }

    // aws Parameter Store의 파라미터 정보 가져오기
    stage('Check deploy parameter') {
      steps {
        script {
          withAWS(region:'ap-northeast-2', credentials:'jenkinsaws') {
            def mysql_host = sh(script: "aws ssm get-parameters --name /${DEPLOY_TO}/MYSQL_HOST | jq '.Parameters[0].Value'", returnStdout: true).trim()
            def mysql_password = sh(script: "aws ssm get-parameters --name /${DEPLOY_TO}/MYSQL_PASSWORD | jq '.Parameters[0].Value'", returnStdout: true).trim()
            echo "${mysql_host}"
          }
        }
      }
    }
  }
}

2.4 log 확인

master 브랜치에 push 후 log이다.

prod 환경도 정상적으로 설정되며, aws Parameter Store의 /prod/MYSQL_HOST 파라미터도 잘 가져온 것을 확인할 수 있다.

3. Front-end 배포 (AWS S3)

3.1. Jenkinsfile 설정

front-end를 배포하기 위한 'Deploy website' stage 추가

stage('Deploy website') {
  steps{
    dir ('./website') {
      script {
        withAWS(region:'ap-northeast-2', credentials:'jenkinsaws') {
          sh """
          aws s3 sync ./ s3://${DEPLOY_TO}-suyeon-website
          """
        }
      }
    }
  }
}

3.2 AWS S3 버킷 생성

정적 page를 배포하기 위해 환경별로 AWS S3 버킷을 생성하고

3.3 코드 준비

간단하게 배포할 코드를 준비하였다.

./website/index.html

<html>

<body>
  <h1>Hello World</h1>
</body>

</html>

3.4 Prod 배포

Prod 환경에 배포하기 위해 master 브랜치에 새로 추가한 index.html을 push 하였다.

Jenkins Dashboard에서 정상적으로 Pipeline이 동작한 것을 확인할 수 있다.

'Deploy website' Stage의 Log를 확인해보니 prod용으로 만들어 놓은 s3 버킷에 index.html이 잘 배포되었다고 한다.

확인사살 1

확인사살 2

3.5 Dev 배포

Dev 환경에도 배포해보자.

develop branch에 push를 하자 Trigger에 의해 develop Pipeline이 동작한다.

dev 환경에도 정상적으로 배포가 되었다.

4. Docker Image 배포 (AWS ECR)

이번에는 docker를 빌드하여 이미지 생성 후 이미지를 AWS ECR(Elastic Container Registry)에 배포해보자.

4.1 Jenkins node docker 설치 확인

$ docker ps

4.2 Jenkinsfile 설정

docker 이미지를 배포하기 위한 'Build Server' stage 추가

stage('Build Server') {
  steps {
    dir('./server') {
      script {
        withAWS(region:'ap-northeast-2', credentials:'jenkinsaws') {
          def login = ecrLogin()
          def mysql_host = sh(script: "aws ssm get-parameters --name /${DEPLOY_TO}/MYSQL_HOST | jq '.Parameters[0].Value'", returnStdout: true).trim()
          def mysql_password = sh(script: "aws ssm get-parameters --name /${DEPLOY_TO}/MYSQL_PASSWORD | jq '.Parameters[0].Value'", returnStdout: true).trim()
          echo "${login}"
          // 실제 로그인
          sh "${login}"
          sh """
          docker build --build-arg env=${DEPLOY_TO} --build-arg mysqlHost=${mysql_host} --build-arg mysqlPassword=${mysql_password} -t 000000000000.dkr.ecr.ap-northeast-2.amazonaws.com/${DEPLOY_TO}-webserver .
          docker push 000000000000.dkr.ecr.ap-northeast-2.amazonaws.com/${DEPLOY_TO}-webserver
          """
        }
      }
    }
  }
}

000000000000 대신 AWS 계정 ID를 넣어줘야 한다.

4.3 AWS ECR Repositories 생성

docker 이미지를 배포할 AWS ECR Repository를 환경별로 생성하였다.

4.4 Docker 빌드 환경 준비

./server/package.json

{
  "name": "server",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc",
    "start": "node ./dist/index.js",
    "test": "node_modules/.bin/jest .",
    "lint": "npx eslint index.ts"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@types/jest": "^26.0.20",
    "express": "^4.17.1",
    "typescript": "^4.1.3"
  },
  "devDependencies": {
    "@typescript-eslint/eslint-plugin": "^4.14.1",
    "@typescript-eslint/parser": "^4.14.1",
    "eslint": "^7.18.0",
    "jest": "^26.6.3"
  }
}

./server/Dockerfile

FROM node:11.13.0
LABEL name="server"

RUN mkdir app

WORKDIR /app
COPY ./package.json /app/package.json
COPY ./package-lock.json /app/package-lock.json

RUN npm install

ARG env
ARG mysqlHost
ARG mysqlPassword
ENV APP_ENV=$env
ENV MYSQL_HOST=$mysqlHost
ENV MYSQL_PASSWORD=$mysqlPassword

COPY . /app

EXPOSE 80

RUN echo 'Build Completed'

# The first parameter of docker CMD is executable and second parameter is file or parameters.
# Docker cmd internally uses sh -C
CMD ["npm","start"]

4.5 Prod 배포

prod 용 AWS ECR Repository에 이미지가 잘 들어갔다.

5. Docker Container 배포 (AWS ECS)

AWS ECR에 push 된 이미지를 AWS ECS(Elastic Container Service)에 배포해보자.

5.1 Jenkinsfile 설정

docker 컨테이너를 배포하기 위한 'Deploy Server' stage 추가

stage('Deploy Server') {
  steps {
    script {
      withAWS(region:'ap-northeast-2', credentials:'jenkinsaws') {
        sh """
          aws ecs update-service \
            --region ap-northeast-2 \
            --cluster ${DEPLOY_TO}-app \
            --service ${DEPLOY_TO}-webserver \
            --force-new-deployment \
            --desired-count 2
          aws ecs wait services-stable \
            --cluster ${DEPLOY_TO}-app \
            --services ${DEPLOY_TO}-webserverD
        """
      }
    }
  }
}

5.2 AWS ECS 클러스터 생성

5.3 Prod 배포

AWS ECS 클러스터 작업 확인

Reference

https://www.jenkins.io/doc/book/pipeline/

아마존 Fire TV Stick 구매 및 NETFLIX(넷플릭스) 연결

suyeon96 — Mon, 11 Jan 2021 03:42:18 +0900

코로나19가 지속되며 집에 머무는 시간이 많아졌고 TV로 편하게 NETFLIX를 보면 어떨까 생각했다.

이참에 IPTV를 설치할까 고민하다 TV를 많이 보는 편도 아니고, 가끔 NETFILX와 유튜브만 볼 것 같아 보다 가성비 좋은 아마존 Fire Tv Stick을 구매하였다.

셋탑박스 중 샤오미 TV Stick도 잠깐 구매 선상에 올랐지만, 아마존을 애정 하는 관계로다가 Fire TV Stick을 선택하였다.

참고로 현재 Amazon Fire TV Stick은 3가지 모델로 출시되어 있다.

Left to right: Fire TV Stick Lite, Fire TV Stick, Fire TV Stick 4K

하드웨어 성능은 거의 비슷하나 리모컨 기능과 해상도 지원이 조금씩 다르니 자신에게 잘 맞는 제품을 선택하면 된다.

(참고 : Amazon Fire TV Stick, Stick Lite, and Stick 4K specs compared)

	Fire TV Stick Lite	Fire TV Stick	Fire TV Stick 4K
Video	1080p @ 60 fps HDR10+	1080p @ 60 fps HDR10+	4K @ 60 fps HDR10+
CPU	MT8695D 1.7 GHz quad-core 32-bit (software limitation)	MT8695D 1.7 GHz quad-core 32-bit (software limitation)	MTK8695+MT7668 1.7 GHz quad-core 32-bit (software limitation)
GPU	IMG GE8300	IMG GE8300	IMG GE8300
RAM	1GB DDR4	1GB DDR4	1.5 GB DDR4
Storage	8GB	8GB	8GB
WiFi	WiFi 5 2 x 2 MIMO	WiFi 5 2 x 2 MIMO	WiFi 5 2 x 2 MIMO
Bluetooth	BT 5.0	BT 5.0	BT 5.0
Ethernet	10/100 (with dongle)	10/100 (with dongle)	10/100 (with dongle)
OS	Fire OS 7 (Android 9)	Fire OS 7 (Android 9)	Fire OS 6 (Android 7.1)
Remote	Alexa voice remote Lite	Alexa voice remote	Alexa voice remote
Price	$30	$40	$50

구성품은 아래와 같다.

설치방법은 매우매우 간단하다.

미국에서 직구해서 110v 어답터가 포함되어 있으니, 이것만 220v 어답터로 변경해서 사용하면 된다.

TV HDMI 단자에 연결하고

Wifi 연결하고 아마존 로그인까지 완료하면 설정은 끝이다.

NETFLIX, 유튜브, 아마존 FRIME Video 등 다양한 OTT 서비스를 이용할 수 있다.

나의 목적은 NETFLIX였으니, NETFLIX 앱을 선택하여 로그인하면 PC 또는 태블릿과 동일하게 이용 가능하다.

끝!

[VSCode] EditorConfig - 확장자 별 tab size (Indentation) 설정하기

suyeon96 — Mon, 4 Jan 2021 20:55:11 +0900

코드의 가독성과 일관성 유지를 위해 표준화된 Code Style과 Rule에 따라 코드를 작성하는 것이 중요하다.

그중 Indentation Rule (들여쓰기 규칙)을 Visual Studio Code에서 File Format 별로 설정하는 방법을 알아보자.

Google HTML/CSS Style Guide와 JavaScript Standard Style에 따라 .html, .css, .js의 경우 하나의 tab을 2 spaces로 설정하고, 나머지 파일에 대해서는 default인 4 spaces로 유지한다.

Google HTML/CSS Style Guide

JavaScript Standard Style

EditorConfig for VS Code

1. Default Setting

1.1 Preferences > Settings (⌘ + ,)에서 Text Editor > Tab Size를 4로 설정

1.2 Preferences > Settings (⌘ + ,)에서 Text Editor > Detect Indentation 체크

2. VS Code Extension : EditorConfig for VS Code 설치

2.1 Installation

2.2 폴더 우클릭 후 Generate .editorconfig

2.3 .editorconfig 파일 수정

.html .css .js 파일의 경우 indent_size = 2로 설정

[*.{html, css, js}]
indent_size = 2

Supported Properties (https://editorconfig.org/#supported-properties)

Properties	Comment
indent_style	`tab` 또는 `space` 설정
indent_size	들여쓰기 수준에 사용되는 너비의 size 설정
end_of_line	개행 표시 방법 제어 (`lf`, `cr`, `crlf`)
charset	인코딩 설정
trim_trailing_whitespace	newline 앞의 공백 문자를 제거하려면 `true`로 그렇지 않으면 `false`로 설정
insert_final_newline	저장 시 파일 마지막 line을 줄바꿈 처리 하려면 `true`로 그렇지 않으면 `false`로 설정

.html 파일은 2 spaces로 .java 파일은 4 spaces로 설정된 것을 확인할 수 있다.

.html

.java

[자료구조] 그래프 (Graph) - 인접행렬 vs 인접리스트, DFS, BFS, Connected Component, Spanning Tree

suyeon96 — Mon, 4 Jan 2021 04:05:49 +0900

1. 그래프

1.1 그래프란?

그래프(Graph)란 요소들이 서로 복잡하게 연결되어 있는 관계를 표현하는 자료구조이다.

그래프는 정점(vertex)과 간선(edge)들의 집합으로 구성된다.

G = (V, E)

수학적으로 그래프를 표시하는 방법이다.

V(G)는 그래프 G의 정점들의 집합을, E(G)는 그래프 G의 간선들의 집합을 의미한다.

그래프는 수학자 오일러(Euler)에 의해 창안되어 수학의 한 분야로서 수백 년 간 연구되어 왔지만, 컴퓨터 과학 분야에서 그래프 알고리즘을 다루기 시작한 것은 오래되지 않았다.

지하철 노선도, 도심의 도로 등 실생활의 다양한 예를 그래프로 표현하고 활용할 수 있으며, 특히 알고리즘에서 굉장히 많이 사용되므로 그래프에 대해 반드시 공부해야 한다.

※ 오일러 경로 (Eulerian Tour)

그래프에 존재하는 모든 간선을 한번만 통과하면서 처음 정점으로 되돌아오는 경로
그래프의 모든 정점에 연결된 간선의 개수가 짝수일 때만 오일러 경로가 존재 (오일러의 정리)

1.2 그래프 용어

정점 (vertex)

노드(node)라고도 하며 데이터가 저장되는 그래프의 기본 원소이다.
간선 (edge)

링크(link)라고도 하며 정점 간의 관계를 나타낸다.
인접 정점 (adjacent vertex)

하나의 정점에서 간선에 의해 직접 연결되어 있는 정점을 뜻한다.
위 그래프에서 정점 C의 인접 정점은 A, D 이다.
차수(degree)

정점에 연결된 간선의 수를 말한다.
위 그래프에서 정점 A의 차수는 3이고, 모든 정점의 차수를 합하면 8이다.
무방향 그래프에서 하나의 간선은 두 개의 정점에 인접하기 때문에 간선 수에 2배를 해주면 된다.

방향 그래프의 경우 외부에서 오는 간선의 수를 진입 차수(in-degree)라고 하며, 외부로 향하는 간선의 수를 진출 차수(out-degree)라고 한다.
경로 (path)

간선을 따라갈 수 있는 길을 말하며, 정점을 나열하여 표시한다.
정점 s로부터 정점 e까지의 경로는 s, v₁, v₂ ... e로 표현하며, 반드시 정점들 간의 간선이 존재해야 한다.
너무나도 당연하게도 간선이 존재하지 않는 길은 경로가 될 수 없다.
경로의 길이 (length)

경로를 구성하는 데 사용된 간선의 수를 뜻한다.
단순 경로 (simple path)

경로 중에서 반복되는 간선이 없는 경로이다.
사이클 (cycle)

시작 정점과 종료 정점이 같은 단순 경로를 뜻한다.
위 그래프에서 A, C, D, A 경로를 사이클이라고 한다.

추가로 그래프를 표현하는 방법에 대해서도 알아보자.

V(G1) = {0, 1, 2, 3}, E(G1) = {(0, 1), (0, 2), (0, 3), (1, 2), (2, 3)}
V(G2) = {0, 1, 2, 3}, E(G2) = {(0, 1), (0, 2)}
V(G3) = (0, 1, 3}, E(G3) = {<0, 1>, <1, 0>, <1, 2>}

1.3 그래프의 종류

그래프는 간선(edge)의 종류에 따라 구분된다.

무방향 그래프 (Undirected Graph)

두 정점을 연결하는 간선에 방향이 없는 그래프이며, 양 방향으로 이동이 가능하다.

위 그래프의 경우 (A, B)로 표현한다.

방향 그래프 (Directed Graph)

두 정점을 연결하는 간선에 방향이 존재하는 그래프이며, 간선의 방향으로만 이동할 수 있다.

위 그래프의 경우 <A, B>로 표현한다.

가중치 그래프 (Weighted Graph)

간선에 비용(cost) 또는 가중치(weight)가 할당된 그래프이다. 네트워크(network)라고 불리기도 한다.

완전 그래프 (Complete Graph)

모든 정점 간에 간선이 존재하는 그래프이다.

무방향 완전 그래프의 정점의 수가 n이라면, 전체 간선의 수는 n * (n-1) / 2 가 된다.

위 그래프의 경우 n=4이며 간선의 수는 (4*3)/2=6 이다.

1.4 그래프 ADT

객체

정점의 집합과 간선의 집합

연산

create() : 그래프 생성
insertVertex(v) : 그래프에 정점 v 삽입
insertEdge(u, v) : 그래프에 u정점과 v정점을 연결하는 간선 삽입
deleteVertex(v) : 그래프에서 정점 v 삭제 (v에 연결된 모든 간선도 함께 삭제)
deleteEdge(u, v) : 그래프에서 u정점과 v정점을 연결하는 간선 삭제
adjacent(v) : 정점 v에 인접한 모든 정점을 반환

1.5 그래프 구현 - 인접 행렬 (Adjacency Materix)

컴퓨터에서 그래프를 구현하는 방법에는 배열(Array)을 사용하는 방법과 연결리스트(Linked List)를 사용하는 방법이 있다.

인접 행렬을 이용한 그래프 구현

그래프의 정점을 2차원 배열로 만든 것이다.

정점의 개수가 n이라면 n*n 형태의 2차원 배열이 인접 행렬로 사용된다.

인접 행렬에서 행과 열은 정점을 의미하며, 각각의 원소들은 정점 간의 간선을 나타낸다.

무방향 그래프는 (a), (b)에서 볼 수 있듯이 인접 행렬이 대칭적 구조를 가진다.
(두 개의 정점에서 간선이 동시에 연결되어 있기 때문)

가중치 그래프의 경우 행렬에서 0과 1이 아니라 각 간선의 가중치 값이 저장된다.
(이 경우 가중치가 0인 것과 간선이 없는 것이 구별돼야 함)

장점

2차원 배열에 모든 정점들의 간선 정보가 있기 때문에, 두 정점을 연결하는 간선을 조회할 때 O(1) 시간복잡도로 가능하다.
정점(i)의 차수를 구할 때는 다음과 같이 인접행렬(M)의 i번째 행의 값을 모두 더하면 되므로 O(n)의 시간복잡도를 가진다.

( $degree(i) = \sum_{k=0}^{n-1}{M[i][k]}$ )
구현이 비교적 간단하다.

단점

간선의 수와 무관하게 항상 n² 크기의 2차원 배열이 필요하므로 메모리 공간이 낭비된다.
그래프의 모든 간선의 수를 알아내려면 인접행렬 전체를 확인해야 하므로 O(n²)의 시간이 소요된다.

C++ 구현

/*
 * 9.1
 * 인접 행렬(Adjacency Matrix)를 이용한 Graph 구현
 */
#include <iostream>
using namespace std;

#define MAX_VTXS 256    // 최대 정점 개수

class AdjMatGraph{
private:
    int size;                       // 정점의 개수
    char vertices[MAX_VTXS];        // 정점의 이름
    int adjMat[MAX_VTXS][MAX_VTXS];    // 인접 행렬

public:
    AdjMatGraph(){
        reset();
    }
    ~AdjMatGraph(){}

    char getVertex(int i){
        return vertices[i];
    }
    int getEdge(int i, int j){
        return adjMat[i][j];
    }
    void setEdge(int i, int j, int val){
        adjMat[i][j] = val;
    }

    // 그래프 초기화
    void reset(){
        for(int i=0; i<MAX_VTXS; i++){
            for(int j=0; j<MAX_VTXS; j++){
                setEdge(i, j, 0);
            }
        }
        size = 0;
    }

    // 정점 삽입
    void insertVertex(char name){
        if(isFull()){
            cout << "Graph vertex full error" << endl;
            return;
        }

        vertices[size++] = name;
    }

    // 간선 삽입 (무방향 그래프)
    void insertEdge(int u, int v){
        setEdge(u, v, 1);       // 가중치 그래프에서는 1이 아닌 가중치 삽입
        setEdge(v, u, 1);       // 방향 그래프에서는 삭제 (<u,v>만 존재)
    }

    // 그래프 정보 출력
    void display(){
        cout << "vertex size : " << size << endl;
        cout << "    ";
        for(int i=0; i<size; i++){
            cout << getVertex(i) << " ";
        }
        cout << endl;

        for(int i=0; i<size; i++){
            cout << getVertex(i) << " : ";
            for(int j=0; j<size; j++){
                cout << getEdge(i, j) << " ";
            }
            cout << endl;
        }
    }

    bool isEmpty(){
        return size == 0;
    }
    bool isFull(){
        return size >= MAX_VTXS;
    }
};

int main(){
    AdjMatGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3

    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(0, 3);     // A->D
    graph.insertEdge(2, 3);     // C->D

    graph.display();

    return 0;
}

인접행렬을 이용하여 아래와 같은 그래프를 구현하였다.

1.6 그래프 구현 - 인접 리스트 (Adjacency List)

인접 리스트를 이용한 그래프 구현

그래프의 각 정점에 인접한 정점들을 연결리스트(Linked List)로 표현하는 방법이다.

즉 정점의 개수만큼 인접리스트가 존재하며, 각각의 인접리스트에는 인접한 정점 정보가 저장되는 것이다.

그래프는 각 인접리스트에 대한 헤드포인터를 배열로 갖는다.

무방향 그래프의 경우 간선이 추가되면 각각의 정점의 인접리스트에 반대편 정점의 노드를 추가해야 한다.

장점

존재하는 간선만 관리하면 되므로 메모리 사용 측면에서 보다 효율적이다.
그래프의 모든 간선의 수를 알아내려면 각 정점의 헤더 노드부터 모든 인접리스트를 탐색해야 하므로 O(n+e)의 시간이 소요된다.

단점

두 정점을 연결하는 간선을 조회하거나 정점의 차수를 알기 위해서는 정점의 인접 리스트를 탐색해야 하므로 정점의 차수만큼의 시간이 필요하다. O(degree(v))
구현이 비교적 어렵다.

C++ 구현

/*
 * 9.2
 * 인접 리스트(Adjacency List)를 이용한 Graph 구현 (무방향 그래프)
 */
#include <iostream>
using namespace std;

#define MAX_VTXS 256    // 최대 정점 개수

struct Node{
private:
    int id;         // vertex id
    Node* link;     // next node's pointer

public:
    Node(int _id, Node* _link){
        id = _id;
        link = _link;
    }
    ~Node(){};

    // getter/setter
    int getId(){
        return id;
    }
    void setId(int _id){
        id = _id;
    }
    Node* getLink(){
        return link;
    }
    void setLink(Node* _link){
        link = _link;
    }
};

class AdjListGraph{
private:
    int size;                   // 정점의 개수
    char vertices[MAX_VTXS];    // 정점의 이름
    Node* adjList[MAX_VTXS];    // 인접 리스트

public:
    AdjListGraph(){
        size = 0;
    }
    ~AdjListGraph(){}

    char getVertex(int i){
        return vertices[i];
    }

    // 그래프 초기화
    void reset(){
        for(int i=0; i<size; i++){
            if(adjList[i] != NULL){
                delete adjList[i];
            }
        }
        size = 0;
    }

    // 정점 삽입
    void insertVertex(char name){
        if(isFull()){
            cout << "Graph vertex full error" << endl;
            return;
        }

        vertices[size] = name;
        adjList[size++] = NULL;
    }

    // 간선 삽입 (무방향 그래프)
    void insertEdge(int u, int v){
        // 인접리스트에 추가
        adjList[u] = new Node(v, adjList[u]);   // 새로운 노드로 head pointer가 바뀜 (새로운 node는 기존의 head pointer를 link로 함)
        adjList[v] = new Node(u, adjList[v]);   // 방향 그래프에서는 삭제 (<u,v>만 존재)
    }

    // 그래프 정보 출력
    void display(){
        cout << "vertex size : " << size << endl;
        for(int i=0; i<size; i++){
            cout << getVertex(i) << " : ";
            Node* head = adjList[i];
            while(head != NULL){
                cout << getVertex(head->getId()) << " ";
                head = head->getLink();
            }
            cout << endl;
        }
    }

    // 'v'번째 정점의 인접 정점 리스트 반환
    Node* adjacent(int v){
        return adjList[v];
    }

    bool isEmpty(){
        return size == 0;
    }
    bool isFull(){
        return size >= MAX_VTXS;
    }
};

int main(){
    AdjListGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3

    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(0, 3);     // A->D
    graph.insertEdge(2, 3);     // C->D

    graph.display();

    return 0;
}

동일하게 아래의 그래프를 인접 리스트로 구현한 것이다.

1.7 인접 행렬 vs 인접 리스트

마치 어떻게 활용될지에 따라 ArrayList와 LinkedList를 고민하는 것처럼, 이 또한 상황에 따라 알맞은 방법을 선택해야 한다.

만약 10억 개의 노드가 있고 각 노드가 2개씩의 간선만 있는 상황이다. 인접행렬로 구현한 그래프에서는 한 정점의 차수를 구할 때 10억번의 연산을 수행할 것이다. 반면, 인접리스트로 구현한 그래프에서는 2번의 연산만 수행하면 된다.

정점의 개수에 비해 간선의 개수가 매우 적은 희소 그래프(sparse graph)에서는 인접리스트가 유리할 수 있고, 모든 정점간에 간선이 존재하는 완전 그래프(Complete Graph)에서는 인접행렬이 유리할 수 있다.

그래프에서 주로 어떤 연산이 수행되는지도 매우 중요하게 고려되어야 할 것이다.

답은 없다. 상황에 따라 최선의 방법을 선택하는 것이 프로그래머의 덕목이다.

2. 그래프 활용

2.1 깊이우선 탐색 (DFS)

깊이우선 탐색(DFS: Depth First Search)이란 특정 노드에서 시작하여 다음 분기(branch)로 넘어가기 전에 해당 분기를 완벽하게(끝까지) 탐색하는 방법을 뜻한다.

아래 그래프를 깊이우선 탐색해보자

인접행렬을 이용한 DFS 구현 (C++)

// DFS 탐색 기능이 추가된 그래프
class SearchAdjMatGraph : public AdjMatGraph{
private:
    bool visited[MAX_VTXS];     // 방문 기록

public:
    // 모든 정점의 방문기록을 false로 초기화
    void resetVisited(){
        for(int i=0; i<size; i++){
            visited[i] = false;
        }
    }

    // 깊이우선탐색 (순환)
    void dfs(int v){
        resetVisited();
        dfsRecur(v);
    }
    void dfsRecur(int v){
        visited[v] = true;      // 현재 vertex 방문처리
        cout << getVertex(v) << " ";

        for(int n=0; n<size; n++){
            if(isLinked(v, n) && visited[n]==false){
                dfsRecur(n);
            }
        }
    }
};

int main(){
    SearchAdjMatGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3
    graph.insertVertex('E');    // 4
    graph.insertVertex('F');    // 5
    graph.insertVertex('G');    // 6
    graph.insertVertex('H');    // 7
    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(1, 3);     // B->D
    graph.insertEdge(2, 3);     // C->D
    graph.insertEdge(2, 4);     // C->E
    graph.insertEdge(3, 5);     // D->F
    graph.insertEdge(4, 6);     // E->G
    graph.insertEdge(4, 7);     // E->H
    graph.insertEdge(6, 7);     // G->H

    cout << "== Display Graph == " << endl;
    graph.display();

    cout << "-DFS => ";
    graph.dfs(0);

    return 0;
}

인접리스트를 이용한 DFS 구현 (C++)

// DFS 탐색 기능이 추가된 그래프
class SearchAdjListGraph : public AdjListGraph{
private:
    bool visited[MAX_VTXS];     // 방문 기록

public:
    // 모든 정점의 방문기록을 false로 초기화
    void resetVisited(){
        for(int i=0; i<size; i++){
            visited[i] = false;
        }
    }

    // 깊이우선탐색 (순환)
    void dfs(int v){
        resetVisited();
        dfsRecur(v);
    }
    void dfsRecur(int v){
        visited[v] = true;      // 현재 vertex 방문처리
        cout << getVertex(v) << " ";

        // v 정점의 인접리스트를 모두 방문하며 탐색
        for(Node *p=adjList[v]; p!=NULL; p=p->getLink()){
            if(visited[p->getId()] == false){
                dfsRecur(p->getId());
            }
        }
    }
};

int main(){
    SearchAdjListGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3
    graph.insertVertex('E');    // 4
    graph.insertVertex('F');    // 5
    graph.insertVertex('G');    // 6
    graph.insertVertex('H');    // 7
    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(1, 3);     // B->D
    graph.insertEdge(2, 3);     // C->D
    graph.insertEdge(2, 4);     // C->E
    graph.insertEdge(3, 5);     // D->F
    graph.insertEdge(4, 6);     // E->G
    graph.insertEdge(4, 7);     // E->H
    graph.insertEdge(6, 7);     // G->H

    cout << "== Display Graph == " << endl;
    graph.display();

    cout << "-DFS => ";
    graph.dfs(0);

    return 0;
}

DFS 결과 순서가 다른 이유는 인접 리스트의 노드 순서가 역순으로 들어있기 때문이다.

※ 시간복잡도

정점의 수가 n이고 간선의 수가 e인 그래프를 인접 행렬로 구현하는 경우 DFS 시간복잡도는 O(n²) 이며, 인접 리스트로 구현하는 경우 DFS 시간복잡도는 O(n+e) 이다.

2.2 너비우선 탐색

너비우선 탐색(BFS: Breadth First Search)이란 특정 노드에서 시작하여 인접한 노드를 먼저 탐색해나가는 방법을 뜻한다.

이번에는 아래 그래프를 너비우선 탐색해보자

인접행렬을 이용한 BFS 구현 (C++)

// BFS 탐색 기능이 추가된 그래프
class SearchAdjMatGraph : public AdjMatGraph{
private:
    bool visited[MAX_VTXS];     // 방문 기록

public:
    // 모든 정점의 방문기록을 false로 초기화
    void resetVisited(){
        for(int i=0; i<size; i++){
            visited[i] = false;
        }
    }

    // 너비우선탐색 (큐 이용)
    void bfs(int v){
        resetVisited();

        visited[v] = true;      // 현재 vertex 방문처리
        cout << getVertex(v) << " ";

        queue<int> queue;
        queue.push(v);          // 시작 vertex enqueue

        while(!queue.empty()){
            v = queue.front();
            queue.pop();        // v = queue.dequeue()

            // 인접 정점 탐색
            for(int n=0; n<size; n++){
                if(isLinked(v, n) && visited[n]==false){
                    cout << getVertex(n) << " ";
                    visited[n] = true;  // 방문 처리
                    queue.push(n);
                }
            }
        }

    }
};

int main(){
    SearchAdjMatGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3
    graph.insertVertex('E');    // 4
    graph.insertVertex('F');    // 5
    graph.insertVertex('G');    // 6
    graph.insertVertex('H');    // 7
    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(1, 3);     // B->D
    graph.insertEdge(2, 3);     // C->D
    graph.insertEdge(2, 4);     // C->E
    graph.insertEdge(3, 5);     // D->F
    graph.insertEdge(4, 6);     // E->G
    graph.insertEdge(4, 7);     // E->H
    graph.insertEdge(6, 7);     // G->H

    cout << "== Display Graph == " << endl;
    graph.display();

    cout << "-BFS => ";
    graph.bfs(0);

    return 0;
}

인접리스트를 이용한 BFS 구현 (C++)

// BFS 탐색 기능이 추가된 그래프
class SearchAdjListGraph : public AdjListGraph{
private:
    bool visited[MAX_VTXS];     // 방문 기록

public:
    // 모든 정점의 방문기록을 false로 초기화
    void resetVisited(){
        for(int i=0; i<size; i++){
            visited[i] = false;
        }
    }

    // 너비우선탐색 (큐 사용)
    void bfs(int v){
        resetVisited();

        visited[v] = true;      // 현재 vertex 방문처리
        cout << getVertex(v) << " ";

        queue<int> queue;
        queue.push(v);          // 시작 vertex enqueue

        while(!queue.empty()){
            v = queue.front();
            queue.pop();        // v = queue.dequeue()

            // 인접 정점 탐색
            for(Node *n=adjList[v]; n!=NULL; n=n->getLink()){
                int nId = n->getId();       // 인접 노드의 정점 id
                if(!visited[nId]){
                    cout << getVertex(nId) << " ";
                    visited[nId] = true;  // 방문 처리
                    queue.push(nId);
                }
            }
        }
    }
};

int main(){
    SearchAdjListGraph graph;

    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3
    graph.insertVertex('E');    // 4
    graph.insertVertex('F');    // 5
    graph.insertVertex('G');    // 6
    graph.insertVertex('H');    // 7
    // 간선 삽입
    graph.insertEdge(0, 1);     // A->B
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(1, 3);     // B->D
    graph.insertEdge(2, 3);     // C->D
    graph.insertEdge(2, 4);     // C->E
    graph.insertEdge(3, 5);     // D->F
    graph.insertEdge(4, 6);     // E->G
    graph.insertEdge(4, 7);     // E->H
    graph.insertEdge(6, 7);     // G->H

    cout << "== Display Graph == " << endl;
    graph.display();

    cout << "-BFS => ";
    graph.bfs(0);

    return 0;
}

※ 시간복잡도

정점의 수가 n이고 간선의 수가 e인 그래프를 인접 행렬로 구현하는 경우 BFS 시간복잡도는 O(n²) 이며, 인접 리스트로 구현하는 경우 BFS 시간복잡도는 O(n+e) 이다.

2.3 Connected Component

Connected Component(연결 성분)이란 여러 개의 노드의 집합에서 간선으로 연결된 각각의 그래프를 의미한다.

연결 성분을 찾는 방법

그래프 상의 임의의 노드를 선택해 DFS 또는 BFS 탐색을 수행한다.
(방문한 노드는 같은 성분으로 labeling 한다.)
남은 노드 중 방문하지 않은 노드를 선택하여 다시 1번을 수행한다.
그래프의 모든 노드가 방문처리될 때까지 1, 2번을 반복한다.

C++ 구현

/*
 * 9.9
 * 인접 행렬(Adjacency Matrix)과 DFS를 이용한 Connected Component (연결 성분) 탐색 프로그램 구현해보기
 */
#include <iostream>
using namespace std;

#define MAX_VTXS 256    // 최대 정점 개수

class AdjMatGraph{
protected:
    int size;                           // 정점의 개수
    char vertices[MAX_VTXS];            // 정점의 이름
    int adjMat[MAX_VTXS][MAX_VTXS];     // 인접 행렬

public:
    AdjMatGraph(){
        reset();
    }
    ~AdjMatGraph(){}

    char getVertex(int i){
        return vertices[i];
    }
    int getEdge(int i, int j){
        return adjMat[i][j];
    }
    void setEdge(int i, int j, int val){
        adjMat[i][j] = val;
    }

    // 그래프 초기화
    void reset(){
        for(int i=0; i<MAX_VTXS; i++){
            for(int j=0; j<MAX_VTXS; j++){
                setEdge(i, j, 0);
            }
        }
        size = 0;
    }

    // 정점 삽입
    void insertVertex(char name){
        if(isFull()){
            cout << "Graph vertex full error" << endl;
            return;
        }

        vertices[size++] = name;
    }

    // 간선 삽입 (무방향 그래프)
    void insertEdge(int u, int v){
        setEdge(u, v, 1);       // 가중치 그래프에서는 1이 아닌 가중치 삽입
        setEdge(v, u, 1);       // 방향 그래프에서는 삭제 (<u,v>만 존재)
    }

    // 그래프 정보 출력
    void display(){
        cout << "vertex size : " << size << endl;
        cout << "    ";
        for(int i=0; i<size; i++){
            cout << getVertex(i) << " ";
        }
        cout << endl;

        for(int i=0; i<size; i++){
            cout << getVertex(i) << " : ";
            for(int j=0; j<size; j++){
                cout << getEdge(i, j) << " ";
            }
            cout << endl;
        }
    }

    // 두개의 정점이 연결되어 있는지 검사
    bool isLinked(int u, int v){
        return getEdge(u, v) != 0;
    }

    bool isEmpty(){
        return size == 0;
    }
    bool isFull(){
        return size >= MAX_VTXS;
    }
};

// DFS를 이용하여 그래프의 연결성분 탐색
class ConnectedComponentGraph : public AdjMatGraph{
private:
    int labelValue = 0;
    int label[MAX_VTXS];     // component label;

public:
    // 모든 node의 label을 0으로 초기화
    void resetVisited(){
        for(int i=0; i<size; i++){
            label[i] = 0;
        }
    }

    // 깊이우선탐색 (순환)
    void labelDfsRecur(int v){
        label[v] = labelValue;

        for(int n=0; n<size; n++){
            if(isLinked(v, n) && label[n]==0){
                labelDfsRecur(n);
            }
        }
    }

    void findConnectedComponent(){
        cout << "== Connected Component ==" << endl;
        int cnt = 0;        // component 개수
        labelValue = 0;     // labelValue 초기화
        resetVisited();     // label array 초기화

        for(int i=0; i<size; i++){
            if(label[i]==0){        // 방문하지 않은 node의 경우
                labelValue++;       // label 값 증가
                labelDfsRecur(i);
                cnt++;
            }
        }

        cout << "- component 개수 : " << cnt << endl;
        for(int i=1; i<=labelValue; i++){
            cout << "  " << i << " : ";
            for(int j=0; j<size; j++){
                if(label[j]==i){
                    cout << "[" << getVertex(j) << "]";
                }
            }
            cout << endl;
        }

    }
};

int main(){
    // 그래프 모양
    cout << "== Graph Shape ==" << endl;
    cout << "A - C   E - G" << endl;
    cout << "          \\ " << endl;
    cout << "B - D - F   H" << endl;
    cout << endl;

    // 인접 행렬 그래프
    ConnectedComponentGraph graph;

    cout << "== Adjacency Matrix Graph == " << endl;
    // 정점 삽입 (A, B, C, D)
    graph.insertVertex('A');    // 0
    graph.insertVertex('B');    // 1
    graph.insertVertex('C');    // 2
    graph.insertVertex('D');    // 3
    graph.insertVertex('E');    // 4
    graph.insertVertex('F');    // 5
    graph.insertVertex('G');    // 6
    graph.insertVertex('H');    // 7
    // 간선 삽입
    graph.insertEdge(0, 2);     // A->C
    graph.insertEdge(1, 3);     // B->D
    graph.insertEdge(3, 5);     // D->F
    graph.insertEdge(4, 6);     // E->G
    graph.insertEdge(4, 7);     // E->H

    graph.display();

    graph.findConnectedComponent();

    return 0;
}

2.4 신장 트리 (Spanning Tree)

신장 트리(spanning tree)란 그래프 내의 모든 정점이 연결되어 있으면서 사이클이 없는 트리를 의미한다.

신장 트리는 그래프의 n개의 정점을 정확하게 n-1개의 간선으로 연결하게 된다.

신장 트리를 구현하기 위해서는 DFS 또는 BFS 도중에 사용된 간선들만 남겨두면 된다.

즉, 이를 그림으로 표현하면 아래와 같다.

[자료구조] 우선순위 큐와 힙 (Priority Queue & Heap)

suyeon96 — Mon, 4 Jan 2021 03:07:10 +0900

1. 우선순위 큐

1.1 우선순위 큐란?

큐(Queue)는 먼저 들어오는 데이터가 먼저 나가는 FIFO(First In First Out) 형식의 자료구조이다.

우선순위 큐(Priority Queue)는 먼저 들어오는 데이터가 아니라, 우선순위가 높은 데이터가 먼저 나가는 형태의 자료구조이다.

우선순위 큐는 일반적으로 힙(Heap)을 이용하여 구현한다.

1.2 힙이란?

힙(Heap)은 우선순위 큐를 위해 고안된 완전이진트리 형태의 자료구조이다.

여러 개의 값 중 최댓값 또는 최솟값을 찾아내는 연산이 빠르다.

힙의 특징

완전이진트리 형태로 이루어져 있다.
부모노드와 서브트리간 대소 관계가 성립된다. (반정렬 상태)
이진탐색트리(BST)와 달리 중복된 값이 허용된다.

힙의 종류

최대 힙 (Max Heap)

부모 노드의 키 값이 자식 노드보다 크거나 같은 완전이진트리이다.

❝ key(부모노드) ≥ key(자식노드) ❞

최소 힙 (Min Heap)

부모 노드의 키 값이 자식 노드보다 작거나 같은 완전이진트리이다.

❝ key(부모노드) ≥ key(자식노드) ❞

1.3 우선순위 큐 구현방법 비교

우선순위 큐를 힙이 아니라 배열 또는 연결리스트를 이용하여 구현할 수도 있다.

하지만 배열과 연결리스트는 선형 구조의 자료구조이므로 삽입 또는 삭제 연산을 위한 시간복잡도는 O(n)이다.

반면 힙트리는 완전이진트리 구조이므로 힙트리의 높이는 log₂(n+1)이며, 힙의 시간복잡도는 O(log₂n)이다.

아래는 이를 정리한 표이다.

1.4 우선순위 큐 ADT

객체

우선순위를 가진 요소들의 모음

연산

insert(x) : 우선순위 큐에 요소 x 추가
remove() : 우선순위 큐에서 가장 우선순위가 높은 요소를 삭제하고 반환
find() : 우선순위 큐에서 가장 우선순위가 높은 요소를 반환

2. 우선순위 큐 구현

2.1 힙 구현

힙은 일반적으로 배열을 이용하여 구현한다.

완전 이진트리이므로 중간에 비어있는 요소가 없기 때문이다.

위 그림과 같이 트리의 각 노드에 번호를 붙이고, 이 번호를 배열의 인덱스로 생각하면 효과적으로 힙을 구현할 수 있다.

배열로 구현하였기 때문에 부모 또는 자식 노드를 찾아가는 연산을 구현하기도 간편하다.

자식노드를 구하고 싶을 때

왼쪽 자식노드 index = (부모 노드 index) * 2
오른쪽 자식노드 index = (부모 노드 index) * 2 + 1

부모노드를 구하고 싶을 때

부모 노드 index = (자식노드 index) / 2

2.2 삽입 연산

힙에 삽입을 하기 위해서는 힙 트리의 성질을 만족시키면서 새로운 요소를 추가해야 한다.

삽입 방법

우선 완전이진트리의 마지막 노드에 이어서 새로운 노드를 추가한다.
추가된 새로운 노드를 부모의 노드와 비교하여 교환한다.
정상적인 힙트리가 될 때 까지 (더이상 부모노드와 교환할 필요가 없을 때까지) 2번을 반복한다.

최악의 경우 새로 추가된 노드가 루트노트까지 비교하며 올라가야 하므로 시간복잡도가 O(log₂n)이다.

2.3 삭제 연산

힙 트리에서 루트노드가 가장 우선순위가 높으므로 루트 노드를 삭제해야 한다.

삭제가 이뤄진 후 힙 트리의 성질이 유지돼야 하므로 아래와 같은 방법으로 삭제를 진행한다.

삭제 방법

루트 노드를 삭제한다.
루트 노드가 삭제된 빈자리에 완전이진트리의 마지막 노드를 가져온다.
루트 자리에 위치한 새로운 노드를 자식 노드와 비교하여 교환한다.
이때 최대 힙인 경우 자식노드 중 더 큰 값과 교환을 하며, 최소 힙인 경우 더 작은 값과 교환을 한다.
정상적인 힙트리가 될 때까지 (더 이상 자식노드와 교환할 필요가 없을 때까지) 3번을 반복한다.

삭제 연산 또한 최악의 경우 루트노트부터 가장 아래까지 내려가야 하므로 시간복잡도가 O(log₂n)이다.

2.4 우선순위 큐 구현 (C++)

#include <iostream>
using namespace std;

#define MAX_ELEMENT 200      // heap array size

template <typename T>
struct Node{
private:
    int key;
    T data;
public:
    Node(){
        key = 0;
    }
    Node(int _key, T _data){
        key = _key;
        data = _data;
    }
    ~Node(){}

    // getter/setter
    int getKey(){
        return key;
    }
    void setKey(int _key){
        key = _key;
    }
    T getData(){
        return data;
    }
    void setData(T _data){
        data = _data;
    }
};

template <typename T>
class MaxHeap{
private:
    Node<T> node[MAX_ELEMENT];
    int size;   // heap 요소 개수
public:
    MaxHeap(){
        size = 0;
    }
    ~MaxHeap(){}

    // search node
    Node<T>& getParent(int index){
        return node[index/2];
    }
    Node<T>& getLeftChild(int index){
        return node[index*2];
    }
    Node<T>& getRightChild(int index){
        return node[index*2+1];
    }

    // 삽입
    void insert(int key, T data){
        if(isFull()){
            cout << "Heap is Full" << endl;
            return;
        }

        int index = ++size;     // 힙트리 마지막 노드의 다음 위치에서 시작

        // 힙트리를 거슬러 올라가며 부모 노드와 비교
        while(index != 1 && key > getParent(index).getKey()){
            node[index] = getParent(index);
            index /= 2;
        }

        // 최종 위치에 데이터 삽입
        node[index].setKey(key);
        node[index].setData(data);
    }

    // 삭제
    T remove(){
        if(isEmpty()){
            cout << "Heap is Empty" << endl;
            exit(EXIT_FAILURE);
        }

        Node<T> itemNode = node[1];         // root node (삭제 대상)
        Node<T> lastNode = node[size--];    // 힙트리의 마지막 노드
        int index = 1;                      // 마지막 노드의 index (root 부터 시작)

        // root 부터 내려가며 자식 노드와 비교
        while(index <= size){
            if(index*2 > size){             // leaf node인 경우 (자식 노드가 없는 경우)
                break;
            }else if(index*2 == size){      // 자식노드가 하나인 경우
                if(lastNode.getKey() < getLeftChild(index).getKey()){
                    node[index] = getLeftChild(index);
                    index *= 2;
                }else{
                    break;
                }
            }else{                          // 자식노드가 두개인 경우
                int leftChildKey = getLeftChild(index).getKey();
                int rightChildKey = getRightChild(index).getKey();

                // 둘 중 key가 더 큰 자식노드와 교환
                if(lastNode.getKey() < leftChildKey || lastNode.getKey() < rightChildKey){
                    node[index] = leftChildKey > rightChildKey ? getLeftChild(index) : getRightChild(index);
                    index = leftChildKey > rightChildKey ? index*2 : index*2+1;
                }else{
                    break;
                }
            }
        }
        node[index] = lastNode;     // 마지막 노드를 최종 위치에 저장
        return itemNode.getData();  // 삭제 노드의 data 반환
    }

    // 출력
    void display(){
        int level = 1;
        for(int i=1; i<= size; i++){
            if(i == level){
                cout << endl;
                level *= 2;
            }
            cout << node[i].getData() << "(" << node[i].getKey() << ")  ";
        }
        cout << '\n' << "-------------------------" << endl;
    }

    bool isEmpty(){
        return size == 0;
    }
    bool isFull(){
        return size == MAX_ELEMENT - 1;
    }

};

int main(){
    MaxHeap<int> priorityQueue;

    // 삽입
    priorityQueue.insert(10, 10);
    priorityQueue.insert(5, 5);
    priorityQueue.insert(30, 30);
    priorityQueue.insert(8, 8);
    priorityQueue.insert(9, 9);
    priorityQueue.insert(3, 3);
    priorityQueue.insert(7, 7);
    priorityQueue.display();

    // 삭제
    priorityQueue.remove();
    priorityQueue.display();
    priorityQueue.remove();
    priorityQueue.display();

    return 0;
}

2.5 C++에서의 우선순위 큐 사용 (STL)

#include <iostream>
#include <queue>
using namespace std;

int main(){
    // Max Heap
    priority_queue<int, vector<int>, less<int>> pq1;

    pq1.push(5);
    pq1.push(2);
    pq1.push(8);
    pq1.push(9);
    pq1.push(1);
    pq1.push(14);

    pq1.pop();
    pq1.pop();

    cout << "Max Heap PQ : ";
    while(!pq1.empty()){
        cout << pq1.top() << " ";
        pq1.pop();
    }
    cout << endl;

    // Min Heap
    priority_queue<int, vector<int>, greater<int>> pq2;

    pq2.push(5);
    pq2.push(2);
    pq2.push(8);
    pq2.push(9);
    pq2.push(1);
    pq2.push(14);

    pq2.pop();
    pq2.pop();

    cout << "Min Heap PQ : ";
    while(!pq2.empty()){
        cout << pq2.top() << " ";
        pq2.pop();
    }
    cout << endl;

    return 0;
}

2.6 [응용] 힙 정렬 (Heap Sort)

힙 정렬이란 최대 힙트리나 최소 힙트리를 이용한 정렬 알고리즘 중 하나이다.

힙 정렬 알고리즘

n개의 요소를 하나씩 힙에 삽입한다.
n번에 걸쳐 힙에서 요소를 하나씩 삭제하고 반환된 값을 순차적으로 정렬한다.

앞에서 힙의 삽입·삭제 시간복잡도는 O(log₂n) 이라는 것을 알아보았다.

힙 정렬을 위해 n번의 삽입과 n번의 삭제가 이뤄지므로 정렬에 필요한 전체 시간은 log₂n + log₂n에 비례한다.

이는 O(log₂n) 시간복잡도로 표현 가능하며, 삽입정렬과 같은 간단한 정렬 알고리즘의 시간복잡도가 O(n²)이라는 것과 비교했을 때 매우 효율적인 알고리즘이다.

특히 힙 정렬은 전체 자료를 정렬하는 것보다 전체에서 가장 큰 값 몇 개가 필요할 때 유용하다.

C++ 힙 정렬 구현

/*
 * 8.5
 * Max Heap을 이용하여 내림차순 힙 정렬 구현
 */
#include <iostream>
using namespace std;

#define MAX_ELEMENT 200      // heap array size

struct Node{
private:
    int key;
public:
    Node(){
        key = 0;
    }
    Node(int _key){
        key = _key;
    }
    ~Node(){}

    // getter/setter
    int getKey(){
        return key;
    }
    void setKey(int _key){
        key = _key;
    }
};

class MaxHeap{
private:
    Node node[MAX_ELEMENT];
    int size;   // heap 요소 개수
public:
    MaxHeap(){
        size = 0;
    }
    ~MaxHeap(){}

    // search node
    Node& getParent(int index){
        return node[index/2];
    }
    Node& getLeftChild(int index){
        return node[index*2];
    }
    Node& getRightChild(int index){
        return node[index*2+1];
    }

    // 삽입
    void insert(int key){
        if(isFull()){
            cout << "Heap is Full" << endl;
            return;
        }

        int index = ++size;     // 힙트리 마지막 노드의 다음 위치에서 시작

        // 힙트리를 거슬러 올라가며 부모 노드와 비교
        while(index != 1 && key > getParent(index).getKey()){
            node[index] = getParent(index);
            index /= 2;
        }

        // 최종 위치에 데이터 삽입
        node[index].setKey(key);
    }

    // 삭제
    int remove(){
        if(isEmpty()){
            cout << "Heap is Empty" << endl;
            exit(EXIT_FAILURE);
        }

        Node itemNode = node[1];         // root node (삭제 대상)
        Node lastNode = node[size--];    // 힙트리의 마지막 노드
        int index = 1;                      // 마지막 노드의 index (root 부터 시작)

        // root 부터 내려가며 자식 노드와 비교
        while(index <= size){
            if(index*2 > size){             // leaf node인 경우 (자식 노드가 없는 경우)
                break;
            }else if(index*2 == size){      // 자식노드가 하나인 경우
                if(lastNode.getKey() < getLeftChild(index).getKey()){
                    node[index] = getLeftChild(index);
                    index *= 2;
                }else{
                    break;
                }
            }else{                          // 자식노드가 두개인 경우
                int leftChildKey = getLeftChild(index).getKey();
                int rightChildKey = getRightChild(index).getKey();

                // 둘 중 key가 더 큰 자식노드와 교환
                if(lastNode.getKey() < leftChildKey || lastNode.getKey() < rightChildKey){
                    node[index] = leftChildKey > rightChildKey ? getLeftChild(index) : getRightChild(index);
                    index = leftChildKey > rightChildKey ? index*2 : index*2+1;
                }else{
                    break;
                }
            }
        }
        node[index] = lastNode;     // 마지막 노드를 최종 위치에 저장
        return itemNode.getKey();  // 삭제 노드의 data 반환
    }

    bool isEmpty(){
        return size == 0;
    }
    bool isFull(){
        return size == MAX_ELEMENT - 1;
    }

};

// 힙 정렬
void heapSort(int a[], int n){
    MaxHeap heap;

    for(int i=0; i<n; i++){
        heap.insert(a[i]);
    }

    for(int i=0; i<n; i++){
        a[i] = heap.remove();
    }
}

int main(){
    int data[10];

    for(int i=0; i<10; i++){
        data[i] = rand() % 100;     // random data
    }

    cout << "origin data : ";
    for(int i=0; i<10; i++) cout << data[i] << " ";
    cout << endl;

    heapSort(data, sizeof(data)/sizeof(int));
    cout << "sorted data : ";
    for(int i=0; i<10; i++) cout << data[i] << " ";
    cout << endl;

    return 0;
}

오름차순 구현을 위해서는 Min Heap을 사용하고, 내림차순 구현을 위해서는 Max Heap을 사용하는 것이 편하다.

[자료구조] 이진탐색트리 (Binary Search Tree)

suyeon96 — Mon, 4 Jan 2021 02:30:02 +0900

1. 이진탐색트리

1.1 이진탐색트리란?

이진탐색트리(BST: Binary Search Tree)는 이진트리 기반의 탐색을 위한 자료구조이다.

이진탐색의 효율적인 탐색 능력을 가지며, 삽입과 삭제가 가능한 것이 특징이다.

1.2 이진탐색트리의 4가지 조건

모든 노드는 유일한 키를 갖는다.
왼쪽 서브트리의 키들은 루트의 키보다 작다.
오른쪽 서브트리의 키들은 루트의 키보다 작다.
왼쪽과 오른쪽 서브트리도 이진탐색트리이다.

1.3 이진탐색트리 특징

이진탐색트리를 순회할 때는 중위순회(In-order Traversal) 방법을 사용한다.
(왼쪽 서브트리 → 루트 → 오른쪽 서브트리 순서)

이진탐색트리를 중위 순회한 결과는 트리 내의 모든 값들을 오름차순으로 정렬한 결과를 나타낸다.

예를 들어 위 그림의 트리를 중위 순회한 결과는 다음과 같다.
→ 3 7 12 18 26 27 31

1.4 이진탐색트리 ADT

객체

이진탐색트리의 4가지 조건을 만족하는 이진트리

연산

search(key) : 키 값이 key인 노드를 찾아 반환
insert(n) : 이진탐색트리의 특성을 유지하며 노드 n 삽입
delete(n) : 이진탐색트리의 특성을 유지하며 노드 n 삭제

2. 이진탐색트리 연산

2.1 탐색

이진탐색트리에서 root 노드가 왼쪽 서브트리보다 크고 오른쪽 서브트리보다 작다는 점을 기억하자.

탐색 방법

찾고자하는 키와 현재 루트 노드의 키를 비교한다.
찾고자하는 키가 루트 노드의 키보다 작으면 왼쪽 자식 노드를 기준으로 다시 1번부터 시작한다.
찾고자하는 키가 루트 노드의 키보다 크면 오른쪽 자식 노드를 기준으로 다시 1번부터 시작한다.
찾고자하는 키와 루트 노드의 키가 같으면 탐색이 종료된다.

굉장히 easy한 방법이다.

위의 알고리즘을 구현하려고 보니 순환(Recursive)을 써도 되고, 반복(Iterative)을 사용해도 된다.

각각의 방법을 이용하여 한번 구현해보자.

a. 순환으로 탐색 구현

// 탐색 (순환)
Node<T>* searchRecur(Node<T>* node, T key){
    if(node == NULL) return NULL;

    if(key == node->getData()) return node;     // key == root 노드의 data
    else if(key < node->getData()) return searchRecur(node->getLeft(), key);    // key < root 노드의 data
    else if(key > node->getData()) return searchRecur(node->getRight(), key);   // key > root 노드의 data
}

b. 반복으로 탐색 구현

// 탐색 (반복)
Node<T>* searchIter(Node<T>* node, T key){
    while(node != NULL){
        if(key == node->getData()) return node;     // key == root 노드의 data
        else if(key < node->getData()) node = node->getLeft();   // key < root 노드의 data
        else if(key > node->getData()) node = node->getRight();  // key > root 노드의 data
    }
    return NULL;    // 탐색이 실패한 경우 NULL 반환
}

사실 효율성을 따지면 반복으로 구현한 탐색 함수가 훨씬 유리하다.

하지만 우리는 공부를 하는 단계이니 여러 방법으로 시도를 해봐야 도움이 될 것이다.

여기서 잠깐. 트리의 각 노드는 자신을 루트로 하는 이진트리가 될 수 있다.

그럼 Node 클래스에서 멤버 함수로 탐색을 구현해 보자.

c. Node 클래스에서 멤버함수로 순환 탐색 구현

template <typename T>
struct Node{
private:
    T data;
    Node* left;
    Node* right;
public:
    Node(T _data, Node* _left, Node* _right){
        data = _data;
        left = _left;
        right = _right;
    }
    ~Node(){}

    // Node 멤버함수로 순환탐색 구현 (ㅎㅎ)
    Node* search(T key){
        if(key == data)                         // key == 노드의 data
            return this;
        else if(key < data && left != NULL)     // key < 노드의 data
            return left->search(key);
        else if(key > data && right != NULL)    // key > 노드의 data
            return left->search(key);
        else                                    // 탐색이 실패한 경우
            return NULL;
    }

    ...

}

여러가지 방법으로 탐색 알고리즘을 구현해 보았다.

여기서 알 수 있듯이 이진탐색트리 탐색 연산의 시간복잡도는 트리의 높이가 h 일 때 O(h)가 된다.

2.2 삽입

이진탐색트리에 삽입을 하기 위해서는 이진탐색트리의 조건을 만족하는 위치를 찾아 새로운 노드를 추가해야 한다.

삽입 방법

추가하고자 하는 key로 탐색을 수행한다.
이진탐색트리에는 중복된 key가 있을 수 없으므로, 추가하고자 하는 key를 갖는 노드가 있다면 삽입이 불가능하다.
탐색에 실패한다면 실패한 위치가 바로 새로운 노드가 삽입 되는 위치가 된다.

왜 3번에서 탐색이 실패한 위치에 새로운 노드가 삽입되는 지는 탐색을 이해하였다면 충분히 이해했으리라고 생각한다.

순환을 이용하여 삽입 구현

// 삽입 (순환)
void insertRecur(Node<T>* node, T key){
    Node<T>* newNode = new Node<T>(key, nullptr, nullptr);  // 새로운 key를 가지는 node 생성

    if(key == node->getData()){         // 트리에 이미 key값을 가지는 node가 있는 경우
        return;
    }else if(key < node->getData()){    // key < root 노드의 data
        if(node->getLeft() == NULL){
            node->setLeft(newNode);
        }else{
            insertRecur(node->getLeft(), key);
        }
    }else if(key > node->getData()){    // key > root 노드의 data
        if(node->getRight() == NULL){
            node->setRight(newNode);
        }else{
            insertRecur(node->getRight(), key);
        }
    }
}

이진탐색트리 삽입 연산의 시간복잡도 또한 탐색 연산과 동일하게 트리의 높이가 h 일 때 O(h)가 된다.

물론 삽입이라는 계산이 한번 추가되지만, O(1) 수준이므로 무시한다.

2.3 삭제

이진탐색트리에서 삭제는 기존 노드를 삭제하면서 이진탐색트리의 조건을 만족시켜야 하므로, 탐색과 삽입 연산보다 조금 복잡하다.

삭제 시 발생할 수 있는 경우의 수는 3가지이다.

삭제하려는 노드가 leaf 노드인 경우
삭제하려는 노드가 왼쪽이나 오른쪽 자식노드 중 하나만 가지고 있는 경우
삭제하려는 노드가 두 개의 자식노드를 모두 가지고 있는 경우

첫 번째 "삭제하려는 노드가 leaf 노드인 경우" 해당 노드만 삭제하면 된다.

즉 부모노드를 찾아서 부모노드에서 해당 link를 null로 만들어 연결을 끊으면 되고, 동적으로 할당된 노드였을 경우 메모리 반납까지 해주면 된다.

두 번째 "삭제하려는 노드가 하나의 자식노드만 가지는 경우" 해당 노드의 부모노드와 자식노드를 연결해주면 된다.

LinkedList에서의 삭제를 생각하면 이해가 쉬울 것이다.

부모노드를 찾아서 부모노드에서 해당 link를 자식노드의 link로 연결시켜주면 된다.

역시나 마찬가지로 동적으로 할당된 노드였을 경우 삭제 노드를 먼저 반납해야 한다.

마지막으로 "삭제하려는 노드가 두개의 자식노드를 모두 가지는 경우" 조금 복잡하다.

그림을 보며천천히 생각해 보자.

18 노드를 삭제한다고 가정했을 때 노드가 삭제된 후 그 자리를 누가 채워야 할까?

그림에서 유추했듯이 정답은 왼쪽 서브트리에서 가장 큰 값 또는 오른쪽 서브트리에서 가장 작은 값이다.

이유는 단순하다.

그래야만 이진탐색트리의 조건을 만족하며 트리의 변동성을 최소화할 수 있기 때문이다.

이진탐색트리를 중위 순회하면, 우리가 알다시피 Left → Root → Right 순서로 순회한다.

Left는 왼쪽 서브트리에서 가장 오른쪽 아래의 node이며, Right는 오른쪽 서브트리에서 가장 왼쪽 아래의 node이다.

따라서 위 트리에서 삭제될 18 노드의 이전 노드는 12 노드이며, 이후 노드는 22 노드이다.

이들 중 하나를 삭제될 노드 자리에 채우면 삭제 이후 이진탐색트리의 형태가 유지되는 것이다.

삭제 구현

// 삭제
void remove(Node<T>* parentNode, Node<T>* deleteNode){
    // Case1. 삭제하려는 node가 leaf 노드인 경우
    if(deleteNode->isLeaf()){
        if(deleteNode == this->getRoot()){     // 삭제하려는 node가 root인 경우
            this->setRoot(nullptr);
        }else{
            if(parentNode->getLeft() == deleteNode){        // parent의 왼쪽 자식노드 삭제
                parentNode->setLeft(nullptr);
            }else if(parentNode->getRight() == deleteNode){ // parent의 오른쪽 자식노드 삭제
                parentNode->setRight(nullptr);
            }
        }
    }
    // Case2. 삭제하려는 node가 하나의 자식노드만 갖는 경우
    else if(deleteNode->getLeft() == NULL || deleteNode->getRight() == NULL){
        Node<T>* childNode = (deleteNode->getLeft() != NULL) ? deleteNode->getLeft() : deleteNode->getRight();  // 삭제할 node의 유일한 자식노드

        if(deleteNode == this->getRoot()){    // 삭제하려는 node가 root인 경우
            this->setRoot(childNode);
        }else{
            if(parentNode->getLeft() == deleteNode){        // parent의 왼쪽 자식노드에 childNode link
                parentNode->setLeft(childNode);
            }else if(parentNode->getRight() == deleteNode){ // parent의 오른쪽 자식노드 childNode link
                parentNode->setRight(childNode);
            }
        }
    }
    // Case3. 삭제하려는 node가 2개의 자식노드를 모두 갖는 경우
    else{
        // 삭제하려는 노드의 오른쪽 서브트리에서 가장 작은 노드를 탐색하는 과정
        Node<T>* succp = deleteNode;
        Node<T>* succ = deleteNode->getRight();
        while(succ->getLeft() != NULL){
            succp = succ;
            succ = succ->getLeft();
        }

        // 3-1. 후계자 노드의 부모와 후계자 노드의 자식 연결
        if(succp->getLeft() == succ){
            succp->setLeft(succ->getRight());
        }else{  // 후계자 노드가 삭제할 노드의 바로 오른쪽 자식인 경우
            succp->setRight(succ->getRight());
        }

        // 3-2. 삭제할 노드의 data를 후계자노드의 data로 대체
        deleteNode->setData(succ->getData());

        // 3-3. 삭제할 노드를 후계자노드로 변경 (후계자노드를 delete 하기 위해)
        deleteNode = succ;
    }

    delete deleteNode;  // memory 반납
}

트리의 높이가 h 이고 삭제 대상 노드의 레벨이 d 일 때 h-d 만큼의 비교 연산을 수행해야 한다.

복사 및 삭제 과정의 연산은 상수시간으로 무시하면, 이진탐색트리 삭제연산의 시간복잡도 또한 O(h)이다.

2.4 이진탐색트리 연산의 시간복잡도

위에서 알아본 것과 같이 이진탐색트리의 탐색, 삽입, 삭제 연산의 시간복잡도는 모두 O(h)이다.

h는 트리의 높이이며, 이전 글에서 아래와 같이 공부했었다.

❝ n개의 노드를 가지는 이진트리에서 최소 높이는 $h ≥ \lceil{log_2(n+1)}\rceil$ 이며, 최대 높이는 n이다. ❞

결과적으로 최악의 경우 (경사이진트리 모양) 이진탐색트리의 시간복잡도는 O(n)이다.

하지만 최선의 경우 (포화이진트리 모양) 이진탐색트리의 시간복잡도는 O(log₂n)이 된다.

2.5 C++ 이진탐색트리 구현 (전체 소스코드)

#include <iostream>
#include <queue>
using namespace std;

template <typename T>
struct Node{
private:
    T data;
    Node* left;
    Node* right;
public:
    Node(T _data, Node* _left, Node* _right){
        data = _data;
        left = _left;
        right = _right;
    }
    ~Node(){}

    // getter/setter
    T getData(){
        return data;
    }
    void setData(T _data){
        data = _data;
    }
    Node* getLeft(){
        return left;
    }
    void setLeft(Node* _left){
        left = _left;
    }
    Node* getRight(){
        return right;
    }
    void setRight(Node* _right){
        right = _right;
    }

    // is leaf node?
    bool isLeaf(){
        return left==nullptr && right==nullptr;
    }

    // Node 멤버함수로 순환탐색 구현 (ㅎㅎ)
    Node* search(T key){
        if(key == data)                         // key == 노드의 data
            return this;
        else if(key < data && left != NULL)     // key < 노드의 data
            return left->search(key);
        else if(key > data && right != NULL)    // key > 노드의 data
            return left->search(key);
        else                                    // 탐색이 실패한 경우
            return NULL;
    }
};

template <typename T>
class BinaryTree{
private:
    Node<T>* root;
public:
    BinaryTree(){
        root = nullptr;
    }
    ~BinaryTree(){}

    // set root node
    void setRoot(Node<T>* _root){
        root = _root;
    }
    // get root node
    Node<T>* getRoot(){
        return root;
    }

    // 전위 순회(Pre-order Traversal)
    void preorder(){
        cout << "Preorder  : [ ";
        preorder(root);
        cout << "]" << endl;
    }
    void preorder(Node<T>* node){
        if(node != NULL){
            cout << node->getData() << " ";
            preorder(node->getLeft());
            preorder(node->getRight());
        }
    }

    // 중위 순회(In-order Traversal)
    void inorder(){
        cout << "Inorder   : [ ";
        inorder(root);
        cout << "]" << endl;
    }
    void inorder(Node<T>* node){
        if(node != NULL){
            inorder(node->getLeft());
            cout << node->getData() << " ";
            inorder(node->getRight());
        }
    }

    // 후위 순회(Post-order Traversal)
    void postorder(){
        cout << "Postorder : [ ";
        postorder(root);
        cout << "]" << endl;
    }
    void postorder(Node<T>* node){
        if(node != NULL){
            postorder(node->getLeft());
            postorder(node->getRight());
            cout << node->getData() << " ";
        }
    }

    // 레벨 순회(Level-order Traversal)
    void levelorder(){
        cout << "Levelorder: [ ";
        if(!isEmpty()){
            queue<Node<T>*> q;
            q.push(root);
            while(!q.empty()){
                Node<T>* node = q.front();
                q.pop();
                if(node != NULL){
                    cout << node->getData() << " ";
                    q.push(node->getLeft());
                    q.push(node->getRight());
                }
            }
        }
        cout << "]" << endl;
    }

    // 전체 노드 개수 구하기
    int getCount(){
        return isEmpty() ? 0 : getCount(root);
    }
    int getCount(Node<T>* node){
        if(node == NULL) return 0;
        return 1 + getCount(node->getLeft()) + getCount(node->getRight());
    }

    // leaf 노드 개수 구하기
    int getLeafCount(){
        return isEmpty() ? 0 : getLeafCount(root);
    }
    int getLeafCount(Node<T>* node){
        if(node == NULL) return 0;
        if(node->isLeaf()) return 1;
        else return getLeafCount(node->getLeft()) + getLeafCount(node->getRight());
    }

    // 트리 높이 구하기
    int getHeight(){
        return isEmpty() ? 0 : getHeight(root);
    }
    int getHeight(Node<T>* node){
        if(node == NULL) return 0;
        int lHeight = getHeight(node->getLeft());   // 왼쪽 서브트리 높이 계산
        int rHeight = getHeight(node->getRight());  // 오른쪽 서브트리 높이 계산
        return (lHeight > rHeight) ? lHeight + 1 : rHeight + 1;
    }

    bool isEmpty(){
        return root == nullptr;
    }

};

// 이진탐색트리 (이진트리 상속)
template <typename T>
class BinarySearchTree : public BinaryTree<T>{
private:
    // 탐색 (순환)
    Node<T>* searchRecur(Node<T>* node, T key){
        if(node == NULL) return NULL;

        if(key == node->getData()) return node;     // key == root 노드의 data
        else if(key < node->getData()) return searchRecur(node->getLeft(), key);    // key < root 노드의 data
        else if(key > node->getData()) return searchRecur(node->getRight(), key);   // key > root 노드의 data
    }

    // 탐색 (반복)
    Node<T>* searchIter(Node<T>* node, T key){
        while(node != NULL){
            if(key == node->getData()) return node;     // key == root 노드의 data
            else if(key < node->getData()) node = node->getLeft();   // key < root 노드의 data
            else if(key > node->getData()) node = node->getRight();  // key > root 노드의 data
        }
        return NULL;    // 탐색이 실패한 경우 NULL 반환
    }

    // 삽입 (순환)
    void insertRecur(Node<T>* node, T key){
        Node<T>* newNode = new Node<T>(key, nullptr, nullptr);  // 새로운 key를 가지는 node 생성

        if(key == node->getData()){         // 트리에 이미 key값을 가지는 node가 있는 경우
            return;
        }else if(key < node->getData()){    // key < root 노드의 data
            if(node->getLeft() == NULL){
                node->setLeft(newNode);
            }else{
                insertRecur(node->getLeft(), key);
            }
        }else if(key > node->getData()){    // key > root 노드의 data
            if(node->getRight() == NULL){
                node->setRight(newNode);
            }else{
                insertRecur(node->getRight(), key);
            }
        }
    }

    // 삭제
    void remove(Node<T>* parentNode, Node<T>* deleteNode){
        // Case1. 삭제하려는 node가 leaf 노드인 경우
        if(deleteNode->isLeaf()){
            if(deleteNode == this->getRoot()){     // 삭제하려는 node가 root인 경우
                this->setRoot(nullptr);
            }else{
                if(parentNode->getLeft() == deleteNode){        // parent의 왼쪽 자식노드 삭제
                    parentNode->setLeft(nullptr);
                }else if(parentNode->getRight() == deleteNode){ // parent의 오른쪽 자식노드 삭제
                    parentNode->setRight(nullptr);
                }
            }
        }
        // Case2. 삭제하려는 node가 하나의 자식노드만 갖는 경우
        else if(deleteNode->getLeft() == NULL || deleteNode->getRight() == NULL){
            Node<T>* childNode = (deleteNode->getLeft() != NULL) ? deleteNode->getLeft() : deleteNode->getRight();  // 삭제할 node의 유일한 자식노드

            if(deleteNode == this->getRoot()){    // 삭제하려는 node가 root인 경우
                this->setRoot(childNode);
            }else{
                if(parentNode->getLeft() == deleteNode){        // parent의 왼쪽 자식노드에 childNode link
                    parentNode->setLeft(childNode);
                }else if(parentNode->getRight() == deleteNode){ // parent의 오른쪽 자식노드 childNode link
                    parentNode->setRight(childNode);
                }
            }
        }
        // Case3. 삭제하려는 node가 2개의 자식노드를 모두 갖는 경우
        else{
            // 삭제하려는 노드의 오른쪽 서브트리에서 가장 작은 노드를 탐색하는 과정
            Node<T>* succp = deleteNode;
            Node<T>* succ = deleteNode->getRight();
            while(succ->getLeft() != NULL){
                succp = succ;
                succ = succ->getLeft();
            }

            // 3-1. 후계자 노드의 부모와 후계자 노드의 자식 연결
            if(succp->getLeft() == succ){
                succp->setLeft(succ->getRight());
            }else{  // 후계자 노드가 삭제할 노드의 바로 오른쪽 자식인 경우
                succp->setRight(succ->getRight());
            }

            // 3-2. 삭제할 노드의 data를 후계자노드의 data로 대체
            deleteNode->setData(succ->getData());

            // 3-3. 삭제할 노드를 후계자노드로 변경 (후계자노드를 delete 하기 위해)
            deleteNode = succ;
        }

        delete deleteNode;  // memory 반납
    }

public:
    BinarySearchTree(){}
    ~BinarySearchTree(){}

    // 탐색
    Node<T>* search(T key){
        //return searchRecur(this->getRoot(), key);
        return searchIter(this->getRoot(), key);
    }

    // 삽입
    void insert(T key){
        if(this->isEmpty()){
            Node<T>* newNode = new Node<T>(key, nullptr, nullptr);  // 새로운 key를 가지는 node 생성
            this->setRoot(newNode);
        }else{
            insertRecur(this->getRoot(), key);
        }
    }

    // 삭제
    void remove(T key){
        if(this->isEmpty()){
            cout << "Tree is Empty" << endl;
            return;
        }

        // parentNode와 deleteNode를 찾는 과정
        Node<T>* parentNode = nullptr;          // 삭제하려는 node의 부모 node (최초 root의 부모노드는 없음)
        Node<T>* deleteNode = this->getRoot();    // 삭제하려는 node
        while(deleteNode != NULL && deleteNode->getData() != key){
            parentNode = deleteNode;
            deleteNode = (key < parentNode->getData()) ? parentNode->getLeft() : parentNode->getRight();
        }

        if(deleteNode == NULL){
            cout << "Key is not in Tree" << endl;
            return;
        }else{
            remove(parentNode, deleteNode);
        }

    }

};

int main(){
    BinarySearchTree<int> tree;

    // 10개 node 삽입
    tree.insert(35);
    tree.insert(18);
    tree.insert(7);
    tree.insert(26);
    tree.insert(12);
    tree.insert(3);
    tree.insert(68);
    tree.insert(22);
    tree.insert(30);
    tree.insert(99);

    // Calculate
    cout << "전체 노드개수 : " << tree.getCount() << endl;
    cout << "단말 노드개수 : " << tree.getLeafCount() << endl;
    cout << "이진트리 높이 : " << tree.getHeight() << endl;

    // Traversal
    tree.preorder();
    tree.inorder();
    tree.postorder();
    tree.levelorder();

    // 삭제
    cout << "==== 노드 3 삭제 ====" << endl;
    tree.remove(3);
    tree.levelorder();
    cout << "==== 노드 68 삭제 ====" << endl;
    tree.remove(68);
    tree.levelorder();
    cout << "==== 노드 18 삭제 ====" << endl;
    tree.remove(18);
    tree.levelorder();
    cout << "==== 노드 35 삭제 ====" << endl;
    tree.remove(35);
    tree.levelorder();

    // Last Calculate
    cout << "전체 노드개수 : " << tree.getCount() << endl;
    cout << "단말 노드개수 : " << tree.getLeafCount() << endl;
    cout << "이진트리 높이 : " << tree.getHeight() << endl;

    return 0;
}

[자료구조] 트리? + 이진 트리 (Binary Tree)

suyeon96 — Sun, 3 Jan 2021 18:45:32 +0900

1. 트리

1.1 트리란?

트리(Tree)란 계층적인 구조를 나타내는 자료구조이다.

이전에 다룬 스택(Stack)과 큐(Queue)와 같은 선형 구조와 달리 트리는 비선형 구조이며, 나무를 거꾸로 그린 형태이다.

1.2 트리 용어

노드(node): 트리를 구성하는 기본 원소
루트 노드(root node/root): 트리에서 부모가 없는 최상위 노드, 트리의 시작점
부모 노드(parent node): 루트 노드 방향으로 직접 연결된 노드
자식 노드(child node): 루트 노드 반대방향으로 직접 연결된 노드
형제 노드(siblings node): 같은 부모 노드를 갖는 노드들
리프 노드(leaf (node))/단말 노드(terminal node): 자식이 없는 노드
간선(edge): 노드간의 연결
레벨(level): 루트 노드(level=1)부터 노드까지 연결된 링크 수의 합
높이(height): 가장 긴 루트 경로의 길이
차수(degree): 각 노드의 자식의 개수
트리의 차수(degree of tree): 트리의 최대 차수 = max[deg1, deg2, ..., degn]
경로(path): 한 노드에서 다른 한 노드에 이르는 길 사이에 있는 노드들의 순서
길이(length): 출발 노드에서 도착 노드까지 거치는 노드의 개수
깊이(depth): 루트 경로의 길이
크기(size): 노드의 개수
너비(width): 가장 많은 노드를 갖고 있는 레벨의 크기

1.3 트리 구현의 문제점

만약 하나의 노드가 여러개의 자식노드를 가지는 불규칙한 트리의 경우 node를 구현하기가 상당히 복잡해진다.

이러한 이유로 실제로는 하나의 노드가 2개의 자식노드만 가지는 이진트리가 많이 사용된다.

2. 이진트리

2.1 이진트리란?

이진트리(Binary Tree)란 모든 노드의 차수가 최대 2인 형태의 트리이다.

서브트리는 공집합일 수 있으며 반드시 왼쪽 서브트리와 오른쪽 서브트리가 서로 구별되어야 한다.

2.2 이진트리 ADT

객체

노드와 간선의 집합
노드는 공집합이거나 공집합이 아닌 경우 루트노드와 왼쪽 서브트리, 오른쪽 서브트리로 구성됨
모든 서브트리도 이진트리임

연산

create() : 이진트리 생성
insertNode(n) : 이진트리에 노드 n 삽입
deleteNode(n) : 이진트리에서 노드 n 삭제
isEmpty() : 이진트리가 공백 상태인지 확인
getRoot() : 이진트리의 루프노드 반환
getCount() : 이진트리의 노드 개수 반환
getHeight() : 이진트리의 높이 반환
display() : 이진트리의 내용 출력

2.3 일반트리 → 이진트리 변환

그렇다면 자식노드의 개수가 2개 이상인 트리는 구현이 불가능한 것일까?

아니다. 대부분의 트리는 이진트리로 변환이 가능하다.

예를 들어 아래의 그림에서 왼쪽 트리는 오른쪽 이진트리로 변환이 가능하다.

이해가 되는가?

일반트리에서 첫 번째 자식노드를 이진트리에서는 왼쪽 서브트리에 위치시킨다.

나머지 형제노드는 이진트리에서 오른쪽 서브트리에 위치된다.

위와 같은 방법을 통해 이진트리로 변환하여 구현하면 보다 간단하게 구현이 가능하다.

2.4 이진트리 종류

포화 이진트리 (Full Binary Tree)

트리의 각 레벨에 노드가 완전히 채워져있는 이진트리를 뜻한다.

모든 leaf 노드는 같은 level에 있어야하며, 마지막 level의 노드의 개수는 최대가 되어야 한다.

완전 이진트리 (Complete Binary Tree)

마지막 level을 제외한 모든 level의 노드가 완전히 채워져 있으며, 마지막 level의 노드들은 왼쪽부터 순차적으로 채워져 있는 이진트리를 뜻한다.

2.5 이진트리의 성질

이진트리에서의 edge 개수

이진트리에서 루트 노드를 제외하고 모든 노드가 하나의 부모 노드를 가지고 있다.
∴ n개의 노드의 이진트리에서 간선(edge)의 개수는 n-1개이다.

같은 높이의 이진트리에서 노드의 최소·최대 개수

이진트리에서 하나의 레벨에는 최소한 하나의 노드가 존재해야 한다.
또한 하나의 노드는 최대 2개의 자식을 가질 수 있으므로 level $i$에서의 노드의 최대 개수는 $2^{i-1}$이다.
즉 높이가 h인 이진트리의 최대 노드 개수는이다.
∴ 높이가 h인 이진트리에서 최소 노드의 개수는 h개이며,최대 노드의 개수는 $\sum_{i=1}^{h}{2^{i-1}} = 2^h-1$ 개이다.

노드의 개수가 동일한 이진트리의 최소·최대 높이

하나의 레벨에서 최소한 하나의 노드는 있어야 하므로 최대 높이는 n을 넘을 수 없다.
또한 $n ≤ 2^h - 1$ 이므로 $h ≥ log_2(n+1)$ 이다. (h가 정수이므로 올림 처리를 해야 함)
∴ n개의 노드를 가지는 이진트리에서 최소 높이는 $h ≥ \lceil{log_2(n+1)}\rceil$ 이며, 최대 높이는 n이다.

2.6 이진트리 구현 (Array? Link?)

아래와 같이 배열을 이용해 이진트리를 구현할 수 있다.

특정한 상황에서 완전 이진트리 또는 포화 이진트리의 경우 배열을 이용하면 효과적으로 구현할 수 있다.

하지만 일반적으로 배열로 이진트리를 구현하는 경우 메모리 낭비가 심할뿐더러 배열에 크기에 따라 트리의 높이가 제한된다.

따라서 대부분의 경우 Link를 이용하여 이진트리를 구현한다.

Link를 이용하여 이진트리를 구현하는 방법은 LinkedList를 구현하는 방법과 유사하다.

각 노드는 data 속성과 2개의 Link 속성을 가진다.

여기서 Link 속성은 각각 왼쪽 서브트리와 오른쪽 서브트리의 노드 주소를 가리키는 2개의 포인터 변수를 뜻한다.

따라서 한 노드를 root 노드로 지정하면, 노드간의 Link를 통해 이진트리가 구성되는 것이다.

2.7 Link를 이용한 이진트리 구현 (C++)

#include <iostream>
using namespace std;

template <typename T>
struct Node{
private:
    T data;
    Node* left;
    Node* right;
public:
    Node(T _data, Node* _left, Node* _right){
        data = _data;
        left = _left;
        right = _right;
    }
    ~Node(){}

    // getter/setter
    T getData(){
        return data;
    }
    void setData(T _data){
        data = _data;
    }
    Node* getLeft(){
        return left;
    }
    void setLeft(Node* _left){
        left = _left;
    }
    Node* getRight(){
        return right;
    }
    void setRight(Node* _right){
        right = _right;
    }

    // is leaf node?
    bool isLeaf(){
        return left==nullptr && right==nullptr;
    }
};

template <typename T>
class BinaryTree{
private:
    Node<T>* root;
public:
    BinaryTree(){
        root = nullptr;
    }
    ~BinaryTree(){}

    void setRoot(Node<T>* _root){
        root = _root;
    }

    Node<T>* getRoot(){
        return root;
    }

    bool isEmpty(){
        return root == nullptr;
    }

};

int main(){
    BinaryTree<char> tree;

    // Create Node
    Node<char> *d = new Node<char>('D', nullptr, nullptr );
    Node<char> *e = new Node<char>('E', nullptr, nullptr );
    Node<char> *b = new Node<char>('B', d, e );
    Node<char> *f = new Node<char>('F', nullptr, nullptr );
    Node<char> *c = new Node<char>('C', f, nullptr );
    Node<char> *a = new Node<char>('A', b, c );

    // Create Tree
    tree.setRoot(a);

    return 0;
}

main() 에서 위 그림과 같은 이진트리를 생성하였다.

2.8 이진트리 순회

트리는 선형 구조의 자료구조가 아니기 때문에 노드들을 방문할 규칙을 선택해야 한다.

표준적인 방법에는 전위, 중위, 후위 순회 방법이 있으며 재귀호출을 통해 이를 구현한다.

대부분의 경우 위 3가지 방법으로 트리를 순회하며 문제를 해결할 수 있다.

하지만 이외의 경우 개발자는 각각의 상황에 맞게 트리를 순회하는 알고리즘을 작성하여 이용하면 된다. (레벨 순회 등)

전위 순회(Pre-order Traversal)

루트 → 왼쪽 서브트리 → 오른쪽 서브트리 순서로 방문하는 순회 방법

void preorder(Node<T>* node){
    if(node != NULL){
        cout << node->getData() << " ";
        preorder(node->getLeft());
        preorder(node->getRight());
    }
}

중위 순회(In-order Traversal)

왼쪽 서브트리 → 루트 → 오른쪽 서브트리 순서로 방문하는 순회 방법

void inorder(Node<T>* node){
    if(node != NULL){
        inorder(node->getLeft());
        cout << node->getData() << " ";
        inorder(node->getRight());
    }
}

후위 순회(Post-order Traversal)

왼쪽 서브트리 → 오른쪽 서브트리 → 루트 순서로 방문하는 순회 방법

void postorder(Node<T>* node){
    if(node != NULL){
        postorder(node->getLeft());
        postorder(node->getRight());
        cout << node->getData() << " ";
    }
}

레벨 순회(Level-order Traversal)

레벨 순서로 방문하는 순회 방법

너비 우선 순회(Breadth-First traversal)라고도 함

void levelorder(){
    cout << "Levelorder: [ ";
    if(!isEmpty()){
        queue<Node<T>*> q;
        q.push(root);
        while(!q.empty()){
            Node<T>* node = q.front();
            q.pop();
            if(node != NULL){
                cout << node->getData() << " ";
                q.push(node->getLeft());
                q.push(node->getRight());
            }
        }
    }
    cout << "]" << endl;
}

위에서 구현한 이진트리를 각각의 순회 방법으로 출력한 결과이다.

[자료구조] 순환 (Recursion) - 팩토리얼, 거듭제곱 계산, 피보나치 수열, 하노이의 탑, 영역 채색

suyeon96 — Sat, 2 Jan 2021 23:17:59 +0900

1. 순환

1.1 순환이란?

순환(Recursion)은 컴퓨터 과학에서 재귀라고도 하며 자신을 정의할 때 자기 자신을 재참조하는 방법을 뜻한다.

순환은 알고리즘을 해결하는데 사용되는 일종의 프로그래밍 기법이며, 트리 자료구조를 공부하기에 앞서 간단하게 알아보자.

1.2 반복 vs 순환

프로그래밍 언어에서 같은 일을 반복하기 위한 방법에는 반복(iteration)과 순환(recursion)이 있다.

반복이란 for나 while 등의 반복문을 사용하여 조건이 만족할 때까지 계속하여 반복시키는 방식이다.

순환은 위에서 말한대로 method가 자기 자신을 다시 호출하는 방식을 의미한다.

일반적으로 순환은 method 호출을 하게 되므로 반복에 비해 수행 속도가 떨어진다.

하지만, 필요한 경우 순환을 사용하면 반복을 사용하는 것보다 훨씬 간단하고 효율적으로 문제를 해결할 수 있다.

각각의 경우에 따라 상황에 맞게 반복과 순환 중 선택을 하면 된다.

2. 팩토리얼

2.1 팩토리얼의 정의

n! = n · (n-1) · (n-2) · (n-3) · ··· · 3 · 2 · 1

팩토리얼(Factorial)은 1에서부터 n까지의 범위에 있는 모든 정수를 곱하는 것을 의미한다.

예를들어 5! = 5 · 4 · 3 · 2 · 1 = 120이다.

양의 정수 n의 팩토리얼은 아래와 같이 정의할 수 있다.

위의 정의에서 n!을 정의하는데 다시 (n-1)!가 사용되었다.

이러한 구조가 순환 구조인 것이다.

이를 코드로 작성해보자.

2.2 팩토리얼 구현 (순환) `C++`

int factorial(int n){
    if(n==1) return 1;
    else return (n * factorial(n-1));
}

line3에서 위의 공식처럼 다시 자기 자신(factorial)을 호출하는 것을 볼 수 있다.

3!을 구하는 경우 factorial(3)은 아래와 같이 동작된다.

또한 순환 알고리즘에서는 반드시 순환 호출을 멈추는 조건이 필요하다.

팩토리얼 코드에서는 line2에서 n=1 일 때 순환을 멈추고 상수 1을 반환한다.

만약 순환호출을 멈추는 조건이 없다면, 시스템 오류가 발생할 때까지 자기자신을 무한히 호출하며 무한루프에 빠지게 될 것이다.

3. 거듭제곱 계산

xⁿ을 구하기 위해서는 일반적으로 x를 n번 반복적으로 더하는 방법을 사용한다.

하지만 순환을 이용해서 거듭제곱 계산을 할 수 도 있다.

xⁿ을 구하는 코드를 반복과 순환호출 방법으로 각각 구현하고 비교해보자.

3.1 거듭제곱 계산 구현 (반복)

double power(double x, int n){
    double r = 1.0;
    for(int i=0; i<n; i++){
        r = r*x;
    }
    return r;
}

n만큼 반복하며 x를 곱해가는 방식이다.

당연히 시간복잡도는 O(n)이다.

3.2 거듭제곱 계산 구현 (순환호출)

double power(double x, int n){
    if(n==0) return 1.0;
    else if ((n%2)==0)             // n이 짝수인 경우
        return power(x*x, n/2);
    else                           // n이 홀수인 경우
        return x * power(x*x, (n-1)/2);
}

n이 짝수인 경우 x²을 먼저 계산한 후 이 값을 n/2로 제곱한다.

n이 홀수인 경우 x²을 먼저 계산한 후 이 값을 (n-1)/2로 제곱하고 x를 한 번 더 곱해준다.

2¹⁰을 계산하는 경우 아래와 같이 동작한다.

한번 순환할 때마다 반복 횟수가 절반씩(n/2) 줄어드는 것을 알 수 있다.

이를 시간복잡도로 나타내면 O(log₂n)이다.

3.3 정리

반복을 사용하여 거듭제곱을 계산하는 것보다, 순환호출을 사용하여 거듭제곱을 계산하는 경우 시간복잡도 측면에서 더욱 효율적임을 알 수 있다.

반복 O(n) > 순환호출 O(log₂n)

4. 피보나치 수열 계산

4.1 피보나치 수열 정의

수학에서 피보나치 수(Fibonacci numbers)는 첫째 및 둘째 항이 1이며 그 뒤의 모든 항은 바로 앞 두 항의 합인 수열이다.

편의상 0번째 항을 0으로 두기도 한다.

피보나치 수 ${\displaystyle F_{n}}$을 정의하면 다음과 같다.

위 점화식을 보아하니 피보나치 수열 또한 순환호출을 이용하여 구현이 가능한 것을 알 수 있다.

이번에는 피보나치 수열을 구하는 코드를 반복과 순환호출 방법으로 각각 구현하고 비교해보자.

4.2 피보나치 수열 계산 구현 (반복)

int fibo(int n){
    if(n<2) return n;
    else{
        int tmp, current=1, last=0;
        for(int i=2; i<=n; i++){
            tmp = current;
            current += last;
            last = tmp;
        }
        return current;
    }
}

2~n만큼 반복하며 순차적으로 두 항의 수를 더해나가는 방법이다.

당연히 시간복잡도는 O(n)이다.

4.3 피보나치 수열 계산 구현 (순환호출)

int fibo(int n){
    if(n==0) return 0;
    if(n==1) return 1;
    else return (fibo(n-1) + fibo(n-2));
}

반복문을 이용하여 구현한 코드에 비해 단순하고 이해하기 쉽게 구현되었다.

하지만 실제로는 매우 비효율적이다.

예를들어 fibo(6)을 계산하는 경우 아래와 같이 동작한다.

fibo(6)를 호출하면 fibo(4)가 2번 호출된다. fibo(3)은 3번 호출되며 fibo(2)는 5번 호출된다.

fibo(6)을 구하기 위해 fibo() 함수가 총 25번이나 호출되었다.

순환 단계가 깊어질수록 이러한 현상은 더욱 심해진다.

이를 시간복잡도로 나타내면 O(2ⁿ)이다.

4.4 정리

피보나치 수열을 계산하는 경우 순환호출을 사용하는 것보다 반복으로 문제를 해결하는 것이 훨씬 효율적이다.

반복 O(n) < 순환호출 O(2ⁿ)

이렇듯 문제에 따라 반복 또는 순환호출 중 적절한 방법을 선택하여 사용해야 한다.

5. 하노이 탑

5.1 하노이 탑이란?

하노이의 탑(Tower of Hanoi)은 퍼즐의 일종이다. 세 개의 기둥과 이 기둥에 꽂을 수 있는 크기가 다양한 원판들이 있고, 퍼즐을 시작하기 전에는 한 기둥에 원판들이 작은 것이 위에 있도록 순서대로 쌓여 있다.

게임의 목적은 다음 조건을 만족시키면서, 한 기둥에 꽂힌 원판들을 그 순서 그대로 다른 기둥으로 옮겨서 다시 쌓는 것이다.

1. 한 번에 하나의 원판만 이동할 수 있다.
2. 맨 위에 있는 원판만 이동할 수 있다.
3. 큰 원판이 작은 원판 위에 있어서는 안 된다.
4. 중간의 막대를 임시적으로 이용할 수 있으나 앞의 조건들을 지켜야한다.

하노이의 탑 이동순서

5.2 하노이의 탑 구현

#include <iostream>
using namespace std;

void hanoi(int n, char from, char tmp, char to){
    if(n==1){
        cout << n << ": " << from << " -> " << to << endl;
    }else{
        hanoi(n-1, from, to, tmp);                          // A의 맨 밑을 제외한 나머지 원판들을 B로 옮김
        cout << n << ": " << from << " -> " << to << endl;  // A에 남은 한 개의 원판(맨 밑)을 C로 옮김
        hanoi(n-1, tmp, from, to);                          // B의 원판들을 C로 옮김
    }
}

int main(){
    hanoi(4, 'A', 'B', 'C');
    return 0;
}

6. 영역채색

6.1 영역채색이란?

영상처리 분야에서 영역 채색(Blob coloring) 또는 연결화소 분석법(Connected Component Labeling)이라 불리는 알고리즘은 BW 이미지에서 연결된 객체를 찾는 방법이다.

6.2 영역채색 구현

#include <iostream>
#include <vector>
using namespace std;

#define WIDTH 20
#define HEIGHT 9

// 근접 4방향 화소가 이어져있는지 판단하여 labeling
void labelComponent(unsigned int img[HEIGHT][WIDTH], int x, int y, int label){
    if(x<0 || y<0 || x>=WIDTH || y>=HEIGHT){    // 이미지 영역 밖인 경우 return
        return;
    }

    if (img[y][x] == 9){    // labeling 처리가 안된 black 픽셀인 경우
        img[y][x] = label;  // 해당 픽셀에 label값 부여

        // (4방향 연결) 좌,상,우,하 방향으로 순환호출
        labelComponent(img, x-1, y, label);
        labelComponent(img, x, y-1, label);
        labelComponent(img, x+1, y, label);
        labelComponent(img, x, y+1, label);
    }
}

// BW 이미지 영역채색
void blobColoring(unsigned int img[HEIGHT][WIDTH]){
    int label = 1;  // label 초기화

    // [0,0] 화소부터 모든 화소에 대해 차례대로 loop 돌면서 labeling 처리가 안된 화소인 경우 labelComponent() 호출
    for(int y=0; y<HEIGHT; y++){
        for(int x=0; x<WIDTH; x++){
            if(img[y][x] == 9){
                labelComponent(img, x, y, label++);
            }
        }
    }
}

// 이미지 출력
void printImage(unsigned int img[HEIGHT][WIDTH]){
    for(int y=0; y<HEIGHT; y++){
        for(int x=0; x<WIDTH; x++){
            if(img[y][x] == 0){
                cout << ".";
            }else{
                cout << img[y][x];
            }
        }
        cout << endl;
    }
    cout << endl;
}

int main(){
    unsigned int image[HEIGHT][WIDTH] = {0,0,0,0,0,0,9,0,0,0,0,9,9,9,9,9,0,0,9,9,
                                         9,9,9,9,9,0,9,0,0,0,0,0,0,0,0,9,0,0,9,9,
                                         0,0,9,0,0,0,9,0,0,0,0,9,9,9,9,9,0,0,9,9,
                                         0,9,9,9,0,0,9,9,9,0,0,9,0,0,0,0,0,0,9,9,
                                         0,9,0,9,0,0,9,0,0,0,0,9,9,9,9,9,0,0,9,9,
                                         9,9,0,9,9,0,9,0,0,0,0,0,0,0,0,0,0,0,9,9,
                                         9,0,0,0,9,0,9,0,0,0,0,0,9,0,9,0,0,0,0,0,
                                         9,0,0,0,9,0,9,0,0,0,0,0,9,0,9,0,0,0,9,9,
                                         0,0,0,0,0,0,9,0,0,0,0,9,9,9,9,9,0,0,9,9};

    cout << "<Original Image>" << endl;
    printImage(image);
    cout << "<Labelled Image>" << endl;
    blobColoring(image);
    printImage(image);

    return 0;
}

이미지의 [0,0] 위치에서부터 차례대로 loop를 돌며 labeling 되지않은 검은색 pixel(9)을 마주치면 labelComponent(x, y)를 호출한다.

labelComponent(x, y)에서는 (x, y) 픽셀이 labeling 되지않은 검은색 pixel(9)이면 label값을 부여하고 인접한 4방향의 픽셀값으로 labelComponent(x, y)를 순환호출한다.

따라서 하나의 component를 만나는 경우 해당 component의 pixel은 전부 라벨링이 되는 것이다.

[자료구조] 리스트 (ArrayList vs LinkedList)

suyeon96 — Sat, 2 Jan 2021 22:39:55 +0900

1. 리스트

1.1 리스트란?

리스트(List)란 앞에서 공부한 배열, 스택, 큐 등과 같은 선형 자료구조이다.

그렇다면 이들과 리스트의 차이점은 무엇일까?

스택과 큐의 경우 자료의 접근이 전단(front) 혹은 후단(rear)에 제한되어 있다.

하지만 리스트는 이러한 제한이 없다. 즉, 임의의 위치에 있는 항목에 접근이나 연산이 가능하다는 것이다.

1.2 배열 vs 리스트

배열(array) 또한 임의의 위치에 접근이 가능하다.

그렇다면 배열과 리스트의 차이는 무엇일까?

배열은 각각의 원소에 순서대로 index가 할당되어 있다.

위 배열에서 c 원소를 삭제하는 경우 아래와 같은 형태가 된다.

삭제한 c의 메모리 공간은 빈 공간으로 남아있으며, d와 e의 index는 변함이 없다.

만약 위의 행위가 리스트로 구현이 된다면 아래와 같은 형태가 된다.

더 이상 리스트에 c의 메모리 공간 자체가 존재하지 않는다.

덕분에 데이터 밀도가 촘촘해졌으며, 메모리 공간을 효율적으로 사용할 수 있게 되었다.

하지만 c 뒤에 위치하고 있었던 d와 e의 index가 변경되었다.

즉, 리스트에서는 index를 식별자로 사용할 수 없다.

위의 예제에서 봤듯이 리스트에서는 index가 중요하지 않다.

리스트에서 중요한 것은 원소들 간의 순서이다.

따라서 리스트를 다른 말로 시퀀스(sequence)라고도 한다.

수학에서의 유한수열(finite sequence)과 같은 개념이라고 생각하면 된다.

1.3 리스트 ADT

객체

임의의 위치에 접근이 가능한 동일한 자료형 요소들의 순서 있는 모음

연산

insert(i, x) : i 위치에 새로운 요소 x 삽입
delete(i) : i 위치의 요소를 삭제하고 반환
getEntry(i) : i 위치의 요소를 반환
find(x) : 리스트에 요소 x가 있는지 확인
replace(i, x) : i 위치에 있는 요소를 x로 변경
isEmpty() : 리스트가 비어있으면 true 아니면 false 반환
isFull() : 리스트가 가득 차 있으면 true 아니면 false 반환
size() : 리스트 내의 모든 요소 개수를 반환
display() : 리스트 내의 모든 요소 출력

2. ArrayList

2.1 ArrayList란?

ArrayList는 배열을 이용하여 리스트를 구현한 것이다.

ArrayList를 구현하기 위해서는 크기가 정해진 1차원 배열이 필요하다.

이 배열에 리스트에 요소들이 순서대로 저장되는 것이다.

또한 배열 내에서 리스트의 범위를 알기 위해, 리스트에 저장된 요소의 개수를 나타내는 변수 length가 필요하다.

2.2 ArrayList 구현 (C++)

#include <iostream>
using namespace std;

#define MAX_LIST_SIZE 100

template <typename T>
class ArrayList {
private:
    T data[MAX_LIST_SIZE];
    int length;

public:
    ArrayList(){
        length = 0;
    }
    ~ArrayList(){}

    // [삽입] list의 idx번째에 요소 x 추가
    void insert(int idx, T x){
        if(isFull()){
            cout << "List full error" << endl;
            return;
        }
        if(idx<0 || idx>length){
            cout << "insert index error" << endl;
            return;
        }

        for(int i=length; i>idx; i--){  // idx 뒤의 요소들을 한칸씩 뒤로 이동
            data[i] = data[i-1];
        }
        data[idx] = x;  // idx번째에 x 대입

        length++;
    }

    // [삭제] idx번째 요소를 리스트에서 제거 후 반환
    T remove(int idx){
        if(isEmpty()){
            cout << "List empty error" << endl;
            exit(EXIT_FAILURE);
        }
        if(idx<0 || idx>length){
            cout << "remove index error" << endl;
            exit(EXIT_FAILURE);
        }

        T x = data[idx];                    // 삭제될 요소
        for(int i=idx+1; i<length; i++){    // idx 뒤의 요소들을 한칸씩 앞으로 이동
            data[i-1] = data[i];
        }

        length--;
        return x;
    }

    // idx번째 항목 반환
    T getEntry(int idx){
        return data[idx];
    }

    // 요소 x가 리스트에 있는지 확인
    bool find(T x){
        for(int i=0; i<length; i++){
            if(data[i] == x){
                return true;
            }
        }
        return false;
    }

    // idx번째 요소를 x로 변경
    void replace(int idx, T x){
        data[idx] = x;
    }

    // List size 반환
    int size(){
        return length;
    }

    // List 출력
    void display() {
        cout << "List : ";
        for(int i=0; i<size(); i++){
            cout << "[" << data[i] << "]";
        }
        cout << endl;
    }

    bool isEmpty(){
        return length == 0;
    }
    bool isFull(){
        return length == MAX_LIST_SIZE;
    }
};

int main(){
    ArrayList<char> list;

    cout << "===== insert list x5 =====" << endl;
    list.insert(0, 'a');
    list.insert(1, 'b');
    list.insert(2, 'c');
    list.insert(list.size(), 'd');  // list 마지막에 'd' 삽입
    list.insert(4, 'e');
    cout << "size : " << list.size() << endl;
    list.display();

    cout << "===== remove index3 =====" << endl;
    list.remove(3); // 3번째 요소 삭제
    cout << "size : " << list.size() << endl;
    list.display();

    cout << "===== insert 'f' at index1 =====" << endl;
    list.insert(1, 'f');
    cout << "size : " << list.size() << endl;
    list.display();

    cout << "===== replace 'g' at index0 =====" << endl;
    list.replace(0, 'g');
    list.display();

    return 0;
}

2.3 [번외] Java에서의 ArrayList (java.util.ArrayList)

ArrayList는 Java에서 가장 많이 사용되는 자료구조 중 하나이다.

Java에서 기본적으로 제공하는 ArrayList에 대해 알아보자.

import java.util.ArrayList;
ArrayList<Integer> lists = new ArrayList<>();

ArrayList 사용 예시

lists.add(10);
lists.add(20);
lists.add(1, 40);  // 1번째에 40 추가

lists.remove(1);   // 리스트의 1번째 요소 삭제

lists.get(0);      // 리스트의 0번째 요소 반환

ArrayList를 사용함에도 최대 배열 size를 지정하지 않았다.

왜 그럴까?

Java의 ArrayList는 내부적으로 배열의 크기가 고정되어 설정된다.

만약 배열이 가득 찼음에도 새로운 데이터가 추가된다면, 기존의 배열보다 1.5배 긴 새로운 배열을 만들어 기존 리스트 데이터를 새로운 배열로 복제한다.

하지만 이러한 경우 당연히 시간이 오래 걸리기 때문에 프로그래머는 이를 고려하여 ArrayList를 사용해야 한다.

3. Linked List

3.1 Linked List란?

Linked List는 Node 간의 연결(Link)을 이용하여 동적으로 크기를 할당할 수 있는 선형 자료구조이다.

Node는 데이터와 포인터를 가지고 있으며 각 Node의 포인터는 다음 Node 또는 이전 Node와의 연결을 담당한다.

3.2 Linked List 구조

각각의 Node는 data와 link 변수를 가진다.

data 변수에는 Linked List에서 사용할 자료형의 데이터가 들어가고, link 변수에는 다음 Node의 메모리 주소값이 들어간다.

head pointer란 첫 번째 Node의 주소를 가리키는 변수를 뜻한다.

3.3 ArrayList vs LinkedList

ArrayList와 LinkedList의 차이점을 알아보자.

3.4 Linked List 종류

Singly Linked List (단일 연결 리스트)

Singly Linked List는 각 노드에 data와 한 개의 포인터 변수가 있고, 각 노드의 포인터는 다음 노드를 가리킨다.

Circular Linked List (원형 연결 리스트)

Circular Linked List는 Singly Linked List와 동일하지만 마지막 노드의 포인터가 처음 노드를 가리킨다.

우리가 앞에서 다뤘던 Circular Queue처럼 원형 구조의 리스트가 된다.

Doubly Linked List (이중 연결 리스트)

Doubly Linked List 또한 Singly Linked List와 비슷하지만, 각 노드에 2개의 포인터 변수가 있다.

각각의 포인터는 이전 노드와 다음 노드를 가리킨다.

3.5 head pointer를 사용하여 LinkedList 구현 (C++)

Singly Linkedlist를 구현해보자.

LinkedList의 head를 표현하기 위해 head pointer 개념을 사용한다. (자세한 내용은 뒤에서...)

#include <iostream>
using namespace std;

// Node
template <typename T>
struct Node {
private:
    T data;
    Node<T>* next = nullptr;
public:
    Node(T d, Node<T>* pNode){
        data = d;
        next = pNode;
    }
    ~Node(){}
    Node<T>* getNext() {
        return next;
    }
    void setNext(Node<T>* pNode){
        next = pNode;
    }
    T getData(){
        return data;
    }
};

template <typename T>
class SinglyLinkedList {
private:
    Node<T>* head;  // head pointer
    int size = 0;

public:
    SinglyLinkedList(){
        head = nullptr;
    }
    ~SinglyLinkedList(){}

    // list 마지막에 data 삽입
    void insert(T data){
        Node<T>* node = new Node<T>(data, nullptr);

        if(isEmpty()){      // 비어있는 경우 head에 node 추가
            head = node;
        }else{              // 아닌 경우 마지막 node를 찾아서 해당 node의 next에 새로운 node를 연결
            Node<T>* prevNode = head;
            for(int i=0; i<size-1; i++) {
                prevNode = prevNode->getNext();
            }
            prevNode->setNext(node);
        }

        size++;
    }

    // list의 idx번째에 data 삽입
    void insert(T data, int idx){
        if(idx < 0 || idx > size){
            cout << "index error" << endl;
            return;
        }

        Node<T>* node = new Node<T>(data, nullptr);

        if(idx==0){     // 0번째 index에 추가하는 경우
            node->setNext(head);        // 새로운 node의 next에 기존 head node를 연결 (비어있는 경우 nullptr로 들어감)
            head = node;                // 0번째 index가 바꼈기 때문에 head를 바꾸어줌
        }else{          // 아닌경우
            Node<T>* prevNode = head;
            for(int i=0; i<idx-1; i++) {
                prevNode = prevNode->getNext();     // index-1번째 node를 찾은 후
            }
            node->setNext(prevNode->getNext());     // 새로운 node의 next에 이전 node의 next를 대입.
            prevNode->setNext(node);                // 이전 node의 next에는 새로운 node를 연결
        }

        size++;
    }

    // idx번째 요소 삭제
    void remove(int idx){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            return;
        }
        if(idx < 0 || idx > size){
            cout << "index error" << endl;
            return;
        }

        if(idx==0){     // 0번째 index를 지우는 경우 head를 다음노드로 바꿔줌
            Node<T>* tmpNode = head;
            head = tmpNode->getNext();
            delete tmpNode;
        }else{          // 아닌경우
            Node<T>* prevNode = head;
            for(int i=0; i<idx-1; i++) {
                prevNode = prevNode->getNext();     // index-1번째 node를 찾은 후
            }
            Node<T>* tmpNode = prevNode->getNext();
            prevNode->setNext(tmpNode->getNext());  // 해당 node의 next를 삭제할 node의 next로 바꿔줌
            delete tmpNode;
        }

        size--;
    }

    // list 출력
    void display(){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            return;
        }

        Node<T>* tmpNode = head;
        while(tmpNode){
            cout << "[" << tmpNode->getData() << "]";
            tmpNode = tmpNode->getNext();
        }
        cout << endl;
    }

    bool isEmpty(){
        return size==0 ? true : false;
    }
};

int main(){
    SinglyLinkedList<char> list;

    cout << "===== insert x3 =====" << endl;
    list.insert('a');
    list.insert('b');
    list.insert('c');
    list.insert('d', 2);   // insert 'd' at index2
    list.display();

    cout << "===== remove index1 =====" << endl;
    list.remove(1);
    list.display();

    return 0;
}

3.6 head node를 사용하여 LinkedList 구현 (C++)

이번엔 head node 개념을 사용해서 구현해보자. (역시나 자세한 내용은 뒤에서...)

#include <iostream>
using namespace std;

// Node
template <typename T>
struct Node {
private:
    T data;
    Node<T>* next = nullptr;
public:
    Node(){
        data = T();
        next = nullptr;
    }
    Node(T d, Node<T>* pNode){
        data = d;
        next = pNode;
    }
    ~Node(){}

    Node<T>* getNext() {
        return next;
    }
    void setNext(Node<T>* pNode){
        next = pNode;
    }
    T getData(){
        return data;
    }
};

template <typename T>
class SinglyLinkedList {
private:
    Node<T> org;  // head node

public:
    SinglyLinkedList(){}
    ~SinglyLinkedList(){}

    // first node 반환 (list의 head pointer)
    Node<T>* getHead(){
        return org.getNext();
    }

    // idx번째 항목 반환
    Node<T>* getEntry(int idx){
        if(idx<-1 || idx>size()){
            cout << "index error" << endl;
            exit(EXIT_FAILURE);
        }

        Node<T>* node = &org;

        // head node부터 idx번 반복해서 next node를 찾아감
        for(int i=-1; i<idx; i++){
            node = node->getNext();
        }
        return node;
    }

    // list의 idx번째에 data 삽입
    void insert(int idx, T data){
        Node<T>* prev = getEntry(idx-1);                // idx번째 node의 이전 node

        Node<T>* node = new Node<T>(data, prev->getNext()); // 새로운 node의 next에 prev의 next를 대입
        prev->setNext(node);                                // prev의 next에는 새로운 node의 주소 대입
    }

    // list의 idx번째 요소 삭제 및 반환
    T remove(int idx){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            exit(EXIT_FAILURE);
        }
        Node<T>* node = getEntry(idx);          // 삭제할 node
        T data = node->getData();               // 삭제할 node의 data

        Node<T>* prev = getEntry(idx-1);    // idx번째 node의 이전 node
        prev->setNext(node->getNext());         // prev의 next에 삭제할 node의 next 대입
        delete node;

        return data;
    }

    // list의 idx번째 요소를 data로 변경
    void replace(int idx, T data){
        Node<T>* prev = getEntry(idx-1);    // 삭제될 node의 이전 node

        Node<T>* node = new Node<T>(data, prev->getNext()->getNext());  // 새로운 node
        delete prev->getNext();
        prev->setNext(node);
    }

    // list 출력
    void display(){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            return;
        }

        for(Node<T> *p = getHead(); p != nullptr; p=p->getNext()){
            cout << "[" << p->getData() << "]";
        }
        cout << endl;
    }

    int size(){
        int cnt = 0;
        for(Node<T> *p = getHead(); p != nullptr; p=p->getNext()){
            cnt++;
        }
        return cnt;
    }

    bool isEmpty(){
        return size()==0 ? true : false;
    }

    void clear(){
        while(!isEmpty()){
            remove(0);
        }
    }
};

int main(){
//    SinglyLinkedList<char> list;
//
//    cout << "===== insert x3 =====" << endl;
//    list.insert(0, 'a');
//    list.insert(1, 'b');
//    list.insert(2, 'c');
//    list.display();
//
//    cout << "===== insert 'd' at index2 =====" << endl;
//    list.insert(2, 'd');
//    list.display();
//
//    cout << "===== remove index1 =====" << endl;
//    list.remove(1);
//    list.display();

    SinglyLinkedList<int> list;
    list.insert(0, 10);
    list.insert(0, 20);
    list.insert(1, 30);
    list.insert(list.size(), 40);
    list.insert(2, 50);
    list.display();
    list.remove(2);
    list.remove(list.size()-1);
    list.remove(0);
    list.replace(1, 90);
    list.display();
    list.clear();
    list.display();

    return 0;
}

3.7 head pointer vs head node

LinkedList에서는 첫 번째 node의 주소를 관리하기 위해 head pointer를 사용한다.

하지만 head node를 사용하여 첫 번째 node를 가리킬 수도 있다.

head pointer

Class LinkedList{
    Node* head;
    ...

head node

Class LinkedList{
    Node org;    // 실제 head point는 "org.link"
    ...

head pointer를 사용하는 경우 첫 번째 node인지 구별하여 첫번째 node에서 삽입, 삭제가 이뤄지는 경우 따로 처리를 해주어야 한다.

// list의 idx번째에 data 삽입
void insert(int idx, T data){
    Node<T>* node = new Node<T>(data, nullptr);

    if(idx==0){     // 0번째 index에 추가하는 경우
        node->setNext(head);
        head = node;
    }else{          // 아닌경우
        Node<T>* prevNode = head;
        for(int i=0; i<idx-1; i++) {
            prevNode = prevNode->getNext();
        }
        node->setNext(prevNode->getNext());
        prevNode->setNext(node);
    }
}

head node를 사용하면 실제 head 앞에 임의의 empty node가 있어 항상 동일한 logic으로 구현할 수 있다. → 삽입과 삭제 용이

// list의 idx번째에 data 삽입
void insert(int idx, T data){
    Node<T>* prev = getEntry(idx-1);                // idx번째 node의 이전 node

    Node<T>* node = new Node<T>(data, prev->getNext()); // 새로운 node의 next에 prev의 next를 대입
    prev->setNext(node);                                // prev의 next에는 새로운 node의 주소 대입
}

head pointer를 사용한 code와 비교했을 때 확실히 간단해진 것을 볼 수 있다.

3.8 Circular Linked List

위에서 설명했듯이 Circular Linked List는 마지막 Node의 link가 첫 번째 Node를 가리키는 원형 구조의 리스트이다.

이러한 구조에서 가장 마지막 Node tail에 쉽게 접근하기 위해 head pointer가 tail Node를 가리키게 된다.

즉, 개념적으로 head pointer가 가리키는 Node가 tail Node이며, tail Node의 다음 Node가 head Node인 것이다.

3.9 Doubly Linked List

이중연결리스트 또한 위에서 설명했을뿐더러 이전에 deque를 구현해 보았으니, 바로 C++로 구현해보자.

#include <iostream>
using namespace std;

// Node
template <typename T>
struct Node {
private:
    T data;
    Node<T>* prev;
    Node<T>* next;
public:
    Node(){
        data = T();
        prev = nullptr;
        next = nullptr;
    }
    Node(T d, Node<T>* prevNode, Node<T>* nextNode){
        data = d;
        prev = prevNode;
        next = nextNode;
    }
    ~Node(){}

    Node<T>* getPrev() {
        return prev;
    }
    void setPrev(Node<T>* pNode){
        prev = pNode;
    }
    Node<T>* getNext() {
        return next;
    }
    void setNext(Node<T>* pNode){
        next = pNode;
    }
    T getData(){
        return data;
    }
};

template <typename T>
class DoublyLinkedList {
private:
    Node<T> org;  // head node

public:
    DoublyLinkedList(){}
    ~DoublyLinkedList(){}

    // first node 반환 (list의 head pointer)
    Node<T>* getHead(){
        return org.getNext();
    }

    // idx번째 항목 반환
    Node<T>* getEntry(int idx){
        if(idx<-1 || idx>size()){
            cout << "index error" << endl;
            exit(EXIT_FAILURE);
        }

        Node<T>* node = &org;

        // head node부터 idx번 반복해서 next node를 찾아감
        for(int i=-1; i<idx; i++){
            node = node->getNext();
        }
        return node;
    }

    // list의 idx번째에 data 삽입
    void insert(int idx, T data){
        Node<T>* prev = getEntry(idx-1);                        // idx번째 node의 이전 node

        Node<T>* node = new Node<T>(data, prev, prev->getNext());   // 새로운 node의 prev에는 prev, next에는 prev->next 대입
        prev->setNext(node);                                        // prev의 next에는 새로운 node 대입
        if(node->getNext() != nullptr){                             // node의 next가 null이 아닌 경우 next->prev에 새로운 node 대입
            node->getNext()->setPrev(node);
        }
    }

    // list의 idx번째 요소 삭제 및 반환
    T remove(int idx){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            exit(EXIT_FAILURE);
        }
        Node<T>* node = getEntry(idx);          // 삭제할 node
        T data = node->getData();               // 삭제할 node의 data

        Node<T>* prev = getEntry(idx-1);    // idx번째 node의 이전 node
        prev->setNext(node->getNext());         // prev의 next에 삭제할 node의 next 대입
        if(node->getNext() != nullptr){         // node의 next가 null이 아닌 경우 next->prev에 삭제할 node의 prev 대입
            node->getNext()->setPrev(prev);
        }
        delete node;

        return data;
    }

    // list의 idx번째 요소를 data로 변경
    void replace(int idx, T data){
        Node<T>* prev = getEntry(idx-1);    // 삭제될 node의 이전 node

        Node<T>* node = new Node<T>(data, prev, prev->getNext()->getNext());  // 새로운 node
        delete prev->getNext();
        prev->setNext(node);
        if(node->getNext() != nullptr){
            node->getNext()->setPrev(node);
        }
    }

    // list 출력
    void display(){
        if(isEmpty()){
            cout << "List is Empty" << endl;
            return;
        }

        for(Node<T> *p = getHead(); p != nullptr; p=p->getNext()){
            cout << "[" << p->getData() << "]";
        }
        cout << endl;
    }

    int size(){
        int cnt = 0;
        for(Node<T> *p = getHead(); p != nullptr; p=p->getNext()){
            cnt++;
        }
        return cnt;
    }

    bool isEmpty(){
        return size()==0 ? true : false;
    }

    void clear(){
        while(!isEmpty()){
            remove(0);
        }
    }
};

int main(){
    DoublyLinkedList<int> list;

    list.insert(0, 10);
    list.insert(0, 20);
    list.insert(1, 30);
    list.insert(list.size(), 40);
    list.insert(2, 50);
    list.display();
    list.remove(2);
    list.remove(list.size()-1);
    list.remove(0);
    list.replace(1, 90);
    list.display();
    list.clear();
    list.display();

    return 0;
}

[C++] 메모리 정적 할당 vs 동적 할당 (Stack vs Heap)

suyeon96 — Fri, 1 Jan 2021 02:21:32 +0900

이전 글 : [C++] 포인터 한방에 이해하기 (Call by Value vs Call by Reference)

Memory 영역 (Stack vs Heap)

컴퓨터에서 메모리 영역은 아래와 같이 나뉘어있다.

Code : 실행한 프로그램의 코드가 저장됨
Data : 전역변수와 static변수가 저장되며 프로그램 종료 시까지 사라지지 않고 남아있음
Heap : 동적으로 할당된 메모리영역이며 프로그래머에 의해 할당( C++ : new, C : malloc ) 및 해제( C++ : delete, C : free )됨
Stack : 지역변수와 매개변수가 할당되고 함수를 빠져나가면 자동 소멸됨

정적 메모리 할당 vs 동적 메모리 할당

프로그래밍 관점에서 메모리 영역에는 크게 stack과 heap 메모리 공간이 있다.

정적으로 메모리를 할당하면 컴파일 시 stack 영역에 할당되며, 함수를 빠져나갈 때 소멸된다.

프로그램 컴파일 시 stack에 얼마만큼의 크기로 할당을 해야하는지 결정되기 때문에, 컴파일 이후 크기가 변경될 수 없다.

따라서 정적 배열 선언 시 크기를 가변적으로 명시하면 문제가 될 수 있으므로 반드시 상수로 명시해야 한다.

int main() {
    int n = 10;
    int arr[n];    // 불가능
    int arr[10];   // 가능
}

반면 동적으로 메모리를 할당하는 경우 데이터가 heap 영역에 할당된다.

위에서 다루었듯이 heap은 프로그래머에 의해 할당(new)되거나 소멸(delete)된다.

따라서 프로그래머가 원할 때 원하는 크기로 할당할 수 있는 것이다.

참고로 포인터 변수는 stack에 할당된다.

int main() {
    int n = 10;
    int* arr = new int[n];    // arr 포인터 변수는 stack에 할당되며, arr 배열은 heap에 할당됨
}

new & delete

위에서 했던 이야기지만, 정적 메모리는 Compile 시에 stack 영역에 할당되고 함수를 빠져나올 때 소멸된다.

반면 동적 메모리는 Runtime 시 프로그래머의 의도대로 heap 영역에 할당되고 소멸된다.

따라서 동적 메모리를 control 하기 위해 규칙을 정해놓았으며, C++에서는 할당 시 new 연산자를 사용하며 소멸 시엔 delete 연산자를 사용한다.

heap 영역에 동적 할당되는 메모리의 경우 전적으로 프로그래머에 의해 관리되므로, 사용이 끝난다면 반드시 delete를 해주어야 한다.

참고로 동적 배열을 delete 하는 경우 배열이라는 것을 명시하기 위해 delete[] 연산자를 사용해야만 한다.

// 할당
int *pData = new int;
int *array = new int[size];

// 소멸
delete pData;
delete[] array;

2차원 배열의 동적 할당

2차원 배열을 동적할당 하는 경우 아래와 같은 구조를 가진다.

mat : int**형
mat[i] : int*형
mat[i][j] : int형

2차원 동적 배열은 단순하게 한 줄로 선언하기 힘들고 loop를 돌며 일일이 할당 및 해제를 해줘야 한다.

#include <iostream>
using namespace std;

// int형 2차원 배열 동적 할당
int** alloc2DArr (int rows, int cols){
    if(rows <= 0 || cols <= 0) return NULL;
    int** mat = new int* [rows];
    for (int i=0 ; i<rows ; i++ )
        mat[i] = new int[cols];
    return mat;
}

// int형 2차원 배열 동적 해제
void free2DArr ( int** mat, int rows, int cols=0){
    if(mat != NULL){
        for(int i=0 ; i<rows ; i++)
            delete[] mat[i];
        delete[] mat;
    }
}

int main() {

    int **mat;
    int rows, cols;
    cin >> rows >> cols;

    // mat 할당
    mat = alloc2DArr(rows, cols);

    // mat[][] 랜덤 입력
    for(int i=0; i<rows; i++){
        for(int j=0; j<cols; j++){
            mat[i][j] = rand()%100;
        }
    }

    // mat 출력
    for(int i=0; i<rows; i++){
        for(int j=0; j<cols; j++){
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }

    // mat 해제
    free2DArr(mat, rows, cols);

    return 0;
}

참고로 2중 loop를 돌리는 것보다 memset (#include <string.h>)을 사용하는 것이 유용하다.

또한 이보다 vector를 사용하는 것이 더욱 편리하고 빠르다.

(위의 내용은 나중에 따로 포스팅...)

[C++] 포인터 한방에 이해하기 (Call by Value vs Call by Reference)

suyeon96 — Fri, 1 Jan 2021 02:10:06 +0900

포인터 (Pointer)

포인터 변수

포인터란 "어떤 것을 가리키는 것"을 의미한다.

C나 C++ 등의 프로그래밍 언어에서 포인터는 "주소를 가리키는 것"을 뜻하며, 이러한 것을 저장하는 변수를 포인터 변수라고 한다.

프로그래밍에서 포인터가 악명이 높기로 유명하지만, 의외로 단순하니 겁먹을 필요가 없다.

아래 코드를 보자.

int a = 10;
int* p = &a;

a라는 int형 변수를 선언하고 10으로 초기화하였다.

p라는 int형 포인터 변수를 선언하고 a의 주소값으로 초기화하였다.

여기서 한가지 짚고 넘어가야 할 것이 있다.

& (주소 연산자)

주소 연산자 &를 사용하면 변수에 할당된 메모리 주소를 확인할 수 있다.
참고로 비트 연산자 AND(&)와 모양은 같지만, 주소 연산자는 단항 연산자이고 비트 AND연산자는 이항 연산자이다.
* (역참조 연산자)

역참조 연산자 *를 사용하면 특정 메모리의 주소값에 접근할 수 있다.

즉 위의 코드는 아래 그림과 같은 구조를 가진다.

int a = 10; // int형 변수 선언
- int형이므로 a라는 이름의 4byte 메모리 공간을 할당 (메모리 주소 : 0x0014)
- 해당 메모리에 숫자 10 입력
int* p = &a; // int형 포인터 변수 선언
- int형 이므로 p라는 이름의 4byte 메모리 공간 할당 (메모리 주소 : 0x0004)
- 해당 메모리에 변수 a의 주소값(0x0014) 입력

한번 확인해보자.

int a = 10;
int* p = &a;

cout << "a : " << a << endl;
cout << "&a : " << &a << endl;
cout << "p : " << p << endl;
cout << "*p : " << *p << endl;
cout << "&p : " << &p << endl;

이러한 구조로 메모리에 할당이 된 것을 확인할 수 있다.

여기서 중요한 점은 역참조 연산자 *를 통해 포인터 변수가 가리키는 주소 a의 값 10을 알 수 있다는 것이다.

포인터 변수가 자료형을 가져야 하는 이유도 여기에 있다.

자료형이 없다면 포인터는 역참조 시 해당 메모리의 값을 해석할 수 없다.

위의 경우 int형이라고 명시가 되어 있었기 때문에 0073FA74 주소의 메모리 값을 int형으로 읽어올 수 있는 것이다.

이중 포인터, 3중 포인터

위의 개념을 잘 이해했다면 2중 포인터, 3중 포인터도 거뜬하다.

긴 말 필요 없이 아래 코드를 보자.

int a = 10;
int* p1 = &a;
int** p2 = &p1;
int*** p3 = &p2;

cout << "a : " << a << endl;
cout << "&a : " << &a << '\n' << endl;

cout << "p1 : " << p1 << endl;
cout << "*p1 : " << *p1 << endl;
cout << "&p1 : " << &p1 << '\n' <<  endl;

cout << "p2 : " << p2 << endl;
cout << "*p2 : " << *p2 << endl;
cout << "**p2 : " << **p2 << endl;
cout << "&p2 : " << &p2 << '\n' <<  endl;

cout << "p3 : " << p3 << endl;
cout << "*p3 : " << *p3 << endl;
cout << "**p3 : " << **p3 << endl;
cout << "***p3 : " << ***p3 << endl;
cout << "&p3 : " << &p3 << endl;

Call by Value vs Call by Reference

자 이제 우리는 포인터가 어떤 역할을 하는지 알고 있다.

그렇다면 함수의 매개변수에 변수 값을 전달하는 것과 주소 값을 전달할 때 어떤 차이가 있는지 보자.

#include <iostream>
using namespace std;

void callByVal(int a){
    a = 20;
}

void callByRef(int* b){
    *b = 20;
}

int main()
{
    int a = 10;
    int b = 10;

    callByVal(a);
    callByRef(&b);

    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    return 0;
}

int형 a와 b변수를 선언하고 10으로 초기화하였다.

이후 callByVal 함수에서는 a의 값을 받아서 20으로 수정하였고, callByRef 함수에서는 b의 주소값을 받아 20으로 수정하였다.

그런 다음 다시 main에서 a와 b를 출력해보니 b는 20으로 바뀌었지만, a는 그대로 10으로 출력된다.

이제 이해가 되는가?

callByVal 함수에서는 a의 값 10을 받아서 메모리에 새로운 공간을 할당하고 받은 값 10을 입력하였다. 그런 다음 새로운 메모리 공간의 10을 20으로 변환하였다. 따라서 main에 있는 기존 a의 값은 전혀 변함이 없었던 것이다.

반면 callByRef 함수에서는 b의 주소값을 받아서 메모리에 새로운 공간을 할당하고 b의 주소값을 입력하였다. 그런 다음 새로운 메모리 공간에 있는 주소값이 가리키는 b변수를 찾아 해당 값을 20으로 변환하였다. 따라서 main에 있는 기존 b값이 20으로 변경된 것이다.

배열과 포인터

배열은 사실 포인터와 같은 역할을 한다.

포인터는 주소를 담는 변수라고 계속해서 이야기해왔다.

배열 변수 또한 포인터와 동일하게 배열의 첫 번째 index의 주소를 가지고 있다.

아래 코드를 보자.

int arr[5] = {1, 2, 3, 4, 5};

cout << "arr[0] : " << arr[0] << endl;
cout << "arr : " << arr << endl;

arr 변수가 arr[0]의 주소값을 가지고 있음을 알 수 있다.

그렇다면 이를 응용하여 배열에 접근할 때 아래와 같이 코드를 작성할 수도 있다.

int arr[5] = {1, 2, 3, 4, 5};

cout << "arr : " << arr << ",  ";
cout << "arr[0] : " << arr[0] << ",  ";
cout << "*arr : " << *arr << endl;

cout << "arr+1 : " << arr+1 << ",  ";
cout << "arr[1] : " << arr[1] << ",  ";
cout << "*(arr+1) : " << *(arr+1) << endl;

cout << "arr+2 : " << arr+2 << ",  ";
cout << "arr[2] : " << arr[2] << ",  ";
cout << "*(arr+2) : " << *(arr+2) << endl;

cout << "arr+3 : " << arr+3 << ",  ";
cout << "arr[3] : " << arr[3] << ",  ";
cout << "*(arr+3) : " << *(arr+3) << endl;

cout << "arr+4 : " << arr+4 << ",  ";
cout << "arr[4] : " << arr[4] << ",  ";
cout << "*(arr+4) : " << *(arr+4) << endl;

객체 멤버의 접근

C++에서 객체의 멤버에 접근하는 방법에 대해 알아보자.

객체에서 멤버에 접근할 때는 . 연산자를 사용하며 포인터 객체의 멤버에 접근할 때는 → 연산자를 사용한다.

#include <iostream>
using namespace std;

class Test{
public:
    int a;
    int b;
};

int main()
{
    Test T;
    Test* pT = &T;

    T.a = 1;
    pT->b = 2;

    cout << "a : " << pT->a << endl;
    cout << "b : " << T.b << endl;

    return 0;
}

Test Class 객체의 a 멤버변수에 접근하는 방법으로 T.a, (&T)→a, pT→a, (*pT).a 가 모두 가능하다.

[자료구조] 덱 (Deque)

suyeon96 — Thu, 31 Dec 2020 23:50:07 +0900

덱 (Deque)

덱?

덱(Deque)이란 Double-Ended Queue의 줄임말이다.

즉, 앞쪽 front와 뒤쪽 rear에서 모두 삽입과 삭제가 가능한 큐를 의미한다.

덱 ADT

객체

전단과 후단 양쪽에서의 삽입과 삭제를 허용하는 동일한 자료형의 요소들의 모음

연산

addFront(x) : 요소 x를 덱의 맨 앞에 추가
addRear(x) : 요소 x를 덱의 맨 뒤에 추가
deleteFront() : 큐의 맨 앞의 요소를 삭제하고 반환
deleteRear() : 큐의 맨 뒤의 요소를 삭제하고 반환
getFront() : 큐의 맨 앞의 요소를 삭제하지 않고 반환
getRear() : 큐의 맨 뒤의 요소를 삭제하지 않고 반환
isEmpty() : 큐가 비어있으면 true 아니면 false 반환
isFull() : 큐가 가득 차 있으면 true 아니면 false 반환
size() : 큐 내의 모든 요소 개수를 반환
display() : 큐 내의 모든 요소 출력

Array로 Circular Deque 구현 (C++)

/*
 * array를 이용하여 Circular Deque 구현
 */
#include <iostream>
using namespace std;

#define MAX_DEQUE_SIZE 10

class Deque {
private:
    int front;  // 첫번째 요소 앞의 index
    int rear;   // 마지막 요소 index
    int data[MAX_DEQUE_SIZE];

public:
    Deque(){
        front = 0;
        rear = 0;
    }
    ~Deque(){}

    void addFront(int n){
        if(isFull()){
            cout << "Deque Full Error" << endl;
            exit(1);
        }
        data[front] = n;
        front = (front-1+MAX_DEQUE_SIZE)%MAX_DEQUE_SIZE;    // front가 0 이하로 떨어지는 경우 max index로 순회
    }

    void addRear(int n){    // push
        if(isFull()){
            cout << "Deque Full Error" << endl;
            exit(1);
        }
        rear = (rear+1)%MAX_DEQUE_SIZE;   // rear가 max를 넘어가는 경우 다시 0번째 index로 순회
        data[rear] = n;
    }

    int deleteFront(){  // pop
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(1);
        }
        front = (front+1)%MAX_DEQUE_SIZE;   // front가 max를 넘어가는 경우 다시 0번째 index로 순회
        return data[front];
    }

    int deleteRear(){
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(1);
        }
        int tmp = data[rear];
        rear = (rear-1+MAX_DEQUE_SIZE)%MAX_DEQUE_SIZE;   // rear가 0 이하로 떨어지는 경우 max index로 순회
        return tmp;
    }

    int getFront(){
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(1);
        }
        return data[(front+1)%MAX_DEQUE_SIZE];
    }

    int getRear(){
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(1);
        }
        return data[rear];
    }

    int size(){
        return front<=rear ? rear-front : (rear+MAX_DEQUE_SIZE)-front;
    }

    void display(){
        for(int i=front+1; i<=front+size(); i++){
            cout << "[" << data[i%MAX_DEQUE_SIZE] << "]";
        }
        cout << endl;
    }

    // circular array의 front와 rear 정보를 보기위한 메소드
    void displayDetail(){
        cout << "DEQUE :";
        for(int i=front+1; i<=front+size(); i++){
            cout << "[" << data[i%MAX_DEQUE_SIZE] << "]";
        }
        cout << endl;
        cout << "index :";
        for(int i=front+1; i<=front+size(); i++){
            cout << " " << i%MAX_DEQUE_SIZE << " ";
        }
        cout << endl;
        cout << "front : " << front << ", rear : " << rear << endl;
        cout << endl;
    }

    bool isEmpty(){
        return front == rear;
    }
    bool isFull() {
        return front == (rear+1)%MAX_DEQUE_SIZE;
    }
};

int main() {
    Deque deque;

    cout << "===== addRear x3 =====" << endl;
    deque.addRear(1);
    deque.addRear(2);
    deque.addRear(3);
    cout << " size : " << deque.size() << endl;
    deque.displayDetail();

    cout << "===== addFront x2 ======" << endl;
    deque.addFront(5);
    deque.addFront(6);
    cout << " size : " << deque.size() << endl;
    deque.displayDetail();

    cout << "===== deleteRear x1 ======" << endl;
    deque.deleteRear();
    cout << " size : " << deque.size() << endl;
    deque.displayDetail();

    cout << "===== deleteFront x3 ======" << endl;
    deque.deleteFront();
    deque.deleteFront();
    deque.deleteFront();
    cout << " size : " << deque.size() << endl;
    deque.displayDetail();
}

LinkedList로 Circular Deque 구현 (C++)

/*
 * 이중 Linked List를 이용하여 Deque 구현
 */
#include <iostream>
using namespace std;

// Doubly Linked List
struct Node {
    int data;
    Node* prev; // 이전 Node를 가리키는 pointer
    Node* next; // 다음 Node를 가리키는 pointer

public:
    Node(){
        prev = nullptr;
        next = nullptr;
        data = 0;
    }
    Node(int n, Node* prevNode = nullptr, Node* nextNode = nullptr){
        data = n;
        prev = prevNode;
        next = nextNode;
    }
    ~Node(){}

    void setPrev(Node* prevNode){
        prev = prevNode;
    }
    void setNext(Node* nextNode){
        next = nextNode;
    }
};

// Deque Class
class Deque {
private:
    Node* front;    // Deack의 front를 가리키는 Node pointer
    Node* rear;     // Deack의 rear를 가리키는 Node pointer
    int dataSize;   // Stack에 저장된 데이터 size

public:
    Deque(){
        front = nullptr;
        rear = nullptr;
        dataSize = 0;
    }
    ~Deque(){
        while(!isEmpty()){
            deleteFront(); //deleteRear();
        }
        delete front;
        delete rear;
    }

    //새로운 node를 생성 (prev : null, next : 기존의 front node)
    //front를 새로운 node로 변경
    //최초 생성이라면 rear = node 해줌
    //이후 front가 추가될 때마다 기존 node의 prev에 새로 추가되는 node 대입
    void addFront(int n){
        Node* node = new Node(n, nullptr, front);
        if(rear == nullptr){
            rear = node;
        }else{
            front->setPrev(node);
        }
        front = node;
        dataSize++;
    }

    //addFront()와 같은 맥락.
    //새로운 node를 생성 (prev : 기존의 rear node, next : null)
    //rear를 새로운 node로 변경
    //최초 생성이라면 front = node 해줌
    //이후 rear가 추가될 때마다 기존 node의 next에 새로 추가되는 node 대입
    void addRear(int n){
        Node* node = new Node(n, rear, nullptr);
        if(front == nullptr){
            front = node;
        }else{
            rear->setNext(node);
        }
        rear = node;
        dataSize++;
    }

    //deque가 비어있는 경우 error occurred
    //그렇지 않다면, 우선 front node의 데이터를 임시 변수 'data'에 담아놓음
    //front를 next node로 변경한 다음, 삭제된 node(front였던)는 delete 처리 (메모리자원을위해)
    //아까 담아놓은 'data'를 반환
    //또한 현재 front노드의 prev를 null로 지정
    int deleteFront(){
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(EXIT_FAILURE);
        }else{
            int data = front->data;
            Node* node = front;
            front = front->next;
            front->setPrev(nullptr);
            delete node;
            dataSize--;
            return data;
        }
    }

    //deleteFront()와 같은 맥락.
    //deque가 비어있는 경우 error occurred
    //그렇지 않다면, 우선 rear node의 데이터를 임시 변수 'data'에 담아놓음
    //rear를 prev node로 변경한 다음, 삭제된 node(rear였던)는 delete 처리 (메모리자원을위해)
    //아까 담아놓은 'data'를 반환
    //또한 현재 rear노드의 next를 null로 지정
    int deleteRear(){
        if(isEmpty()){
            cout << "Deque Empty Error" << endl;
            exit(EXIT_FAILURE);
        }else{
            int data = rear->data;
            Node* node = rear;
            rear = rear->prev;
            rear->setNext(nullptr);
            delete node;
            dataSize--;
            return data;
        }
    }

    // deque의 모든 data 출력
    void display(){
        if(isEmpty()){
            cout << "Deque is Empty" << endl;
        }else{
            Node* node = front;
            while(node){
                cout << "[" << node->data << "]";
                node = node->next;
            }
            cout << endl;
        }
    }

    // deque size 반환
    int size(){
        return dataSize;
    }

    bool isEmpty(){
        return dataSize == 0;
    }
};

int main() {
    Deque deque;

    cout << "===== addRear x3 =====" << endl;
    deque.addRear(1);
    deque.addRear(2);
    deque.addRear(3);
    cout << " size : " << deque.size() << endl;
    deque.display();

    cout << "===== addFront x2 ======" << endl;
    deque.addFront(5);
    deque.addFront(6);
    cout << " size : " << deque.size() << endl;
    deque.display();

    cout << "===== deleteRear x1 ======" << endl;
    cout << deque.deleteRear() << endl;
    cout << " size : " << deque.size() << endl;
    deque.display();

    cout << "===== deleteFront x3 ======" << endl;
    cout << deque.deleteFront() << endl;
    cout << deque.deleteFront() << endl;
    cout << deque.deleteFront() << endl;
    cout << " size : " << deque.size() << endl;
    deque.display();
}